home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / tutsamp / pertext / connect.cpp next >
C/C++ Source or Header  |  1997-08-05  |  44KB  |  1,428 lines
  1. /*+==========================================================================
  2.   File:      CONNECT.CPP
  3.  
  4.   Summary:   Implementation file for the connection points (and their
  5.              connections) offered by the connectable objects in the
  6.              PERTEXT server sample. COM objects are implemented for
  7.              Connection Point Enumerators, Connection Points, and
  8.              Connection Enumerators.
  9.  
  10.              For a comprehensive tutorial code tour of this module's
  11.              contents and offerings see the tutorial PERTEXT.HTM
  12.              file. For more specific technical details on the internal
  13.              workings see the comments dispersed throughout the module's
  14.              source code.
  15.  
  16.   Classes:   COEnumConnectionPoints, COConnectionPoint, and
  17.              COEnumConnections.
  18.  
  19.   Functions: none.
  20.  
  21.   Origin:    5-12-97: atrent - Editor inheritance from STOSERVE
  22.              Tutorial Code Sample. Very little change was required.
  23.  
  24. ----------------------------------------------------------------------------
  25.   This file is part of the Microsoft COM Tutorial Code Samples.
  26.  
  27.   Copyright (C) Microsoft Corporation, 1997.  All rights reserved.
  28.  
  29.   This source code is intended only as a supplement to Microsoft
  30.   Development Tools and/or on-line documentation.  See these other
  31.   materials for detailed information regarding Microsoft code samples.
  32.  
  33.   THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  34.   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  35.   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  36.   PARTICULAR PURPOSE.
  37. ==========================================================================+*/
  38.  
  39.  
  40. /*---------------------------------------------------------------------------
  41.   We include WINDOWS.H for all Win32 applications.
  42.   We include OLE2.H because we will be calling the COM/OLE Libraries.
  43.   We include OLECTL.H because it has definitions for connectable objects.
  44.   We include APPUTIL.H because we will be building this application using
  45.     the convenient Virtual Window and Dialog classes and other
  46.     utility functions in the APPUTIL Library (ie, APPUTIL.LIB).
  47.   We include IPAGES.H and PAGEGUID.H for the common page-related
  48.     Interface class, GUID, and CLSID specifications.
  49.   We include SERVER.H because it has internal class declarations
  50.     for the server housing for the components in this DLL.
  51.   We include CONNECT.H for object class declarations for the various
  52.     connection point and connection COM objects used in PERTEXT.
  53.   We include TEXTPAGE.H because it has the class COEnumConnectionPoints
  54.     declarations as well as the COTextPage class declaration.
  55. ---------------------------------------------------------------------------*/
  56. #include <windows.h>
  57. #include <ole2.h>
  58. #include <olectl.h>
  59. #include <apputil.h>
  60. #include <ipages.h>
  61. #include <pageguid.h>
  62. #include "server.h"
  63. #include "connect.h"
  64. #include "textpage.h"
  65.  
  66.  
  67. /*---------------------------------------------------------------------------
  68.   COEnumConnectionPoints's implementation of its main COM object class
  69.   including Constructor, Destructor, QueryInterface, AddRef, Release,
  70.   Next, Skip, Reset, and Clone.
  71. ---------------------------------------------------------------------------*/
  72.  
  73. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  74.   Method:   COEnumConnectionPoints::COEnumConnectionPoints
  75.  
  76.   Summary:  COEnumConnectionPoints Constructor.
  77.  
  78.   Args:     IUnknown* pHostObj
  79.               Pointer to the host object whose connection points are
  80.               being enumerated.
  81.  
  82.   Modifies: m_cRefs, m_pHostObj, m_iEnumIndex, m_cConnPts, and m_paConnPts.
  83.  
  84.   Returns:  void
  85. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  86. COEnumConnectionPoints::COEnumConnectionPoints(
  87.   IUnknown* pHostObj)
  88. {
  89.   // Zero the COM object's reference count.
  90.   m_cRefs = 0;
  91.  
  92.   // Assign the Host Object pointer.
  93.   m_pHostObj = pHostObj;
  94.  
  95.   // Initialize the Connection Point enumerator variables.
  96.   m_iEnumIndex = 0;
  97.   m_cConnPts = 0;
  98.   m_paConnPts = NULL;
  99.  
  100.   return;
  101. }
  102.  
  103.  
  104. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  105.   Method:   COEnumConnectionPoints::~COEnumConnectionPoints
  106.  
  107.   Summary:  COEnumConnectionPoints Destructor.
  108.  
  109.   Args:     void
  110.  
  111.   Modifies: m_paConnPts.
  112.  
  113.   Returns:  void
  114. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  115. COEnumConnectionPoints::~COEnumConnectionPoints(void)
  116. {
  117.   if (NULL != m_paConnPts)
  118.   {
  119.     UINT i;
  120.  
  121.     // Release all the connection point interface pointers.
  122.     for (i=0; i<m_cConnPts; i++)
  123.       if (NULL != m_paConnPts[i])
  124.         m_paConnPts[i]->Release();
  125.  
  126.     // Delete the array of interface pointers.
  127.     delete [] m_paConnPts;
  128.   }
  129.  
  130.   return;
  131. }
  132.  
  133.  
  134. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  135.   Method:   COEnumConnectionPoints::Init
  136.  
  137.   Summary:  COEnumConnectionPoints Initialization method.  Create any
  138.             necessary arrays, structures, and objects.
  139.  
  140.   Args:     ULONG cConnPts,
  141.               Number of Connections Points.
  142.             IConnectionPoint** paConnPts,
  143.               Pointer to array of connection point interface pointers.
  144.             ULONG iEnumIndex
  145.               The initial Enumerator index value.
  146.  
  147.   Modifies: m_cConnPts, m_paConnPts, m_iEnumIndex.
  148.  
  149.   Returns:  HRESULT
  150.               Standard result code. NOERROR for success.
  151. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  152. HRESULT COEnumConnectionPoints::Init(
  153.           ULONG cConnPts,
  154.           IConnectionPoint** paConnPts,
  155.           ULONG iEnumIndex)
  156. {
  157.   HRESULT hr = NOERROR;
  158.   UINT i;
  159.  
  160.   // Remember the number of Connection points.
  161.   m_cConnPts = cConnPts;
  162.  
  163.   // Remember the initial enumerator index.
  164.   m_iEnumIndex = iEnumIndex;
  165.  
  166.   // Create a copy of the array of connection points and keep it inside
  167.   // this enumerator COM object.
  168.   m_paConnPts = new IConnectionPoint* [(UINT) cConnPts];
  169.  
  170.   // Fill the array copy with the IConnectionPoint interface pointers from
  171.   // the array passed. AddRef for each new Interface pointer copy made.
  172.   if (NULL != m_paConnPts)
  173.   {
  174.     for (i=0; i<cConnPts; i++)
  175.     {
  176.       m_paConnPts[i] = paConnPts[i];
  177.       m_paConnPts[i]->AddRef();
  178.     }
  179.   }
  180.   else
  181.     hr = E_OUTOFMEMORY;
  182.  
  183.   return (hr);
  184. }
  185.  
  186.  
  187. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  188.   Method:   COEnumConnectionPoints::QueryInterface
  189.  
  190.   Summary:  QueryInterface of the COEnumConnectionPoints non-delegating
  191.             IUnknown implementation.
  192.  
  193.   Args:     REFIID riid,
  194.               [in] GUID of the Interface being requested.
  195.             PPVOID ppv)
  196.               [out] Address of the caller's pointer variable that will
  197.               receive the requested interface pointer.
  198.  
  199.   Returns:  HRESULT
  200. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  201. STDMETHODIMP COEnumConnectionPoints::QueryInterface(
  202.                REFIID riid,
  203.                PPVOID ppv)
  204. {
  205.   HRESULT hr = E_NOINTERFACE;
  206.  
  207.   *ppv = NULL;
  208.  
  209.   // The IEnumConnectionPoints interface is implemented directly in
  210.   // this COM object rather than being a nested interface implementation.
  211.   if (IID_IUnknown == riid || IID_IEnumConnectionPoints == riid)
  212.     *ppv = (LPVOID)this;
  213.  
  214.   if (NULL != *ppv)
  215.   {
  216.     // We've handed out a pointer to the interface so obey the COM rules
  217.     // and AddRef the reference count.
  218.     ((LPUNKNOWN)*ppv)->AddRef();
  219.     hr = NOERROR;
  220.   }
  221.  
  222.   return (hr);
  223. }
  224.  
  225.  
  226. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  227.   Method:   COEnumConnectionPoints::AddRef
  228.  
  229.   Summary:  AddRef of the COEnumConnectionPoints non-delegating IUnknown
  230.             implementation.
  231.  
  232.   Args:     void
  233.  
  234.   Modifies: m_cRefs.
  235.  
  236.   Returns:  ULONG
  237.               New value of m_cRefs (COM object's reference count).
  238. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  239. STDMETHODIMP_(ULONG) COEnumConnectionPoints::AddRef(void)
  240. {
  241.   ULONG cRefs;
  242.  
  243.   cRefs = ++m_cRefs;
  244.  
  245.   // Also AddRef the host object to ensure it stays around as long as
  246.   // this enumerator.
  247.   m_pHostObj->AddRef();
  248.  
  249.   return cRefs;
  250. }
  251.  
  252.  
  253. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  254.   Method:   COEnumConnectionPoints::Release
  255.  
  256.   Summary:  Release of the COEnumConnectionPoints non-delegating IUnknown
  257.             implementation.
  258.  
  259.   Args:     void
  260.  
  261.   Modifies: m_cRefs.
  262.  
  263.   Returns:  ULONG
  264.               New value of m_cRefs (COM object's reference count).
  265. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  266. STDMETHODIMP_(ULONG) COEnumConnectionPoints::Release(void)
  267. {
  268.   ULONG cRefs;
  269.  
  270.   // Pass this release along to the Host object being enumerated.
  271.   m_pHostObj->Release();
  272.  
  273.   cRefs = --m_cRefs;
  274.  
  275.   if (0 == cRefs)
  276.   {
  277.     // We artificially bump the main ref count to prevent reentrancy via
  278.     // the main object destructor.
  279.     m_cRefs++;
  280.     delete this;
  281.   }
  282.  
  283.   return cRefs;
  284. }
  285.  
  286.  
  287. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  288.   Method:   COEnumConnectionPoints::Next
  289.  
  290.   Summary:  The Next member method of this IEnumConnectionPoints interface
  291.             implementation. Called by outside clients of a
  292.             COEnumConnectionPoints object to request that a number of next
  293.             connection point interface pointers be deposited into an array
  294.             supplied by the caller.
  295.  
  296.   Args:     ULONG cReq
  297.               Number of connection points requested for return (starting at
  298.               the current Enumerator index).
  299.             IConnectionPoint** paConnPts,
  300.               Pointer to a caller's output array that will receive the
  301.               enumerated IConnectionPoint interface pointers.
  302.             ULONG* cEnumerated)
  303.               Pointer to a ULONG variable that will contain the number of
  304.               connection points actually enumerated by this call.
  305.  
  306.   Returns:  HRESULT
  307.               Standard result code. NOERROR for success.
  308. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  309. STDMETHODIMP COEnumConnectionPoints::Next(
  310.                ULONG cReq,
  311.                IConnectionPoint** paConnPts,
  312.                ULONG* pcEnumerated)
  313. {
  314.   HRESULT hr = NOERROR;
  315.   ULONG cRet = 0;
  316.  
  317.   // Make sure the argument values passed are valid.
  318.   if (NULL != m_paConnPts)
  319.   {
  320.     if (NULL != paConnPts)
  321.     {
  322.       if (NULL != *paConnPts && m_iEnumIndex < m_cConnPts)
  323.       {
  324.         if (NULL != pcEnumerated)
  325.           *pcEnumerated = 0L;
  326.         else
  327.           if (1L != cReq)
  328.             hr = E_POINTER;
  329.       }
  330.       else
  331.         hr = S_FALSE;
  332.     }
  333.     else
  334.       hr = E_POINTER;
  335.   }
  336.   else
  337.     hr = S_FALSE;
  338.  
  339.   if (SUCCEEDED(hr))
  340.   {
  341.     // Starting at the current Enumerator index, loop to assign the
  342.     // requested number of output connection point interface pointers.
  343.     for (; m_iEnumIndex < m_cConnPts && cReq > 0;
  344.            paConnPts++, cRet++, cReq--)
  345.     {
  346.       // Assign from the inside Enumerator array to the specified receiving
  347.       // array.
  348.       *paConnPts = m_paConnPts[m_iEnumIndex++];
  349.       // After assigning a copy of an IConnectionPoint pointer, AddRef it.
  350.       if (NULL != *paConnPts)
  351.         (*paConnPts)->AddRef();
  352.     }
  353.  
  354.     // Assign the output number of connection points enumerated.
  355.     if (NULL != pcEnumerated)
  356.       *pcEnumerated = cRet;
  357.   }
  358.  
  359.   return hr;
  360. }
  361.  
  362.  
  363. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  364.   Method:   COEnumConnectionPoints::Skip
  365.  
  366.   Summary:  The Skip member method of this IEnumConnectionPoints interface
  367.             implementation. Starting at the current Enumerator index, skip
  368.             the specified number of connection point items.
  369.  
  370.   Args:     ULONG cSkip
  371.               Number of Connection Point items to skip.
  372.  
  373.   Returns:  HRESULT
  374.               Standard result code. NOERROR for success.
  375. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  376. STDMETHODIMP COEnumConnectionPoints::Skip(
  377.                ULONG cSkip)
  378. {
  379.   HRESULT hr = NOERROR;
  380.  
  381.   // If there really is a connection point array and the requested
  382.   // amount of skip does not exceed the number of connection points,
  383.   // then bump the index by the requested skip amount.
  384.   if (NULL != m_paConnPts && (m_iEnumIndex + cSkip) < m_cConnPts)
  385.     m_iEnumIndex += cSkip;
  386.   else
  387.     hr = S_FALSE;
  388.  
  389.   return hr;
  390. }
  391.  
  392.  
  393. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  394.   Method:   COEnumConnectionPoints::Reset
  395.  
  396.   Summary:  The Reset member method of the IEnumConnectionPoints interface
  397.             implementation. Resets the Enumeration index to the first
  398.             connection point item in the array.
  399.  
  400.   Args:     void.
  401.  
  402.   Returns:  HRESULT
  403.               Standard result code. NOERROR for success.
  404. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  405. STDMETHODIMP COEnumConnectionPoints::Reset(
  406.                void)
  407. {
  408.   // Zero the main Enumerator index.
  409.   m_iEnumIndex = 0;
  410.  
  411.   return NOERROR;
  412. }
  413.  
  414.  
  415. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  416.   Method:   COEnumConnectionPoints::Clone
  417.  
  418.   Summary:  The Clone member method of this IEnumConnectionPoints
  419.             interface implementation. Creates a new clone of this entire
  420.             Connection Point enumerator COM object.
  421.  
  422.   Args:     IEnumConnectionPoints** ppIEnum
  423.               Address of the caller's output pointer variable that will
  424.               receive the IEnumConnectionPoints interface pointer of the
  425.               new enumerator clone.
  426.  
  427.   Returns:  HRESULT
  428.               Standard result code. NOERROR for success.
  429. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  430. STDMETHODIMP COEnumConnectionPoints::Clone(
  431.                IEnumConnectionPoints** ppIEnum)
  432. {
  433.   HRESULT hr;
  434.   COEnumConnectionPoints* pCOEnum;
  435.  
  436.   // NULL the output variable first.
  437.   *ppIEnum = NULL;
  438.  
  439.   // Create the Clone Enumerator COM object.
  440.   pCOEnum = new COEnumConnectionPoints(m_pHostObj);
  441.   if (NULL != pCOEnum)
  442.   {
  443.     // Initialize it with same values as in this existing enumerator.
  444.     hr = pCOEnum->Init(m_cConnPts, m_paConnPts, m_iEnumIndex);
  445.     if (SUCCEEDED(hr))
  446.     {
  447.       // QueryInterface to return the requested interface pointer.
  448.       // An AddRef will be conveniently done by the QI.
  449.       if (SUCCEEDED(hr))
  450.         hr = pCOEnum->QueryInterface(
  451.                         IID_IEnumConnectionPoints,
  452.                         (PPVOID)ppIEnum);
  453.     }
  454.   }
  455.   else
  456.     hr = E_OUTOFMEMORY;
  457.  
  458.   return hr;
  459. }
  460.  
  461.  
  462. /*---------------------------------------------------------------------------
  463.   COConnectionPoint's implementation of its main COM object class
  464.   including Constructor, Destructor, QueryInterface, AddRef, Release,
  465.   GetConnectionInterface, GetConnectionPointContainer, Advise, Unadvise,
  466.   and EnumConnections.
  467. ---------------------------------------------------------------------------*/
  468.  
  469. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  470.   Method:   COConnectionPoint::COConnectionPoint
  471.  
  472.   Summary:  COConnectionPoint Constructor.
  473.  
  474.   Args:     IUnknown* pHostObj
  475.               Pointer to IUnknown of the connectable object offering this
  476.               connection point.
  477.  
  478.   Returns:  void
  479. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  480. COConnectionPoint::COConnectionPoint(
  481.   IUnknown* pHostObj)
  482. {
  483.   // Zero the COM object's reference count.
  484.   m_cRefs = 0;
  485.  
  486.   // Remember an IUnknown pointer to the connectable object that offers
  487.   // this connection point. Since this connection point object's lifetime
  488.   // is geared to that of the connectable object there is no need to
  489.   // AddRef the following copied pointer to the connectable object.
  490.   m_pHostObj = pHostObj;
  491.  
  492.   // Initialize the Connection Point variables.
  493.   m_dwNextCookie = COOKIE_START_VALUE;
  494.   m_uiMaxIndex = 0;
  495.   m_cConnections = 0;
  496.   m_paConnections = NULL;
  497.  
  498.   return;
  499. }
  500.  
  501.  
  502. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  503.   Method:   COConnectionPoint::~COConnectionPoint
  504.  
  505.   Summary:  COConnectionPoint Destructor.
  506.  
  507.   Args:     void
  508.  
  509.   Modifies: m_paConnections.
  510.  
  511.   Returns:  void
  512. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  513. COConnectionPoint::~COConnectionPoint(void)
  514. {
  515.   UINT i;
  516.   IUnknown* pUnk;
  517.  
  518.   if (NULL != m_paConnections)
  519.   {
  520.     // Release all the connection sink interface pointers.
  521.     for (i=0; i<m_uiMaxIndex; i++)
  522.     {
  523.       pUnk = m_paConnections[i].pUnk;
  524.       if (NULL != pUnk)
  525.         pUnk->Release();
  526.     }
  527.  
  528.     // Delete the array of interface pointers.
  529.     delete [] m_paConnections;
  530.   }
  531.  
  532.   return;
  533. }
  534.  
  535.  
  536. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  537.   Method:   COConnectionPoint::Init
  538.  
  539.   Summary:  COConnectionPoint Initialization method.  Create any
  540.             necessary arrays, structures, and subordinate objects.
  541.  
  542.   Args:     REFIID riid
  543.               Reference to the IID of the Sink interface associated with
  544.               this connection point.
  545.  
  546.   Returns:  HRESULT
  547.               Standard result code. NOERROR for success.
  548. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  549. HRESULT COConnectionPoint::Init(
  550.           REFIID riid)
  551. {
  552.   HRESULT hr = NOERROR;
  553.   CONNECTDATA* paConns;
  554.  
  555.   // Keep a copy of the reference to the IID of the sink interface
  556.   // associated with this connection point. Needed for later
  557.   // use by the GetConnectionInterface method.
  558.   m_iidSink = riid;
  559.  
  560.   // Build the initial dynamic array for connections.
  561.   paConns = new CONNECTDATA[ALLOC_CONNECTIONS];
  562.   if (NULL != paConns)
  563.   {
  564.     // Zero the array.
  565.     memset(paConns, 0, ALLOC_CONNECTIONS * sizeof(CONNECTDATA));
  566.  
  567.     // Rig this connection point object so that it will use the
  568.     // new internal array of connections.
  569.     m_uiMaxIndex = ALLOC_CONNECTIONS;
  570.     m_paConnections = paConns;
  571.   }
  572.   else
  573.     hr = E_OUTOFMEMORY;
  574.  
  575.   return (hr);
  576. }
  577.  
  578.  
  579. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  580.   Method:   COConnectionPoint::QueryInterface
  581.  
  582.   Summary:  QueryInterface of the COConnectionPoint non-delegating
  583.             IUnknown implementation.
  584.  
  585.   Args:     REFIID riid,
  586.               [in] GUID of the Interface being requested.
  587.             PPVOID ppv)
  588.               [out] Address of the caller's pointer variable that will
  589.               receive the requested interface pointer.
  590.  
  591.   Returns:  HRESULT
  592. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  593. STDMETHODIMP COConnectionPoint::QueryInterface(
  594.                REFIID riid,
  595.                PPVOID ppv)
  596. {
  597.   HRESULT hr = E_NOINTERFACE;
  598.  
  599.   *ppv = NULL;
  600.  
  601.   // The IConnectionPoint interface is implemented directly in this
  602.   // COM object rather than being a nested interface implementation.
  603.   if (IID_IUnknown == riid || IID_IConnectionPoint == riid)
  604.     *ppv = (LPVOID)this;
  605.  
  606.   if (NULL != *ppv)
  607.   {
  608.     // We've handed out a pointer to the interface so obey the COM rules
  609.     // and AddRef the reference count.
  610.     ((LPUNKNOWN)*ppv)->AddRef();
  611.     hr = NOERROR;
  612.   }
  613.  
  614.   return (hr);
  615. }
  616.  
  617.  
  618. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  619.   Method:   COConnectionPoint::AddRef
  620.  
  621.   Summary:  AddRef of the COConnectionPoint non-delegating IUnknown
  622.             implementation.
  623.  
  624.   Args:     void
  625.  
  626.   Modifies: m_cRefs.
  627.  
  628.   Returns:  ULONG
  629.               New value of m_cRefs (COM object's reference count).
  630. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  631. STDMETHODIMP_(ULONG) COConnectionPoint::AddRef(void)
  632. {
  633.   ULONG cRefs;
  634.  
  635.   cRefs = ++m_cRefs;
  636.  
  637.   return cRefs;
  638. }
  639.  
  640.  
  641. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  642.   Method:   COConnectionPoint::Release
  643.  
  644.   Summary:  Release of the COConnectionPoint non-delegating IUnknown
  645.             implementation.
  646.  
  647.   Args:     void
  648.  
  649.   Modifies: m_cRefs.
  650.  
  651.   Returns:  ULONG
  652.               New value of m_cRefs (COM object's reference count).
  653. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  654. STDMETHODIMP_(ULONG) COConnectionPoint::Release(void)
  655. {
  656.   ULONG cRefs;
  657.  
  658.   cRefs = --m_cRefs;
  659.  
  660.   if (0 == cRefs)
  661.   {
  662.     // We artificially bump the main ref count to prevent reentrancy via
  663.     // the main object destructor. We relinquish thread ownership of this
  664.     // object prior to deleting it--a good practice.
  665.     m_cRefs++;
  666.     delete this;
  667.   }
  668.  
  669.   return cRefs;
  670. }
  671.  
  672.  
  673. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  674.   Method:   COConnectionPoint::GetSlot
  675.  
  676.   Summary:  An internal private utility member method to obtain a free
  677.             slot in the dynamic connections array. GetSlot will expand the
  678.             dynamic array for more entries if needed.
  679.  
  680.   Args:     UINT* puiFreeSlot
  681.               Address of an output variable to receive the free slot index.
  682.  
  683.   Modifies: m_uiMaxIndex, m_paConnections.
  684.  
  685.   Returns:  HRESULT
  686.               Standard result code. NOERROR for success.
  687. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  688. HRESULT COConnectionPoint::GetSlot(
  689.           UINT* puiFreeSlot)
  690. {
  691.   HRESULT hr = NOERROR;
  692.   BOOL bOpen = FALSE;
  693.   UINT i;
  694.   CONNECTDATA* paConns;
  695.  
  696.   // Zero the output variable.
  697.   *puiFreeSlot = 0;
  698.  
  699.   // Loop to find an empty slot.
  700.   for (i=0; i<m_uiMaxIndex; i++)
  701.   {
  702.     if (m_paConnections[i].dwCookie == 0)
  703.     {
  704.       // We found an open empty slot.
  705.       *puiFreeSlot = i;
  706.       bOpen = TRUE;
  707.       break;
  708.     }
  709.   }
  710.  
  711.   if (!bOpen)
  712.   {
  713.     // We didn't find an existing open slot in the array--it's full.
  714.     // Expand the array by ALLOC_CONNECTIONS entries and assign the
  715.     // appropriate output index.
  716.     paConns = new CONNECTDATA[m_uiMaxIndex + ALLOC_CONNECTIONS];
  717.     if (NULL != paConns)
  718.     {
  719.       // Copy the content of the old full array to the new larger array.
  720.       for (i=0; i<m_uiMaxIndex; i++)
  721.       {
  722.         paConns[i].pUnk = m_paConnections[i].pUnk;
  723.         paConns[i].dwCookie = m_paConnections[i].dwCookie;
  724.       }
  725.  
  726.       // Zero (ie mark as empty) the expanded portion of the new array.
  727.       for (i=m_uiMaxIndex; i<m_uiMaxIndex+ALLOC_CONNECTIONS; i++)
  728.       {
  729.         paConns[i].pUnk = NULL;
  730.         paConns[i].dwCookie = 0;
  731.       }
  732.  
  733.       // New larger array is ready--delete the old array.
  734.       delete [] m_paConnections;
  735.  
  736.       // Rig the connection point to use the new larger array.
  737.       m_paConnections = paConns;
  738.  
  739.       // Assign the output free slot as first entry in new expanded area.
  740.       *puiFreeSlot = m_uiMaxIndex;
  741.  
  742.       // Calculate the new max index.
  743.       m_uiMaxIndex += ALLOC_CONNECTIONS;
  744.     }
  745.     else
  746.       hr = E_OUTOFMEMORY;
  747.   }
  748.  
  749.   return hr;
  750. }
  751.  
  752.  
  753. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  754.   Method:   COConnectionPoint::FindSlot
  755.  
  756.   Summary:  An internal private utility member method to find an existing
  757.             slot (identified by the specified dwCookie value) in the
  758.             dynamic connections array.
  759.  
  760.   Args:     DWORD dwCookie,
  761.               The connection key (cookie) to find.
  762.             UINT* puiSlot)
  763.               Address of an output variable to receive the slot index.
  764.  
  765.   Returns:  HRESULT
  766.               Standard result code. NOERROR for success.
  767. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  768. HRESULT COConnectionPoint::FindSlot(
  769.           DWORD dwCookie,
  770.           UINT* puiSlot)
  771. {
  772.   HRESULT hr = CONNECT_E_NOCONNECTION;
  773.   UINT i;
  774.  
  775.   // Loop to find the Cookie.
  776.   for (i=0; i<m_uiMaxIndex; i++)
  777.   {
  778.     if (dwCookie == m_paConnections[i].dwCookie)
  779.     {
  780.       // If a cookie match is found, assign the output slot index.
  781.       *puiSlot = i;
  782.       hr = NOERROR;
  783.       break;
  784.     }
  785.   }
  786.  
  787.   return hr;
  788. }
  789.  
  790.  
  791. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  792.   Method:   COConnectionPoint::GetConnectionInterface
  793.  
  794.   Summary:  The GetConnectionInterface member method of this
  795.             IConnectionPoint interface implementation. Called to get the
  796.             IID of the Sink interface associated with this connection
  797.             point.
  798.  
  799.   Args:     IID* piidSink
  800.               Pointer to the IID of the associated sink interface.
  801.  
  802.   Returns:  HRESULT
  803.               Standard result code. NOERROR for success.
  804. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  805. STDMETHODIMP COConnectionPoint::GetConnectionInterface(
  806.                IID* piidSink)
  807. {
  808.   HRESULT hr = NOERROR;
  809.  
  810.   if (NULL != piidSink)
  811.     *piidSink = m_iidSink;
  812.   else
  813.     hr = E_POINTER;
  814.  
  815.   return hr;
  816. }
  817.  
  818.  
  819. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  820.   Method:   COConnectionPoint::GetConnectionPointContainer
  821.  
  822.   Summary:  The GetConnectionPointContainer member method of this
  823.             IConnectionPoint interface implementation. Called to get the
  824.             connection point container that contains this connection
  825.             point.
  826.  
  827.   Args:     IConnectionPointContainer** ppConnPtCon
  828.               Address of the pointer variable that will recieve the
  829.               IConnectionPointContainer interface pointer.
  830.  
  831.   Returns:  HRESULT
  832.               Standard result code. NOERROR for success.
  833. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  834. STDMETHODIMP COConnectionPoint::GetConnectionPointContainer(
  835.                IConnectionPointContainer** ppConnPtCon)
  836. {
  837.   HRESULT hr;
  838.  
  839.   // Use QueryInterface to get the interface pointer and to perform the
  840.   // needed AddRef on the returned pointer.
  841.   hr = m_pHostObj->QueryInterface(
  842.                      IID_IConnectionPointContainer,
  843.                      (PPVOID) ppConnPtCon);
  844.  
  845.   return hr;
  846. }
  847.  
  848.  
  849. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  850.   Method:   COConnectionPoint::Advise
  851.  
  852.   Summary:  The Advise member method of this IConnectionPoint interface
  853.             implementation. Called by clients to establish a connection of
  854.             their sink to this connection point.
  855.  
  856.   Args:     IUnknown* pUnkSink
  857.               IUnknown interface pointer of the Sink object in the client.
  858.             DWORD* pdwCookie
  859.               Pointer to a DWORD in the client that will receive a unique
  860.               key used by the client to refer to the connection established
  861.               by this Advise call.
  862.  
  863.   Returns:  HRESULT
  864.               Standard result code. NOERROR for success.
  865. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  866. STDMETHODIMP COConnectionPoint::Advise(
  867.                IUnknown* pUnkSink,
  868.                DWORD* pdwCookie)
  869. {
  870.   HRESULT hr = NOERROR;
  871.   UINT uiFreeSlot = 0;
  872.   IUnknown* pISink = NULL;
  873.  
  874.   // Zero the output connection key.
  875.   *pdwCookie = 0;
  876.  
  877.   // Get the specific associated client Sink interface that this
  878.   // connection point expects to use for notifications.
  879.   hr = pUnkSink->QueryInterface(m_iidSink, (PPVOID)&pISink);
  880.   if (SUCCEEDED(hr))
  881.   {
  882.     // Store the specific sink interface in this connection point's
  883.     // array of live connections. First find a free slot (expand the
  884.     // array if needed).
  885.     hr = GetSlot(&uiFreeSlot);
  886.     if (SUCCEEDED(hr))
  887.     {
  888.       // Assign the new slot with the connection entry.
  889.       m_paConnections[uiFreeSlot].pUnk = pISink;
  890.       m_paConnections[uiFreeSlot].dwCookie = m_dwNextCookie;
  891.  
  892.       // Assign the output Cookie value.
  893.       *pdwCookie = m_dwNextCookie;
  894.  
  895.       // Increment the Cookie counter.
  896.       m_dwNextCookie++;
  897.  
  898.       // Increment the number of live connections.
  899.       m_cConnections++;
  900.     }
  901.   }
  902.   else if (hr == E_NOINTERFACE)
  903.   {
  904.      // The sink does not support m_iidSink.
  905.      hr = CONNECT_E_CANNOTCONNECT;
  906.   }
  907.  
  908.   return hr;
  909. }
  910.  
  911.  
  912. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  913.   Method:   COConnectionPoint::Unadvise
  914.  
  915.   Summary:  The Unadvise member method of this IConnectionPoint interface
  916.             implementation. Called by clients to disconnect a connection
  917.             of their sink to this connection point. The connection is
  918.             identified by the dwCookie argument (obtained by a previous
  919.             Advise call).
  920.  
  921.   Args:     DWORD dwCookie
  922.               Connection key that was obtained by a previous Advise call.
  923.  
  924.   Returns:  HRESULT
  925.               Standard result code. NOERROR for success.
  926. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  927. STDMETHODIMP COConnectionPoint::Unadvise(
  928.                DWORD dwCookie)
  929. {
  930.   HRESULT hr = NOERROR;
  931.   UINT uiSlot;
  932.  
  933.   if (0 != dwCookie)
  934.   {
  935.     hr = FindSlot(dwCookie, &uiSlot);
  936.     if (SUCCEEDED(hr))
  937.     {
  938.       // Release the sink interface.
  939.       RELEASE_INTERFACE(m_paConnections[uiSlot].pUnk);
  940.  
  941.       // Mark the array entry as empty.
  942.       m_paConnections[uiSlot].dwCookie = 0;
  943.  
  944.       // Decrement the number of live connections.
  945.       m_cConnections--;
  946.     }
  947.   }
  948.   else
  949.     hr = E_INVALIDARG;
  950.  
  951.   return hr;
  952. }
  953.  
  954.  
  955. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  956.   Method:   COConnectionPoint::EnumConnections
  957.  
  958.   Summary:  The EnumConnections member method of this IConnectionPoint
  959.             interface implementation. Called to obtain an IEnumConnections
  960.             enumerator interface that can be used to enumerate the
  961.             connections of this connection point.
  962.  
  963.   Args:     IEnumConnections** ppIEnum
  964.               Address of the caller's output pointer variable that will
  965.               receive the enumerator IEnumConnections interface pointer.
  966.  
  967.   Returns:  HRESULT
  968.               Standard result code. NOERROR for success.
  969. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  970. STDMETHODIMP COConnectionPoint::EnumConnections(
  971.                IEnumConnections** ppIEnum)
  972. {
  973.   HRESULT hr = OLE_E_NOCONNECTION;
  974.   CONNECTDATA* paConns;
  975.   COEnumConnections* pCOEnum;
  976.   UINT i,j;
  977.  
  978.   // Zero the output enumerator interface pointer.
  979.   *ppIEnum = NULL;
  980.  
  981.   if (0 != m_cConnections)
  982.   {
  983.     // Create an array of CONNECTDATA structures.
  984.     paConns = new CONNECTDATA[(UINT)m_cConnections];
  985.     if (NULL != paConns)
  986.     {
  987.       for (i=0, j=0; i<m_uiMaxIndex && j<m_cConnections; i++)
  988.       {
  989.         // Copy non-empty entries only.
  990.         if (0 != m_paConnections[i].dwCookie)
  991.         {
  992.           // Assign the occupied entry.
  993.           paConns[j].pUnk = (IUnknown*)m_paConnections[i].pUnk;
  994.           paConns[j].dwCookie = m_paConnections[i].dwCookie;
  995.           j++;
  996.         }
  997.       }
  998.  
  999.       // Create a new COM object for enumerating connections. Pass
  1000.       // 'this' as a pHostObj pointer used later to ensure the host
  1001.       // connection point object stays alive as long as the enumerator
  1002.       // that enumerates connections to that connection point.
  1003.       pCOEnum = new COEnumConnections(this);
  1004.       if (NULL != pCOEnum)
  1005.       {
  1006.         // Use the previously constructed (paConns) array of connections
  1007.         // to init the new COEnumConnections COM object. The Init will
  1008.         // build yet another internal copy of this array. Set the
  1009.         // initial enumerator index to 0.
  1010.         hr = pCOEnum->Init(m_cConnections, paConns, 0);
  1011.  
  1012.         // QueryInterface to return the requested interface pointer.
  1013.         // An AddRef will be conveniently done by the QI.
  1014.         if (SUCCEEDED(hr))
  1015.           hr = pCOEnum->QueryInterface(
  1016.                           IID_IEnumConnections,
  1017.                           (PPVOID)ppIEnum);
  1018.       }
  1019.       else
  1020.         hr = E_OUTOFMEMORY;
  1021.  
  1022.       // We're done with the locally constructed array copy--delete it.
  1023.       delete [] paConns;
  1024.     }
  1025.     else
  1026.       hr = E_OUTOFMEMORY;
  1027.   }
  1028.  
  1029.   return hr;
  1030. }
  1031.  
  1032.  
  1033. /*---------------------------------------------------------------------------
  1034.   COEnumConnections's implementation of its main COM object class
  1035.   including Constructor, Destructor, QueryInterface, AddRef, Release,
  1036.   Next, Skip, Reset, and Clone.
  1037. ---------------------------------------------------------------------------*/
  1038.  
  1039. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1040.   Method:   COEnumConnections::COEnumConnections
  1041.  
  1042.   Summary:  COEnumConnections Constructor.
  1043.  
  1044.   Args:     IUnknown* pHostObj
  1045.               Pointer to IUnknown interface of the host Connection Point
  1046.               COM object whose connections are being enumerated.
  1047.  
  1048.   Modifies: m_cRefs, m_pHostObj, m_iEnumIndex, m_cConnections,
  1049.             and m_paConnections.
  1050.  
  1051.   Returns:  void
  1052. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1053. COEnumConnections::COEnumConnections(
  1054.   IUnknown* pHostObj)
  1055. {
  1056.   // Zero the COM object's reference count.
  1057.   m_cRefs = 0;
  1058.  
  1059.   // Assign the Host Object pointer.
  1060.   m_pHostObj = pHostObj;
  1061.  
  1062.   // Initialize the Connection Point enumerator variables.
  1063.   m_iEnumIndex = 0;
  1064.   m_cConnections = 0;
  1065.   m_paConnections = NULL;
  1066.  
  1067.   return;
  1068. }
  1069.  
  1070.  
  1071. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1072.   Method:   COEnumConnections::~COEnumConnections
  1073.  
  1074.   Summary:  COEnumConnections Destructor.
  1075.  
  1076.   Args:     void
  1077.  
  1078.   Modifies: m_paConnections.
  1079.  
  1080.   Returns:  void
  1081. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1082. COEnumConnections::~COEnumConnections(void)
  1083. {
  1084.   if (NULL != m_paConnections)
  1085.   {
  1086.     UINT i;
  1087.  
  1088.     // Release all the connected sink interface pointers.
  1089.     for (i=0; i<m_cConnections; i++)
  1090.       m_paConnections[i].pUnk->Release();
  1091.  
  1092.     // Delete the array of connections.
  1093.     delete [] m_paConnections;
  1094.   }
  1095.  
  1096.   return;
  1097. }
  1098.  
  1099.  
  1100. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1101.   Method:   COEnumConnections::Init
  1102.  
  1103.   Summary:  COEnumConnections Initialization method.  Create any
  1104.             necessary arrays, structures, and objects.
  1105.  
  1106.   Args:     ULONG cConnections
  1107.               Number of Connections.
  1108.             CONNECTDATA* paConnections,
  1109.               Pointer to array of connections.
  1110.             ULONG iEnumIndex
  1111.               The Enumerator index initial value.
  1112.  
  1113.   Modifies: m_cConnections, m_paConnections, m_pHostObj, m_iEnumIndex.
  1114.  
  1115.   Returns:  HRESULT
  1116.               Standard result code. NOERROR for success.
  1117. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1118. HRESULT COEnumConnections::Init(
  1119.           ULONG cConnections,
  1120.           CONNECTDATA* paConnections,
  1121.           ULONG iEnumIndex)
  1122. {
  1123.   HRESULT hr = NOERROR;
  1124.   UINT i;
  1125.  
  1126.   // Remember the number of live Connections.
  1127.   m_cConnections = cConnections;
  1128.  
  1129.   // Remember the initial enumerator index.
  1130.   m_iEnumIndex = iEnumIndex;
  1131.  
  1132.   // Create a copy of the array of connections and keep it inside
  1133.   // this enumerator COM object.
  1134.   m_paConnections = new CONNECTDATA [(UINT) cConnections];
  1135.  
  1136.   // Fill the array copy with the connection data from the connections
  1137.   // array passed. AddRef for each new sink Interface pointer copy made.
  1138.   if (NULL != m_paConnections)
  1139.   {
  1140.     for (i=0; i<cConnections; i++)
  1141.     {
  1142.       m_paConnections[i] = paConnections[i];
  1143.       m_paConnections[i].pUnk->AddRef();
  1144.     }
  1145.   }
  1146.   else
  1147.     hr = E_OUTOFMEMORY;
  1148.  
  1149.   return (hr);
  1150. }
  1151.  
  1152.  
  1153. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1154.   Method:   COEnumConnections::QueryInterface
  1155.  
  1156.   Summary:  QueryInterface of the COEnumConnections non-delegating
  1157.             IUnknown implementation.
  1158.  
  1159.   Args:     REFIID riid,
  1160.               [in] GUID of the Interface being requested.
  1161.             PPVOID ppv)
  1162.               [out] Address of the caller's pointer variable that will
  1163.               receive the requested interface pointer.
  1164.  
  1165.   Returns:  HRESULT
  1166. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1167. STDMETHODIMP COEnumConnections::QueryInterface(
  1168.                REFIID riid,
  1169.                PPVOID ppv)
  1170. {
  1171.   HRESULT hr = E_NOINTERFACE;
  1172.  
  1173.   *ppv = NULL;
  1174.  
  1175.   // The IEnumConnections interface is implemented directly in this
  1176.   // COM object rather than being a nested interface implementation.
  1177.   if (IID_IUnknown == riid || IID_IEnumConnections == riid)
  1178.     *ppv = (LPVOID)this;
  1179.  
  1180.   if (NULL != *ppv)
  1181.   {
  1182.     // We've handed out a pointer to the interface so obey the COM rules
  1183.     // and AddRef the reference count.
  1184.     ((LPUNKNOWN)*ppv)->AddRef();
  1185.     hr = NOERROR;
  1186.   }
  1187.  
  1188.   return (hr);
  1189. }
  1190.  
  1191.  
  1192. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1193.   Method:   COEnumConnections::AddRef
  1194.  
  1195.   Summary:  AddRef of the COEnumConnections non-delegating IUnknown
  1196.             implementation.
  1197.  
  1198.   Args:     void
  1199.  
  1200.   Modifies: m_cRefs.
  1201.  
  1202.   Returns:  ULONG
  1203.               New value of m_cRefs (COM object's reference count).
  1204. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1205. STDMETHODIMP_(ULONG) COEnumConnections::AddRef(void)
  1206. {
  1207.   ULONG cRefs;
  1208.  
  1209.   cRefs = ++m_cRefs;
  1210.  
  1211.   // Also AddRef the host object to ensure it stays around as long as
  1212.   // this enumerator.
  1213.   m_pHostObj->AddRef();
  1214.  
  1215.   return cRefs;
  1216. }
  1217.  
  1218.  
  1219. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1220.   Method:   COEnumConnections::Release
  1221.  
  1222.   Summary:  Release of the COEnumConnections non-delegating IUnknown
  1223.             implementation.
  1224.  
  1225.   Args:     void
  1226.  
  1227.   Modifies: m_cRefs.
  1228.  
  1229.   Returns:  ULONG
  1230.               New value of m_cRefs (COM object's reference count).
  1231. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1232. STDMETHODIMP_(ULONG) COEnumConnections::Release(void)
  1233. {
  1234.   ULONG cRefs;
  1235.  
  1236.   // Pass this release along to the Host object being enumerated.
  1237.   m_pHostObj->Release();
  1238.  
  1239.   cRefs = --m_cRefs;
  1240.  
  1241.   if (0 == cRefs)
  1242.   {
  1243.     // We artificially bump the main ref count to prevent reentrancy via
  1244.     // the main object destructor.
  1245.     m_cRefs++;
  1246.     delete this;
  1247.   }
  1248.  
  1249.   return cRefs;
  1250. }
  1251.  
  1252.  
  1253. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1254.   Method:   COEnumConnections::Next
  1255.  
  1256.   Summary:  The Next member method of this IEnumConnections interface
  1257.             implementation. Called by outside clients of a
  1258.             COEnumConnections object to request a number of next
  1259.             connections be returned in an array supplied by the caller.
  1260.  
  1261.   Args:     ULONG cReq
  1262.               Number of connection points requested for return (starting at
  1263.               the current Enumerator index).
  1264.             CONNECTDATA* paConnections,
  1265.               Pointer to a caller's output array that will receive the
  1266.               enumerated connection data structures.
  1267.             ULONG* pcEnumerated)
  1268.               Pointer to a ULONG variable that will contain the number of
  1269.               connection points actually enumerated by this call.
  1270.  
  1271.   Returns:  HRESULT
  1272.               Standard result code. NOERROR for success.
  1273. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1274. STDMETHODIMP COEnumConnections::Next(
  1275.                ULONG cReq,
  1276.                CONNECTDATA* paConnections,
  1277.                ULONG* pcEnumerated)
  1278. {
  1279.   HRESULT hr = NOERROR;
  1280.   ULONG cRet = 0;
  1281.  
  1282.   // Make sure the argument values passed are valid.
  1283.   if (NULL != m_paConnections)
  1284.   {
  1285.     if (NULL != paConnections)
  1286.     {
  1287.       if (m_iEnumIndex < m_cConnections)
  1288.       {
  1289.         if (NULL != pcEnumerated)
  1290.           *pcEnumerated = 0L;
  1291.         else
  1292.           if (1L != cReq)
  1293.             hr = E_POINTER;
  1294.       }
  1295.       else
  1296.         hr = S_FALSE;
  1297.     }
  1298.     else
  1299.       hr = E_POINTER;
  1300.   }
  1301.   else
  1302.     hr = S_FALSE;
  1303.  
  1304.   if (SUCCEEDED(hr))
  1305.   {
  1306.     // Starting at the current Enumerator index, loop to assign the
  1307.     // requested number of output connection data structures.
  1308.     for (; m_iEnumIndex < m_cConnections && cReq > 0;
  1309.            paConnections++, m_iEnumIndex++, cRet++, cReq--)
  1310.     {
  1311.       // Because we are assigning a copy of a connection's data, AddRef
  1312.       // its sink interface pointer.
  1313.       if (NULL != m_paConnections[m_iEnumIndex].pUnk)
  1314.         m_paConnections[m_iEnumIndex].pUnk->AddRef();
  1315.  
  1316.       // Assign a connection's data from the inside Enumerator array to
  1317.       // the specified output receiving array.
  1318.       *paConnections = m_paConnections[m_iEnumIndex];
  1319.     }
  1320.  
  1321.     // Assign the output number of connections enumerated.
  1322.     if (NULL != pcEnumerated)
  1323.       *pcEnumerated = cRet;
  1324.   }
  1325.  
  1326.   return hr;
  1327. }
  1328.  
  1329.  
  1330. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1331.   Method:   COEnumConnections::Skip
  1332.  
  1333.   Summary:  The Skip member method of this IEnumConnections interface
  1334.             implementation. Starting at the current Enumerator index, skip
  1335.             the specified number of connection items.
  1336.  
  1337.   Args:     ULONG cSkip
  1338.               Number of Connection items to skip.
  1339.  
  1340.   Returns:  HRESULT
  1341.               Standard result code. NOERROR for success.
  1342. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1343. STDMETHODIMP COEnumConnections::Skip(
  1344.                ULONG cSkip)
  1345. {
  1346.   HRESULT hr = NOERROR;
  1347.  
  1348.   // If there really is a connection array and the requested
  1349.   // amount of skip does not exceed the number of connections,
  1350.   // then bump the index by the requested skip amount.
  1351.   if (NULL != m_paConnections && (m_iEnumIndex + cSkip) < m_cConnections)
  1352.     m_iEnumIndex += cSkip;
  1353.   else
  1354.     hr = S_FALSE;
  1355.  
  1356.   return hr;
  1357. }
  1358.  
  1359.  
  1360. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1361.   Method:   COEnumConnections::Reset
  1362.  
  1363.   Summary:  The Reset member method of the IEnumConnections interface
  1364.             implementation. Resets the Enumeration index to the first
  1365.             connection item in the array.
  1366.  
  1367.   Args:     void.
  1368.  
  1369.   Returns:  HRESULT
  1370.               Standard result code. NOERROR for success.
  1371. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1372. STDMETHODIMP COEnumConnections::Reset(
  1373.                void)
  1374. {
  1375.   // Zero the main Enumerator index.
  1376.   m_iEnumIndex = 0;
  1377.  
  1378.   return NOERROR;
  1379. }
  1380.  
  1381.  
  1382. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  1383.   Method:   COEnumConnections::Clone
  1384.  
  1385.   Summary:  The Clone member method of this IEnumConnections interface
  1386.             implementation. Creates a new clone of this entire Connection
  1387.             enumerator COM object and returns a pointer to its
  1388.             IEnumConnections interface.
  1389.  
  1390.   Args:     IEnumConnections** ppIEnum
  1391.               Address of the caller's output pointer variable that will
  1392.               receive the IEnumConnections interface pointer of the
  1393.               new enumerator clone.
  1394.  
  1395.   Returns:  HRESULT
  1396.               Standard result code. NOERROR for success.
  1397. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  1398. STDMETHODIMP COEnumConnections::Clone(
  1399.                IEnumConnections** ppIEnum)
  1400. {
  1401.   HRESULT hr;
  1402.   COEnumConnections* pCOEnum;
  1403.  
  1404.   // NULL the output variable first.
  1405.   *ppIEnum = NULL;
  1406.  
  1407.   // Create the Clone Enumerator COM object.
  1408.   pCOEnum = new COEnumConnections(m_pHostObj);
  1409.   if (NULL != pCOEnum)
  1410.   {
  1411.     // Initialize it with same values as in this existing enumerator.
  1412.     hr = pCOEnum->Init(m_cConnections, m_paConnections, m_iEnumIndex);
  1413.     if (SUCCEEDED(hr))
  1414.     {
  1415.       // QueryInterface to return the requested interface pointer.
  1416.       // An AddRef will be conveniently done by the QI.
  1417.       if (SUCCEEDED(hr))
  1418.         hr = pCOEnum->QueryInterface(
  1419.                         IID_IEnumConnections,
  1420.                         (PPVOID)ppIEnum);
  1421.     }
  1422.   }
  1423.   else
  1424.     hr = E_OUTOFMEMORY;
  1425.  
  1426.   return hr;
  1427. }
  1428.