windows-server-2003/shell/shdocvw/basesb.cpp

#include "priv.h"

#include <mluisupp.h>

// stuff that should be turned off while in here, but on when 
// it goes to commonsb or shbrows2.cpp
#define IN_BASESB2

#ifdef IN_BASESB2
#define _fFullScreen FALSE
#endif

#include "sccls.h"

#include <idhidden.h>
#include "basesb.h"
#include "iedde.h"
#include "bindcb.h"
#include "resource.h"
#include "security.h"
#include <urlmon.h>
#include "favorite.h"
#include "uemapp.h"
#include <varutil.h>
#include "interned.h" // IHTMLPrivateWindow
#ifdef FEATURE_PICS
#include <ratings.h>
#include <ratingsp.h>
#endif
#include "msiehost.h"

#include "dhuihand.h"
#include "mypics.h"
#include "airesize.h"

#define DM_ACCELERATOR      0
#define DM_WEBCHECKDRT      0
#define DM_COCREATEHTML     0
#define DM_CACHEOLESERVER   0
#define DM_DOCCP            0
#define DM_PICS             0
#define DM_SSL              0
#define DM_MISC             DM_TRACE    // misc/tmp

// get at defs to run a privacy dialog box
#include "privacyui.hpp"

//
//  Remove this #include by defining _bbd._pauto as IWebBrowserApp, just like
//  Explorer.exe.
//
#include "hlframe.h"

extern IUnknown* ClassHolder_Create(const CLSID* pclsid);
extern HRESULT VariantClearLazy(VARIANTARG *pvarg);


#define WMC_ASYNCOPERATION      (WMC_RESERVED_FIRST + 0x0000)

#define ISSPACE(ch) (((ch) == 32) || ((unsigned)((ch) - 9)) <= 13 - 9)

#define IDT_STARTING_APP_TIMER  9001        // trying to pick a unique number... (THIS IS BOGUS! FIX THIS!)
#define STARTING_APP_DURATION   2500

UINT g_uMsgFileOpened = (UINT)-1;         // Registered window message for file opens

// _uActionQueued of WMC_ACYNCOPERATION specifies the operation.
#define ASYNCOP_NIL                 0
#define ASYNCOP_GOTO                1
#define ASYNCOP_ACTIVATEPENDING     2
#define ASYNCOP_CANCELNAVIGATION    3

void IEInitializeClassFactoryObject(IUnknown* punkAuto);
BOOL ParseRefreshContent(LPWSTR pwzContent,
    UINT * puiDelay, LPWSTR pwzUrlBuf, UINT cchUrlBuf);

#define VALIDATEPENDINGSTATE() ASSERT((_bbd._psvPending && _bbd._psfPending) || (!_bbd._psvPending && !_bbd._psfPending))

#define DM_HTTPEQUIV        TF_SHDNAVIGATE
#define DM_NAV              TF_SHDNAVIGATE
#define DM_ZONE             TF_SHDNAVIGATE
#define DM_IEDDE            DM_TRACE
#define DM_CANCELMODE       0
#define DM_UIWINDOW         0
#define DM_ENABLEMODELESS   TF_SHDNAVIGATE
#define DM_EXPLORERMENU     0
#define DM_BACKFORWARD      0
#define DM_PROTOCOL         0
#define DM_ITBAR            0
#define DM_STARTUP          0
#define DM_AUTOLIFE         0
#define DM_PALETTE          0
#define DM_PERSIST          0       // trace IPS::Load, ::Save, etc.
#define DM_VIEWSTREAM       DM_TRACE
#define DM_FOCUS            0
#define DM_FOCUS2           0           // like DM_FOCUS, but verbose

// these two MUST be in order because we peek them together

STDAPI SafeGetItemObject(IShellView *psv, UINT uItem, REFIID riid, void **ppv);
extern HRESULT TargetQueryService(IUnknown *punk, REFIID riid, void **ppvObj);
HRESULT CreateTravelLog(ITravelLog **pptl);
HRESULT CreatePublicTravelLog(IBrowserService *pbs, ITravelLogEx *ptlx, ITravelLogStg **pptlstg);

#ifdef MESSAGEFILTER
/*
 * CMsgFilter - implementation of IMessageFilter
 *
 * Used to help distribute WM_TIMER messages during OLE operations when 
 * we are busy.  If we don't install the CoRegisterMessageFilter
 * then OLE can PeekMessage(PM_NOREMOVE) the timers such that they pile up
 * and fill the message queue.
 *
 */
class CMsgFilter : public IMessageFilter {
public:
    // *** IUnknown methods ***
    STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj)
    {
        // This interface doesn't get QI'ed.
        ASSERT(FALSE);
        return E_NOINTERFACE;
    };
    STDMETHODIMP_(ULONG) AddRef(void)    {   return ++_cRef; };
    STDMETHODIMP_(ULONG) Release(void)   {   ASSERT(_cRef > 0);
                                                _cRef--;
                                                if (_cRef > 0)
                                                    return _cRef;

                                                delete this;
                                                return 0;
                                            };

    // *** IMessageFilter specific methods ***
    STDMETHODIMP_(DWORD) HandleInComingCall(
        IN DWORD dwCallType,
        IN HTASK htaskCaller,
        IN DWORD dwTickCount,
        IN LPINTERFACEINFO lpInterfaceInfo)
    {
        if (_lpMFOld)
           return (_lpMFOld->HandleInComingCall(dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo));
        else
           return SERVERCALL_ISHANDLED;
    };

    STDMETHODIMP_(DWORD) RetryRejectedCall(
        IN HTASK htaskCallee,
        IN DWORD dwTickCount,
        IN DWORD dwRejectType)
    {
        if (_lpMFOld)
            return (_lpMFOld->RetryRejectedCall(htaskCallee, dwTickCount, dwRejectType));
        else
            return 0xffffffff;
    };

    STDMETHODIMP_(DWORD) MessagePending(
        IN HTASK htaskCallee,
        IN DWORD dwTickCount,
        IN DWORD dwPendingType)
    {
        DWORD dw;
        MSG msg;

        // We can get released during the DispatchMessage call...
        // If it's our last release, we'll free ourselves and
        // fault when we dereference _lpMFOld... Make sure this
        // doesn't happen by increasing our refcount.
        //
        AddRef();

        while (PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE))
        {
#ifndef DISPATCH_IETIMERS
            TCHAR szClassName[40];
                
            GetClassName(msg.hwnd, szClassName, ARRAYSIZE(szClassName));


            if (StrCmpI(szClassName, TEXT("Internet Explorer_Hidden")) != 0)
            {
#endif
                DispatchMessage(&msg);
#ifndef DISPATCH_IETIMERS
            }
#endif
        }

        if (_lpMFOld)
            dw = (_lpMFOld->MessagePending(htaskCallee, dwTickCount, dwPendingType));
        else
            dw = PENDINGMSG_WAITDEFPROCESS;

        Release();

        return(dw);
    };

    CMsgFilter() : _cRef(1)
    {
        ASSERT(_lpMFOld == NULL);
    };

    BOOL Initialize()
    {
        return (CoRegisterMessageFilter((LPMESSAGEFILTER)this, &_lpMFOld) != S_FALSE);
    };

    void UnInitialize()
    {
        CoRegisterMessageFilter(_lpMFOld, NULL);

        // we shouldn't ever get called again, but after 30 minutes
        // of automation driving we once hit a function call above
        // and we dereferenced this old pointer and page faulted.

        ATOMICRELEASE(_lpMFOld);
    };

protected:
    int _cRef;
    LPMESSAGEFILTER _lpMFOld;
};
#endif


void IEHard_NavWarning(HWND hwnd, BOOL fIE);
BOOL IEHard_ShowOnNavigateComplete(void);
BOOL IEHard_HostedInIE(IUnknown* punk);


//--------------------------------------------------------------------------
// Detecting a memory leak
//--------------------------------------------------------------------------

HRESULT GetTopFrameOptions(IServiceProvider * psp, DWORD * pdwOptions)
{
    IServiceProvider * pspTop;
    HRESULT hres = psp->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IServiceProvider, &pspTop));
    if (SUCCEEDED(hres))
    {
        ITargetFrame2 *ptgf;
        hres = pspTop->QueryService(SID_SContainerDispatch, IID_PPV_ARG(ITargetFrame2, &ptgf));
        if (SUCCEEDED(hres))
        {
            hres = ptgf->GetFrameOptions(pdwOptions);
            ptgf->Release();
        }
        pspTop->Release();
    }

    return hres;
}

void UpdateDesktopComponentName(LPCWSTR lpcwszURL, LPCWSTR lpcwszName)
{
    IActiveDesktop * piad;

    if (SUCCEEDED(SHCoCreateInstance(NULL, &CLSID_ActiveDesktop, NULL, IID_PPV_ARG(IActiveDesktop, &piad))))
    {
        COMPONENT comp;
        comp.dwSize = SIZEOF(comp);

        if (SUCCEEDED(piad->GetDesktopItemBySource(lpcwszURL, &comp, 0)) && !comp.wszFriendlyName[0])
        {
            StrCpyNW(comp.wszFriendlyName, lpcwszName, ARRAYSIZE(comp.wszFriendlyName));
            piad->ModifyDesktopItem(&comp, COMP_ELEM_FRIENDLYNAME);
            piad->ApplyChanges(AD_APPLY_SAVE);
        }
        piad->Release();
    }
}

HRESULT CBaseBrowser2::_Initialize(HWND hwnd, IUnknown* pauto)
{
    if (pauto)
    {
        pauto->AddRef();
    }
    else
    {
        CIEFrameAuto_CreateInstance(NULL, &pauto);
    }

    // Grab _pauto interfaces we use throughout this code.
    //
    if (pauto)
    {
        pauto->QueryInterface(IID_PPV_ARG(IWebBrowser2, &_bbd._pautoWB2));
        ASSERT(_bbd._pautoWB2);

        pauto->QueryInterface(IID_PPV_ARG(IExpDispSupport, &_bbd._pautoEDS));
        ASSERT(_bbd._pautoEDS);

        pauto->QueryInterface(IID_PPV_ARG(IShellService, &_bbd._pautoSS));
        ASSERT(_bbd._pautoSS);

        pauto->QueryInterface(IID_PPV_ARG(ITargetFrame2, &_ptfrm));
        ASSERT(_ptfrm);

        pauto->QueryInterface(IID_PPV_ARG(IHlinkFrame, &_bbd._phlf));
        ASSERT(_bbd._phlf);

        IHTMLWindow2 *pWindow;
        if( SUCCEEDED(GetWindowFromUnknown( pauto, &pWindow )) )
        {
            pWindow->QueryInterface(IID_PPV_ARG(IShellHTMLWindowSupport, &_phtmlWS));
            pWindow->Release( );
        }
        ASSERT( _phtmlWS );

        _pauto = pauto;
    }

    //  _psbOuter?
    if (NULL == _bbd._phlf)
    {
        Release();
        return E_FAIL;
    }
    else
    {
        _SetWindow(hwnd);
        return S_OK;
    }
}


HRESULT CBaseBrowser2::InitializeTransitionSite()
{
    return S_OK;
}


HRESULT CBaseBrowser2_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
    CBaseBrowser2 *pbb = new CBaseBrowser2(pUnkOuter);
    if (pbb)
    {
        *ppunk = pbb->_GetInner();
        return S_OK;
    }
    *ppunk = NULL;
    return E_OUTOFMEMORY;
}

CBaseBrowser2::CBaseBrowser2(IUnknown* punkAgg) :
       CAggregatedUnknown(punkAgg),
        _bptBrowser(BPT_DeferPaletteSupport)
{
    TraceMsg(TF_SHDLIFE, "ctor CBaseBrowser2 %x", this);

    _bbd._uActivateState = SVUIA_ACTIVATE_FOCUS;
    _InitComCtl32();

    ASSERT(S_FALSE == _DisableModeless());
    ASSERT(_cp == CP_ACP);
    ASSERT(!_fNoTopLevelBrowser);
    ASSERT(!_dwDocFlags);

    _QueryOuterInterface(IID_PPV_ARG(IBrowserService2, &_pbsOuter));
    _QueryOuterInterface(IID_PPV_ARG(IBrowserService3, &_pbsOuter3));
    _QueryOuterInterface(IID_PPV_ARG(IShellBrowser, &_psbOuter));
    _QueryOuterInterface(IID_PPV_ARG(IServiceProvider, &_pspOuter));

    // The following are intercepted by CCommonBrowser, but we don't call 'em
    //_QueryOuterInterface(IID_PPV_ARG(IOleCommandTarget, &_pctOuter));
    //_QueryOuterInterface(IID_PPV_ARG(IInputObjectSite, &_piosOuter));

    _dwStartingAppTick = 0;
}


CBaseBrowser2::~CBaseBrowser2()
{
    TraceMsg(TF_SHDLIFE, "dtor CBaseBrowser2 %x", this);

    // Are we releasing these too early (i.e. does anything in the
    // rest of this func rely on having the 'vtables' still be valid?)
    RELEASEOUTERINTERFACE(_pbsOuter);
    RELEASEOUTERINTERFACE(_pbsOuter3);
    RELEASEOUTERINTERFACE(_psbOuter);
    RELEASEOUTERINTERFACE(_pspOuter);

    // The following are intercepted by CCommonBrowser, but we don't call 'em
    //RELEASEOUTERINTERFACE(_pctOuter);
    //RELEASEOUTERINTERFACE(_piosOuter);
    
    ASSERT(_hdpaDLM == NULL);    // subclass must free it.

    // finish tracking here
    if (_ptracking) 
    {
        delete _ptracking;
        _ptracking = NULL;
    }

    //
    // Notes: Unlike IE3.0, we release CIEFrameAuto pointers here.
    //
    ATOMICRELEASE(_bbd._pautoWB2);
    ATOMICRELEASE(_bbd._pautoEDS);
    ATOMICRELEASE(_bbd._pautoSS);
    ATOMICRELEASE(_phtmlWS);
    ATOMICRELEASE(_bbd._phlf);
    ATOMICRELEASE(_ptfrm);
    ATOMICRELEASE(_pauto);
    
    ATOMICRELEASE(_punkSFHistory);

    // clean up our palette by simulating a switch out of palettized mode
    _bptBrowser = BPT_NotPalettized;
    _QueryNewPalette();

    ASSERT(!_bbd._phlf);
    ASSERT(!_ptfrm);
    ASSERT(S_FALSE == _DisableModeless());
    ASSERT(_bbd._hwnd==NULL);

    ATOMICRELEASE(_pact);

    ATOMICRELEASE(_pIUrlHistoryStg);
    ATOMICRELEASE(_pITravelLogStg);
    ATOMICRELEASE(_poleHistory);
    ATOMICRELEASE(_pstmHistory);
    ATOMICRELEASE(_bbd._ptl);

    ATOMICRELEASE(_pHTMLDocument);
    ATOMICRELEASE(_pphHistory);
    ATOMICRELEASE(_pDispViewLinkedWebOCFrame);

#ifdef MESSAGEFILTER
    if (_lpMF) 
    {
        IMessageFilter* lpMF = _lpMF;
        _lpMF = NULL;
        ((CMsgFilter *)lpMF)->UnInitialize();
        EVAL(lpMF->Release() == 0);
    }
#endif

    // This is created during FileCabinet_CreateViewWindow2
    CShellViews_Delete(&_fldBase._cViews);

    // If the class factory object has been cached, unlock it and release.
    if (_pcfHTML) 
    {
        _pcfHTML->LockServer(FALSE);
        _pcfHTML->Release();
    }

    ATOMICRELEASE(_pToolbarExt);
}

HRESULT CBaseBrowser2::v_InternalQueryInterface(REFIID riid, void **ppvObj)
{
    static const QITAB qit[] = {
        QITABENT(CBaseBrowser2, IShellBrowser),         // IID_IShellBrowser
        QITABENTMULTI(CBaseBrowser2, IOleWindow, IShellBrowser), // IID_IOleWindow
        QITABENT(CBaseBrowser2, IOleInPlaceUIWindow),   // IID_IOleInPlaceUIWindow
        QITABENT(CBaseBrowser2, IOleCommandTarget),     // IID_IOleCommandTarget
        QITABENT(CBaseBrowser2, IDropTarget),           // IID_IDropTarget
        QITABENTMULTI(CBaseBrowser2, IBrowserService, IBrowserService3), // IID_IBrowserService
        QITABENTMULTI(CBaseBrowser2, IBrowserService2, IBrowserService3), // IID_IBrowserService2
        QITABENT(CBaseBrowser2, IBrowserService3),      // IID_IBrowserService3
        QITABENT(CBaseBrowser2, IServiceProvider),      // IID_IServiceProvider
        QITABENT(CBaseBrowser2, IOleContainer),         // IID_IOleContainer
        QITABENT(CBaseBrowser2, IAdviseSink),           // IID_IAdviseSink
        QITABENT(CBaseBrowser2, IInputObjectSite),      // IID_IInputObjectSite
        QITABENT(CBaseBrowser2, IDocNavigate),          // IID_IDocNavigate
        QITABENT(CBaseBrowser2, IPersistHistory),       // IID_IPersistHistory
        QITABENT(CBaseBrowser2, IInternetSecurityMgrSite), // IID_IInternetSecurityMgrSite
        QITABENT(CBaseBrowser2, IVersionHost),          // IID_IVersionHost
        QITABENT(CBaseBrowser2, IProfferService),       // IID_IProfferService
        QITABENT(CBaseBrowser2, ITravelLogClient),      // IID_ITravelLogClient
        QITABENT(CBaseBrowser2, ITravelLogClient2),     // IID_ITravelLogClient2
        QITABENTMULTI(CBaseBrowser2, ITridentService, ITridentService2), // IID_ITridentService
        QITABENT(CBaseBrowser2, ITridentService2),      // IID_ITridentService2
        QITABENT(CBaseBrowser2, IInitViewLinkedWebOC),  // IID_IInitViewLinkedWebOC
        QITABENT(CBaseBrowser2, INotifyAppStart),       // IID_INotifyAppStart
        { 0 },
    };

    return QISearch(this, qit, riid, ppvObj);
}

BOOL CBaseBrowser2::_IsViewMSHTML(IShellView * psv)
{
    BOOL fIsMSHTML = FALSE;
    
    if (psv)
    {
        IPersist *pPersist = NULL;
        HRESULT hres = SafeGetItemObject(psv, SVGIO_BACKGROUND, IID_PPV_ARG(IPersist, &pPersist));
        if (SUCCEEDED(hres) && (pPersist != NULL))
        {
            CLSID clsid;
            hres = pPersist->GetClassID(&clsid);
            if (SUCCEEDED(hres) && IsEqualGUID(clsid, CLSID_HTMLDocument))
                fIsMSHTML = TRUE;
            pPersist->Release();
        }
    }
    return fIsMSHTML;
}

HRESULT CBaseBrowser2::ReleaseShellView()
{
    //  We're seeing some reentrancy here.  If _cRefUIActivateSV is non-zero, it means we're
    //  in the middle of UIActivating the shell view.
    //
    if (_cRefUIActivateSV)
    {
        TraceMsg(TF_WARNING, 
            "CBB(%x)::ReleaseShellView _cRefUIActivateSV(%d)!=0  _bbd._psv=%x ABORTING", 
            this, _cRefUIActivateSV, _bbd._psv);
        return S_OK;
    }
    
    BOOL fViewObjectChanged = FALSE;

    VALIDATEPENDINGSTATE();

    TraceMsg(DM_NAV, "CBaseBrowser2(%x)::ReleaseShellView(%x)", this, _bbd._psv);

    ATOMICRELEASE(_pdtView);

    if (_bbd._psv) 
    {
        //  Disable navigation while we are UIDeactivating/DestroyWindowing
        // the IShellView. Some OC/DocObject in it (such as ActiveMovie)
        // might have a message loop long enough to cause some reentrancy.

        _psbOuter->EnableModelessSB(FALSE);

        // Tell the shell's HTML window we are releasing the document.
        if (_phtmlWS)
        {
            _phtmlWS->ViewReleased();
        }

        //
        //  We need to cancel the menu mode so that unmerging menu won't
        // destroy the menu we are dealing with (which caused GPF in USER).
        // DocObject needs to do appropriate thing for context menus.
        // (02-03-96 SatoNa)
        //
        HWND hwndCapture = GetCapture();
        TraceMsg(DM_CANCELMODE, "ReleaseShellView hwndCapture=%x _bbd._hwnd=%x", hwndCapture, _bbd._hwnd);
        if (hwndCapture && hwndCapture==_bbd._hwnd) 
        {
            TraceMsg(DM_CANCELMODE, "ReleaseShellView Sending WM_CANCELMODE");
            SendMessage(_bbd._hwnd, WM_CANCELMODE, 0, 0);
        }

        //
        //  We don't want to resize the previous view window while we are
        // navigating away from it.
        //
        TraceMsg(TF_SHDUIACTIVATE, "CSB::ReleaseShellView setting _fDontResizeView");
        _fDontResizeView = TRUE;

        // If the current view is still waiting for ReadyStateComplete,
        // and the view we're swapping in here does not support this property,
        // then we'll never go to ReadyStateComplete! Simulate it here:
        //
        // NOTE: ZekeL put this in _CancelNavigation which happened way too often.
        // I think this is the case he was trying to fix, but I don't remember
        // the bug number so I don't have a specific repro...
        //
        
        if (!_bbd._fIsViewMSHTML)
        {
            _fReleasingShellView = TRUE;
            OnReadyStateChange(_bbd._psv, READYSTATE_COMPLETE);
            _fReleasingShellView = FALSE;
        }

        // At one point during a LOR stress test, we got re-entered during
        // this UIActivate call (some rogue 3rd-party IShellView perhaps?)
        // which caused _psv to get freed, and we faulted during the unwind.
        // Gaurd against this by swapping the _psv out early.
        //
        IShellView* psv = _bbd._psv;
        _bbd._psv = NULL;
        if (psv)
        {
            psv->UIActivate(SVUIA_DEACTIVATE);
            if (_cRefUIActivateSV)
            {
                TraceMsg(TF_WARNING, "CBB(%x)::ReleaseShellView setting _bbd._psv = NULL (was %x) while _cRefUIActivateSV=%d",
                    this, psv, _cRefUIActivateSV);
            }

            ATOMICRELEASE(_bbd._pctView);

            if (_pvo)
            {
                IAdviseSink *pSink;

                // paranoia: only blow away the advise sink if it is still us
                if (SUCCEEDED(_pvo->GetAdvise(NULL, NULL, &pSink)) && pSink)
                {
                    if (pSink == SAFECAST(this, IAdviseSink *))
                        _pvo->SetAdvise(0, 0, NULL);

                    pSink->Release();
                }

                fViewObjectChanged = TRUE;
                ATOMICRELEASE(_pvo);
            }
            
            psv->SaveViewState();
            TraceMsg(DM_NAV, "ief NAV::%s %x",TEXT("ReleaseShellView Calling DestroyViewWindow"), psv);
            psv->DestroyViewWindow();
    
            UINT cRef = psv->Release();
            TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("ReleaseShellView called psv->Release"), psv, cRef);

            _bbd._hwndView = NULL;
            TraceMsg(TF_SHDUIACTIVATE, "CSB::ReleaseShellView resetting _fDontResizeView");
            _fDontResizeView = FALSE;

            if (_bbd._pidlCur) 
            {
                ILFree(_bbd._pidlCur);
                _bbd._pidlCur = NULL;
            }
        }
        
        _psbOuter->EnableModelessSB(TRUE);

        //
        //  If there is any blocked async operation AND we can navigate now,
        // unblock it now. 
        //
        _MayUnblockAsyncOperation();
    }

    ATOMICRELEASE(_bbd._psf);

    if (fViewObjectChanged)
        _ViewChange(DVASPECT_CONTENT, -1);

    if (_bbd._pszTitleCur)
    {
        LocalFree(_bbd._pszTitleCur);
        _bbd._pszTitleCur = NULL;
    }

    // NOTES: (SatoNa)
    //
    //  This is the best time to clean up the left-over from UI-negotiation
    // from the previous DocObject. Excel 97, for some reason, takes 16
    // pixels from the top (for the formula bar) when we UI-deactivate it
    // by callin gIOleDocumentView::UIActivate(FALSE), which we call above.
    //
    SetRect(&_rcBorderDoc, 0, 0, 0, 0);
    return S_OK;
}

void CBaseBrowser2::_StopCurrentView()
{
    // send OLECMDID_STOP
    if (_bbd._pctView) // we must check!
    {
        _bbd._pctView->Exec(NULL, OLECMDID_STOP, OLECMDEXECOPT_DONTPROMPTUSER, NULL, NULL);
    }
}

//
// This function synchronously cancels the pending navigation if any.
//
HRESULT CBaseBrowser2::_CancelPendingNavigation(BOOL fDontReleaseState)
{
    TraceMsg(TF_SHDNAVIGATE, "CBB::_CancelPendingNavigation called");
    
    _StopAsyncOperation();
    
    HRESULT hres = S_FALSE;

#ifndef NON_NATIVE_FRAMES

    if (_bbd._psvPending) 
    {
        if (_IsViewMSHTML(_bbd._psvPending))
        {
            VARIANT varStop;

            V_VT(&varStop)   = VT_BOOL;
            V_BOOL(&varStop) = VARIANT_TRUE;

            IUnknown_Exec(_bbd._psvPending, NULL, OLECMDID_STOP, 0, &varStop, NULL);
        }
        else
        {
            if (_bbd._phlf && !fDontReleaseState) 
            {
                 // release our state
                 _bbd._phlf->Navigate(0, NULL, NULL, NULL);
            }

            _CancelPendingView();
        }

        hres = S_OK;
    }

#else

    if (_bbd._psvPending) 
    {
        if (_bbd._phlf && !fDontReleaseState) 
        {
             // release our state
             _bbd._phlf->Navigate(0, NULL, NULL, NULL);
        }

        _CancelPendingView();
        hres = S_OK;
    }

#endif

    return hres;
}

void CBaseBrowser2::_SendAsyncNavigationMsg(VARIANTARG *pvarargIn)
{
    LPCWSTR psz = VariantToStrCast(pvarargIn);
    if (psz)
    {
        LPITEMIDLIST pidl;
        if (EVAL(SUCCEEDED(IECreateFromPathW(psz, &pidl))))
        {
            _NavigateToPidlAsync(pidl, 0); // takes ownership of pidl
        }
    }
}


//
// NOTES: It does not cancel the pending view.
//
void CBaseBrowser2::_StopAsyncOperation(void)
{
    // Don't remove posted WMC_ASYNCOPERATION message. PeekMesssage removes
    // messages for children! (SatoNa)
    _uActionQueued = ASYNCOP_NIL;

    // Remove the pidl in the queue (single depth)
    _FreeQueuedPidl(&_pidlQueued);
}

//
//  This function checks if we have any asynchronous operation AND
// we no longer need to postpone. In that case, we unblock it by
// posting a WMC_ASYNCOPERATION.
//
void CBaseBrowser2::_MayUnblockAsyncOperation(void)
{
    if (_uActionQueued!=ASYNCOP_NIL && _CanNavigate()) 
    {
        TraceMsg(TF_SHDNAVIGATE, "CBB::_MayUnblockAsyncOp posting WMC_ASYNCOPERATION");
        PostMessage(_bbd._hwnd, WMC_ASYNCOPERATION, 0, 0);
    }
}

BOOL CBaseBrowser2::_PostAsyncOperation(UINT uAction)
{
    _uActionQueued = uAction;
    return PostMessage(_bbd._hwnd, WMC_ASYNCOPERATION, 0, 0);
}

LRESULT CBaseBrowser2::_SendAsyncOperation(UINT uAction)
{
    _uActionQueued = uAction;
    return SendMessage(_bbd._hwnd, WMC_ASYNCOPERATION, 0, 0);
}

HRESULT CBaseBrowser2::_CancelPendingNavigationAsync(void)
{
    TraceMsg(TF_SHDNAVIGATE, "CBB::_CancelPendingNavigationAsync called");

    _StopAsyncOperation();
    _PostAsyncOperation(ASYNCOP_CANCELNAVIGATION);
    return S_OK;
}

HRESULT CBaseBrowser2::_CancelPendingView(void)
{
    if (_bbd._psvPending) 
    {
        TraceMsg(DM_NAV, "ief NAV::%s %x",TEXT("_CancelPendingView Calling DestroyViewWindow"), _bbd._psvPending);
        _bbd._psvPending->DestroyViewWindow();

        ASSERT(_bbd._psfPending);

        // When cancelling a pending navigation, make sure we
        // think the pending operation is _COMPLETE otherwise
        // we may get stuck in a _LOADING state...
        //
        TraceMsg(TF_SHDNAVIGATE, "basesb(%x) Fake pending ReadyState_Complete", this);
        OnReadyStateChange(_bbd._psvPending, READYSTATE_COMPLETE);

        ATOMICRELEASE(_bbd._psvPending);

        // Paranoia
        ATOMICRELEASE(_bbd._psfPending);
        
        _bbd._hwndViewPending = NULL;

        _setDescendentNavigate(NULL);

        SetNavigateState(BNS_NORMAL);

        if (_bbd._pidlPending) 
        {
            ILFree(_bbd._pidlPending);
            _bbd._pidlPending = NULL;
        }

        if (_bbd._pszTitlePending)
        {
            LocalFree(_bbd._pszTitlePending);
            _bbd._pszTitlePending = NULL;
        }

        // Pending navigation is canceled.
        // since the back button works as a stop on pending navigations, we
        // should check that here as well.
        _pbsOuter->UpdateBackForwardState();
        _NotifyCommandStateChange();

        _PauseOrResumeView(_fPausedByParent);
    }
    return S_OK;
}

void CBaseBrowser2::_UpdateTravelLog(BOOL fForceUpdate /* = FALSE */)
{
    //
    //  we update the travellog in two parts.  first we update
    //  the current entry with the current state info, 
    //  then we create a new empty entry.  UpdateEntry()
    //  and AddEntry() need to always be in pairs, with 
    //  identical parameters.
    //
    //  if this navigation came from a LoadHistory, the 
    //  _fDontAddTravelEntry will be set, and the update and 
    //  cursor movement will have been adjusted already.
    //  we also want to prevent new frames from updating 
    //  and adding stuff, so unless this is the top we
    //  wont add to the travellog if this is a new frame.
    //
    ASSERT(!(_grfHLNFPending & HLNF_CREATENOHISTORY));

    ITravelLog *ptl;
    GetTravelLog(&ptl);
    BOOL fTopFrameBrowser = IsTopFrameBrowser(SAFECAST(this, IServiceProvider *), SAFECAST(this, IShellBrowser *));
 
    if (ptl)
    {
        //  
        //  some times we are started by another app (MSWORD usually) that has HLink
        //  capability.  we detect this by noting that we are a new browser with an empty
        //  TravelLog, and then see if we can get a IHlinkBrowseContext.  if this is successful,
        //  we should add an entry and update it immediately with the external info.
        //
        IHlinkBrowseContext *phlbc = NULL;  // init to suppress bogus C4701 warning
        BOOL fExternalNavigate = (FAILED(ptl->GetTravelEntry(SAFECAST(this, IBrowserService *), 0, NULL)) &&
            fTopFrameBrowser && _bbd._phlf && SUCCEEDED(_bbd._phlf->GetBrowseContext(&phlbc)));

        if (fExternalNavigate)
        {
            ptl->AddEntry(SAFECAST(this, IBrowserService *), FALSE);
            ptl->UpdateExternal(SAFECAST(this, IBrowserService *), phlbc);
            phlbc->Release();
        }
        else if (_bbd._psv && (fForceUpdate || !_fIsLocalAnchor || (_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)))
        {
            ptl->UpdateEntry(SAFECAST(this, IBrowserService *), _fIsLocalAnchor);  // CAST for IUnknown
        }

        if (!_fDontAddTravelEntry && (_bbd._psv || fTopFrameBrowser))
        {
            ptl->AddEntry(SAFECAST(this, IBrowserService *), _fIsLocalAnchor);  // CAST for IUnknown
        }

        ptl->Release();
    }

    _fDontAddTravelEntry  = FALSE;
    _fIsLocalAnchor       = FALSE;
}


void CBaseBrowser2::_OnNavigateComplete(LPCITEMIDLIST pidl, DWORD grfHLNF)
{
    _pbsOuter->UpdateBackForwardState();
}


//// Does only the top shbrowse need this?  or the top oc frame too?
HRESULT CBaseBrowser2::UpdateSecureLockIcon(int eSecureLock)
{
    // only the top boy should get to set his stuff
    if (!IsTopFrameBrowser(SAFECAST(this, IServiceProvider *), SAFECAST(this, IShellBrowser *)))
        return S_OK;

    if (eSecureLock != SECURELOCK_NOCHANGE)
        _bbd._eSecureLockIcon = eSecureLock;
    
    // 
    //  There is no mixed Security Icon - zekel 6-AUG-97
    //  right now we have no icon or TT for SECURELOCK_SET_MIXED, which 
    //  is set when the root page is secure but some of the other content
    //  or frames are not.  some PM needs to implement, probably 
    //  with consultation from TonyCi and DBau.  by default we currently
    //  only show for pages that are completely secure.
    //

    TraceMsg(DM_SSL, "CBB:UpdateSecureLockIcon() _bbd._eSecureLockIcon = %d", _bbd._eSecureLockIcon);

    //
    // It looks like it doesnt matter what icon we select here,
    // the status bar always shows some lock icon that was cached there earlier
    // and it treats this HICON as a bool to indicat on or off  - zekel - 5-DEC-97
    //

    HICON hicon = NULL;
    TCHAR szText[MAX_TOOLTIP_STRING];

    szText[0] = 0;

    switch (_bbd._eSecureLockIcon)
    {
    case SECURELOCK_SET_UNSECURE:
    case SECURELOCK_SET_MIXED:
        hicon = NULL;
        break;

    case SECURELOCK_SET_SECUREUNKNOWNBIT:
        hicon = g_hiconSSL;
        break;

    case SECURELOCK_SET_SECURE40BIT:
        hicon = g_hiconSSL;
        MLLoadString(IDS_SSL40, szText, ARRAYSIZE(szText));
        break;

    case SECURELOCK_SET_SECURE56BIT:
        hicon = g_hiconSSL;
        MLLoadString(IDS_SSL56, szText, ARRAYSIZE(szText));
        break;

    case SECURELOCK_SET_SECURE128BIT:
        hicon = g_hiconSSL;
        MLLoadString(IDS_SSL128, szText, ARRAYSIZE(szText));
        break;

    case SECURELOCK_SET_FORTEZZA:
        hicon = g_hiconFortezza;
        MLLoadString(IDS_SSL_FORTEZZA, szText, ARRAYSIZE(szText));
        break;

    default:
        ASSERT(0);
        return E_FAIL;
    }

    VARIANTARG var = {0};
    if (_bbd._pctView && SUCCEEDED(_bbd._pctView->Exec(&CGID_Explorer, SBCMDID_GETPANE, PANE_SSL, NULL, &var))
        && V_UI4(&var) != PANE_NONE)
    {
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETICON, V_UI4(&var), (LPARAM)(hicon), NULL);
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTIPTEXT, V_UI4(&var), (LPARAM)(szText[0] ? szText : NULL), NULL);

        // Also add the tip text as the pane's normal text.  Because of the pane's size it will be clipped,
        // but it will show up as a useful string in MSAA.
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTEXTW, V_UI4(&var), (LPARAM)(szText[0] ? szText : NULL), NULL);
    }    
    return S_OK;
}

//
// Update Privacy Icon
//
HRESULT CBaseBrowser2::_UpdatePrivacyIcon(BOOL fSetState, BOOL fNewImpacted)
{
    static BOOL fHelpShown = FALSE;

    //
    // only the top boy should get to set his stuff
    //
    if (!IsTopFrameBrowser(SAFECAST(this, IServiceProvider *), SAFECAST(this, IShellBrowser *)))
        return S_OK;

    //
    // save off the privacy state
    //
    if(fSetState)
    {
        _bbd._fPrivacyImpacted = fNewImpacted;
    }

    HICON hicon = NULL;
    TCHAR szText[MAX_TOOLTIP_STRING];

    szText[0] = 0;

    if(_bbd._fPrivacyImpacted)
    {
        hicon = g_hiconPrivacyImpact;
        MLLoadString(IDS_PRIVACY_TOOLTIP, szText, ARRAYSIZE(szText));
    }

    if (_bbd._pctView)
    {
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETICON, STATUS_PANE_PRIVACY, (LPARAM)(hicon), NULL);
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTIPTEXT, STATUS_PANE_PRIVACY, (LPARAM)(szText[0] ? szText : NULL), NULL);

        // Also add the tip text as the panes normal text.  Because of the pane's size it will be clipped,
        // but it will show up as a useful string in MSAA.
        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTEXTW, STATUS_PANE_PRIVACY, (LPARAM)(szText[0] ? szText : NULL), NULL);
    }    

    // if impacted and never shown before, show bubble toolhelp
    if(FALSE == fHelpShown && _bbd._fPrivacyImpacted)
    {
        DWORD   dwValue, dwSize;

        // only do this work once
        fHelpShown = TRUE;

        // Check to see if we should show discovery UI
        dwSize = sizeof(DWORD);
        if(ERROR_SUCCESS != SHGetValueW(HKEY_CURRENT_USER,
                REGSTR_PATH_INTERNET_SETTINGS,
                REGSTR_VAL_PRIVDISCOVER,
                NULL, &dwValue, &dwSize)
            || 0 == dwValue)
        {
            BOOL    bStatusBarVisible = FALSE;
            INT_PTR i = 1;
            HRESULT hr;

            // suppression setting not set, show ui if status bar is visible
            IBrowserService *pbs;
            hr = _pspOuter->QueryService(SID_STopFrameBrowser, IID_PPV_ARG(IBrowserService, &pbs));
            if(SUCCEEDED(hr))
            {
                hr = pbs->IsControlWindowShown(FCW_STATUS, &bStatusBarVisible);
                pbs->Release();
            }

            BOOL fDontShowPrivacyFirstTimeDialogAgain = FALSE;
            if(SUCCEEDED(hr) && bStatusBarVisible)
            {
                fDontShowPrivacyFirstTimeDialogAgain = DoPrivacyFirstTimeDialog( _bbd._hwnd);
            }

            if( fDontShowPrivacyFirstTimeDialogAgain == TRUE)
            {
                dwValue = 1;
                SHSetValue(HKEY_CURRENT_USER, REGSTR_PATH_INTERNET_SETTINGS, REGSTR_VAL_PRIVDISCOVER,
                    REG_DWORD, &dwValue, sizeof(DWORD));
            }
        }
    }

    return S_OK;
}

//
//  This block of code simply prevents calling UIActivate of old
// extensions with a new SVUIA_ value.
//
HRESULT CBaseBrowser2::_UIActivateView(UINT uState)
{
    if (_bbd._psv) 
    {
        BOOL fShellView2;
        IShellView2* psv2;
        if (SUCCEEDED(_bbd._psv->QueryInterface(IID_PPV_ARG(IShellView2, &psv2))))
        {
            fShellView2 = TRUE;
            psv2->Release();
        }
        else
        {
            fShellView2 = FALSE;
        }

        if (uState == SVUIA_INPLACEACTIVATE && !fShellView2)
        {
            uState = SVUIA_ACTIVATE_NOFOCUS;        // map it to old one.
        }

        if (_cRefUIActivateSV)
        {
            TraceMsg(TF_WARNING, "CBB(%x)::_UIActivateView(%d) entered reentrantly!!!!!! _cRefUIActivate=%d",
                this, uState, _cRefUIActivateSV);
            if (uState == SVUIA_DEACTIVATE)
            {
                _fDeferredUIDeactivate = TRUE;
                return S_OK;
            }
            if (!_HeyMoe_IsWiseGuy())
            {
                if (_bbd._psv)
                    _bbd._psv->UIActivate(SVUIA_INPLACEACTIVATE);
                return S_OK;
            }
        }

        _cRefUIActivateSV++;

        TraceMsg(TF_SHDUIACTIVATE, "CBaseBrowser2(%x)::_UIActivateView(%d) about to call _bbd._psv(%x)->UIActivate",
            this, uState, _bbd._psv);

        _bbd._psv->UIActivate(uState);

        if (uState == SVUIA_ACTIVATE_FOCUS && !fShellView2)
        {
            // win95 defview expects a SetFocus on activation (nt5 bug#172210)
            if (_bbd._hwndView)
                SetFocus(_bbd._hwndView);
        }

        TraceMsg(TF_SHDUIACTIVATE, "CBaseBrowser2(%x)::_UIActivateView(%d) back from _bbd._psv(%x)->UIActivate",
            this, uState, _bbd._psv);

        _cRefUIActivateSV--;

        _UpdatePrivacyIcon(FALSE, FALSE);
        UpdateSecureLockIcon(SECURELOCK_NOCHANGE);
        
    }
    _bbd._uActivateState = uState;

    // If this is a pending view, set the focus to its window even though it's hidden.
    // In ActivatePendingView(), we check if this window still has focus and, if it does,
    // we will ui-activate the view. Fix for IE5 bug #70632 -- MohanB

    if (    SVUIA_ACTIVATE_FOCUS == uState
        &&  !_bbd._psv
        &&  !_bbd._hwndView
        &&  _bbd._psvPending
        &&  _bbd._hwndViewPending
       )
    {
        ::SetFocus(_bbd._hwndViewPending);
    }

    if (_fDeferredUIDeactivate)
    {
        TraceMsg(TF_SHDUIACTIVATE, "CBaseBrowser2(%x)::_UIActivateView processing deferred UIDeactivate, _bbd._psv=%x",
            this, _bbd._psv);
        _fDeferredUIDeactivate = FALSE;
        if (_bbd._psv)
            _bbd._psv->UIActivate(SVUIA_DEACTIVATE);
        _UpdatePrivacyIcon(FALSE, FALSE);
        UpdateSecureLockIcon(SECURELOCK_NOCHANGE);
        _bbd._uActivateState = SVUIA_DEACTIVATE;
    }

    if (_fDeferredSelfDestruction)
    {
        TraceMsg(TF_SHDUIACTIVATE, "CBaseBrowser2(%x)::_UIActivateView processing deferred OnDestroy",
            this);
        _fDeferredSelfDestruction = FALSE;
        _pbsOuter->OnDestroy();
    }

    return S_OK;
}


//Called from CShellBrowser::OnCommand
HRESULT CBaseBrowser2::Offline(int iCmd)
{
    HRESULT hresIsOffline = IsGlobalOffline() ? S_OK : S_FALSE;

    switch(iCmd){
    case SBSC_TOGGLE:
        hresIsOffline = (hresIsOffline == S_OK) ? S_FALSE : S_OK; // Toggle Property
        // Tell wininet that the user wants to go offline
        SetGlobalOffline(hresIsOffline == S_OK); 
        SendShellIEBroadcastMessage(WM_WININICHANGE,0,0, 1000); // Tell all browser windows to update their title   
        break;
        
    case SBSC_QUERY:
        break;
    default: // Treat like a query
        break;                   
    }
    return hresIsOffline;
}



BOOL _TrackPidl(LPITEMIDLIST pidl, IUrlHistoryPriv *php, BOOL fIsOffline, LPTSTR pszUrl, DWORD cchUrl)
{
    BOOL fRet = FALSE;

    // Should use IsBrowserFrameOptionsPidlSet(pidl, BFO_ENABLE_HYPERLINK_TRACKING)
    //     instead of IsURLChild() because it doesn't work in Folder Shortcuts and doesn't
    //     work in NSEs outside of the "IE" name space (like Web Folders).
    if (pidl && IsURLChild(pidl, FALSE))
    {
        if (SUCCEEDED(IEGetNameAndFlags(pidl, SHGDN_FORPARSING, pszUrl, cchUrl, NULL)))
        {
            PROPVARIANT vProp;
            if (SUCCEEDED(php->GetProperty(pszUrl, PID_INTSITE_TRACKING, &vProp)))
            {
                if (vProp.vt == VT_UI4)
                {
                    if (fIsOffline)
                        fRet = (vProp.ulVal & TRACK_OFFLINE_CACHE_ENTRY) ? TRUE : FALSE;
                    else
                        fRet = (vProp.ulVal & TRACK_ONLINE_CACHE_ENTRY) ? TRUE : FALSE;
                }

                PropVariantClear(&vProp);
            }
        }
    }

    return fRet;
}

// End tracking of previous page
// May start tracking of new page
// use SatoN's db to quick check tracking/tracking scope bits, so
// to eliminate call to CUrlTrackingStg::IsOnTracking
void CBaseBrowser2::_MayTrackClickStream(LPITEMIDLIST pidlNew)
{
    BOOL    fIsOffline = (Offline(SBSC_QUERY) != S_FALSE);
    IUrlHistoryStg*    phist;
    IUrlHistoryPriv*   phistp;
    PROPVARIANT vProp = {0};
    TCHAR szUrl[MAX_URL_STRING];

    ASSERT(_bbd._pautoWB2);

    HRESULT hr = _pspOuter->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IUrlHistoryStg, &phist));
    if (SUCCEEDED(hr))
    {
        hr = phist->QueryInterface(IID_PPV_ARG(IUrlHistoryPriv, &phistp));
        phist->Release();
    }

    if (SUCCEEDED(hr))
    {
        if (_TrackPidl(_bbd._pidlCur, phistp, fIsOffline, szUrl, SIZECHARS(szUrl)))
        {
            if (_ptracking)
                _ptracking->OnUnload(szUrl);
            else
                hr = E_FAIL;
        }
    }

    if (SUCCEEDED(hr))
    {
        if (_TrackPidl(pidlNew, phistp, fIsOffline, szUrl, SIZECHARS(szUrl)))
        {    
            // instance of object already exists
            BRMODE brMode = BM_NORMAL;
            DWORD dwOptions;

            if (!_ptracking) 
            {
                _ptracking = new CUrlTrackingStg();
                if (!_ptracking)
                    hr = E_OUTOFMEMORY;
            }

            if (SUCCEEDED(hr))
            {
                hr = GetTopFrameOptions(_pspOuter, &dwOptions);
                if (SUCCEEDED(hr))
                {
                    //Is this a desktop component?                    
                    if (dwOptions & FRAMEOPTIONS_DESKTOP)
                        brMode = BM_DESKTOP;
                    //Is it fullscreen?                    
                    else if (dwOptions & (FRAMEOPTIONS_SCROLL_AUTO | FRAMEOPTIONS_NO3DBORDER))
                        brMode = BM_THEATER;
                }

                _ptracking->OnLoad(szUrl, brMode, FALSE);
            }
        }
    }

    phistp->Release();
}


HRESULT CBaseBrowser2::_SwitchActivationNow()
{
    ASSERT(_bbd._psvPending);

    WORD wNavTypeFlags = 0;  // init to suppress bogus C4701 warning

    IShellView* psvNew = _bbd._psvPending;
    IShellFolder* psfNew = _bbd._psfPending;
    HWND hwndViewNew = _bbd._hwndViewPending;
    LPITEMIDLIST pidlNew = _bbd._pidlPending;

    _bbd._fIsViewMSHTML = _IsViewMSHTML(psvNew);
    
    _bbd._psvPending = NULL;
    _bbd._psfPending = NULL;
    _bbd._hwndViewPending = NULL;
    _bbd._pidlPending = NULL;

    // Quickly check tracking prefix string on this page,
    // if turned on, log enter/exit events
    // Should use IsBrowserFrameOptionsSet(_bbd._psf, BFO_ENABLE_HYPERLINK_TRACKING)
    //     instead of IsURLChild() because it doesn't work in Folder Shortcuts and doesn't
    //     work in NSEs outside of the "IE" name space (like Web Folders).
    if ((_bbd._pidlCur && IsURLChild(_bbd._pidlCur, FALSE)) ||
        (pidlNew && IsURLChild(pidlNew, FALSE)))
        _MayTrackClickStream(pidlNew);

    // nuke the old stuff
    _pbsOuter->ReleaseShellView();
    
    ASSERT(!_bbd._psv && !_bbd._psf && !_bbd._hwndView);

    // activate the new stuff
    if (_grfHLNFPending != (DWORD)-1) 
    {
        _OnNavigateComplete(pidlNew, _grfHLNFPending);
    }

    VALIDATEPENDINGSTATE();

    // now do the actual switch

    // no need to addref because we're keeping the pointer and just chaning
    // it from the pending to the current member variables
    _bbd._psf = psfNew;
    _bbd._psv = psvNew; 

    ILFree(_bbd._pidlCur);
    _bbd._pidlCur = pidlNew;

    DEBUG_CODE(TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];)
    DEBUG_CODE(IEGetDisplayName(_bbd._pidlCur, szPath, SHGDN_FORPARSING);)
    DEBUG_CODE(TraceMsg(DM_TRACE, "CBB::ActivatePendingView (TRAVELLOG): _UpdateTravelLog called from shdocvw for %ws", szPath);)

    _bbd._hwndView = hwndViewNew;
    _dwReadyStateCur = _dwReadyStatePending;

    if (_bbd._pszTitleCur)
        LocalFree(_bbd._pszTitleCur);
    _bbd._pszTitleCur = _bbd._pszTitlePending;
    _bbd._pszTitlePending = NULL;

    if (_eSecureLockIconPending != SECURELOCK_NOCHANGE)
    {
        _bbd._eSecureLockIcon = _eSecureLockIconPending;
        _eSecureLockIconPending = SECURELOCK_NOCHANGE;
    }

    //
    //  This is the best time to resize the newone.
    //
    _pbsOuter->_UpdateViewRectSize();
    SetWindowPos(_bbd._hwndView, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);

    // WARNING: Not all shellview supports IOleCommandTarget!!!
    _fUsesPaletteCommands = FALSE;
    
    if ( _bbd._psv )
    {
        _bbd._psv->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &_bbd._pctView));

        // PALETTE: Exec down to see if they support the colors changes Command so that we don't have to 
        // PALETTE: wire ourselves into the OnViewChange mechanism just to get palette changes...
        if ( _bbd._pctView && 
             SUCCEEDED(_bbd._pctView->Exec( &CGID_ShellDocView, SHDVID_CANDOCOLORSCHANGE, 0, NULL, NULL)))
        {
            _fUsesPaletteCommands = TRUE;

            // force a colors dirty to make sure that we check for a new palette for each page...
            _ColorsDirty( BPT_UnknownPalette );
        }
    }

    // PALETTE: only register for the OnViewChange stuff if the above exec failed...
    if (SUCCEEDED(_bbd._psv->QueryInterface(IID_PPV_ARG(IViewObject, &_pvo))) && !_fUsesPaletteCommands )
        _pvo->SetAdvise(DVASPECT_CONTENT, ADVF_PRIMEFIRST, this);

    _Exec_psbMixedZone();

    if (_bbd._pctView != NULL)
    {
        _bbd._pctView->Exec(&CGID_ShellDocView, SHDVID_RESETSTATUSBAR, 0, NULL, NULL);
    }

    return S_OK;
}

// This member is called when we about to destroy the current shell view.
// Returning S_FALSE indicate that the user hit CANCEL when it is prompted
// to save the changes (if any).

HRESULT CBaseBrowser2::_MaySaveChanges(void)
{
    HRESULT hres = S_OK;
    if (_bbd._pctView) // we must check!
    {
        hres = _bbd._pctView->Exec(&CGID_Explorer, SBCMDID_MAYSAVECHANGES,
                            OLECMDEXECOPT_PROMPTUSER, NULL, NULL);
    }
    return hres;
}

HRESULT CBaseBrowser2::_DisableModeless(void)
{
    if (_cRefCannotNavigate == 0)
    {
        OLECMD rgCmd;
        BOOL fPendingInScript = FALSE;

        //  if pending shell view supports it, give it a chance to tell us it's not ready
        //  to deactivate [eg executing a script].  normally scripts should not be run
        //  before inplace activation, but TRIDENT sometimes has to do this when parsing.
        //
        rgCmd.cmdID = SHDVID_CANDEACTIVATENOW;
        rgCmd.cmdf = 0;

        if (SUCCEEDED(IUnknown_QueryStatus(_bbd._psvPending, &CGID_ShellDocView, 1, &rgCmd, NULL)) &&
            (rgCmd.cmdf & MSOCMDF_SUPPORTED) &&
            !(rgCmd.cmdf & MSOCMDF_ENABLED))
        {
            fPendingInScript = TRUE;
        }

        if (!fPendingInScript) 
        {
            return S_FALSE;
        }
    }
    return S_OK;
}

BOOL CBaseBrowser2::_CanNavigate(void)
{
    return !((_DisableModeless() == S_OK) || (! IsWindowEnabled(_bbd._hwnd)));
}

HRESULT CBaseBrowser2::CanNavigateNow(void)
{
    return _CanNavigate() ? S_OK : S_FALSE;
}

HRESULT CBaseBrowser2::_PauseOrResumeView(BOOL fPaused)
{
    // If fPaused (it's minimized or the parent is minimized) or
    // _bbd._psvPending is non-NULL, we need to pause.
    if (_bbd._pctView) 
    {
        VARIANT var = { 0 };
        var.vt = VT_I4;
        var.lVal = (_bbd._psvPending || fPaused) ? FALSE : TRUE;
        _bbd._pctView->Exec(NULL, OLECMDID_ENABLE_INTERACTION, OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
    }

    return S_OK;
}

HRESULT CBaseBrowser2::CreateViewWindow(IShellView* psvNew, IShellView* psvOld, LPRECT prcView, HWND* phwnd)
{
    _fCreateViewWindowPending = TRUE;
    _pbsOuter->GetFolderSetData(&(_fldBase._fld)); // it's okay to stomp on this every time

    HRESULT hres = FileCabinet_CreateViewWindow2(_psbOuter, &_fldBase, psvNew, psvOld, prcView, phwnd);

    _fCreateViewWindowPending = FALSE;
    return hres;
}


//
// grfHLNF == (DWORD)-1 means don't touch the history at all.
//
// NOTE:
// if _fCreateViewWindowPending == TRUE, it means we came through here once
// already, but we are activating a synchronous view and the previous view would
// not deactivate immediately...
// It is used to delay calling IShellView::CreateViewWindow() for shell views until we know that
// we can substitute psvNew for _bbd._psv.
//
HRESULT CBaseBrowser2::_CreateNewShellView(IShellFolder* psf, LPCITEMIDLIST pidl, DWORD grfHLNF)
{
    BOOL fActivatePendingView = FALSE;
    IShellView *psvNew = NULL;

    // Bail Out of Navigation if modal windows are up from our view
    // Should we restart navigation on next EnableModeless(TRUE)?
    if (!_CanNavigate())
    {
        TraceMsg(DM_ENABLEMODELESS, "CSB::_CreateNewShellView returning ERROR_BUSY");
        return HRESULT_FROM_WIN32(ERROR_BUSY);
    }
        
    HRESULT hres = _MaySaveChanges();
    if (hres == S_FALSE)
    {
        TraceMsg(DM_WARNING, "CBB::_CreateNewShellView _MaySaveChanges returned S_FALSE. Navigation canceled");
        return HRESULT_FROM_WIN32(ERROR_CANCELLED);
    }

    TraceMsg(DM_WARNING, "CBB::_CNSV - Cur View MSHTML? %d  Pending View MSHTML? %d",
             _IsViewMSHTML(_bbd._psv), _IsViewMSHTML(_bbd._psvPending));

    VALIDATEPENDINGSTATE();

#ifndef NON_NATIVE_FRAMES

    // The navigation has been interrupted.
    //
    if (   _bbd._psv
        && _bbd._psvPending
        && _IsViewMSHTML(_bbd._psvPending))
    {
        _fHtmlNavCanceled = TRUE;
    }

#endif

    _CancelPendingView();

    ASSERT (_fCreateViewWindowPending == FALSE);

    VALIDATEPENDINGSTATE();

    if (_bbd._psv && _IsViewMSHTML(_bbd._psv))
    {
        ATOMICRELEASE(_pphHistory);
        SafeGetItemObject(_bbd._psv, SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &_pphHistory));
    }

    hres = psf->CreateViewObject(_bbd._hwnd, IID_PPV_ARG(IShellView, &psvNew));

    if (SUCCEEDED(hres))
    {
        _bbd._fCreatingViewWindow = TRUE;

        IUnknown_SetSite(psvNew, _psbOuter);    // SetSite for the view

        _psbOuter->EnableModelessSB(FALSE);
    
        HWND hwndViewNew = NULL;
        RECT rcView;

        //
        // NOTES: SatoNa
        //
        //  Notice that we explicitly call _GetViewBorderRect (non-virtual)
        // instead of virtual _GetShellView, which CShellBrowser override.
        // We now call thru (virtual) _pbsOuter, is this o.k.?
        //
        _pbsOuter->_GetViewBorderRect(&rcView);

        // It is ncecessary for _bbd._pidlPending and _bbd._psvPending to both be set together.
        // they're  a pair
        // previously _bbd._pidlPending was being set after the call to
        // FileCabinet_CreateViewWindow and when messages were pumped there  [NOTE: messages should not have been pumped there...]
        // a redirect would be nofied in the bind status callback.
        // this meant that a valid _bbd._pidlPending was actually available BUT
        // then we would return and blow away that _bbd._pidlPending
        //
        ASSERT(_bbd._psvPending == NULL );
        _bbd._psvPending = psvNew;
        psvNew->AddRef();

        ASSERT(_bbd._psfPending == NULL);
        ASSERT(_bbd._pidlPending == NULL);

        _bbd._psfPending = psf;
        psf->AddRef();

        _bbd._pidlPending = ILClone(pidl);

        // Initialize _bbd._pidlNewShellView which will be used by GetViewStateStream
        _bbd._pidlNewShellView = pidl;
        _grfHLNFPending = grfHLNF;

        // Start at _COMPLETE just in case the object we connect
        // to doesn't notify us of ReadyState changes
        //
        _dwReadyStatePending = READYSTATE_COMPLETE;

        // We need to cache this information here because the _dwDocFlags
        // can change during the call to CreateViewWindow. This information
        // is needed to determine whether or not we should stop the current
        // view. If the document does not know how to navigate, then we
        // stop the current view. The is needed in order to stop the 
        // navigation in the current view when a new navigation has started.
        //
        BOOL fDocCanNavigate = _dwDocFlags & DOCFLAG_DOCCANNAVIGATE;

        hres = _pbsOuter->CreateViewWindow(psvNew, _bbd._psv, &rcView, &hwndViewNew);

        IUnknown_SetSite(psvNew, NULL); // The view by now must have psb

        _bbd._pidlNewShellView = NULL;

        TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("_CreateNewShellView(3) Called CreateViewWindow"), psvNew, hres);

        if (SUCCEEDED(hres))
        {
            // we defer the _PauseOrResumeView until here when we have enough
            // info to know if it's a new page or not.  o.w. we end up (e.g.)
            // stopping bgsounds etc. on local links (nash:32270).
#ifdef NON_NATIVE_FRAMES
            // 
            // Note (scotrobe): This was a no-op in IE5.
            //
            _PauseOrResumeView(_fPausedByParent);
            
            // We stop the current view because we need to flush away any image stuff that
            // is in queue so that the actual html file can get downloaded
            //
            _StopCurrentView();
#endif

            // We can't stop the current view if the doc knows how
            // to navigate. This is because in that case, the document
            // in current view is the same document as the pending view.
            //
            if (!fDocCanNavigate)
            {
                _StopCurrentView();
            }

            _bbd._hwndViewPending = hwndViewNew;

            // chrisfra - if hres == S_FALSE this (calling ActivatePendingViewAsync
            // when _bbd._psv==NULL) will break async URL download
            // as it will cause _bbd._psvPending to be set to NULL prematurely.  this should
            // be deferred until CDocObjectView::CBindStatusCallback::OnObjectAvailable
            //if (hres==S_OK || _bbd._psv==NULL)
            
            ASSERT(( hres == S_OK ) || ( hres == S_FALSE ));
            
            if (hres == S_OK)
            {
                // We should activate synchronously.
                //
                // NOTE: This used to be ActivatePendingViewAsyc(), but that causes a
                // fault if you navigated to C:\ and click A:\ as soon as it appears. This
                // puts the WM_LBUTTONDOWN in FRONT of the WMC_ASYNCOPERATION message. If
                // there's no disk in drive A: then a message box appears while in the
                // middle of the above FileCabinet_CreateViewWindow call and we pull off
                // the async activate and activate the view we're in the middle of
                // creating! Don't do that.
                //
                fActivatePendingView = TRUE;
            }
            else
            {
                // Activation is pending.
                // since the back button works as a stop on pending navigations, we
                // should check that here as well.
                _pbsOuter->UpdateBackForwardState();
            }
        }
        else
        {
            if (   _bbd._psvPending
                && !(_dwDocFlags & DOCFLAG_NAVIGATEFROMDOC)
                && _IsViewMSHTML(_bbd._psvPending))
            {
                _fHtmlNavCanceled = TRUE;
            }
            else
            {
                _fHtmlNavCanceled = FALSE;
            }

            TraceMsg(DM_WARNING, "ief _CreateNewShellView psvNew->CreateViewWindow failed %x", hres);
            _CancelPendingView();
        }

        psvNew->Release();

        if (_psbOuter)
            _psbOuter->EnableModelessSB(TRUE);
    }
    else
    {
        TraceMsg(TF_WARNING, "ief _BrowseTo psf->CreateViewObject failed %x", hres);
    }

    _fHtmlNavCanceled = FALSE;

    //
    //  If there is any blocked async operation AND we can navigate now,
    // unblock it now. 
    //
    _MayUnblockAsyncOperation();

    _bbd._fCreatingViewWindow = FALSE;

    VALIDATEPENDINGSTATE();

    TraceMsg(DM_WARNING, "CBB::_CNSV - Cur View MSHTML? %d  Pending View MSHTML? %d",
             _IsViewMSHTML(_bbd._psv), _IsViewMSHTML(_bbd._psvPending));

    if (fActivatePendingView && !_IsViewMSHTML(_bbd._psvPending))
    {
        //
        // Since _IsViewMSHTML can delegate to a marshalled interface,
        // we can get re-entrancy.  On re-entrancy, we can do a 
        // _CancelPendingView in which case _bbd._psvPending is 
        // no longer valid.
        //
        // So, we need to see if we still have _hbd._psvPending here.  
        //

        if (_bbd._psvPending)
        {
            _PreActivatePendingViewAsync(); // so we match old code

            hres = _pbsOuter->ActivatePendingView();
            if (FAILED(hres))
                TraceMsg(DM_WARNING, "CBB::_CNSV ActivatePendingView failed");
        }
    }

    TraceMsg(DM_STARTUP, "ief _CreateNewShellView returning %x", hres);
    return hres;
}

//  private bind that is very loose in its bind semantics.
HRESULT IEBindToObjectForNavigate(LPCITEMIDLIST pidl, IBindCtx * pbc, IShellFolder **ppsfOut);

// this binds to the pidl folder then hands off to CreateNewShellView
// if you have anything you need to do like checking before we allow the navigate, it
// should go into _NavigateToPidl
HRESULT CBaseBrowser2::_CreateNewShellViewPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD fSBSP)
{
    SetNavigateState(BNS_BEGIN_NAVIGATE);

    TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("_CreateNewShellViewPidl not same pidl"), pidl, _bbd._pidlCur);

    // Check for URL-pidl?

    // We will allow UI to be displayed by passing this IBindCtx to IShellFolder::BindToObject().
    IBindCtx * pbc = NULL;
    IShellFolder* psf;
    HRESULT hres;

    pbc = CreateBindCtxForUI(SAFECAST(this, IShellBrowser*));    // I'm safecasting to IUnknown.  IShellBrowser is only for disambiguation.
    hres = IEBindToObjectForNavigate(pidl, pbc, &psf);   // If pbc is NULL, we will survive.

    if (SUCCEEDED(hres))
    {
        hres = _CreateNewShellView(psf, pidl, grfHLNF);
        TraceMsg(DM_STARTUP, "CSB::_CreateNewShellViewPidl _CreateNewShellView(3) returned %x", hres);
        psf->Release();
    }
    else
    {
        // This will happen when a user tries to navigate to a directory past
        // MAX_PATH by double clicking on a subdirectory in the shell.
        TraceMsg(DM_TRACE, "CSB::_CreateNSVP BindToOject failed %x", hres);
    }

    
    // If _CreateNewShellView (or IEBindToObject) fails or the user cancels
    // the MayOpen dialog (hres==S_FALSE), we should restore the navigation
    // state to NORMAL (to stop animation). 
    if (FAILED(hres))
    {
        TraceMsg(TF_SHDNAVIGATE, "CSB::_CreateNSVP _CreateNewShellView FAILED (%x). SetNavigateState to NORMAL", hres);
        SetNavigateState(BNS_NORMAL);
    }

    ATOMICRELEASE(pbc);
    TraceMsg(DM_STARTUP, "CSB::_CreateNewShellViewPidl returning %x", hres);
    return hres;
}

//
// Returns the border rectangle for the shell view.
//
HRESULT CBaseBrowser2::_GetViewBorderRect(RECT* prc)
{
    _pbsOuter->_GetEffectiveClientArea(prc, NULL);  // hmon?
    // (derived class subtracts off border taken by all "frame" toolbars)
    return S_OK;
}

//
// Returns the window rectangle for the shell view window.
//
HRESULT CBaseBrowser2::GetViewRect(RECT* prc)
{
    //
    // By default (when _rcBorderDoc is empty), ShellView's window
    // rectangle is the same as its border rectangle.
    //
    _pbsOuter->_GetViewBorderRect(prc);

    // Subtract document toolbar margin
    prc->left += _rcBorderDoc.left;
    prc->top += _rcBorderDoc.top;
    prc->right -= _rcBorderDoc.right;
    prc->bottom -= _rcBorderDoc.bottom;

    TraceMsg(DM_UIWINDOW, "ief GetViewRect _rcBorderDoc=%x,%x,%x,%x",
             _rcBorderDoc.left, _rcBorderDoc.top, _rcBorderDoc.right, _rcBorderDoc.bottom);
    TraceMsg(DM_UIWINDOW, "ief GetViewRect prc=%x,%x,%x,%x",
             prc->left, prc->top, prc->right, prc->bottom);

    return S_OK;
}

HRESULT CBaseBrowser2::_PositionViewWindow(HWND hwnd, LPRECT prc)
{
    SetWindowPos(hwnd, NULL,
                 prc->left, prc->top, 
                 prc->right - prc->left, 
                 prc->bottom - prc->top,
                 SWP_NOZORDER | SWP_NOACTIVATE);

    return S_OK;
}

void CBaseBrowser2::_PositionViewWindowHelper(HWND hwnd, LPRECT prc)
{
    if (_pbsOuter3)
        _pbsOuter3->_PositionViewWindow(hwnd, prc);
    else
        _PositionViewWindow(hwnd, prc);
}

HRESULT CBaseBrowser2::_UpdateViewRectSize(void)
{
    RECT rc;

    TraceMsg(TF_SHDUIACTIVATE, "CSB::_UpdateViewRectSize called when _fDontReszeView=%d, _bbd._hwndV=%x, _bbd._hwndVP=%x",
             _fDontResizeView, _bbd._hwndView, _bbd._hwndViewPending);

    _pbsOuter->GetViewRect(&rc);

    if (_bbd._hwndView && !_fDontResizeView) 
    {
        TraceMsg(TF_SHDUIACTIVATE, "CSB::_UpdateViewRectSize resizing _bbd._hwndView(%x)", _bbd._hwndView);
        _PositionViewWindowHelper(_bbd._hwndView, &rc);
    }

    if (_bbd._hwndViewPending) 
    {
        TraceMsg(TF_SHDUIACTIVATE, "CSB::_UpdateViewRectSize resizing _bbd._hwndViewPending(%x)", _bbd._hwndViewPending);
        _PositionViewWindowHelper(_bbd._hwndViewPending, &rc);
    }
    return S_OK;
}

UINT g_idMsgGetAuto = 0;

// this stays in shdocvw because the OC requires drop target registration
void CBaseBrowser2::_RegisterAsDropTarget()
{
    // if it's okay to register and we haven't registered already
    // and we've processed WM_CREATE
    if (!_fNoDragDrop && !_fRegisteredDragDrop && _bbd._hwnd)
    {
        BOOL fAttemptRegister = _fTopBrowser ? TRUE : FALSE;

        // if we're not toplevel, we still try to register
        // if we have a proxy browser
        if (!fAttemptRegister)
        {
            IShellBrowser* psb;
            HRESULT hres = _pspOuter->QueryService(SID_SProxyBrowser, IID_PPV_ARG(IShellBrowser, &psb));
            if (SUCCEEDED(hres)) 
            {
                fAttemptRegister = TRUE;
                psb->Release();
            }
        }

        if (fAttemptRegister)
        {
            HRESULT hr;
            IDropTarget *pdt;

            // SAFECAST(this, IDropTarget*), the hard way
            hr = THR(QueryInterface(IID_PPV_ARG(IDropTarget, &pdt)));
            if (SUCCEEDED(hr)) 
            {
                hr = THR(RegisterDragDrop(_bbd._hwnd, pdt));
                if (SUCCEEDED(hr)) 
                {
                    _fRegisteredDragDrop = TRUE;
                }
                pdt->Release();
            }
        }
    }
}

void CBaseBrowser2::_UnregisterAsDropTarget()
{
    if (_fRegisteredDragDrop)
    {
        _fRegisteredDragDrop = FALSE;
        
        THR(RevokeDragDrop(_bbd._hwnd));
    }
}


HRESULT CBaseBrowser2::OnCreate(LPCREATESTRUCT pcs)
{
    HRESULT hres;
    TraceMsg(DM_STARTUP, "_OnCreate called");

    if (g_idMsgGetAuto == 0)
        g_idMsgGetAuto = RegisterWindowMessage(TEXT("GetAutomationObject"));

    hres = InitPSFInternet();

    // do stuff that depends on window creation
    if (SUCCEEDED(hres))
    {
        // this must be done AFTER the ctor so that we get virtuals right
        // NOTE: only do this if we're actually creating the window, because
        //       the only time we SetOwner(NULL) is OnDestroy.
        //
        _bbd._pautoSS->SetOwner(SAFECAST(this, IShellBrowser*));
    
        _RegisterAsDropTarget();
    }

    TraceMsg(DM_STARTUP, "ief OnCreate returning %d (SUCCEEDED(%x))", SUCCEEDED(hres), hres);

    return SUCCEEDED(hres) ? S_OK : E_FAIL;
}

HRESULT CBaseBrowser2::OnDestroy()
{
    //  We're seeing some reentrancy here.  If _cRefCannotNavigate is non-zero, it means we're
    //  in the middle of something and shouldn't destroy ourselves.
    //

    //  Also check reentrant calls to OnDestroy().
    if (_fInDestroy)
    {
        // Already being destroyed -- bail out.
        return S_OK;
    }

    _fInDestroy = TRUE;

    if (_cRefUIActivateSV)
    {
        TraceMsg(TF_WARNING, 
            "CBB(%x)::OnDestroy _cRefUIActivateSV(%d)!=0", 
            this, _cRefUIActivateSV);

        // I need to defer my self-destruction.
        //
        _fDeferredSelfDestruction = TRUE;
        return S_OK;
    }

    _CancelPendingView();
    _pbsOuter->ReleaseShellView();
    
#ifdef DEBUG
    // It is valid for _cRefCannotNavigate > 0 if we the system is shutting down. The reason
    // for this is that we can still be processing a call to ::CreateNewShellView() when we
    // the desktop recieves the WM_ENDSESSION and destroys us. In this case its ok to proceed
    // with the destroy in this case, since we are logging off or rebooting anyway.
    AssertMsg(_fMightBeShuttingDown || (S_FALSE == _DisableModeless()),
              TEXT("CBB::OnDestroy _cRefCannotNavigate!=0 (%d)"),
              _cRefCannotNavigate);
#endif

    ATOMICRELEASE(_bbd._ptl);

    // This should always be successful because the IDropTarget is registered 
    // in _OnCreate() and is the default one.
    // _pdtView should have already been released in ReleaseShellView
    ASSERT(_pdtView == NULL);

    _UnregisterAsDropTarget();
    //
    //  It is very important to call _bbd._pauto->SetOwner(NULL) here, which will
    // remove any reference from the automation object to us. Before doing
    // it, we always has cycled references and we never be released.
    //
    _bbd._pautoSS->SetOwner(NULL);

    _bbd._hwnd = NULL;

#ifdef DEBUG
    _fProcessed_WM_CLOSE = TRUE;
#endif
    _DLMDestroy();
    IUnknown_SetSite(_pToolbarExt, NULL); // destroy the toolbar extensions

    if (_pauto)
    {
        IWebBrowserPriv * pWBPriv;

        HRESULT hr = _pauto->QueryInterface(IID_PPV_ARG(IWebBrowserPriv, &pWBPriv));
        if (SUCCEEDED(hr))
        {
            pWBPriv->OnClose();
            pWBPriv->Release();
        }
    }

    ATOMICRELEASE(_pHTMLDocument);
    ATOMICRELEASE(_pphHistory);

    return S_OK;
}

HRESULT CBaseBrowser2::NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF)
{
    HRESULT hr = S_OK;

    LPITEMIDLIST pidlNew = (LPITEMIDLIST)pidl;

    //
    //  Need to handle going back to an outside app - zekel 7MAY97
    //  i have dumped the code that did this, so now i need to put it
    //  into the CTravelLog implementation, so that it will be done properly
    //  without us.  but it shouldnt be done here regardless.
    //

    //  Remove? - with the old Travellog code
    // special case hack for telling us to use the local history, not
    // the global history
    if (pidl && pidl != PIDL_LOCALHISTORY)
        pidlNew = ILClone(pidl);

    //
    // Fortunately the only callers of NavigateToPidl use HLNF_NAVIGATINGBACK/FORWARD
    // so that's the only mapping we need to do here.
    //
    DWORD dwSBSP = 0;
    if (grfHLNF != (DWORD)-1)
    {
        if (grfHLNF & SHHLNF_WRITENOHISTORY)
            dwSBSP |= SBSP_WRITENOHISTORY;
        if (grfHLNF & SHHLNF_NOAUTOSELECT)
            dwSBSP |= SBSP_NOAUTOSELECT;
    }
    if (grfHLNF & HLNF_NAVIGATINGBACK)
        dwSBSP = SBSP_NAVIGATEBACK;
    else if (grfHLNF & HLNF_NAVIGATINGFORWARD)
        dwSBSP = SBSP_NAVIGATEFORWARD;

    if (dwSBSP)
    {
        if (_psbOuter)
        {
            hr = _psbOuter->BrowseObject(pidlNew, dwSBSP);  // browse will do the nav here.
        }

        ILFree(pidlNew);
    }
    else
        _NavigateToPidlAsync(pidlNew, dwSBSP, FALSE);  // takes ownership of the pidl
    
    return hr;
}

// S_OK means we found at least one valid connection point
//
HRESULT GetWBConnectionPoints(IUnknown* punk, IConnectionPoint **ppcp1, IConnectionPoint **ppcp2)
{
    HRESULT           hres = E_FAIL;
    IExpDispSupport*  peds;
    CConnectionPoint* pccp1 = NULL;
    CConnectionPoint* pccp2 = NULL;
    
    if (ppcp1)
        *ppcp1 = NULL;
    if (ppcp2)
        *ppcp2 = NULL;

    if (punk && SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IExpDispSupport, &peds))))
    {
        if (ppcp1 && SUCCEEDED(peds->FindCIE4ConnectionPoint(DIID_DWebBrowserEvents,
                                                reinterpret_cast<CIE4ConnectionPoint**>(&pccp1))))
        {
            *ppcp1 = pccp1->CastToIConnectionPoint();
            hres = S_OK;
        }

        if (ppcp2 && SUCCEEDED(peds->FindCIE4ConnectionPoint(DIID_DWebBrowserEvents2,
                                                reinterpret_cast<CIE4ConnectionPoint**>(&pccp2))))
        {
            *ppcp2 = pccp2->CastToIConnectionPoint();
            hres = S_OK;
        }
            
        peds->Release();
    }

    return hres;
}

void CBaseBrowser2::_UpdateBackForwardState()
{
    if (_fTopBrowser && !_fNoTopLevelBrowser) 
    {
        IConnectionPoint *pccp1;
        IConnectionPoint *pccp2;

        if (S_OK == GetWBConnectionPoints(_bbd._pautoEDS, &pccp1, &pccp2))
        {
            HRESULT hresT;
            VARIANTARG va[2];
            DISPPARAMS dp;
            ITravelLog *ptl;

            GetTravelLog(&ptl);

            // if we've got a site or if we're trying to get to a site,
            // enable the back button
            BOOL fEnable = (ptl ? S_OK == ptl->GetTravelEntry(SAFECAST(this, IShellBrowser *), TLOG_BACK, NULL) : FALSE);
                
            VARIANT_BOOL bEnable = fEnable ? VARIANT_TRUE : VARIANT_FALSE;
            TraceMsg(TF_TRAVELLOG, "CBB::UpdateBackForward BACK = %d", fEnable);

            // We use SHPackDispParams once instead of calling DoInvokeParams multiple times...
            //
            hresT = SHPackDispParams(&dp, va, 2, VT_I4, CSC_NAVIGATEBACK, VT_BOOL, bEnable);
            ASSERT(S_OK==hresT);

            // Removed the following EnableModelessSB(FALSE) because VB5 won't run the event handler if
            // we're modal.
            // _psbOuter->EnableModelessSB(FALSE);

            IConnectionPoint_SimpleInvoke(pccp1, DISPID_COMMANDSTATECHANGE, &dp);
            IConnectionPoint_SimpleInvoke(pccp2, DISPID_COMMANDSTATECHANGE, &dp);

            fEnable = (ptl ? S_OK == ptl->GetTravelEntry(SAFECAST(this, IShellBrowser *), TLOG_FORE, NULL) : FALSE);
            bEnable = fEnable ? VARIANT_TRUE : VARIANT_FALSE;
            TraceMsg(TF_TRAVELLOG, "CBB::UpdateBackForward FORE = %d", fEnable);

            ATOMICRELEASE(ptl);
            // We know how SHPackDispParams fills in va[]
            ASSERT(VT_BOOL == va[0].vt);
            va[0].boolVal = bEnable;
            ASSERT(VT_I4 == va[1].vt);
            va[1].lVal = CSC_NAVIGATEFORWARD;

            IConnectionPoint_SimpleInvoke(pccp1, DISPID_COMMANDSTATECHANGE, &dp);
            IConnectionPoint_SimpleInvoke(pccp2, DISPID_COMMANDSTATECHANGE, &dp);
            ATOMICRELEASE(pccp1);
            ATOMICRELEASE(pccp2);

            // Removed the following _psbOuter->EnableModelessSB(TRUE) because VB5 won't run the event handler if
            // we're modal.
            // _psbOuter->EnableModelessSB(TRUE);
        }
    }
}

void CBaseBrowser2::_NotifyCommandStateChange()
{
    HRESULT hr;

    // I'm only firing these in the toplevel case
    // Why? Who cares about the frameset case
    // since nobody listens to these events on
    // the frameset.
    //
    if (_fTopBrowser && !_fNoTopLevelBrowser) 
    {
        IConnectionPoint * pccp1;
        IConnectionPoint * pccp2;

        if (S_OK == GetWBConnectionPoints(_bbd._pautoEDS, &pccp1, &pccp2))
        {
            ASSERT(pccp1 || pccp2); // Should've gotten at least one

            VARIANTARG args[2];
            DISPPARAMS dp;

            hr = SHPackDispParams(&dp, args, 2,
                                  VT_I4,   CSC_UPDATECOMMANDS,
                                  VT_BOOL, FALSE);

            IConnectionPoint_SimpleInvoke(pccp1, DISPID_COMMANDSTATECHANGE, &dp);
            IConnectionPoint_SimpleInvoke(pccp2, DISPID_COMMANDSTATECHANGE, &dp);

            ATOMICRELEASE(pccp1);
            ATOMICRELEASE(pccp2);
        }
    }
}


LRESULT CBaseBrowser2::OnCommand(WPARAM wParam, LPARAM lParam)
{
    UINT idCmd = GET_WM_COMMAND_ID(wParam, lParam);
    HWND hwndControl = GET_WM_COMMAND_HWND(wParam, lParam);
    if (IsInRange(idCmd, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST))
    {
        if (_bbd._hwndView)
            SendMessage(_bbd._hwndView, WM_COMMAND, wParam, lParam);
        else
            TraceMsg(0, "view cmd id with NULL view");

        /// REVIEW - how can we get FCIDM_FAVORITECMD... range if we're NOT toplevelapp?
        /// REVIEW - should RecentOnCommand be done this way too?
    }
    
    return S_OK;
}


LRESULT CBaseBrowser2::OnNotify(LPNMHDR pnm)
{
    // the id is from the view, probably one of the toolbar items

    if (IsInRange(pnm->idFrom, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST))
    {
        if (_bbd._hwndView)
            SendMessage(_bbd._hwndView, WM_NOTIFY, pnm->idFrom, (LPARAM)pnm);
    }
    return 0;
}

HRESULT CBaseBrowser2::OnSetFocus()
{
    if (_bbd._hwndView) 
    {
        SetFocus(_bbd._hwndView);
    } 
    return 0;
}


#define ABOUT_HOME L"about:home"
// This function is VERY focused on achieving what the
// caller wants.  That's why it has a very specific
// meaning to the return value.
BOOL IsAboutHomeOrNonAboutURL(LPITEMIDLIST pidl)
{
    BOOL fIsAboutHomeOrNonAboutURL = TRUE;
    WCHAR wzCur[MAX_URL_STRING];

    if (pidl && SUCCEEDED(IEGetDisplayName(pidl, wzCur, SHGDN_FORPARSING)))
    {        
        // Is it "about:home"?
        if (0 != StrCmpNICW(ABOUT_HOME, wzCur, ARRAYSIZE(ABOUT_HOME) - 1))
        {
            // No.  We also want to return TRUE if the scheme was NOT an ABOUT URL.
            fIsAboutHomeOrNonAboutURL = (URL_SCHEME_ABOUT != GetUrlSchemeW(wzCur));
        }
    }

    return fIsAboutHomeOrNonAboutURL;            
}

//
// This function activate the pending view synchronously.
//
HRESULT CBaseBrowser2::ActivatePendingView(void)
{
    HRESULT hres = E_FAIL;
    BOOL bHadFocus;

    TraceMsg(TF_SHDNAVIGATE, "CBB::ActivatePendingView called");

    if (!_bbd._psvPending || !_bbd._psfPending)
    {
#ifdef DEBUG
        // it is valid for these to be null if we are shutting down b/c the desktop
        // could have destroyed us, which would have called ::OnDestroy which calls _CancelPendingView
        // which releases and nulls out _bbd._psvPending and _bbd._psfPending
        ASSERT(_fMightBeShuttingDown);
#endif
        goto Done;
    }

#ifndef NON_NATIVE_FRAMES

    IUnknown_Exec(_bbd._psvPending, &CGID_ShellDocView, SHDVID_COMPLETEDOCHOSTPASSING, 0, NULL, NULL);

#endif

#ifdef FEATURE_PICS
    if (S_FALSE == IUnknown_Exec(_bbd._psvPending, &CGID_ShellDocView, SHDVID_CANACTIVATENOW, NULL, NULL, NULL))
    {
        hres = S_OK;    // still waiting . . . but no failure.
        goto DoneWait;
    }
#endif
    
    //  if we are in modal loop, don't activate now
    if (_cRefCannotNavigate > 0)
    {
        goto Done;
    }

    // if _cRefCannotNavigate > 0 it is possible that _hwndViewPending has not been created so this assert 
    // should go after the check above
    ASSERT(_bbd._hwndViewPending);
    
    //  if shell view supports it, give it a chance to tell us it's not ready
    //  to deactivate [eg executing a script]
    //
    OLECMD rgCmd;
    rgCmd.cmdID = SHDVID_CANDEACTIVATENOW;
    rgCmd.cmdf = 0;
    if (_bbd._pctView &&
        SUCCEEDED(_bbd._pctView->QueryStatus(&CGID_ShellDocView, 1, &rgCmd, NULL)) &&
        (rgCmd.cmdf & MSOCMDF_SUPPORTED) &&
        !(rgCmd.cmdf & MSOCMDF_ENABLED)) 
    {
        //
        //  The DocObject that reported MSOCMDF_SUPPORTED must send
        //  SHDVID_DEACTIVATEMENOW when we're out of scripts or whatever so that
        //  we retry the activate
        //
        TraceMsg(DM_WARNING, "CBB::ActivatePendingView DocObject says I can't deactivate it now");
        goto Done;
    }

    ASSERT(_bbd._psvPending);

    // Prevent any navigation while we have the pointers swapped and we're in
    // delicate state
    _psbOuter->EnableModelessSB(FALSE);

    //
    // Don't play sound for the first navigation (to avoid multiple
    // sounds to be played for a frame-set creation).
    //
    if (_bbd._psv && IsWindowVisible(_bbd._hwnd) && !(_dwSBSPQueued & SBSP_WRITENOHISTORY)) 
    {
        IEPlaySound(TEXT("ActivatingDocument"), FALSE);
    }

    ASSERT(_bbd._psvPending);

    //  NOTE: if there are any other protocols that need to not be in 
    //  the travel log, it should probably implemented through UrlIs(URLIS_NOTRAVELLOG)
    //  right now, About: is the only one we care about
    //
    // Note that with the native frames changes, if we don't have
    // a psv, we will want to call _UpdateTravelLog because that is
    // where the first travel entry is added.
    //
    if (!(_grfHLNFPending & HLNF_CREATENOHISTORY) && 
        (!_bbd._psv || IsAboutHomeOrNonAboutURL(_bbd._pidlCur))
        && !_fDontUpdateTravelLog)
    {
        DEBUG_CODE(TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];)
        DEBUG_CODE(IEGetDisplayName(_bbd._pidlCur, szPath, SHGDN_FORPARSING);)
        DEBUG_CODE(TraceMsg(DM_TRACE, "CBB::ActivatePendingView (TRAVELLOG): _UpdateTravelLog called from shdocvw for %ws", szPath);)

        _UpdateTravelLog();
    }

    //  WARNING - these will only fail if the UpdateTravelLog() - zekel - 7-AUG-97
    //  was skipped and these bits are set.

    //  alanau 5-may-98 -- I still hit this assert on a script-based navigate to the same page.
    //      iedisp.cpp sees StrCmpW("about:blank","about:blank?http://www.microsoft.com/ie/ie40/gallery/_main.htm") 
    //      (for example), but basesb.cpp sees two equal pidls (both "about:blank?http://...").
    //      Killing this assert.
    // ASSERT(!_fDontAddTravelEntry);
    //
    //  scotrobe 11-Aug-99 If the hosted document is able to
    //  navigate itself, _UpdateTravelLog() will never be called.
    //
    ASSERT((_dwDocFlags & DOCFLAG_DOCCANNAVIGATE) || !_fIsLocalAnchor);

    // before we destroy the window check if it or any of its childern has focus
    bHadFocus =     _bbd._hwndView && (IsChildOrSelf(_bbd._hwndView, GetFocus()) == S_OK)
                ||  _bbd._hwndViewPending && (IsChildOrSelf(_bbd._hwndViewPending, GetFocus()) == S_OK);

    _pbsOuter->_SwitchActivationNow();

    _psbOuter->EnableModelessSB(TRUE);

    TraceMsg(DM_NAV, "CBaseBrowser2(%x)::ActivatePendingView(%x)", this, _bbd._psv);

    // if some other app has focus, then don't uiactivate this navigate
    // or we'll steal focus away. we'll uiactivate when we next get activated
    //
    // ie4.01, bug#64630 and 64329
    // _fActive only gets set by WM_ACTIVATE on the TopBrowser.  so for subframes
    // we always defer setting the focus if they didnt have focus before navigation.
    // the parent frame should set the subframe as necessary when it gets 
    //  its UIActivate.   - ReljaI 4-NOV-97
    if (SVUIA_ACTIVATE_FOCUS == _bbd._uActivateState && !(_fActive || bHadFocus))
    {
        _bbd._uActivateState = SVUIA_INPLACEACTIVATE;
        _fUIActivateOnActive = TRUE;
    }
    
    _UIActivateView(_bbd._uActivateState);

    // Tell the shell's HTML window we have a new document.
    if (_phtmlWS)
    {
        _phtmlWS->ViewActivated();
    }

    // this matches the _bbd._psvPending = NULL above.
    // we don't put this right beside there because the
    // _SwitchActivationNow could take some time, as well as the DoInvokePidl

    SetNavigateState(BNS_NORMAL);

    _pbsOuter->UpdateBackForwardState();
    _NotifyCommandStateChange();

    if (!_fNoDragDrop && _fTopBrowser)
    {
        ASSERT(_bbd._psv);
        // _SwitchActivationNow should have already released the old _pdtView and set it to NULL
        ASSERT(_pdtView == NULL);
        _bbd._psv->QueryInterface(IID_PPV_ARG(IDropTarget, &_pdtView));
    }

    // The pending view may have a title change stored up, so fire the TitleChange.
    // Also the pending view may not tell us about title changes, so simulate one.
    //
    if (_bbd._pszTitleCur)
    {
        if (_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)
        {
            VARIANTARG  varTitle;
            HRESULT     hrExec;

            V_VT(&varTitle) = VT_BSTR;
            V_BSTR(&varTitle) = SysAllocString(_bbd._pszTitleCur);

            ASSERT(V_BSTR(&varTitle));

            hrExec = IUnknown_Exec( _psbOuter, NULL, OLECMDID_SETTITLE, NULL, &varTitle, NULL);

            VariantClear(&varTitle);
        }
        else
        {
            FireEvent_DoInvokeStringW(_bbd._pautoEDS, DISPID_TITLECHANGE, _bbd._pszTitleCur);
        }
    }
    else if (_bbd._pidlCur)
    {
        WCHAR wzFullName[MAX_URL_STRING];

        hres = ::IEGetNameAndFlags(_bbd._pidlCur, SHGDN_NORMAL, wzFullName, SIZECHARS(wzFullName), NULL);
        if (SUCCEEDED(hres))
            FireEvent_DoInvokeStringW(_bbd._pautoEDS, DISPID_TITLECHANGE, wzFullName);
    }

    // We must fire this event LAST because the app can shut us down
    // in response to this event.
    //

    //
    // MSWorks printing bug 104242 - Do NOT fire the NC2 event when the state is 
    // interactive. doing this will cause WorksCalender to print a partial document.
    // Instead, we have the SetReadyState explicitly directly call FireEvent_NaviagateComplete
    // and so the event will fire once the whole document has been parsed in.  This
    // code is matched by a bunch of event blockers in formkrnl.cxx
    //
    if ( GetModuleHandle(TEXT("WKSCAL.EXE")))
    {
        LBSTR::CString strPath;

        LPTSTR pstrPath = strPath.GetBuffer( MAX_URL_STRING );

        if ( strPath.GetAllocLength() < MAX_URL_STRING )
        {
            TraceMsg( TF_WARNING, "CBaseBrowser2::ActivatePendingView() - strPath Allocation Failed!" );

            hres = E_OUTOFMEMORY;
        }
        else
        {
            hres = IEGetDisplayName( _bbd._pidlCur, pstrPath, SHGDN_FORPARSING );

            // Let CString class own the buffer again.
            strPath.ReleaseBuffer();
        }

        if ( FAILED(hres) )
        {
            strPath.Empty();
        }

        if (   GetUrlSchemeW( strPath ) == URL_SCHEME_ABOUT
            || GetUrlSchemeW( strPath ) == URL_SCHEME_FILE
            || GetUrlSchemeW( strPath ) == URL_SCHEME_INVALID
           )
        {
            goto Done;
        }
    }

    // fire the event!
    FireEvent_NavigateComplete(_bbd._pautoEDS, _bbd._pautoWB2, _bbd._pidlCur, _bbd._hwnd);

    // Sync up the lock icon state with CDocObjectHost
    
    if (S_OK != IUnknown_Exec(_bbd._psv, &CGID_ShellDocView, SHDVID_FORWARDSECURELOCK, NULL, NULL, NULL))
    {      
        // No CDocObjectHost, so we're not secure
        CComVariant varLock((long) SECURELOCK_SET_UNSECURE);
        
        if (!IsTopFrameBrowser(SAFECAST(this, IServiceProvider *), SAFECAST(this, IShellBrowser *)))
        {
            // we should suggest if we are not the top frame
            IOleCommandTarget *pct;

            if (SUCCEEDED(QueryService(SID_STopFrameBrowser, IID_PPV_ARG(IOleCommandTarget, &pct))))
            {
                varLock.lVal += SECURELOCK_FIRSTSUGGEST;       
                pct->Exec(&CGID_Explorer, SBCMDID_SETSECURELOCKICON, 0, &varLock, NULL);
                pct->Release();
            }
        }       
        else
        {
            Exec(&CGID_Explorer, SBCMDID_SETSECURELOCKICON, 0, &varLock, NULL);
        }
    }

    hres = S_OK;

Done:
    OnReadyStateChange(NULL, READYSTATE_COMPLETE);
DoneWait:
    return hres;
}

LRESULT CBaseBrowser2::_DefWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    //
    // call the UNICODE/ANSI aware DefWindowProc
    //
    return ::SHDefWindowProc(hwnd, uMsg, wParam, lParam);
}


void CBaseBrowser2::_ViewChange(DWORD dwAspect, LONG lindex)
{
    //
    // we are interested in content changes only
    //

    // NOTE: if we are registed for separate palette commands, then do not invalidate the colours here...
    if (dwAspect & DVASPECT_CONTENT && !_fUsesPaletteCommands )
    {
        //
        // recompute our palette
        //
        _ColorsDirty(BPT_UnknownPalette);
    }
    else
    {
        TraceMsg(DM_PALETTE, "cbb::_vc not interested in aspect(s) %08X", dwAspect);
    }
}

void CBaseBrowser2::_ColorsDirty(BrowserPaletteType bptNew)
{
    //
    // if we are not currently handling palette messages then get out
    //
    if (_bptBrowser == BPT_DeferPaletteSupport)
    {
        TraceMsg(DM_PALETTE, "cbb::_cd deferring palette support");
        return;
    }

    //
    // we only handle palette changes and display changes
    //
    if ((bptNew != BPT_UnknownPalette) && (bptNew != BPT_UnknownDisplay))
    {
        AssertMsg(FALSE, TEXT("CBaseBrowser2::_ColorsDirty: invalid BPT_ constant"));
        bptNew = BPT_UnknownPalette;
    }

    //
    // if we aren't on a palettized display we don't care about palette changes
    //
    if ((bptNew != BPT_UnknownDisplay) && (_bptBrowser == BPT_NotPalettized))
    {
        TraceMsg(DM_PALETTE, "cbb::_cd not on palettized display");
        return;
    }

    //
    // if we are already handling one of these then we're done
    //
    if ((_bptBrowser == BPT_PaletteViewChanged) ||
        (_bptBrowser == BPT_DisplayViewChanged))
    {
        TraceMsg(DM_PALETTE, "cbb::_cd coalesced");
        return;
    }

    //
    // unknown display implies unknown palette when the display is palettized
    //
    if (_bptBrowser == BPT_UnknownDisplay)
        bptNew = BPT_UnknownDisplay;

    //
    // post ourselves a WM_QUERYNEWPALETTE so we can pile up multiple advises
    // and handle them at once (we can see a lot of them sometimes...)
    // NOTE: the lParam is -1 so we can tell that WE posted it and that
    // NOTE: it doesn't necessarily mean we onw the foreground palette...
    //
    if (PostMessage(_bbd._hwnd, WM_QUERYNEWPALETTE, 0, (LPARAM) -1))
    {
        TraceMsg(DM_PALETTE, "cbb::_cd queued update");

        //
        // remember that we have already posted a WM_QUERYNEWPALETTE
        //
        _bptBrowser = (bptNew == BPT_UnknownPalette)?
            BPT_PaletteViewChanged : BPT_DisplayViewChanged;
    }
    else
    {
        TraceMsg(DM_PALETTE, "cbb::_cd FAILED!");

        //
        // at least remember that the palette is stale
        //
        _bptBrowser = bptNew;
    }
}

void CBaseBrowser2::v_PropagateMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL fSend)
{
    if (_bbd._hwnd)
        PropagateMessage(_bbd._hwnd, uMsg, wParam, lParam, fSend);
}

void CBaseBrowser2::_DisplayChanged(WPARAM wParam, LPARAM lParam)
{
    //
    // forward this on to our children
    //
    v_PropagateMessage(WM_DISPLAYCHANGE, wParam, lParam, TRUE);

    //
    // and mark our colors as dirty
    //
    _ColorsDirty(BPT_UnknownDisplay);
}

// 
// return results for _UpdateBrowserPaletteInPlace()
//    S_OK : BrowserPalette was successfully updated in place
//    S_FALSE : BrowserPalette is exactly the same, no need to update
//    E_FAIL : Unable to update palette in place at all, caller needs to create new palette 
// 
HRESULT CBaseBrowser2::_UpdateBrowserPaletteInPlace(LOGPALETTE *plp)
{
    if (!_hpalBrowser)
        return E_FAIL;

    WORD w;
    if (GetObject(_hpalBrowser, sizeof(w), &w) != sizeof(w))
        return E_FAIL;

    if (w != plp->palNumEntries)
        return E_FAIL;

    if (w > 256)
        return E_FAIL;

    //
    // GDI marks a palette as dirty if you update its colors
    // only replace the entries if the colors are actually different
    // this prevents excessive flashing
    //
    PALETTEENTRY ape[256];

    if (GetPaletteEntries(_hpalBrowser, 0, w, ape) != w)
        return E_FAIL;

    if (memcmp(ape, plp->palPalEntry, w * sizeof(PALETTEENTRY)) == 0)
    {
        TraceMsg(DM_PALETTE, "cbb::_ubpip %08x already had view object's colors", _hpalBrowser);
        return S_FALSE;
    }

    // make sure we don't reuse the global halftone palette that we are reusing across shdocvw....
    // do this after we've done the colour match 
    if ( _hpalBrowser == g_hpalHalftone )
    {
        return E_FAIL;
    }
    
    //
    // actually set up the colors
    //
    if (SetPaletteEntries(_hpalBrowser, 0, plp->palNumEntries,
        plp->palPalEntry) != plp->palNumEntries)
    {
        return E_FAIL;
    }

    TraceMsg(DM_PALETTE, "cbb::_ubpip updated %08x with view object's colors", _hpalBrowser);
    return S_OK;
}

void CBaseBrowser2::_RealizeBrowserPalette(BOOL fBackground)
{
    HPALETTE hpalRealize;

    //
    // get a palette to realize
    //
    if (_hpalBrowser)
    {
        TraceMsg(DM_PALETTE, "cbb::_rbp realizing %08x", _hpalBrowser);
        hpalRealize = _hpalBrowser;
    }
    else
    {
        TraceMsg(DM_PALETTE, "cbb::_rbp realizing DEFAULT_PALETTE");
        hpalRealize = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
    }

    if ( !_fOwnsPalette && !fBackground )
    {
        // NOTE: if we don't think we own the foreground palette, and we
        // NOTE: are being told to realize in the foreground, then ignore
        // NOTE: it because they are wrong...
        fBackground = TRUE;
    }
    
    //
    // get a DC to realize on and select our palette
    //
    HDC hdc = GetDC(_bbd._hwnd);

    if (hdc)
    {
        HPALETTE hpalOld = SelectPalette(hdc, hpalRealize, fBackground);

        if (hpalOld)
        {
            //
            // we don't paint any palettized stuff ourselves we're just a frame
            // eg. we don't need to repaint here if the realize returns nonzero
            //
            RealizePalette(hdc);

            //
            // since we create and delete our palette alot, don't leave it selected
            //
            SelectPalette(hdc, hpalOld, TRUE);
        }
        ReleaseDC(_bbd._hwnd, hdc);
    }
}

void CBaseBrowser2::_PaletteChanged(WPARAM wParam, LPARAM lParam)
{
    TraceMsg(DM_PALETTE, "cbb::_pc (%08X, %08X, %08X) begins -----------------------", this, wParam, lParam);

    //
    // cdturner: 08/03/97
    // we think that we currently own the foregorund palette, we need to make sure that 
    // the window that just realized in the foreground (and thus caused the system
    // to generate the WM_PALETTECHANGED) was us, otherwise, we no longer own the 
    // palette 
    // 
    if ( _fOwnsPalette )
    {
        // by default we do not own it.
        _fOwnsPalette = FALSE;
        
        // the wParam hwnd we get is the top-level window that cause it, so we need to walk the window
        // chain to find out if it is one of our parents...
        // start at _bbd._hwnd (incase we are the top-level :-))
        HWND hwndParent = _bbd._hwnd;
        while ( hwndParent != NULL )
        {
            if ( hwndParent == (HWND) wParam )
            {
                // we caused it, so therefore we must still own it...
                _fOwnsPalette = TRUE;
                break;
            }
            hwndParent = GetParent( hwndParent );
        }
    }
    
    //
    // should we realize now? (see _QueryNewPalette to understand _bptBrowser)
    //
    // NOTE: we realize in the background here on purpose!  This helps us be
    // compatible with Netscape plugins etc that think they can own the
    // palette from inside the browser.
    //
    if (((HWND)wParam != _bbd._hwnd) && (_bptBrowser == BPT_Normal))
        _RealizeBrowserPalette(TRUE);

    //
    // always forward the changes to the current view
    // let the toolbars know too
    //
    if (_bbd._hwndView)
        TraceMsg(DM_PALETTE, "cbb::_pc forwarding to view window %08x", _bbd._hwndView);
    _pbsOuter->_SendChildren(_bbd._hwndView, TRUE, WM_PALETTECHANGED, wParam, lParam);  // SendMessage

    TraceMsg(DM_PALETTE, "cbb::_pc (%08X) ends -------------------------", this);
}

BOOL CBaseBrowser2::_QueryNewPalette()
{
    BrowserPaletteType bptNew;
    HPALETTE hpalNew = NULL;
    BOOL fResult = TRUE;
    BOOL fSkipRealize = FALSE;
    HDC hdc;

    TraceMsg(DM_PALETTE, "cbb::_qnp (%08X) begins ==================================", this);

TryAgain:
    switch (_bptBrowser)
    {
    case BPT_Normal:
        TraceMsg(DM_PALETTE, "cbb::_qnp - normal realization");
        //
        // Normal Realization: realize _hpalBrowser in the foreground
        //

        // avoid realzing the palette into the display if we've been asked not to...
        if ( !fSkipRealize )
            _RealizeBrowserPalette(FALSE);
        break;

    case BPT_ShellView:
        TraceMsg(DM_PALETTE, "cbb::_qnp - forwarding to shell view");
        //
        // Win95 Explorer-compatible: forward the query to the shell view
        //
        if (_bbd._hwndView && SendMessage(_bbd._hwndView, WM_QUERYNEWPALETTE, 0, 0))
            break;

        TraceMsg(DM_PALETTE, "cbb::_qnp - no shell view or view didn't answer");

        //
        // we only manage our palette as a toplevel app
        //

        //
        // the view didn't handle it; fall through to use a generic palette
        //
    UseGenericPalette:
        TraceMsg(DM_PALETTE, "cbb::_qnp - using generic palette");
        //
        // Use a Halftone Palette for the device
        //
        hpalNew = g_hpalHalftone;
        bptNew = BPT_Normal;
        goto UseThisPalette;

    case BPT_UnknownPalette:
    case BPT_PaletteViewChanged:
        TraceMsg(DM_PALETTE, "cbb::_qnp - computing palette");
        //
        // Undecided: try to use IViewObject::GetColorSet to compose a palette
        //
        LOGPALETTE *plp;
        HRESULT hres;

        // default to forwarding to the view if something fails along the way
        hpalNew = NULL;
        bptNew = BPT_ShellView;

        //
        // if we have a view object then try to get its color set
        //
        if (!_pvo)
        {
            TraceMsg(DM_PALETTE, "cbb::_qnp - no view object");
            goto UseGenericPalette;
        }

        plp = NULL;
        hres = _pvo->GetColorSet(DVASPECT_CONTENT, -1, NULL, NULL, NULL, &plp);

        if (FAILED(hres))
        {
            TraceMsg(DM_PALETTE, "cbb::_qnp - view object's GetColorSet failed");
            goto UseThisPalette;
        }

        //
        // either a null color set or S_FALSE mean the view object doesn't care
        //
        if (!plp)
            hres = S_FALSE;

        if (hres != S_FALSE)
        {
            //
            // can we reuse the current palette object?
            //
            HRESULT hrLocal = _UpdateBrowserPaletteInPlace(plp);
            if (FAILED( hrLocal ))
            {
                TraceMsg(DM_PALETTE, "cbb::_qnp - creating new palette for view object's colors");
                hpalNew = CreatePalette(plp);
            }
            else
            {
                hpalNew = _hpalBrowser;

                // NOTE: if we got back the same palette, don't bother realizing it into the foreground.
                // NOTE: this has the (desirable) side effect of stops us flashing the display when a
                // NOTE: control on a page has (wrongly) realized its own palette...
                if ( hrLocal == S_FALSE )
                {
                    // ASSERT( GetActiveWindow() == _bbd._hwnd );
                    fSkipRealize = TRUE;
                }
            }

            //
            // did we succeed at setting up a palette?
            //
            if (hpalNew)
            {
                TraceMsg(DM_PALETTE, "cbb::_qnp - palette is ready to use");
                bptNew = BPT_Normal;
            }
            else
            {
                TraceMsg(DM_PALETTE, "cbb::_qnp - failed to create palette");
            }
        }

        //
        // free the logical palette from the GetColorSet above
        //
        if (plp)
            CoTaskMemFree(plp);

        //
        // if the view object responded that it didn't care then pick a palette
        //
        if (hres == S_FALSE)
        {
            TraceMsg(DM_PALETTE, "cbb::_qnp - view object doesn't care");
            goto UseGenericPalette;
        }

        //
        // fall through to use the palette we decided on
        //
    UseThisPalette:
        //
        // we get here when we've decided on a new palette strategy
        //
        TraceMsg(DM_PALETTE, "cbb::_qnp - chose palette %08x", hpalNew);
        //
        // do we have a new palette object to use?
        //
        if (hpalNew != _hpalBrowser)
        {
            if (_hpalBrowser && _hpalBrowser != g_hpalHalftone)
            {
                TraceMsg(DM_PALETTE, "cbb::_qnp - deleting old palette %08x", _hpalBrowser);
                DeletePalette(_hpalBrowser);
            }
            _hpalBrowser = hpalNew;
        }
        
        //
        // notify the hosted object that we just changed the palette......
        //
        if ( _bbd._pctView )
        {
            VARIANTARG varIn = {0};
            varIn.vt = VT_I4;
            varIn.intVal = DISPID_AMBIENT_PALETTE;
            
            _bbd._pctView->Exec( &CGID_ShellDocView, SHDVID_AMBIENTPROPCHANGE, 0, &varIn, NULL );
        }

        //
        // now loop back and use this new palette strategy
        //
        _bptBrowser = bptNew;
        goto TryAgain;

    case BPT_UnknownDisplay:
    case BPT_DisplayViewChanged:
    case BPT_DeferPaletteSupport:
        TraceMsg(DM_PALETTE, "cbb::_qnp - unknown display");
        //
        // Unknown Display: decide whether we need palette support or not
        //
        hdc = GetDC(NULL);

        if (hdc)
        {
            bptNew = (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)?
                BPT_UnknownPalette : BPT_NotPalettized;
            ReleaseDC(NULL, hdc);
        }

        //
        // Set the new mode and branch accordingly
        // NOTE: we don't do a UseThisPalette here because it is still unknown
        //
        if (hdc && (_bptBrowser = bptNew) == BPT_UnknownPalette)
            goto TryAgain;

        TraceMsg(DM_PALETTE, "cbb::_qnp - not in palettized display mode");

        //
        // fall through to non-palette case
        //
    case BPT_NotPalettized:
        //
        // Not in Palettized Mode: do nothing
        //
        // if we just switched from a palettized mode then free our palette
        //
        if (_hpalBrowser)
        {
            TraceMsg(DM_PALETTE, "cbb::_qnp - old palette still lying around");
            hpalNew = NULL;
            bptNew = BPT_NotPalettized;
            goto UseThisPalette;
        }

        //
        // and don't do anything else
        //
        fResult = FALSE;
        break;

    default:
        TraceMsg(DM_PALETTE, "cbb::_qnp - invalid BPT_ state!");
        //
        // we should never get here
        //
        ASSERT(FALSE);
        _bptBrowser = BPT_UnknownDisplay;
        goto TryAgain;
    }

    TraceMsg(DM_PALETTE, "cbb::_qnp (%08X) ends ====================================", this);

    return fResult;
}


HRESULT CBaseBrowser2::_TryShell2Rename(IShellView* psv, LPCITEMIDLIST pidlNew)
{
    HRESULT hres = E_FAIL;

    if (EVAL(psv))  // Winstone once found it to be NULL.
    {
        // ? -  overloading the semantics of IShellExtInit
        IPersistFolder* ppf;
        hres = psv->QueryInterface(IID_PPV_ARG(IPersistFolder, &ppf));
        if (SUCCEEDED(hres)) 
        {
            hres = ppf->Initialize(pidlNew);
            if (SUCCEEDED(hres)) 
            {
                // we need to update what we're pointing to
                LPITEMIDLIST pidl = ILClone(pidlNew);
                if (pidl) 
                {
                    if (IsSameObject(psv, _bbd._psv)) 
                    {
                        ASSERT(_bbd._pidlCur);
                        ILFree(_bbd._pidlCur);
                        _bbd._pidlCur = pidl;

                        // If the current pidl is renamed, we need to fire a
                        // TITLECHANGE event. We don't need to do this in the
                        // pending case because the NavigateComplete provides
                        // a way to get the title.
                        //
                        WCHAR wzFullName[MAX_URL_STRING];

                        ::IEGetNameAndFlags(_bbd._pidlCur, SHGDN_NORMAL, wzFullName, SIZECHARS(wzFullName), NULL);
            
                        FireEvent_DoInvokeStringW(_bbd._pautoEDS, DISPID_TITLECHANGE, wzFullName);
                    } 
                    else if (IsSameObject(psv, _bbd._psvPending)) 
                    {
                        ASSERT(_bbd._pidlPending);
                        ILFree(_bbd._pidlPending);
                        _bbd._pidlPending = pidl;
                    } 
                    else 
                    {
                        // It may be possible to get here during _MayPlayTransition!
                        //
                        ASSERT(!_bbd._psvPending); // this should be the case if we get here
                        ASSERT(FALSE); // we should never get here or we have a problem
                    }
                }
            }
            ppf->Release();
        }
    }

    return hres;
}

HRESULT CBaseBrowser2::OnSize(WPARAM wParam)
{
    if (wParam != SIZE_MINIMIZED) 
    {
        _pbsOuter->v_ShowHideChildWindows(FALSE);
    }
    
    return S_OK;
}

BOOL CBaseBrowser2::v_OnSetCursor(LPARAM lParam)
{
    if (_fNavigate || _fDescendentNavigate) 
    {
        switch (LOWORD(lParam)) 
        {
        case HTBOTTOM:
        case HTTOP:
        case HTLEFT:
        case HTRIGHT:
        case HTBOTTOMLEFT:
        case HTBOTTOMRIGHT:
        case HTTOPLEFT:
        case HTTOPRIGHT:
            break;

        default:
            SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
            return TRUE;
        }
    }
    else
    {
        if (GetTickCount() < _dwStartingAppTick + STARTING_APP_DURATION)
        {
            SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
            return TRUE;
        }
    }

    return FALSE;
}

const SA_BSTRGUID s_sstrSearchFlags = {
    38 * SIZEOF(WCHAR),
    L"{265b75c1-4158-11d0-90f6-00c04fd497ea}"
};

#define PROPERTY_VALUE_SEARCHFLAGS ((BSTR)s_sstrSearchFlags.wsz)

LRESULT CBaseBrowser2::_OnGoto(void)
{
    TraceMsg(TF_SHDNAVIGATE, "CBB::_OnGoto called");

    //
    //  If we can't navigate right now, postpone it by restoring _uAction
    // and don't free pidlQueued. Subsequent _MayUnblockAsyncOperation call
    // will post WMC_ASYNCOPERATION (if we can navigate) and we come here
    // again.
    //
    if (!_CanNavigate()) 
    {
        TraceMsg(TF_SHDNAVIGATE, "CBB::_OnGoto can't do it now. Postpone!");
        _uActionQueued = ASYNCOP_GOTO;
        return S_FALSE;
    }

    LPITEMIDLIST pidl = _pidlQueued;
    DWORD dwSBSP = _dwSBSPQueued;
    _dwSBSPQueued = 0;

    _pidlQueued = NULL;

    if (pidl && PIDL_NOTHING != pidl) 
    {
        DWORD grfHLNF = 0;
        
        if (dwSBSP & SBSP_WRITENOHISTORY)
        {
            grfHLNF |= SHHLNF_WRITENOHISTORY;
        }
        if (dwSBSP & SBSP_NOAUTOSELECT)
        {
            grfHLNF |= SHHLNF_NOAUTOSELECT;
        }

        if (PIDL_LOCALHISTORY == pidl)
        {
            pidl = NULL;

            // For beta2 we need to do a better job mapping SBSP to HLNF values.
            // For beta1, this is the only case that's busted.
            //
            // This problem stems from converting _NavigateToPidl in ::NavigateToPidl
            // into a call to the Async version
            //
            if (dwSBSP & SBSP_NAVIGATEBACK)
                grfHLNF = HLNF_NAVIGATINGBACK;
            else if (dwSBSP & SBSP_NAVIGATEFORWARD)
                grfHLNF = HLNF_NAVIGATINGFORWARD;
        }
        else if (dwSBSP == (DWORD)-1)
        {
            // Same problem as above
            //
            // This problem stems from converting _NavigateToPidl in ::NavigateToTLItem
            // into a call to the Async version
            //
            grfHLNF = (DWORD)-1;
        }
        else
        {
            if (dwSBSP & SBSP_REDIRECT)
                grfHLNF |= HLNF_CREATENOHISTORY;
            {
                IWebBrowser2 *pWB2; 
                BOOL bAllow = ((dwSBSP & SBSP_ALLOW_AUTONAVIGATE) ? TRUE : FALSE);
    
                if (bAllow)
                    grfHLNF |= HLNF_ALLOW_AUTONAVIGATE;
    
                if (SUCCEEDED(_pspOuter->QueryService(SID_SHlinkFrame, IID_PPV_ARG(IWebBrowser2, &pWB2)))) 
                {
                    if (pWB2) 
                    {
                        VARIANT v = {0}; // for failure of below call
                        pWB2->GetProperty(PROPERTY_VALUE_SEARCHFLAGS, &v);
                        if (v.vt == VT_I4) 
                        {
                            v.lVal &= (~ 0x00000001);   // Clear the allow flag before we try to set it.
                            v.lVal |= (bAllow ? 0x01 : 0x00);
                        } 
                        else 
                        {
                            VariantClear(&v);
                            v.vt = VT_I4;
                            v.lVal = (bAllow ? 0x01 : 0x00);
                        }
                        pWB2->PutProperty(PROPERTY_VALUE_SEARCHFLAGS, v);
                        pWB2->Release();
                    }
                }
            }
        }

        TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("_OnGoto called calling _NavigateToPidl"), pidl, _bbd._pidlCur);
        _pbsOuter->_NavigateToPidl(pidl, (DWORD)grfHLNF, dwSBSP);
    }
    else 
    {
        // wParam=NULL means canceling the navigation.
        TraceMsg(DM_NAV, "NAV::_OnGoto calling _CancelPendingView");
        _CancelPendingView();

        if (PIDL_NOTHING == pidl)
        {
            // If we're being told to navigate to nothing, go there
            //
            // What should we do with the history??
            //
            _pbsOuter->ReleaseShellView();
        }
        else if (!_bbd._pidlCur)
        {
            //
            //  If the very first navigation failed, navigate to
            // a local html file so that the user will be able
            // to View->Options dialog.
            //
            TCHAR szPath[MAX_PATH]; // This is always local
            HRESULT hresT = _GetStdLocation(szPath, ARRAYSIZE(szPath), DVIDM_GOLOCALPAGE);
            if (FAILED(hresT) || !PathFileExists(szPath)) 
            {
                StrCpyN(szPath, TEXT("shell:Desktop"), ARRAYSIZE(szPath));
            }
            BSTR bstr = SysAllocStringT(szPath);
            if (bstr) 
            {
                TraceMsg(TF_SHDNAVIGATE, "CBB::_OnGoto Calling _bbd._pauto->Navigate(%s)", szPath);
                _bbd._pautoWB2->Navigate(bstr,NULL,NULL,NULL,NULL);
                SysFreeString(bstr);
            }
        }
    }

    _FreeQueuedPidl(&pidl);

    return 0;
}

void CBaseBrowser2::_FreeQueuedPidl(LPITEMIDLIST* ppidl)
{
    if (*ppidl && PIDL_NOTHING != *ppidl) 
    {
        ILFree(*ppidl);
    }
    *ppidl = NULL;
}

HRESULT CBaseBrowser2::OnFrameWindowActivateBS(BOOL fActive)
{
    BOOL fOldActive = _fActive;
    
    if (_pact)
    {
        TraceMsg(TF_SHDUIACTIVATE, "OnFrameWindowActivateBS(%d)", fActive);
        _pact->OnFrameWindowActivate(fActive);
    }

    _fActive = fActive;
    
    if (fActive && !fOldActive && _fUIActivateOnActive)
    {
        _fUIActivateOnActive = FALSE;

        _UIActivateView(SVUIA_ACTIVATE_FOCUS);
    }

    return S_OK;
}

LRESULT CBaseBrowser2::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    if (uMsg == g_uMsgFileOpened)
    {
        AppStarted();
        return 0;
    }

    switch(uMsg)
    {
#ifdef DEBUG
    // compile time assert to make sure we don't use these msgs
    // here since we must allow these to go to the subclasses 
    case CWM_GLOBALSTATECHANGE:
    case CWM_FSNOTIFY:
    case WMC_ACTIVATE:
        break;

    case WM_QUERYENDSESSION:
        // assume we are going to be shutting down (if we aren't, we unset this during the
        // WM_ENDSESSION message)
        _fMightBeShuttingDown = TRUE;
        goto DoDefault; // act like we didn't handle this msg
        break;

    case WM_ENDSESSION:
        // the wParam tells us if the session is being ended or not
        _fMightBeShuttingDown = (BOOL)wParam;
        return 0;
        break;
#endif
        
    // UGLY: Win95/NT4 shell DefView code sends this msg and does not deal
    // with the failure case. other ISVs do the same so this needs to stay forever
    case CWM_GETISHELLBROWSER:
        return (LRESULT)_psbOuter;  // not ref counted!

    //  WM_COPYDATA is used to implement inter-window target'ed navigation
    //  Copy data contains target, URL, postdata and referring URL
    case WM_COPYDATA:
        return (LRESULT)FALSE;

    case WMC_ASYNCOPERATION:
        {
            UINT uAction = _uActionQueued;
            _uActionQueued = ASYNCOP_NIL;

            switch(uAction) 
            {
            case ASYNCOP_GOTO:
                _OnGoto();
                break;
    
            case ASYNCOP_ACTIVATEPENDING:
                VALIDATEPENDINGSTATE();
                if (_bbd._psvPending) // paranoia
                {  
                    if (FAILED(_pbsOuter->ActivatePendingView()) && _cRefCannotNavigate > 0)
                    {
                        _uActionQueued = ASYNCOP_ACTIVATEPENDING; // retry activation
                    }
                }
                break;
    
            case ASYNCOP_CANCELNAVIGATION:
                _CancelPendingNavigation();
                break;

            case ASYNCOP_NIL:
                break;

            default:
                ASSERT(0);
                break;
            }
        }
        break;

    case WMC_DELAYEDDDEEXEC:
        return IEDDE_RunDelayedExecute();
        break;
        
    case WM_SIZE:
        _pbsOuter->OnSize(wParam);
        break;

#ifdef PAINTINGOPTS
    case WM_WINDOWPOSCHANGING:
        // Let's not waste any time blitting bits around, the viewer window
        // is really the guy that has the content so when it resizes itself
        // it can decide if it needs to blt or not.  This also makes resizing
        // look nicer.
        ((LPWINDOWPOS)lParam)->flags |= SWP_NOCOPYBITS;
        goto DoDefault;
#endif

    case WM_ERASEBKGND:
        if (!_bbd._hwndView)
            goto DoDefault;

        goto DoDefault;

    case WM_SETFOCUS:
        return _pbsOuter->OnSetFocus();

    case WM_DISPLAYCHANGE:
        _DisplayChanged(wParam, lParam);
        break;

    case WM_PALETTECHANGED:
        _PaletteChanged(wParam, lParam);
        break;

    case WM_QUERYNEWPALETTE:
        // we always pass -1 as the LParam to show that we posted it to ourselves...
        if ( lParam != 0xffffffff )
        {
            // otherwise, it looks like the system or our parent has just sent a real honest to God,
            // system WM_QUERYNEWPALETTE, so we now own the Foreground palette and we have a license to
            // to SelectPalette( hpal, FALSE );
            _fOwnsPalette = TRUE;
        }
        return _QueryNewPalette();

    case WM_SYSCOLORCHANGE:
    case WM_ENTERSIZEMOVE:
    case WM_EXITSIZEMOVE:
    case WM_WININICHANGE:
    case WM_FONTCHANGE:
        v_PropagateMessage(uMsg, wParam, lParam, TRUE);
        break;

    case WM_PRINT:
        // Win95 explorer did this
        if (_bbd._hwndView)
            SendMessage(_bbd._hwndView, uMsg, wParam, lParam);
        break;

#ifdef DEBUG
    case WM_ACTIVATE:
        // do *not* do any toolbar stuff here.  it will mess up the desktop.
        // override does that in shbrows2.cpp
        TraceMsg(DM_FOCUS, "cbb.wpbs(WM_ACT): => default");
        goto DoDefault;
#endif

    case WM_SETCURSOR:
        if (v_OnSetCursor(lParam))
            return TRUE;
        goto DoDefault;

    case WM_TIMER:
        if (wParam == IDT_STARTING_APP_TIMER)
        {
            AppStarted();
            return 0;
        }
        goto DoDefault;

    case WM_CREATE:
        if (S_OK != _pbsOuter->OnCreate((LPCREATESTRUCT)lParam))
        {
            _pbsOuter->OnDestroy();
            return -1;
        }
        g_uMsgFileOpened = RegisterWindowMessage(SH_FILEOPENED);
        return 0;

    case WM_NOTIFY:
        return _pbsOuter->OnNotify((LPNMHDR)lParam);

    case WM_COMMAND:
        _pbsOuter->OnCommand(wParam, lParam);
        break;

    case WM_DESTROY:
        _pbsOuter->OnDestroy();
        break;

    case WMC_IEHARD_NAVWARNING:
        _ShowIEHardNavWarning();
        break;

    default:
        if (uMsg == g_idMsgGetAuto)
        {
            //
            //  According to LauraBu, using WM_GETOBJECT for our private
            // purpose will work, but will dramatically slow down
            // accessibility apps unless we actually implement one of
            // accessibility interfaces. Therefore, we use a registered
            // message to get the automation/frame interface out of
            // IE/Nashvile frame. (SatoNa)
            //
            IUnknown* punk;
            if (SUCCEEDED(_bbd._pautoSS->QueryInterface(*(IID*)wParam, (void **)&punk)))
                return (LRESULT)punk; // Note that it's AddRef'ed by QI.
            return 0;
        }
        else if (uMsg == GetWheelMsg()) 
        {
             // Forward the mouse wheel message on to the view window
            if (_bbd._hwndView) 
            {
                PostMessage(_bbd._hwndView, uMsg, wParam, lParam);
                return 1;
            }
            // Fall through...
        }

DoDefault:
        return _DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    return 0;
}

// *** IOleWindow methods ***
HRESULT CBaseBrowser2::GetWindow(HWND * lphwnd)
{
    *lphwnd = _bbd._hwnd;
    return S_OK;
}

HRESULT CBaseBrowser2::GetViewWindow(HWND * lphwnd)
{
    *lphwnd = _bbd._hwndView;
    return S_OK;
}

HRESULT CBaseBrowser2::ContextSensitiveHelp(BOOL fEnterMode)
{
    return E_NOTIMPL;
}

// *** IShellBrowser methods *** (same as IOleInPlaceFrame)
HRESULT CBaseBrowser2::InsertMenusSB(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
{
    return S_OK;
}

HRESULT CBaseBrowser2::SetMenuSB(HMENU hmenuShared, HOLEMENU holemenuReserved, HWND hwndActiveObject)
{
    return S_OK;
}

/*----------------------------------------------------------
Purpose: Remove menus that are shared with other menus from 
         the given browser menu.


Returns: 
Cond:    --
*/
HRESULT CBaseBrowser2::RemoveMenusSB(HMENU hmenuShared)
{
    return S_OK;
}

HRESULT CBaseBrowser2::SetStatusTextSB(LPCOLESTR lpszStatusText)
{
    // Even if we're not toplevel, send this to SendControlMsg
    // so events get notified. (Also simplifies CVOCBrowser.)
    //
    HRESULT hres;
    
    // If we are asked to put some text into the status bar, first save off what is already in pane 0
    if (lpszStatusText)
    {
        LRESULT lIsSimple = FALSE;
        
        // If we have a menu down, then we are already in simple mode. So send the 
        // text to pane 255 (simple)
        _psbOuter->SendControlMsg(FCW_STATUS, SB_ISSIMPLE, 0, 0L, &lIsSimple);
        
        if (!_fHaveOldStatusText && !lIsSimple)
        {
            WCHAR wzStatusText[MAX_URL_STRING];
            LRESULT ret;

            // TODO: Put this into a wrapper function because iedisp.cpp does something similar.
            //       Great when we convert to UNICODE
            if (SUCCEEDED(_psbOuter->SendControlMsg(FCW_STATUS, SB_GETTEXTLENGTHW, 0, 0, &ret)) &&
                LOWORD(ret) < ARRAYSIZE(wzStatusText))
            {
                // SB_GETTEXTW is not supported by the status bar control in Win95. Hence, the thunk here.
                _psbOuter->SendControlMsg(FCW_STATUS, SB_GETTEXTW, STATUS_PANE_NAVIGATION, (LPARAM)wzStatusText, NULL);
                StrCpyNW(_szwOldStatusText, wzStatusText, ARRAYSIZE(_szwOldStatusText));
                _fHaveOldStatusText = TRUE;
            }
        }   

        hres = _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTEXTW, lIsSimple ? 255 | SBT_NOBORDERS : STATUS_PANE_NAVIGATION | SBT_NOTABPARSING, (LPARAM)lpszStatusText, NULL);
    }
    else if (_fHaveOldStatusText) 
    {
        VARIANTARG var = {0};
        if (_bbd._pctView && SUCCEEDED(_bbd._pctView->Exec(&CGID_Explorer, SBCMDID_GETPANE, PANE_NAVIGATION, NULL, &var))
             && V_UI4(&var) != PANE_NONE)
        {
            hres = _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTEXTW, V_UI4(&var),(LPARAM)_szwOldStatusText, NULL);
        }
        else
        {
            hres = E_FAIL;
        }
        _fHaveOldStatusText = FALSE;
    }
    else
    {
        // No message, and no old status text, so clear what's there.
        hres = _psbOuter->SendControlMsg(FCW_STATUS, SB_SETTEXTW, STATUS_PANE_NAVIGATION | SBT_NOTABPARSING , (LPARAM)lpszStatusText, NULL);
    }
    return hres;
}

HRESULT CBaseBrowser2::EnableModelessSB(BOOL fEnable)
{
    //  We no longer call _CancelNavigation here, which causes some problems
    // when the object calls EnableModeless when we are navigating away
    // (see IE bug 4581). Instead, we either cancel or postpone asynchronous
    // event while _DisableModeless(). (SatoNa)

    //
    // If we're NOT top level, assume virtual EnableModelessSB
    // handled this request and forwarded it to us. (See CVOCBrowser.)
    //
    if (fEnable)
    {
        // Robust against random calls
        //
        // If this EVAL rips, somebody is calling EMSB(TRUE) without a
        // (preceeding) matching EMSB(FALSE).  Find and fix!
        //
        if (EVAL(_cRefCannotNavigate > 0))
        {
            _cRefCannotNavigate--;
        }

        // Tell the shell's HTML window to retry pending navigation.
        if (_cRefCannotNavigate == 0 && _phtmlWS)
        {
            _phtmlWS->CanNavigate();
        }
    }
    else
    {
        _cRefCannotNavigate++;
    }

    //
    //  If there is any blocked async operation AND we can navigate now,
    // unblock it now. 
    //
    _MayUnblockAsyncOperation();

    return S_OK;
}

HRESULT CBaseBrowser2::TranslateAcceleratorSB(LPMSG lpmsg, WORD wID)
{
    return S_FALSE;
}


//
//  This function starts the navigation to the navigation to the specified
// pidl asynchronously. It cancels the pending navigation synchronously
// if any.
//
// NOTE: This function takes ownership of the pidl -- caller does NOT free pidl!!!
//
void CBaseBrowser2::_NavigateToPidlAsync(LPITEMIDLIST pidl, DWORD dwSBSP, BOOL fDontCallCancel)
{
    BOOL fCanSend = FALSE;

    TraceMsg(TF_SHDNAVIGATE, "CBB::_NavigateToPidlAsync called");

    // _StopAsyncOperation(); 
    if (!fDontCallCancel)
        _CancelPendingNavigation(); // which calls _StopAsyncOperation too
    else 
    {
        //
        //  I'm removing this assert because _ShowBlankPage calls this funcion
        // with fDontCallCancel==TRUE -- callin _CancelPendingNavigation here
        // causes GPF in CDocHostObject::_CancelPendingNavigation. (SatoNa)
        //
        // ASSERT(_bbd._pidlPending == NULL);
    }

    ASSERT(!_pidlQueued);

    _pidlQueued   = pidl;
    _dwSBSPQueued = dwSBSP;

    // Technically a navigate must be async or we have problems such as:
    //   1> object initiating the navigate (mshtml or an object on the page
    //      or script) gets destroyed when _bbd._psv is removed and then we return
    //      from this call into the just freed object.
    //   2> object initiating the navigate gets called back by an event
    //
    // In order for Netscape OM compatibility, we must ALWAY have a _bbd._psv or
    // _bbd._psvPending, so we go SYNC when we have neither. This avoids problem
    // <1> but not problem <2>. As we find faults, we'll work around them.
    //
    // Check _fAsyncNavigate to avoid navigate when persisting the WebBrowserOC
    // This avoids faults in Word97 and MSDN's new InfoViewer -- neither like
    // being reentered by an object they are in the middle of initializing.
    //
    if (_bbd._psv || _bbd._psvPending || _fAsyncNavigate)
    {
        _PostAsyncOperation(ASYNCOP_GOTO);
    }
    else
    {
        //  if we are just starting out, we can do this synchronously and
        //  reduce the window where the IHTMLWindow2 for the frame is undefined
        fCanSend = TRUE;
    }

    // Starting a navigate means we are loading someing...
    //
    OnReadyStateChange(NULL, READYSTATE_LOADING);

    //
    // Don't play sound for the first navigation (to avoid multiple
    // sounds to be played for a frame-set creation).
    //
    if (   _bbd._psv
        && IsWindowVisible(_bbd._hwnd)
        && !(_dwSBSPQueued & SBSP_WRITENOHISTORY)
        && !(_dwDocFlags & DOCFLAG_NAVIGATEFROMDOC))
    {
        IEPlaySound(TEXT("Navigating"), FALSE);
    }

    if (fCanSend)
    {
        _SendAsyncOperation(ASYNCOP_GOTO);
    }
}

// Now that all navigation paths go through
// _NavigateToPidlAsync we probably don't need to activate async.
// Remove this code...
//
BOOL CBaseBrowser2::_ActivatePendingViewAsync(void)
{
    TraceMsg(TF_SHDNAVIGATE, "CBB::_ActivatePendingViewAsync called");

    _PreActivatePendingViewAsync();

    //
    // _bbd._psvPending is for debugging purpose.
    //
    return _PostAsyncOperation(ASYNCOP_ACTIVATEPENDING);
}


HRESULT _TryActivateOpenWindow(LPCITEMIDLIST pidl)
{
    HWND hwnd;
    IWebBrowserApp *pwb;
    HRESULT hr = WinList_FindFolderWindow(pidl, NULL, &hwnd, &pwb);
    if (S_OK == hr)
    {
        CoAllowSetForegroundWindow(pwb, NULL);
        SetForegroundWindow(hwnd);
        ShowWindow(hwnd, SW_SHOWNORMAL);
        pwb->Release();
    }

    return hr;
}


HRESULT CBaseBrowser2::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
{
    HRESULT hr;
    BOOL fNewWindow = FALSE;

    if (PIDL_NOTHING == pidl)
    {
        if (!_CanNavigate()) 
            return HRESULT_FROM_WIN32(ERROR_BUSY);

        _NavigateToPidlAsync((LPITEMIDLIST)PIDL_NOTHING, wFlags);
        return S_OK;
    }

    if (!_CanNavigate()) 
        return HRESULT_FROM_WIN32(ERROR_BUSY);

    LPITEMIDLIST pidlNew = NULL;
    int iTravel = 0;

    switch (wFlags & (SBSP_RELATIVE | SBSP_ABSOLUTE | SBSP_PARENT | SBSP_NAVIGATEBACK | SBSP_NAVIGATEFORWARD))
    {
    case SBSP_NAVIGATEBACK:
        ASSERT(pidl==NULL || pidl==PIDL_LOCALHISTORY);
        iTravel = TLOG_BACK;
        break;

    case SBSP_NAVIGATEFORWARD:
        ASSERT(pidl==NULL || pidl==PIDL_LOCALHISTORY);
        iTravel = TLOG_FORE;
        break;

    case SBSP_RELATIVE:
        if (ILIsEmpty(pidl) && (wFlags & SBSP_NEWBROWSER))
            fNewWindow = TRUE;
        else if (_bbd._pidlCur)
            pidlNew = ILCombine(_bbd._pidlCur, pidl);
        break;

    case SBSP_PARENT:
        pidlNew = ILCloneParent(_bbd._pidlCur);
        break;

    default:
        ASSERT(FALSE);
        // fall through
    case SBSP_ABSOLUTE:
        pidlNew = ILClone(pidl);
        break;
    }

    if (iTravel)
    {
        ITravelLog *ptl;
        hr = GetTravelLog(&ptl);
        if (SUCCEEDED(hr))
        {
            hr = ptl->Travel(SAFECAST(this, IShellBrowser*), iTravel);
            ptl->Release();
        }
        _pbsOuter->UpdateBackForwardState();
        return hr;
    }

    // if block is needed for multi-window open.  if we're called to open  a new
    // window, but we're in the middle of navigating, we say we're busy.
    if (wFlags & SBSP_SAMEBROWSER)
    {
        if (wFlags & (SBSP_EXPLOREMODE | SBSP_OPENMODE))
        {
            // fail this if we're already navigating
            if (!_CanNavigate() || (_uActionQueued == ASYNCOP_GOTO))
            {
                return HRESULT_FROM_WIN32(ERROR_BUSY);
            }
        }
    }
    
    if (pidlNew || fNewWindow)
    {
        if ((wFlags & (SBSP_NEWBROWSER | SBSP_SAMEBROWSER)) == SBSP_NEWBROWSER)
        {
            // SBSP_NEWBROWSER + SBSP_EXPLOREMODE
            // means never reuse windows, always create a new explorer

            if (wFlags & SBSP_EXPLOREMODE)
            {
                _OpenNewFrame(pidlNew, wFlags); // takes ownership of pidl
            }
            else
            {
                hr = _TryActivateOpenWindow(pidlNew);
                if ((S_OK == hr) || 
                    (E_PENDING == hr))    // it will come up eventually
                {
                    hr = S_OK;
                    ILFree(pidlNew);
                }
                else
                    _OpenNewFrame(pidlNew, wFlags); // takes ownership of pidl
            }
        }
        else
        {
            // NOTE: we assume SBSP_SAMEBROWSER if SBSP_NEWBROWSER is not set
            _NavigateToPidlAsync(pidlNew, wFlags /* grfSBSP */); // takes ownership of pidl
        }
        hr = S_OK;
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    return hr;
}


HRESULT CBaseBrowser2::GetControlWindow(UINT id, HWND * lphwnd)
{
    return E_FAIL;
}

HRESULT CBaseBrowser2::SendControlMsg(UINT id, UINT uMsg, WPARAM wParam,
            LPARAM lParam, LRESULT *pret)
{
    HWND hwndControl = NULL;

    if (pret)
    {
        *pret = 0;
    }

    // If this is statusbar and set text then signal event change.
    if ((id == FCW_STATUS) && (uMsg == SB_SETTEXT || uMsg == SB_SETTEXTW) && // trying to set status text
        (!(wParam & SBT_OWNERDRAW))) // we don't own the window -- this can't work
    {
        // When browser or java perf timing mode is enabled, use "Done" or "Applet Started" 
        // in the status bar to get load time.
        if(g_dwStopWatchMode && (g_dwStopWatchMode & (SPMODE_BROWSER | SPMODE_JAVA)))
        {
            StopWatch_MarkJavaStop((LPSTR)lParam, _bbd._hwnd, (uMsg == SB_SETTEXTW));
        }
        
        if (uMsg == SB_SETTEXTW)
        {
            FireEvent_DoInvokeStringW(_bbd._pautoEDS, DISPID_STATUSTEXTCHANGE, (LPWSTR)lParam);
        }
        else
        {
            FireEvent_DoInvokeString(_bbd._pautoEDS, DISPID_STATUSTEXTCHANGE, (LPSTR)lParam);
        }
    }

    HRESULT hres = _psbOuter->GetControlWindow(id, &hwndControl);
    if (SUCCEEDED(hres))
    {
        LRESULT ret = SendMessage(hwndControl, uMsg, wParam, lParam);
        if (pret)
        {
            *pret = ret;
        }
    }

    return hres;
}
 
HRESULT CBaseBrowser2::QueryActiveShellView(struct IShellView ** ppshv)
{
    IShellView * psvRet = _bbd._psv;

    if ( _fCreateViewWindowPending )
    {
        ASSERT( _bbd._psvPending );
        psvRet = _bbd._psvPending;
    }
    //
    // We have both psv and hwndView after the completion of view creation.
    //
    *ppshv = psvRet;
    if (psvRet)
    {
        psvRet->AddRef();
        return NOERROR;
    }

    return E_FAIL;
}

HRESULT CBaseBrowser2::OnViewWindowActive(struct IShellView * psv)
{
    AssertMsg((!_bbd._psv || IsSameObject(_bbd._psv, psv)),
              TEXT("CBB::OnViewWindowActive _bbd._psv(%x)!=psv(%x)"),
              psv, _bbd._psv);
    _pbsOuter->_OnFocusChange(ITB_VIEW);
    return S_OK;
}

HRESULT CBaseBrowser2::SetToolbarItems(LPTBBUTTON pViewButtons, UINT nButtons, UINT uFlags)
{
    return NOERROR;
}

//
// Notes: pidlNew will be freed
//
HRESULT CBaseBrowser2::_OpenNewFrame(LPITEMIDLIST pidlNew, UINT wFlags)
{
    UINT uFlags = COF_CREATENEWWINDOW;
    
    if (wFlags & SBSP_EXPLOREMODE) 
        uFlags |= COF_EXPLORE;
    else 
    {
        // maintain the same class if possible
        if (IsNamedWindow(_bbd._hwnd, TEXT("IEFrame")))
            uFlags |= COF_IEXPLORE;
    }

    IBrowserService *pbs;
    ITravelLog *ptlClone = NULL;
    DWORD bid = BID_TOPFRAMEBROWSER;

    if (!(wFlags & SBSP_NOTRANSFERHIST))
    {
        if (SUCCEEDED(_pspOuter->QueryService(SID_STopFrameBrowser, IID_PPV_ARG(IBrowserService, &pbs))))
        {
            ITravelLog *ptl;

            if (SUCCEEDED(pbs->GetTravelLog(&ptl)))
            {
                if (SUCCEEDED(ptl->Clone(&ptlClone)))
                {
                    ptlClone->UpdateEntry(pbs, FALSE);
                    bid = pbs->GetBrowserIndex();
                }
                ptl->Release();
            }
            pbs->Release();
        }
    }

    INotifyAppStart * pnasTop;
    HRESULT hr = _pspOuter->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(INotifyAppStart, &pnasTop));
    if (SUCCEEDED(hr))
    {
        pnasTop->AppStarting();
        pnasTop->Release();
    }

    hr = SHOpenNewFrame(pidlNew, ptlClone, bid, uFlags);
    
    if (ptlClone)
        ptlClone->Release();

    return hr;
}

//
//  This is a helper member of CBaseBroaser class (non-virtual), which
// returns the effective client area. We get this rectangle by subtracting
// the status bar area from the real client area.
//
HRESULT CBaseBrowser2::_GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon)
{
    // (derived class overrides w/ GetEffectiveClientRect for FCIDM_STATUS etc.)
    //
    // This code should only be hit in the WebBrowserOC case, but I don't
    // have a convenient assert for that... [mikesh]
    //
    ASSERT(hmon == NULL);
    GetClientRect(_bbd._hwnd, lprectBorder);
    return NOERROR;
}

HRESULT CBaseBrowser2::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
{
    TraceMsg(TF_SHDUIACTIVATE, "UIW::ReqestBorderSpace pborderwidths=%x,%x,%x,%x",
             pborderwidths->left, pborderwidths->top, pborderwidths->right, pborderwidths->bottom);
    return S_OK;
}

//
// This is an implementation of IOleInPlaceUIWindow::GetBorder.
//
//  This function returns the bounding rectangle for the active object.
// It gets the effective client area, then subtract border area taken by
// all "frame" toolbars.
//
HRESULT CBaseBrowser2::GetBorder(LPRECT lprectBorder)
{
    _pbsOuter->_GetViewBorderRect(lprectBorder);
    return S_OK;
}

//
// NOTES: We used to handle the border space negotiation in CShellBrowser
//  and block it for OC (in Beta-1 of IE4), but I've changed it so that
//  CBaseBrowser2 always handles it. It simplifies our implementation and
//  also allows a DocObject to put toolbars within the frameset, which is
//  requested by the Excel team. (SatoNa)
//
HRESULT CBaseBrowser2::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
{
    if (pborderwidths) 
    {
        TraceMsg(TF_SHDUIACTIVATE, "UIW::SetBorderSpace pborderwidths=%x,%x,%x,%x",
                 pborderwidths->left, pborderwidths->top, pborderwidths->right, pborderwidths->bottom);
        _rcBorderDoc = *pborderwidths;
    }
    else
    {
        TraceMsg(TF_SHDUIACTIVATE, "UIW::SetBorderSpace pborderwidths=NULL");
        SetRect(&_rcBorderDoc, 0, 0, 0, 0);
    }
    
    _pbsOuter->_UpdateViewRectSize();
    return S_OK;
}

HRESULT CBaseBrowser2::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
{
    TraceMsg(TF_SHDUIACTIVATE, "UIW::SetActiveObject called %x", pActiveObject);

    ATOMICRELEASE(_pact);

    if (pActiveObject)
    {
        _pact = pActiveObject;
        _pact->AddRef();
    }

    return S_OK;
}


/***********************************************************************\
    FUNCTION: _AddFolderOptionsSheets

    DESCRIPTION:
        Add the sheets for the "Folder Options" dialog.  These sheets
    come from the IShelLView object.
\***********************************************************************/
HRESULT CBaseBrowser2::_AddFolderOptionsSheets(DWORD dwReserved, LPFNADDPROPSHEETPAGE pfnAddPropSheetPage, LPPROPSHEETHEADER ppsh)
{
    // Add the normal Folder Option sheets.
    IShellPropSheetExt * ppsx;
    HRESULT hr = _pbsOuter->CreateBrowserPropSheetExt(IID_PPV_ARG(IShellPropSheetExt, &ppsx));
    if (SUCCEEDED(hr))
    {
        hr = ppsx->AddPages(AddPropSheetPage, (LPARAM)ppsh);
        ppsx->Release();
    }

    // Let the view add additional pages.  The exception will be FTP Folders because it exists to add
    // internet pages and we don't want them here.  However, if the above failed, then
    // we also want to fall back to this.  One of the cases this fixes if if the
    // browser fell back to legacy FTP support (web browser), then the above call will
    // fail on browser only, and we want to fall thru here to add the internet options.  Which
    // is appropriate for the fallback legacy FTP case because the menu will only have "Internet Options"
    // on it.
    if (FAILED(hr) || !IsBrowserFrameOptionsSet(_bbd._psf, BFO_BOTH_OPTIONS))
    {
        EVAL(SUCCEEDED(hr = _bbd._psv->AddPropertySheetPages(dwReserved, pfnAddPropSheetPage, (LPARAM)ppsh)));
    }

    return hr;
}


/***********************************************************************\
    FUNCTION: _AddInternetOptionsSheets

    DESCRIPTION:
        Add the sheets for the "Internet Options" dialog.  These sheets
    come from the browser.
\***********************************************************************/
HRESULT CBaseBrowser2::_AddInternetOptionsSheets(DWORD dwReserved, LPFNADDPROPSHEETPAGE pfnAddPropSheetPage, LPPROPSHEETHEADER ppsh)
{
    HRESULT hr;

    // Add the normal Internet Control Panel sheets. (This won't work when viewing FTP)
    if (_bbd._psvPending)
        hr = _bbd._psvPending->AddPropertySheetPages(dwReserved, pfnAddPropSheetPage, (LPARAM)ppsh);
    else
        hr = _bbd._psv->AddPropertySheetPages(dwReserved, pfnAddPropSheetPage, (LPARAM)ppsh);

    return hr;
}

/***********************************************************************\
    FUNCTION: _DoOptions

    DESCRIPTION:
        The user selected either "Folder Options" or "Internet Options" from
    the View or Tools menu (or where ever it lives this week).  The logic
    in this function is a little strange because sometimes the caller doesn't
    tell us which we need to display in the pvar.  If not, we need to calculate
    what to use.
    1. If it's a URL pidl (HTTP, GOPHER, etc) then we assume it's the
       "Internet Options" dialog.  We then use psv->AddPropertySheetPages()
       to create the "Internet Options" property sheets.
    2. If it's in the shell (or FTP because it needs folder options), then
       we assume it's "Folder Options" the user selected.  In that case,
       we get the property sheets using _pbsOuter->CreateBrowserPropSheetExt().
     
    Now it gets weird.  The PMs want FTP to have both "Internet Options" and
    "Folder Options".  If the pvar param is NULL, assume it's "Folder Options".
    If it was "Internet Options" in the internet case, then I will pass an
    pvar forcing Internet Options.

    NOTE: SBO_NOBROWSERPAGES means "Folder Options".  I'm guessing browser refers
          to the original explorer browser.
\***********************************************************************/

HDPA CBaseBrowser2::s_hdpaOptionsHwnd = NULL;

void CBaseBrowser2::_DoOptions(VARIANT* pvar)
{
    // Step 1. Determine what sheets to use.
    DWORD dwFlags = SBO_DEFAULT;
    TCHAR szCaption[MAX_PATH];
    
    if (!_bbd._psv)
        return;

    // Did the caller explicitly tell us which to use?
    if (pvar && pvar->vt == VT_I4)
        dwFlags = pvar->lVal;
    else if (_bbd._pidlCur)
    {
        // don't show the Folder Option pages if
        // 1. we're browsing the internet (excluding FTP), or
        // 2. if we're browsing a local file (not a folder), like a local .htm file.
        if (IsBrowserFrameOptionsSet(_bbd._psf, BFO_RENAME_FOLDER_OPTIONS_TOINTERNET))
        {
            // SBO_NOBROWSERPAGES means don't add the "Folder Options" pages.
            dwFlags = SBO_NOBROWSERPAGES;
        }
    }
    
    PROPSHEETHEADER psh;
    HPROPSHEETPAGE rPages[MAX_PAGES];

    psh.dwSize = SIZEOF(psh);
    psh.dwFlags = PSH_DEFAULT | PSH_USECALLBACK;
    psh.hInstance = MLGetHinst();
    psh.hwndParent = _bbd._hwnd;
    psh.pszCaption = szCaption;
    psh.nPages = 0;
    psh.nStartPage = 0;
    psh.phpage = rPages;
    psh.pfnCallback = _OptionsPropSheetCallback;

    // Step 2. Now add "Internet Options" or "Folder Options" sheets.
    if (dwFlags == SBO_NOBROWSERPAGES)
    {
        // They don't want folder pages. (The used to refer to it as browser)
        EVAL(SUCCEEDED(_AddInternetOptionsSheets(0, AddPropSheetPage, &psh)));
        MLLoadString(IDS_INTERNETOPTIONS, szCaption, ARRAYSIZE(szCaption));
    }
    else
    {
        EVAL(SUCCEEDED(_AddFolderOptionsSheets(0, AddPropSheetPage, &psh)));
        MLLoadString(IDS_FOLDEROPTIONS, szCaption, ARRAYSIZE(szCaption));
    }

    ULONG_PTR uCookie = 0;
    SHActivateContext(&uCookie);
    if (psh.nPages == 0)
    {
        SHRestrictedMessageBox(_bbd._hwnd);
    }
    else
    {
        // Step 3. Display the dialog
        _bbd._psv->EnableModelessSV(FALSE);
        INT_PTR iPsResult = PropertySheet(&psh);
        _SyncDPA();
        _bbd._psv->EnableModelessSV(TRUE);

        if (ID_PSREBOOTSYSTEM == iPsResult)
        {
            // The "offline folders" prop page will request a reboot if the user
            // has enabled or disabled client-side-caching.
            RestartDialog(_bbd._hwnd, NULL, EWX_REBOOT);
        }
    }
    if (uCookie)
    {
        SHDeactivateContext(uCookie);
    }
}

// we're here because our prop sheet just closed
// we need to purge it from the hwnd list
// check all the hwnds because 1) there's probably
// only one anyway, 2) paranoia.
void CBaseBrowser2::_SyncDPA()
{
    ENTERCRITICAL;

    if (s_hdpaOptionsHwnd != NULL)
    {
        int i, cPtr = DPA_GetPtrCount(s_hdpaOptionsHwnd);
        ASSERT(cPtr >= 0);

        // remove handles for windows which aren't there anymore
        for (i = cPtr - 1; i >= 0; i--)
        {
            HWND hwnd = (HWND)DPA_GetPtr(s_hdpaOptionsHwnd, i);
            if (!IsWindow(hwnd))
            {
                DPA_DeletePtr(s_hdpaOptionsHwnd, i);
                cPtr--;
            }
        }

        // if there aren't any windows left then clean up the hdpa
        if (cPtr == 0)
        {
            DPA_Destroy(s_hdpaOptionsHwnd);
            s_hdpaOptionsHwnd = NULL;
        }
    }

    LEAVECRITICAL;
}

int CALLBACK
CBaseBrowser2::_OptionsPropSheetCallback(HWND hwndDlg, UINT uMsg, LPARAM lParam)
{
    switch (uMsg)
    {
    case PSCB_INITIALIZED:
        {
            ENTERCRITICAL;

            if (s_hdpaOptionsHwnd == NULL)
            {
                // low mem -> Create failure -> don't track hwnd
                s_hdpaOptionsHwnd = DPA_Create(1);
            }

            if (s_hdpaOptionsHwnd != NULL)
            {
                // low mem -> AppendPtr array expansion failure -> don't track hwnd
                DPA_AppendPtr(s_hdpaOptionsHwnd, hwndDlg);
            }

            LEAVECRITICAL;
        }
        break;
    }

    return 0;
}

HRESULT CBaseBrowser2::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, 
                                  OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
{
    if (rgCmds == NULL)
        return E_INVALIDARG;

    if (pguidCmdGroup == NULL)
    {
        for (ULONG i = 0 ; i < cCmds; i++)
        {
            rgCmds[i].cmdf = 0;

            switch (rgCmds[i].cmdID)
            {
            case OLECMDID_SETDOWNLOADSTATE:
            case OLECMDID_UPDATECOMMANDS:
                rgCmds[i].cmdf = OLECMDF_ENABLED;
                break;

            case OLECMDID_STOP:
            case OLECMDID_STOPDOWNLOAD:
                if (_bbd._psvPending) // pending views are stoppable
                {
                    rgCmds[i].cmdf = OLECMDF_ENABLED;
                }
                else if (_bbd._pctView) // current views may support stop also
                {
                    _bbd._pctView->QueryStatus(NULL, 1, &rgCmds[i], pcmdtext);
                }
                break;

            default:
                // set to zero above
                if (_bbd._pctView)
                {
                    // Recursion check.  Avoid looping for those command IDs where Trident bounces
                    // back up to us.
                    //
                    if (_fInQueryStatus)
                        break;
                    _fInQueryStatus = TRUE;
                    _bbd._pctView->QueryStatus(NULL, 1, &rgCmds[i], pcmdtext);
                    _fInQueryStatus = FALSE;
                }
                break;
            }
        }
    }
    else if (IsEqualGUID(CGID_Explorer, *pguidCmdGroup))
    {
        for (ULONG i=0 ; i < cCmds ; i++)
        {
            switch (rgCmds[i].cmdID)
            {            
            case SBCMDID_ADDTOFAVORITES:
            case SBCMDID_CREATESHORTCUT:
                rgCmds[i].cmdf = OLECMDF_ENABLED;   // support these unconditionally
                break;

            case SBCMDID_CANCELNAVIGATION:
                rgCmds[i].cmdf = _bbd._psvPending ? OLECMDF_ENABLED : 0;
                break;

            case SBCMDID_OPTIONS:
                rgCmds[i].cmdf = OLECMDF_ENABLED;
                break;

            default:
                rgCmds[i].cmdf = 0;
                break;
            }
        }
    }
    else if (IsEqualGUID(CGID_ShellDocView, *pguidCmdGroup))
    {
        for (ULONG i=0 ; i < cCmds ; i++)
        {
            ITravelLog *ptl;

            switch (rgCmds[i].cmdID)
            {
            case SHDVID_CANGOBACK:
                rgCmds[i].cmdf = FALSE; // Assume False 
                if (SUCCEEDED(GetTravelLog(&ptl)))
                {
                    ASSERT(ptl);
                    if (S_OK == ptl->GetTravelEntry(SAFECAST(this, IShellBrowser *), TLOG_BACK, NULL))
                        rgCmds[i].cmdf = TRUE;
                    ptl->Release();
                }
                break;

            case SHDVID_CANGOFORWARD:
                rgCmds[i].cmdf = FALSE; // Assume False 
                if (SUCCEEDED(GetTravelLog(&ptl)))
                {
                    ASSERT(ptl);
                    if (S_OK == ptl->GetTravelEntry(SAFECAST(this, IShellBrowser *), TLOG_FORE, NULL))
                        rgCmds[i].cmdf = TRUE;
                    ptl->Release();
                }
                break;

            case SHDVID_PRINTFRAME:
            case SHDVID_MIMECSETMENUOPEN:
            case SHDVID_FONTMENUOPEN:
                if (_bbd._pctView)
                    _bbd._pctView->QueryStatus(pguidCmdGroup, 1, &rgCmds[i], pcmdtext);
                break;

            default:
                rgCmds[i].cmdf = 0;
                break;
            }
        }
    }
    else
    {
        return OLECMDERR_E_UNKNOWNGROUP;
    }

    return S_OK;
}

HRESULT CBaseBrowser2::_ShowBlankPage(LPCTSTR pszAboutUrl, LPCITEMIDLIST pidlIntended)
{
    // Never execute this twice.
    if (_fNavigatedToBlank) 
    {
        TraceMsg(TF_WARNING, "Re-entered CBaseBrowser2::_ShowBlankPage");
        return E_FAIL;
    }

    _fNavigatedToBlank = TRUE;

    BSTR bstrURL;
    TCHAR szPendingURL[MAX_URL_STRING + 1];
    TCHAR *pszOldUrl = NULL;
    
    szPendingURL[0] = TEXT('#');
    HRESULT hres;
    

    if (pidlIntended)
    {
        hres = ::IEGetNameAndFlags(pidlIntended, SHGDN_FORPARSING, szPendingURL + 1, SIZECHARS(szPendingURL)-1, NULL);
        if (S_OK == hres)
            pszOldUrl = szPendingURL;
    }   

    hres = CreateBlankURL(&bstrURL, pszAboutUrl, pszOldUrl);
   
    if (SUCCEEDED(hres))
    {
        LPITEMIDLIST pidlTemp;

        hres = IECreateFromPathW(bstrURL, &pidlTemp);
        if (SUCCEEDED(hres)) 
        {
            //
            // Note that we pass TRUE as fDontCallCancel to asynchronously
            // cancel the current view. Otherwise, we hit GPF in CDocHostObject::
            // _CancelPendingNavigation.
            //
            _NavigateToPidlAsync(pidlTemp, 0, TRUE); // takes ownership of pidl
        }

        SysFreeString(bstrURL);
    }
    return hres;
}

int CALLBACK _PunkRelease(void * p, void * pData)
{
    IUnknown* punk = (IUnknown*)p;
    punk->Release();
    return 1;
}

void CBaseBrowser2::_DLMDestroy(void)
{
    if (_hdpaDLM) 
    {
        DPA_DestroyCallback(_hdpaDLM, _PunkRelease, NULL);
        _hdpaDLM = NULL;
    }
}

HRESULT CBaseBrowser2::InitializeDownloadManager()
{
    _hdpaDLM = DPA_Create(4);
    return S_OK;
}


//
// DLM = DownLoad Manager
//
void CBaseBrowser2::_DLMUpdate(MSOCMD* prgCmd)
{
    ASSERT(prgCmd->cmdID == OLECMDID_STOPDOWNLOAD);
    for (int i = DPA_GetPtrCount(_hdpaDLM) - 1; i >= 0; i--) 
    {
        IOleCommandTarget* pcmdt = (IOleCommandTarget*)DPA_GetPtr(_hdpaDLM, i);
        prgCmd->cmdf = 0;
        pcmdt->QueryStatus(NULL, 1, prgCmd, NULL);
        if (prgCmd->cmdf & MSOCMDF_ENABLED) 
        {
            // We found one downloading guy, skip others. 
            break;
        }
        else 
        {
            // This guy is no longer busy, remove it from the list,
            // and continue. 
            DPA_DeletePtr(_hdpaDLM, i);
            pcmdt->Release();
        }
    }
}

void CBaseBrowser2::_DLMRegister(IUnknown* punk)
{
    // Check if it's already registered. 
    for (int i = 0; i < DPA_GetPtrCount(_hdpaDLM); i++) 
    {
        IOleCommandTarget* pcmdt = (IOleCommandTarget*)DPA_GetPtr(_hdpaDLM, i);
        if (IsSameObject(pcmdt, punk)) 
        {
            // Already registered, don't register.
            return;
        }
    }

    IOleCommandTarget* pcmdt;
    HRESULT hres = punk->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &pcmdt));
    if (SUCCEEDED(hres)) 
    {
        if (DPA_AppendPtr(_hdpaDLM, pcmdt) == -1) 
        {
            pcmdt->Release();
        }
    }
}

//
// This function updates the _fDescendentNavigate flag.
//
// ALGORITHM:
//  If pvaragIn->lVal has some non-zero value, we set _fDescendentNavigate.
//  Otherwise, we ask the current view to see if it has something to stop.
// 
HRESULT CBaseBrowser2::_setDescendentNavigate(VARIANTARG *pvarargIn)
{
    ASSERT(!pvarargIn || pvarargIn->vt == VT_I4 || pvarargIn->vt == VT_BOOL || pvarargIn->vt == VT_UNKNOWN);
    if (!pvarargIn || !pvarargIn->lVal)
    {
        MSOCMD rgCmd;

        rgCmd.cmdID = OLECMDID_STOPDOWNLOAD;
        rgCmd.cmdf = 0;
        if (_bbd._pctView)
            _bbd._pctView->QueryStatus(NULL, 1, &rgCmd, NULL);

        //
        // If and only if the view says "I'm not navigating any more",
        // we'll ask the same question to each registered objects.
        //
        if (_hdpaDLM && !(rgCmd.cmdf & MSOCMDF_ENABLED)) 
        {
            _DLMUpdate(&rgCmd);
        }

        _fDescendentNavigate = (rgCmd.cmdf & MSOCMDF_ENABLED) ? TRUE:FALSE;
    }
    else
    {
        if (_hdpaDLM && pvarargIn->vt == VT_UNKNOWN) 
        {
            ASSERT(pvarargIn->punkVal);
            _DLMRegister(pvarargIn->punkVal);
        }
        _fDescendentNavigate = TRUE;
    }
    return S_OK;
}

void CBaseBrowser2::_CreateShortcutOnDesktop(IUnknown *pUnk, BOOL fUI)
{
    ISHCUT_PARAMS ShCutParams = {0};
    IWebBrowser *pwb = NULL;
    IDispatch *pdisp = NULL;
    IHTMLDocument2 *pDoc = NULL;
    LPITEMIDLIST pidlCur = NULL;
    BSTR bstrTitle = NULL;
    BSTR bstrURL = NULL;
    
    if (!fUI || (MLShellMessageBox(_bbd._hwnd,
                                 MAKEINTRESOURCE(IDS_CREATE_SHORTCUT_MSG),
                                 MAKEINTRESOURCE(IDS_TITLE),
                                 MB_OKCANCEL) == IDOK))
    {
         TCHAR szPath[MAX_PATH];
         
         if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_DESKTOPDIRECTORY, TRUE))
         {
            TCHAR szName[MAX_URL_STRING];
            HRESULT hr;

            if (pUnk)
            {
                hr = IUnknown_QueryService(pUnk, SID_SHlinkFrame, IID_PPV_ARG(IWebBrowser, &pwb));
                if (hr)
                    goto Cleanup;
                
                hr = pUnk->QueryInterface(IID_PPV_ARG(IHTMLDocument2, &pDoc));
                if (hr)
                    goto Cleanup;
                
                hr = pDoc->get_URL(&bstrURL);
                if (hr)
                    goto Cleanup;
                
                hr = pDoc->get_title(&bstrTitle);
                if (hr)
                    goto Cleanup;
                
                if (SysStringLen(bstrTitle) == 0)
                {
                    StrCpyNW(szName, bstrURL, ARRAYSIZE(szName));
                    ShCutParams.pszTitle = PathFindFileName(szName); 
                }
                else
                {
                    StrCpyNW(szName, bstrTitle, ARRAYSIZE(szName));
                    ShCutParams.pszTitle = szName;
                }
                
                pidlCur = PidlFromUrl(bstrURL);
                if (!pidlCur)
                    goto Cleanup;
                
                ShCutParams.pidlTarget = pidlCur;
            }
            else
            {
                hr = QueryService(SID_SHlinkFrame, IID_PPV_ARG(IWebBrowser, &pwb));
                if (hr)
                    goto Cleanup;
                
                hr = pwb->get_Document(&pdisp);
                if (hr)
                    goto Cleanup;
                
                hr = pdisp->QueryInterface(IID_PPV_ARG(IHTMLDocument2, &pDoc));
                if (hr)
                    goto Cleanup;
                
                ShCutParams.pidlTarget = _bbd._pidlCur;
                if(_bbd._pszTitleCur)
                {
                    StrCpyNW(szName, _bbd._pszTitleCur, ARRAYSIZE(szName));
                    ShCutParams.pszTitle = szName;
                }
                else
                {
                    ::IEGetNameAndFlags(_bbd._pidlCur, SHGDN_INFOLDER, szName, SIZECHARS(szName), NULL);
                    ShCutParams.pszTitle = PathFindFileName(szName); 
                }
            }
            ShCutParams.pszDir = szPath; 
            ShCutParams.pszOut = NULL;
            ShCutParams.bUpdateProperties = FALSE;
            ShCutParams.bUniqueName = TRUE;
            ShCutParams.bUpdateIcon = TRUE;
            
            hr = pwb->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &ShCutParams.pCommand));
            ASSERT((S_OK == hr) && (BOOLIFY(ShCutParams.pCommand)));
            if (hr)
                goto Cleanup;
            
            ShCutParams.pDoc = pDoc;
            ShCutParams.pDoc->AddRef();
            
            hr = CreateShortcutInDirEx(&ShCutParams);
            AssertMsg(SUCCEEDED(hr), TEXT("CDOH::_CSOD CreateShortcutInDir failed %x"), hr);
            if (hr)
                goto Cleanup;
         } 
         else 
         {
             TraceMsg(DM_ERROR, "CSB::_CSOD SHGetSFP(DESKTOP) failed");
         }
    }
Cleanup:
    SysFreeString(bstrTitle);
    SysFreeString(bstrURL);
    ILFree(pidlCur);
    SAFERELEASE(ShCutParams.pDoc);
    SAFERELEASE(ShCutParams.pCommand);
    SAFERELEASE(pwb);
    SAFERELEASE(pdisp);
    SAFERELEASE(pDoc);
}


void CBaseBrowser2::_AddToFavorites(LPCITEMIDLIST pidl, LPCTSTR pszTitle, BOOL fDisplayUI)
{
    HRESULT hr;
    IWebBrowser *pwb = NULL;
    IOleCommandTarget *pcmdt = NULL;

    if (SHIsRestricted2W(_bbd._hwnd, REST_NoFavorites, NULL, 0))
        return;

    hr = QueryService(SID_SHlinkFrame, IID_PPV_ARG(IWebBrowser, &pwb));
    if (S_OK == hr)
    {
        hr = pwb->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &pcmdt));
        ASSERT((S_OK == hr) && (BOOLIFY(pcmdt)));
        
        pwb->Release();
    }

    //there's a small window where _pidlCur can be freed while AddToFavorites is coming up,
    // so use a local copy instead
    LPITEMIDLIST pidlCur = NULL;
    if (!pidl)
        pidlCur = ILClone(_bbd._pidlCur);

    if (pidl || pidlCur)
        AddToFavorites(_bbd._hwnd, pidl ? pidl : pidlCur, pszTitle, fDisplayUI, pcmdt, NULL);

    ILFree(pidlCur);

    SAFERELEASE(pcmdt);
}

HRESULT CBaseBrowser2::_OnCoCreateDocument(VARIANTARG *pvarargOut)
{
    HRESULT hres;

    //
    // Cache the class factory object and lock it (leave it loaded)
    //
    if (_pcfHTML == NULL) 
    {
        TraceMsg(DM_COCREATEHTML, "CBB::_OnCoCreateDoc called first time (this=%x)", this);
        hres = CoGetClassObject(CLSID_HTMLDocument, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
                    0, IID_PPV_ARG(IClassFactory, &_pcfHTML));
        if (SUCCEEDED(hres)) 
        {
            hres = _pcfHTML->LockServer(TRUE);
            if (FAILED(hres)) 
            {
                _pcfHTML->Release();
                _pcfHTML = NULL;
                return hres;
            }
        } 
        else 
        {
            return hres;
        }
    }

    TraceMsg(DM_COCREATEHTML, "CBB::_OnCoCreateDoc creating an instance (this=%x)", this);

    hres = _pcfHTML->CreateInstance(NULL, IID_PPV_ARG(IUnknown, &pvarargOut->punkVal));
    if (SUCCEEDED(hres)) 
    {
        pvarargOut->vt = VT_UNKNOWN;
    } 
    else 
    {
        pvarargOut->vt = VT_EMPTY;
    }
    return hres;
}


// fill a buffer with a variant, return a pointer to that buffer on success of the conversion

LPCTSTR VariantToString(const VARIANT *pv, LPTSTR pszBuf, UINT cch)
{
    *pszBuf = 0;

    if (pv && pv->vt == VT_BSTR && pv->bstrVal)
    {
        StrCpyN(pszBuf, pv->bstrVal, cch);
        if (*pszBuf)
            return pszBuf;
    }
    return NULL;
}

HRESULT CBaseBrowser2::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, 
                           VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
    HRESULT hres = OLECMDERR_E_NOTSUPPORTED;

    if (pguidCmdGroup == NULL) 
    {
        switch(nCmdID) 
        {

        case OLECMDID_CLOSE:
            HWND hwnd;
            GetWindow(&hwnd);
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            hres = S_OK;
            break;

        // CBaseBrowser2 doesn't actually do the toolbar -- itbar does, forward this
        case OLECMDID_UPDATECOMMANDS:
            _NotifyCommandStateChange();
            hres = S_OK;
            break;

        case OLECMDID_SETDOWNLOADSTATE:

            ASSERT(pvarargIn);

            if (pvarargIn) 
            {
                _setDescendentNavigate(pvarargIn);
                hres = _updateNavigationUI();              
            }
            else 
            {
                hres = E_INVALIDARG;
            }
            break;
            
        case OLECMDID_REFRESH:
            if (_bbd._pctView) // we must check!
                hres = _bbd._pctView->Exec(NULL, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
            else if (_bbd._psv)
            {
                _bbd._psv->Refresh();
                hres = S_OK;
            }

            break;

        //
        //  When Exec(OLECMDID_STOP) is called either by the containee (the
        // current document) or the automation service object, we cancel
        // the pending navigation (if any), then tell the current document
        // to stop the go-going download in that page.
        //
        case OLECMDID_STOP:
            // cant stop if we are modeless
            if (S_FALSE == _DisableModeless())
            {
                LPITEMIDLIST pidlIntended = (_bbd._pidlPending) ? ILClone(_bbd._pidlPending) : NULL;
                _CancelPendingNavigation();

                // the _bbd._pctView gives us a _StopCurrentView()
                _pbsOuter->_ExecChildren(_bbd._pctView, TRUE, NULL, OLECMDID_STOP, OLECMDEXECOPT_DONTPROMPTUSER, NULL, NULL);   // Exec

                if (!_bbd._pidlCur)
                {
                    TCHAR szResURL[MAX_URL_STRING];

                    hres = MLBuildResURLWrap(TEXT("shdoclc.dll"),
                                             HINST_THISDLL,
                                             ML_CROSSCODEPAGE,
                                             TEXT("navcancl.htm"),
                                             szResURL,
                                             ARRAYSIZE(szResURL),
                                             TEXT("shdocvw.dll"));
                    if (SUCCEEDED(hres))
                    {
                        _ShowBlankPage(szResURL, pidlIntended);
                    }
                }

                if (pidlIntended)
                {
                    ILFree(pidlIntended);
                }
                    
            }

            hres = S_OK;
            break;

        // handled in basesb so IWebBrowser::ExecWB gets this
        // since this used to be in shbrowse, make sure we do
        // it only if _fTopBrowser
        case OLECMDID_FIND:
#define TBIDM_SEARCH            0x123 // defined in browseui\itbdrop.h

            // Check restriction here cuz Win95 didn't check in SHFindFiles like it now does.
            if (!SHRestricted(REST_NOFIND) && _fTopBrowser)
            {
                if (!_bbd._pctView || FAILED(_bbd._pctView->Exec(NULL, nCmdID, nCmdexecopt, pvarargIn, pvarargOut))) 
                {
                    if (pvarargIn && pvarargIn->vt == VT_UNKNOWN)
                    {
                        ASSERT(pvarargIn->punkVal);

                        VARIANT  var = {0};
                        var.vt = VT_I4;
                        var.lVal = -1;
                        if (SUCCEEDED(IUnknown_Exec(pvarargIn->punkVal, &CLSID_CommonButtons, TBIDM_SEARCH, 0, NULL, &var)))
                            break;
                    }
                    SHFindFiles(_bbd._pidlCur, NULL);
                }
            }
            break;

        case OLECMDID_HTTPEQUIV_DONE:
        case OLECMDID_HTTPEQUIV:
            hres = OnHttpEquiv(_bbd._psv, (OLECMDID_HTTPEQUIV_DONE == nCmdID), pvarargIn, pvarargOut);
            break;

        case OLECMDID_PREREFRESH:
            // Tell the shell's HTML window we have a new document
            // Fall through default
            if (_phtmlWS)
            {
                _phtmlWS->ViewActivated();
            }

        // Binder prints by reflecting the print back down. do the same here
        // Note: we may want to do the same for _PRINTPREVIEW, _PROPERTIES, _STOP, etc.
        // The null command group should all go down, no need to stop these at the pass.
        default:
            if (_bbd._pctView) // we must check!
                hres = _bbd._pctView->Exec(NULL, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
            else
                hres = OLECMDERR_E_NOTSUPPORTED;
            break;
        }
    }
    else if (IsEqualGUID(CGID_MSHTML, *pguidCmdGroup))
    {
        if (_bbd._pctView) // we must check!
            hres = _bbd._pctView->Exec(&CGID_MSHTML, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
        else
            hres = OLECMDERR_E_NOTSUPPORTED;
    }
    else if (IsEqualGUID(CGID_Explorer, *pguidCmdGroup))
    {
        switch(nCmdID) 
        {
        case SBCMDID_CREATESHORTCUT:
            if (   pvarargIn
                && (V_VT(pvarargIn) == VT_UNKNOWN)
               )
            {
                _CreateShortcutOnDesktop(V_UNKNOWN(pvarargIn), nCmdexecopt & OLECMDEXECOPT_PROMPTUSER);
            }
            else
            {
                _CreateShortcutOnDesktop(NULL, nCmdexecopt & OLECMDEXECOPT_PROMPTUSER);
            }
            hres = S_OK;
            break;

        case SBCMDID_ADDTOFAVORITES:
            {
                LPITEMIDLIST pidl = NULL;

                //if someone doesn't pass a path in, _AddToFavorites will use the current page
                if ((pvarargIn != NULL) && (pvarargIn->vt == VT_BSTR))
                    IECreateFromPath(pvarargIn->bstrVal, &pidl);
                
                TCHAR szTitle[128];
                LPTSTR pszTitle = NULL;
                if (pvarargOut)
                    pszTitle = (LPTSTR)VariantToString(pvarargOut, szTitle, ARRAYSIZE(szTitle)); // may be NULL
                else
                {
                    if (_bbd._pszTitleCur)
                        pszTitle = StrCpyNW(szTitle, _bbd._pszTitleCur, ARRAYSIZE(szTitle));
                }

                _AddToFavorites(pidl, pszTitle, nCmdexecopt & OLECMDEXECOPT_PROMPTUSER);

                if (pidl)
                    ILFree(pidl);
                hres = S_OK;
            }
            break;

        case SBCMDID_OPTIONS:
            _DoOptions(pvarargIn);
            break;

        case SBCMDID_CANCELNAVIGATION:

            TraceMsg(DM_NAV, "ief NAV::%s called when _bbd._pidlCur==%x, _bbd._psvPending==%x",
                             TEXT("Exec(SBCMDID_CANCELNAV) called"),
                             _bbd._pidlCur, _bbd._psvPending);

            // Check if this is sync or async
            if (pvarargIn && pvarargIn->vt == VT_I4 && pvarargIn->lVal) 
            {
                TraceMsg(DM_WEBCHECKDRT, "CBB::Exec calling _CancelPendingNavigation");
                _CancelPendingNavigation();
            }
            else
            {
                //
                //  We must call ASYNC version in this case because this call
                // is from the pending view itself.
                //
                LPITEMIDLIST pidlIntended = (_bbd._pidlPending) ? ILClone(_bbd._pidlPending) : NULL;
                _CancelPendingNavigationAsync();

                if (!_bbd._pidlCur)
                {
                    if (!_fDontShowNavCancelPage)
                    {
                        TCHAR szResURL[MAX_URL_STRING];

                        if (IsGlobalOffline())
                        {
                            hres = MLBuildResURLWrap(TEXT("shdoclc.dll"),
                                                     HINST_THISDLL,
                                                     ML_CROSSCODEPAGE,
                                                     TEXT("offcancl.htm"),
                                                     szResURL,
                                                     ARRAYSIZE(szResURL),
                                                     TEXT("shdocvw.dll"));
                            if (SUCCEEDED(hres))
                            {
                                _ShowBlankPage(szResURL, pidlIntended);
                            }
                        }
                        else
                        {
                            hres = MLBuildResURLWrap(TEXT("shdoclc.dll"),
                                                     HINST_THISDLL,
                                                     ML_CROSSCODEPAGE,
                                                     TEXT("navcancl.htm"),
                                                     szResURL,
                                                     ARRAYSIZE(szResURL),
                                                     TEXT("shdocvw.dll"));
                            if (SUCCEEDED(hres))
                            {
                                _ShowBlankPage(szResURL, pidlIntended);
                            }
                        }
                    }
                    else
                    {
                        _fDontShowNavCancelPage = FALSE;
                    }
                }

                if (pidlIntended)
                    ILFree(pidlIntended);
            }
            hres = S_OK;
            break;

        case SBCMDID_ASYNCNAVIGATION:

            TraceMsg(DM_NAV, "ief NAV::%s called when _bbd._pidlCur==%x, _bbd._psvPending==%x",
                             TEXT("Exec(SBCMDID_ASYNCNAV) called"),
                             _bbd._pidlCur, _bbd._psvPending);

            //
            //  We must call ASYNC version in this case because this call
            // is from the pending view itself.
            //
            _SendAsyncNavigationMsg(pvarargIn);
            hres = S_OK;
            break;


        case SBCMDID_COCREATEDOCUMENT:
            hres = _OnCoCreateDocument(pvarargOut);
            break;

        case SBCMDID_HISTSFOLDER:
            if (pvarargOut) 
            {
                VariantClearLazy(pvarargOut);
                if (NULL == _punkSFHistory)
                {
                    IHistSFPrivate *phsfHistory;

                    hres = LoadHistoryShellFolder(NULL, &phsfHistory);
                    if (SUCCEEDED(hres))
                    {
                        hres = phsfHistory->QueryInterface(IID_PPV_ARG(IUnknown, &_punkSFHistory));
                        phsfHistory->Release();
                    }
                }
                if (NULL != _punkSFHistory)
                {
                    pvarargOut->vt = VT_UNKNOWN;
                    pvarargOut->punkVal = _punkSFHistory;
                    _punkSFHistory->AddRef();
                }
            }
            break;

        case SBCMDID_UPDATETRAVELLOG:
            {
                BOOL fForceUpdate = FALSE;

                if (pvarargIn && (VT_I4 == V_VT(pvarargIn)))
                {
                    _fIsLocalAnchor = !!(V_I4(pvarargIn) & TRAVELLOG_LOCALANCHOR);
                    fForceUpdate = !!(V_I4(pvarargIn) & TRAVELLOG_FORCEUPDATE);
                }

                _UpdateTravelLog(fForceUpdate);
            }
            // fall through

        case SBCMDID_REPLACELOCATION:
            if (pvarargIn && pvarargIn->vt == VT_BSTR)
            {
                WCHAR wzParsedUrl[MAX_URL_STRING];
                LPWSTR  pszUrl = pvarargIn->bstrVal;
                LPITEMIDLIST pidl;

                // BSTRs can be NULL.
                if (!pszUrl)
                    pszUrl = L"";

                // NOTE: This URL came from the user, so we need to clean it up.
                //       If the user entered "yahoo.com" or "Search Get Rich Quick",
                //       it will be turned into a search URL by ParseURLFromOutsideSourceW().
                DWORD cchParsedUrl = ARRAYSIZE(wzParsedUrl);
                if (!ParseURLFromOutsideSourceW(pszUrl, wzParsedUrl, &cchParsedUrl, NULL))
                {
                    StrCpyN(wzParsedUrl, pszUrl, ARRAYSIZE(wzParsedUrl));
                } 

                IEParseDisplayName(CP_ACP, wzParsedUrl, &pidl);
                if (pidl)
                {
                    NotifyRedirect(_bbd._psv, pidl, NULL);
                    ILFree(pidl);
                }
            }

            // even if there was no url, still force no refresh.
            _fGeneratedPage = TRUE;
            
            //  force updating the back and forward buttons
            _pbsOuter->UpdateBackForwardState();
            hres = S_OK;
            break;

        case SBCMDID_ONCLOSE:
            hres = S_OK;

            if (_bbd._pctView)
            {
                hres = _bbd._pctView->Exec(pguidCmdGroup, nCmdID, 0, NULL, NULL);
            }

            break;

        case SBCMDID_SETSECURELOCKICON:
            {
                //  if this is a SET, then just obey.
                LONG lock = pvarargIn->lVal;
                TraceMsg(DM_SSL, "SB::Exec() SETSECURELOCKICON lock = %d", lock);

                if (lock >= SECURELOCK_FIRSTSUGGEST)
                {
                    //
                    //  if this was ever secure, then the lowest we can be
                    //  suggested to is MIXED.  otherwise we just choose the 
                    //  lowest level of security suggested.
                    //
                    if ((lock == SECURELOCK_SUGGEST_UNSECURE) && 
                        (_bbd._eSecureLockIcon != SECURELOCK_SET_UNSECURE))
                    {
                        lock = SECURELOCK_SET_MIXED;
                    }
                    else
                    {
                        lock = min(lock - SECURELOCK_FIRSTSUGGEST, _bbd._eSecureLockIcon);
                    }
                }

                UpdateSecureLockIcon(lock);
                hres = S_OK;
            }
            break;

        default:
            hres = OLECMDERR_E_NOTSUPPORTED;
            break;
        }
    }
    else if (IsEqualGUID(CGID_ShellDocView, *pguidCmdGroup))
    {
        switch(nCmdID) 
        {
        case SHDVID_GOBACK:
            hres = _psbOuter->BrowseObject(NULL, SBSP_NAVIGATEBACK);
            break;

        case SHDVID_GOFORWARD:
            hres = _psbOuter->BrowseObject(NULL, SBSP_NAVIGATEFORWARD);
            break;

        // we reflect AMBIENTPROPCHANGE down because this is how iedisp notifies dochost
        // that an ambient property has changed. we don't need to reflect this down in
        // cwebbrowsersb because only the top-level iwebbrowser2 is allowed to change props
        case SHDVID_AMBIENTPROPCHANGE:
        case SHDVID_PRINTFRAME:
        case SHDVID_MIMECSETMENUOPEN:
        case SHDVID_FONTMENUOPEN:
        case SHDVID_DOCFAMILYCHARSET:
            if (_bbd._pctView) // we must check!
            {
                hres = _bbd._pctView->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
            }
            else
                hres = E_FAIL;
            break;

        case SHDVID_DEACTIVATEMENOW:
            if (!_bbd._psvPending)
            {
                hres = S_OK;
                break;
            }
            //  fall through to activate new view
#ifdef FEATURE_PICS
        case SHDVID_ACTIVATEMENOW:
#endif
            if (   pvarargIn
                && (VT_BOOL == V_VT(pvarargIn))
                && (VARIANT_TRUE == V_BOOL(pvarargIn)))  // Synchronous
            {
                if (_bbd._psvPending)
                {
                    ASSERT(_pbsOuter);
                    _pbsOuter->ActivatePendingView();
                }
            }
            else  // Asynchronous
            {
                _ActivatePendingViewAsync();
            }

            hres = S_OK;
            break;


        case SHDVID_GETPENDINGOBJECT:
            ASSERT( pvarargOut);
            if (_bbd._psvPending && ((pvarargIn && pvarargIn->vt == VT_BOOL && pvarargIn->boolVal) || !_bbd._psv))
            {
                VariantClearLazy(pvarargOut);
                _bbd._psvPending->QueryInterface(IID_PPV_ARG(IUnknown, &pvarargOut->punkVal));
                if (pvarargOut->punkVal) pvarargOut->vt = VT_UNKNOWN;
            }
            hres = (pvarargOut->punkVal == NULL) ? E_FAIL : S_OK;
            break;

 
        case SHDVID_SETPRINTSTATUS:
            if (pvarargIn && pvarargIn->vt == VT_BOOL)
            {
                VARIANTARG var = {0};
                if (_bbd._pctView && SUCCEEDED(_bbd._pctView->Exec(&CGID_Explorer, SBCMDID_GETPANE, PANE_PRINTER, NULL, &var))
                     && V_UI4(&var) != PANE_NONE)
                {
                    _psbOuter->SendControlMsg(FCW_STATUS, SB_SETICON, V_UI4(&var), 
                                  (LPARAM)(pvarargIn->boolVal ? g_hiconPrinter : NULL), NULL);
                    // we're putting the printer icon and the offline icon in the same
                    // slot on the status bar, so when we turn off the printer icon
                    // we have to check to see if we're offline so we can put the offline
                    // icon back
                    if (!pvarargIn->boolVal && IsGlobalOffline())
                    {
#ifdef DEBUG
                        VARIANTARG var2 = {0};
                        _bbd._pctView->Exec(&CGID_Explorer, SBCMDID_GETPANE, PANE_OFFLINE, NULL, &var2);
                        ASSERT(V_UI4(&var2) == V_UI4(&var));
#endif DEBUG
                        _psbOuter->SendControlMsg(FCW_STATUS, SB_SETICON, V_UI4(&var),
                                                  (LPARAM)(g_hiconOffline), NULL);
                    } // if (!pvarargIn->boolVal && IsGlobalOffline())
                }
                hres = S_OK;
            }
            else
                hres = E_INVALIDARG;
            break;

#ifdef FEATURE_PICS
        /* Dochost sends up this command to have us put up the PICS access
         * denied dialog.  This is done so that all calls to this ratings
         * API are modal to the top-level browser window;  that in turn
         * lets the ratings code coalesce denials for all subframes into
         * a single dialog.
         */
        case SHDVID_PICSBLOCKINGUI:
            {
                void * pDetails;
                if (pvarargIn && pvarargIn->vt == VT_INT_PTR)
                    pDetails = pvarargIn->byref;
                else
                    pDetails = NULL;
                TraceMsg(DM_PICS, "CBaseBrowser2::Exec calling RatingAccessDeniedDialog2");
                /**
                 * We QueryService for an SID_IRatingNotification which is
                 * implemented by our host, if we find it, instead of 
                 * displaying the modal ratings dialog, we notify our host through
                 * the interface and allow it to make the decision
                 */
                IRatingNotification* pRatingNotify;
                hres = QueryService(SID_SRatingNotification, IID_PPV_ARG(IRatingNotification, &pRatingNotify));
                if (SUCCEEDED(hres))
                {
                    RATINGBLOCKINGINFO* pRBInfo = NULL;
                    TraceMsg(DM_PICS, "CBaseBrowser2::Exec calling RatingMarsCrackData");
                    hres = RatingCustomCrackData(NULL, pDetails, &pRBInfo);
                    if (SUCCEEDED(hres))
                    {
                        hres = pRatingNotify->AccessDeniedNotify(pRBInfo);
                        RatingCustomDeleteCrackedData(pRBInfo);
                    }
                    pRatingNotify->Release();
                } // if (SUCCEEDED(hres))
                else {
                    hres = RatingAccessDeniedDialog2(_bbd._hwnd, NULL, pDetails);
                }
            }
            break;
#endif

       case SHDVID_ONCOLORSCHANGE:
            // PALETTE:
            // PALETTE: recompute our palette
            // PALETTE:
            _ColorsDirty(BPT_UnknownPalette);
            break;

        case SHDVID_GETOPTIONSHWND:
        {
            ASSERT(pvarargOut != NULL);
            ASSERT(V_VT(pvarargOut) == VT_BYREF);


            // return the hwnd for the inet options
            // modal prop sheet. we're tracking
            // this hwnd because if it's open
            // and plugUI shutdown needs to happen,
            // that dialog needs to receive a WM_CLOSE
            // before we can nuke it

            hres = E_FAIL;

            // is there a list of window handles?

            ENTERCRITICAL;

            if (s_hdpaOptionsHwnd != NULL)
            {
                int cPtr = DPA_GetPtrCount(s_hdpaOptionsHwnd);
                // is that list nonempty?
                if (cPtr > 0)
                {
                    HWND hwndOptions = (HWND)DPA_GetPtr(s_hdpaOptionsHwnd, 0);
                    ASSERT(hwndOptions != NULL);

                    pvarargOut->byref = hwndOptions;

                    // remove it from the list
                    // that hwnd is not our responsibility anymore
                    DPA_DeletePtr(s_hdpaOptionsHwnd, 0);

                    // successful hwnd retrieval
                    hres = S_OK;
                }
            }

            LEAVECRITICAL;
        }
        break;

        case SHDVID_DISPLAYSCRIPTERRORS:
        {
            HRESULT hr;

            hr = _bbd._pctView->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);

            return hr;
        }
        break;

        case SHDVID_NAVIGATEFROMDOC:  // The document called Navigate
            _dwDocFlags |= DOCFLAG_NAVIGATEFROMDOC;
            return S_OK;

        case SHDVID_SETNAVIGATABLECODEPAGE:
            _dwDocFlags |= DOCFLAG_SETNAVIGATABLECODEPAGE;
            return S_OK;

        case SHDVID_CHECKINCACHEIFOFFLINE:
            {
                if (pvarargIn && (VT_BSTR == V_VT(pvarargIn)) && V_BSTR(pvarargIn)
                    && pvarargOut && (VT_BOOL == V_VT(pvarargOut)))
                {
                    LPITEMIDLIST pidl = PidlFromUrl(V_BSTR(pvarargIn));
                    if (pidl)
                    {
                        // (scotrobe): We should be passing fIsPost
                        // into _CheckInCacheIfOffline. 
                        //
                        V_BOOL(pvarargOut) = (S_OK == _CheckInCacheIfOffline(pidl, FALSE));
                        ILFree(pidl);

                        return S_OK;
                    }
                }
                return E_FAIL;
            }
            break;

        case SHDVID_CHECKDONTUPDATETLOG:
            {
                if (pvarargOut)
                {
                    V_VT(pvarargOut) = VT_BOOL;
                    V_BOOL(pvarargOut) = (_fDontAddTravelEntry ? VARIANT_TRUE : VARIANT_FALSE);
                    hres = S_OK;
                }
                break;
            }

        case SHDVID_FIREFILEDOWNLOAD:
            if (pvarargOut)
            {
                BOOL fCancel = FALSE;

                V_VT(pvarargOut) = VT_BOOL;

                FireEvent_FileDownload(_bbd._pautoEDS, &fCancel, pvarargIn ? V_BOOL(pvarargIn):VARIANT_FALSE);
                pvarargOut->boolVal = (fCancel ? VARIANT_TRUE : VARIANT_FALSE);
                hres = S_OK;
            }
            break;

        default:
            hres = OLECMDERR_E_NOTSUPPORTED;
            break;
        }
    }
    else if (IsEqualGUID(CGID_ShortCut, *pguidCmdGroup))
    {
        if (_bbd._pctView) // we must check!
            hres = _bbd._pctView->Exec(&CGID_ShortCut, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
        else
            hres = OLECMDERR_E_NOTSUPPORTED;
    } 
    else if (IsEqualGUID(CGID_DocHostCmdPriv, *pguidCmdGroup))
    {
        switch(nCmdID) 
        {
        case DOCHOST_DOCCANNAVIGATE:
            if (pvarargIn && VT_UNKNOWN == V_VT(pvarargIn) && V_UNKNOWN(pvarargIn))
            {
                _dwDocFlags |= DOCFLAG_DOCCANNAVIGATE;
            }
            else
            {
                _dwDocFlags &= ~DOCFLAG_DOCCANNAVIGATE;                
            }

            hres = S_OK;
            break;

        case DOCHOST_SETBROWSERINDEX:
            if (pvarargIn && VT_I4 == V_VT(pvarargIn))
            {
                _dwBrowserIndex = V_I4(pvarargIn);
                return S_OK;
            }

            return E_INVALIDARG;

        default:
            hres = OLECMDERR_E_UNKNOWNGROUP;  // Backwards compatability
            break;
        }
    }
    else if (IsEqualGUID(CGID_InternetExplorer, *pguidCmdGroup))
    {
        switch(nCmdID) 
        {
        case IECMDID_SET_INVOKE_DEFAULT_BROWSER_ON_NEW_WINDOW:
            if ((NULL != pvarargIn) && (pvarargIn->vt == VT_BOOL))
            {
                _fInvokeDefBrowserOnNewWindow = pvarargIn->boolVal ? TRUE : FALSE;
                hres = S_OK;
            }
            else
            {
                hres = E_INVALIDARG;
            }
            break;

        case IECMDID_GET_INVOKE_DEFAULT_BROWSER_ON_NEW_WINDOW:
            if ((NULL != pvarargOut) && (pvarargOut->vt == VT_EMPTY))
            {
                pvarargOut->vt = VT_BOOL;
                pvarargOut->boolVal = _fInvokeDefBrowserOnNewWindow ? TRUE : FALSE;
                hres = S_OK;
            }
            else
            {
                hres = E_INVALIDARG;
            }
            break;
            
        case IECMDID_BEFORENAVIGATE_GETSHELLBROWSE:
            {
                // true if pending navigate is NOT a web navigation.
                if (pvarargOut && _pidlBeforeNavigateEvent)
                {
                    DWORD dwAttributes = SFGAO_FOLDER;
                    hres = IEGetAttributesOf(_pidlBeforeNavigateEvent, &dwAttributes);

                    V_VT(pvarargOut) = VT_BOOL;
                    V_BOOL(pvarargOut) = SUCCEEDED(hres) && (dwAttributes & SFGAO_FOLDER) ?
                         VARIANT_TRUE : VARIANT_FALSE;
                    hres = S_OK;
                }
            }
            break;


        case IECMDID_BEFORENAVIGATE_DOEXTERNALBROWSE:
            {
                if (_pidlBeforeNavigateEvent)
                {                  
                    hres = _psbOuter->BrowseObject(_pidlBeforeNavigateEvent, SBSP_ABSOLUTE | SBSP_NEWBROWSER);
                }
            }
            break;

        case IECMDID_BEFORENAVIGATE_GETIDLIST:
            {
                if (pvarargOut && _pidlBeforeNavigateEvent)
                {                  
                    hres = InitVariantFromIDList(pvarargOut, _pidlBeforeNavigateEvent);
                }
            }
            break;

        default:
            hres = OLECMDERR_E_NOTSUPPORTED;
            break;
        }
    }
    else
    {
        hres = OLECMDERR_E_UNKNOWNGROUP;
    }
    return hres;
}

LPITEMIDLIST
CBaseBrowser2::PidlFromUrl(BSTR bstrUrl)
{
    LPITEMIDLIST pidl = NULL;

    ASSERT(bstrUrl);

    IEParseDisplayNameWithBCW(CP_ACP, bstrUrl, NULL, &pidl);

    // IEParseDisplayNameWithBCW will return a null pidl if 
    // the URL has any kind of fragment identifier at the
    // end - #, ? =, etc.
    //    
    if (!pidl) 
    {
        TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];
        DWORD cchBuf = ARRAYSIZE(szPath);

        // If it's a FILE URL, convert it to a path.
        //
        if (IsFileUrlW(bstrUrl) && SUCCEEDED(PathCreateFromUrl(bstrUrl, szPath, &cchBuf, 0)))
        {
            // That worked, we are done because our buffer is now full.
        }
        else        
        {
            // We now need to copy to the buffer and we assume it's a path.
            //
            StrCpyN(szPath, bstrUrl, ARRAYSIZE(szPath));
        }

        pidl = SHSimpleIDListFromPath(szPath);
    }

    return pidl;
}

BSTR
CBaseBrowser2::GetHTMLWindowUrl(IHTMLWindow2 * pHTMLWindow)
{
    BSTR bstrUrl = NULL;

    IHTMLPrivateWindow * pPrivateWindow;
    HRESULT hr = pHTMLWindow->QueryInterface(IID_PPV_ARG(IHTMLPrivateWindow, &pPrivateWindow));
    if (SUCCEEDED(hr))
    {
        pPrivateWindow->GetAddressBarUrl(&bstrUrl);
        pPrivateWindow->Release();
    }

    return bstrUrl;
}

LPITEMIDLIST
CBaseBrowser2::_GetPidlForDisplay(BSTR bstrUrl, BOOL * pfIsErrorUrl /* = NULL */)
{
    BOOL fIsErrorUrl  = FALSE;
    LPITEMIDLIST pidl = NULL;

    if (bstrUrl)
    {
        fIsErrorUrl = ::IsErrorUrl(bstrUrl);
        if (!fIsErrorUrl)
        {
            pidl = PidlFromUrl(bstrUrl);
        }
        else
        {
            // Only strip the anchor fragment if it's not JAVASCRIPT: or VBSCRIPT:, because a # could not an
            // anchor but a string to be evaluated by a script engine like #00ff00 for an RGB color.
            //
            int nScheme = GetUrlSchemeW(bstrUrl);      
            if (nScheme != URL_SCHEME_JAVASCRIPT && nScheme != URL_SCHEME_VBSCRIPT)
            {
                //  Locate local anchor fragment if possible
                //
                LPWSTR pszFragment = StrChr(bstrUrl, L'#');

                // It is possible to have a fragment identifier 
                // with no corresponding fragment.
                //
                if (pszFragment && lstrlen(pszFragment) > 1)
                {
                    BSTR bstrTemp = SysAllocString(pszFragment+1);
                    if (bstrTemp)
                    {
                        pidl = PidlFromUrl(bstrTemp);
                        SysFreeString(bstrTemp);
                    }
                }
            }
        }
    }

    if (pfIsErrorUrl)
        *pfIsErrorUrl = fIsErrorUrl;

    return pidl;
}

HRESULT CBaseBrowser2::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName,
        ULONG *pchEaten, IMoniker **ppmkOut)
{

    TraceMsg(0, "sdv TR ::ParseDisplayName called");
    *ppmkOut = NULL;
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::EnumObjects( DWORD grfFlags, IEnumUnknown **ppenum)
{
    TraceMsg(0, "sdv TR ::EnumObjects called");
    *ppenum = NULL;
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::LockContainer( BOOL fLock)
{
    TraceMsg(0, "sdv TR ::LockContainer called");
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::SetTitle(IShellView* psv, LPCWSTR lpszName)
{
    LPWSTR *ppszName = NULL;
    BOOL fFireEvent = FALSE;
    LPITEMIDLIST pidl;

    // We need to forward title changes on to the automation interface.
    // But since title changes can technically occur at any time we need
    // to distinguish between current and pending title changes and only
    // pass on the current title change now. We'll pass on the pending
    // title change at NavigateComplete time. (This also lets us identify
    // when we navigate to non-SetTitle object (such as the shell) and
    // simulate a TitleChange event.)
    //
    // Since the DocObjectHost needs to retrieve the title later, we
    // hold onto the current view's title change so they don't have to.
    //

    // Figure out which object is changing.
    //
    if (IsSameObject(_bbd._psv, psv))
    {
        ppszName = &_bbd._pszTitleCur;
        pidl = _bbd._pidlCur;
        fFireEvent = TRUE;
    }
    else if (EVAL(IsSameObject(_bbd._psvPending, psv) || !_bbd._psvPending)) // no pending probably means we're in _MayPlayTransition
    {
        ppszName = &_bbd._pszTitlePending;
        pidl = _bbd._pidlPending;
        // If we have no current guy, might as well set the title early
        fFireEvent = !_bbd._psv;
    }
    else
    {
        ppszName = NULL;
        pidl = NULL;        // init pidl to suppress bogus C4701 warning
    }

    if (ppszName)
    {
        UINT cchLen = lstrlenW(lpszName) + 1; // +1 for NULL
        UINT cbAlloc;

        // For some reason we cap the length of this string. We can't cap
        // less than MAX_PATH because we need to handle filesys names.
        //
        if (cchLen > MAX_PATH)
            cchLen = MAX_PATH;

        // We want to allocate at least a medium size string because
        // many web pages script the title one character at a time.
        //
#define MIN_TITLE_ALLOC  64
        if (cchLen < MIN_TITLE_ALLOC)
            cbAlloc = MIN_TITLE_ALLOC * SIZEOF(*lpszName);
        else
            cbAlloc = cchLen * SIZEOF(*lpszName);
#undef  MIN_TITLE_ALLOC

        // Do we need to allocate?
        if (!(*ppszName) || LocalSize((HLOCAL)(*ppszName)) < cbAlloc)
        {
            // Free up Old Title
            if(*ppszName)
                LocalFree((void *)(*ppszName));
                
            *ppszName = (LPWSTR)LocalAlloc(LPTR, cbAlloc);
        }

        if (*ppszName)
        {
            StrCpyNW(*ppszName, lpszName, cchLen);

            if (fFireEvent)
            {
                DWORD dwOptions;

                FireEvent_DoInvokeStringW(_bbd._pautoEDS, DISPID_TITLECHANGE, *ppszName);

                // If this is a desktop component, try to update the friendly name if necessary.
                if (!_fCheckedDesktopComponentName)
                {
                    _fCheckedDesktopComponentName = TRUE;
                    if (SUCCEEDED(GetTopFrameOptions(_pspOuter, &dwOptions)) && (dwOptions & FRAMEOPTIONS_DESKTOP))
                    {
                        WCHAR wszPath[MAX_URL_STRING];
                        if (SUCCEEDED(::IEGetDisplayName(pidl, wszPath, SHGDN_FORPARSING)))
                        {
                            UpdateDesktopComponentName(wszPath, lpszName);
                        }
                    }
                }
            }
        }
    }

    return NOERROR;
}
HRESULT CBaseBrowser2::GetTitle(IShellView* psv, LPWSTR pszName, DWORD cchName)
{
    LPWSTR psz;

    if (!psv || IsSameObject(_bbd._psv, psv))
    {
        psz = _bbd._pszTitleCur;
    }
    else if (EVAL(IsSameObject(_bbd._psvPending, psv) || !_bbd._psvPending))
    {
        psz = _bbd._pszTitlePending;
    }
    else
    {
        psz = NULL;
    }

    if (psz)
    {
        StrCpyNW(pszName, psz, cchName);
        return(S_OK);
    }
    else
    {
        *pszName = 0;
        return(E_FAIL);
    }
}

HRESULT CBaseBrowser2::GetParentSite(struct IOleInPlaceSite** ppipsite)
{
    *ppipsite = NULL;
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::GetOleObject(struct IOleObject** ppobjv)
{
    *ppobjv = NULL;
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::NotifyRedirect(IShellView * psv, LPCITEMIDLIST pidlNew, BOOL *pfDidBrowse)
{
    HRESULT hres = E_FAIL;
    
    if (pfDidBrowse)
        *pfDidBrowse = FALSE;

    if (IsSameObject(psv, _bbd._psv) ||
        IsSameObject(psv, _bbd._psvPending))
    {
        hres = _pbsOuter->_TryShell2Rename(psv, pidlNew);
        if (FAILED(hres)) 
        {
            // if we weren't able to just swap it, we've got to browse to it
            // but pass redirect so that we don't add a navigation stack item
            //
            // NOTE: the above comment is a bit old since we don't pass
            // redirect here. If we ever start passing redirect here,
            // we'll confuse ISVs relying on the NavigateComplete event
            // exactly mirroring when navigations enter the navigation stack.
            //
            hres = _psbOuter->BrowseObject(pidlNew, SBSP_WRITENOHISTORY | SBSP_SAMEBROWSER);

            if(pfDidBrowse)
                *pfDidBrowse = TRUE;
        }
    }

    return hres;
}

HRESULT CBaseBrowser2::SetFlags(DWORD dwFlags, DWORD dwFlagMask)
{
    if (dwFlagMask & BSF_REGISTERASDROPTARGET)
    {
        _fNoDragDrop = (!(dwFlags & BSF_REGISTERASDROPTARGET)) ? TRUE : FALSE;

        if (!_fNoDragDrop)
            _RegisterAsDropTarget();
        else
            _UnregisterAsDropTarget();
    }
    
    if (dwFlagMask & BSF_DONTSHOWNAVCANCELPAGE)
    {
        _fDontShowNavCancelPage = !!(dwFlags & BSF_DONTSHOWNAVCANCELPAGE);
    }

    if (dwFlagMask & BSF_HTMLNAVCANCELED)
    {
        _fHtmlNavCanceled = !!(dwFlags & BSF_HTMLNAVCANCELED);
    }

    return S_OK;
}

HRESULT CBaseBrowser2::GetFlags(DWORD *pdwFlags)
{
    DWORD dwFlags = 0;

    if (!_fNoDragDrop)
        dwFlags |= BSF_REGISTERASDROPTARGET;
        
    if (_fTopBrowser)
        dwFlags |= BSF_TOPBROWSER;

    if (_grfHLNFPending & HLNF_CREATENOHISTORY)
        dwFlags |= BSF_NAVNOHISTORY;

    if (_fHtmlNavCanceled)
        dwFlags |= BSF_HTMLNAVCANCELED;
    
    if (_dwDocFlags & DOCFLAG_SETNAVIGATABLECODEPAGE)
        dwFlags |= BSF_SETNAVIGATABLECODEPAGE;

    if (_dwDocFlags & DOCFLAG_NAVIGATEFROMDOC)
        dwFlags |= BSF_DELEGATEDNAVIGATION;

    *pdwFlags = dwFlags;

    return S_OK;
}


HRESULT CBaseBrowser2::UpdateWindowList(void)
{
    // code used to assert, but in WebBrowserOC cases we can get here.
    return E_UNEXPECTED;
}

STDMETHODIMP CBaseBrowser2::IsControlWindowShown(UINT id, BOOL *pfShown)
{
    if (pfShown)
        *pfShown = FALSE;
    return E_NOTIMPL;
}

STDMETHODIMP CBaseBrowser2::ShowControlWindow(UINT id, BOOL fShow)
{
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags)
{
    return ::IEGetDisplayName(pidl, pwszName, uFlags);
}

HRESULT CBaseBrowser2::IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST * ppidlOut)
{
    HRESULT hr;
    IBindCtx * pbc = NULL;    
    WCHAR wzParsedUrl[MAX_URL_STRING];

    //
    // if we can find a search context living in a host somewhere,
    // then we need to pass that into ParseUrlFromOutsideSource
    // because it'll use it to customize the behavior of
    // the search hooks if a search ends up happening
    //

    ISearchContext *  pSC = NULL;
    QueryService(SID_STopWindow, IID_PPV_ARG(ISearchContext, &pSC));

    //
    // NOTE: This URL came from the user, so we need to clean it up.
    //       If the user entered "yahoo.com" or "Search Get Rich Quick",
    //       it will be turned into a search URL by ParseURLFromOutsideSourceW().
    //

    DWORD cchParsedUrl = ARRAYSIZE(wzParsedUrl);
    if (!ParseURLFromOutsideSourceWithContextW(pwszPath, wzParsedUrl, &cchParsedUrl, NULL, pSC))
    {
        StrCpyN(wzParsedUrl, pwszPath, ARRAYSIZE(wzParsedUrl));
    } 

    if (pSC != NULL)
    {
        pSC->Release();
    }

    // This is currently used for FTP, so we only do it for FTP for perf reasons.
    if (URL_SCHEME_FTP == GetUrlSchemeW(wzParsedUrl))
        pbc = CreateBindCtxForUI(SAFECAST(this, IOleContainer *));  // We really want to cast to (IUnknown *) but that's ambiguous.
    
    hr = IEParseDisplayNameWithBCW(uiCP, wzParsedUrl, pbc, ppidlOut);
    ATOMICRELEASE(pbc);

    return hr;
}

HRESULT _DisplayParseError(HWND hwnd, HRESULT hres, LPCWSTR pwszPath)
{
    if (FAILED(hres)
        && hres != E_OUTOFMEMORY
        && hres != HRESULT_FROM_WIN32(ERROR_CANCELLED))
    {
        TCHAR szPath[MAX_URL_STRING];
        SHUnicodeToTChar(pwszPath, szPath, ARRAYSIZE(szPath));
        MLShellMessageBox(hwnd,
                        MAKEINTRESOURCE(IDS_ERROR_GOTO),
                        MAKEINTRESOURCE(IDS_TITLE),
                        MB_OK | MB_SETFOREGROUND | MB_ICONSTOP,
                        szPath);

        hres = HRESULT_FROM_WIN32(ERROR_CANCELLED);
    }

    return hres;
}

HRESULT CBaseBrowser2::DisplayParseError(HRESULT hres, LPCWSTR pwszPath)
{
    return _DisplayParseError(_bbd._hwnd, hres, pwszPath);
}

HRESULT CBaseBrowser2::_CheckZoneCrossing(LPCITEMIDLIST pidl)
{
    if (!(_dwDocFlags & DOCFLAG_NAVIGATEFROMDOC))
    {
        return _pbsOuter->v_CheckZoneCrossing(pidl);
    }

    return S_OK;
}


// if in global offline mode and this item requires net access and it is
// not in the cache put up UI to go online.
//
// returns:
//      S_OK        URL is ready to be accessed
//      E_ABORT     user canceled the UI

HRESULT CBaseBrowser2::_CheckInCacheIfOffline(LPCITEMIDLIST pidl, BOOL fIsAPost)
{
    HRESULT hr = S_OK;      // assume it is
    VARIANT_BOOL fFrameIsSilent;
    VARIANT_BOOL fFrameHasAmbientOfflineMode;

    EVAL(SUCCEEDED(_bbd._pautoWB2->get_Silent(&fFrameHasAmbientOfflineMode)));    // should always work

    EVAL(SUCCEEDED(_bbd._pautoWB2->get_Offline(&fFrameIsSilent)));   
    if ((fFrameIsSilent == VARIANT_FALSE) &&
        (fFrameHasAmbientOfflineMode == VARIANT_FALSE)&&
        pidl && (pidl != PIDL_NOTHING) && (pidl != PIDL_LOCALHISTORY) && 
        IsBrowserFrameOptionsPidlSet(pidl, BFO_USE_IE_OFFLINE_SUPPORT) && 
        IsGlobalOffline()) 
    {
        TCHAR szURL[MAX_URL_STRING];
        EVAL(SUCCEEDED(::IEGetNameAndFlags(pidl, SHGDN_FORPARSING, szURL, SIZECHARS(szURL), NULL)));

        if (UrlHitsNet(szURL) && ((!UrlIsMappedOrInCache(szURL)) || fIsAPost))
        {
            // UI to allow user to go on-line
            HWND hParentWnd = NULL; // init to suppress bogus C4701 warning

            hr = E_FAIL;
            if(!_fTopBrowser)
            {
               IOleWindow *pOleWindow;
               hr = _pspOuter->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IOleWindow, &pOleWindow));
               if(SUCCEEDED(hr))
               { 
                    ASSERT(pOleWindow);
                    hr = pOleWindow->GetWindow(&hParentWnd);
                    pOleWindow->Release();
               }
            }
            
            if (S_OK != hr)
            {
                hr = S_OK;
                hParentWnd = _bbd._hwnd;
            }


            _psbOuter->EnableModelessSB(FALSE);
            if (InternetGoOnline(szURL, hParentWnd, FALSE))
            {
                // Tell all browser windows to update their title and status pane
                SendShellIEBroadcastMessage(WM_WININICHANGE,0,0, 1000); 
            }    
            else
                hr = E_ABORT;   // user abort case...

            _psbOuter->EnableModelessSB(TRUE);
        }
    }

    return hr;
}


// This function exists to prevent us from using the stack space too long.
// We will use it here and then free it when we return.
HRESULT CBaseBrowser2::_ReplaceWithGoHome(LPCITEMIDLIST * ppidl, LPITEMIDLIST * ppidlFree)
{
    TCHAR szHome[MAX_URL_STRING];
    HRESULT hres = _GetStdLocation(szHome, ARRAYSIZE(szHome), DVIDM_GOHOME);

    if (SUCCEEDED(hres))
    {
        hres = IECreateFromPath(szHome, ppidlFree);
        if (SUCCEEDED(hres))
        {
            *ppidl = *ppidlFree;
        }
    }

    return hres;
}

// this does all the preliminary checking of whether we can navigate to pidl or not.
// then if all is ok, we do the navigate with CreateNewShellViewPidl
HRESULT CBaseBrowser2::_NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD fSBSP)
{
    HRESULT hres;
    BOOL fCanceledDueToOffline = FALSE;
    BOOL fIsAPost = FALSE;  
    LPITEMIDLIST pidlFree = NULL;

    //
    // If we are processing a modal dialog, don't process it.
    //
    // NOTES: Checking _cRefCannotNavigate is supposed to be enough, but
    //  since we are dealing with random ActiveX objects, we'd better be
    //  robust. That's why we check IsWindowEnabled as well.
    //
    if ((S_OK ==_DisableModeless()) || !IsWindowEnabled(_bbd._hwnd)) 
    {
        TraceMsg(DM_ENABLEMODELESS, "CSB::_NavigateToPidl returning ERROR_BUSY");
        hres = HRESULT_FROM_WIN32(ERROR_BUSY);
        goto Done;
    }

    TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("_NavigateToPidl called"), pidl, grfHLNF);
    // used to be we would pull a NULL out of the 
    // the TravelLog, but i dont think that happens anymore
    ASSERT(pidl);  // Get ZEKEL

    // Sometimes we are navigated to the INTERNET shell folder
    // if this is the case, we really want to goto the Start Page.
    // This case only happens if you select "Internet Explorer" from the 
    // Folder Explorer Band.
    if (IsBrowserFrameOptionsPidlSet(pidl, BFO_SUBSTITUE_INTERNET_START_PAGE))
    {
        hres = _ReplaceWithGoHome(&pidl, &pidlFree);
        if (FAILED(hres))
            goto Done;
    }

    // We should only fire the BeforeNavigate event
    // if the document is not going to fire it.
    // We know that the document will fire it if
    // the document didn't call Navigate, the document
    // knows how to navigate and the document isn't hyperlinking.
    //
    if (!(_dwDocFlags & DOCFLAG_NAVIGATEFROMDOC))
    {
        hres = _FireBeforeNavigateEvent(pidl, &fIsAPost);
        if (hres == E_ABORT)
            goto Done;   // event handler told us to cancel
    }

    // if we can't go here (?), cancel the navigation
    hres = _CheckZoneCrossing(pidl);
    if (hres != S_OK)
        goto Done;
        
    TraceMsg(DM_NAV, "ief NAV::%s %x %x",TEXT("_CreateNewShellViewPidl called"), pidl, grfHLNF);

    //
    // Now that we are actually navigating...
    //

    // tell the frame to cancel the current navigation
    // and tell it about history navigate options as it will not be getting it
    // from subsequent call to Navigate
    //
    if (_bbd._phlf) 
    {
        _bbd._phlf->Navigate(grfHLNF&(SHHLNF_WRITENOHISTORY|SHHLNF_NOAUTOSELECT), NULL, NULL, NULL);
    }

    hres = _CheckInCacheIfOffline(pidl, fIsAPost);
    if (hres != S_OK) 
    {
        fCanceledDueToOffline = TRUE;
        goto Done;
    }


    //
    //  if we goto the current page, we still do a full navigate
    //  but we dont want to create a new entry.
    //
    //  **EXCEPTIONS**
    //  if this was a generated page, ie Trident did doc.writes(),
    //  we need to always create a travel entry, because trident 
    //  can rename the pidl, but it wont actually be that page.
    //
    //  if this was a post then we need to create a travelentry.
    //  however if it was a travel back/fore, it will already have
    //  set the the bit, so we still wont create a new entry.
    //
    //
    //  NOTE: this is similar to a refresh, in that it reparses
    //  the entire page, but creates no travel entry.
    //
    if (   !_fDontAddTravelEntry                 // If the flag is already set, short circuit the rest
        && !fIsAPost                             // ...and not a Post
        && !_fGeneratedPage                      // ...and not a Generated Page
        && !(grfHLNF & HLNF_CREATENOHISTORY)     // ...and the CREATENOHISTORY flag is NOT set
        && pidl                                  // ...and we have a pidl to navigate to
        && _bbd._pidlCur                         // ...as well as a current pidl
        && ILIsEqual(pidl, _bbd._pidlCur)        // ...and the pidls are equal
        )
        _fDontAddTravelEntry = TRUE;             // Then set the DontAddTravelEntry flag.

    TraceMsg(TF_TRAVELLOG, "CBB:_NavToPidl() _fDontAddTravelEntry = %d", _fDontAddTravelEntry);

    _fGeneratedPage = FALSE;

    hres = _CreateNewShellViewPidl(pidl, grfHLNF, fSBSP);

    _dwDocFlags &= ~(DOCFLAG_NAVIGATEFROMDOC | DOCFLAG_SETNAVIGATABLECODEPAGE);

    if (SUCCEEDED(hres))
    {
        ATOMICRELEASE(_pHTMLDocument);
    }

Done:
    if (FAILED(hres))
    {
        TraceMsg(DM_WARNING, "CSB::_NavigateToPidl _CreateNewShellViewPidl failed %x", hres);

        // On failure we won't hit _ActivatePendingView
        OnReadyStateChange(NULL, READYSTATE_COMPLETE);

        //  if this was navigation via ITravelLog, 
        //  this will revert us to the original position
        if (_fDontAddTravelEntry)
        {
            ITravelLog *ptl;
        
            if(SUCCEEDED(GetTravelLog(&ptl)))
            {
                ptl->Revert();
                ptl->Release();
            }
            _fDontAddTravelEntry = FALSE;
            ASSERT(!_fIsLocalAnchor);

            ATOMICRELEASE(_poleHistory);
            ATOMICRELEASE(_pbcHistory);
            ATOMICRELEASE(_pstmHistory);
        }
        if (_pbsOuter)
            _pbsOuter->UpdateBackForwardState();

        //  we failed and have nothing to show for it...
        if (!_bbd._pidlCur && !_fNavigatedToBlank)
        {
            TCHAR szResURL[MAX_URL_STRING];

            if (fCanceledDueToOffline)
            {
                hres = MLBuildResURLWrap(TEXT("shdoclc.dll"),
                                         HINST_THISDLL,
                                         ML_CROSSCODEPAGE,
                                         TEXT("offcancl.htm"),
                                         szResURL,
                                         ARRAYSIZE(szResURL),
                                         TEXT("shdocvw.dll"));
                if (SUCCEEDED(hres))
                {
                    _ShowBlankPage(szResURL, pidl);
                }
            }
            else
            {
                // NT #274562: We only want to navigate to the
                //    about:NavigationCancelled page if it wasn't
                //    a navigation to file path. (UNC or Drive).
                //    The main reason for this is that if the user
                //    enters "\\unc\share" into Start->Run and
                //    the window can't successfully navigate to the
                //    share because permissions don't allow it, we
                //    want to close the window after the user hits
                //    [Cancel] in the [Retry][Cancel] dialog.  This
                //    is to prevent the shell from appearing to have
                //    shell integrated bugs and to be compatible with
                //    the old shell.
                if ( IsBrowserFrameOptionsPidlSet(_bbd._pidlCur, BFO_SHOW_NAVIGATION_CANCELLED ) )
                {
                    hres = MLBuildResURLWrap(TEXT("shdoclc.dll"),
                                             HINST_THISDLL,
                                             ML_CROSSCODEPAGE,
                                             TEXT("navcancl.htm"),
                                             szResURL,
                                             ARRAYSIZE(szResURL),
                                             TEXT("shdocvw.dll"));
                    if (SUCCEEDED(hres))
                    {
                        _ShowBlankPage(szResURL, pidl);
                    }
                }
            }
        }
    }

    ILFree(pidlFree);
    
    return hres;
}

HRESULT CBaseBrowser2::OnReadyStateChange(IShellView* psvSource, DWORD dwReadyState)
{
    BOOL fChange = FALSE;

    if (psvSource)
    {
        if (IsSameObject(psvSource, _bbd._psv))
        {
            TraceMsg(TF_SHDNAVIGATE, "basesb(%x)::OnReadyStateChange(Current, %d)", this, dwReadyState);
            fChange = (_dwReadyStateCur != dwReadyState);
            _dwReadyStateCur = dwReadyState;
            if ((READYSTATE_COMPLETE == dwReadyState) && !_fReleasingShellView)
                _Exec_psbMixedZone();
        }
        else if (IsSameObject(psvSource, _bbd._psvPending))
        {
            TraceMsg(TF_SHDNAVIGATE, "basesb(%x)::OnReadyStateChange(Pending, %d)", this, dwReadyState);
            fChange = (_dwReadyStatePending != dwReadyState);
            _dwReadyStatePending = dwReadyState;
        }
        else if (!_bbd._psvPending)
        {
            // Assume psvSource != _bbd._psv && NULL==_bbd._psvPending
            // means that _SwitchActivationNow is in the middle
            // of _MayPlayTransition's message loop and the
            // _bbd._psvPending dude is updating us.
            //
            // NOTE: We don't fire the event because get_ReadyState
            // can't figure this out. We know we will eventually
            // fire the event because CBaseBrowser2 will go to _COMPLETE
            // after _SwitchActivationNow.
            //
            TraceMsg(TF_SHDNAVIGATE, "basesb(%x)::OnReadyStateChange(ASSUMED Pending, %d)", this, dwReadyState);
            _dwReadyStatePending = dwReadyState;
       }
    }
    else
    {
        // We use this function when our own simulated
        // ReadyState changes
        //
        TraceMsg(TF_SHDNAVIGATE, "basesb(%x)::OnReadyStateChange(Self, %d)", this, dwReadyState);
        fChange = (_dwReadyState != dwReadyState);
        _dwReadyState = dwReadyState;
    }

    // No sense in firing events if nothing actually changed...
    //
    if (fChange && _bbd._pautoEDS)
    {
        DWORD dw;

        IUnknown_CPContainerOnChanged(_pauto, DISPID_READYSTATE);

        // if we at Complete, fire the event
        get_ReadyState(&dw);
        if (READYSTATE_COMPLETE == dw)
        {
            if (  !(_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)
               || !_bbd._fIsViewMSHTML)
            {
                FireEvent_DocumentComplete(_bbd._pautoEDS, _bbd._pautoWB2, _bbd._pidlCur);
            }

            // If we hit this, we have not picked up the history object we created.
            //
            AssertMsg(_fDontAddTravelEntry || !_poleHistory, TEXT("CBB::OnDocComplete: nobody picked up _poleHistory"));

            if (g_dwProfileCAP & 0x00080000) 
            {
                StopCAP();
            }
            
            ATOMICRELEASE(_pphHistory);
        }
    }

    return S_OK;
}

HRESULT CBaseBrowser2::get_ReadyState(DWORD * pdwReadyState)
{
    DWORD dw = _dwReadyState;

    if (_bbd._psvPending && _dwReadyStatePending < dw)
    {
        dw = _dwReadyStatePending;
    }

    if (_bbd._psv && _dwReadyStateCur < dw)
    {
        dw = _dwReadyStateCur;
    }

    *pdwReadyState = dw;

    return S_OK;
}

HRESULT CBaseBrowser2::_updateNavigationUI()
{
    if (_fNavigate || _fDescendentNavigate)
    {
        SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
        if (!_fDownloadSet)
        {
            FireEvent_DoInvokeDispid(_bbd._pautoEDS, DISPID_DOWNLOADBEGIN);
            _fDownloadSet = TRUE;
        }   
    }
    else
    {
        if (_fDownloadSet)
        {
            FireEvent_DoInvokeDispid(_bbd._pautoEDS, DISPID_DOWNLOADCOMPLETE);
            _fDownloadSet = FALSE;
        }
        SetCursor(LoadCursor(NULL, IDC_ARROW));            
    }

    return S_OK;
}

HRESULT CBaseBrowser2::SetNavigateState(BNSTATE bnstate)
{
    switch (bnstate) 
    {
    case BNS_BEGIN_NAVIGATE:
    case BNS_NAVIGATE:
        _fNavigate = TRUE;
        _updateNavigationUI();
        break;

    case BNS_NORMAL:
        _fNavigate = FALSE;
        _updateNavigationUI();
        break;
    }
    return S_OK;
}


HRESULT CBaseBrowser2::GetNavigateState(BNSTATE *pbnstate)
{
    // Return Navigate if we are processing a navigation or if
    // we are processing a modal dialog.
    //
    // NOTES: Checking _cRefCannotNavigate is supposed to be enough, but
    //  since we are dealing with random ActiveX objects, we'd better be
    //  robust. That's why we check IsWindowEnabled as well.
    //
    *pbnstate = (_fNavigate || (S_OK ==_DisableModeless()) || _fDescendentNavigate ||
            !IsWindowEnabled(_bbd._hwnd)) ? BNS_NAVIGATE : BNS_NORMAL;
    return S_OK;
}

HRESULT CBaseBrowser2::UpdateBackForwardState(void)
{
    if (_fTopBrowser) 
    {
        _UpdateBackForwardState();
    } 
    else 
    {
        // sigh, BrowserBand now makes this fire
        //ASSERT(_fTopBrowser);
        IBrowserService *pbs = NULL;
        TraceMsg(TF_SHDNAVIGATE, "cbb.ohlfn: !_fTopBrowser (BrowserBand?)");
        if (SUCCEEDED(_pspOuter->QueryService(SID_STopFrameBrowser, IID_PPV_ARG(IBrowserService, &pbs)))) 
        {
            BOOL fTopFrameBrowser = IsSameObject(pbs, SAFECAST(this, IShellBrowser *));
            if (!fTopFrameBrowser)
                pbs->UpdateBackForwardState();
            else 
                _UpdateBackForwardState();
            pbs->Release();        
        }
    }
    return S_OK;
}


HRESULT CBaseBrowser2::QueryService(REFGUID guidService, REFIID riid, void **ppv)
{
    HRESULT hr;

    *ppv = NULL;

    //
    // NOTES: Notice that CBaseBrowser2 directly expose the automation
    //  service object via QueryService. CWebBrowserSB will appropriately
    //  dispatch those. See comments on CWebBrowserSB::QueryService for
    //  detail. (SatoNa)
    //
    if (IsEqualGUID(guidService, SID_SWebBrowserApp) || 
        IsEqualGUID(guidService, SID_SContainerDispatch) || 
        IsEqualGUID(guidService, IID_IExpDispSupport))
    {
        hr = _bbd._pautoSS->QueryInterface(riid, ppv);
    }
    else  if (IsEqualGUID(guidService, SID_SHlinkFrame) || 
              IsEqualGUID(guidService, IID_ITargetFrame2) || 
              IsEqualGUID(guidService, IID_ITargetFrame)) 
    {
        hr = _ptfrm->QueryInterface(riid, ppv);
    }
    else if (IsEqualGUID(guidService, SID_STopLevelBrowser) || 
             IsEqualGUID(guidService, SID_STopFrameBrowser) ||
             IsEqualGUID(guidService, SID_STopWindow) ||
             IsEqualGUID(guidService, SID_SProfferService))
    {
        if (IsEqualGUID(riid, IID_IUrlHistoryStg))
        {
            ASSERT(_fTopBrowser);

            if (!_pIUrlHistoryStg)
            {
                // create this object the first time it's asked for
                CoCreateInstance(CLSID_CUrlHistory, NULL, CLSCTX_INPROC_SERVER,
                        IID_PPV_ARG(IUrlHistoryStg, &_pIUrlHistoryStg));
            }

            if (_pIUrlHistoryStg)
                hr = _pIUrlHistoryStg->QueryInterface(riid, ppv);
            else
                hr = E_NOINTERFACE;
        }
        else if (IsEqualGUID(riid, IID_IToolbarExt))
        {
            // This code should all migrate to a helper object after IE5B2. So this
            // should be temporary (stevepro).
            if (!_pToolbarExt)
            {
                IUnknown* punk;
                if (SUCCEEDED(CBrowserExtension_CreateInstance(NULL, &punk, NULL)))
                {
                    IUnknown_SetSite(punk, _psbOuter);
                    punk->QueryInterface(IID_PPV_ARG(IToolbarExt, &_pToolbarExt));
                    punk->Release();
                }
            }

            if (_pToolbarExt)
                hr = _pToolbarExt->QueryInterface(riid, ppv);
            else
                hr = E_NOINTERFACE;
        }
        else
            hr = QueryInterface(riid, ppv);
    }
    else if (IsEqualGUID(guidService, SID_SUrlHistory)) 
    {
        if (!_pIUrlHistoryStg)
        {
            // Asking for it creates a copy in _pIUrlHistoryStg
            IUrlHistoryStg *puhs;
            if (SUCCEEDED(_pspOuter->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IUrlHistoryStg, &puhs))))
            {
                if (!_pIUrlHistoryStg)
                    _pIUrlHistoryStg = puhs;
                else
                    puhs->Release();
            }
        }
        
        if (_pIUrlHistoryStg)
            hr = _pIUrlHistoryStg->QueryInterface(riid, ppv);
        else
            hr = E_NOINTERFACE;
    }
    else if (IsEqualGUID(guidService, SID_SShellBrowser) || 
             IsEqualGUID(guidService, SID_SVersionHost)) 
    {
        if (IsEqualIID(riid, IID_IHlinkFrame)) 
        {
            // HACK: MSHTML uses IID_IShellBrowser instead of SID_SHlinkFrame
            hr = _pspOuter->QueryService(SID_SHlinkFrame, riid, ppv);
        } 
        else if (IsEqualIID(riid, IID_IBindCtx) && _bbd._phlf) 
        {
            // HACK ALERT: Notice that we are using QueryService to the
            //  other direction here. We must make it absolutely sure
            //  that we'll never infinitly QueryService each other.
            hr = IUnknown_QueryService(_bbd._phlf, IID_IHlinkFrame, riid, ppv);
        } 
        else 
        {
            hr = QueryInterface(riid, ppv);
        }
    }
    else if (IsEqualGUID(guidService, SID_SOmWindow))
    {
        // HACK ALERT: Notice that we are using QueryService to the
        //  other direction here. We must make it absolutely sure
        //  that we'll never infinitly QueryService each other.
        hr = IUnknown_QueryService(_ptfrm, SID_SOmWindow, riid, ppv);
    }
    else if (IsEqualGUID(guidService, IID_IElementNamespaceTable) && _bbd._psv)
    {
        hr = IUnknown_QueryService(_bbd._psv, IID_IElementNamespaceTable, riid, ppv);
    }
    else if (IsEqualGUID(guidService, SID_STravelLogCursor))
    {
        // exposed travel log object
        if (!_pITravelLogStg)
        {    
            // create this object the first time it's asked for
            ITravelLog * ptl;
            GetTravelLog(&ptl);

            ITravelLogEx *ptlx;
            if (ptl && SUCCEEDED(ptl->QueryInterface(IID_PPV_ARG(ITravelLogEx, &ptlx))))
            {
                hr = CreatePublicTravelLog(SAFECAST(this, IBrowserService *), ptlx, &_pITravelLogStg);
                ptlx->Release();
            }
            SAFERELEASE(ptl);
        }
        
        if (_pITravelLogStg)
        {         
            hr = _pITravelLogStg->QueryInterface(riid, ppv);
        }
    }
    else if (IsEqualGUID(riid,IID_IEnumPrivacyRecords))
    {
        IHTMLWindow2     * pIW  = NULL;
        IServiceProvider * pISP = NULL;

        hr = QueryService(IID_IHTMLWindow2, IID_PPV_ARG(IHTMLWindow2, &pIW));
        if (SUCCEEDED(hr))
        {
            hr = pIW->QueryInterface(IID_PPV_ARG(IServiceProvider, &pISP));
            if (SUCCEEDED(hr))
            {
                hr = pISP->QueryService(IID_IEnumPrivacyRecords, IID_IEnumPrivacyRecords, ppv);
                pISP->Release();
            }
            pIW->Release();
        }        
    }
    else
    {
        hr = IProfferServiceImpl::QueryService(guidService, riid, ppv);
    }

    ASSERT(SUCCEEDED(hr) ? *ppv != NULL : *ppv == NULL);  // COM rules

    return hr;
}


void CBaseBrowser2::OnDataChange(FORMATETC *, STGMEDIUM *)
{
}

void CBaseBrowser2::OnViewChange(DWORD dwAspect, LONG lindex)
{
    _ViewChange(dwAspect, lindex);
}

void CBaseBrowser2::OnRename(IMoniker *)
{
}

void CBaseBrowser2::OnSave()
{
}

void CBaseBrowser2::OnClose()
{
    _ViewChange(DVASPECT_CONTENT, -1);
}


// *** IDropTarget ***

// These methods are defined in shdocvw.cpp
extern DWORD CommonDragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt);


// Use the ShellView IDropTarget functions whenever they are implemented

// IDropTarget::DragEnter

HRESULT CBaseBrowser2::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
    if (_pdtView)
        return _pdtView->DragEnter(pdtobj, grfKeyState, ptl, pdwEffect);
    else 
    {
        if (_fNoDragDrop)
        {
            _dwDropEffect = DROPEFFECT_NONE;
        }
        else
        {
            _dwDropEffect = CommonDragEnter(pdtobj, grfKeyState, ptl);
        }
        *pdwEffect &= _dwDropEffect;
    }
    return S_OK;
}

// IDropTarget::DragOver

HRESULT CBaseBrowser2::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
    if (S_OK == _DisableModeless()) 
    {
        *pdwEffect = 0;
        return S_OK;
    }

    if (_pdtView)
        return _pdtView->DragOver(grfKeyState, ptl, pdwEffect);

    *pdwEffect &= _dwDropEffect;
    return S_OK;    
}


// IDropTarget::DragLeave

HRESULT CBaseBrowser2::DragLeave(void)
{
    if (_pdtView)
        return _pdtView->DragLeave();
    return S_OK;
}


// IDropTarget::DragDrop

HRESULT CBaseBrowser2::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    if (S_OK == _DisableModeless()) 
    {
        *pdwEffect = 0;
        return S_OK;
    }
    BOOL fNavigateDone = FALSE;
    HRESULT hr = E_FAIL;
    // If this is a shortcut - we want it to go via _NavIEShortcut
    // First check if it indeed a shortcut

    STGMEDIUM medium;

    if (_ptfrm && (DataObj_GetDataOfType(pdtobj, CF_HDROP, &medium)))
    {         
        WCHAR wszPath[MAX_PATH];

        if (DragQueryFileW((HDROP)medium.hGlobal, 0, wszPath, ARRAYSIZE(wszPath)))
        {
            LPWSTR pwszExtension = PathFindExtensionW(wszPath);
            // Check the extension to see if it is a .URL file

            if (0 == StrCmpIW(pwszExtension, L".url"))
            {
                // It is an internet shortcut 
                VARIANT varShortCutPath = {0};
                VARIANT varFlag = {0};

                varFlag.vt = VT_BOOL;
                varFlag.boolVal = VARIANT_TRUE;

                LBSTR::CString strPath( wszPath );

                varShortCutPath.vt = VT_BSTR;
                varShortCutPath.bstrVal = strPath;

                hr = IUnknown_Exec(_ptfrm, &CGID_Explorer, SBCMDID_IESHORTCUT, 0, &varShortCutPath, &varFlag);
                fNavigateDone = SUCCEEDED(hr);   
                if(fNavigateDone)
                {
                    DragLeave();
                }
            }
        }

        // must call ReleaseStgMediumHGLOBAL since DataObj_GetDataOfType added an extra GlobalLock
        ReleaseStgMediumHGLOBAL(NULL, &medium);
    }

    if (FALSE == fNavigateDone)
    {
        if (_pdtView)
        {
            hr = _pdtView->Drop(pdtobj, grfKeyState, pt, pdwEffect);
        }
        else 
        {
            LPITEMIDLIST pidlTarget;
            hr = SHPidlFromDataObject(pdtobj, &pidlTarget, NULL, 0);
            if (SUCCEEDED(hr))
            {
                ASSERT(pidlTarget);
                hr = _psbOuter->BrowseObject(pidlTarget, SBSP_SAMEBROWSER | SBSP_ABSOLUTE);
                ILFree(pidlTarget);
            }
        }
    }

    return hr;
}

HRESULT CBaseBrowser2::_FireBeforeNavigateEvent(LPCITEMIDLIST pidl, BOOL* pfIsPost)
{
    HRESULT hres = S_OK;

    IBindStatusCallback * pBindStatusCallback;
    LPTSTR pszHeaders = NULL;
    LPBYTE pPostData = NULL;
    DWORD cbPostData = 0;
    BOOL fCancelled=FALSE;
    STGMEDIUM stgPostData;
    BOOL fHavePostStg = FALSE;

    *pfIsPost = FALSE;
    
    // If this is the first BeforeNavigateEvent of a ViewLinkedWebOC we do not need to fire.
    // It is fired by the hosting Trident. Note that _fIsViewLinkedWebOC is only set by the 
    // host, so we need not worry about BeforeNavigateEvent not being fired for other in other
    // instances of the WebOC.

    if (_fIsViewLinkedWebOC && (!_fHadFirstBeforeNavigate))
    {
        _fHadFirstBeforeNavigate = TRUE;
        return hres;
    }

    // get the bind status callback for this browser and ask it for
    // headers and post data
    if (SUCCEEDED(GetTopLevelPendingBindStatusCallback(this,&pBindStatusCallback))) 
    {
        GetHeadersAndPostData(pBindStatusCallback,&pszHeaders,&stgPostData,&cbPostData, pfIsPost);
        pBindStatusCallback->Release();
        fHavePostStg = TRUE;

        if (stgPostData.tymed == TYMED_HGLOBAL) 
        {
            pPostData = (LPBYTE) stgPostData.hGlobal;
        }
    }

    // Fire a BeforeNavigate event to inform container that we are about
    // to navigate and to give it a chance to cancel.  We have to ask
    // for post data and headers to pass to event, so only do this if someone
    // is actually hooked up to the event (HasSinks() is TRUE).
    //if (_bbd._pautoEDS->HasSinks()) 
    {
        TCHAR szFrameName[MAX_URL_STRING];
        SHSTR strHeaders;

        szFrameName[0] = 0;

        // get our frame name
        ITargetFrame2 *pOurTargetFrame;
        hres = TargetQueryService(SAFECAST(this, IShellBrowser *), IID_PPV_ARG(ITargetFrame2, &pOurTargetFrame));
        if (SUCCEEDED(hres))
        {
            LPOLESTR pwzFrameName = NULL;
            pOurTargetFrame->GetFrameName(&pwzFrameName);
            pOurTargetFrame->Release();

            if (pwzFrameName) 
            {
                SHUnicodeToTChar(pwzFrameName, szFrameName, ARRAYSIZE(szFrameName));
                CoTaskMemFree(pwzFrameName);            
            }               
        }

        strHeaders.SetStr(pszHeaders);

        _pidlBeforeNavigateEvent = (LPITEMIDLIST) pidl; // no need to copy

        // This is a work around for view linked weboc. Setting the frame name has side effects.
        
        TCHAR * pEffectiveName;

        if (_fIsViewLinkedWebOC && !szFrameName[0])
        {
            pEffectiveName = _szViewLinkedWebOCFrameName;
        }
        else
        {
            pEffectiveName = szFrameName[0] ? szFrameName : NULL;
        }

        // fire the event!
        FireEvent_BeforeNavigate(_bbd._pautoEDS, _bbd._hwnd, _bbd._pautoWB2,
            pidl, NULL, 0, pEffectiveName,
            pPostData, cbPostData, strHeaders.GetStr(), &fCancelled);

        ASSERT(_pidlBeforeNavigateEvent == pidl);
        _pidlBeforeNavigateEvent = NULL;

        // free anything we alloc'd above
        if (pszHeaders)
        {
            LocalFree(pszHeaders);
            pszHeaders = NULL;
        }

        if (fCancelled) 
        {
            // container told us to cancel
            hres = E_ABORT;
        }
    }
    if (fHavePostStg) 
    {
        ReleaseStgMedium(&stgPostData);
    }
    return hres;
}

HRESULT CBaseBrowser2::SetTopBrowser()
{
    _fTopBrowser = TRUE;

#ifdef MESSAGEFILTER
    if (!_lpMF) 
    {
        /*
         * Create a message filter here to pull out WM_TIMER's while we are
         * busy.  The animation timer, along with other timers, can get
         * piled up otherwise which can fill the message queue and thus USER's
         * heap.
         */
        _lpMF = new CMsgFilter();

        if (_lpMF && !(((CMsgFilter *)_lpMF)->Initialize()))
        {
            ATOMICRELEASE(_lpMF);
        }
    }
#endif
    return S_OK;
}

HRESULT CBaseBrowser2::_ResizeView()
{
    _pbsOuter->_UpdateViewRectSize();
    if (_pact) 
    {
        RECT rc;
        GetBorder(&rc);
        TraceMsg(TF_SHDUIACTIVATE, "UIW::SetBorderSpaceDW calling _pact->ResizeBorder");
        _pact->ResizeBorder(&rc, this, TRUE);
    }
    return S_OK;
} 

HRESULT CBaseBrowser2::_ResizeNextBorder(UINT itb)
{
    // (derived class resizes inner toolbar if any)
    return _ResizeView();
}

HRESULT CBaseBrowser2::_OnFocusChange(UINT itb)
{
#if 0
    // the OC *does* get here (it's not aggregated so _pbsOuter->_OnFocusChange
    // ends up here not in commonsb).  not sure if E_NOTIMPL is o.k., but
    // for now it's what we'll do...
    ASSERT(0);
#endif
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::OnFocusChangeIS(IUnknown* punkSrc, BOOL fSetFocus)
{
    ASSERT(0);          // split: untested!
    // do we need to do _UIActivateView?
    ASSERT(fSetFocus);  // i think?

    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::v_ShowHideChildWindows(BOOL fChildOnly)
{
    // (derived class does ShowDW on all toolbars)
    if (!fChildOnly) 
    {
        _pbsOuter->_ResizeNextBorder(0);
        // This is called in ResizeNextBorder 
        // _UpdateViewRectSize();
    }

    return S_OK;
}

//***   _ExecChildren -- broadcast Exec to view and toolbars
// NOTES
//  we might do *both* punkBar and fBroadcast if we want to send stuff
//  to both the view and to all toolbars, e.g. 'stop' or 'refresh'.
//
//  Note: n.b. the tray isn't a real toolbar, so it won't get called (sigh...).
HRESULT CBaseBrowser2::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast, const GUID *pguidCmdGroup,
    DWORD nCmdID, DWORD nCmdexecopt,
    VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
    //ASSERT(!fBroadcast);    // only derived class supports this
    // alanau: but CWebBrowserSB doesn't override this method, so we hit this assert.

    // 1st, send to specified guy (if requested)
    if (punkBar != NULL) 
    {
        // send to specified guy
        IUnknown_Exec(punkBar, pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
    }

    // (derived class broadcasts to toolbars)

    return S_OK;
}

HRESULT CBaseBrowser2::_SendChildren(HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
#if 0
    // the OC *does* get here (it's not aggregated so _pbsOuter->_SendChildren
    // ends up here not in commonsb).  since there are no kids i guess it's
    // ok to just drop the fBroadcast on the floor.
    ASSERT(!fBroadcast);    // only derived class supports this
#endif

    // 1st, send to specified guy (if requested)
    if (hwndBar != NULL)
    {
        // send to specified guy
        SendMessage(hwndBar, uMsg, wParam, lParam);
    }

    // (derived class broadcasts to toolbars)

    return S_OK;
}

//
//  Handle <META HTTP-EQUIV ...> headers for lower components
//
HRESULT CBaseBrowser2::OnHttpEquiv(IShellView* psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut)
{
    return OLECMDERR_E_NOTSUPPORTED;
} // _HandleHttpEquiv

STDMETHODIMP CBaseBrowser2::GetPalette( HPALETTE * phpal )
{
    BOOL fRes = FALSE;
    if ( _hpalBrowser )
    {
       *phpal = _hpalBrowser;
       fRes = TRUE;
    }
    return fRes ? NOERROR : E_FAIL;
}


//
//  IPersist
//
HRESULT 
CBaseBrowser2::GetClassID(CLSID *pclsid)
{
    return E_NOTIMPL;
}

//
// IPersistHistory
//  
#ifdef DEBUG
#define c_szFrameMagic TEXT("IE4ViewStream")
#define c_cchFrameMagic SIZECHARS(c_szFrameMagic)
#endif

// NOTE this is almost the same kind of data that is 
//  stored in a TravelEntry.

typedef struct _PersistedFrame {
    DWORD cbSize;
    DWORD type;
    DWORD lock;
    DWORD bid;
    CLSID clsid;
    DWORD cbPidl;
} PERSISTEDFRAME, *PPERSISTEDFRAME;

#define PFTYPE_USEPIDL      1
#define PFTYPE_USECLSID     2

#define PFFLAG_SECURELOCK   0x00000001


HRESULT GetPersistedFrame(IStream *pstm, PPERSISTEDFRAME ppf, LPITEMIDLIST *ppidl)
{
    HRESULT hr;
    ASSERT(pstm);
    ASSERT(ppf);
    ASSERT(ppidl);

#ifdef DEBUG
    TCHAR szMagic[SIZECHARS(c_szFrameMagic)];
    DWORD cbMagic = CbFromCch(c_cchFrameMagic);

    ASSERT(SUCCEEDED(IStream_Read(pstm, (void *) szMagic, cbMagic)));
    ASSERT(!StrCmp(szMagic, c_szFrameMagic));
#endif //DEBUG

    // This is pointing to the stack, make sure it starts NULL
    *ppidl = NULL;

    if(SUCCEEDED(hr = IStream_Read(pstm, (void *) ppf, SIZEOF(PERSISTEDFRAME))))
    {
        if(ppf->cbSize == SIZEOF(PERSISTEDFRAME) && (ppf->type == PFTYPE_USECLSID || ppf->type == PFTYPE_USEPIDL))
        {
            //  i used SHAlloc() cuz its what all the IL functions use
            if(ppf->cbPidl)
                *ppidl = (LPITEMIDLIST) SHAlloc(ppf->cbPidl);
        
            if(*ppidl)
            {
                hr = IStream_Read(pstm, (void *) *ppidl, ppf->cbPidl);
                if(FAILED(hr))
                {
                    ILFree(*ppidl);
                    *ppidl = NULL;
                }
            }
            else 
                hr = E_OUTOFMEMORY;
        }
        else
            hr = E_UNEXPECTED;
    }

    return hr;
}

HRESULT
CBaseBrowser2::LoadHistory(IStream *pstm, IBindCtx *pbc)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(pstm);

    TraceMsg(TF_TRAVELLOG, "CBB::LoadHistory entered pstm = %X, pbc = %d", pstm, pbc);

    ATOMICRELEASE(_poleHistory);
    ATOMICRELEASE(_pstmHistory);
    ATOMICRELEASE(_pbcHistory);

    if (pstm)
    {
        PERSISTEDFRAME pf;
        LPITEMIDLIST pidl;

        hr = GetPersistedFrame(pstm, &pf, &pidl);
        if (SUCCEEDED(hr))
        {
            //  need to restore the previous bid
            //  if this is a new window
            ASSERT(pf.bid == _dwBrowserIndex || !_bbd._pidlCur);
            _dwBrowserIndex = pf.bid;
            _eSecureLockIconPending = pf.lock;

            if (pf.type == PFTYPE_USECLSID)
            {
                hr = E_FAIL;

                if (_pHTMLDocument)
                {
                    if (   (_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)
                        && IsEqualCLSID(pf.clsid, CLSID_HTMLDocument))
                    {
                        IPersistHistory * pph;
                        hr = _pHTMLDocument->QueryInterface(IID_PPV_ARG(IPersistHistory, &pph));

                        if (SUCCEEDED(hr))
                        {
                            _fDontAddTravelEntry = TRUE;

                            hr = pph->LoadHistory(pstm, pbc);
                            TraceMsg(TF_TRAVELLOG, "CBB::LoadHistory called pole->LoadHistory, hr =%X", hr);

                            pph->Release();

                            return hr;
                        }
                    }
                    else
                    {
                        ATOMICRELEASE(_pHTMLDocument);  // We are going to cocreate a new document.
                    }
                }

                if (S_OK != hr)
                {
                    // Get the class and instantiate
                    hr = CoCreateInstance(pf.clsid, NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, IID_PPV_ARG(IOleObject, &_poleHistory));
                }

                if (SUCCEEDED(hr))
                {
                    DWORD dwFlags;

                    hr = _poleHistory->GetMiscStatus(DVASPECT_CONTENT, &dwFlags);
                    if (SUCCEEDED(hr))
                    {
                        if (dwFlags & OLEMISC_SETCLIENTSITEFIRST)
                        {
                            pstm->AddRef();  
                            if (pbc)
                                pbc->AddRef();
 
                            // we need to addref because we will use it async
                            // whoever uses it needs to release.
                            _pstmHistory = pstm;
                            _pbcHistory = pbc;
                        }
                        else
                        {
                            IPersistHistory * pph;
                            hr = _poleHistory->QueryInterface(IID_PPV_ARG(IPersistHistory, &pph));

                            if (SUCCEEDED(hr))
                            {
                                hr = pph->LoadHistory(pstm, pbc);
                                TraceMsg(TF_TRAVELLOG, "CBB::LoadHistory called pole->LoadHistory, hr =%X", hr);

                                pph->Release();
                            }
                        }

                        //  if we made then set the prepared history object in 
                        //  _poleHistory
                        if (FAILED(hr))
                        {
                            ATOMICRELEASE(_poleHistory);
                            ATOMICRELEASE(_pstmHistory);
                            ATOMICRELEASE(_pbcHistory);
                        }
                    }
                }
            }
            
            //
            // just browse the object
            // if poleHistory is set, then when the dochost is created
            // it will pick up the object and use it.
            // other wise we will do a normal navigate.
            //
            if (pidl)
            {
                DEBUG_CODE(TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];)
                DEBUG_CODE(SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL);)
                DEBUG_CODE(TraceMsg(DM_TRACE, "CBB::LoadHistory: URL - %ws", szPath);)

                _fDontAddTravelEntry = TRUE;
                hr = _psbOuter->BrowseObject(pidl, SBSP_SAMEBROWSER | SBSP_ABSOLUTE);
                ILFree(pidl);
            }
            else
                hr = E_OUTOFMEMORY;
        }
    }

    TraceMsg(TF_TRAVELLOG, "CBB::LoadHistory exiting, hr =%X", hr);
    _pbsOuter->UpdateBackForwardState();
    return hr;
}

// Save a stream represeting the history at this point.
// Be sure to keep this and GetDummyWindowData in sync.

HRESULT
CBaseBrowser2::SaveHistory(IStream *pstm)
{
    HRESULT hr = E_UNEXPECTED;
    TraceMsg(TF_TRAVELLOG, "CBB::SaveHistory entering, pstm =%X", pstm);
    ASSERT(pstm);

    if(_bbd._pidlCur)
    {
        PERSISTEDFRAME pf = {0};
        pf.cbSize = SIZEOF(pf);
        pf.bid = GetBrowserIndex();
        pf.cbPidl = ILGetSize(_bbd._pidlCur);
        pf.type = PFTYPE_USEPIDL;
        pf.lock = _bbd._eSecureLockIcon;

        DEBUG_CODE(TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];)
        DEBUG_CODE(IEGetDisplayName(_bbd._pidlCur, szPath, SHGDN_FORPARSING);)
        
        ASSERT(SUCCEEDED(IStream_Write(pstm, (void *) c_szFrameMagic, CbFromCch(c_cchFrameMagic))));
    
        //
        //  in order to use IPersistHistory we need to get the CLSID of the Ole Object
        //  then we need to get IPersistHistory off that object
        //  then we can save the PERSISTEDFRAME and the pidl and then pass 
        //  the stream down into the objects IPersistHistory
        //

        //  Right now we circumvent the view object for history - zekel - 18-JUL-97
        //  right now we just grab the DocObj from the view object, and then query
        //  the Doc for IPersistHistory.  really what we should be doing is QI the view
        //  for pph, and then use it.  however this requires risky work with the
        //  navigation stack, and thus should be postponed to IE5.  looking to the future
        //  the view could persist all kinds of great state info
        //
        //  but now we just get the background object.  but check to make sure that it
        //  will be using the DocObjHost code by QI for IDocViewSite
        //

        //  _bbd._psv can be null in subframes that have not completed navigating
        //  before a refresh is called
        //
        if (!_pphHistory && _bbd._psv)
        {
            hr = SafeGetItemObject(_bbd._psv, SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &_pphHistory));
        }

        if (_pphHistory)
        {
            IDocViewSite *pdvs;

            if (SUCCEEDED(_bbd._psv->QueryInterface(IID_PPV_ARG(IDocViewSite, &pdvs))) && 
                SUCCEEDED(hr = _pphHistory->GetClassID(&(pf.clsid))))
            {
                pf.type = PFTYPE_USECLSID;
                TraceMsg(TF_TRAVELLOG, "CBB::SaveHistory is PFTYPE_USECLSID");
            }

            ATOMICRELEASE(pdvs);
        }


        if (SUCCEEDED(hr = IStream_Write(pstm,(void *)&pf, pf.cbSize)))
            hr = IStream_Write(pstm,(void *)_bbd._pidlCur, pf.cbPidl);

        if (SUCCEEDED(hr) && pf.type == PFTYPE_USECLSID)
            hr = _pphHistory->SaveHistory(pstm);

        ATOMICRELEASE(_pphHistory);
    }
    
    TraceMsg(TF_TRAVELLOG, "CBB::SaveHistory exiting, hr =%X", hr);
    return hr;
}

HRESULT CBaseBrowser2::SetPositionCookie(DWORD dwPositionCookie)
{
    HRESULT hr = E_FAIL;
    //
    //  we force the browser to update its internal location and the address bar
    //  this depends on the fact that setposition cookie was always 
    //  started by a ptl->Travel(). so that the current position in the ptl
    //  is actually the correct URL for us to have.  zekel - 22-JUL-97
    //

    ITravelLog *ptl;
    GetTravelLog(&ptl);
    if(ptl)
    {
        ITravelEntry *pte;
        if(EVAL(SUCCEEDED(ptl->GetTravelEntry(SAFECAST(this, IShellBrowser *), 0, &pte))))
        {
            LPITEMIDLIST pidl;
            if(SUCCEEDED(pte->GetPidl(&pidl)))
            {
                BOOL fUnused;
                ASSERT(pidl);

                if (SUCCEEDED(hr = _FireBeforeNavigateEvent(pidl, &fUnused)))
                {
                    IPersistHistory *pph;
                    if(_bbd._psv && SUCCEEDED(hr = SafeGetItemObject(_bbd._psv, SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &pph))))
                    {
                        ASSERT(pph);

                        //  now that we are certain that we are going to call into 
                        //   the document, we need to update the entry right before.
                        //  NOTE: after an update, we cannot revert if there was an
                        //  error in the Set...
                        ptl->UpdateEntry(SAFECAST(this, IShellBrowser *), TRUE);

                        hr = pph->SetPositionCookie(dwPositionCookie);
                        pph->Release();

                        //  this updates the browser to the new pidl, 
                        //  and navigates there directly if necessary.
                        BOOL fDidBrowse;
                        NotifyRedirect(_bbd._psv, pidl, &fDidBrowse);

                        if (!fDidBrowse)
                        {
                            // fire the event!
                            FireEvent_NavigateComplete(_bbd._pautoEDS, _bbd._pautoWB2, _bbd._pidlCur, _bbd._hwnd);          
                            FireEvent_DocumentComplete(_bbd._pautoEDS, _bbd._pautoWB2, _bbd._pidlCur);
                        }
                    }

                }
                ILFree(pidl);
            }
            pte->Release();
        }
        ptl->Release();
    }

    TraceMsg(TF_TRAVELLOG, "CBB::SetPositionCookie exiting, cookie = %X, hr =%X", dwPositionCookie, hr);
    
    return hr;
}

HRESULT CBaseBrowser2::GetPositionCookie(DWORD *pdwPositionCookie)
{
    HRESULT hr = E_FAIL;
    IPersistHistory *pph;
    ASSERT(pdwPositionCookie);

    if(pdwPositionCookie && _bbd._psv && SUCCEEDED(hr = SafeGetItemObject(_bbd._psv, SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &pph))))
    {
        ASSERT(pph);

        hr = pph->GetPositionCookie(pdwPositionCookie);
        pph->Release();
    }

    TraceMsg(TF_TRAVELLOG, "CBB::GetPositionCookie exiting, cookie = %X, hr =%X", *pdwPositionCookie, hr);

    return hr;
}

DWORD CBaseBrowser2::GetBrowserIndex()
{
    //  the first time we request the index, we init it.
    if (!_dwBrowserIndex)
    {
        //
        //  the topframe browser all have the same browser index so 
        //  that they can trade TravelEntries if necessary.  because we now
        //  trade around TravelEntries, then we need to make the bids relatively
        //  unique.  and avoid ever having a random frame be BID_TOPFRAMEBROWSER
        //
        if (IsTopFrameBrowser(SAFECAST(this, IServiceProvider *), SAFECAST(this, IShellBrowser *)))
            _dwBrowserIndex = BID_TOPFRAMEBROWSER;
        else do
        {
            _dwBrowserIndex = SHRandom();

        } while (!_dwBrowserIndex || _dwBrowserIndex == BID_TOPFRAMEBROWSER);
        // psp->Release();

        TraceMsg(TF_TRAVELLOG, "CBB::GetBrowserIndex() NewFrame BID = %X", _dwBrowserIndex);
    }

    return _dwBrowserIndex;
}

HRESULT CBaseBrowser2::GetHistoryObject(IOleObject **ppole, IStream **ppstm, IBindCtx **ppbc) 
{
    ASSERT(ppole);
    ASSERT(ppstm);
    ASSERT(ppbc);

    *ppole = _poleHistory;
    *ppstm = _pstmHistory;
    *ppbc = _pbcHistory;

    //  we dont need to release, because we are just giving away our
    //  reference.
    _poleHistory = NULL;
    _pstmHistory = NULL;
    _pbcHistory = NULL;

    if(*ppole)
        return NOERROR;

    ASSERT(!*ppstm);
    return E_FAIL;
}

HRESULT CBaseBrowser2::SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor)
{
    if (!_poleHistory && !_fGeneratedPage)
    {
        ASSERT(pole);

        // Note: _fIsLocalAnchor is ignored if (_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)
        // is TRUE. In that case, the document (Trident) can navigate
        // itself and will take care of updating the travel log.
        //
        _fIsLocalAnchor = fIsLocalAnchor;

        if (pole)
        {
            _poleHistory = pole;
            _poleHistory->AddRef();
            return NOERROR;
        }
    }
    return E_FAIL;
}

HRESULT CBaseBrowser2::CacheOLEServer(IOleObject *pole)
{
    TraceMsg(DM_CACHEOLESERVER, "CBB::CacheOLEServer called");
    HRESULT hres;
    IPersist* pps;

    // ISVs want to turn off this caching because it's "incovenient"
    // to have the browser hold onto their object. We can do that
    // with a quick registry check here, but first let's make sure
    // we don't have a real bug to fix...

    hres = pole->QueryInterface(IID_PPV_ARG(IPersist, &pps));
    if (FAILED(hres)) 
    {
        return hres;
    }

    CLSID clsid = CLSID_NULL;
    hres = pps->GetClassID(&clsid);
    pps->Release();

    if (SUCCEEDED(hres)) 
    {
        SA_BSTRGUID str;
        InitFakeBSTR(&str, clsid);

        VARIANT v;
        hres = _bbd._pautoWB2->GetProperty(str.wsz, &v);
        if (SUCCEEDED(hres) && v.vt != VT_EMPTY) 
        {
            // We already have it. We are fine.
            TraceMsg(DM_CACHEOLESERVER, "CBB::CacheOLEServer not first time");
            VariantClear(&v);
        }
        else
        {
            // We don't have it yet. Add it. 
            v.vt = VT_UNKNOWN;
            v.punkVal = ClassHolder_Create(&clsid);
            if (v.punkVal)
            {
                hres = _bbd._pautoWB2->PutProperty(str.wsz, v);
                TraceMsg(DM_CACHEOLESERVER, "CBB::CacheOLEServer first time %x", hres);
                v.punkVal->Release();
            }
        }
    }
    return hres;
}

HRESULT CBaseBrowser2::GetSetCodePage(VARIANT* pvarIn, VARIANT* pvarOut)
{
    // Process the out parameter first so that the client can set and
    // get the previous value in a single call.

    if (pvarOut) 
    {
        pvarOut->vt = VT_I4;
        pvarOut->lVal = _cp;
    }

    if (pvarIn && pvarIn->vt==VT_I4) 
    {
        TraceMsg(DM_DOCCP, "CBB::GetSetCodePage changing _cp from %d to %d", _cp, pvarIn->lVal);
        _cp = pvarIn->lVal;
    }

    return S_OK;
}

HRESULT CBaseBrowser2::GetPidl(LPITEMIDLIST *ppidl)
{
    ASSERT(ppidl);

    *ppidl = ILClone(_bbd._pidlCur);

    return *ppidl ? S_OK : E_FAIL;
}

HRESULT CBaseBrowser2::SetReferrer(LPITEMIDLIST pidl)
{
    return E_NOTIMPL;
}

HRESULT CBaseBrowser2::GetBrowserByIndex(DWORD dwID, IUnknown **ppunk)
{
    HRESULT hr = E_FAIL;
    ASSERT(ppunk);
    *ppunk = NULL;

    //gotta get the target frame ...
    ITargetFramePriv * ptf;
    if(SUCCEEDED(_ptfrm->QueryInterface(IID_PPV_ARG(ITargetFramePriv, &ptf))))
    {
        ASSERT(ptf);
        hr = ptf->FindBrowserByIndex(dwID, ppunk);

        ptf->Release();
    }

    return hr;
}

HRESULT CBaseBrowser2::GetTravelLog(ITravelLog **pptl)
{
    *pptl = NULL;

    if (!_bbd._ptl)
    {
        IBrowserService *pbs;
        if (SUCCEEDED(_pspOuter->QueryService(SID_STopFrameBrowser, IID_PPV_ARG(IBrowserService, &pbs)))) 
        {
            if (IsSameObject(SAFECAST(this, IBrowserService *), pbs))
            {
                // we are it, so we need to make us a TravelLog
                CreateTravelLog(&_bbd._ptl);
            }
            else
            {
                pbs->GetTravelLog(&_bbd._ptl);
            }
            pbs->Release();
        }
    }

    return _bbd._ptl ? _bbd._ptl->QueryInterface(IID_PPV_ARG(ITravelLog, pptl)) : E_FAIL;
}

HRESULT CBaseBrowser2::InitializeTravelLog(ITravelLog* ptl, DWORD dwBrowserIndex)
{
    ptl->QueryInterface(IID_PPV_ARG(ITravelLog, &_bbd._ptl));   // hold a copy
    _dwBrowserIndex = dwBrowserIndex;
    return S_OK;
}

// Let the top level browser know that it might need to update it's zones information
void CBaseBrowser2::_Exec_psbMixedZone()
{
    IShellBrowser *psbTop;
    if (SUCCEEDED(_pspOuter->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &psbTop)))) 
    {
        IUnknown_Exec(psbTop, &CGID_Explorer, SBCMDID_MIXEDZONE, 0, NULL, NULL);
        psbTop->Release();
    }
}

STDMETHODIMP CBaseBrowser2::QueryUseLocalVersionVector(BOOL *pfUseLocal)
{
    *pfUseLocal = FALSE;
    return S_OK;
}

STDMETHODIMP CBaseBrowser2::QueryVersionVector(IVersionVector *pVersion)
{
    HRESULT    hr;
    ULONG      cchVer = 0;

    // Was IE's version set by a registry entry?
    // This simplified call checks for presence of the IE string
    //
    hr = pVersion->GetVersion(L"IE", NULL, &cchVer);
    ASSERT(hr == S_OK);

    if (cchVer == 0)
    {
        // Not already set.  Set it to default value.
        // Note that the four digits of precision is required due to a peculiarity in the parser.
        //
        hr = pVersion->SetVersion(L"IE", L"6.0000");
    }

    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FindWindowByIndex
//
//  Interface : ITravelLogClient
//
//  Synopsis  : Returns the window with the given index.
//
//--------------------------------------------------------------------------
HRESULT
CBaseBrowser2::FindWindowByIndex(DWORD dwID, IUnknown ** ppunk)
{
    return GetBrowserByIndex(dwID, ppunk);
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::GetWindowData
//
//  Interface : ITravelLogClient
//
//  Synopsis  : Returns a WINDOWDATA structure containing pertinent
//              window information needed for the travel log.. 
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::GetWindowData(LPWINDOWDATA pWinData)
{
    HRESULT hr = S_OK;

    ASSERT(pWinData);
    ASSERT(_bbd._pidlCur);

    DEBUG_CODE(TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];)
    DEBUG_CODE(IEGetDisplayName(_bbd._pidlCur, szPath, SHGDN_FORPARSING);)
    DEBUG_CODE(TraceMsg(DM_TRACE, "CBB::ActivatePendingView (TRAVELLOG): _UpdateTravelLog called from shdocvw for %ws", szPath);)

    ZeroMemory(pWinData, sizeof(WINDOWDATA));

    // Window ID and codepage
    //
    pWinData->dwWindowID = GetBrowserIndex();
    pWinData->uiCP       = _cp;

    // Current Pidl
    //
    pWinData->pidl = ILClone(_bbd._pidlCur);

    // Title - when we are in a shell view, 
    // _bbd._pszTitleCur is NULL, which is correct.
    // However, we still have to create memory for
    // pWinData->lpszTitle and you can't pass NULL
    // to SHStrDupW.
    //
    if (_bbd._pszTitleCur)
        hr = SHStrDupW(_bbd._pszTitleCur, &pWinData->lpszTitle);

    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::LoadHistoryPosition
//
//  Interface : ITravelLogClient
//
//  Synopsis  : Loads the Url location and position cookie. This is used 
//              during a history navigation in a frame that involves a
//              local anchor. 
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::LoadHistoryPosition(LPOLESTR pszUrlLocation, DWORD dwCookie)
{
    IEPlaySound(TEXT("Navigating"), FALSE);

    return SetPositionCookie(dwCookie);
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::GetDummyWindowData
//
//  Interface : ITravelLogClient2
//
//  Synopsis  : Fills in a windowdata and a stream very similar to 
//              that created by SaveHistory.
//              Be sure to keep this and SaveHistory in sync.
//
//--------------------------------------------------------------------------

STDMETHODIMP CBaseBrowser2::GetDummyWindowData(
        LPWSTR pszUrl, 
        LPWSTR pszTitle,
        LPWINDOWDATA pWinData)
{
    HRESULT hres = S_OK;
    PERSISTEDFRAME pf = {0};
    LPITEMIDLIST pidl;

      // grab current window ID
    pWinData->dwWindowID = GetBrowserIndex();

      // everything else is dummy
    pWinData->uiCP = 0;
    hres = SHStrDup(pszUrl, &pWinData->lpszUrl);
    hres = SHStrDup(pszTitle, &pWinData->lpszTitle);

    if (!pWinData->pStream)
    {
      hres = CreateStreamOnHGlobal(NULL, FALSE, &pWinData->pStream);
      if (hres)
          goto done;
    }

    pidl = PidlFromUrl(pszUrl);

    pf.cbSize = SIZEOF(pf);
    pf.bid = GetBrowserIndex();
    pf.cbPidl = ILGetSize(pidl);
    pf.type = PFTYPE_USEPIDL;
    pf.lock = 0; // _bbd._eSecureLockIcon;

    ASSERT(SUCCEEDED(IStream_Write(pWinData->pStream, (void *) c_szFrameMagic, CbFromCch(c_cchFrameMagic))));

    if (SUCCEEDED(hres = IStream_Write(pWinData->pStream,(void *)&pf, pf.cbSize)))
        hres = IStream_Write(pWinData->pStream,(void *)pidl, pf.cbPidl);

    ILFree(pidl); 

done:
    return SUCCEEDED(hres) ? S_OK : E_FAIL;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::UpdateDesktopComponent
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::UpdateDesktopComponent(IHTMLWindow2 * pHTMLWindow)
{
    BSTR bstrTitle = NULL;
    BSTR bstrUrlUnencoded = NULL;
    HRESULT hr = S_OK;
    IHTMLDocument2 * pHTMLDocument2;
    IHTMLDocument4 * pHTMLDocument4;
    DWORD   dwOptions = 0;

    hr = pHTMLWindow->get_document(&pHTMLDocument2);
    if (SUCCEEDED(hr))
    {
        hr = pHTMLDocument2->QueryInterface(IID_PPV_ARG(IHTMLDocument4, &pHTMLDocument4));

        if (SUCCEEDED(hr))
        {
            pHTMLDocument2->get_title(&bstrTitle);
            pHTMLDocument4->get_URLUnencoded(&bstrUrlUnencoded);

            TraceMsg(DM_TRACE, "CBaseBrowser2::UpdateDesktopComponent: URLUnencoded - %ws; Title - %ws",
                     bstrUrlUnencoded, bstrTitle);

            // Update the desktop component's friendly name.
            //
            UpdateDesktopComponentName(bstrUrlUnencoded, bstrTitle);
            
            SysFreeString(bstrTitle);
            SysFreeString(bstrUrlUnencoded);

            pHTMLDocument4->Release();
        }

        pHTMLDocument2->Release();
    }

    return hr;
}

HRESULT
CBaseBrowser2::_InitDocHost(IWebBrowser2 * pWebBrowser)
{
    HRESULT     hr = E_FAIL;
    IDispatch*  pDocDispatch = NULL;

    ASSERT(pWebBrowser);

    // get the IHTMLWindow2 for the WebOC windowop
    hr = pWebBrowser->get_Document(&pDocDispatch);
    if (S_OK == hr && pDocDispatch)
    {
        IHTMLDocument2* pDoc;    
        
        hr = pDocDispatch->QueryInterface(IID_PPV_ARG(IHTMLDocument2, &pDoc));
        pDocDispatch->Release();

        if (S_OK == hr)
        {
            IHTMLWindow2* pHtmlWindow;
            
            hr = pDoc->get_parentWindow(&pHtmlWindow);
            pDoc->Release();

            if (S_OK == hr)
            {
                BOOL fIsFrameWindow = IsFrameWindow(pHtmlWindow);
                pHtmlWindow->Release();

                if (!fIsFrameWindow && _bbd._pctView)
                {
                    hr = _bbd._pctView->Exec(&CGID_ShellDocView, 
                                             SHDVID_NAVSTART, 
                                             0, 
                                             NULL, 
                                             NULL);
                }
            }
        }
    }
    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireBeforeNavigate2
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireBeforeNavigate2(IDispatch * pDispatch,
                                   LPCTSTR     lpszUrl,
                                   DWORD       dwFlags,
                                   LPCTSTR     lpszFrameName,
                                   LPBYTE      pPostData,
                                   DWORD       cbPostData,
                                   LPCTSTR     lpszHeaders,
                                   BOOL        fPlayNavSound,
                                   BOOL      * pfCancel)
{
    HRESULT      hr = S_OK;
    BSTR         bstrUrl = NULL;
    LPITEMIDLIST pidl = NULL;
    IWebBrowser2 * pWebBrowser = NULL;

    ASSERT(pfCancel);

    *pfCancel = FALSE;
        
    // Stress fix
    //
    if (NULL == lpszUrl)
    {
        bstrUrl = SysAllocString(_T(""));
    }
    else
    {
        bstrUrl = SysAllocString(lpszUrl);
    }

    pidl = PidlFromUrl(bstrUrl);

    if (pidl)
    {

        hr = _GetWebBrowserForEvt(pDispatch, &pWebBrowser);

        if (S_OK == hr)
        {
            ASSERT(pWebBrowser);

            _pidlBeforeNavigateEvent = pidl; // no need to copy.

            // This is a work around for view linked weboc. Setting the frame name has side effects.
        
            LPCTSTR pEffectiveName;

            if (_fIsViewLinkedWebOC && (lpszFrameName == NULL || !lpszFrameName[0]))
            {
                pEffectiveName = _szViewLinkedWebOCFrameName;
            }
            else
            {
                pEffectiveName = lpszFrameName;
            }

            FireEvent_BeforeNavigate(pWebBrowser, _bbd._hwnd, pWebBrowser,
                                     pidl, NULL, dwFlags, pEffectiveName,
                                     pPostData, cbPostData, lpszHeaders, pfCancel);

            // Make sure that we remove earlier URLs that are cached during redirections.
            _InitDocHost(pWebBrowser);

            ATOMICRELEASE(pWebBrowser);

            ASSERT(_pidlBeforeNavigateEvent == pidl);
            _pidlBeforeNavigateEvent = NULL;

            ILFree(pidl);

            if (!*pfCancel && fPlayNavSound)
            {
                IEPlaySound(TEXT("Navigating"), FALSE);
            }
        }        
    }

    if (_phtmlWS && !pDispatch)
    {
        if (!_bbd._psvPending)
        {
            _phtmlWS->ViewReleased();
        }
        else
        {
            _phtmlWS->ViewReleaseIntelliForms();
        }
    }
    else if (_phtmlWS && !_bbd._psvPending)
    {
        _DismissFindDialog();
    }

    SysFreeString(bstrUrl);
    
    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireNavigateError
//
//  Interface : ITridentService2
//
//  Called when there is a binding error
//
//  Input     : pHTMLWindow         - used to determine if we are a frame or 
//                                    the top-level.
//              bstrURL             - the URL which caused the error.                                   
//              bstrTargetFrameName - the frame being targeted.
//              dwStatusCode        - the binding error
//              pfCancel            - set by the host if it wants to 
//                                    cancel autosearch or friendly error
//                                    pages
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireNavigateError(IHTMLWindow2 * pHTMLWindow2, 
                                 BSTR           bstrURL,
                                 BSTR           bstrTargetFrameName,
                                 DWORD          dwStatusCode,
                                 BOOL         * pfCancel)
{
    ASSERT(dwStatusCode != 0);

    HRESULT hr = S_OK;
    IWebBrowser2 * pWebBrowser = NULL;

    *pfCancel = FALSE;

    //
    //  Use top-level if window is not specified or the window is the top-level 
    //
    if ((pHTMLWindow2 != NULL) && IsFrameWindow(pHTMLWindow2))
    {
        hr = _GetWebBrowserForEvt(pHTMLWindow2, &pWebBrowser);
    }
    else
    {
        hr = _GetWebBrowserForEvt(NULL, &pWebBrowser);
    }

    if (S_OK == hr)
    {
        ASSERT(pWebBrowser);

        TCHAR  szUrl[INTERNET_MAX_URL_LENGTH];

        LPITEMIDLIST pidl = NULL;

        if (bstrURL)
        {
            StrCpyN(szUrl, bstrURL, ARRAYSIZE(szUrl));
        }
        else
        {
            StrCpyN(szUrl, _T(""), ARRAYSIZE(szUrl));
        }

        pidl = PidlFromUrl(szUrl);

        if (pidl)
        {
            FireEvent_NavigateError(pWebBrowser, 
                                    pWebBrowser,
                                    pidl,
                                    bstrTargetFrameName,
                                    dwStatusCode,
                                    pfCancel);
            ILFree(pidl);
        }
    }

    ATOMICRELEASE(pWebBrowser);

    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FirePrintTemplateEvent
//
//  Interface : ITridentService
//
//  Called when a template is instantiate or torndown
//
//  pHTMLWindow is used to determine if we are a frame or the top-level
//  dispidPrintEvent either DISPID_PRINTTEMPLATEINSTANTIATION 
//                   or     DISPID_PRINTTEMPLATETEARDOWN 
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FirePrintTemplateEvent(IHTMLWindow2 * pHTMLWindow2, DISPID dispidPrintEvent)
{
    HRESULT hr = S_OK;

    IWebBrowser2 * pWebBrowser = NULL;

    //
    //  Use top-level if window is not specified or the window is the top-level 
    //
    if ((pHTMLWindow2 != NULL) && IsFrameWindow(pHTMLWindow2))
    {
        hr = _GetWebBrowserForEvt(pHTMLWindow2, &pWebBrowser);
    }
    else
    {
        hr = _GetWebBrowserForEvt(NULL, &pWebBrowser);
    }

    if (S_OK == hr)
    {
        ASSERT(pWebBrowser);

        FireEvent_PrintTemplateEvent(pWebBrowser, 
                                     pWebBrowser,
                                     dispidPrintEvent);
    }

    ATOMICRELEASE(pWebBrowser);
    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireUpdatePageStatus
//
//  Interface : ITridentService
//
//  Called when a template is instantiate or torndown
//
//  pHTMLWindow is used to determine if we are a frame or the top-level
//  nPage defined to be the number of pages spooled
//  fDone a flag to indicate that the last page has been sppoled
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireUpdatePageStatus(IHTMLWindow2 * pHTMLWindow2, DWORD nPage, BOOL fDone)
{
    HRESULT hr = S_OK;

    IWebBrowser2 * pWebBrowser = NULL;

    //
    //  Use top-level if window is not specified or the window is the top-level 
    //
    if  ((pHTMLWindow2 != NULL) && IsFrameWindow(pHTMLWindow2))
    {
        hr = _GetWebBrowserForEvt(pHTMLWindow2, &pWebBrowser);
    }
    else
    {
        hr = _GetWebBrowserForEvt(NULL, &pWebBrowser);
    }

    if (S_OK == hr)
    {
        ASSERT(pWebBrowser);

        FireEvent_UpdatePageStatus(pWebBrowser, 
                                   pWebBrowser,
                                   nPage,
                                   fDone);
    }

    ATOMICRELEASE(pWebBrowser);
    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FirePrivacyImpactedStateChange
//
//  Interface : ITridentService2
//
//  Called whenever the global privacy impacted state changes
//
//  Input     : The new privacy impacted state
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FirePrivacyImpactedStateChange(BOOL bPrivacyImpacted)
{
    HRESULT         hr          = S_OK;
    IWebBrowser2  * pWebBrowser = NULL;

    //
    // Update browser frame / save state
    //
    _UpdatePrivacyIcon(TRUE, bPrivacyImpacted);

    //
    // We always fire this at the top level 
    //
    hr = _GetWebBrowserForEvt(NULL, &pWebBrowser);

    if (S_OK == hr)
    {
        ASSERT(pWebBrowser);
        FireEvent_PrivacyImpactedStateChange(pWebBrowser, 
                                     bPrivacyImpacted);
    }

    ATOMICRELEASE(pWebBrowser);
    return hr;
}
    
HRESULT
CBaseBrowser2::_DismissFindDialog()
{
    BSTR bstrName = SysAllocString(STR_FIND_DIALOG_NAME);
    if (bstrName)
    {
        VARIANT varProp = {0};
        _bbd._pautoWB2->GetProperty(bstrName, &varProp);

        if ( (varProp.vt == VT_DISPATCH) && (varProp.pdispVal != NULL) )
        {
            IUnknown* pWindow = varProp.pdispVal;

            //now that we've pulled the pdispVal out of the propbag, clear the property on the automation object
            VARIANT varTmp = {0};
            _bbd._pautoWB2->PutProperty(bstrName, varTmp);

            //(davemi) see IE5 bug 57060 for why the below line doesn't work and IDispatch must be used instead
            //pWindow->close();
            IDispatch * pdisp;
            if (SUCCEEDED(pWindow->QueryInterface(IID_PPV_ARG(IDispatch, &pdisp))))
            {
                DISPID dispid;
                DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};

                BSTR bstrClose = SysAllocString(L"close");
                if (bstrClose)
                {
                    HRESULT hr;

                    hr = pdisp->GetIDsOfNames(IID_NULL, &bstrClose, 1, LOCALE_SYSTEM_DEFAULT, &dispid);
                    if (hr == S_OK)
                        pdisp->Invoke(dispid, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &dispparamsNoArgs, &varTmp, NULL, NULL);

                    SysFreeString(bstrClose);
                }

                pdisp->Release();
            }
        }
        
        VariantClear(&varProp);
        SysFreeString(bstrName);
    }

    return S_OK;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::_GetWebBrowserForEvt
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::_GetWebBrowserForEvt(IDispatch     * pDispatch,
                                    IWebBrowser2 ** ppWebBrowser)
{
    if (_fIsViewLinkedWebOC && _pDispViewLinkedWebOCFrame && _fHadFirstBeforeNavigate)
    {
        *ppWebBrowser = _pDispViewLinkedWebOCFrame;
        _pDispViewLinkedWebOCFrame->AddRef();

        return S_OK;
    }
    else if (pDispatch)  // Top-level
    {
        return IUnknown_QueryService(pDispatch,
                                     SID_SWebBrowserApp,
                                     IID_PPV_ARG(IWebBrowser2, ppWebBrowser));
    }        
    else
    {
        *ppWebBrowser = _bbd._pautoWB2;

        if (*ppWebBrowser)
        {
            (*ppWebBrowser)->AddRef();
            return S_OK;
        }

        return E_FAIL;
    }
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::GetUrlSearchComponent
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::GetUrlSearchComponent(BSTR * pbstrSearch)
{
    TCHAR sz[MAX_URL_STRING];

    ASSERT(pbstrSearch);
    ASSERT(!*pbstrSearch);
    if (ILGetHiddenString(_bbd._pidlPending ? _bbd._pidlPending : _bbd._pidlCur,
                          IDLHID_URLQUERY,
                          sz,
                          SIZECHARS(sz)))
    {
        *pbstrSearch = SysAllocString(sz);
    }
    return (*pbstrSearch) ? S_OK : E_FAIL;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::IsErrorUrl
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::IsErrorUrl(LPCTSTR lpszUrl, BOOL *pfIsError)
{
    HRESULT hr = S_OK;
    
    if (!lpszUrl || !pfIsError)
    {
        hr = E_INVALIDARG;
        goto Cleanup;
    }

    *pfIsError = ::IsErrorUrl(lpszUrl);
    
Cleanup:
    return hr;
}


//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireNavigateComplete2
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireNavigateComplete2(IHTMLWindow2 * pHTMLWindow2,
                                     DWORD          dwFlags)
{
    if (!pHTMLWindow2)
        return E_POINTER;

    HRESULT hr = E_FAIL;
    BOOL    fIsErrorUrl = FALSE;

    BSTR bstrUrl = GetHTMLWindowUrl(pHTMLWindow2);
    if (bstrUrl)
    {
        // If the URL is a res: URL, _GetPidlForDisplay will return
        // the URL after the # in the res: URL.
        //
        LPITEMIDLIST pidl = _GetPidlForDisplay(bstrUrl, &fIsErrorUrl);

        if (pidl)
        {
            BOOL fViewActivated = FALSE;
            IWebBrowser2 * pWebBrowser = NULL;

            // If this is not a frame, we update the browser
            // state and pass the browser's IWebBrowser2 to 
            // FireEvent_NavigateComplete. If this is a frame,
            // we pass the IWebBrowser2 of the window.
            //
            if (!(dwFlags & NAVDATA_FRAMEWINDOW))
            {
                fViewActivated = _ActivateView(bstrUrl, pidl, dwFlags, fIsErrorUrl);

                if (_dwDocFlags & DOCFLAG_DOCCANNAVIGATE)
                {
                    ATOMICRELEASE(_pHTMLDocument);
                    pHTMLWindow2->get_document(&_pHTMLDocument);
                }

                if (IEHard_ShowOnNavigateComplete())
                {
                    EnableModelessSB(FALSE);
                    IEHard_NavWarning(_bbd._hwnd, IEHard_HostedInIE((IShellBrowser*)this));
                    EnableModelessSB(TRUE);
                }
            }
            else
            {
                if (IsWindowVisible(_bbd._hwnd) 
                    && !(_dwSBSPQueued & SBSP_WRITENOHISTORY)
                    && !(dwFlags & NAVDATA_FRAMECREATION)
                    && !(dwFlags & NAVDATA_RESTARTLOAD)) 
                {
                    IEPlaySound(TEXT("ActivatingDocument"), FALSE);
                }   

                if (_pbsOuter)
                {
                    _pbsOuter->UpdateBackForwardState();
                }
            }

            hr = _GetWebBrowserForEvt((dwFlags & NAVDATA_FRAMEWINDOW) ? pHTMLWindow2 : NULL,
                                      &pWebBrowser);

            if (S_OK == hr && !fViewActivated)
            {
                ASSERT(pWebBrowser);

                // fire the event!
                FireEvent_NavigateComplete(pWebBrowser, pWebBrowser, pidl, _bbd._hwnd);           
            }

            ATOMICRELEASE(pWebBrowser);

            ILFree(pidl);
        }

        SysFreeString(bstrUrl);
    }

    return hr;
}

//+-------------------------------------------------------------------------
//
// Method   : CBaseBrowser2::_ActivateView
//
// Synopsis : If there is a pending view, it will be activated. If there
//            if not a pending view, which is the case when we are 
//            navigating due to a hyperlink, OM navigation, or frame
//            navigation, we update the browser state. (The view is already
//            active in this case.)  In either case, we update the
//            state of the dochost.
//
//--------------------------------------------------------------------------

BOOL
CBaseBrowser2::_ActivateView(BSTR         bstrUrl,
                             LPITEMIDLIST pidl,
                             DWORD        dwFlags,
                             BOOL         fIsErrorUrl)
{
    BOOL fViewActivated = FALSE;

    // Activate the pending view if there is one.
    //
    if (_bbd._psvPending)
    {
        ILFree(_bbd._pidlPending);

        _bbd._pidlPending = ILClone(pidl);

        _fDontUpdateTravelLog = !!(dwFlags & NAVDATA_DONTUPDATETRAVELLOG);

        ASSERT(_pbsOuter);
        _pbsOuter->ActivatePendingView();

        _fDontUpdateTravelLog = FALSE;
        fViewActivated = TRUE;
    }
    else
    {
        UINT uProt = GetUrlSchemeW(bstrUrl);

        if (   uProt != URL_SCHEME_JAVASCRIPT 
            && uProt != URL_SCHEME_VBSCRIPT)
        {
            _UpdateBrowserState(pidl);
        }

        // In the case where there is a pending view
        // ActivatePendingView() will call ViewActivated().
        // Also, the call to ViewActivated() must happen
        // after the current pidl has changed. The current
        // pidl changes in _UpdateBrowserState().
        // 
        if (_phtmlWS)
        {
            _phtmlWS->ViewActivated();
        }

        // Don't play sound for the first navigation (to avoid multiple
        // sounds to be played for a frame-set creation).
        //

        ASSERT(_bbd._psv);

        if (IsWindowVisible(_bbd._hwnd) && !(_dwSBSPQueued & SBSP_WRITENOHISTORY)) 
        {
            IEPlaySound(TEXT("ActivatingDocument"), FALSE);
        }                    
    }

    // In the case of an error URL, we must send the original URL
    // to the dochost. It needs the res: URL in the case of an 
    // error page so it knows not to update the history.
    //
    if (!fIsErrorUrl)
    {
        _UpdateDocHostState(pidl, fIsErrorUrl);
    }
    else
    {
        LPITEMIDLIST pidlOriginal = PidlFromUrl(bstrUrl);

        if (pidlOriginal)
        {
            _UpdateDocHostState(pidlOriginal, fIsErrorUrl);
            ILFree(pidlOriginal);
        }
    }

    if (_pbsOuter)
    {
        _pbsOuter->_OnFocusChange(ITB_VIEW);
    }

    return fViewActivated;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::_UpdateBrowserState
//
//--------------------------------------------------------------------------

void
CBaseBrowser2::_UpdateBrowserState(LPCITEMIDLIST pidl)
{
    ASSERT(pidl);

    ILFree(_bbd._pidlCur);

    _bbd._pidlCur = ILClone(pidl);

    // With the _bbd._pidlCur now updated, we can now call UpdateWindowList to 
    // update the window list with the new pidl.
    //
    _pbsOuter->UpdateWindowList();
    _fGeneratedPage = FALSE;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::_UpdateDocHostState
//
//--------------------------------------------------------------------------

void
CBaseBrowser2::_UpdateDocHostState(LPITEMIDLIST pidl, BOOL fIsErrorUrl) const
{
    DOCHOSTUPDATEDATA dhud;
    VARIANT varVal;

    ASSERT(  (_bbd._psvPending  &&  _bbd._pidlPending)
          || (!_bbd._psvPending && !_bbd._pidlPending));

    ASSERT(!_bbd._pidlPending || ILIsEqual(_bbd._pidlPending, pidl) || fIsErrorUrl);

    IShellView * psv = _bbd._psvPending ? _bbd._psvPending : _bbd._psv;
    ASSERT(psv);

    dhud._pidl = pidl;       
    dhud._fIsErrorUrl = fIsErrorUrl;

    varVal.vt = VT_PTR;
    varVal.byref = &dhud;

    IUnknown_Exec(psv, &CGID_ShellDocView, 
                  SHDVID_UPDATEDOCHOSTSTATE, 0, &varVal, NULL);
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireDocumentComplete
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireDocumentComplete(IHTMLWindow2 * pHTMLWindow2,
                                    DWORD          dwFlags)
{
    if (!pHTMLWindow2)
        return E_POINTER;

    HRESULT hr = E_FAIL;

    BSTR bstrUrl = GetHTMLWindowUrl(pHTMLWindow2);
    if (bstrUrl)
    {                      
        LPITEMIDLIST pidl = _GetPidlForDisplay(bstrUrl);

        if (pidl)
        {
            IWebBrowser2 * pWebBrowser;

            hr = _GetWebBrowserForEvt((dwFlags & NAVDATA_FRAMEWINDOW) ? pHTMLWindow2 : NULL,
                                      &pWebBrowser);
            ASSERT(pWebBrowser);

            if (S_OK == hr)
            {
                FireEvent_DocumentComplete(pWebBrowser, pWebBrowser, pidl);
                pWebBrowser->Release();
            }

            ILFree(pidl);
        }

        SysFreeString(bstrUrl);
    }

    if (!(dwFlags & NAVDATA_FRAMEWINDOW) && !IEHard_ShowOnNavigateComplete())
    {               
        if (_CanShowModalDialogNow())
        {
            // Even if we think we can, don't do it from inside DocumentComplete or any other Trident event.
            // Pumping messages during any of these events is bad for Trident, so we'll do it slightly later.
            
            PostMessage(_bbd._hwnd, WMC_IEHARD_NAVWARNING, 0, 0);                
        }
    }

    return hr;
}


// Determines if we are in a reasonable state to show a random dialog box out of nowhere.
// The browser can get into states where the window is basically useless and no view
// is hosted.  One such case is when a new window navigates to unhostable content 
// (like an exe file).  If we put up a dialog at a bad time, we'll disrupt some sensitive
// Trident timing and the content won't be sent to the download dialog.

BOOL CBaseBrowser2::_CanShowModalDialogNow()
{
    return (_bbd._hwnd && IsWindow(_bbd._hwnd) && IsWindowVisible(_bbd._hwnd) &&
            _bbd._hwndView && IsWindow(_bbd._hwndView) && IsWindowVisible(_bbd._hwndView));
}

 
void CBaseBrowser2::_ShowIEHardNavWarning()
{
    if (_CanShowModalDialogNow())
    {
        // If GetLastActivePopup returns something other than the supplied window, it means
        // there is a modal or modeless dialog that is active, and we don't bother showing any message.       
        
        HWND hwndPopup = GetLastActivePopup(_bbd._hwnd);

        if (hwndPopup == _bbd._hwnd)
        {
            // Most of the time, this means that there are no dialogs attached to us.
            // But there could still be a modeless dialog showing; it just isn't active right now.  
            // We'll show our messagebox anyway, because the same thing would happen if you opened 
            // the About dialog yourself -- it would be parented to the top window, and the modeless
            // dialog would still be dangling around and enabled.
        
            EnableModelessSB(FALSE);
            IEHard_NavWarning(_bbd._hwnd, IEHard_HostedInIE((IShellBrowser*)this));
            EnableModelessSB(TRUE);
        }
    }
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireDownloadBegin
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireDownloadBegin()
{
    return _updateNavigationUI();
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::FireDownloadComplete
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::FireDownloadComplete()
{
    return _updateNavigationUI();
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::GetPendingUrl
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::GetPendingUrl(BSTR * pbstrPendingUrl)
{
    if (!pbstrPendingUrl)
        return E_POINTER;

    *pbstrPendingUrl = NULL;

    LPITEMIDLIST pidl = _bbd._pidlPending ? _bbd._pidlPending : _bbd._pidlCur;

    TCHAR szPath[INTERNET_MAX_URL_LENGTH + 1];

    HRESULT hr = IEGetDisplayName(pidl, szPath, SHGDN_FORPARSING);
    if (S_OK == hr)
    {
        TraceMsg(DM_TRACE, "CBaseBrowser2::GetPendingUrl - URL: %ws", szPath);

        *pbstrPendingUrl = SysAllocString(szPath);
    }

    return (*pbstrPendingUrl) ? S_OK : E_FAIL;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::ActiveElementChanged
//
//  Interface : ITridentService
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::ActiveElementChanged(IHTMLElement * pHTMLElement)
{
    // Forward the call to the OmWindow
    //
    if (_phtmlWS)
    {
        return _phtmlWS->ActiveElementChanged(pHTMLElement);
    }

    return E_FAIL;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::InitAutoImageResize()
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::InitAutoImageResize()
{
    HRESULT hr = S_OK;
   
    if (_pAIResize)
        UnInitAutoImageResize();

    CAutoImageResize *pAIResize = new CAutoImageResize();
    if (pAIResize)
    {
        // need to get a pDoc2 for the init call...
        IDispatch *pDocDispatch;
        hr = _bbd._pautoWB2->get_Document(&pDocDispatch);
        if (SUCCEEDED(hr))
        {
            IHTMLDocument2 *pDoc2;
            hr = pDocDispatch->QueryInterface(IID_PPV_ARG(IHTMLDocument2,&pDoc2));
            if (SUCCEEDED(hr))
            {
                // init the object
                pAIResize->Init(pDoc2); 

                // cache the pointer for destruction later
                _pAIResize=pAIResize;

                pDoc2->Release();
            }
            pDocDispatch->Release();
        }

        if (FAILED(hr))
        {
            delete pAIResize;
        }
    }
    else
        hr = E_OUTOFMEMORY;

    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::UnInitAutoImageResize()
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::UnInitAutoImageResize()
{
    if (_pAIResize)
    {
        _pAIResize->UnInit();
        ATOMICRELEASE(_pAIResize);
    }

    return S_OK;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::IsGalleryMeta
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::IsGalleryMeta(BOOL bFlag, void *pMyPics)
{
    // Forward the call to the CMyPics object
    //

    if (pMyPics)
    {
        ((CMyPics*)pMyPics)->IsGalleryMeta(bFlag);
        return S_OK;
    }

    return E_FAIL;
}

//+-------------------------------------------------------------------------
//
// Functions that live in mypics.cpp that are called below
//
//--------------------------------------------------------------------------

HRESULT SendDocToMailRecipient(LPCITEMIDLIST pidl, UINT uiCodePage, DWORD grfKeyState, IUnknown *pUnkSite);
BOOL    MP_IsEnabledInIEAK();
BOOL    MP_IsEnabledInRegistry();


//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::EmailPicture
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------

HRESULT
CBaseBrowser2::EmailPicture(BSTR bstrURL)
{
    IDispatch *pDocDispatch;
    HRESULT hr = _bbd._pautoWB2->get_Document(&pDocDispatch);
    if (SUCCEEDED(hr))
    {
        IHTMLDocument2 *pDoc2;
        hr = pDocDispatch->QueryInterface(IID_PPV_ARG(IHTMLDocument2, &pDoc2));
        if (SUCCEEDED(hr))
        {
            // Get that cmd target thingie...
            IOleCommandTarget *pcmdt;
            hr = IUnknown_QueryService(pDoc2, SID_SWebBrowserApp, IID_PPV_ARG(IOleCommandTarget, &pcmdt));
            if (SUCCEEDED(hr))
            {
                // ... and thus the pidl...
                LPITEMIDLIST pidlForImg;
                hr = IEParseDisplayName(CP_ACP, bstrURL, &pidlForImg);
                if (SUCCEEDED(hr))
                {                    
                    // ... and pray this works...
                    SendDocToMailRecipient(pidlForImg, 0, FORCE_COPY, pcmdt);
                    
                    ILFree(pidlForImg);
                }
                pcmdt->Release();
            }
            pDoc2->Release();
        }
        pDocDispatch->Release();
    }
    
    return hr;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::AttachMyPics
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------


HRESULT
CBaseBrowser2::AttachMyPics(void *pDoc2, void **ppMyPics)
{
    IHTMLDocument2 *pdoc2     = (IHTMLDocument2 *)pDoc2;
    DWORD           dwOptions = 0;

    ASSERT(ppMyPics && *ppMyPics==NULL);

    if (!MP_IsEnabledInIEAK()     || 
        !MP_IsEnabledInRegistry() ||
        !IsInternetExplorerApp()) 
    {
        return S_OK;
    }

    if (!pdoc2 || !ppMyPics || (*ppMyPics != NULL)) 
    {
        return S_OK;
    }

    //Is this a desktop component?                    
    if (SUCCEEDED(GetTopFrameOptions(_pspOuter, &dwOptions)))
    {    
        if (dwOptions & FRAMEOPTIONS_DESKTOP) 
        {
            return S_OK;
        }
    }

    CMyPics *pPics = new CMyPics();

    if (pPics)
    {
        if (SUCCEEDED(pPics->Init(pdoc2))) 
        {
            *ppMyPics = pPics;
        } 
        else 
        {
            pPics->Release();
        }
    }

    return S_OK;
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::ReleaseMyPics
//
//  Interface : ITridentService2
//
//--------------------------------------------------------------------------

BOOL
CBaseBrowser2::ReleaseMyPics(void *pMyPics)
{
    CMyPics *pPics = (CMyPics *) pMyPics;

    BOOL bRet = pPics->IsOff();

    if (pPics) 
    {
        pPics->UnInit();
        pPics->Release();
    }

    return (bRet);
}

STDMETHODIMP CBaseBrowser2::SetFrameName(BSTR bstrFrameName)
{
    return StringCchCopy(_szViewLinkedWebOCFrameName, ARRAYSIZE(_szViewLinkedWebOCFrameName), bstrFrameName);
}

//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::AppStarting
//
//  Interface : INotifyAppStart
//
//--------------------------------------------------------------------------
HRESULT
CBaseBrowser2::AppStarting(void)
{
    _dwStartingAppTick = GetTickCount();
    SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
    SetTimer( _bbd._hwnd, IDT_STARTING_APP_TIMER, STARTING_APP_DURATION, NULL);

    return S_OK;
}


//+-------------------------------------------------------------------------
//
//  Method    : CBaseBrowser2::AppStarted
//
//  Interface : INotifyAppStart
//
//--------------------------------------------------------------------------
HRESULT
CBaseBrowser2::AppStarted(void)
{
    _dwStartingAppTick = 0;
    KillTimer( _bbd._hwnd, IDT_STARTING_APP_TIMER );
    SetCursor(LoadCursor(NULL, IDC_ARROW));

    return S_OK;
}