/***********************************************************************
* 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;
}
