void CGNetUpdater::Init()
{
CheckHR(m_pMasterServer.CreateInstance(__uuidof(SHAREDLib::RemoteMasterServer)));
CheckHR(AtlAdvise(m_pMasterServer, (IGameEvents *) this, IID_IRemoteMasterServerEvents, &m_dwMasterServerCookie));
CheckHR(AtlAdvise(m_pMasterServer, (IGameEvents *) this, IID_IGameEvents, &m_dwMasterServerCookie2));
}
STDMETHODIMP CSOActiveX::SetClientSite( IOleClientSite* aClientSite )
{
HRESULT hr = IOleObjectImpl<CSOActiveX>::SetClientSite( aClientSite );
if( !aClientSite )
{
ATLASSERT( mWebBrowser2 );
if( mWebBrowser2 )
AtlUnadvise( mWebBrowser2, DIID_DWebBrowserEvents2, mCookie );
return hr;
}
CComPtr<IOleContainer> aContainer;
m_spClientSite->GetContainer( &aContainer );
ATLASSERT( aContainer );
if( SUCCEEDED( hr ) && aContainer )
{
CComQIPtr<IServiceProvider, &IID_IServiceProvider> aServiceProvider( aContainer );
ATLASSERT( aServiceProvider );
if( aServiceProvider )
{
aServiceProvider->QueryService( SID_SInternetExplorer,
IID_IWebBrowser,
(void**)&mWebBrowser2 );
ATLASSERT( mWebBrowser2 );
if( mWebBrowser2 )
AtlAdvise( mWebBrowser2, GetUnknown(), DIID_DWebBrowserEvents2, &mCookie );
}
}
return hr;
}
void CImpCEDL::CreateEvntSink(void) throw()
{
if(m_pEvents) {//already an event interface created ?
return; //yes, don't worry just use the existing one.
}
//initalize Event interface now
HRESULT hr = CComObject<CImpDLEvents>::CreateInstance(&m_pEvents);
if(FAILED(hr)) {
ComThrow(GetObjectCLSID(),__uuidof(IDLEvents),hr);
}
m_pEvents->AddRef(); //stay with one reference
hr = AtlAdvise(GetUnknown(),m_pEvents->GetUnknown(),
IID_IDLEvents, &m_dwEvents);
if(FAILED(hr)) {
FC_DEBUGPRINT1(_T("CEDL> Advise failed hr=0x%x\n"),hr);
m_dwEvents = 0;
m_pEvents->Release();
m_pEvents = NULL;
ComThrow(GetObjectCLSID(),__uuidof(IDLEvents),hr);
}
}
HRESULT STDMETHODCALLTYPE CBrandBand::SetSite(IUnknown* pUnkSite)
{
CComPtr<IBrowserService> browserService;
CComPtr<IOleWindow> oleWindow;
CComPtr<IServiceProvider> serviceProvider;
CComPtr<IProfferService> profferService;
HWND parentWindow;
HWND hwnd;
HRESULT hResult;
fSite.Release();
if (pUnkSite == NULL)
{
hResult = AtlUnadvise(fSite, DIID_DWebBrowserEvents, fAdviseCookie);
// TODO: revoke brand band service
return S_OK;
}
// get window handle of parent
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &fSite));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
parentWindow = NULL;
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &oleWindow));
if (SUCCEEDED(hResult))
hResult = oleWindow->GetWindow(&parentWindow);
if (!::IsWindow(parentWindow))
return E_FAIL;
// create worker window in parent window
hwnd = SHCreateWorkerWindowW(0, parentWindow, 0,
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, NULL, 0);
if (hwnd == NULL)
return E_FAIL;
SubclassWindow(hwnd);
// take advice to watch events
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
if (SUCCEEDED(hResult))
{
hResult = serviceProvider->QueryService(
SID_SBrandBand, IID_PPV_ARG(IProfferService, &profferService));
if (SUCCEEDED(hResult))
hResult = profferService->ProfferService(SID_SBrandBand,
static_cast<IServiceProvider *>(this), &fProfferCookie);
hResult = serviceProvider->QueryService(SID_SShellBrowser,
IID_PPV_ARG(IBrowserService, &browserService));
if (SUCCEEDED(hResult))
hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
}
// ignore any hResult errors up to here - they are nonfatal
hResult = S_OK;
SelectImage();
return hResult;
}
STDMETHODIMP CUpdateIssueService::OnInitialized(IServiceProvider *pServiceProvider)
{
CHECK_E_POINTER(pServiceProvider);
CComPtr<IUnknown> pUnk;
RETURN_IF_FAILED(QueryInterface(__uuidof(IUnknown), (LPVOID*)&pUnk));
RETURN_IF_FAILED(pServiceProvider->QueryService(CLSID_ThreadService, &m_pThreadService));
RETURN_IF_FAILED(AtlAdvise(m_pThreadService, pUnk, __uuidof(IThreadServiceEventSink), &m_dwAdvice));
RETURN_IF_FAILED(pServiceProvider->QueryService(CLSID_TimerService, &m_pTimerService));
return S_OK;
}
HRESULT DWebBrowserEventsImpl::Connect(IWebBrowser2 * pWB)
{
HRESULT hr = S_OK;
m_spWebBrowser = pWB;
if (!m_spWebBrowser)
return hr;
hr = AtlAdvise(m_spWebBrowser, (IDispatch*)this, __uuidof(DWebBrowserEvents2), &m_dwCookie);
return hr;
}
static void test_cp(void)
{
DWORD cookie = 0;
HRESULT hres;
hres = AtlAdvise(NULL, (IUnknown*)0xdeed0000, &CLSID_Test, &cookie);
ok(hres == E_INVALIDARG, "expect E_INVALIDARG, returned %08x\n", hres);
hres = AtlUnadvise(NULL, &CLSID_Test, 0xdeadbeef);
ok(hres == E_INVALIDARG, "expect E_INVALIDARG, returned %08x\n", hres);
hres = AtlAdvise((IUnknown*)&ConnectionPointContainer, (IUnknown*)0xdead0000, &CLSID_Test, &cookie);
ok(hres == S_OK, "AtlAdvise failed: %08x\n", hres);
ok(cookie == 0xdeadbeef, "cookie = %x\n", cookie);
ok(advise_cnt == 1, "advise_cnt = %d\n", advise_cnt);
hres = AtlUnadvise((IUnknown*)&ConnectionPointContainer, &CLSID_Test, 0xdeadbeef);
ok(hres == S_OK, "AtlUnadvise failed: %08x\n", hres);
ok(!advise_cnt, "advise_cnt = %d\n", advise_cnt);
}
// Subscribe to an event sink on the control
HRESULT CControlSite::Advise(IUnknown *pIUnkSink, const IID &iid, DWORD *pdwCookie)
{
if (m_spObject == NULL)
{
return E_UNEXPECTED;
}
if (pIUnkSink == NULL || pdwCookie == NULL)
{
return E_INVALIDARG;
}
return AtlAdvise(m_spObject, pIUnkSink, iid, pdwCookie);
}
bool CEventHandler::HookEvent(IUnknown* pSource)
{
#if defined(__USE_ADDBACK_DUAL)
const HRESULT hr = AtlAdvise(pSource, GetUnknown(), __uuidof(IAddBackEvents), &cookie_);
if (FAILED(hr)) return false;
#elif defined(__USE_ADDBACK_DISPATCH)
DispEventAdvise(pSource, &__uuidof(_IAddBackEvents));
#elif defined(__USE_ADDBACK_BYATTRIB_DISPATCH)
__hook(&_IAddBackEvents::ChangedAddEnd, pSource, &CEventHandler::onChangedAddEnd);
__hook(&_IAddBackEvents::ChangedSum, pSource, &CEventHandler::onChangedSum);
#endif
return true;
}
STDMETHODIMP CTimelineLoadingService::OnInitialized(IServiceProvider *pServiceProvider)
{
CHECK_E_POINTER(pServiceProvider);
m_pServiceProvider = pServiceProvider;
CComQIPtr<ITimelineControlSupport> pTimelineControlSupport = m_pControl;
ATLASSERT(pTimelineControlSupport);
RETURN_IF_FAILED(pTimelineControlSupport->GetTimelineControl(&m_pTimelineControl));
CComPtr<IUnknown> pUnk;
RETURN_IF_FAILED(QueryInterface(__uuidof(IUnknown), (LPVOID*)&pUnk));
RETURN_IF_FAILED(pServiceProvider->QueryService(SERVICE_TIMELINE_UPDATE_THREAD, &m_pThreadServiceUpdateService));
RETURN_IF_FAILED(AtlAdvise(m_pThreadServiceUpdateService, pUnk, __uuidof(IThreadServiceEventSink), &m_dwAdviceThreadServiceUpdateService));
RETURN_IF_FAILED(pServiceProvider->QueryService(SERVICE_TIMELINE_SHOWMORE_THREAD, &m_pThreadServiceShowMoreService));
if (m_pThreadServiceShowMoreService)
{
RETURN_IF_FAILED(AtlAdvise(m_pThreadServiceShowMoreService, pUnk, __uuidof(IThreadServiceEventSink), &m_dwAdviceThreadServiceShowMoreService));
}
return S_OK;
}
STDMETHODIMP CTimelineCleanupService::OnInitialized(IServiceProvider *pServiceProvider)
{
CComPtr<IUnknown> pUnk;
RETURN_IF_FAILED(QueryInterface(__uuidof(IUnknown), (LPVOID*)&pUnk));
CComQIPtr<ITimelineControlSupport> pTimelineControlSupport = m_pControl;
ATLASSERT(pTimelineControlSupport);
RETURN_IF_FAILED(pTimelineControlSupport->GetTimelineControl(&m_pTimelineControl));
RETURN_IF_FAILED(pServiceProvider->QueryService(SERVICE_TIMELINE_CLENUP_TIMER, &m_pTimerServiceCleanup));
RETURN_IF_FAILED(AtlAdvise(m_pTimerServiceCleanup, pUnk, __uuidof(ITimerServiceEventSink), &m_dwAdviceTimerServiceCleanup));
RETURN_IF_FAILED(m_pTimerServiceCleanup->StartTimer(1000 * 60)); //1 minute
return S_OK;
}
void CMDriveDlg::OnAdvise()
{
if (m_nAdviseCnt < m_nMaxAdvises)
{
CComObject<CDriver>* pDriver;
CComObject<CDriver>::CreateInstance(&pDriver);
pDriver->m_nID = m_nAdviseCnt;
HRESULT hRes = AtlAdvise(pRandom, pDriver->GetUnknown(), IID_IRandomEvent, &m_arrAdvise[m_nAdviseCnt++]);
if (FAILED(hRes))
{
AfxMessageBox("Advise failed");
m_nAdviseCnt--;
}
}
else
AfxMessageBox("No more advises");
}
HRESULT STDMETHODCALLTYPE CAddressEditBox::Init(HWND comboboxEx, HWND editControl, long param14, IUnknown *param18)
{
CComPtr<IBrowserService> browserService;
fCombobox.SubclassWindow(comboboxEx);
fEditWindow.SubclassWindow(editControl);
fSite = param18;
SHAutoComplete(fEditWindow.m_hWnd, SHACF_FILESYSTEM | SHACF_URLALL | SHACF_USETAB);
// take advice to watch events
HRESULT hResult = IUnknown_QueryService(param18, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
if (SUCCEEDED(hResult))
{
hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
}
return hResult;
}
//------------------------------------------------------------------*
HRESULT CFCMessageSessionThread::DoConnect()
{
HRESULT hr;
if (m_pMessage != NULL)
return S_OK;
TrcPrint(TRC_INTERFACE, _T("MsgSession: DoConnect(%s)\n"),(LPCTSTR) m_pRawMsgSession->m_strMachineName);
hr = ConnectToOnlineServer(&m_pMessage);
if (FAILED(hr))
return hr;
if (m_pMessage == NULL)
return E_FAIL;
hr = m_pMessage->QueryInterface(IID_IConnection,(void**)&m_pCheckConnection);
if (FAILED(hr))
return hr;
hr = Login();
if (FAILED(hr)) {
DoDisconnect();
return hr;
}
hr = AtlAdvise(m_pMessage, GetUnknown(), IID__ICERemoteMessageEvent, &m_dwMsgNotifyCookie);
if (FAILED(hr)) {
DoDisconnect();
return hr;
}
hr = m_pMessage->Connect(m_lKey);
if (FAILED(hr)) {
TRACE(_T("MsgSession::Connected callback: error while trying to connect to message source; 0x%08X\n"), hr);
TrcPrint(TRC_ERROR, _T("MsgSession::Connected callback: error while trying to connect to message source; 0x%08X\n"), hr);
DoDisconnect();
return hr;
}
return hr;
}
CJSProxyObj::CJSProxyObj(CJSExtender* _pJSExtender, IDispatch *pDisp, const GUID iid, CString strPrefix) :
m_dwCookie(0xFEFEFEFE), m_pDisp(pDisp), m_EventIID(iid)
{
m_pEventObj = nullptr;
ITypeInfo* pTypeInfo = nullptr;
m_pJSExtender = _pJSExtender;
if (theApp.m_pEventProxy)
{
m_pEventObj = theApp.m_pEventProxy;
theApp.m_pEventProxy = nullptr;
}
else
{
pDisp->GetTypeInfo(0, GetUserDefaultLCID(), &pTypeInfo);
if (pTypeInfo)
{
CComPtr<ITypeLib> pTypeLib;
UINT nIndex = 0;
pTypeInfo->GetContainingTypeLib(&pTypeLib, &nIndex);
pTypeLib->GetTypeInfoOfGuid(iid, &m_pTypeInfo);
pTypeInfo->Release();
}
}
CString strName = strPrefix;
auto it = m_pJSExtender->m_mapCloudJSObject.find(strName);
if (it != m_pJSExtender->m_mapCloudJSObject.end())
{
int nSize = m_pJSExtender->m_mapCloudJSObject.size();
CString s = _T("");
s.Format(_T("%s_%d_"), strName, nSize);
strName = s;
}
m_bstrPrefix = CComBSTR(strName);
SetEventNames();
m_pJSExtender->m_mapCloudJSObject[strName] = this;
HRESULT hr = AtlAdvise(m_pDisp, this, m_EventIID, &m_dwCookie);
}
HRESULT
CUSBSimEndpoint::InitEvents (void)
{
CComObject < CUSBSimEndpointEvents > *pEvents;
HRESULT hr;
hr = CComObject < CUSBSimEndpointEvents >::CreateInstance (&pEvents);
if (FAILED (hr)) {
TRACE_ERR ("CreateInstance", hr);
} else {
hr = AtlAdvise (m_pSoftUSBEndpoint, pEvents,
__uuidof (ISoftUSBEndpointEvents), &m_dwCookie);
if (FAILED (hr)) {
TRACE_ERR ("AtlAdvise", hr);
pEvents->Release ();
} else {
pEvents->AddRef ();
pEvents->SetEndpoint (this);
m_pEvents = pEvents;
}
}
return hr;
}
//----------------------------------------------------------------------------
// Init
HRESULT CAnchoBackgroundAPI::Init(LPCTSTR lpszThisPath, LPCTSTR lpszRootURL, BSTR bsID, LPCTSTR lpszGUID, LPCTSTR lpszPath)
{
// set our ID
m_bsID = bsID;
m_GUID = lpszGUID;
m_sRootURL = lpszRootURL;
CString sPath(lpszPath);
// create logger window
IF_FAILED_RET(CLogWindow::CreateLogWindow(&m_LogWindow.p));
// create a magpie instance
#ifdef MAGPIE_REGISTERED
IF_FAILED_RET(m_Magpie.CoCreateInstance(CLSID_MagpieApplication));
#else
// Load magpie from the same path where this exe file is.
CString s(lpszThisPath);
s += _T("Magpie.dll");
HMODULE hModMagpie = ::LoadLibrary(s);
if (!hModMagpie)
{
return E_FAIL;
}
fnCreateMagpieInstance CreateMagpieInstance = (fnCreateMagpieInstance)::GetProcAddress(hModMagpie, "CreateMagpieInstance");
if (!CreateMagpieInstance)
{
return E_FAIL;
}
IF_FAILED_RET(CreateMagpieInstance(&m_Magpie));
#endif
// add a loader for scripts in the extension filesystem
IF_FAILED_RET(m_Magpie->AddFilesystemScriptLoader((LPWSTR)(LPCWSTR)sPath));
// add a loder for scripts in this exe file
IF_FAILED_RET(m_Magpie->AddResourceScriptLoader((ULONG)_AtlModule.GetResourceInstance()));
// advise logger
IF_FAILED_RET(AtlAdvise(m_Magpie, (IUnknown*)(CAnchoAddonBackgroundLogger*)(this), DIID__IMagpieLoggerEvents, &m_dwMagpieSinkCookie));
// load manifest
CString sManifestFilename;
sManifestFilename.Format(_T("%smanifest.json"), sPath);
CAtlFile f;
IF_FAILED_RET(f.Create(sManifestFilename, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING));
ULONGLONG nLen = 0;
IF_FAILED_RET(f.GetSize(nLen));
// limit to 4gb
if (nLen > 0x00000000ffffffff)
{
return E_OUTOFMEMORY;
}
DWORD dwLen = (DWORD)nLen;
CStringA sManifest("exports.manifest = ");
DWORD strLen = (DWORD)sManifest.GetLength();
IF_FAILED_RET(f.Read(sManifest.GetBuffer(dwLen + strLen) + strLen, dwLen));
sManifest.ReleaseBuffer(dwLen + strLen);
sManifest += _T(';');
IF_FAILED_RET(m_Magpie->RunScript(L"manifest", (LPWSTR)(LPCWSTR)CA2W(sManifest)));
// set ourselfs in magpie as a global accessible object
IF_FAILED_RET(m_Magpie->AddExtension((LPWSTR)s_AnchoGlobalAPIObjectName, (IAnchoBackgroundAPI*)this));
// initialize Ancho API
// api.js will do now additional initialization, like looking at the manifest
// and creating a background page.
IF_FAILED_RET(m_Magpie->Run((LPWSTR)s_AnchoMainAPIModuleID));
return S_OK;
}
void MonitorFlash(IDispatch *pDisp)
{
if (!pDisp) return;
HRESULT hr = S_OK;
// 使用CFlashSink3, 连接点无法成功Advise, 报错: E_POINTER 0x80004003(无效指针)
/*
EVENT_SINK es;
CFlashSink3* sink3 = new CFlashSink3();
IDispatch* pSinkDisp = NULL;
hr = sink3->QueryInterface(DIID__IShockwaveFlashEvents, reinterpret_cast<void**>(&pSinkDisp));
hr = AtlAdvise(pDisp, sink3, DIID__IShockwaveFlashEvents, &es.dwCookie);
if (SUCCEEDED(hr))
{
es.pUnkSink = pSinkDisp;
es.pUnkSrc = pDisp;
es.iid = DIID__IShockwaveFlashEvents;
CIESeeker::Instance()->AddSink(es);
cout << _T("Advised[DIID__IShockwaveFlashEvents], dwCookie = ") << es.dwCookie << endl;
}
*/
// 使用CFlashSink2, 连接点无法成功Advise, dwCookie = 0. 报错: CONNECT_E_CANNOTCONNECT 0x80040202(无法连接).
// IShockwaveFlashEvents不支持CCmdTarget方式的连接点
/*
EVENT_SINK es;
CFlashSink2* sink2 = new CFlashSink2();
IDispatch* pSinkDisp = sink2->GetIDispatch(FALSE);
//hr = AfxConnectionAdvise(pDisp, DIID__IShockwaveFlashEvents, pSinkDisp, FALSE, &es.dwCookie);
hr = AtlAdvise(pDisp, pSinkDisp, DIID__IShockwaveFlashEvents, &es.dwCookie);
if (hr)
{
es.pUnkSink = pSinkDisp;
es.pUnkSrc = pDisp;
es.iid = DIID__IShockwaveFlashEvents;
CIESeeker::Instance()->AddSink(es);
cout << _T("Advised[DIID__IShockwaveFlashEvents], dwCookie = ") << es.dwCookie << endl;
}
*/
EVENT_SINK es;
CComObject<CFlashSink> *sink = new CComObject<CFlashSink>;
hr = AtlAdvise(pDisp, sink, DIID__IShockwaveFlashEvents, &es.dwCookie);
if (SUCCEEDED(hr))
{
es.pUnkSink = sink;
es.pUnkSrc = pDisp;
es.iid = DIID__IShockwaveFlashEvents;
CIESeeker::Instance()->AddSink(es);
cout << _T("Advised[DIID__IShockwaveFlashEvents], dwCookie = ") << es.dwCookie << endl;
}
/*
IConnectionPointContainer *spCPC = NULL;
IConnectionPoint *spCP = NULL;
//CFlashSunk *sink = new CFlashSunk();
//CComObject<CFlashSunk> *sink = new CComObject<CFlashSunk>();
//DWORD dwCookie = 0;
hr = pDisp->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void**>(&spCPC));
if (SUCCEEDED(hr) && spCPC)
{
cout << _T("Found IHTMLObjectElement>>IConnectionPointContainer!") << endl;
hr = spCPC->FindConnectionPoint(DIID__IShockwaveFlashEvents, &spCP);
if (SUCCEEDED(hr) && spCP)
{
cout << _T("Found IHTMLObjectElement>>IConnectionPointContainer>>IConnectionPoint[DIID__IShockwaveFlashEvents]!") << endl;
hr = spCP->Advise(m_flashSink, &m_flashCookie);
if (SUCCEEDED(hr))
{
cout << _T("Advised[DIID__IShockwaveFlashEvents], dwCookie = ") << m_flashCookie << endl;
}
}
}
*/
//if(spCP) spCP->Release();
//if(spCPC) spCPC->Release();
}
//----------------------------------------------------------------------------
// Init
HRESULT CAnchoRuntime::Init()
{
ATLASSERT(m_spUnkSite);
// get IServiceProvider to get IWebBrowser2 and IOleWindow
CComQIPtr<IServiceProvider> pServiceProvider = m_spUnkSite;
if (!pServiceProvider)
{
return E_FAIL;
}
// get IWebBrowser2
pServiceProvider->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, (LPVOID*)&m_pWebBrowser.p);
if (!m_pWebBrowser) {
return E_FAIL;
}
AtlAdvise(m_pWebBrowser, (IUnknown *)(TWebBrowserEvents *) this, DIID_DWebBrowserEvents2, &m_WebBrowserEventsCookie);
ATLTRACE(L"ANCHO: runtime initialization - CoCreateInstance(CLSID_AnchoAddonService)\n");
// create addon service object
IF_FAILED_RET(m_pAnchoService.CoCreateInstance(CLSID_AnchoAddonService));
CComQIPtr<IAnchoServiceApi> serviceApi = m_pAnchoService;
if (!serviceApi) {
return E_NOINTERFACE;
}
{//Get TabManager
CComQIPtr<IDispatch> dispatch;
IF_FAILED_RET(serviceApi->get_tabManager(&dispatch));
CComQIPtr<IAnchoTabManagerInternal> tabManager = dispatch;
if (!tabManager) {
return E_NOINTERFACE;
}
mTabManager = tabManager;
}
{//Get WindowManager
CComQIPtr<IDispatch> dispatch;
IF_FAILED_RET(serviceApi->get_windowManager(&dispatch));
CComQIPtr<IAnchoWindowManagerInternal> windowManager = dispatch;
if (!windowManager) {
return E_NOINTERFACE;
}
mWindowManager = windowManager;
}
// Registering tab in service - obtains tab id and assigns it to the tab as property
IF_FAILED_RET(mTabManager->registerRuntime((OLE_HANDLE)getFrameTabWindow(), this, m_HeartbeatSlave.id(), &m_TabID));
HWND hwnd;
m_pWebBrowser->get_HWND((SHANDLE_PTR*)&hwnd);
::SetProp(hwnd, s_AnchoTabIDPropertyName, (HANDLE)m_TabID);
//Get WindowId
IF_FAILED_RET(mWindowManager->getWindowIdFromHWND(reinterpret_cast<OLE_HANDLE>(getMainWindow()), &mWindowID));
CComObject<CAnchoBrowserEvents>* pBrowserEventSource;
IF_FAILED_RET(CComObject<CAnchoBrowserEvents>::CreateInstance(&pBrowserEventSource));
m_pBrowserEventSource = pBrowserEventSource;
AtlAdvise(m_pBrowserEventSource, (IUnknown*)(TAnchoBrowserEvents*) this, IID_DAnchoBrowserEvents,
&m_AnchoBrowserEventsCookie);
// Set the sink as property of the browser so it can be retrieved if someone wants to send
// us events.
IF_FAILED_RET(m_pWebBrowser->PutProperty(L"_anchoBrowserEvents", CComVariant(m_pBrowserEventSource)));
ATLTRACE(L"ANCHO: runtime %d initialized\n", m_TabID);
return S_OK;
}
BrowserControlPane::BrowserControlPane(HWND hpwnd, HINSTANCE hInstance, RECT* ipBoundRect)
: hparentwnd(hpwnd)
// 콘트롤 폐인 없음... : ControlPane( ipBoundRect )
{
HRESULT err;
RECT bounds;
TCHAR* sClassName = TEXT("NexonADBrowser");
WNDCLASS windowClass;
CComPtr< IOleObject > pOleObject;
RECT clientRECT;
ASSERT(ipBoundRect != NULL);
this->isActivated = TRUE;
this->allowNewWindow = TRUE;
this->showScrollBar = FALSE;
this->sLimitToInside[0] = 0;
this->timeout = kInitialTimeout;
this->keyHandling = kHandleAndDontPass;
this->mouseHandling = kHandleAndDontPass;
// this->initialLoading = TRUE;
this->initialLoading = FALSE;
bounds = *ipBoundRect;
// create window
windowClass.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_DBLCLKS | CS_OWNDC;
windowClass.lpfnWndProc = (WNDPROC)BrowserControlPane::WindowProcEntry;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = NULL;
windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
windowClass.hbrBackground = (HBRUSH) ::GetStockObject(BLACK_BRUSH);
windowClass.lpszMenuName = NULL;
windowClass.lpszClassName = sClassName;
RegisterClass(&windowClass);
ASSERT(s_pInCreation == NULL);
s_pInCreation = this;
this->hwnd = CreateWindowEx(0, sClassName, _T(""), WS_CHILD | WS_CLIPSIBLINGS,
bounds.left, bounds.top, bounds.right - bounds.left, bounds.bottom - bounds.top,
hparentwnd, (HMENU)NULL, hInstance, (LPVOID)NULL);
::SetWindowLongA(this->hwnd, GWL_USERDATA, (DWORD) this);
s_pInCreation = NULL;
// create WebBrowser control
err = ::CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_INPROC, IID_IOleObject, (void**)&pOleObject);
ASSERT(SUCCEEDED(err));
if (SUCCEEDED(err))
{
err = pOleObject->SetClientSite(this);
ASSERT(SUCCEEDED(err));
}
// in-place actvivate the control
if (SUCCEEDED(err))
{
::SetRect(&clientRECT, 0, 0, bounds.right - bounds.left, bounds.bottom - bounds.top);
err = pOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, this, 0, this->hwnd, &clientRECT);
ASSERT(SUCCEEDED(err));
}
// get the browser control pointer
if (SUCCEEDED(err))
{
this->pBrowser = pOleObject;
ASSERT(this->pBrowser != NULL);
}
// setup connection for events
if (SUCCEEDED(err))
{
err = AtlAdvise(this->pBrowser, (IOleClientSite*) this, DIID_DWebBrowserEvents2, &this->connCookie);
ASSERT(SUCCEEDED(err));
}
// set size
if (SUCCEEDED(err))
{
CComQIPtr<IOleInPlaceObject, &IID_IOleInPlaceObject> pInPlaceObject(this->pBrowser);
ASSERT(pInPlaceObject != NULL);
err = pInPlaceObject->SetObjectRects(&clientRECT, &clientRECT);
ASSERT(SUCCEEDED(err));
}
if (FAILED(err))
{
if (this->pBrowser != NULL)
{
err = AtlUnadvise(this->pBrowser, DIID_DWebBrowserEvents2, this->connCookie);
ASSERT(SUCCEEDED(err));
}
this->pBrowser.Release();
::OleUninitialize();
::DestroyWindow(this->hwnd);
this->hwnd = NULL;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
// Verbindung zur GeoEdit-Erweiterung über deren Interface IEditExtensionSite herstellen
STDMETHODIMP CNewArea::SetEditExtensionSite (IEditExtensionSite* pIEdExSite)
{
try
{
if (pIEdExSite != NULL)
{
WUnknown wISite;
// Verbindung zu TRiAS über Interface ITriasExtension herstellen
THROW_FAILED_HRESULT (pIEdExSite->GetXtensionSite (wISite.ppi()));
THROW_FAILED_HRESULT (pIEdExSite->CreateInterfaceTO (m_wTopObjs.ppi()));
if (wISite.IsValid()) // in TRiAS reinhängen
{
if (m_dwCookieN != 0L || m_dwCookieSN != 0L) // anmelden
_com_issue_error (E_UNEXPECTED); // darf noch nicht angemeldet sein
m_Site = wISite; // throws_com_error
THROW_FAILED_HRESULT (AtlAdvise (m_Site, (ITRiASNotificationSink*)this,
IID_ITRiASNotificationSink, &m_dwCookieN));
THROW_FAILED_HRESULT (AtlAdvise (m_Site, (ITRiASSysNotificationSink*)this,
IID_ITRiASSysNotificationSink, &m_dwCookieSN));
}
m_wEdExSite = pIEdExSite;
m_wEdExSite->SetCursor (CURSFORM_CROSS, TRUE);
THROW_FAILED_HRESULT (m_wTopObjs->GetEnumTopicalObjectsGeometry (TRUE, m_wAllTObjs.ppi()));
m_wTopObjs->SetMarkVis (true); // Stützpunkte der ausgewählten Objekte sollen
// markiert werden
WEnumObjektGeometrie wGrabObjs (CLSID_EnumObjektGeometrie);
m_wGrabObjs = wGrabObjs;
}
else
{
if (m_wObj.IsValid())
{
int iActTool = DEX_GetActiveTool();
// wenn NewArea "richtig" verlassen wird (also nicht bloß zum Parken), dann das
// aktuell editierte (temporäre) Objekt wieder aus den ausgewählten Objekten
// herausnehmen
if (ID_TOOL_DESIGN != iActTool)
{
Rectangle Rec = GetDeleteRectangle (m_wObj, m_wTopObjs, m_wRestrictCursor, m_LastPt);
DEX_RePaintRectWait (Rec); // OHNE nachfolgendes Update() !!!
m_wTopObjs->DeleteTopicalObjectGeometry (m_wObj);
m_wObj.Assign (NULL);
}
// NewArea wird bloß zum Parken verlassen; dann hier die letzte Strecke, die zum
// DesignTool führt, zu löschen
else if (m_wDragObj.IsValid())
{
BOOL bTopIsPaint; // wird in CTopicalObjects der Hintergrund gezeichnet?
m_wTopObjs->IsPaint (&bTopIsPaint);
_ASSERTE (m_bIsPaint == false && bTopIsPaint == false);
m_wDragObj->DeleteLastSituation (m_bIsPaint || bTopIsPaint);
m_bWithDel = false;
}
}
// Stützpunktmarkierungen der ausgewählten Objekte sollen gelöscht werden
m_wTopObjs->SetMarkVis (false);
// Cursor wieder auf die Standard-Form "PFEIL" zurücksetzen
m_wEdExSite->SetCursor (CURSFORM_PFEIL, TRUE);
if (m_dwCookieN != 0L || m_dwCookieSN != 0L) // abmelden
THROW_FAILED_HRESULT (DisconnectFromServer()); // gibt uns u.u. frei
if (m_wRestrictCursor.IsValid())
{
m_wRestrictCursor->UnDraw();
m_wRestrictCursor.Assign (NULL);
}
m_wRestrLine1.Assign (NULL);
m_wRestrLine2.Assign (NULL);
m_wTopObjs.Assign (NULL);
m_wEdExSite.Assign (NULL);
m_bMessBox = false; // keine MessageBox angezeigt
}
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
return S_OK;
} // SetEditExtensionSite
