#include "priv.h" #include #include "hlframe.h" #include "winlist.h" #include "resource.h" //CLSID_SearchBand #include "interned.h" // IHTMLPrivateWindow // Locally defined FINDFRAME flag used to guarantee ITargetFrame vs ITargetFrame2 compatibility #define FINDFRAME_OLDINTERFACE FINDFRAME_INTERNAL STDAPI SafeGetItemObject(LPSHELLVIEW psv, UINT uItem, REFIID riid, LPVOID *ppv); HRESULT TargetQueryService(LPUNKNOWN punk, REFIID riid, void **ppvObj); HRESULT CoCreateNewIEWindow( DWORD dwClsContext, REFIID riid, void **ppvunk ); /****************************************************************** NAME: SetOleStrMember SYNOPSIS: sets a new value for OleStr member ******************************************************************/ HRESULT SetOleStrMember(WCHAR **ppszMember, LPCOLESTR pszNewValue) { HRESULT hr; if (*ppszMember) { LocalFree(*ppszMember); *ppszMember = NULL; } if (pszNewValue) { *ppszMember = StrDupW(pszNewValue); hr = *ppszMember ? S_OK : E_OUTOFMEMORY; } else { *ppszMember = NULL; hr = S_OK; } return hr; } /****************************************************************** NAME: GetOleStrMember SYNOPSIS: gets a value for OleStr member as new CoTaskMemAlloc LPOLESTR ******************************************************************/ HRESULT GetOleStrMember(LPCOLESTR pszMember, WCHAR **ppszReturnValue) { HRESULT hr; if (pszMember) hr = SHStrDupW(pszMember, ppszReturnValue); else { hr = S_OK; *ppszReturnValue = NULL; } return hr; } /******************************************************************* NAME: CIEFrameAuto::SetFrameName SYNOPSIS: Sets the Frame Name. Frees current one if exists. ********************************************************************/ STDMETHODIMP CIEFrameAuto::SetFrameName(LPCOLESTR pszFrameName) { // AOL and other 3rd Party 3.0 compatibility. The ITargetNotify // object that sets off a window open operation via AOL container // registers itself in ShellCallbacks list and wnsprintf's the // coresponding cookie in the front of the frame name ("" if there // is no frame name as in _blank). we extract the cookie, notify // all registered callbacks, then set the name MINUS the _[NNNNN..] // that was prepending to the frame name. if (pszFrameName && pszFrameName[0] == '_' && pszFrameName[1] == '[') { #define MAX_COOKIE 24 WCHAR wszCookie[MAX_COOKIE + 1]; // big enough for "cbCookie" int i; long cbCookie; BOOL fNonDigit = FALSE; IShellWindows* psw = NULL; for (i = 2; i < MAX_COOKIE && pszFrameName[i] && pszFrameName[i] != ']'; i++) { wszCookie[i-2] = pszFrameName[i]; if (i != 2 || pszFrameName[2] != '-') fNonDigit = fNonDigit || pszFrameName[i] < '0' || pszFrameName[i] > '9'; } wszCookie[i-2] = 0; if (i >= 3 && pszFrameName[i] == ']' && !fNonDigit) { cbCookie = StrToIntW(wszCookie); psw = WinList_GetShellWindows(TRUE); if (psw) { IUnknown *punkThis; if (SUCCEEDED(QueryInterface(IID_IUnknown, (LPVOID *) &punkThis))) { psw->OnCreated(cbCookie, punkThis); punkThis->Release(); } psw->Release(); } pszFrameName = pszFrameName + i + 1; if (pszFrameName[0] == 0) pszFrameName = NULL; } } return SetOleStrMember(&m_pszFrameName, pszFrameName); } /******************************************************************* NAME: CIEFrameAuto::GetFrameName SYNOPSIS: Gets the Frame Name. Allocates a copy (this is an [OUT] parameter ********************************************************************/ STDMETHODIMP CIEFrameAuto::GetFrameName(WCHAR **ppszFrameName) { return GetOleStrMember(m_pszFrameName, ppszFrameName); } /******************************************************************* NAME: CIEFrameAuto::_GetParentFramePrivate SYNOPSIS: Gets an the IUnknown pointer of the parent frame, or NULL if this is a top level frame. This pointer must be Released by Caller after use. IMPLEMENTATION: A Frame Container is required to implement ITargetFrame::GetParentFrame and implement GetParentFrame by returning the IUnknown pointer of the Browser that hosts it. A Browser implements GetParentFrame by returning NULL if it's top level or calling GetParentFrame on its Container if it is embedded. NOTE: THIS PRIVATE VERSION doesn't check for parent being desktopframe. ********************************************************************/ HRESULT CIEFrameAuto::_GetParentFramePrivate(LPUNKNOWN *ppunkParentFrame) { LPOLEOBJECT pOleObject = NULL; LPOLECLIENTSITE pOleClientSite = NULL; HRESULT hr = S_OK; LPUNKNOWN punkParent = NULL; // Start off with OleObject for this OCX embedding, it will // be null if we're top level (a CIEFrameAuto, not a CVOCBrowser) _GetOleObject(&pOleObject); if (pOleObject != NULL) { // Assumes GetClientSite succeeds and returns NULL if we // are not embedded hr = pOleObject->GetClientSite( &pOleClientSite); if (FAILED(hr)) goto errExit; pOleObject->Release(); pOleObject = NULL; // If pOleClientSite is NULL, then we are at the top level if (pOleClientSite == NULL) { hr = S_OK; goto errExit; } else { hr = TargetQueryService(pOleClientSite, IID_IUnknown, (LPVOID*)&punkParent); if (FAILED(hr)) { // if parent container does not support ITargetFrame, then // the parent container must be some other app, like VB. In this // case, we've already found the outermost frame (us). Return // S_OK and a NULL ptgfTargetFrame which indicates that we are the // outermost HTML frame. hr = S_OK; } SAFERELEASE(pOleClientSite); } } errExit: SAFERELEASE(pOleObject); SAFERELEASE(pOleClientSite); *ppunkParentFrame = punkParent; return hr; } /******************************************************************* NAME: CIEFrameAuto::GetParentFrame SYNOPSIS: Gets an the IUnknown pointer of the parent frame, or NULL if this is a top level frame. This pointer must be Released by Caller after use. IMPLEMENTATION: A Frame Container is required to implement ITargetFrame::GetParentFrame and implement GetParentFrame by returning the IUnknown pointer of the Browser that hosts it. A Browser implements GetParentFrame by returning NULL if it's top level or calling GetParentFrame on its Container if it is embedded. ********************************************************************/ STDMETHODIMP CIEFrameAuto::GetParentFrame(LPUNKNOWN *ppunkParentFrame) { HRESULT hr = _GetParentFramePrivate(ppunkParentFrame); // Check if the parent is the desktop, if so, the frame chain stops // at us if (SUCCEEDED(hr) && *ppunkParentFrame) { LPTARGETFRAME2 ptgfParent; DWORD dwOptions; if (SUCCEEDED((*ppunkParentFrame)->QueryInterface(IID_ITargetFrame2, (LPVOID *)&ptgfParent))) { ptgfParent->GetFrameOptions(&dwOptions); if (dwOptions & FRAMEOPTIONS_DESKTOP) { (*ppunkParentFrame)->Release(); *ppunkParentFrame = NULL; } ptgfParent->Release(); } } return hr; } // PLEASE PROPOGATE ANY CHANGES TO THESE ENUMS TO \mshtml\iextag\httpwfh.h typedef enum _TARGET_TYPE { TARGET_FRAMENAME, TARGET_SELF, TARGET_PARENT, TARGET_BLANK, TARGET_TOP, TARGET_MAIN, TARGET_SEARCH, TARGET_MEDIA } TARGET_TYPE; typedef struct _TARGETENTRY { TARGET_TYPE targetType; const WCHAR *pTargetValue; } TARGETENTRY; static const TARGETENTRY targetTable[] = { {TARGET_SELF, L"_self"}, {TARGET_PARENT, L"_parent"}, {TARGET_BLANK, L"_blank"}, {TARGET_TOP, L"_top"}, {TARGET_MAIN, L"_main"}, {TARGET_SEARCH, L"_search"}, {TARGET_MEDIA, L"_media"}, {TARGET_SELF, NULL} }; /******************************************************************* NAME: ParseTargetType SYNOPSIS: Maps pszTarget into a target class. IMPLEMENTATION: Treats unknown MAGIC targets as _self ********************************************************************/ // PLEASE PROPOGATE ANY CHANGES TO THIS FUNCTION TO \mshtml\iextag\httpwf.cxx TARGET_TYPE ParseTargetType(LPCOLESTR pszTarget) { const TARGETENTRY *pEntry = targetTable; if (pszTarget[0] != '_') return TARGET_FRAMENAME; while (pEntry->pTargetValue) { if (!StrCmpW(pszTarget, pEntry->pTargetValue)) return pEntry->targetType; pEntry++; } // Treat unknown MAGIC targets as regular frame name! <> return TARGET_FRAMENAME; } /******************************************************************* NAME: TargetQueryService SYNOPSIS: Returns a pointer to containing Browser's ITargetFrame interface (or NULL if container does not support it) NOTES: If we don't yet have this interface pointer yet, this function will QueryInterface to get it. ********************************************************************/ HRESULT TargetQueryService(LPUNKNOWN punk, REFIID riid, void **ppvObj) { // Get the ITargetFrame for the embedding. return IUnknown_QueryService(punk, IID_ITargetFrame2, riid, ppvObj); } /******************************************************************* NAME: _TargetTopLevelWindows SYNOPSIS: see FindFrame, does the named targets across windows ********************************************************************/ HRESULT _TargetTopLevelWindows(LPTARGETFRAMEPRIV ptgfpThis, LPCOLESTR pszTargetName, DWORD dwFlags, LPUNKNOWN *ppunkTargetFrame) { IShellWindows* psw = NULL; HRESULT hr = E_FAIL; *ppunkTargetFrame = NULL; psw = WinList_GetShellWindows(TRUE); if (psw != NULL) { IUnknown *punkEnum; IEnumVARIANT *penumVariant; VARIANT VarResult; BOOL fDone = FALSE; LPTARGETFRAMEPRIV ptgfpWindowFrame; hr = psw->_NewEnum(&punkEnum); if (SUCCEEDED(hr)) { hr = punkEnum->QueryInterface(IID_IEnumVARIANT, (LPVOID *)&penumVariant); if (SUCCEEDED(hr)) { while (!fDone) { VariantInit(&VarResult); hr = penumVariant->Next(1, &VarResult, NULL); if (hr == NOERROR) { if (VarResult.vt == VT_DISPATCH && VarResult.pdispVal) { hr = VarResult.pdispVal->QueryInterface(IID_ITargetFramePriv, (LPVOID *)&ptgfpWindowFrame); if (SUCCEEDED(hr)) { if (ptgfpWindowFrame != ptgfpThis) { hr = ptgfpWindowFrame->FindFrameDownwards(pszTargetName, dwFlags, ppunkTargetFrame); if (SUCCEEDED(hr) && *ppunkTargetFrame != NULL) { fDone = TRUE; } } ptgfpWindowFrame->Release(); } } } else fDone = TRUE; VariantClear(&VarResult); } penumVariant->Release(); } punkEnum->Release(); } psw->Release(); } return hr; } /******************************************************************* NAME: CreateTargetFrame SYNOPSIS: Creates a new window, if pszTargetName is not special target, names it pszTargetName. returns IUnknown for the object that implements ITargetFrame,IHlinkFrame and IWebBrowserApp. ********************************************************************/ // PLEASE PROPOGATE ANY CHANGES TO THIS FUNCTION TO \mshtml\iextag\httpwf.cxx HRESULT CreateTargetFrame(LPCOLESTR pszTargetName, LPUNKNOWN /*IN,OUT*/ *ppunk) { LPTARGETFRAME2 ptgfWindowFrame; HRESULT hr = S_OK; // Launch a new window, set it's frame name to pszTargetName // return it's IUnknown. If the new window is passed to us, // just set the target name. if (NULL == *ppunk) { #ifndef UNIX hr = CoCreateNewIEWindow(CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, IID_IUnknown, (LPVOID*)ppunk); #else hr = CoCreateInternetExplorer( IID_IUnknown, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER, (LPVOID*) ppunk ); #endif } if (SUCCEEDED(hr)) { // Don't set frame name if target is special or missing if (pszTargetName && ParseTargetType(pszTargetName) == TARGET_FRAMENAME) { HRESULT hrLocal; hrLocal = (*ppunk)->QueryInterface(IID_ITargetFrame2, (LPVOID *)&ptgfWindowFrame); if (SUCCEEDED(hrLocal)) { ptgfWindowFrame->SetFrameName(pszTargetName); ptgfWindowFrame->Release(); } } // Even if we don't set the frame name, we still want to return // success, otherwise we'd have a blank window hanging around. } return hr; } /******************************************************************* NAME: CIEFrameAuto::_DoNamedTarget SYNOPSIS: see FindFrame, does the named targets. checks itself then if that fails, all children except for punkContextFrame (if punkContextFrame != NULL). if all of the above fail, will recurse upwards if necessary, if punkContextFrame != NULL. if punkContextFrame is NULL, then this works out to checking ourself and all children then giving up. ********************************************************************/ HRESULT CIEFrameAuto::_DoNamedTarget(LPCOLESTR pszTargetName, LPUNKNOWN punkContextFrame, DWORD dwFlags, LPUNKNOWN * ppunkTargetFrame) { // asserts HRESULT hr = S_OK; HRESULT hrLocal; LPUNKNOWN punkParent = NULL; LPUNKNOWN punkThisFrame = NULL; LPTARGETFRAMEPRIV ptgfpParent = NULL; LPUNKNOWN punkThis = NULL; LPUNKNOWN punkChildObj = NULL; LPUNKNOWN punkChildFrame = NULL; LPTARGETFRAMEPRIV ptgfpChild = NULL; LPOLECONTAINER pOleContainer = NULL; LPENUMUNKNOWN penumUnknown = NULL; LPUNKNOWN punkProxyContextFrame = NULL; LPTARGETFRAMEPRIV ptgfpTarget = NULL; ASSERT(ppunkTargetFrame); *ppunkTargetFrame = NULL; hr = QueryInterface(IID_IUnknown, (LPVOID*)&punkThis); ASSERT(punkThis != NULL); if (FAILED(hr)) goto exitPoint; // First check for match on US! if (m_pszFrameName && !StrCmpW(pszTargetName, m_pszFrameName)) { *ppunkTargetFrame = punkThis; // Set punkThis to NULL to prevent Release at exit punkThis = NULL; goto exitPoint; } // we ask our ShellView's embedded DocObject if it supports ITargetFrame. If it does, // we first let it look for the target. hrLocal = GetFramesContainer(&pOleContainer); if (SUCCEEDED(hrLocal) && pOleContainer != NULL) { hr = pOleContainer->EnumObjects(OLECONTF_EMBEDDINGS, &penumUnknown); if (hr != S_OK || penumUnknown == NULL) goto exitPoint; while (TRUE) { hr = penumUnknown->Next(1, &punkChildObj, NULL); if (punkChildObj == NULL) { hr = S_OK; break; } hrLocal = punkChildObj->QueryInterface(IID_ITargetFramePriv, (LPVOID *) &ptgfpChild); if (SUCCEEDED(hrLocal)) { hr = ptgfpChild->QueryInterface(IID_IUnknown, (LPVOID *) &punkChildFrame); if (FAILED(hr)) goto exitPoint; // IF this isn't the punkContextFrame, see if embedding supports ITargetFrame if (punkChildFrame != punkContextFrame) { hr = ptgfpChild->FindFrameDownwards(pszTargetName, dwFlags, ppunkTargetFrame); if (hr != S_OK || *ppunkTargetFrame != NULL) goto exitPoint; } } punkChildObj->Release(); punkChildObj = NULL; SAFERELEASE(punkChildFrame); SAFERELEASE(ptgfpChild); } } if (!(*ppunkTargetFrame) && pOleContainer) { hr = _FindWindowByName(pOleContainer, pszTargetName, ppunkTargetFrame); if (S_OK == hr) goto exitPoint; } // We don't recurse to parent in punkContextFrame is NULL if (punkContextFrame == NULL) goto exitPoint; hr = GetParentFrame(&punkParent); if (hr != S_OK) goto exitPoint; if (punkParent != NULL) { // We have a parent, recurse upwards, with ourself as context frame hr = punkParent->QueryInterface(IID_ITargetFramePriv, (LPVOID*)&ptgfpParent); if (hr != S_OK) goto exitPoint; hr = ptgfpParent->FindFrameInContext(pszTargetName, punkThis, dwFlags, ppunkTargetFrame); goto exitPoint; } // At this point we've come to the top level frame. // Enumerate top level windows, unless we're a toolbar *ppunkTargetFrame = NULL; if (_psb != _psbProxy) { // Webbar : Find in context of top frame of proxy hr = TargetQueryService(_psbProxy, IID_ITargetFramePriv, (LPVOID *) &ptgfpTarget); if (SUCCEEDED(hr) && ptgfpTarget) { hr = ptgfpTarget->QueryInterface(IID_IUnknown, (LPVOID *) &punkProxyContextFrame); if (SUCCEEDED(hr)) { hr = ptgfpTarget->FindFrameInContext(pszTargetName, punkProxyContextFrame, dwFlags, ppunkTargetFrame); if (*ppunkTargetFrame) goto exitPoint; } } } else if (!(FINDFRAME_OLDINTERFACE & dwFlags)) { hr = _TargetTopLevelWindows((LPTARGETFRAMEPRIV)this, pszTargetName, dwFlags, ppunkTargetFrame); if (*ppunkTargetFrame) goto exitPoint; } // Now we have exhausted all frames. Unless FINDFRAME_JUSTTESTEXISTENCE // is set in dwFlags, create a new window, set it's frame name and return it if (dwFlags & FINDFRAME_JUSTTESTEXISTENCE) { hr = S_OK; } else { // CreateTargetFrame will not work with AOL 3.01 clients // so we must return E_FAIL hr = E_FAIL; } exitPoint: SAFERELEASE(punkProxyContextFrame); SAFERELEASE(ptgfpTarget); SAFERELEASE(punkThis); SAFERELEASE(punkThisFrame); SAFERELEASE(ptgfpParent); SAFERELEASE(punkParent); SAFERELEASE(punkChildFrame); SAFERELEASE(ptgfpChild); SAFERELEASE(penumUnknown); SAFERELEASE(pOleContainer); SAFERELEASE(punkChildObj); return hr; } //+------------------------------------------------------------------------- // // Method : CIEFrameAuto::_FindWindowByName // // Synopsis : Searches the give container for the given frame name. // This method is called when _DoNamedTarget fails to find // the target frame in one of the container's embeddings. // //+------------------------------------------------------------------------- HRESULT CIEFrameAuto::_FindWindowByName(IOleContainer * pOleContainer, LPCOLESTR pszTargetName, LPUNKNOWN * ppunkTargetFrame) { HRESULT hr; IHTMLDocument2 * pDocument; IHTMLPrivateWindow * pPrivWindow; IHTMLWindow2 * pHTMLWindow; IServiceProvider * pServiceProvider; IWebBrowserApp * pWebBrowserApp; ASSERT(pOleContainer); ASSERT(ppunkTargetFrame); hr = pOleContainer->QueryInterface(IID_IHTMLDocument2, (void**)&pDocument); if (SUCCEEDED(hr)) { hr = pDocument->get_parentWindow(&pHTMLWindow); if (SUCCEEDED(hr)) { hr = pHTMLWindow->QueryInterface(IID_IHTMLPrivateWindow, (void**)&pPrivWindow); pHTMLWindow->Release(); if (SUCCEEDED(hr)) { hr = pPrivWindow->FindWindowByName(pszTargetName, &pHTMLWindow); if (S_OK == hr) { hr = pHTMLWindow->QueryInterface(IID_IServiceProvider, (void **) &pServiceProvider); if (S_OK == hr) { hr = pServiceProvider->QueryService(SID_SWebBrowserApp, IID_IWebBrowserApp, (void **) &pWebBrowserApp); if (S_OK == hr) { *ppunkTargetFrame = SAFECAST(pWebBrowserApp, IUnknown*); (*ppunkTargetFrame)->AddRef(); pWebBrowserApp->Release(); } pServiceProvider->Release(); } pHTMLWindow->Release(); } pPrivWindow->Release(); } } pDocument->Release(); } return hr; } /******************************************************************* NAME: CIEFrameAuto::SetFrameSrc SYNOPSIS: Sets the Frame original SRC url. Frees current one if exists. ********************************************************************/ HRESULT CIEFrameAuto::SetFrameSrc(LPCOLESTR pszFrameSrc) { return SetOleStrMember(&m_pszFrameSrc, pszFrameSrc); } IShellView* CIEFrameAuto::_GetShellView(void) { IShellView* psv = NULL; if (_psb) { _psb->QueryActiveShellView(&psv); } return psv; } /******************************************************************* NAME: CIEFrameAuto::GetFrameSrc SYNOPSIS: Gets the Frame original URL. Allocates a copy (this is an [OUT] parameter NOTES: If we are at top level, SRC is dynamic, so ask our contained DocObject to do it for us. ********************************************************************/ HRESULT CIEFrameAuto::GetFrameSrc(WCHAR **ppszFrameSrc) { LPUNKNOWN punkParent = NULL; LPTARGETFRAME ptgfTargetFrame = NULL; LPTARGETCONTAINER ptgcTargetContainer = NULL; HRESULT hr; *ppszFrameSrc = NULL; hr = GetParentFrame(&punkParent); if (hr != S_OK) goto exitPoint; // If we're an embedding we have original src. If we're top level and // src has been set, return that, else defer to document if (punkParent != NULL || m_pszFrameSrc) { hr = GetOleStrMember(m_pszFrameSrc, ppszFrameSrc); } else // We're top level without an explicit SRC { *ppszFrameSrc = NULL; hr = S_OK; IShellView* psv = _GetShellView(); if (psv) { HRESULT hrLocal = SafeGetItemObject(psv, SVGIO_BACKGROUND, IID_ITargetContainer, (LPVOID*) &ptgcTargetContainer); if (SUCCEEDED(hrLocal)) { hr = ptgcTargetContainer->GetFrameUrl(ppszFrameSrc); } else { // Backwards compatibility hrLocal = SafeGetItemObject(psv, SVGIO_BACKGROUND, IID_ITargetFrame, (LPVOID*) &ptgfTargetFrame); if (SUCCEEDED(hrLocal)) { hr = ptgfTargetFrame->GetFrameSrc(ppszFrameSrc); } } psv->Release(); } } exitPoint: SAFERELEASE(punkParent); SAFERELEASE(ptgfTargetFrame); SAFERELEASE(ptgcTargetContainer); return hr; } /******************************************************************* NAME: CIEFrameAuto::GetFramesContainer SYNOPSIS: Returns an addref'ed pointer to the LPOLECONTAINER for our nested frames. Can be NULL. ********************************************************************/ HRESULT CIEFrameAuto::GetFramesContainer(LPOLECONTAINER *ppContainer) { HRESULT hr; LPTARGETFRAME ptgfTargetFrame = NULL; LPTARGETCONTAINER ptgcTargetContainer = NULL; // FEATURE REVIEW -- why is S_OK and NULL a valid return? E_FAIL makes way more sense... // (That's what will get returned if _psv->GetItemObject failes.) hr = S_OK; *ppContainer = NULL; IShellView* psv = _GetShellView(); if (psv) { HRESULT hrLocal; hrLocal = SafeGetItemObject(psv, SVGIO_BACKGROUND, IID_ITargetContainer, (LPVOID*) &ptgcTargetContainer); if (SUCCEEDED(hrLocal)) { hr = ptgcTargetContainer->GetFramesContainer(ppContainer); } else { // Backwards compatibility hrLocal = SafeGetItemObject(psv, SVGIO_BACKGROUND, IID_ITargetFrame, (LPVOID*) &ptgfTargetFrame); if (SUCCEEDED(hrLocal)) { hr = ptgfTargetFrame->GetFramesContainer(ppContainer); } } psv->Release(); } SAFERELEASE(ptgcTargetContainer); SAFERELEASE(ptgfTargetFrame); return hr; } /******************************************************************* NAME: CIEFrameAuto::SetFrameOptions SYNOPSIS: Sets the Frame Options. ********************************************************************/ HRESULT CIEFrameAuto::SetFrameOptions(DWORD dwFlags) { m_dwFrameOptions = dwFlags; return S_OK; } /******************************************************************* NAME: CIEFrameAuto::GetFrameOptions SYNOPSIS: Returns the frame options ********************************************************************/ HRESULT CIEFrameAuto::GetFrameOptions(LPDWORD pdwFlags) { *pdwFlags = m_dwFrameOptions; // If we are full screen turn on a few extras... VARIANT_BOOL fFullScreen; if ((SUCCEEDED(get_FullScreen(&fFullScreen)) && fFullScreen == VARIANT_TRUE) || (SUCCEEDED(get_TheaterMode(&fFullScreen)) && fFullScreen == VARIANT_TRUE)) { *pdwFlags |= FRAMEOPTIONS_SCROLL_AUTO | FRAMEOPTIONS_NO3DBORDER; } else if (_psbProxy != _psb) { // If we are in the WebBar, turn off the 3D border. *pdwFlags |= FRAMEOPTIONS_NO3DBORDER; } // if we are desktop, turn on FRAMEOPTIONS_DESKTOP if (_fDesktopFrame) { *pdwFlags |= FRAMEOPTIONS_DESKTOP; } return S_OK; } /******************************************************************* NAME: CIEFrameAuto::SetFrameMargins SYNOPSIS: Sets the Frame margins. ********************************************************************/ HRESULT CIEFrameAuto::SetFrameMargins(DWORD dwWidth, DWORD dwHeight) { m_dwFrameMarginWidth = dwWidth; m_dwFrameMarginHeight = dwHeight; return S_OK; } /******************************************************************* NAME: CIEFrameAuto::GetFrameMargins SYNOPSIS: Returns the frame margins ********************************************************************/ HRESULT CIEFrameAuto::GetFrameMargins(LPDWORD pdwWidth, LPDWORD pdwHeight) { *pdwWidth = m_dwFrameMarginWidth; *pdwHeight = m_dwFrameMarginHeight; return S_OK; } /******************************************************************* NAME: CIEFrameAuto::_fDesktopComponent SYNOPSIS: Returns TRUE if this frame is a desktop component top level frame or a the top frame of a browser band other than the search pane. These panes need special treatment of FindFrame and navigate. *******************************************************************/ BOOL CIEFrameAuto::_fDesktopComponent() { BOOL fInDesktop = FALSE; LPUNKNOWN punkParent; // Special interpretation for desktop components and non-search browser bands // NULL pszTargetName at top level frames is defined as being targeted // to the window whose frame is "_desktop". this will create a new top level // browser as necessary and return it's frame. if (SUCCEEDED(_GetParentFramePrivate(&punkParent)) && punkParent) { DWORD dwOptions; LPTARGETFRAME2 ptgfTop; // not a top level frame unless our parent is desktop frame if (SUCCEEDED(punkParent->QueryInterface(IID_ITargetFrame2, (LPVOID *) &ptgfTop))) { if (SUCCEEDED(ptgfTop->GetFrameOptions(&dwOptions))) { fInDesktop = (dwOptions & FRAMEOPTIONS_DESKTOP) ? TRUE:FALSE; } ptgfTop->Release(); } punkParent->Release(); } else if (m_dwFrameOptions & FRAMEOPTIONS_BROWSERBAND) { // a browser band - check for search band (proxied hlinkframe) fInDesktop = _psb == _psbProxy; } return fInDesktop; } // ITargetFrame2 members /******************************************************************* NAME: CIEFrameAuto::GetTargetAlias SYNOPSIS: Gets the Frame Name. Allocates a copy (this is an [OUT] parameter ********************************************************************/ STDMETHODIMP CIEFrameAuto::GetTargetAlias(LPCOLESTR pszTargetName, WCHAR **ppszTargetAlias) { BOOL fInDesktop = _fDesktopComponent(); // Special interpretation for desktop components and non-search browser bands // NULL pszTargetName and "_top" at top level frames are defined as being targeted // to the window whose frame is "_desktop". this will create a new top level // browser as necessary and return it's frame. if (pszTargetName == NULL && _fDesktopComponent()) return GetOleStrMember(L"_desktop", ppszTargetAlias); *ppszTargetAlias = NULL; return E_FAIL; } /******************************************************************* NAME: CIEFrameAuto::FindFrame SYNOPSIS: Gets an the IUnknown pointer of the frame referenced by pszTarget. This pointer must be Released by Caller after use. punkContextFrame, if not NULL, is the IUnknown pointer for the immediate descendent frame in whose subtree the Target reference (eg anchor with a Target tag) resides. dwFlags are flags which modify FindFrame's behaviour and can be any combination of FINDFRAME_FLAGS. In particular, SETTING FINDFRAME_JUSTTESTEXISTENCE allows the caller to defeat the default FindFrame behavior of creating a new top level frame named pszTarget, if pszTarget does not exist. IMPLEMENTATION: NOTE: In HTML all anchors and other TARGET tags can occur ONLY in leaf FRAMES!! punkContextFrame is significant only if pszTarget is not a MAGIC target name (_self, _top, _blank, _parent). Non-MAGIC target names: first off, this frame should check if it matches pszTarget and return it's own IUnknown pointer forthwith. if punkContextFrame is not NULL, all child Frames except punkContextFrame should be searched (depth first) for pszTarget with punkContextFrame == NULL. on failure, the parent of this frame should be recursively called with this frame replacing punkContextFrame. if this is a top level Frame (so there is no parent), all top level frames should be called with punkContextFrame == NULL. if this fails, then a new top level frame should be created (unless FINDFRAME_JUSTTESTEXISTENCE is set in dwFlags), named pszTarget and its IUnknown returned. if punkContextFrame is NULL, all child Frames should be searched depth first for pszTarget. on failure, NULL should be returned. MAGIC target names: _self should return the IUnknown of this ITargetFrame _top should be recursively passed up to the top level ITargetFrame. if there is no FrameParent, this defaults to _self. _parent should return the IUnknown of the FrameParent ITargetFrame. if there is no FrameParent, this defaults to _self. _blank should be recursively passed up to the top level ITargetFrame, which should create a unnamed top level frame ********************************************************************/ STDMETHODIMP CIEFrameAuto::FindFrame(LPCOLESTR pszTargetName, DWORD dwFlags, LPUNKNOWN *ppunkTargetFrame) { LPTARGETFRAMEPRIV ptgfpTarget = NULL; LPUNKNOWN punkContextFrame = NULL; HRESULT hr = E_FAIL; BOOL fInContext = TRUE; BOOL fWasMain = FALSE; TARGET_TYPE targetType; if (pszTargetName == NULL || *pszTargetName == 0) pszTargetName = L"_self"; targetType = ParseTargetType(pszTargetName); if (targetType == TARGET_MAIN) { fWasMain = TRUE; pszTargetName = L"_self"; } *ppunkTargetFrame = NULL; // Default behavior: // If this is a webbar and targeting _main, find frame in _psbProxy and return it // If this is in browser, find frame relative to ourselves if (_psb != _psbProxy && fWasMain) { // Webbar : Find in context of top frame of proxy hr = TargetQueryService(_psbProxy, IID_ITargetFramePriv, (LPVOID *) &ptgfpTarget); } else { // Browser : A normal find in context in ourself hr = QueryInterface(IID_ITargetFramePriv, (LPVOID *) &ptgfpTarget); } if (SUCCEEDED(hr) && ptgfpTarget) { if (fInContext) { hr = ptgfpTarget->QueryInterface(IID_IUnknown, (LPVOID *) &punkContextFrame); if (SUCCEEDED(hr)) { hr = ptgfpTarget->FindFrameInContext(pszTargetName, punkContextFrame, dwFlags, ppunkTargetFrame); } } else { hr = ptgfpTarget->FindFrameDownwards(pszTargetName, dwFlags, ppunkTargetFrame); } } SAFERELEASE(punkContextFrame); SAFERELEASE(ptgfpTarget); if (SUCCEEDED(hr) && *ppunkTargetFrame == NULL && !(FINDFRAME_OLDINTERFACE&dwFlags)) hr = S_FALSE; return hr; } // ITargetFramePriv members /******************************************************************* NAME: CIEFrameAuto::FindFrameDownwards SYNOPSIS: IMPLEMENTATION: ********************************************************************/ STDMETHODIMP CIEFrameAuto::FindFrameDownwards(LPCOLESTR pszTargetName, DWORD dwFlags, LPUNKNOWN *ppunkTargetFrame) { return FindFrameInContext(pszTargetName, NULL, dwFlags | FINDFRAME_JUSTTESTEXISTENCE, ppunkTargetFrame); } /******************************************************************* NAME: CIEFrameAuto::FindFrameInContext SYNOPSIS: IMPLEMENTATION: ********************************************************************/ STDMETHODIMP CIEFrameAuto::FindFrameInContext(LPCOLESTR pszTargetName, LPUNKNOWN punkContextFrame, DWORD dwFlags, LPUNKNOWN *ppunkTargetFrame) { //asserts TARGET_TYPE targetType; HRESULT hr = S_OK; LPUNKNOWN punkParent = NULL; LPUNKNOWN punkThisFrame = NULL; LPTARGETFRAMEPRIV ptgfpTargetFrame = NULL; LPUNKNOWN punkThis = NULL; targetType = ParseTargetType(pszTargetName); if (targetType == TARGET_FRAMENAME) { hr = _DoNamedTarget(pszTargetName, punkContextFrame, dwFlags, ppunkTargetFrame); goto exitPoint; } // Must be a Magic Target //for search, first show the search bar and then reach across to get it's TargetFrame if (targetType == TARGET_SEARCH) { SA_BSTRGUID strGuid; VARIANT vaGuid; InitFakeBSTR(&strGuid, CLSID_SearchBand); vaGuid.vt = VT_BSTR; vaGuid.bstrVal = strGuid.wsz; //if we're in an explorer bar, use the proxy's pbs IBrowserService *pbs = _pbs; if (_psb != _psbProxy) { EVAL(SUCCEEDED(_psbProxy->QueryInterface(IID_IBrowserService, (void**)&pbs))); } IUnknown_Exec(pbs, &CGID_ShellDocView, SHDVID_SHOWBROWSERBAR, 1, &vaGuid, NULL); VARIANT vaPunkBand = {0}; hr = IUnknown_Exec(pbs, &CGID_ShellDocView, SHDVID_GETBROWSERBAR, NULL, NULL, &vaPunkBand); if (_psb != _psbProxy) { ATOMICRELEASE(pbs); } if (hr == S_OK) { IDeskBand* pband; pband = (IDeskBand*)vaPunkBand.punkVal; ASSERT(pband); if (pband) { IBrowserBand* pbb; hr = pband->QueryInterface(IID_IBrowserBand, (LPVOID*)&pbb); if (SUCCEEDED(hr)) { // now, get the pidl search pane is navigated to. // if it's null we have to navigate it to something -- default search url (web search) // this used to be in CSearchBand::_NavigateOC but caused problems // if user had dial up networking set up and tried to get to the file search we would // first set pidl to web search url (_NavigateOC is called by _CreateOCHost) which would // cause AutoDial dialog to come up and then we would navigate the pane to the file search // (nt5 bug#186970) reljai -- 6/22/98 VARIANT varPidl = {0}; if (SUCCEEDED(IUnknown_Exec(pbb, &CGID_SearchBand, SBID_GETPIDL, 0, NULL, &varPidl))) { ISearchItems* psi; LPITEMIDLIST pidl = VariantToIDList(&varPidl); VariantClear(&varPidl); if (!pidl && SUCCEEDED(IUnknown_QueryService(pbb, SID_SExplorerToolbar, IID_ISearchItems, (void **)&psi))) { // get the default search url WCHAR wszSearchUrl[INTERNET_MAX_URL_LENGTH]; if (SUCCEEDED(psi->GetDefaultSearchUrl(wszSearchUrl, ARRAYSIZE(wszSearchUrl)))) { IBandNavigate* pbn; if (SUCCEEDED(pbb->QueryInterface(IID_IBandNavigate, (void **)&pbn))) { // reuse pidl IECreateFromPathW(wszSearchUrl, &pidl); pbn->Select(pidl); pbn->Release(); } } psi->Release(); } ILFree(pidl); } IWebBrowser2* pwb; hr = pbb->GetObjectBB(IID_IWebBrowser2, (LPVOID*)&pwb); //set the search pane's opener property if (SUCCEEDED(hr)) { IDispatch* pdisp; if (SUCCEEDED(pwb->get_Document(&pdisp)) && pdisp) { IHTMLDocument2* pDoc; if (SUCCEEDED(pdisp->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc)) && pDoc) { IHTMLWindow2* pWindow; if (SUCCEEDED(pDoc->get_parentWindow(&pWindow)) && pWindow) { VARIANT var; VariantInit(&var); var.vt = VT_DISPATCH; _omwin.QueryInterface(IID_IUnknown, (void**)&var.pdispVal); pWindow->put_opener(var); VariantClear(&var); pWindow->Release(); } pDoc->Release(); } pdisp->Release(); } } if (SUCCEEDED(hr)) { hr = pwb->QueryInterface(IID_ITargetFramePriv, (void **)ppunkTargetFrame); pwb->Release(); } pbb->Release(); } pband->Release(); } } else { //maybe we're the search bar //hack to let search pane know to remember the next navigation IUnknown *punkThis; if (SUCCEEDED(_psb->QueryInterface(IID_IUnknown, (void**)&punkThis))) { hr = QueryInterface(IID_ITargetFramePriv, (void**)&ptgfpTargetFrame); if (SUCCEEDED(hr)) *ppunkTargetFrame = ptgfpTargetFrame; ptgfpTargetFrame = NULL; punkThis->Release(); } } goto exitPoint; } // content pane of MediaBar: if (targetType == TARGET_MEDIA) { SA_BSTRGUID strGuid; VARIANT vaGuid; InitFakeBSTR(&strGuid, CLSID_MediaBand); vaGuid.vt = VT_BSTR; vaGuid.bstrVal = strGuid.wsz; //if we're in an explorer bar, use the proxy's pbs IBrowserService *pbs = _pbs; if (_psb != _psbProxy) { EVAL(SUCCEEDED(_psbProxy->QueryInterface(IID_IBrowserService, (void**)&pbs))); } IUnknown_Exec(pbs, &CGID_ShellDocView, SHDVID_SHOWBROWSERBAR, 1, &vaGuid, NULL); VARIANT vaPunkBand = {0}; hr = IUnknown_Exec(pbs, &CGID_ShellDocView, SHDVID_GETBROWSERBAR, NULL, NULL, &vaPunkBand); if (_psb != _psbProxy) { ATOMICRELEASE(pbs); } if (hr == S_OK) { IDeskBand* pband; pband = (IDeskBand*)vaPunkBand.punkVal; ASSERT(pband); if (pband) { IBrowserBand* pbb; hr = pband->QueryInterface(IID_IBrowserBand, (LPVOID*)&pbb); if (SUCCEEDED(hr)) { IWebBrowser2* pwb; hr = pbb->GetObjectBB(IID_IWebBrowser2, (LPVOID*)&pwb); //set the media pane's opener property if (SUCCEEDED(hr)) { IDispatch* pdisp; if (SUCCEEDED(pwb->get_Document(&pdisp)) && pdisp) { IHTMLDocument2* pDoc; if (SUCCEEDED(pdisp->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc)) && pDoc) { IHTMLWindow2* pWindow; if (SUCCEEDED(pDoc->get_parentWindow(&pWindow)) && pWindow) { VARIANT var; VariantInit(&var); var.vt = VT_DISPATCH; _omwin.QueryInterface(IID_IUnknown, (void**)&var.pdispVal); pWindow->put_opener(var); VariantClear(&var); pWindow->Release(); } pDoc->Release(); } pdisp->Release(); } } if (SUCCEEDED(hr)) { hr = pwb->QueryInterface(IID_ITargetFramePriv, (void **)ppunkTargetFrame); pwb->Release(); } pbb->Release(); } pband->Release(); } } else { ASSERT(0); // means we have no explorer bands at all........ // but the SHDVID_SHOWBROWSERBAR just before does launch the media bar } goto exitPoint; } hr = QueryInterface(IID_IUnknown, (LPVOID*)&punkThis); ASSERT(punkThis != NULL); if (targetType == TARGET_SELF) { *ppunkTargetFrame = punkThis; // Set punkThis to NULL to prevent Release at exit punkThis = NULL; } else // _blank, _parent, _top { hr = GetParentFrame(&punkParent); if (hr != S_OK) goto exitPoint; if (punkParent == NULL) { if (targetType == TARGET_PARENT || targetType == TARGET_TOP) { *ppunkTargetFrame = punkThis; // Set punkThis to NULL to prevent Release at exit punkThis = NULL; } else // TARGET_BLANK { if (dwFlags & FINDFRAME_JUSTTESTEXISTENCE) { // It is the client's responsibility to handle "_blank" hr = S_OK; } else { // CreateTargetFrame will not work with AOL 3.01 clients // so we must return E_FAIL hr = E_FAIL; } *ppunkTargetFrame = NULL; } } else // punkParent != NULL { // Handle parent ourself, defer _top and _blank to top level frame if (targetType == TARGET_PARENT) { *ppunkTargetFrame = punkParent; // Set punkThisFrame to NULL to prevent Release at exit punkParent = NULL; } else { hr = punkParent->QueryInterface(IID_ITargetFramePriv, (LPVOID*)&ptgfpTargetFrame); if (hr != S_OK) goto exitPoint; hr = ptgfpTargetFrame->FindFrameInContext(pszTargetName, punkThis, dwFlags, ppunkTargetFrame); } } } exitPoint: SAFERELEASE(punkThis); SAFERELEASE(punkThisFrame); SAFERELEASE(ptgfpTargetFrame); SAFERELEASE(punkParent); return hr; } HRESULT CIEFrameAuto::_GetOleObject(IOleObject** ppobj) { HRESULT hres = E_UNEXPECTED; if (_pbs) { hres = _pbs->GetOleObject(ppobj); } return hres; } // ITargetFrame implementation for backwards compatibility HRESULT CIEFrameAuto::CTargetFrame::QueryInterface(REFIID riid, LPVOID * ppvObj) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->QueryInterface(riid, ppvObj); } ULONG CIEFrameAuto::CTargetFrame::AddRef(void) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->AddRef(); } ULONG CIEFrameAuto::CTargetFrame::Release(void) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->Release(); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::SetFrameName SYNOPSIS: Sets the Frame Name. Frees current one if exists. ********************************************************************/ STDMETHODIMP CIEFrameAuto::CTargetFrame::SetFrameName(LPCOLESTR pszFrameName) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->SetFrameName(pszFrameName); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetFrameName SYNOPSIS: Gets the Frame Name. Allocates a copy (this is an [OUT] parameter ********************************************************************/ STDMETHODIMP CIEFrameAuto::CTargetFrame::GetFrameName(WCHAR **ppszFrameName) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetFrameName(ppszFrameName); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetParentFrame SYNOPSIS: Gets an the IUnknown pointer of the parent frame, or NULL if this is a top level frame. This pointer must be Released by Caller after use. IMPLEMENTATION: A Frame Container is required to implement ITargetFrame::GetParentFrame and implement GetParentFrame by returning the IUnknown pointer of the Browser that hosts it. A Browser implements GetParentFrame by returning NULL if it's top level or calling GetParentFrame on its Container if it is embedded. ********************************************************************/ STDMETHODIMP CIEFrameAuto::CTargetFrame::GetParentFrame(LPUNKNOWN *ppunkParentFrame) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetParentFrame(ppunkParentFrame); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::FindFrame SYNOPSIS: Gets an the IUnknown pointer of the frame referenced by pszTarget. This pointer must be Released by Caller after use. punkContextFrame, if not NULL, is the IUnknown pointer for the immediate descendent frame in whose subtree the Target reference (eg anchor with a Target tag) resides. dwFlags are flags which modify FindFrame's behaviour and can be any combination of FINDFRAME_FLAGS. In particular, SETTING FINDFRAME_JUSTTESTEXISTENCE allows the caller to defeat the default FindFrame behavior of creating a new top level frame named pszTarget, if pszTarget does not exist. IMPLEMENTATION: NOTE: In HTML all anchors and other TARGET tags can occur ONLY in leaf FRAMES!! punkContextFrame is significant only if pszTarget is not a MAGIC target name (_self, _top, _blank, _parent). Non-MAGIC target names: first off, this frame should check if it matches pszTarget and return it's own IUnknown pointer forthwith. if punkContextFrame is not NULL, all child Frames except punkContextFrame should be searched (depth first) for pszTarget with punkContextFrame == NULL. on failure, the parent of this frame should be recursively called with this frame replacing punkContextFrame. if this is a top level Frame (so there is no parent), all top level frames should be called with punkContextFrame == NULL. if this fails, then a new top level frame should be created (unless FINDFRAME_JUSTTESTEXISTENCE is set in dwFlags), named pszTarget and its IUnknown returned. if punkContextFrame is NULL, all child Frames should be searched depth first for pszTarget. on failure, NULL should be returned. MAGIC target names: _self should return the IUnknown of this ITargetFrame _top should be recursively passed up to the top level ITargetFrame. if there is no FrameParent, this defaults to _self. _parent should return the IUnknown of the FrameParent ITargetFrame. if there is no FrameParent, this defaults to _self. _blank should be recursively passed up to the top level ITargetFrame, which should create a unnamed top level frame ********************************************************************/ STDMETHODIMP CIEFrameAuto::CTargetFrame::FindFrame(LPCOLESTR pszTargetName, LPUNKNOWN punkContextFrame, DWORD dwFlags, LPUNKNOWN *ppunkTargetFrame) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->FindFrame(pszTargetName, dwFlags|FINDFRAME_OLDINTERFACE, ppunkTargetFrame); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::RemoteNavigate SYNOPSIS: Used in response to WM_COPYDATA message with dwData equal to TF_NAVIGATE. Does a FindFrame (named target only) and if frame is not found returns S_FALSE. If found, returns S_OK and fires off the navigate. cLength is number of ULONGs in pulData TODO: Relies on RemoteNavigate member of top level MSHTML docobject host. Need to write the equivalent code to work if top level frame contains some other DocObject. Post,etc require help from bindstatuscallback. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::RemoteNavigate(ULONG cLength,ULONG *pulData) { // FEATURE chrisfra 10/22/96 - this is now here purely for backwards compatibility and // should be removed for ie4.0 return E_FAIL; } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::SetFrameSrc SYNOPSIS: Sets the Frame original SRC url. Frees current one if exists. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::SetFrameSrc(LPCOLESTR pszFrameSrc) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->SetFrameSrc(pszFrameSrc); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetFrameSrc SYNOPSIS: Gets the Frame original URL. Allocates a copy (this is an [OUT] parameter NOTES: If we are at top level, SRC is dynamic, so ask our contained DocObject to do it for us. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::GetFrameSrc(WCHAR **ppszFrameSrc) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetFrameSrc(ppszFrameSrc); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetFramesContainer SYNOPSIS: Returns an addref'ed pointer to the LPOLECONTAINER for our nested frames. Can be NULL. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::GetFramesContainer(LPOLECONTAINER *ppContainer) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetFramesContainer(ppContainer); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::SetFrameOptions SYNOPSIS: Sets the Frame Options. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::SetFrameOptions(DWORD dwFlags) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->SetFrameOptions(dwFlags); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetFrameOptions SYNOPSIS: Returns the frame options ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::GetFrameOptions(LPDWORD pdwFlags) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetFrameOptions(pdwFlags); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::SetFrameMargins SYNOPSIS: Sets the Frame margins. ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::SetFrameMargins(DWORD dwWidth, DWORD dwHeight) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->SetFrameMargins(dwWidth, dwHeight); } /******************************************************************* NAME: CIEFrameAuto::CTargetFrame::GetFrameMargins SYNOPSIS: Returns the frame margins ********************************************************************/ HRESULT CIEFrameAuto::CTargetFrame::GetFrameMargins(LPDWORD pdwWidth, LPDWORD pdwHeight) { CIEFrameAuto* pie = IToClass(CIEFrameAuto, _TargetFrame, this); return pie->GetFrameMargins(pdwWidth, pdwHeight); } /******************************************************************* NAME: CIEFrameAuto::FindBrowserByIndex SYNOPSIS: Returns an IUnknown that points to a Browser that has the requested index ********************************************************************/ HRESULT CIEFrameAuto::FindBrowserByIndex(DWORD dwID,IUnknown **ppunkBrowser) { HRESULT hr = S_OK; IOleContainer * poc = NULL; IBrowserService *pbs; ASSERT(ppunkBrowser); *ppunkBrowser = NULL; if (!_psb) return E_FAIL; // first check self if(SUCCEEDED(_psb->QueryInterface(IID_IBrowserService, (LPVOID *) &pbs))) { ASSERT(pbs); if(dwID == pbs->GetBrowserIndex()) { // this is the one... *ppunkBrowser = (IUnknown *)pbs; goto exitPoint; } SAFERELEASE(pbs); } hr = GetFramesContainer(&poc); if (SUCCEEDED(hr) && poc) { IEnumUnknown *penum = NULL; IUnknown *punk; hr = E_FAIL; if (S_OK != poc->EnumObjects(OLECONTF_EMBEDDINGS, &penum) || penum == NULL) goto exitPoint; while (S_OK == penum->Next(1, &punk, NULL)) { ITargetFramePriv *ptf; if (punk == NULL) break; if(SUCCEEDED(punk->QueryInterface(IID_ITargetFramePriv, (LPVOID *) &ptf))) { ASSERT(ptf); hr = ptf->FindBrowserByIndex(dwID, ppunkBrowser); SAFERELEASE(ptf); } SAFERELEASE(punk); if (SUCCEEDED(hr)) //foundit! break; } // Native frames - no WebBrowser OC in frame. Note that // if a WebOC is included on a web page with an // tag, navigations in the WebOC will be placed in the travel // log. However, since the WebOC does not currently support // ITravelLogClient, back and forward will not work correctly. // The WebOC will need to be updated to support ITravelLogClient. // if (FAILED(hr)) { IHTMLDocument2 * pDoc = NULL; IHTMLWindow2 * pWnd = NULL; IHTMLWindow2 * pTop = NULL; ITravelLogClient * ptlc = NULL; if (SUCCEEDED(poc->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc))) { if (SUCCEEDED(pDoc->get_parentWindow(&pWnd))) { if (SUCCEEDED(pWnd->get_top(&pTop))) { if (SUCCEEDED(pTop->QueryInterface(IID_ITravelLogClient, (void**)&ptlc))) { hr = ptlc->FindWindowByIndex(dwID, ppunkBrowser); } } } } SAFERELEASE(pDoc); SAFERELEASE(pWnd); SAFERELEASE(pTop); SAFERELEASE(ptlc); } SAFERELEASE(penum); SAFERELEASE(poc); } else { hr = E_FAIL; } exitPoint: return hr; } // External helper function for TRIDENT when it stands alone w/o the steely thews of // shdocvw CIEFrameAuto to shield it's pityfull body. STDAPI HlinkFindFrame(LPCWSTR pszFrameName, LPUNKNOWN *ppunk) { HRESULT hres = E_FAIL; *ppunk = NULL; if (pszFrameName) { switch (ParseTargetType(pszFrameName)) { case TARGET_FRAMENAME: hres = _TargetTopLevelWindows(NULL, pszFrameName, FINDFRAME_JUSTTESTEXISTENCE, ppunk); break; case TARGET_BLANK: hres = S_FALSE; break; } } return hres; }