windows-xp/Source/XPSP1/NT/shell/shdocvw/tframe.cpp

#include "priv.h"
#include <varutil.h>
#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! <<for NETSCAPE compatibility>>
    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 <OBJECT>
        // 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;
}