DWORD tLuaCOM::addConnection(tLuaCOM *server) { if(!server->hasTypeInfo()) return false; HRESULT hr; IDispatch *pdisp_server = server->GetIDispatch(); IConnectionPointContainer *pcpc = NULL; IConnectionPoint *connection_point; hr = pdisp->QueryInterface ( IID_IConnectionPointContainer, (void **) &pcpc ); if(FAILED(hr)) { return NULL; } { IID guid; server->GetIID(&guid); hr = pcpc->FindConnectionPoint(guid, &connection_point); } pcpc->Release(); pcpc = NULL; if(FAILED(hr)) { return NULL; } DWORD connection_point_cookie; hr = connection_point->Advise ( (IUnknown *) pdisp_server, &connection_point_cookie ); if(FAILED(hr)) { connection_point->Release(); connection_point = NULL; return NULL; } if(conn_point!=NULL) conn_point->Release(); conn_point = connection_point; conn_cookie = connection_point_cookie; return connection_point_cookie; }
BOOL COutlookButton::SetupConnection(IDispatch *pDisp) { IConnectionPointContainer *pCPC = 0; HRESULT hr = S_OK; try { // Set up the connection and call Advise. if (FAILED((hr=pDisp->QueryInterface(IID_IConnectionPointContainer,(void **)&pCPC)))) return FALSE; if (FAILED((hr=pCPC->FindConnectionPoint(__uuidof(Office::_CommandBarButtonEvents),&m_pCP)))) { pCPC->Release(); return FALSE; } if (FAILED((hr=m_pCP->Advise(static_cast<IDispatch*>(this), &m_dwCookie)))) { pCPC->Release(); return FALSE; } pCPC->Release(); } catch(...) { } return TRUE; }
void CAddUserRequest::InitMpaWebEvent() { IConnectionPointContainer* pCPContainer = NULL; CComPtr<IConnectionPoint> m_pSessionConnectionPoint; HRESULT hr = m_pWebCustomizer->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPContainer); if (pCPContainer) { hr = pCPContainer->FindConnectionPoint(__uuidof(_IMpaWebCustomizerEvents),&m_pSessionConnectionPoint); if(SUCCEEDED(hr)) { LPUNKNOWN pInterEvent = GetInterface(&IID_IUnknown); hr = m_pSessionConnectionPoint->Advise(pInterEvent ,&m_dwSessionCookie); pCPContainer->Release(); } else { ASSERT(FALSE); } } else { ASSERT(FALSE); } }
QWmpEvents::QWmpEvents(IUnknown *source, QObject *parent) : QObject(parent) , m_ref(1) , m_connectionPoint(0) , m_adviseCookie(0) { HRESULT hr; IConnectionPointContainer *container = 0; if ((hr = source->QueryInterface( IID_IConnectionPointContainer, reinterpret_cast<void **>(&container))) != S_OK) { qWarning("No connection point container, %x: %d", hr, qwmp_error_string(hr)); } else { if ((hr = container->FindConnectionPoint( __uuidof(IWMPEvents), &m_connectionPoint)) != S_OK) { qWarning("No connection point for IWMPEvents %d", hr); } else if ((hr = m_connectionPoint->Advise( static_cast<IWMPEvents3 *>(this), &m_adviseCookie)) != S_OK) { qWarning("Failed to link to connection point, %x, %s", hr, qwmp_error_string(hr)); m_connectionPoint->Release(); m_connectionPoint = 0; } container->Release(); } }
HRESULT CLoopbackDevice::SetupConnectionPoint(IUnknown* punkObject, REFIID iidConnectionPoint) { HRESULT hr = S_OK; IConnectionPointContainer* piConnectionPointContainer = NULL; IUnknown* punkSink = NULL; //If there is already connection point enabled, disable it if(NULL != m_piConnectionPoint) { IfFailHrGo(ReleaseConnectionPoint()); } IfFailHrGo(punkObject->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void **>(&piConnectionPointContainer))); IfFailHrGo(piConnectionPointContainer->FindConnectionPoint(iidConnectionPoint, &m_piConnectionPoint)); // Get the IUknown of this interface as this is the event sink punkSink = (this)->GetUnknown(); if(NULL == punkSink) { IfFailHrGo(E_UNEXPECTED); } IfFailHrGo(m_piConnectionPoint->Advise(punkSink, &m_dwConnectionCookie)); Exit: return hr; }
BOOL ZDrOleClient::InterfaceDisconnect( IUnknown *pObj, REFIID riid, LPDWORD pdwConn ) { HRESULT hr; IConnectionPointContainer *pCPointContainer = 0; IConnectionPoint *pCPoint = 0; if ( pObj == 0 || pdwConn == 0 ) return( FALSE ); if ( *pdwConn == 0 ) return( FALSE ); hr = pObj->QueryInterface( IID_IConnectionPointContainer, (LPVOID *) &pCPointContainer ); if ( FAILED( hr ) ) return( FALSE ); hr = pCPointContainer->FindConnectionPoint( riid, &pCPoint ); if ( SUCCEEDED( hr ) ) { // This is the Point to kill m_pEditorEventSink. We are doing this // through Unadvise hr = pCPoint->Unadvise(*pdwConn); if ( SUCCEEDED( hr ) ) *pdwConn = 0L; pCPoint->Release( ); } pCPointContainer->Release( ); return( SUCCEEDED( hr ) ); } // InterfaceDisconnect
/********************************************************** * COperator::RegisterTapiEventInterface * *---------------------------------------* * Description: * Get a unique identifier (m_ulAdvice) for * this connection point. * Return: * S_OK * Failed HRESULTs from QI(), * IConnectionPointContainer::FindConnectionPoint(), * or IConnectionPoint::Advise() ***********************************************************/ HRESULT COperator::RegisterTapiEventInterface() { HRESULT hr = S_OK; IConnectionPointContainer * pCPC; IConnectionPoint * pCP; hr = m_pTapi->QueryInterface( IID_IConnectionPointContainer, (void **)&pCPC ); if ( SUCCEEDED( hr ) ) { hr = pCPC->FindConnectionPoint( IID_ITTAPIEventNotification, &pCP ); pCPC->Release(); } if ( SUCCEEDED( hr ) ) { hr = pCP->Advise( m_pTAPIEventNotification, &m_ulAdvise ); pCP->Release(); } return hr; } /* COperator::RegisterTapiEventInterface */
VOID WindCppAPIImp::release() { if (m_pDWindData != NULL) { cancelAllRequest(); HRESULT hr = E_FAIL; IConnectionPointContainer *pCPC; hr = m_pDWindData.QueryInterface(IID_IConnectionPointContainer, (void **)&pCPC); if(SUCCEEDED(hr)) { IConnectionPoint *pCP; hr = pCPC->FindConnectionPoint(__uuidof(WindDataCOMLib::_DWindDataCOMEvents), &pCP); if (SUCCEEDED(hr)) { hr = pCP->Unadvise(m_dwAdvise); pCP->Release(); } pCPC->Release(); } m_pDWindData.Release(); m_pDWindData = NULL; if (m_pSink != NULL) { delete m_pSink; m_pSink = NULL; } m_dwAdvise = 0; } }
void CWebWindow::Unadvise() { IConnectionPointContainer* pCPContainer = NULL; IConnectionPointPtr m_pSessionConnectionPoint; HRESULT hr = m_pWebCustomizer->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPContainer); if (pCPContainer) { hr = pCPContainer->FindConnectionPoint(__uuidof(_IMpaWebCustomizerEvents),&m_pSessionConnectionPoint); if(SUCCEEDED(hr)) { // LPUNKNOWN pInterEvent = m_MpaWebEvent.GetInterface(&IID_IUnknown); // hr = m_pSessionConnectionPoint->Advise(pInterEvent ,&m_dwSessionCookie); hr = m_pSessionConnectionPoint->Unadvise(m_dwSessionCookie); pCPContainer->Release(); } else { ASSERT(FALSE); } } else { ASSERT(FALSE); } }
// unadvise the world without decrementing the reference count of the client. //reduces refcount of pworld by 1. void DeleteWorld(IWorld* pWorld, DWORD dwCookie) { IConnectionPoint* pconnpt = NULL; IConnectionPointContainer* pconnptctr = NULL; if (pWorld == NULL) return; HRESULT hr = pWorld->QueryInterface(IID_IConnectionPointContainer, (LPVOID*)&pconnptctr); if (SUCCEEDED(hr)) { hr = pconnptctr->FindConnectionPoint(IID_IVWObjectSite, &pconnpt); if (SUCCEEDED(hr)) { // HACK: artificially addref ptr IUnknown* p = (IUnknown *)dwCookie; p->AddRef(); pconnpt->Unadvise(dwCookie); pconnpt->Release(); } pconnptctr->Release(); } pWorld->Terminate(); // REVIEW: let caller SAFERELEASE ptr rather than do it in here // SAFERELEASE(pWorld); }
BOOL CXTPReportDataManager::DataBind() { HRESULT hr = E_FAIL; try { if (m_pDataSource == NULL) return FALSE; m_pConnection = NULL; // get connection _variant_t vtConnection; if (SUCCEEDED(hr = m_pDataSource->get_ActiveConnection(&vtConnection)) && vtConnection.pdispVal) { m_pConnection = vtConnection; } // clear report control ClearReportControl(); // create columns if (FAILED(hr = CreateColumns())) return FALSE; // create records if (FAILED(hr = AddReportRecords(m_pDataSource, FALSE))) return FALSE; m_pReportControl->Populate(); // advise events m_pRstEvent = new CRstEvent(this); if (!m_pRstEvent) return FALSE; IUnknown *pUnk = NULL; hr = m_pRstEvent->QueryInterface(__uuidof(IUnknown), (void **) &pUnk); if (FAILED(hr)) return FALSE; IConnectionPointContainer *pCPC = NULL; IConnectionPoint *pCP = NULL; hr = m_pDataSource->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC); if (FAILED(hr)) return FALSE; hr = pCPC->FindConnectionPoint(__uuidof(XTPREPORTADODB::RecordsetEvents), &pCP); pCPC->Release(); if (FAILED(hr)) return FALSE; hr = pCP->Advise(pUnk, &m_dwRstEvent); pCP->Release(); } catch(_com_error &e) { TRACE_ProviderError(m_pConnection); TRACE_ComError(e); hr = FAILED(hr) ? hr : E_FAIL; } catch(...) { TRACE(_T("Unknown error in DataBind()\n")); hr = FAILED(hr) ? hr : E_FAIL; } return FAILED(hr) ? FALSE : TRUE; }
HRESULT CSoftHIDInputKbdMapper::SetupEventSink ( IUnknown *punkObject, IUnknown *punkSink, REFIID iidConnectionPoint, IConnectionPoint *&rpiConnectionPoint, DWORD &rdwCookie ) /*++ Routine Description: If punkObject is non-NULL installs event sink on specific connection point and returns IConnectionPoint and cookie. Arguments: punkObject - IUnknown on object punkSink - IUnknown of event sink to install iidConnectionPoint - IID of desired connection point rpiConnectionPoint - connection point returned here rdwCookie - connection point cookie returned here Synchronization: None Return value: S_OK - success other - from called routines --*/ { HRESULT hr = S_OK; IConnectionPointContainer *piConnectionPointContainer = NULL; rpiConnectionPoint = NULL; rdwCookie = 0; IfFalseHrGo(NULL != punkObject, S_OK); IfFailHrGo(punkObject->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void **>(&piConnectionPointContainer))); IfFailHrGo(piConnectionPointContainer->FindConnectionPoint(iidConnectionPoint, &rpiConnectionPoint)); IfFailHrGo(rpiConnectionPoint->Advise(punkSink, &rdwCookie)); Exit: if (FAILED(hr)) { RELEASE(rpiConnectionPoint); rdwCookie = 0; } RELEASE(piConnectionPointContainer); return hr; }
// Set up the connection to a manipulation or inertia processor BOOL CManipulationEventSink::SetupConnPt(IUnknown *manipulationProc) { BOOL success = FALSE; IConnectionPointContainer* pConPointContainer = NULL; // Only connect if there isn't already an active connection if (m_pConnPoint == NULL) { // Check if supports connectable objects success = SUCCEEDED(manipulationProc->QueryInterface(IID_IConnectionPointContainer, (LPVOID*)&(pConPointContainer))); // Get connection point interface if(success) { success = SUCCEEDED(pConPointContainer->FindConnectionPoint( _uuidof(_IManipulationEvents), &(m_pConnPoint))); } // Clean up connection point container if (pConPointContainer != NULL) { pConPointContainer->Release(); pConPointContainer = NULL; } // Hook event object to the connection point IUnknown* pUnk = NULL; if(success) { // Get pointer to manipulation event sink's IUnknown pointer success = SUCCEEDED(QueryInterface(IID_IUnknown, (LPVOID*)&pUnk)); } // Establish connection point to callback interface if(success) { success = SUCCEEDED(m_pConnPoint->Advise(pUnk, &(m_uID))); } // Clean up IUnknown pointer if(pUnk != NULL) { pUnk->Release(); } if (!success && m_pConnPoint != NULL) { m_pConnPoint->Release(); m_pConnPoint = NULL; } } return success; }
BOOL ZDrOleClient::InterfaceConnect( IUnknown *pObj, REFIID riid, IUnknown *pIUnknownSink, LPDWORD pdwConn ) { TraceLineS( "ZDrOleClient::InterfaceConnect", "" ); HRESULT hr; IConnectionPointContainer *pCPointContainer = 0; IConnectionPoint *pCPoint = 0; if ( pObj == 0 || pIUnknownSink == 0 || pdwConn == 0 ) return( FALSE ); hr = pObj->QueryInterface( IID_IConnectionPointContainer, (LPVOID *) &pCPointContainer ); if ( FAILED( hr ) ) return( FALSE ); hr = pCPointContainer->FindConnectionPoint( riid, &pCPoint ); if ( SUCCEEDED( hr ) ) { hr = pCPoint->Advise( pIUnknownSink, pdwConn ); if ( hr == E_POINTER ) AfxMessageBox( "Invalid Pointer!" ); else if ( hr == CONNECT_E_ADVISELIMIT ) AfxMessageBox( "No more Connections available!" ); else if ( hr == CONNECT_E_CANNOTCONNECT ) AfxMessageBox( "No Connection!" ); pCPoint->Release( ); } else { if ( hr == E_OUTOFMEMORY ) TraceLineS( "FindConnectionPoint failed: ", "E_OUTOFMEMORY" ); else if ( hr == E_UNEXPECTED ) TraceLineS( "FindConnectionPoint failed: ", "E_UNEXPECTED" ); else if ( hr == E_POINTER ) TraceLineS( "FindConnectionPoint failed: ", "E_POINTER" ); else if ( hr == CONNECT_E_NOCONNECTION ) TraceLineS( "FindConnectionPoint failed: ", "CONNECT_E_NOCONNECTION" ); else if ( hr == S_OK ) TraceLineS( "FindConnectionPoint failed: ", "S_OK" ); else TraceLineX( "FindConnectionPoint failed: ", (zLONG) hr ); } pCPointContainer->Release( ); return( SUCCEEDED( hr ) ); } // InterfaceConnect
static void initEventHandler() { IConnectionPointContainer* icpc; iTunes->QueryInterface(IID_IConnectionPointContainer, (void **)&icpc); IConnectionPoint* icp; icpc->FindConnectionPoint(DIID__IiTunesEvents, &icp); icpc->Release(); DWORD dwAdvise; iTunesEventHandler = new CiTunesEventHandler(); icp->Advise(iTunesEventHandler, &dwAdvise); icp->Release(); }
/* ** Constructor. ** */ PlayerITunes::CEventHandler::CEventHandler(PlayerITunes* player) : m_Player(player), m_RefCount(), m_ConnectionPoint(), m_ConnectionCookie() { IConnectionPointContainer* icpc; m_Player->m_iTunes->QueryInterface(IID_IConnectionPointContainer, (void**)&icpc); icpc->FindConnectionPoint(DIID__IiTunesEvents, &m_ConnectionPoint); m_ConnectionPoint->Advise(this, &m_ConnectionCookie); icpc->Release(); }
BOOL WindCppAPIImp::initialize() { if (m_pDWindData != NULL) { return TRUE; } HRESULT hr = E_FAIL; hr = m_pDWindData.CreateInstance(__uuidof(WindDataCOMLib::WindDataCOM), NULL, CLSCTX_ALL); if(!SUCCEEDED(hr)) { return FALSE; } m_pDWindData->enableAsyn(1); IConnectionPointContainer *pCPC; hr = m_pDWindData.QueryInterface(IID_IConnectionPointContainer, (void **)&pCPC); if(!SUCCEEDED(hr)) { return FALSE; } IConnectionPoint *pCP; hr = pCPC->FindConnectionPoint(__uuidof(WindDataCOMLib::_DWindDataCOMEvents), &pCP); if (!SUCCEEDED(hr)) { return FALSE; } pCPC->Release(); IUnknown *m_pSinkUnk; m_pSink = new WindDataComSink(); hr = m_pSink->QueryInterface(IID_IUnknown, (void **)&m_pSinkUnk); if(!SUCCEEDED(hr)) { pCP->Release(); return FALSE; } hr = pCP->Advise(m_pSinkUnk, &m_dwAdvise); if(!SUCCEEDED(hr)) { return FALSE; } pCP->Release(); return TRUE; }
// Connects CManipulationEventSink object to ManipulationProcessor. // in: // pManipulationProcessor - pointer to the IManipulationProcessor to connect to // returns: // success status, true if the connection is established, false on failure bool CManipulationEventSink::Connect(IManipulationProcessor* pManipulationProcessor) { // Check input arguments if (pManipulationProcessor == NULL) { ASSERT((pManipulationProcessor != NULL) && L"CManipulationEventSink::Create : incorrect arguments"); return false; } // Check object state if ((m_dwCookie != 0) || (m_pConnection != NULL)) { ASSERT((m_dwCookie == 0) && (m_pConnection == NULL) && L"CManipulationEventSink::Connect : connection already established"); return false; } // Get the container with the connection points. IConnectionPointContainer* pConnectionContainer = NULL; HRESULT hr = pManipulationProcessor->QueryInterface(&pConnectionContainer); if (FAILED(hr)) { ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to get the container with the connection points"); return false; } // Get a connection point. hr = pConnectionContainer->FindConnectionPoint(__uuidof(_IManipulationEvents), &m_pConnection); if (FAILED(hr)) { ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to get a connection point"); pConnectionContainer->Release(); return false; } // Release the connection container. pConnectionContainer->Release(); // Advise. Establishes an advisory connection between the connection point and the // caller's sink object. hr = m_pConnection->Advise(this, &m_dwCookie); if (FAILED(hr)) { ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to Advise"); m_pConnection->Release(); m_pConnection = NULL; return false; } return true; }
HRESULT WebHelper::Init(DispatchCallback *pCallback) { m_pDispatchCB = pCallback; IConnectionPointContainer *pCPContainer = NULL; HWND hwndBrowser = NULL; // Create the InternetExplorer object. HRESULT hr = CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_ALL, IID_IWebBrowser2, (void**)&m_pBrowser); LOG_MSG_IF_FAILED(L"CoCreateInstance(CLSID_InternetExplorer)", hr); // Set up the connection point so that we receive events. if (SUCCEEDED(hr)) { hr = m_pBrowser->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPContainer); LOG_MSG_IF_FAILED(L"QueryInterface for IConnectionPointContainer)", hr); } if (SUCCEEDED(hr)) { hr = pCPContainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_pCP); LOG_MSG_IF_FAILED(L"FindConnectionPoint)", hr); } if (SUCCEEDED(hr)) { hr = m_pCP->Advise(this, &m_dwCookie); LOG_MSG_IF_FAILED(L"Advise)", hr); } if (SUCCEEDED(hr)) { hr = m_pBrowser->get_HWND((SHANDLE_PTR*)&hwndBrowser); } // Move the browser window to the front. if (SUCCEEDED(hr)) { SetWindowPos(hwndBrowser, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); } SAFE_RELEASE(pCPContainer); return hr; }
/****************************************************************** * CHandler::SinkEvents() * * Sets up the Click event sink and saves a pointer to the * IConnectionPoint for the button. The sink should be freed before * the application is released. * ******************************************************************/ HRESULT CHandler::SinkEvents(LPDISPATCH pObject) { HRESULT hr; // Get server's IConnectionPointContainer interface. IConnectionPointContainer* pCPC; hr = pObject->QueryInterface(IID_IConnectionPointContainer, (void **)&pCPC); if (SUCCEEDED(hr)) { // Find connection point for events we're interested in. hr = pCPC->FindConnectionPoint(m_riid, &m_pConnection); if (SUCCEEDED(hr)) { hr = m_pConnection->Advise(static_cast<IDispatch*>(this), &m_dwCookie); } // Release the IConnectionPointContainer pCPC->Release(); } return hr; }
void CIncrementSystemBFDlg::ConnectButton1(IHTMLElement *pButtonElem) { HRESULT hr = 0; IConnectionPointContainer* pCPC = NULL; IConnectionPoint* pCP = NULL; IUnknown* pUnk = NULL; DWORD dwCookie; // Check that this is a connectable object. hr = pButtonElem->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC); if (hr == S_OK) { //AfxMessageBox("ConnectionPointContainer"); // Find the connection point. IEnumConnectionPoints *ppEnum=NULL; hr=pCPC->EnumConnectionPoints(&ppEnum); // ppEnum->Next() // if( hr == S_OK) { //ppEnum->Next() } hr = pCPC->FindConnectionPoint(DIID_HTMLinputTextElementEvents2/*DIID_HTMLButtonElementEvents2*/, &pCP); // hr = pCPC->FindConnectionPoint(__uuidof(IID_HTMLElementEvents2)/*DIID_HTMLButtonElementEvents2*/, &pCP); if ( SUCCEEDED(hr)) { //AfxMessageBox( "Find connection point "); // Advise the connection point. // pUnk is the IUnknown interface pointer for your event sink //CDHTMLEventSink* pSink = new CDHTMLEventSink;// CMyEventSink;// ; //pSink->SetParent(this); //IUnknown* pUnk = pSink->GetInterface(&IID_IUnknown); CMyEventSink* pSink = new CMyEventSink; hr = pCP->Advise(pSink, &dwCookie); pCP->Release(); } pCPC->Release(); } }
// This is called by us to get a connection to IE and start handling IE events void CObjectWithSite::ConnectEventSink() { HRESULT hr; IConnectionPointContainer* pCPC; if(pSite==NULL) return; // If we don't have a site, don't do anything // Get an IConnectionPointContainer interface pointer from the site hr=pSite->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPC); if(FAILED(hr)) return; // If we couldn't get it, abort // Now we use the IConnectionPointContainer interface to get an IConnectionPoint interface pointer that will handle DWebBrowserEvents2 "dispatch interface" events. // That means we have to plug our implementation of DWebBrowserEvents2 into the returned IConnectionPoint interface using its Advise() method, as below hr=pCPC->FindConnectionPoint(DIID_DWebBrowserEvents2,&pCP); if(FAILED(hr)) { // If it failed, release the pCPC interface pointer and abort pCPC->Release(); return; } // Finally we can plug our event handler object EventSink into the connection point and start receiving IE events // The advise cookie is just a return value we use when we want to "unplug" our event handler object from the connection point pCP->Advise((IUnknown*)&EventSink,&adviseCookie); }
/****************************************************************************** * AttachToSource -- This method attaches to an event source. ******************************************************************************/ STDMETHODIMP CPartProgramSink::AttachToSource( IUnknown* pEventSource ) { HRESULT hr = S_OK; IConnectionPointContainer* pCPC = NULL; hr = pEventSource->QueryInterface( IID_IConnectionPointContainer, (void**)&pCPC ); if (SUCCEEDED(hr)){ hr = pCPC->FindConnectionPoint( __uuidof(PCDLRN::IApplicationEvents), &m_pConnectionPoint ); if (SUCCEEDED(hr)){ hr = m_pConnectionPoint->Advise( this, &m_dwConnection ); } pCPC->Release(); } return hr; }
void CXTPReportDataManager::RemoveDataSource() { try { // unadvise events if (m_pRstEvent) { IConnectionPointContainer *pCPC = NULL; IConnectionPoint *pCP = NULL; HRESULT hr = m_pDataSource->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC); if (SUCCEEDED(hr)) { hr = pCPC->FindConnectionPoint(__uuidof(XTPREPORTADODB::RecordsetEvents), &pCP); pCPC->Release(); if (SUCCEEDED(hr)) { hr = pCP->Unadvise(m_dwRstEvent); pCP->Release(); } } //delete m_pRstEvent; m_pRstEvent->Release(); m_pRstEvent = NULL; } // set data source pointer to NULL m_pDataSource = NULL; } catch(_com_error &e) { TRACE_ProviderError(m_pConnection); TRACE_ComError(e); } catch(...) { TRACE(_T("Unknown error in RemoveDataSource()\n")); } }
void createBrowser() { createControl (&CLSID_WebBrowser); browser = (IWebBrowser2*) queryInterface (&IID_IWebBrowser2); IConnectionPointContainer* connectionPointContainer = (IConnectionPointContainer*) queryInterface (&IID_IConnectionPointContainer); if (connectionPointContainer != nullptr) { connectionPointContainer->FindConnectionPoint (DIID_DWebBrowserEvents2, &connectionPoint); if (connectionPoint != nullptr) { WebBrowserComponent* const owner = dynamic_cast <WebBrowserComponent*> (getParentComponent()); jassert (owner != nullptr); EventHandler* handler = new EventHandler (*owner); connectionPoint->Advise (handler, &adviseCookie); handler->Release(); } } }
void tLuaCOM::releaseConnection(tLuaCOM* server, DWORD cookie) { IConnectionPointContainer *pcpc = NULL; IConnectionPoint *connection_point; HRESULT hr = pdisp->QueryInterface ( IID_IConnectionPointContainer, (void **) &pcpc ); if(FAILED(hr)) { LUACOM_ERROR("Object does not accept connections!"); } { IID guid; server->GetIID(&guid); hr = pcpc->FindConnectionPoint(guid, &connection_point); } pcpc->Release(); pcpc = NULL; if(FAILED(hr)) { LUACOM_ERROR("No connection point for this interface!"); } connection_point->Unadvise(cookie); connection_point->Release(); connection_point = NULL; }
void CInviteChatDlg::CloseMpaWebEvent() { IConnectionPointContainer* pCPContainer = NULL; CComPtr<IConnectionPoint> m_pSessionConnectionPoint; HRESULT hr = m_pWebCustomizer->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPContainer); if (pCPContainer) { hr = pCPContainer->FindConnectionPoint(__uuidof(_IMpaWebCustomizerEvents),&m_pSessionConnectionPoint); if(SUCCEEDED(hr)) { hr = m_pSessionConnectionPoint->Unadvise(m_dwSessionCookie); pCPContainer->Release(); } else { ASSERT(FALSE); } } else { ASSERT(FALSE); } }
HRESULT UnRegisterCallBack() { LogMessage("UnRegisterCallBack: started"); HRESULT hr = S_OK; // // get connection point container on the tapi object // IConnectionPointContainer *pCPContainer = NULL; hr = g_pTapi->QueryInterface(IID_IConnectionPointContainer, (void **)&pCPContainer); if (FAILED(hr)) { LogError("UnRegisterCallBack: " "Failed to get IConnectionPointContainer on TAPI"); return hr; } // // find connection point for our interface // IConnectionPoint *pConnectionPoint = NULL; hr = pCPContainer->FindConnectionPoint(IID_ITTAPIEventNotification, &pConnectionPoint); pCPContainer->Release(); pCPContainer = NULL; if (FAILED(hr)) { LogError("RegisterCallback: Failed to get a connection point for " "ITTAPIEventNotification"); return hr; } // // unregister the callback // hr = pConnectionPoint->Unadvise(g_nTAPINotificationCookie); pConnectionPoint->Release(); pConnectionPoint = NULL; g_nTAPINotificationCookie = 0; if (FAILED(hr)) { LogError("UnRegisterCallBack: Unadvise failed"); } else { LogMessage("UnRegisterCallBack: succeeded"); } return hr; }
// Initialize this print job checker by registering a print document package target. // This is required before the application can use this print job checker to monitor a print job. HRESULT D2DPrintJobChecker::Initialize( _In_ IPrintDocumentPackageTarget* documentPackageTarget ) { // Application can only initialize this job checker once. if (m_isInitialized) { return E_FAIL; } HRESULT hr = (documentPackageTarget != nullptr) ? S_OK : E_INVALIDARG; IConnectionPointContainer* connectionPointContainer = nullptr; if (SUCCEEDED(hr)) { hr = documentPackageTarget->QueryInterface(IID_PPV_ARGS(&connectionPointContainer)); } if (SUCCEEDED(hr)) { hr = connectionPointContainer->FindConnectionPoint( __uuidof(IPrintDocumentPackageStatusEvent), &m_connectionPoint ); } IUnknown* unknownEvent = nullptr; if (SUCCEEDED(hr)) { hr = this->QueryInterface(IID_PPV_ARGS(&unknownEvent)); } if (SUCCEEDED(hr)) { hr = m_connectionPoint->Advise(unknownEvent, &m_eventCookie); } // Create an event handle for print job completion. if (SUCCEEDED(hr)) { m_completionEvent = ::CreateEvent( nullptr, // The handle cannot be inherited by child processes. TRUE, // The event object requires the use of the ResetEvent function to set the event state to nonsignaled. FALSE, // The initial state of the event object is nonsignaled. nullptr // Name of the event object. ); hr = (!m_completionEvent) ? HRESULT_FROM_WIN32(::GetLastError()) : hr; } if (unknownEvent) { unknownEvent->Release(); unknownEvent = nullptr; } if (connectionPointContainer) { connectionPointContainer->Release(); connectionPointContainer = nullptr; } if (SUCCEEDED(hr)) { m_isInitialized = true; } else { ReleaseResources(); } return hr; }
IEView::IEView(HWND parent, HTMLBuilder* builder, int x, int y, int cx, int cy) { MSG msg; IOleObject* pOleObject = NULL; IOleInPlaceObject *pOleInPlace; this->parent = parent; this->builder = builder; this->smileyWindow = NULL; prev = next = NULL; hwnd = NULL; sink = NULL; pWebBrowser = NULL; m_pConnectionPoint = NULL; m_cRef = 0; #ifdef GECKO if (SUCCEEDED(CoCreateInstance(CLSID_MozillaBrowser, NULL, CLSCTX_INPROC, IID_IWebBrowser2, (LPVOID*)&pWebBrowser))) { #else if (SUCCEEDED(CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_INPROC, IID_IWebBrowser2, (LPVOID*)&pWebBrowser))) { #endif // pWebBrowser->put_RegisterAsBrowser(VARIANT_FALSE); // pWebBrowser->put_RegisterAsDropTarget(VARIANT_FALSE); if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IOleObject, (void**)&pOleObject))) { rcClient.left = x; rcClient.top = y; rcClient.right = x + cx; rcClient.bottom = y + cy; pOleObject->SetClientSite(this); pOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, &msg, this, 0, parent, &rcClient); pOleObject->Release(); } else { MessageBox(NULL,"IID_IOleObject failed.","RESULT",MB_OK); } if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IOleInPlaceObject, (void**)&pOleInPlace))) { pOleInPlace->GetWindow(&hwnd); pOleInPlace->Release(); } else { MessageBox(NULL,"IID_IOleInPlaceObject failed.","RESULT",MB_OK); } LONG style = GetWindowLong(hwnd, GWL_EXSTYLE); style |= (WS_EX_STATICEDGE); SetWindowLong(hwnd,GWL_EXSTYLE,style); IConnectionPointContainer* pCPContainer; // Step 1: Get a pointer to the connection point container. if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPContainer))) { // m_pConnectionPoint is defined like this: // Step 2: Find the connection point. if (SUCCEEDED(pCPContainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_pConnectionPoint))) { // Step 3: Advise the connection point that you // want to sink its events. sink = new IEViewSink(); #ifndef GECKO if (FAILED(m_pConnectionPoint->Advise((IUnknown *)sink, &m_dwCookie))) { MessageBox(NULL, "Failed to Advise", "C++ Event Sink", MB_OK); } #endif } pCPContainer->Release(); } #ifndef GECKO setUserWndProc((WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (LONG) IEViewWindowProcedure)); #endif } EnterCriticalSection(&mutex); next = list; if (next != NULL) { next->prev = this; } list = this; LeaveCriticalSection(&mutex); clear(); } IEView::IEView(HWND parent, SmileyWindow* smileyWindow, int x, int y, int cx, int cy) { MSG msg; IOleObject* pOleObject = NULL; IOleInPlaceObject *pOleInPlace; this->parent = parent; builder = NULL; this->smileyWindow = smileyWindow; prev = next = NULL; hwnd = NULL; sink = NULL; pWebBrowser = NULL; m_pConnectionPoint = NULL; m_cRef = 0; #ifdef GECKO if (SUCCEEDED(CoCreateInstance(CLSID_MozillaBrowser, NULL, CLSCTX_INPROC, IID_IWebBrowser2, (LPVOID*)&pWebBrowser))) { #else if (SUCCEEDED(CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_INPROC, IID_IWebBrowser2, (LPVOID*)&pWebBrowser))) { #endif // pWebBrowser->put_RegisterAsBrowser(VARIANT_FALSE); // pWebBrowser->put_RegisterAsDropTarget(VARIANT_FALSE); if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IOleObject, (void**)&pOleObject))) { rcClient.left = x; rcClient.top = y; rcClient.right = x + cx; rcClient.bottom = y + cy; pOleObject->SetClientSite(this); pOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, &msg, this, 0, parent, &rcClient); pOleObject->Release(); } else { MessageBox(NULL,"IID_IOleObject failed.","RESULT",MB_OK); } if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IOleInPlaceObject, (void**)&pOleInPlace))) { pOleInPlace->GetWindow(&hwnd); pOleInPlace->Release(); } else { MessageBox(NULL,"IID_IOleInPlaceObject failed.","RESULT",MB_OK); } IConnectionPointContainer* pCPContainer; // Step 1: Get a pointer to the connection point container. if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPContainer))) { // m_pConnectionPoint is defined like this: // Step 2: Find the connection point. if (SUCCEEDED(pCPContainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_pConnectionPoint))) { // Step 3: Advise the connection point that you // want to sink its events. sink = new IEViewSink(smileyWindow); #ifndef GECKO if (FAILED(m_pConnectionPoint->Advise((IUnknown *)sink, &m_dwCookie))) { MessageBox(NULL, "Failed to Advise", "C++ Event Sink", MB_OK); } #endif } pCPContainer->Release(); } } clear(); } IEView::~IEView() { IOleObject* pOleObject = NULL; if (SUCCEEDED(pWebBrowser->QueryInterface(IID_IOleObject, (void**)&pOleObject))) { pOleObject->SetClientSite(NULL); pOleObject->Release(); } else { MessageBox(NULL,"IID_IOleObject failed.","RESULT",MB_OK); } EnterCriticalSection(&mutex); if (list == this) { list = next; } else if (prev!=NULL) { prev->next = next; } if (next != NULL) { next->prev = prev; } LeaveCriticalSection(&mutex); if (builder != NULL) { delete builder; builder = NULL; } if (m_pConnectionPoint != NULL) { m_pConnectionPoint->Unadvise(m_dwCookie); m_pConnectionPoint->Release(); } if (sink != NULL) { delete sink; } pWebBrowser->Release(); DestroyWindow(hwnd); } void IEView::setUserWndProc(WNDPROC wndProc) { userWndProc = wndProc; } WNDPROC IEView::getUserWndProc() { return userWndProc; } // IUnknown STDMETHODIMP IEView::QueryInterface(REFIID riid, PVOID *ppv) { *ppv=NULL; if (IID_IUnknown==riid) *ppv=this; if (IID_IOleClientSite==riid) *ppv=(IOleClientSite*)this;//Unknown)m_pIOleClientSite; if (IID_IOleWindow==riid || IID_IOleInPlaceSite==riid) *ppv=(IOleInPlaceSite*)this;//m_pIOleIPSite; if (IID_IDocHostUIHandler==riid) *ppv=(IDocHostUIHandler*)this;//m_pIOleIPSite; if (NULL!=*ppv) { ((LPUNKNOWN)*ppv)->AddRef(); return NOERROR; } return E_NOINTERFACE; }