home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / inole2 / chap08 / polyline / iconnpt.cpp < prev    next >
C/C++ Source or Header  |  1995-05-03  |  7KB  |  335 lines
  1. /*
  2.  * ICONNPT.CPP
  3.  * Polyline Component Chapter 8
  4.  *
  5.  * Implementation of CImpIConnectionPoint for the Polyline object
  6.  * as well as CConnectionPoint.
  7.  *
  8.  *
  9.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  10.  *
  11.  * Kraig Brockschmidt, Microsoft
  12.  * Internet  :  kraigb@microsoft.com
  13.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  14.  */
  15.  
  16.  
  17. #include "polyline.h"
  18.  
  19.  
  20. /*
  21.  * CImpIConnPtCont:CImpIConnPtCont
  22.  * CImpIConnPtCont::~CImpIConnPtCont
  23.  *
  24.  * Constructor Parameters:
  25.  *  pObj            PCPolyline pointing to the object we live in.
  26.  *  pUnkOuter       LPUNKNOWN of the controlling unknown.
  27.  */
  28.  
  29. CImpIConnPtCont::CImpIConnPtCont(PCPolyline pObj
  30.     , LPUNKNOWN pUnkOuter)
  31.     {
  32.     m_cRef=0;
  33.     m_pObj=pObj;
  34.     m_pUnkOuter=pUnkOuter;
  35.     return;
  36.     }
  37.  
  38.  
  39. CImpIConnPtCont::~CImpIConnPtCont(void)
  40.     {
  41.     return;
  42.     }
  43.  
  44.  
  45.  
  46.  
  47. /*
  48.  * CImpIConnPtCont::QueryInterface
  49.  * CImpIConnPtCont::AddRef
  50.  * CImpIConnPtCont::Release
  51.  */
  52.  
  53. STDMETHODIMP CImpIConnPtCont::QueryInterface(REFIID riid, PPVOID ppv)
  54.     {
  55.     return m_pUnkOuter->QueryInterface(riid, ppv);
  56.     }
  57.  
  58. STDMETHODIMP_(ULONG) CImpIConnPtCont::AddRef(void)
  59.     {
  60.     ++m_cRef;
  61.     return m_pUnkOuter->AddRef();
  62.     }
  63.  
  64. STDMETHODIMP_(ULONG) CImpIConnPtCont::Release(void)
  65.     {
  66.     --m_cRef;
  67.     return m_pUnkOuter->Release();
  68.     }
  69.  
  70.  
  71.  
  72.  
  73.  
  74. /*
  75.  * CImpIConnPtCont::EnumConnectionPoints
  76.  *
  77.  * Purpose:
  78.  *  Not implemented.
  79.  *
  80.  * Return Value:
  81.  *  HRESULT         E_NOTIMPL
  82.  */
  83.  
  84. STDMETHODIMP CImpIConnPtCont::EnumConnectionPoints
  85.     (LPENUMCONNECTIONPOINTS *ppEnum)
  86.     {
  87.     *ppEnum=NULL;
  88.     return ResultFromScode(E_NOTIMPL);
  89.     }
  90.  
  91.  
  92.  
  93. /*
  94.  * CImpIConnPtCont::FindConnectionPoint
  95.  *
  96.  * Purpose:
  97.  *  Returns a pointer to the IConnectionPoint for a given
  98.  *  outgoing IID.
  99.  *
  100.  * Parameters:
  101.  *  riid            REFIID of the outgoing interface for which
  102.  *                  a connection point is desired.
  103.  *  ppCP            IConnectionPoint ** in which to return
  104.  *                  the pointer after calling AddRef.
  105.  *
  106.  * Return Value:
  107.  *  HRESULT         NOERROR if the connection point is found,
  108.  *                  E_NOINTERFACE if it's not supported.
  109.  */
  110.  
  111. STDMETHODIMP CImpIConnPtCont::FindConnectionPoint(REFIID riid
  112.     , IConnectionPoint **ppCP)
  113.     {
  114.     *ppCP=NULL;
  115.  
  116.     //CHAPTER8MOD
  117.     if (IID_IPolylineAdviseSink8==riid)
  118.     //End CHAPTER8MOD
  119.         {
  120.         return m_pObj->m_pConnPt->QueryInterface
  121.             (IID_IConnectionPoint, (PPVOID)ppCP);
  122.         }
  123.  
  124.     return ResultFromScode(E_NOINTERFACE);
  125.     }
  126.  
  127.  
  128.  
  129.  
  130.  
  131. //CConnectionPoint implementation
  132.  
  133. /*
  134.  * CConnectionPoint::CConnectionPoint
  135.  * CConnectionPoint::~CConnectionPoint
  136.  *
  137.  * Parameters (Constructor):
  138.  *  pObj            PCPolyline of the object we're in.  We can
  139.  *                  query this for the IConnectionPointContainer
  140.  *                  interface we might need.
  141.  */
  142.  
  143. CConnectionPoint::CConnectionPoint(PCPolyline pObj)
  144.     {
  145.     m_cRef=0;
  146.  
  147.     /*
  148.      * Our lifetime is controlled by the connectable object itself,
  149.      * although other external clients will call AddRef and Release.
  150.      * Since we're nested in the connectable object's lifetime,
  151.      * there's no need to call AddRef on pObj.
  152.      */
  153.     m_pObj=pObj;
  154.     return;
  155.     }
  156.  
  157. CConnectionPoint::~CConnectionPoint(void)
  158.     {
  159.     ReleaseInterface(m_pObj->m_pAdv);
  160.     return;
  161.     }
  162.  
  163.  
  164.  
  165. /*
  166.  * CConnectionPoint::QueryInterface
  167.  * CConnectionPoint::AddRef
  168.  * CConnectionPoint::Release
  169.  *
  170.  * Purpose:
  171.  *  Non-delegating IUnknown members for CConnectionPoint.
  172.  */
  173.  
  174. STDMETHODIMP CConnectionPoint::QueryInterface(REFIID riid
  175.     , LPVOID *ppv)
  176.     {
  177.     *ppv=NULL;
  178.  
  179.     if (IID_IUnknown==riid || IID_IConnectionPoint==riid)
  180.         *ppv=(LPVOID)this;
  181.  
  182.     if (NULL!=*ppv)
  183.         {
  184.         ((LPUNKNOWN)*ppv)->AddRef();
  185.         return NOERROR;
  186.         }
  187.  
  188.     return ResultFromScode(E_NOINTERFACE);
  189.     }
  190.  
  191. STDMETHODIMP_(ULONG) CConnectionPoint::AddRef(void)
  192.     {
  193.     return ++m_cRef;
  194.     }
  195.  
  196. STDMETHODIMP_(ULONG) CConnectionPoint::Release(void)
  197.     {
  198.     if (0!=--m_cRef)
  199.         return m_cRef;
  200.  
  201.     delete this;
  202.     return 0;
  203.     }
  204.  
  205.  
  206.  
  207. /*
  208.  * CConnectionPoint::GetConnectionInterface
  209.  *
  210.  * Purpose:
  211.  *  Returns the IID of the outgoing interface supported through
  212.  *  this connection point.
  213.  *
  214.  * Parameters:
  215.  *  pIID            IID * in which to store the IID.
  216.  */
  217.  
  218. STDMETHODIMP CConnectionPoint::GetConnectionInterface(IID *pIID)
  219.     {
  220.     if (NULL==pIID)
  221.         return ResultFromScode(E_POINTER);
  222.  
  223.     //CHAPTER8MOD
  224.     *pIID=IID_IPolylineAdviseSink8;
  225.     //End CHAPTER8MOD
  226.     return NOERROR;
  227.     }
  228.  
  229.  
  230.  
  231. /*
  232.  * CConnectionPoint::GetConnectionPointContainer
  233.  *
  234.  * Purpose:
  235.  *  Returns a pointer to the IConnectionPointContainer that
  236.  *  is manageing this connection point.
  237.  *
  238.  * Parameters:
  239.  *  ppCPC           IConnectionPointContainer ** in which to return
  240.  *                  the pointer after calling AddRef.
  241.  */
  242.  
  243. STDMETHODIMP CConnectionPoint::GetConnectionPointContainer
  244.     (IConnectionPointContainer **ppCPC)
  245.     {
  246.     return m_pObj->QueryInterface(IID_IConnectionPointContainer
  247.         , (void **)ppCPC);
  248.     }
  249.  
  250.  
  251.  
  252. /*
  253.  * CConnectionPoint::Advise
  254.  *
  255.  * Purpose:
  256.  *  Provides this connection point with a notification sink to
  257.  *  call whenever the appropriate outgoing function/event occurs.
  258.  *
  259.  * Parameters:
  260.  *  pUnkSink        LPUNKNOWN to the sink to notify.  The connection
  261.  *                  point must QueryInterface on this pointer to obtain
  262.  *                  the proper interface to call.  The connection
  263.  *                  point must also insure that any pointer held has
  264.  *                  a reference count (QueryInterface will do it).
  265.  *  pdwCookie       DWORD * in which to store the connection key for
  266.  *                  later calls to Unadvise.
  267.  */
  268.  
  269. STDMETHODIMP CConnectionPoint::Advise(LPUNKNOWN pUnkSink
  270.     , DWORD *pdwCookie)
  271.     {
  272.     //CHAPTER8MOD
  273.     IPolylineAdviseSink8   *pSink;
  274.     //End CHAPTER8MOD
  275.  
  276.     *pdwCookie=0;
  277.  
  278.     //Only allow one connection
  279.     if (NULL!=m_pObj->m_pAdv)
  280.         return ResultFromScode(CONNECT_E_ADVISELIMIT);
  281.  
  282.     //Check for the right interface on the sink.
  283.     //CHAPTER8MOD
  284.     if (FAILED(pUnkSink->QueryInterface(IID_IPolylineAdviseSink8
  285.         , (PPVOID)&pSink)))
  286.     //End CHAPTER8MOD
  287.         return ResultFromScode(CONNECT_E_CANNOTCONNECT);
  288.  
  289.     *pdwCookie=ADVISEKEY;
  290.     m_pObj->m_pAdv=pSink;
  291.     return NOERROR;
  292.     }
  293.  
  294.  
  295.  
  296. /*
  297.  * CConnectionPoint::Unadvise
  298.  *
  299.  * Purpose:
  300.  *  Terminates the connection to the notification sink identified
  301.  *  with dwCookie (that was returned from Advise).  The connection
  302.  *  point has to Release any held pointers for that sink.
  303.  *
  304.  * Parameters:
  305.  *  dwCookie        DWORD connection key from Advise.
  306.  */
  307.  
  308. STDMETHODIMP CConnectionPoint::Unadvise(DWORD dwCookie)
  309.     {
  310.     if (0==dwCookie)
  311.         return ResultFromScode(E_INVALIDARG);
  312.  
  313.     if (ADVISEKEY!=dwCookie)
  314.         ResultFromScode(CONNECT_E_NOCONNECTION);
  315.  
  316.     ReleaseInterface(m_pObj->m_pAdv);
  317.     return NOERROR;
  318.     }
  319.  
  320.  
  321.  
  322. /*
  323.  * CConnectionPoint::EnumConnections
  324.  *
  325.  * Purpose:
  326.  *  Not implemented.
  327.  */
  328.  
  329. STDMETHODIMP CConnectionPoint::EnumConnections
  330.     (LPENUMCONNECTIONS *ppEnum)
  331.     {
  332.     *ppEnum=NULL;
  333.     return ResultFromScode(E_NOTIMPL);
  334.     }
  335.