static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
{
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
DWORD size;
HRESULT hres;
if(PathIsURLW(url))
return CreateURLMoniker(NULL, url, mon);
if(url[1] == ':') {
size = sizeof(new_url);
hres = UrlCreateFromPathW(url, new_url, &size, 0);
if(FAILED(hres)) {
WARN("UrlCreateFromPathW failed: %08x\n", hres);
return hres;
}
}else {
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME);
TRACE("got %s\n", debugstr_w(new_url));
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
return hres;
}
}
return CreateURLMoniker(NULL, new_url, mon);
}
STDMETHODIMP CTCBindHost::CreateMoniker( LPOLESTR pszName, IBindCtx* pBindCtx,
IMoniker** ppMoniker, DWORD dwReserved )
{
HRESULT hResult;
(void)pBindCtx;
(void)dwReserved;
if( ppMoniker == NULL )
{
return( E_POINTER );
}
*ppMoniker = NULL;
if( pszName == NULL )
{
return( E_INVALIDARG );
}
hResult = CreateURLMoniker( NULL, pszName, ppMoniker );
if( FAILED( hResult ) )
{
return( hResult );
}
ASSERT( *ppMoniker != NULL );
return( S_OK );
}
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( );
}
}
int CHtmlDialog::DoModal()
{
//First get the proc ShowHTMLDialog
SHOWHTMLDIALOGFN *pfnShowHTMLDialog;
pfnShowHTMLDialog = (SHOWHTMLDIALOGFN*)GetProcAddress(m_hInstMSHTML, TEXT("ShowHTMLDialog"));
if (!pfnShowHTMLDialog)
return -1;
//Now create a URL Moniker
IMoniker* pmk = NULL;
BSTR bstrURL = m_strURL.AllocSysString();
CreateURLMoniker(NULL, bstrURL, &pmk);
if (!pmk)
return -1;
TCHAR* pchOptions = m_strOptions.IsEmpty() ? NULL : m_strOptions.GetBuffer(0);
//Now show the HTML Dialog
HRESULT hr = (*pfnShowHTMLDialog)(m_hWndParent, pmk, m_varArgs, pchOptions, m_varReturn);
if (FAILED(hr))
return -1;
return 0;
}
static HRESULT generate_moniker(char *baseurl, char *url, DWORD flags, IMoniker **moniker)
{
WCHAR *urlW;
HRESULT hr;
if (flags & URLF_RELATIVEURL)
{
char *combined;
if (!baseurl)
return E_FAIL;
combined = combine_url(baseurl, url);
if (!combined) return E_OUTOFMEMORY;
urlW = strAtoW(combined);
heap_free(combined);
if (!urlW) return E_OUTOFMEMORY;
}
else
{
urlW = strAtoW(url);
if (!urlW) return E_OUTOFMEMORY;
}
hr = CreateURLMoniker(NULL, urlW, moniker);
heap_free(urlW);
return hr;
}
static DWORD WINAPI download_proc(PVOID arg)
{
IMoniker *mon;
IBindCtx *bctx;
IStream *str = NULL;
HRESULT hres;
CreateURLMoniker(NULL, url, &mon);
heap_free(url);
url = NULL;
CreateAsyncBindCtx(0, &InstallCallback, 0, &bctx);
hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&str);
IBindCtx_Release(bctx);
if(FAILED(hres)) {
ERR("BindToStorage failed: %08x\n", hres);
return 0;
}
if(str)
IStream_Release(str);
return 0;
}
static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
{
WCHAR url[INTERNET_MAX_URL_LENGTH];
IStream *stream;
IBindCtx *bctx;
IMoniker *moniker;
IPersistStreamInit *persist;
HRESULT hr;
TRACE("(%p, %s)\n", iface, debugstr_w(p));
if (!p)
return E_INVALIDARG;
if (!PathIsURLW(p))
{
WCHAR fullpath[MAX_PATH];
DWORD needed = sizeof(url) / sizeof(WCHAR);
if (!PathSearchAndQualifyW(p, fullpath, sizeof(fullpath) / sizeof(WCHAR)))
{
ERR("can't find path\n");
return E_FAIL;
}
if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
{
ERR("can't create url from path\n");
return E_FAIL;
}
p = url;
}
hr = CreateURLMoniker(NULL, p, &moniker);
if (FAILED(hr))
return hr;
CreateAsyncBindCtx(0, &xmldoc_bsc.IBindStatusCallback_iface, 0, &bctx);
hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
IBindCtx_Release(bctx);
IMoniker_Release(moniker);
if (FAILED(hr))
return hr;
hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
if (FAILED(hr))
{
IStream_Release(stream);
return hr;
}
hr = IPersistStreamInit_Load(persist, stream);
IPersistStreamInit_Release(persist);
IStream_Release(stream);
return hr;
}
static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
{
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
DWORD size;
HRESULT hres;
if(PathIsURLW(url))
return CreateURLMoniker(NULL, url, mon);
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
TRACE("was %s got %s\n", debugstr_w(url), debugstr_w(new_url));
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
return hres;
}
return CreateURLMoniker(NULL, new_url, mon);
}
static HRESULT WINAPI PHBindHost_CreateMoniker(IBindHost *iface, LPOLESTR szName, IBindCtx *pBC, IMoniker **ppmk, DWORD dwReserved)
{
PluginHost *This = impl_from_IBindHost(iface);
TRACE("(%p)->(%s %p %p %x)\n", This, debugstr_w(szName), pBC, ppmk, dwReserved);
if(!This->doc || !This->doc->window || !This->doc->window->mon) {
FIXME("no moniker\n");
return E_UNEXPECTED;
}
return CreateURLMoniker(This->doc->window->mon, szName, ppmk);
}
static nsresult NSAPI nsURIContentListener_OnStartURIOpen(nsIURIContentListener *iface,
nsIURI *aURI, PRBool *_retval)
{
NSContainer *This = NSURICL_THIS(iface);
nsIWineURI *wine_uri;
nsACString spec_str;
const char *spec;
nsresult nsres;
nsACString_Init(&spec_str, NULL);
nsIURI_GetSpec(aURI, &spec_str);
nsACString_GetData(&spec_str, &spec, NULL);
TRACE("(%p)->(%p(%s) %p)\n", This, aURI, debugstr_a(spec), _retval);
nsACString_Finish(&spec_str);
nsres = nsIURI_QueryInterface(aURI, &IID_nsIWineURI, (void**)&wine_uri);
if(NS_FAILED(nsres)) {
WARN("Could not get nsIWineURI interface: %08lx\n", nsres);
return NS_ERROR_NOT_IMPLEMENTED;
}
nsIWineURI_SetNSContainer(wine_uri, This);
if(This->bscallback && This->bscallback->mon) {
LPWSTR url;
HRESULT hres;
hres = IMoniker_GetDisplayName(This->bscallback->mon, NULL, 0, &url);
if(SUCCEEDED(hres)) {
IMoniker *mon = NULL;
hres = CreateURLMoniker(NULL, url, &mon);
if(SUCCEEDED(hres)) {
nsIWineURI_SetMoniker(wine_uri, mon);
IMoniker_Release(mon);
}else {
WARN("CreateURLMoniker failed: %08lx\n", hres);
}
}else {
WARN("GetDisplayName failed: %08lx\n", hres);
}
}
nsIWineURI_Release(wine_uri);
return NS_ERROR_NOT_IMPLEMENTED;
}
/***********************************************************************
* MkParseDisplayNameEx (URLMON.@)
*/
HRESULT WINAPI MkParseDisplayNameEx(IBindCtx *pbc, LPCWSTR szDisplayName, ULONG *pchEaten, LPMONIKER *ppmk)
{
TRACE("(%p %s %p %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
if(is_registered_protocol(szDisplayName)) {
HRESULT hres;
hres = CreateURLMoniker(NULL, szDisplayName, ppmk);
if(SUCCEEDED(hres)) {
*pchEaten = strlenW(szDisplayName);
return hres;
}
}
return MkParseDisplayName(pbc, szDisplayName, pchEaten, ppmk);
}
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 HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
{
HTMLDocument *This = impl_from_IPersistStreamInit(iface);
IMoniker *mon;
HRESULT hres;
TRACE("(%p)\n", This);
hres = CreateURLMoniker(NULL, about_blankW, &mon);
if(FAILED(hres)) {
WARN("CreateURLMoniker failed: %08x\n", hres);
return hres;
}
prepare_for_binding(This, mon, FALSE);
hres = set_moniker(This->window, mon, NULL, NULL, NULL, FALSE);
IMoniker_Release(mon);
if(FAILED(hres))
return hres;
return channelbsc_load_stream(This->window->pending_window, NULL);
}
/***********************************************************************
* URLDownloadToFileW (URLMON.@)
*
* Downloads URL szURL to file szFileName and call lpfnCB callback to
* report progress.
*
* PARAMS
* pCaller [I] controlling IUnknown interface.
* szURL [I] URL of the file to download
* szFileName [I] file name to store the content of the URL
* dwReserved [I] reserved - set to 0
* lpfnCB [I] callback for progress report
*
* RETURNS
* S_OK on success
*/
HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller, LPCWSTR szURL, LPCWSTR szFileName,
DWORD dwReserved, LPBINDSTATUSCALLBACK lpfnCB)
{
IBindStatusCallback *callback;
IUnknown *unk;
IMoniker *mon;
IBindCtx *bindctx;
HRESULT hres;
TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
if(pCaller)
FIXME("pCaller not supported\n");
hres = DownloadBSC_Create(lpfnCB, szFileName, &callback);
if(FAILED(hres))
return hres;
hres = CreateAsyncBindCtx(0, callback, NULL, &bindctx);
IBindStatusCallback_Release(callback);
if(FAILED(hres))
return hres;
hres = CreateURLMoniker(NULL, szURL, &mon);
if(FAILED(hres)) {
IBindCtx_Release(bindctx);
return hres;
}
hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
IMoniker_Release(mon);
IBindCtx_Release(bindctx);
if(unk)
IUnknown_Release(unk);
return hres == MK_S_ASYNCHRONOUS ? S_OK : hres;
}
static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
{
HTMLDocument *This = impl_from_IPersistStreamInit(iface);
IMoniker *mon;
HRESULT hres;
static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
TRACE("(%p)\n", This);
hres = CreateURLMoniker(NULL, about_blankW, &mon);
if(FAILED(hres)) {
WARN("CreateURLMoniker failed: %08x\n", hres);
return hres;
}
hres = set_moniker(This, mon, NULL, NULL, FALSE);
IMoniker_Release(mon);
if(FAILED(hres))
return hres;
return channelbsc_load_stream(This->window->bscallback, NULL);
}
static HRESULT URLStartDownload(LPCWSTR szURL, LPSTREAM *ppStream, IBindStatusCallback *pBSC)
{
HRESULT hr;
IMoniker *pMoniker;
IBindCtx *pbc;
*ppStream = NULL;
hr = CreateURLMoniker(NULL, szURL, &pMoniker);
if (FAILED(hr))
return hr;
hr = CreateBindCtx(0, &pbc);
if (FAILED(hr))
{
IMoniker_Release(pMoniker);
return hr;
}
hr = RegisterBindStatusCallback(pbc, pBSC, NULL, 0);
if (FAILED(hr))
{
IBindCtx_Release(pbc);
IMoniker_Release(pMoniker);
return hr;
}
hr = IMoniker_BindToStorage(pMoniker, pbc, NULL, &IID_IStream, (void **)ppStream);
/* BindToStorage returning E_PENDING because it's asynchronous is not an error */
if (hr == E_PENDING) hr = S_OK;
IBindCtx_Release(pbc);
IMoniker_Release(pMoniker);
return hr;
}
static BOOL start_download(void)
{
IBindCtx *bind_ctx;
IMoniker *mon;
IUnknown *tmp;
HRESULT hres;
hres = CreateURLMoniker(NULL, url, &mon);
if(FAILED(hres))
return FALSE;
hres = CreateAsyncBindCtx(0, &InstallCallback, NULL, &bind_ctx);
if(SUCCEEDED(hres)) {
hres = IMoniker_BindToStorage(mon, bind_ctx, NULL, &IID_IUnknown, (void**)&tmp);
IBindCtx_Release(bind_ctx);
}
IMoniker_Release(mon);
if(FAILED(hres))
return FALSE;
if(tmp)
IUnknown_Release(tmp);
return TRUE;
}
static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
{
HTMLDocument *This = impl_from_IPersistStreamInit(iface);
IMoniker *mon;
HRESULT hres;
static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
TRACE("(%p)->(%p)\n", This, pStm);
hres = CreateURLMoniker(NULL, about_blankW, &mon);
if(FAILED(hres)) {
WARN("CreateURLMoniker failed: %08x\n", hres);
return hres;
}
prepare_for_binding(This, mon, FALSE);
hres = set_moniker(This, mon, NULL, NULL, TRUE);
IMoniker_Release(mon);
if(FAILED(hres))
return hres;
return channelbsc_load_stream(This->window->pending_window, pStm);
}
//Function which takes input of An HTML Resource Id
BOOL CInfoDlg::ShowDialog(UINT idAboutHTMLID, HINSTANCE hInstance)
{
//Load the IE Specific MSTML Interface DKK
HINSTANCE hinstMSHTML = LoadLibrary(_T("MSHTML.DLL"));
BOOL bSuccess = FALSE;
if(hinstMSHTML)
{
SHOWHTMLDIALOGFN *pfnShowHTMLDialog;
//Locate The Function ShowHTMLDialog in the Loaded MSHTML.DLL
pfnShowHTMLDialog = (SHOWHTMLDIALOGFN*)GetProcAddress(hinstMSHTML, "ShowHTMLDialog");
if(pfnShowHTMLDialog)
{
LPTSTR lpszModule = new TCHAR[MAX_PATH];
//Get The Application Path
if (GetModuleFileName(hInstance, lpszModule, MAX_PATH))
{
//Add the IE Res protocol
TCHAR strResourceURL[MAX_PATH*4];
_stprintf_s(strResourceURL, _countof(strResourceURL), _T("res://%s/%u"), lpszModule, idAboutHTMLID);
//Attempt to Create the URL Moniker to the specified in the URL String
IMoniker *pmk;
if(SUCCEEDED(CreateURLMoniker(NULL,strResourceURL,&pmk)))
{
//Invoke the ShowHTMLDialog function by pointer
//passing the HWND of your Application , the Moniker,
//the remaining parameters can be set to NULL
pfnShowHTMLDialog(NULL,pmk,NULL,L"resizable:yes",NULL);
bSuccess = TRUE;
}
}
delete [] lpszModule;
}
FreeLibrary(hinstMSHTML);
}
return bSuccess;
}
STDMETHODIMP CLHTMLActiveDocument::put_src(/*[in]*/ BSTR newVal)
{
ATLASSERT(0);
#if 0
StopPlay();
if (m_textData)
{
m_textData.Release();
}
if (m_pWindow)
{
#if 0
m_pWindow->Free();
#endif
m_pWindow->Release();
m_pWindow = NULL;
m_spInPlaceSite->InvalidateRect(NULL, TRUE);
}
m_src = newVal;
CComQIPtr<IServiceProvider> sp = m_spClientSite;
if (sp)
{
CComPtr<IMoniker> imkName;
CComPtr<IBindHost> bindHost;
if (SUCCEEDED(sp->QueryService(SID_SBindHost, &bindHost)))
{
bindHost->CreateMoniker(m_src, NULL, &imkName, 0);
}
else
{
CreateURLMoniker(NULL, m_src, &imkName);
}
if (imkName)
{
// Note I'm creating the window before loading the document
CComObject<CLHTMLWindow2>::CreateInstance(&m_pWindow);
if (m_pWindow)
{
m_pWindow->AddRef();
// m_hWnd = m_hWnd;
#if 0 // I Had this
m_pWindow->m_pActiveDocument = this;
#endif
// TODO, init scripting if not already done?
CComPtr<IBindCtx> bctx;
if (SUCCEEDED(CreateBindCtx(0/*reserved*/, &bctx)))
{
Load(FALSE, imkName, bctx, 0);
if (m_document)
{
CComQIPtr<ILDOMDocumentView> documentView = m_document;
documentView->createPresentation(&m_view);
// SetDocument(document);
if (FALSE)
{
StartPlay();
}
m_pWindow->m_pCanvas->m_pView = static_cast<CHTMLDocumentView*>(m_view.p);
m_pWindow->m_pCanvas->m_htmTree = m_pWindow->m_pCanvas->m_pView->m_pRootElement;
// CComQIPtr<ILDOMDocumentView> documentView = m_document;
// documentView->createPresentation(&m_view);
// ATLASSERT(0);
#if 0
m_pView->SetDocument(m_document);
#endif
}
}
}
}
}
#endif
return S_OK;
}
static HRESULT WINAPI IHlink_fnSetStringReference(IHlink* iface,
DWORD grfHLSETF, LPCWSTR pwzTarget, LPCWSTR pwzLocation)
{
HlinkImpl *This = impl_from_IHlink(iface);
TRACE("(%p)->(%i %s %s)\n", This, grfHLSETF, debugstr_w(pwzTarget),
debugstr_w(pwzLocation));
if(grfHLSETF > (HLINKSETF_TARGET | HLINKSETF_LOCATION) &&
grfHLSETF < -(HLINKSETF_TARGET | HLINKSETF_LOCATION))
return grfHLSETF;
if (grfHLSETF & HLINKSETF_TARGET)
{
if (This->Moniker)
{
IMoniker_Release(This->Moniker);
This->Moniker = NULL;
}
if (pwzTarget && *pwzTarget)
{
IMoniker *pMon;
IBindCtx *pbc = NULL;
ULONG eaten;
HRESULT r;
r = CreateBindCtx(0, &pbc);
if (FAILED(r))
return E_OUTOFMEMORY;
r = MkParseDisplayName(pbc, pwzTarget, &eaten, &pMon);
IBindCtx_Release(pbc);
if (FAILED(r))
{
LPCWSTR p = strchrW(pwzTarget, ':');
if (p && (p - pwzTarget > 1))
r = CreateURLMoniker(NULL, pwzTarget, &pMon);
else
r = CreateFileMoniker(pwzTarget, &pMon);
if (FAILED(r))
{
ERR("couldn't create moniker for %s, failed with error 0x%08x\n",
debugstr_w(pwzTarget), r);
return r;
}
}
IHlink_SetMonikerReference(iface, HLINKSETF_TARGET, pMon, NULL);
IMoniker_Release(pMon);
}
}
if (grfHLSETF & HLINKSETF_LOCATION)
{
heap_free(This->Location);
This->Location = NULL;
if (pwzLocation && *pwzLocation)
This->Location = hlink_strdupW( pwzLocation );
}
return S_OK;
}
HRESULT bind_url(LPCWSTR url, HRESULT (*onDataAvailable)(void*,char*,DWORD), void *obj, bsc_t **ret)
{
WCHAR fileUrl[INTERNET_MAX_URL_LENGTH];
bsc_t *bsc;
IBindCtx *pbc;
HRESULT hr;
TRACE("%s\n", debugstr_w(url));
if(!PathIsURLW(url))
{
WCHAR fullpath[MAX_PATH];
DWORD needed = sizeof(fileUrl)/sizeof(WCHAR);
if(!PathSearchAndQualifyW(url, fullpath, sizeof(fullpath)/sizeof(WCHAR)))
{
WARN("can't find path\n");
return E_FAIL;
}
if(FAILED(UrlCreateFromPathW(url, fileUrl, &needed, 0)))
{
ERR("can't create url from path\n");
return E_FAIL;
}
url = fileUrl;
}
hr = CreateBindCtx(0, &pbc);
if(FAILED(hr))
return hr;
bsc = HeapAlloc(GetProcessHeap(), 0, sizeof(bsc_t));
bsc->lpVtbl = &bsc_vtbl;
bsc->ref = 1;
bsc->obj = obj;
bsc->onDataAvailable = onDataAvailable;
bsc->binding = NULL;
bsc->memstream = NULL;
hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&bsc->lpVtbl, NULL, 0);
if(SUCCEEDED(hr))
{
IMoniker *moniker;
hr = CreateURLMoniker(NULL, url, &moniker);
if(SUCCEEDED(hr))
{
IStream *stream;
hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
IMoniker_Release(moniker);
if(stream)
IStream_Release(stream);
}
IBindCtx_Release(pbc);
}
if(FAILED(hr))
{
IBindStatusCallback_Release((IBindStatusCallback*)&bsc->lpVtbl);
bsc = NULL;
}
*ret = bsc;
return hr;
}
// Returns the Secure Base URL to MSXML.
HRESULT CSiteImpl::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
{
return CreateURLMoniker(NULL, _secureBaseURL.c_str(), ppmk);
}
static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
{
BindStatusCallback *bsc;
IBindCtx *pbc;
HRESULT hr;
hr = CreateBindCtx(0, &pbc);
if (hr != S_OK) return hr;
bsc = heap_alloc(sizeof(*bsc));
if (!bsc)
{
IBindCtx_Release(pbc);
return E_OUTOFMEMORY;
}
bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
bsc->ref = 1;
bsc->request = This;
bsc->binding = NULL;
bsc->stream = NULL;
bsc->body = NULL;
TRACE("created callback %p\n", bsc);
if (This->verb != BINDVERB_GET)
{
if (V_VT(body) == VT_BSTR)
{
LONG size = SysStringLen(V_BSTR(body)) * sizeof(WCHAR);
void *ptr;
bsc->body = GlobalAlloc(GMEM_FIXED, size);
if (!bsc->body)
{
heap_free(bsc);
return E_OUTOFMEMORY;
}
ptr = GlobalLock(bsc->body);
memcpy(ptr, V_BSTR(body), size);
GlobalUnlock(bsc->body);
}
else
FIXME("unsupported body data type %d\n", V_VT(body));
}
hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
if (hr == S_OK)
{
IMoniker *moniker;
hr = CreateURLMoniker(NULL, This->url, &moniker);
if (hr == S_OK)
{
IStream *stream;
hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
IMoniker_Release(moniker);
if (stream) IStream_Release(stream);
}
IBindCtx_Release(pbc);
}
if (FAILED(hr))
{
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
bsc = NULL;
}
*obj = bsc;
return hr;
}
/*
* CSite::Load
*
* Purpose:
* Loads the path provided using IPersistMoniker or IPersistFile. If no path
* was provided it simply does an InitNew
*
* Parameters:
* pchPath - The path
*
* Return Value:
*/
HRESULT CSite::Load(LPCTSTR pchPath)
{
HRESULT hr = S_OK;
if ( pchPath != NULL && *pchPath != 0)
{
USES_CONVERSION;
LPWSTR szwName = T2W(const_cast<LPTSTR>(pchPath));
// Path has been provided so check should we use IPersistMoniker or IPersistFile?
if (memcmp(pchPath, _T("file:"), 5 * sizeof(TCHAR)) == 0 ||
memcmp(pchPath, _T("http:"), 5 * sizeof(TCHAR)) == 0 ||
memcmp(pchPath, _T("https:"), 5 * sizeof(TCHAR)) == 0)
{
// OLECHAR szwName[256];
// MultiByteToWideChar(CP_ACP, 0, pchPath, -1, szwName, 256);
// 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 = m_pObj->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();
}
ReleaseInterface(pPMk);
}
ReleaseInterface( pIMoniker );
}
}
else if ( m_pFR->IsFilterIn() )
{
IPersistStreamInit* pPStm = NULL;
LPSTREAM pFilteredStream = NULL;
DWORD dwFlags = 0;
// dwFlags = ((CCEditApp*) AfxGetApp())->GetOptions().GetFilterFlags();
// dwFlags |= dwFilterMultiByteStream; // loading an ANSI Stream
hr = m_pObj->QueryInterface(
IID_IPersistStreamInit,
(void **)&pPStm);
if ( SUCCEEDED(hr) )
{
if (SUCCEEDED(hr = HrFilterIn(pchPath, &pFilteredStream, dwFlags)))
{
hr = pPStm->Load(pFilteredStream);
ReleaseInterface(pFilteredStream);
ReleaseInterface(pPStm);
}
}
}
else
{
// OLECHAR szwName[256];
// MultiByteToWideChar(CP_ACP, 0, pchPath, -1, szwName, 256);
IPersistFile* pPFile;
hr = m_pObj->QueryInterface(
IID_IPersistFile,
(void **) &pPFile);
if ( SUCCEEDED(hr) )
{
// Call Load on the IPersistFile
hr = pPFile->Load((LPWSTR)szwName, 0);
ReleaseInterface(pPFile);
}
}
}
else
{
// No path provided so just do an InitNew on the Stream
IPersistStreamInit* pPStm;
hr = m_pObj->QueryInterface(
IID_IPersistStreamInit,
(void **)&pPStm);
if ( SUCCEEDED(hr) )
{
hr = pPStm->InitNew();
ReleaseInterface(pPStm);
}
}
return hr;
}
STDMETHODIMP CLX3DViewer::put_src(/*[in]*/ BSTR newVal)
{
HRESULT hr;
m_src = newVal;
CComPtr<IServiceProvider> sp;
hr = m_spClientSite->QueryInterface(IID_IServiceProvider, (void**)&sp);
if (SUCCEEDED(hr))
{
CComPtr<IBindHost> bindHost;
hr = sp->QueryService(SID_SBindHost, &bindHost);
if (SUCCEEDED(hr))
{
CComPtr<IMoniker> imkName;
CComPtr<IBindCtx> ctx;
hr = CreateBindCtx(0/*reserved*/, &ctx);
if (SUCCEEDED(hr))
{
hr = bindHost->CreateMoniker(m_src, NULL, &imkName, 0);
if (SUCCEEDED(hr))
{
hr = m_filterGraph.CoCreateInstance(CLSID_LFilterGraph);
if (SUCCEEDED(hr))
{
hr = m_filterGraph->AddSourceFilterForMoniker(imkName, ctx, L"", NULL);
if (SUCCEEDED(hr))
{
CComQIPtr<ILMediaSeeking> seeking = m_filterGraph;
LONGLONG duration;
seeking->GetDuration(&duration);
m_duration = duration / 100000.0;
if (m_duration > 0)
{
m_slider.Enable(TRUE);
m_slider.SetMaxPos(m_duration);
}
else
{
m_slider.Enable(FALSE);
}
// find the renderer filter
CComPtr<ILBasicVideo> basicVideo;
m_filterGraph->QueryFilterInterface(IID_ILBasicVideo, (IUnknown**)&basicVideo);
if (basicVideo)
{
m_basicVideo = basicVideo;
}
}
}
}
}
}
}
return hr;
#if 0
#if 0
m_viewpointStack.RemoveAll();
m_navigationinfoStack.RemoveAll();
#endif
if (m_scene)
{
m_scene->Release();
m_scene = NULL;
}
CComBSTR m_src = newVal;
CComQIPtr<IServiceProvider> sp = m_spClientSite;
if (sp)
{
CComPtr<IMoniker> imkName;
CComPtr<IBindHost> bindHost;
if (SUCCEEDED(sp->QueryService(SID_SBindHost, &bindHost)))
{
bindHost->CreateMoniker(m_src, NULL, &imkName, 0);
}
else
{
CreateURLMoniker(NULL, m_src, &imkName);
}
if (imkName)
{
CComPtr<IBindCtx> bctx;
if (SUCCEEDED(CreateBindCtx(0/*reserved*/, &bctx)))
{
CComPtr<IStream> stream;
imkName->BindToStorage(bctx, NULL, IID_IStream, (void**)&stream);
if (stream)
{
LPOLESTR szDisplayName;
imkName->GetDisplayName(bctx, NULL, &szDisplayName);
_bstr_t url = szDisplayName;
CoTaskMemFree(szDisplayName);
LPTSTR ext = PathFindExtension(url);
if (ext && !strcmp(ext, ".mp4"))
{
m_file.CoCreateInstance(L"LMPEG4.MP4File");
if (m_file)
{
//CComPtr<ILX3DScene> scene;
CComPtr<IUnknown> unk;
m_file->OpenStream(stream);
//m_scene = static_cast<CComObject<CLSAIScene>*>(scene.p);
//scene.Detach();
CComQIPtr<ILBaseFilter> baseFilter = m_file;
if (baseFilter)
{
CComPtr<ILPin> outputpin;
baseFilter->GetPin(0, &outputpin);
CComObject<CMoviePlayerFilter>::CreateInstance(&m_pFilter);
m_pFilter->AddRef();
m_pFilter->m_pMoviePlayer = this;
// TODO, don't have it like this
CComPtr<ILReferenceClock> clock;
clock.CoCreateInstance(L"LMedia.LSystemClock");
m_pFilter->m_clock = clock.Detach();
m_pFilter->m_tStart = 0;
outputpin->Connect(m_pFilter->m_pInput, NULL/*pMediaType*/);
if (TRUE)
{
baseFilter->Run(0);
}
}
else
{
::MessageBox(NULL, "Error opening file", "LViewer", MB_OK);
}
}
}
else
{
CComObject<CLSAIScene>::CreateInstance(&m_scene);
if (m_scene)
{
m_scene->AddRef();
m_scene->m_url = (BSTR)url;
CoTaskMemFree(szDisplayName);
m_scene->readStream(stream);
#if 0
InitStacks();
#endif
}
}
}
}
}
}
#endif
return S_OK;
}
