/*********************************************************************** * CreateURLMonikerEx (URLMON.@) * * Create a url moniker. * * PARAMS * pmkContext [I] Context * szURL [I] Url to create the moniker for * ppmk [O] Destination for created moniker. * dwFlags [I] Flags. * * RETURNS * Success: S_OK. ppmk contains the created IMoniker object. * Failure: MK_E_SYNTAX if szURL is not a valid url, or * E_OUTOFMEMORY if memory allocation fails. */ HRESULT WINAPI CreateURLMonikerEx(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk, DWORD dwFlags) { URLMonikerImpl *obj; HRESULT hres; LPOLESTR lefturl = NULL; TRACE("(%p, %s, %p, %08x)\n", pmkContext, debugstr_w(szURL), ppmk, dwFlags); if (dwFlags & URL_MK_UNIFORM) FIXME("ignoring flag URL_MK_UNIFORM\n"); if(!(obj = heap_alloc(sizeof(*obj)))) return E_OUTOFMEMORY; if(pmkContext) { IBindCtx* bind; DWORD dwMksys = 0; IMoniker_IsSystemMoniker(pmkContext, &dwMksys); if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) { IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl); TRACE("lefturl = %s\n", debugstr_w(lefturl)); IBindCtx_Release(bind); } } hres = URLMonikerImpl_Construct(obj, lefturl, szURL); CoTaskMemFree(lefturl); if(SUCCEEDED(hres)) hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &IID_IMoniker, (void**)ppmk); else heap_free(obj); return hres; }
/****************************************************************************** * FileMoniker_IsEqual */ static HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) { FileMonikerImpl *This = impl_from_IMoniker(iface); CLSID clsid; LPOLESTR filePath; IBindCtx* bind; HRESULT res; TRACE("(%p,%p)\n",iface,pmkOtherMoniker); if (pmkOtherMoniker==NULL) return S_FALSE; IMoniker_GetClassID(pmkOtherMoniker,&clsid); if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker)) return S_FALSE; res = CreateBindCtx(0,&bind); if (FAILED(res)) return res; res = S_FALSE; if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) { if (!lstrcmpiW(filePath, This->filePathName)) res = S_OK; CoTaskMemFree(filePath); } IBindCtx_Release(bind); return res; }
int BookServerTest::createFileMoniker() { ComPtr<IMoniker> moniker; auto hr = CreateFileMoniker(kFileName, &moniker); if (FAILED(hr)) { return -1; } IBindCtx* pbc; CreateBindCtx(0, &pbc); ComPtr<IBook> book; hr = moniker->BindToObject(pbc, NULL, IID_IBook, (void**)&book); if (FAILED(hr)) { return -1; } ComPtr<IStorage> pStorage; ComPtr<IStream> pStream; hr = StgCreateStorageEx(kMonikerFileName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, STGFMT_STORAGE, 0, NULL, 0, IID_IStorage, (void**)&pStorage); if (FAILED(hr)) return hr; hr = pStorage->CreateStream(kStreamName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &pStream); if (FAILED(hr)) return hr; OleSaveToStream(moniker, pStream); return 0; }
HRESULT CDuiAxContainer::MonikerBindToStorage(IMoniker *pMk, IBindCtx *pBC, IBindStatusCallback *pBSC, REFIID riid, void **ppvObj) { HRESULT hr = E_FAIL; CDuiComPtr<IBindCtx> pBCCtx = pBC; if (pBCCtx == NULL) { // creates it if not present hr = CreateBindCtx(0, &pBCCtx); } if ( pBCCtx != NULL ) { if ( pBSC != NULL ) { typedef HRESULT (WINAPI* pfnRegisterBindStatusCallback)( IBindCtx *pbc,IBindStatusCallback *pbsc,IBindStatusCallback **ppbscPrevious,DWORD dwReserved); HMODULE urlmon = ::GetModuleHandleA("urlmon.dll"); if(!urlmon) urlmon = ::LoadLibraryA("urlmon.dll"); pfnRegisterBindStatusCallback OrigRegisterBindStatusCallback = (pfnRegisterBindStatusCallback)::GetProcAddress(urlmon,"RegisterBindStatusCallback"); hr = OrigRegisterBindStatusCallback(pBCCtx, pBSC, NULL, 0); } hr = pMk->BindToStorage(pBCCtx, NULL, riid, ppvObj); } return hr; }
/****************************************************************************** * ItemMoniker_IsEqual ******************************************************************************/ static HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) { CLSID clsid; LPOLESTR dispName1,dispName2; IBindCtx* bind; HRESULT res = S_FALSE; TRACE("(%p,%p)\n",iface,pmkOtherMoniker); if (!pmkOtherMoniker) return S_FALSE; /* check if both are ItemMoniker */ if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE; if(!IsEqualCLSID(&clsid,&CLSID_ItemMoniker)) return S_FALSE; /* check if both displaynames are the same */ if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) { if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) { if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) { if(lstrcmpW(dispName1,dispName2)==0) res = S_OK; CoTaskMemFree(dispName2); } CoTaskMemFree(dispName1); } } return res; }
void CMFCBindCntrItem::LoadFromMoniker(LPUNKNOWN pUnk, OLECHAR* szwName) { HRESULT hr; // Ask the system for a URL Moniker IMoniker* pIMoniker; hr = CreateURLMoniker(NULL, (LPWSTR)szwName, &pIMoniker); if ( SUCCEEDED(hr) ) { // Get the IPersistMoniker interface IPersistMoniker* pPMk; hr = pUnk->QueryInterface( IID_IPersistMoniker, (void **)&pPMk); if ( SUCCEEDED(hr) ) { // note: do not register our BSC when calling IPM::Load directly IBindCtx *pBCtx; hr = CreateBindCtx(0, &pBCtx); if ( SUCCEEDED(hr) ) { // Call Load on the IPersistMoniker hr = pPMk->Load(FALSE, pIMoniker, pBCtx, STGM_READ); pBCtx->Release(); } pPMk->Release(); } pIMoniker->Release( ); } }
/* Newer COM libraries supply the functionality of bindObject() via CoGetObject(), but to avoid depending on that being around, we stick with our own implementation. */ HRESULT bindObject( const WCHAR* name, IID* iid, void** unk ) { HRESULT hr; IBindCtx *bc; IMoniker *mk; ULONG count; if (!unk) return E_POINTER; else *unk = NULL; if (!iid) return E_POINTER; bc = NULL; mk = NULL; hr = CreateBindCtx(0, &bc); if (FAILED(hr)) return hr; hr = MkParseDisplayName(bc, name, &count, &mk); if (FAILED(hr)) { IUnknown_Release(bc); return hr; } hr = IMoniker_BindToObject( mk, bc, NULL, iid, unk ); IUnknown_Release(mk); IUnknown_Release(bc); return hr; }
/*********************************************************************** * HlinkResolveMonikerForData (HLINK.@) */ HRESULT WINAPI HlinkResolveMonikerForData(LPMONIKER pimkReference, DWORD reserved, LPBC pibc, ULONG cFmtetc, FORMATETC *rgFmtetc, IBindStatusCallback *pibsc, LPMONIKER pimkBase) { LPOLESTR name = NULL; IBindCtx *bctx; DWORD mksys = 0; void *obj = NULL; HRESULT hres; TRACE("(%p %x %p %d %p %p %p)\n", pimkReference, reserved, pibc, cFmtetc, rgFmtetc, pibsc, pimkBase); if(cFmtetc || rgFmtetc || pimkBase) FIXME("Unsupported args\n"); hres = RegisterBindStatusCallback(pibc, pibsc, NULL /* FIXME */, 0); if(FAILED(hres)) return hres; hres = IMoniker_IsSystemMoniker(pimkReference, &mksys); if(SUCCEEDED(hres) && mksys != MKSYS_URLMONIKER) WARN("sysmk = %x\n", mksys); /* FIXME: What is it for? */ CreateBindCtx(0, &bctx); hres = IMoniker_GetDisplayName(pimkReference, bctx, NULL, &name); IBindCtx_Release(bctx); if(SUCCEEDED(hres)) { TRACE("got display name %s\n", debugstr_w(name)); CoTaskMemFree(name); } return IMoniker_BindToStorage(pimkReference, pibc, NULL, &IID_IUnknown, &obj); }
/****************************************************************************** * URLMoniker_IsEqual ******************************************************************************/ static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) { URLMonikerImpl *This = (URLMonikerImpl *)iface; CLSID clsid; LPOLESTR urlPath; IBindCtx* bind; HRESULT res; TRACE("(%p,%p)\n",This,pmkOtherMoniker); if(pmkOtherMoniker==NULL) return E_INVALIDARG; IMoniker_GetClassID(pmkOtherMoniker,&clsid); if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker)) return S_FALSE; res = CreateBindCtx(0,&bind); if(FAILED(res)) return res; res = S_FALSE; if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) { int result = lstrcmpiW(urlPath, This->URLName); CoTaskMemFree(urlPath); if(result == 0) res = S_OK; } IUnknown_Release(bind); return res; }
int BookServerTest::readFileMoniker() { ComPtr<IStorage> pStorage; ComPtr<IStream> pStream; auto hr = StgOpenStorageEx(kMonikerFileName, STGM_READ | STGM_SHARE_EXCLUSIVE | STGM_DIRECT, STGFMT_STORAGE, 0, NULL, 0, IID_IStorage, (void**)&pStorage); if (FAILED(hr)) return hr; hr = pStorage->OpenStream(kStreamName, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream); if (FAILED(hr)) return hr; ComPtr<IMoniker> moniker; OleLoadFromStream(pStream, IID_IMoniker, (void**)&moniker); IBindCtx* pbc; CreateBindCtx(0, &pbc); ComPtr<IBook> book; hr = moniker->BindToObject(pbc, NULL, IID_IBook, (void**)&book); if (FAILED(hr)) { return -1; } ComBSTR name; book->get_name(&name); assert(name == kBookName); return 0; }
static HRESULT WINAPI IHlink_fnNavigate(IHlink* iface, DWORD grfHLNF, LPBC pbc, IBindStatusCallback *pbsc, IHlinkBrowseContext *phbc) { HlinkImpl *This = impl_from_IHlink(iface); IMoniker *mon = NULL; HRESULT r; FIXME("Semi-Stub:(%p)->(%i %p %p %p)\n", This, grfHLNF, pbc, pbsc, phbc); r = __GetMoniker(This, &mon, HLINKGETREF_ABSOLUTE); TRACE("Moniker %p\n", mon); if (SUCCEEDED(r)) { IBindCtx *bcxt; IUnknown *unk = NULL; IHlinkTarget *target; CreateBindCtx(0, &bcxt); RegisterBindStatusCallback(bcxt, pbsc, NULL, 0); r = IMoniker_BindToObject(mon, bcxt, NULL, &IID_IUnknown, (void**)&unk); if (r == S_OK) { r = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&target); IUnknown_Release(unk); } if (r == S_OK) { IHlinkTarget_SetBrowseContext(target, phbc); r = IHlinkTarget_Navigate(target, grfHLNF, This->Location); IHlinkTarget_Release(target); } else { static const WCHAR szOpen[] = {'o','p','e','n',0}; LPWSTR target = NULL; r = IHlink_GetStringReference(iface, HLINKGETREF_DEFAULT, &target, NULL); if (SUCCEEDED(r) && target) { ShellExecuteW(NULL, szOpen, target, NULL, NULL, SW_SHOW); CoTaskMemFree(target); } } RevokeBindStatusCallback(bcxt, pbsc); IBindCtx_Release(bcxt); IMoniker_Release(mon); } if (This->Site) IHlinkSite_OnNavigationComplete(This->Site, This->SiteData, 0, r, NULL); TRACE("Finished Navigation\n"); return r; }
// Used (by getDeviceModes) to select a device // so we can list its properties static IBaseFilter* getDevFilter(QString devName) { IBaseFilter* devFilter = nullptr; devName = devName.mid(6); // Remove the "video=" IMoniker* m = nullptr; ICreateDevEnum* devenum = nullptr; if (CoCreateInstance(CLSID_SystemDeviceEnum, nullptr, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**) &devenum) != S_OK) return devFilter; IEnumMoniker* classenum = nullptr; if (devenum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, (IEnumMoniker**)&classenum, 0) != S_OK) return devFilter; while (classenum->Next(1, &m, nullptr) == S_OK) { LPMALLOC coMalloc = nullptr; IBindCtx* bindCtx = nullptr; LPOLESTR olestr = nullptr; char* devIdString; if (CoGetMalloc(1, &coMalloc) != S_OK) goto fail; if (CreateBindCtx(0, &bindCtx) != S_OK) goto fail; if (m->GetDisplayName(bindCtx, nullptr, &olestr) != S_OK) goto fail; devIdString = wcharToUtf8(olestr); // replace ':' with '_' since FFmpeg uses : to delimitate sources for (unsigned i = 0; i < strlen(devIdString); i++) if (devIdString[i] == ':') devIdString[i] = '_'; if (devName != devIdString) goto fail; if (m->BindToObject(0, 0, IID_IBaseFilter, (void**)&devFilter) != S_OK) goto fail; fail: if (olestr && coMalloc) coMalloc->Free(olestr); if (bindCtx) bindCtx->Release(); delete[] devIdString; m->Release(); } classenum->Release(); if (!devFilter) qWarning() << "Could't find the device "<<devName; return devFilter; }
/** Accesses the correct visual studio instance if possible. */ bool AccessVisualStudio(CComPtr<EnvDTE::_DTE>& OutDTE, const FString& InSolutionPath, const TArray<FVSAccessorModule::VisualStudioLocation>& InLocations) { bool bSuccess = false; // Open the Running Object Table (ROT) IRunningObjectTable* RunningObjectTable; if (SUCCEEDED(GetRunningObjectTable(0, &RunningObjectTable)) && RunningObjectTable) { IEnumMoniker* MonikersTable; RunningObjectTable->EnumRunning(&MonikersTable); MonikersTable->Reset(); // Look for all visual studio instances in the ROT IMoniker* CurrentMoniker; while (!bSuccess && MonikersTable->Next(1, &CurrentMoniker, NULL) == S_OK) { IBindCtx* BindContext; LPOLESTR OutName; CComPtr<IUnknown> ComObject; if (SUCCEEDED(CreateBindCtx(0, &BindContext)) && SUCCEEDED(CurrentMoniker->GetDisplayName(BindContext, NULL, &OutName)) && IsVisualStudioMoniker(FString(OutName), InLocations) && SUCCEEDED(RunningObjectTable->GetObject(CurrentMoniker, &ComObject))) { CComPtr<EnvDTE::_DTE> TempDTE; TempDTE = ComObject; // Get the solution path for this instance // If it equals the solution we would have opened above in RunVisualStudio(), we'll take that CComPtr<EnvDTE::_Solution> Solution; LPOLESTR OutPath; if (SUCCEEDED(TempDTE->get_Solution(&Solution)) && SUCCEEDED(Solution->get_FullName(&OutPath))) { FString Filename(OutPath); FPaths::NormalizeFilename(Filename); if( Filename == InSolutionPath ) { OutDTE = TempDTE; bSuccess = true; } } } BindContext->Release(); CurrentMoniker->Release(); } MonikersTable->Release(); RunningObjectTable->Release(); } return bSuccess; }
static NTSTATUS EnumRunningObjectTable( _In_ PVOID ThreadParam ) { IRunningObjectTable* iRunningObjectTable = NULL; IEnumMoniker* iEnumMoniker = NULL; IMoniker* iMoniker = NULL; IBindCtx* iBindCtx = NULL; IMalloc* iMalloc = NULL; ULONG count = 0; HWND listViewHandle = (HWND)ThreadParam; if (!SUCCEEDED(CoGetMalloc(1, &iMalloc))) return STATUS_INSUFFICIENT_RESOURCES; // Query the running object table address if (SUCCEEDED(GetRunningObjectTable(0, &iRunningObjectTable))) { // Enum the objects registered if (SUCCEEDED(IRunningObjectTable_EnumRunning(iRunningObjectTable, &iEnumMoniker))) { while (IEnumMoniker_Next(iEnumMoniker, 1, &iMoniker, &count) == S_OK) { if (SUCCEEDED(CreateBindCtx(0, &iBindCtx))) { OLECHAR* displayName = NULL; // Query the object name if (SUCCEEDED(IMoniker_GetDisplayName(iMoniker, iBindCtx, NULL, &displayName))) { // Set the items name column PhAddListViewItem(listViewHandle, MAXINT, displayName, NULL); // Free the object name IMalloc_Free(iMalloc, displayName); } IBindCtx_Release(iBindCtx); } IEnumMoniker_Release(iMoniker); } IEnumMoniker_Release(iEnumMoniker); } IRunningObjectTable_Release(iRunningObjectTable); } IMalloc_Release(iMalloc); return STATUS_SUCCESS; }
static int FindInterpreterObject( Tcl_Interp *interp, const char *name, LPDISPATCH *ppdisp) { LPRUNNINGOBJECTTABLE pROT = NULL; int result = TCL_OK; HRESULT hr = GetRunningObjectTable(0, &pROT); if (SUCCEEDED(hr)) { IBindCtx* pBindCtx = NULL; hr = CreateBindCtx(0, &pBindCtx); if (SUCCEEDED(hr)) { LPMONIKER pmk = NULL; hr = BuildMoniker(name, &pmk); if (SUCCEEDED(hr)) { IUnknown *pUnkInterp = NULL, **ppUnkInterp = &pUnkInterp; hr = pROT->lpVtbl->IsRunning(pROT, pmk); hr = pmk->lpVtbl->BindToObject(pmk, pBindCtx, NULL, &IID_IUnknown, (void **) ppUnkInterp); if (SUCCEEDED(hr)) { hr = pUnkInterp->lpVtbl->QueryInterface(pUnkInterp, &IID_IDispatch, (void **) ppdisp); pUnkInterp->lpVtbl->Release(pUnkInterp); } else { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "no application named \"%s\"", name)); Tcl_SetErrorCode(interp, "TK", "LOOKUP", "APPLICATION", NULL); result = TCL_ERROR; } pmk->lpVtbl->Release(pmk); } pBindCtx->lpVtbl->Release(pBindCtx); } pROT->lpVtbl->Release(pROT); } if (FAILED(hr) && result == TCL_OK) { Tcl_SetObjResult(interp, Win32ErrorObj(hr)); result = TCL_ERROR; } return result; }
STDMETHODIMP CTCBindHost::MonikerBindToStorage( IMoniker* pMoniker, IBindCtx* pBindCtx, IBindStatusCallback* pBSC, REFIID iid, void** ppObject ) { HRESULT hResult; IBindCtxPtr pNewBindCtx; TCTrace( TRACELEVEL_NORMAL, "IBindHost::MonikerBindToStorage\n" ); if( ppObject == NULL ) { return( E_POINTER ); } *ppObject = NULL; if( pBindCtx != NULL ) { pNewBindCtx = pBindCtx; if( pBSC ) { hResult = RegisterBindStatusCallback( pBindCtx, pBSC, NULL, 0 ); if( FAILED( hResult ) ) { return( hResult ); } } } else { if( pBSC ) { hResult = CreateAsyncBindCtx( 0, pBSC, NULL, &pNewBindCtx ); if( FAILED( hResult ) ) { return( hResult ); } } else { hResult = CreateBindCtx( 0, &pNewBindCtx ); if( FAILED( hResult ) ) { return( hResult ); } } } ASSERT( pNewBindCtx != NULL ); return( pMoniker->BindToStorage( pNewBindCtx, NULL, iid, ppObject ) ); }
DirectShowAudioEndpointControl::DirectShowAudioEndpointControl( DirectShowPlayerService *service, QObject *parent) : QAudioOutputSelectorControl(parent) , m_service(service) , m_bindContext(0) , m_deviceEnumerator(0) { if (CreateBindCtx(0, &m_bindContext) == S_OK) { m_deviceEnumerator = com_new<ICreateDevEnum>(CLSID_SystemDeviceEnum, IID_ICreateDevEnum); updateEndpoints(); setActiveOutput(m_defaultEndpoint); } }
/****************************************************************************** * BindMoniker [OLE32.@] * * Binds to a moniker. * * PARAMS * pmk [I] Moniker to bind to. * grfOpt [I] Reserved option flags. Set to 0. * riid [I] ID of the interface to bind to. * pvResult [O] Address that receives the interface of the object that was bound to. * * RETURNS * Success: S_OK. * Failure: Any HRESULT code. */ HRESULT WINAPI BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID riid, LPVOID * ppvResult) { HRESULT res; IBindCtx * pbc; TRACE("(%p, %x, %s, %p)\n", pmk, grfOpt, debugstr_guid(riid), ppvResult); res = CreateBindCtx(grfOpt, &pbc); if (SUCCEEDED(res)) { res = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppvResult); IBindCtx_Release(pbc); } return res; }
static HRESULT WINAPI IHlink_fnGetStringReference (IHlink* iface, DWORD dwWhichRef, LPWSTR *ppwzTarget, LPWSTR *ppwzLocation) { HlinkImpl *This = impl_from_IHlink(iface); TRACE("(%p) -> (%i %p %p)\n", This, dwWhichRef, ppwzTarget, ppwzLocation); if(dwWhichRef != -1 && dwWhichRef & ~(HLINKGETREF_DEFAULT | HLINKGETREF_ABSOLUTE | HLINKGETREF_RELATIVE)) { if(ppwzTarget) *ppwzTarget = NULL; if(ppwzLocation) *ppwzLocation = NULL; return E_INVALIDARG; } if (ppwzTarget) { IMoniker* mon; HRESULT hres = __GetMoniker(This, &mon, dwWhichRef); if (FAILED(hres)) { if (ppwzLocation) *ppwzLocation = NULL; return hres; } if (mon) { IBindCtx *pbc; CreateBindCtx( 0, &pbc); IMoniker_GetDisplayName(mon, pbc, NULL, ppwzTarget); IBindCtx_Release(pbc); IMoniker_Release(mon); } else *ppwzTarget = NULL; } if (ppwzLocation) *ppwzLocation = hlink_co_strdupW( This->Location ); TRACE("(Target: %s Location: %s)\n", (ppwzTarget)?debugstr_w(*ppwzTarget):"<NULL>", (ppwzLocation)?debugstr_w(*ppwzLocation):"<NULL>"); return S_OK; }
void HTMLIFrameElement::goForward() { #if 0 if (m_pHBC) { CComPtr<IHlink> pHlink; m_pHBC->GetHlink(HLID_NEXT, &pHlink); if (pHlink) { CComPtr<IBindCtx> bctx; CreateBindCtx(0, &bctx); ErrorCode hr = HlinkNavigate(pHlink, m_view, HLNF_NAVIGATINGFORWARD, bctx, NULL, m_pHBC); } // ErrorCode hr = ::HlinkGoForward(m_spUnknown); } #endif }
static bool GetFilterGraph(IFilterGraph** ppFG) { if(!ppFG) return(false); CComPtr<IRunningObjectTable> pROT; if(FAILED(GetRunningObjectTable(0, &pROT))) return 1; CComPtr<IEnumMoniker> pEM; if(FAILED(pROT->EnumRunning(&pEM))) return 1; CComPtr<IBindCtx> pBindCtx; CreateBindCtx(0, &pBindCtx); for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL) { LPOLESTR pDispName = NULL; if(FAILED(pMoniker->GetDisplayName(pBindCtx, NULL, &pDispName))) continue; CStringW strw(pDispName); CComPtr<IMalloc> pMalloc; if(FAILED(CoGetMalloc(1, &pMalloc))) continue; pMalloc->Free(pDispName); if(strw.Find(L"(MPC)") < 0) continue; CComPtr<IUnknown> pUnk; if(S_OK != pROT->GetObject(pMoniker, &pUnk)) continue; CComQIPtr<IFilterGraph> pFG = pUnk; if(!pFG) continue; *ppFG = pFG.Detach(); break; } return(!!*ppFG); }
static void test_SHCreateQueryCancelAutoPlayMoniker(void) { IBindCtx *ctxt; IMoniker *mon; IUnknown *unk; CLSID clsid; HRESULT hr; DWORD sys; if (!pSHCreateQueryCancelAutoPlayMoniker) { win_skip("SHCreateQueryCancelAutoPlayMoniker is not available, skipping tests.\n"); return; } hr = pSHCreateQueryCancelAutoPlayMoniker(NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = pSHCreateQueryCancelAutoPlayMoniker(&mon); ok(hr == S_OK, "got 0x%08x\n", hr); sys = -1; hr = IMoniker_IsSystemMoniker(mon, &sys); ok(hr == S_OK, "got 0x%08x\n", hr); ok(sys == MKSYS_CLASSMONIKER, "got %d\n", sys); memset(&clsid, 0, sizeof(clsid)); hr = IMoniker_GetClassID(mon, &clsid); ok(hr == S_OK, "got 0x%08x\n", hr); ok(IsEqualGUID(&clsid, &CLSID_ClassMoniker), "got %s\n", wine_dbgstr_guid(&clsid)); /* extract used CLSID that implements this hook */ SET_EXPECT(autoplay_BindToObject); SET_EXPECT(autoplay_GetClassObject); CreateBindCtx(0, &ctxt); hr = IMoniker_BindToObject(mon, ctxt, &test_moniker, &IID_IQueryCancelAutoPlay, (void**)&unk); ok(hr == E_NOTIMPL, "got 0x%08x\n", hr); IBindCtx_Release(ctxt); CHECK_CALLED(autoplay_BindToObject); CHECK_CALLED(autoplay_GetClassObject); IMoniker_Release(mon); }
///////////////////////////////////////////////////////////////////////////// // Description: Creates a relative path name, if possible. // // Parameters: // bBeginWithDot - Prepends the relative path with the a period and // backslash. While possibly rendundant, this may be useful for some contexts // of relative pathnames. If a relative path cannot be resolved, this // parameter is ignored. // bool TCMakeRelativePath(LPCTSTR pszPath, LPCTSTR pszFrom, LPTSTR pszDest, int cchMaxDest, bool bBeginWithDot) { // Ensure that input paths are absolute TCHAR szPathCopy[_MAX_PATH], szFromCopy[_MAX_PATH]; if (!_tfullpath(szPathCopy, pszPath, sizeofArray(szPathCopy))) return false; if (!_tfullpath(szFromCopy, pszFrom, sizeofArray(szFromCopy))) return false; // Replace (in-place) forward slashes with backslashes in input paths TCReplaceText(szPathCopy, TEXT("/"), TEXT("\\"), szPathCopy, -1); TCReplaceText(szFromCopy, TEXT("/"), TEXT("\\"), szFromCopy, -1); // The From path MUST be a directory, not a filename, so append backslash if (TEXT('\\') != szFromCopy[_tcslen(szFromCopy) - 1]) _tcscat(szFromCopy, TEXT("\\")); // Use COM monikers to create a relative path HRESULT hr; IBindCtxPtr pbc; IMonikerPtr pmkFrom, pmkPath, pmkRelative; LPOLESTR pszRelative = NULL; if (SUCCEEDED(hr = CreateFileMoniker(_bstr_t(szFromCopy), &pmkFrom)) && SUCCEEDED(hr = CreateFileMoniker(_bstr_t(szPathCopy), &pmkPath)) && S_OK == (hr = pmkFrom->RelativePathTo(pmkPath, &pmkRelative)) && SUCCEEDED(hr = CreateBindCtx(0, &pbc)) && SUCCEEDED(hr = pmkRelative->GetDisplayName(pbc, NULL, &pszRelative))) { if (bBeginWithDot) { TC_tcscpyn(pszDest, TEXT(".\\"), cchMaxDest); cchMaxDest -= 2; pszDest += 2; } TC_tcscpyn(pszDest, _bstr_t(pszRelative), cchMaxDest); CoTaskMemFree(pszRelative); return true; } // Could not make a relative path, copy the absolute path TC_tcscpyn(pszDest, szPathCopy, cchMaxDest); return false; }
bool VideoCaptureDeviceImpl::initName() { if (!m_pMoniker) { return false; } IBindCtx* pBindContext = 0; HRESULT result = CreateBindCtx(0, &pBindContext); if (FAILED(result)) { return false; } IBindCtxSharedPtr bindContextPtr(comInterfaceSharedPtr(pBindContext)); if (!bindContextPtr) { return false; } IPropertyBag* pPropertyBag = 0; result = m_pMoniker->BindToStorage( bindContextPtr.get(), 0, IID_IPropertyBag, reinterpret_cast<void**>(&pPropertyBag)); if (FAILED(result)) { return false; } IPropertyBagSharedPtr propertyBagPtr(comInterfaceSharedPtr(pPropertyBag)); if (!propertyBagPtr) { return false; } VARIANT variant; VariantSharedPtr variantPtr(variantSharedPtr(&variant)); result = propertyBagPtr->Read(s_kFriendlyName.c_str(), variantPtr.get(), 0); if (FAILED(result)) { return false; } const BSTR basicString = variantPtr->bstrVal; if (!basicString) { return false; } std::string friendlyName(utf8StringFromBasicString(basicString)); m_name = friendlyName; return true; }
HRESULT bind_url(IMoniker *mon, HRESULT (*onDataAvailable)(void*,char*,DWORD), void *obj, bsc_t **ret) { bsc_t *bsc; IBindCtx *pbc; HRESULT hr; TRACE("%p\n", mon); hr = CreateBindCtx(0, &pbc); if(FAILED(hr)) return hr; bsc = heap_alloc(sizeof(bsc_t)); bsc->IBindStatusCallback_iface.lpVtbl = &bsc_vtbl; bsc->ref = 1; bsc->obj = obj; bsc->onDataAvailable = onDataAvailable; bsc->binding = NULL; bsc->memstream = NULL; bsc->hres = S_OK; hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0); if(SUCCEEDED(hr)) { IStream *stream; hr = IMoniker_BindToStorage(mon, pbc, NULL, &IID_IStream, (LPVOID*)&stream); if(stream) IStream_Release(stream); IBindCtx_Release(pbc); } if(FAILED(hr)) { IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface); bsc = NULL; } *ret = bsc; return hr; }
static IHTMLDocument2 *create_doc_from_url(const char *start_url) { BSTR url; IBindCtx *bc; IMoniker *url_mon; IPersistMoniker *persist_mon; IHTMLDocument2 *doc; HRESULT hres; hres = CreateBindCtx(0, &bc); ok(hres == S_OK, "CreateBindCtx failed: 0x%08x\n", hres); url = a2bstr(start_url); hres = CreateURLMoniker(NULL, url, &url_mon); ok(hres == S_OK, "CreateURLMoniker failed: 0x%08x\n", hres); hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER, &IID_IHTMLDocument2, (void**)&doc); ok(hres == S_OK, "CoCreateInstance failed: 0x%08x\n", hres); hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist_mon); ok(hres == S_OK, "IHTMLDocument2_QueryInterface failed: 0x%08x\n", hres); hres = IPersistMoniker_Load(persist_mon, FALSE, url_mon, bc, STGM_SHARE_EXCLUSIVE | STGM_READWRITE); ok(hres == S_OK, "IPersistMoniker_Load failed: 0x%08x\n", hres); IPersistMoniker_Release(persist_mon); IMoniker_Release(url_mon); IBindCtx_Release(bc); SysFreeString(url); doc_complete = FALSE; notif_doc = doc; do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink); pump_msgs(&doc_complete); return doc; }
static void test_HlinkResolveMonikerForData(void) { IBindCtx *bctx; HRESULT hres; CreateBindCtx(0, &bctx); _bctx = bctx; SET_EXPECT(IsSystemMoniker); SET_EXPECT(GetDisplayName); SET_EXPECT(BindToStorage); hres = HlinkResolveMonikerForData(&Moniker, 0, bctx, 0, NULL, &BindStatusCallback, NULL); ok(hres == S_OK, "HlinkResolveMonikerForData failed: %08x\n", hres); CHECK_CALLED(IsSystemMoniker); CHECK_CALLED(GetDisplayName); CHECK_CALLED(BindToStorage); IBindCtx_Release(bctx); }
HRESULT CDuiAxContainer::MonikerBindToStorage(IMoniker *pMk, IBindCtx *pBC, IBindStatusCallback *pBSC, REFIID riid, void **ppvObj) { HRESULT hr = E_FAIL; CDuiComPtr<IBindCtx> pBCCtx = pBC; if (pBCCtx == NULL) { // creates it if not present hr = CreateBindCtx(0, &pBCCtx); } if ( pBCCtx != NULL ) { if ( pBSC != NULL ) { hr = RegisterBindStatusCallback(pBCCtx, pBSC, NULL, 0); } hr = pMk->BindToStorage(pBCCtx, NULL, riid, ppvObj); } return hr; }
/*********************************************************************** * CreateAsyncBindCtxEx (urlmon.@) * * Create an asynchronous bind context. */ HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind, DWORD reserved) { AsyncBindCtx *ret; IBindCtx *bindctx; HRESULT hres; TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved); if(!pbind) return E_INVALIDARG; if(reserved) WARN("reserved=%d\n", reserved); if(ibind) { IBindCtx_AddRef(ibind); bindctx = ibind; }else { hres = CreateBindCtx(0, &bindctx); if(FAILED(hres)) return hres; } ret = heap_alloc(sizeof(AsyncBindCtx)); ret->IBindCtx_iface.lpVtbl = &AsyncBindCtxVtbl; ret->ref = 1; ret->bindctx = bindctx; hres = init_bindctx(&ret->IBindCtx_iface, options, callback, format); if(FAILED(hres)) { IBindCtx_Release(&ret->IBindCtx_iface); return hres; } *pbind = &ret->IBindCtx_iface; return S_OK; }
HRESULT WINAPI IFileSystemBindData_Constructor(const WIN32_FIND_DATAW *find_data, LPBC *ppV) { FileSystemBindData *This; HRESULT ret; TRACE("(%p %p)\n", find_data, ppV); if (!ppV) return E_INVALIDARG; *ppV = NULL; This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); if (!This) return E_OUTOFMEMORY; This->IFileSystemBindData_iface.lpVtbl = &FileSystemBindDataVtbl; This->ref = 1; IFileSystemBindData_SetFindData(&This->IFileSystemBindData_iface, find_data); ret = CreateBindCtx(0, ppV); if (SUCCEEDED(ret)) { static const WCHAR nameW[] = { 'F','i','l','e',' ','S','y','s','t','e','m',' ','B','i','n','d',' ','D','a','t','a',0}; BIND_OPTS bindOpts; bindOpts.cbStruct = sizeof(BIND_OPTS); bindOpts.grfFlags = 0; bindOpts.grfMode = STGM_CREATE; bindOpts.dwTickCountDeadline = 0; IBindCtx_SetBindOptions(*ppV, &bindOpts); IBindCtx_RegisterObjectParam(*ppV, (WCHAR*)nameW, (IUnknown*)&This->IFileSystemBindData_iface); IFileSystemBindData_Release(&This->IFileSystemBindData_iface); } else HeapFree(GetProcessHeap(), 0, This); return ret; }