|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 1998.
//
// File: conpt.cxx
//
// Contents: connection point / notification code for cursors
//
// Classes: CConnectionPointBase, CConnectionPointContainer
//
// History: 7 Oct 1994 Dlee Created
// 12 Feb 1998 AlanW Generalized
//
//--------------------------------------------------------------------------
#include "pch.cxx"
#pragma hdrstop
#include <conpt.hxx>
#include "tabledbg.hxx"
// Max. connections per connection point. Should be enough for any application!
const maxConnections = 20;
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::QueryInterface, public
//
// Synopsis: Invokes QueryInterface on container object
//
// Arguments: [riid] -- interface ID
// [ppvObject] -- returned interface pointer
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::QueryInterface( REFIID riid, void **ppvObject){ SCODE sc = S_OK;
if ( 0 == ppvObject ) return E_INVALIDARG;
*ppvObject = 0;
if ( IID_IConnectionPoint == riid ) { *ppvObject = (void *) (IConnectionPoint *) this; } else if ( IID_IUnknown == riid ) { *ppvObject = (void *) (IUnknown *) this; } else { sc = E_NOINTERFACE; }
if (SUCCEEDED(sc)) AddRef();
return sc;} //QueryInterface
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::AddRef, public
//
// Synopsis: Increments ref. count, or delegates to containing object
//
// Returns: ULONG
//
// History: 17 Mar 1998 AlanW
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CConnectionPointBase::AddRef(){ if (_pIContrUnk) return _pIContrUnk->AddRef( ); else { tbDebugOut(( DEB_NOTIFY, "conpt: addref\n" )); return InterlockedIncrement( (long *) &_cRefs ); }} //AddRef
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::Release, public
//
// Synopsis: Decrements ref. count, or delegates to containing object
//
// Returns: ULONG
//
// History: 17 Mar 1998 AlanW
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CConnectionPointBase::Release(){ if (_pIContrUnk) return _pIContrUnk->Release( ); else { long cRefs = InterlockedDecrement((long *) &_cRefs); tbDebugOut(( DEB_NOTIFY, "conpt: release, new crefs: %lx\n", _cRefs )); // If no references, make sure container doesn't know about me anymore
if ( 0 == cRefs ) { Win4Assert( 0 == _pContainer );
#if 0 // Note: no sense trying to avoid an AV for bad client code
if ( 0 != _pContainer ) { // need to have been disconnected; must be an excess release
// from client
Disconnect(); } #endif // 0
delete this; } return cRefs; }} //Release
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::GetConnectionInterface, public
//
// Synopsis: returns the IID of the callback notification object
//
// Arguments: [piid] -- interface ID
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::GetConnectionInterface(IID * piid){ if ( 0 == piid ) return E_POINTER;
*piid = _iidSink; return S_OK;} //GetConnectionInterface
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::GetConnectionPointContainer, public
//
// Synopsis: returns the container that spawned the connection point
//
// Arguments: [ppCPC] -- returns the container
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::GetConnectionPointContainer( IConnectionPointContainer ** ppCPC){ if ( 0 == ppCPC ) return E_POINTER;
*ppCPC = 0; // if disconnected from container, can't do it.
if (0 == _pContainer) return E_UNEXPECTED; _pContainer->AddRef(); *ppCPC = _pContainer;
return S_OK;} //GetConnectionPointContainer
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::Advise, public
//
// Synopsis: Passes in the client's notification object
//
// Arguments: [pIUnk] -- client's notification object
// [pdwCookie] -- returned pseudo-id for this advise
//
// Returns: SCODE
//
// Notes:
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::Advise( IUnknown * piunkNotify, DWORD * pdwCookie){ SCODE sc = S_OK;
if ( 0 != pdwCookie ) *pdwCookie = 0; if ( 0 == piunkNotify || 0 == pdwCookie ) return E_POINTER;
XInterface<IUnknown> piSink;
sc = piunkNotify->QueryInterface( _iidSink, piSink.GetQIPointer() ); if (! SUCCEEDED(sc)) return CONNECT_E_CANNOTCONNECT;
// If disconnected from the container, can't call GetMutex.
if (0 == _pContainer) return CONNECT_E_ADVISELIMIT;
CLock lock( GetMutex() ); CConnectionContext * pConnCtx = LokFindConnection( 0 );
if (0 == pConnCtx && _xaConns.Count() < maxConnections) pConnCtx = &_xaConns[_xaConns.Count()];
if (0 == pConnCtx) sc = CONNECT_E_ADVISELIMIT; else { _dwCookieGen++; Win4Assert( 0 != _dwCookieGen && 0 == LokFindConnection( _dwCookieGen ) ); pConnCtx->Set( piSink.Acquire(), _dwCookieGen, _dwDefaultSpare ); if (_pAdviseHelper) (*_pAdviseHelper) (_pAdviseHelperContext, this, pConnCtx); *pdwCookie = _dwCookieGen; }
return sc;} //Advise
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::Unadvise, public
//
// Synopsis: Turns off an advise previously turned on with Advise()
//
// Arguments: [dwCookie] -- pseudo-id for this advise
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::Unadvise( DWORD dwCookie){ SCODE sc = S_OK; CConnectionContext * pConnCtx = 0;
CReleasableLock lock( GetMutex(), ( 0 != _pContainer ) );
pConnCtx = LokFindConnection( dwCookie ); if (pConnCtx) { if (_pUnadviseHelper) (*_pUnadviseHelper) ( _pUnadviseHelperContext, this, pConnCtx, lock ); pConnCtx->Release(); }
if (0 == pConnCtx) { tbDebugOut(( DEB_WARN, "conpt: unknown advise cookie %x\n", dwCookie )); sc = CONNECT_E_NOCONNECTION; }
return sc;} //Unadvise
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::EnumConnections, public
//
// Synopsis: Returns an enumerator of advises open in this connection
//
// Arguments: [ppEnum] -- returned enumerator
//
// Returns: SCODE
//
// Notes: The spec permits E_NOTIMPL to be returned for this. If
// we chose to implement it, it's a straightforward matter of
// iterating over the _xaConns array.
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointBase::EnumConnections( IEnumConnections ** ppEnum){ if ( 0 == ppEnum ) return E_POINTER;
*ppEnum = 0; return E_NOTIMPL;} //EnumConnections
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::Disconnect, private
//
// Synopsis: Disconnect from the connection point container
//
// Arguments: [dwCookie] -- pseudo-id for this advise
//
// Returns: CConnectionContext* - a connection matching the [dwCookie] or 0
//
// Notes: Should be called with the CPC lock held. Might be called
// without the lock for an Unadvise after the CPC is diconnected.
//
// History: 30 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
void CConnectionPointBase::Disconnect( ){ Win4Assert( 0 != _pContainer ); CLock lock(GetMutex());
_pContainer->RemoveConnectionPoint( this ); _pContainer = 0;}
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::LokFindConnection, private
//
// Synopsis: Find a connection matching an advise cookie
//
// Arguments: [dwCookie] -- pseudo-id for this advise
//
// Returns: CConnectionContext* - a connection matching the [dwCookie] or 0
//
// Notes: Should be called with the CPC lock held. Might be called
// without the lock for an Unadvise after the CPC is diconnected.
//
// History: 10 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
CConnectionPointBase::CConnectionContext * CConnectionPointBase::LokFindConnection( DWORD dwCookie ){ for (unsigned i=0; i<_xaConns.Count(); i++) { CConnectionContext & rConnCtx = _xaConns[i];
if (rConnCtx._dwAdviseCookie == dwCookie) return &rConnCtx; } return 0;}
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointBase::LokFindActiveConnection, private
//
// Synopsis: Find an active advise by indexing
//
// Arguments: [riConn] -- index into conn. context array, updated on return
//
// Returns: CConnectionContext* - pointer to an active connection context,
// or NULL.
//
// Notes: Should be called with the CPC lock held.
//
// History: 10 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
CConnectionPointBase::CConnectionContext * CConnectionPointBase::LokFindActiveConnection( unsigned & riConn ){ while (riConn < _xaConns.Count()) { CConnectionContext & rCtx = _xaConns[riConn];
if (rCtx._dwAdviseCookie != 0) return &rCtx;
riConn++; } return 0;}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::QueryInterface, public
//
// Synopsis: Invokes QueryInterface on cursor object
//
// Arguments: [riid] -- interface ID
// [ppvObject] -- returned interface pointer
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointContainer::QueryInterface( REFIID riid, void **ppvObject){ if ( 0 == ppvObject ) return E_INVALIDARG;
return _rControllingUnk.QueryInterface(riid, ppvObject);} //QueryInterface
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::AddRef, public
//
// Synopsis: Invokes AddRef on cursor object
//
// Returns: ULONG
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CConnectionPointContainer::AddRef(){ tbDebugOut(( DEB_NOTIFY, "conptcontainer: addref\n" )); return _rControllingUnk.AddRef();} //AddRef
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::Release, public
//
// Synopsis: Invokes Release on cursor object
//
// Returns: ULONG
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CConnectionPointContainer::Release(){ tbDebugOut(( DEB_NOTIFY, "conptcontainer: release\n" )); return _rControllingUnk.Release();} //Release
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::CConnectionPointContainer, public
//
// Synopsis: Constructor for connection point container class.
//
// Arguments: [maxConnPt] -- maximum number of connection points supported
// [rUnknown] -- controlling unknown
// [ErrorObject] -- reference to error object
//
// Notes: After construction, use AddConnectionPoint to add a connection
// point into the container.
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
CConnectionPointContainer::CConnectionPointContainer( unsigned maxConnPt, IUnknown &rUnknown, CCIOleDBError & ErrorObject ) : _rControllingUnk(rUnknown), _ErrorObject( ErrorObject ), _cConnPt( 0 ){ Win4Assert( maxConnPt <= maxConnectionPoints );} //CConnectionPointContainer
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::~CConnectionPointContainer, public
//
// Synopsis: Destructor for connection point container class.
//
// Notes: It is expected that all connection points are relased by this
// time.
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
CConnectionPointContainer::~CConnectionPointContainer(){ CLock lock( _mutex );
//
// Release all connection points
//
for (unsigned i = 0; i < _cConnPt; i++) { IConnectionPoint * pIConnPt = _aConnPt[i]._pIConnPt; if ( 0 != pIConnPt ) { _aConnPt[i]._pIConnPt = 0; pIConnPt->Release(); } }} //~CConnectionPointContainer
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::FindConnectionPoint, public
//
// Synopsis: Finds a connection point object that supports the given
// interface for callback to the client
//
// Arguments: [riid] -- interface ID for proposed callback
// [ppPoint] -- returned connection interface pointer
//
// Returns: SCODE
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointContainer::FindConnectionPoint( REFIID riid, IConnectionPoint ** ppPoint){ _ErrorObject.ClearErrorInfo();
if ( 0 == ppPoint ) return E_POINTER;
*ppPoint = 0; SCODE sc = S_OK;
TRANSLATE_EXCEPTIONS; TRY { CLock lock( _mutex );
for (unsigned i = 0; i < _cConnPt; i++) { if ( riid == _aConnPt[i]._iidConnPt ) break; }
if ( i<_cConnPt ) { Win4Assert(_aConnPt[i]._pIConnPt != 0); IConnectionPoint * pIConnPt = _aConnPt[i]._pIConnPt; *ppPoint = pIConnPt; pIConnPt->AddRef(); } else { sc = CONNECT_E_NOCONNECTION; }
if (FAILED(sc)) _ErrorObject.PostHResult(sc, IID_IConnectionPointContainer); } CATCH(CException,e) { _ErrorObject.PostHResult(e.GetErrorCode(), IID_IConnectionPointContainer); sc = E_UNEXPECTED; } END_CATCH; UNTRANSLATE_EXCEPTIONS;
return sc;} //FindConnectionPoint
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::EnumConnectionPoints, public
//
// Synopsis: Enumerates all connection points currently in use
//
// Arguments: [ppEnum] -- returned enumerator
//
// Returns: SCODE
//
// History: 09 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CConnectionPointContainer::EnumConnectionPoints( IEnumConnectionPoints **ppEnum){ _ErrorObject.ClearErrorInfo();
if ( 0 == ppEnum ) return E_POINTER;
*ppEnum = 0; SCODE sc = S_OK;
TRANSLATE_EXCEPTIONS; TRY { CLock lock( _mutex );
XInterface<IEnumConnectionPoints> pEnumCp( new CEnumConnectionPoints( *this ) ); *ppEnum = pEnumCp.GetPointer(); pEnumCp.Acquire(); } CATCH(CException,e) { _ErrorObject.PostHResult(e.GetErrorCode(), IID_IConnectionPointContainer); sc = e.GetErrorCode(); } END_CATCH; UNTRANSLATE_EXCEPTIONS;
return sc;} //EnumConnectionPoints
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::QueryInterface, public
//
// Synopsis: Invokes QueryInterface on connection point enumerator object
//
// Arguments: [riid] -- interface ID
// [ppvObject] -- returned interface pointer
//
// Returns: SCODE
//
// History: 10 Mar 1998 AlanW
//
//--------------------------------------------------------------------------
STDMETHODIMP CEnumConnectionPoints::QueryInterface( REFIID riid, void **ppvObject){ SCODE sc = S_OK;
if ( 0 == ppvObject ) return E_INVALIDARG;
*ppvObject = 0;
if ( IID_IEnumConnectionPoints == riid ) { *ppvObject = (void *) (IEnumConnectionPoints *) this; } else if ( IID_IUnknown == riid ) { *ppvObject = (void *) (IUnknown *) this; } else { sc = E_NOINTERFACE; }
if (SUCCEEDED(sc)) AddRef();
return sc;} //QueryInterface
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::AddRef, public
//
// Synopsis: Invokes AddRef on container object
//
// Returns: ULONG
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CEnumConnectionPoints::AddRef(){ return InterlockedIncrement( (long *) &_cRefs );} //AddRef
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::Release, public
//
// Synopsis: Invokes Release on container object
//
// Returns: ULONG
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CEnumConnectionPoints::Release(){ long cRefs = InterlockedDecrement((long *) &_cRefs);
tbDebugOut(( DEB_NOTIFY, "enumconpt: release, new crefs: %lx\n", _cRefs ));
// If no references, delete.
if ( 0 == cRefs ) { delete this; }
return cRefs;} //Release
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::Clone, public
//
// Synopsis: Clone a connection point enumerator
//
// Arguments: [ppEnum] -- returned enumerator
//
// Returns: SCODE
//
// History: 09 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CEnumConnectionPoints::Clone ( IEnumConnectionPoints **ppEnum){ //_ErrorObject.ClearErrorInfo();
if ( 0 == ppEnum ) return E_POINTER;
*ppEnum = 0; SCODE sc = S_OK;
TRANSLATE_EXCEPTIONS; TRY { XInterface<CEnumConnectionPoints> pEnumCp( new CEnumConnectionPoints( _rContainer ) ); pEnumCp->_iConnPt = _iConnPt; *ppEnum = pEnumCp.GetPointer(); pEnumCp.Acquire(); } CATCH(CException,e) { sc = e.GetErrorCode(); } END_CATCH; UNTRANSLATE_EXCEPTIONS;
return sc;} //Clone
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::Reset, public
//
// Synopsis: Reset a connection point enumerator
//
// Arguments: -NONE-
//
// Returns: SCODE
//
// History: 09 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CEnumConnectionPoints::Reset ( ){ _iConnPt = 0; return S_OK;} //Reset
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::Skip, public
//
// Synopsis: Skip some connection points
//
// Arguments: [cConnections] - number of connection points to skip
//
// Returns: SCODE
//
// History: 09 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CEnumConnectionPoints::Skip ( ULONG cConnections ){ SCODE sc = S_OK;
if ( _iConnPt+cConnections < _rContainer._cConnPt ) _iConnPt += cConnections; else sc = S_FALSE; return sc;} //Skip
//+-------------------------------------------------------------------------
//
// Method: CEnumConnectionPoints::Next, public
//
// Synopsis: Return some connection points
//
// Arguments: [cConnections] - number of connection points to return, at most
// [rgpcm] - array of IConnectionPoint* to be returned
// [pcFetched] - on return, number of connection points in [rgpcm]
//
// Returns: SCODE
//
// History: 09 Mar 1998 AlanW Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CEnumConnectionPoints::Next ( ULONG cConnections, IConnectionPoint **rgpcm, ULONG * pcFetched ){ SCODE sc = S_OK;
if ( 0 != pcFetched ) *pcFetched = 0;
if ( 0 == rgpcm || 0 == pcFetched ) return E_POINTER;
for (ULONG i=0; i<cConnections; i++) rgpcm[i] = 0;
TRANSLATE_EXCEPTIONS; TRY { ULONG cRet = 0; CLock lock(_rContainer._mutex);
// Note: There could be leakage of CP pointers if there are exceptions
// generated by the code below.
while ( _iConnPt < _rContainer._cConnPt && cRet < cConnections ) { XInterface<IConnectionPoint> xCP( _rContainer._aConnPt[_iConnPt]._pIConnPt ); xCP->AddRef(); rgpcm[cRet] = xCP.GetPointer(); cRet++; _iConnPt++; *pcFetched = cRet; xCP.Acquire(); } sc = (cConnections == cRet) ? S_OK : S_FALSE; } CATCH(CException,e) { sc = e.GetErrorCode(); } END_CATCH; UNTRANSLATE_EXCEPTIONS;
return sc;} //Next
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::AddConnectionPoint, public
//
// Synopsis: Adds a connection point to the container.
// Called by the connection point itself.
//
// Arguments: [riid] --- IID of notification interface for CP
// [pConnPt] --- connection point to be removed
//
// Notes: The back pointer from the connection point to the connection
// point container does not contribute to the container's ref.
// count so that the CPC <-> CP structure is not self-referential
// and can be deleted when no longer needed.
//
// History: 10 Mar 1998 AlanW
//
//--------------------------------------------------------------------------
void CConnectionPointContainer::AddConnectionPoint( REFIID riid, CConnectionPointBase *pConnPt){ Win4Assert( _cConnPt < maxConnectionPoints );
XInterface<IConnectionPoint> xConnPt; SCODE sc = pConnPt->QueryInterface( IID_IConnectionPoint, xConnPt.GetQIPointer()); if (!SUCCEEDED(sc)) THROW( CException(sc) );
CLock lock(_mutex);
CConnectionPointContext * pConnPtCtx = &_aConnPt[_cConnPt]; pConnPtCtx->_pIConnPt = xConnPt.Acquire(); pConnPtCtx->_iidConnPt = riid; _cConnPt++;} //AddConnectionPoint
//+-------------------------------------------------------------------------
//
// Method: CConnectionPointContainer::RemoveConnectionPoint, public
//
// Synopsis: Removes a connection point from the container.
// Called by the connection point itself.
//
// Arguments: [pConnPt] --- connection point to be removed
//
// History: 07-Oct-1994 dlee
//
//--------------------------------------------------------------------------
void CConnectionPointContainer::RemoveConnectionPoint( IConnectionPoint *pConnPt){ CLock lock(_mutex);
for (unsigned i = 0; i < _cConnPt; i++) { if ( _aConnPt[i]._pIConnPt == pConnPt ) { _aConnPt[i]._pIConnPt = 0; pConnPt->Release(); } }} //RemoveConnectionPoint
|
