windows-server-2003/shell/browseui/dockbar.cpp

#include "priv.h"
#include "sccls.h"
#include "resource.h"
#include "mshtmhst.h"
#include "desktopp.h"   // DTRF_RAISE etc.

#define WANT_CBANDSITE_CLASS
#include "bandsite.h"

#include "deskbar.h"
#include "theater.h"

#include "mluisupp.h"

#define SUPERCLASS CBaseBar

#define DM_PERSIST      0               // trace IPS::Load, ::Save, etc.
#define DM_POPUI        0               // expando-UI (proto)
#define DM_MENU         0               // trace menu code
#define DM_DRAG         0               // drag move/size (terse)
#define DM_DRAG2        0               // ... (verbose)
#define DM_API          0               // trace API calls
#define DM_HIDE         DM_TRACE               // autohide
#define DM_HIDE2        DM_TRACE               // autohide (verbose)
#define DM_APPBAR       0               // SHAppBarMessage calls
#define DM_OLECT        0               // IOleCommandTarget calls
#define DM_FOCUS        0               // focus change
#define DM_RES          DM_WARNING      // resolution

#define ABS(i)  (((i) < 0) ? -(i) : (i))

#define RECTGETWH(uSide, prc)   (ABE_HORIZ(uSide) ? RECTHEIGHT(*prc) : RECTWIDTH(*prc))

//***   CDB_INITED -- has CDockingBar::_Initialize been called
//
#define CDB_INITED()   (_eInitLoaded && _fInitSited && _fInitShowed)

enum ips_e {
    IPS_FALSE,    // reserved, must be 0 (FALSE)
    IPS_LOAD,
    IPS_LOADBAG,
    IPS_INITNEW,
    IPS_LAST
};

CASSERT(IPS_FALSE == 0);
CASSERT(((IPS_LAST - 1) & 0x03) == (IPS_LAST - 1)); // 2-bit _eInitLoaded


//***   CXFLOAT -- distance from edge to 'float' zone 
// NOTES
//  pls forgive the lousy hungarian...
#define CXFLOAT()   GetSystemMetrics(SM_CXICON)
#define CYFLOAT()   GetSystemMetrics(SM_CYICON)
#define CXYHIDE(uSide)  2       // FEATUE: GetSystemMetrics(xxx), we need an appropriate system metric

#ifdef DEBUG
#if 0   // turn on to debug autohide boundary cases
int g_cxyHide = 8;
#undef  CXYHIDE
#define CXYHIDE(uSide)  g_cxyHide
#endif
#endif

#define CXSMSIZE()  GetSystemMetrics(SM_CXSMSIZE)
#define CYSMSIZE()  GetSystemMetrics(SM_CYSMSIZE)


#ifdef DEBUG
extern unsigned long DbStreamTell(IStream *pstm);
extern BOOL DbCheckWindow(HWND hwnd, RECT *prcExp, HWND hwndClient);
TCHAR *DbMaskToMneStr(UINT uMask, TCHAR *szMnemonics);
#else
#define DbStreamTell(pstm) 0
#define DbCheckWindow(hwnd, prcExp, hwndClient) 0
#define DbMaskToMneStr(uMask, szMnemonics) szMnemonics
#endif

//***   autohide -- design note
//
// here's an overview of how we do autohide.  see the code for details.
//
// only a few routines really know about it.  their behavior is driven
// by '_fHiding'.  when FALSE, they behave normally.  when TRUE, they
// do alternate 'fake' behavior.
//
// a 'real' or 'normal' rect is the full-size rect we display when not hidden.
// a 'fake' or 'tiny' rect is the very thin rect we display when hidden.
// (plus there's a '0-width' rect we register w/ the system when we're hidden).
//
// more specifically,
//
// when fHiding is TRUE, a few routines have alternate 'fake' behavior:
//      _ProtoRect      returns a 'tiny' rect rather than the 'real' rect
//      _NegotiateRect  is a NOOP (so we don't change the 'tiny' rect) 
//      _SetVRect       is a NOOP (so we don't save   the 'tiny' rect)
//      AppBarSetPos    is a NOOP (so we don't set    the 'tiny' rect)
// plus, a few routines handle transitions (and setup):
//      _DoHide         hide/unhide helper
//      _MoveSizeHelper detects and handles transitions
//      _HideReg        register autohide appbar w/ 0-width rect
// and finally, a few messages trigger the transitions:
//      unhide          WM_NCHITTEST on the 'tiny' rect starts the unhide.
//              actually it starts a timer (IDT_AUTOUNHIDE) so there's a
//              bit of hysteresis.
//      hide            WM_ACTIVATE(deact) starts a timer (IDT_AUTOHIDE)
//              which we use to poll for mouse leave events.  again, there
//              is some hysteresis, plus some additional heuristics for hiding.
//              WM_ACTIVATE(act) stops the timer.
//
// #if 0
// we also have 'manual hide'.  manual hide differs from autohide as follows:
//     autohide never negotiates space(*)   , manual hide always does
//     autohide is focus- and cursor- driven, manual hide is UI-driven
//     (*) actually it negotiates space of '0'.
// e.g. 'manual hide' is used for the BrowserBar (e.g. search results).
// however for now at least 'manual hide' is simply a ShowDW(FALSE).
// #endif

void CDockingBar::_AdjustToChildSize()
{
    if (_szChild.cx)
    {
        RECT rc, rcChild;
    
        GetWindowRect(_hwnd, &rc);
        GetClientRect(_hwndChild, &rcChild);

        // we need to change rc by the delta of prc-rcChild
        rc.right += _szChild.cx - RECTWIDTH(rcChild);
        rc.bottom += _szChild.cy - RECTHEIGHT(rcChild);

        _SetVRect(&rc);
    
        _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);

        _szChild.cx = 0;
    }
}

void CDockingBar::_OnPostedPosRectChange()
{
    if (_ptbSite) {
        if (!_fDragging) {
            _AdjustToChildSize();
        }
    }
}

HMENU CDockingBar::_GetContextMenu()
{
    HMENU hmenu = LoadMenuPopup(MENU_WEBBAR);
    if (hmenu) {

        // _eMode
        if (!ISWBM_DESKTOP())
        {
            EnableMenuItem(hmenu, IDM_AB_TOPMOST, MF_BYCOMMAND | MF_GRAYED);
            EnableMenuItem(hmenu, IDM_AB_AUTOHIDE, MF_BYCOMMAND | MF_GRAYED);
        }
        CheckMenuItem(hmenu, IDM_AB_TOPMOST, WBM_IS_TOPMOST() ? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));

        // hide
        // we use _fWantHide (not _fCanHide) to reflect what user asked
        // for, not what he got.  o.w. you can't tell what the state is
        // unless you actually get it.
        CheckMenuItem(hmenu, IDM_AB_AUTOHIDE,
            MF_BYCOMMAND | (_fWantHide ? MF_CHECKED : MF_UNCHECKED));

        CASSERT(PARENT_XTOPMOST == HWND_DESKTOP);   // for WM_ACTIVATE
        CASSERT(PARENT_BTMMOST() == HWND_DESKTOP);  // for WM_ACTIVATE
        if (_eMode & WBM_FLOATING)
        {
            // (for now) only desktop btm/topmost does autohide
            EnableMenuItem(hmenu, IDM_AB_AUTOHIDE, MF_BYCOMMAND | MF_GRAYED);
        }

#ifdef DEBUG
        // FEATURE temporary until we make browser tell us about activation
        CheckMenuItem(hmenu, IDM_AB_ACTIVATE,
            MF_BYCOMMAND | (_fActive ? MF_CHECKED : MF_UNCHECKED));
#endif

    }
    return hmenu;
}

HRESULT CDockingBar::_TrackPopupMenu(const POINT* ppt)
{
    HRESULT hres = S_OK;

    HMENU hmenu = _GetContextMenu();
    if (hmenu)
    {
        TrackPopupMenu(hmenu, /*TPM_LEFTALIGN|*/TPM_RIGHTBUTTON,
            ppt->x, ppt->y, 0, _hwnd, NULL);
        DestroyMenu(hmenu);
    }
    else
    {
        hres = E_OUTOFMEMORY;
    }

    return hres;
}

void CDockingBar::_HandleWindowPosChanging(LPWINDOWPOS pwp)
{
}

/***
 */
LRESULT CDockingBar::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LRESULT lres = 0;
    POINT pt;
    DWORD pos;
    RECT rc;

    switch (uMsg) {
    case WM_CLOSE:
        _AppBarOnCommand(IDM_AB_CLOSE);   // _RemoveToolbar(0)
        break;

    case WM_DESTROY:
        if (_fAppRegistered)
            _AppBarRegister(FALSE);
        break;

    case APPBAR_CALLBACK:
        _AppBarCallback(hwnd, uMsg, wParam, lParam);
        return 0;

    case WM_CONTEXTMENU:
        if (_CheckForwardWinEvent(uMsg, wParam, lParam, &lres))
            break;
            
        if ((LPARAM)-1 == lParam)
        {
            GetClientRect(_hwnd, &rc);
            MapWindowRect(_hwnd, HWND_DESKTOP, &rc);
            pt.x = rc.left + (rc.right - rc.left) / 2;
            pt.y = rc.top + (rc.bottom - rc.top) / 2;
        }
        else
        {
            pt.x = GET_X_LPARAM(lParam);
            pt.y = GET_Y_LPARAM(lParam);
        }
        _TrackPopupMenu(&pt);
        break;

    case WM_ENTERSIZEMOVE:
        ASSERT(_fDragging == 0);
        _fDragging = 0;         // reset if busted
        _xyPending = XY_NIL;
#if XXX_CANCEL
        GetWindowRect(hwnd, &_rcCapture);      // to detect cancel
#endif
        break;

    case WM_SYSCHAR:
        if (wParam == TEXT(' '))
        {
            HMENU hmenu;

            hmenu = GetSystemMenu(hwnd, FALSE);
            if (hmenu) {
                EnableMenuItem(hmenu, SC_RESTORE, MFS_GRAYED | MF_BYCOMMAND);
                EnableMenuItem(hmenu, SC_MAXIMIZE, MFS_GRAYED | MF_BYCOMMAND);
                EnableMenuItem(hmenu, SC_MINIMIZE, MFS_GRAYED | MF_BYCOMMAND);
            }
        }
        goto DoDefault;

    case WM_SIZING:     // goto DoDefault? I doubt it.
    case WM_MOVING:
        {
            LPRECT prc = (RECT*)lParam;

            pos = GetMessagePos();
            if (_fDragging == 0)
            {
                // 1st time
                _DragEnter(uMsg, GET_X_LPARAM(pos), GET_Y_LPARAM(pos), prc);
                ASSERT(_fDragging != 0);
            }
            else
            {
                // 2nd..Nth time
                _DragTrack(uMsg, GET_X_LPARAM(pos), GET_Y_LPARAM(pos), prc, 0);
            }
        }
        return 1;

    case WM_MOVE:       // xLeft , yTop
    case WM_SIZE:       // xWidth, yHeight
        if (_fDragging)
        {
            RECT rcTmp;

            CopyRect(&rcTmp, &_rcPending);
            _DragTrack(uMsg, GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending),
                &rcTmp, 1);
        }

        _OnSize();    // PERF: only needed for WM_SIZE? At worst this might cause a sligth flicker.
        break;
        
    case WM_EXITSIZEMOVE:
        _DragLeave(-1, -1, TRUE);
        ASSERT(_fDragging == 0);

        break;

    case WM_CHILDACTIVATE:
        if (_eMode == WBM_BFLOATING)
            SendMessage(_hwnd, WM_MDIACTIVATE, (WPARAM)_hwnd, 0);
        goto DoDefault;
        
    case WM_WINDOWPOSCHANGING:
        _HandleWindowPosChanging((LPWINDOWPOS)lParam);
        break;

    case WM_WINDOWPOSCHANGED:
Lfwdappbar:
        if (_fAppRegistered)
            _AppBarOnWM(uMsg, wParam, lParam);
        goto DoDefault;        // fwd on so we'll get WM_SIZE etc.

    case WM_TIMER:
        switch (wParam) {

        case IDT_AUTOHIDE:
            {
                ASSERT(_fWantHide && _fCanHide);

                GetCursorPos(&pt);
                GetWindowRect(hwnd, &rc);
                // add a bit of fudge so we don't hide when trying to grab the edge
                InflateRect(&rc, GetSystemMetrics(SM_CXEDGE) * 4,
                    GetSystemMetrics(SM_CYEDGE)*4);

                HWND hwndAct = GetActiveWindow();

                if (!PtInRect(&rc, pt) && hwndAct != hwnd &&
                  (hwndAct == NULL || ::GetWindowOwner(hwndAct) != hwnd))
                  {
                    // to hide, we need to be outside the inflated window,
                    // and we can't be active (for keyboard users).
                    // (heuristics stolen from tray.c)
                    // FEATURE: tray.c also checks TM_SYSMENUCOUNT == 0

                    _DoHide(AHO_KILLDO|AHO_MOVEDO);
                }
            }
            break;

        case IDT_AUTOUNHIDE:    // FEATURE: share code w/ IDT_AUTOHIDE
            ASSERT(_fWantHide && _fCanHide);

            if (_fHiding)
            {
                ASSERT(_fHiding == HIDE_AUTO);
                GetCursorPos(&pt);
                GetWindowRect(hwnd, &rc);
                if (PtInRect(&rc, pt))
                    _DoHide(AHO_KILLUN|AHO_MOVEUN|AHO_SETDO);
                else
        Lkillun:
                    _DoHide(AHO_KILLUN);
            }
            else
            {
                // if we mouse-over and then TAB very quickly, we can end
                // up getting a WM_ACT followed by a WM_TIMER (despite the
                // KillTimer inside OnAct).  if so we need to be careful
                // not to do an AHO_SETDO.  just to be safe we do an
                // AHO_KILLUN as well.
                TraceMsg(DM_HIDE, "cwb.WM_T: !_fHiding (race!) => AHO_KILLUN");
                goto Lkillun;
            }
            break;

        default:
            goto DoDefault;
        }

        break;

    case WM_NCLBUTTONDOWN:
    case WM_LBUTTONDOWN:
        goto DoDefault;


    case WM_ACTIVATE:
        _OnActivate(wParam, lParam);
        goto Lfwdappbar;

    case WM_GETMINMAXINFO:  // prevent it from getting too small
        // n.b. below stuff works for scheme 'win standard large'
        // but not for v. large edges.  not sure why, but we'll
        // have to fix it or the original bug will still manifest
        // on accessibility-enabled machines.

        // nt5:149535: resize/drag of v. small deskbar.
        // APPCOMPAT workaround USER hittest bug for v. small windows.
        // DefWndProc(WM_NCHITTEST) gives wrong result (HTLEFT) when
        // window gets too small.  so stop it from getting v. small.
        //
        // the below calc actually gives us slightly *more* than the
        // min size, but what the heck.  e.g. it gives 8+15+1=24,
        // whereas empirical tests give 20.  not sure why there's a
        // diff, but we'll use the bigger # to be safe.
        {
            RECT rcTmp = {100,100,100,100}; // arbitrary 0-sized rect
            LONG ws, wsx;
            HWND hwndTmp;

            _GetStyleForMode(_eMode, &ws, &wsx, &hwndTmp);
            AdjustWindowRectEx(&rcTmp, ws, FALSE, wsx);

            ((MINMAXINFO *)lParam)->ptMinTrackSize.x = RECTWIDTH(rcTmp)  + CXSMSIZE() + 1;
            ((MINMAXINFO *)lParam)->ptMinTrackSize.y = RECTHEIGHT(rcTmp) + CYSMSIZE() + 1;
            if (ISWBM_FLOAT(_eMode))
            {
                // nt5:169734 'close' button on v. small floating deskbar.
                // APPCOMPAT workaround USER 'close' button bug for v. small windows.
                // the button on a v. small TOOLWINDOW doesn't work.
                // empirically the below adjustment seems to work.
                ((MINMAXINFO *)lParam)->ptMinTrackSize.x += (CXSMSIZE() + 1) * 3 / 2;
                ((MINMAXINFO *)lParam)->ptMinTrackSize.y += (CYSMSIZE() + 1) * 3 / 2;
            }
            TraceMsg(DM_TRACE, "cwb.GMMI: x=%d", ((MINMAXINFO *)lParam)->ptMinTrackSize.x);
        }
        break;

    case WM_NCHITTEST:
        return _OnNCHitTest(wParam, lParam);

    case WM_WININICHANGE:
        // Active Desktop *broadcasts* a WM_WININICHANGE SPI_SETDESKWALLPAPER
        // message when starting up. If this message gets processed during
        // startup at just the right time, then the bands will notify their
        // preferred state, and we lose the persisted state.  Since the desktop
        // wallpaper changing is really of no interest to us, we filter it out here.
        //
        // REVIEW CDTURNER: Would we get a perf win by punting a larger class
        // of these wininichange messages? It seems like most won't affect
        // the contents of a deskbar...
        //
        if (SPI_SETDESKWALLPAPER == wParam)
            break;

        goto DoDefault;
        
    default:
DoDefault:
        return SUPERCLASS::v_WndProc(hwnd, uMsg, wParam, lParam);
    }

    return lres;
}

LRESULT CDockingBar::_OnNCHitTest(WPARAM wParam, LPARAM lParam)
{
    if (_fHiding)
        _DoHide(AHO_SETUN);

    // get 'pure' hittest...
    LRESULT lres = _CalcHitTest(wParam, lParam);

    // ... and perturb it based on where we're docked
    BOOL fSizing = FALSE;
    if (ISWBM_FLOAT(_eMode)) {
        // standard sizing/moving behavior
        return lres;
    }
    else {
        // opposing edge sizes; any other edge moves
        ASSERT(ISABE_DOCK(_uSide));
        switch (_uSide) {
        case ABE_LEFT:
            //  
            // Mirror the edges (since we are dealing with screen coord)
            // if the docked-window parent is mirrored. [samera]
            //
            if (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)))
                fSizing = (lres==HTLEFT);
            else
                fSizing = (lres==HTRIGHT);
            break;
        case ABE_RIGHT:
            //  
            // Mirror the edges (since we are dealing with screen coord)
            // if the docked-window parent is mirrored.
            //
            if (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)))
                fSizing = (lres==HTRIGHT);
            else
                fSizing = (lres==HTLEFT);
            break;
        case ABE_TOP:
            fSizing = (lres==HTBOTTOM);
            break;
        case ABE_BOTTOM:
            fSizing = (lres==HTTOP);
            break;

        default: 
            ASSERT(0); 
            break;
        }
    }

    if (!fSizing) {
        lres = HTCAPTION;
    }
    return lres;
}

//***   _OnActivate --
//
void CDockingBar::_OnActivate(WPARAM wParam, LPARAM lParam)
{
    TraceMsg(DM_HIDE, "cwb.WM_ACTIVATE wParam=%x", wParam);
    if (_fCanHide) {
        ASSERT(_fHiding != HIDE_MANUAL);
        if (LOWORD(wParam) != WA_INACTIVE) {
            // activate
            TraceMsg(DM_HIDE, "cdb._oa:  WM_ACT(act) _fHiding=%d", _fHiding);
            // turn off timers for perf
            // nash:40992: unhide if hidden (e.g. TABed to hidden)
            _DoHide(AHO_KILLDO|AHO_MOVEUN);
        }
        else {
            // deactivate
            _DoHide(AHO_SETDO);         // restore
        }
    }

    return;
}

/***
 */
CDockingBar::CDockingBar() : _eMode(WBM_NIL), _uSide(ABE_RIGHT)
{
    ASSERT(_fIdtUnHide == FALSE);
    ASSERT(_fIdtDoHide == FALSE);
    _ptIdtUnHide.x = _ptIdtUnHide.y = -1;

    // set up worst-case defaults.  we'll end up using them for:
    //     - some of them for Load(bag)
    //     - all  of them for InitNew()
    // note that we might call _InitPos4 again in SetSite.
    _InitPos4(TRUE);

    return;
}

//***   _Initialize -- 2nd-phase ctor
// NOTES
//  we need any IPS::Load settings and also a site before we can init
//  ourself, so most initialization waits until here.
void CDockingBar::_Initialize()
{
    ASSERT(!_fInitShowed);
    ASSERT(_fInitSited && _eInitLoaded);
    ASSERT(!CDB_INITED());

    _fInitShowed = TRUE;

    // warning: delicate phase-ordering here...
    UINT eModeNew = _eMode;
    _eMode = WBM_NIL;
    UINT uSideNew = _uSide;
    _uSide = ABE_NIL;
    HMONITOR hMonNew = _hMon;
    _hMon = NULL;
    // 48463: beta reports fault on boot when we have deskbar+taskbar on
    // same edge (non-merged).  i'm guessing (no proof) that shdocvw isn't
    // init'ed enough early on during boot to handle doing a MergeBS, or
    // alternately that there's a race btwn the tray and desktop threads.
    //
    // plus in any case we shouldn't do the merge just because the guy did
    // a logoff/logon!
    _SetModeSide(eModeNew, uSideNew, hMonNew, /*fNoMerge*/_eInitLoaded == IPS_LOAD);

    _NotifyModeChange(0);

    // if we have a bar on the right and we drag a band from it to
    // the top, we end up getting a sequence:
    //      create deskbar; AddBand; SetSite; _Initialize
    // the AddBand of the (1st) band tries to do an autosize but
    // there's no site yet, so nothing happens.
    //
    // so we need to force it here.
    _AdjustToChildSize();

    if (_fWantHide) {
        _fWantHide = FALSE;
        _AppBarOnCommand(IDM_AB_AUTOHIDE);
    }

    ASSERT(CDB_INITED());

    return;
}

/***
 */
CDockingBar::~CDockingBar()
{
    ASSERT(!_fAppRegistered);   // make sure _ChangeTopMost(WBM_NIL) was called

    // make sure SetSite(NULL); was called
    ASSERT(!_ptbSite);
    return;
}


void CDockingBar::_GetChildPos(LPRECT prc)
{
    GetClientRect(_hwnd, prc);
}

//***   _OnSize -- compute size for OC, leaving room for toolbar (caption?)
//
void CDockingBar::_OnSize(void)
{
    RECT rc;

    if (!_hwndChild || !_eInitLoaded)
        return;

    ASSERT(IsWindow(_hwndChild));

    // don't resize on a hide (it's temporary and we don't want things
    // to jerk around or worse still do a destructive reformat)
    // APPCOMPAT: should suppress resizing here in theater mode autohide
    // too (see theater.cpp)
    if (_fHiding)
        return;

    _GetChildPos(&rc);
    // (used to do ISWBM_EDGELESS 'fake edge' adjustments here, someone
    // nuked them, but should be o.k. now that visuals are frozen *provided*
    // we don't go back to edgeless)

    SetWindowPos(_hwndChild, 0,
            rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc),
            SWP_NOACTIVATE|SWP_NOZORDER);
    //ASSERT(DbCheckWindow(_hwndChild, &rc, xxx));
}

//***   _CalcHitTest --
// NOTES
//      really only has to return an int (win16?)
LRESULT CDockingBar::_CalcHitTest(WPARAM wParam, LPARAM lParam)
{
    LRESULT lRet;

    if (!(ISWBM_BOTTOM(_eMode) && ISWBM_EDGELESS(_eMode))) {
        // For non-btmmost, we can ask USER to perform the default
        // hit testing.
        lRet = DefWindowProcWrap(_hwnd, WM_NCHITTEST, wParam, lParam);
    } else {
        // For btmmost, we need to do it.
        // (possibly dead code if bottom is never edgeless)
        // (if so, compiler should optimize it out)

        //TraceMsg(DM_WARNING, "cdb.ro: edgeless!");

        RECT rc;
        GetWindowRect(_hwnd, &rc);
        UINT x = GET_X_LPARAM(lParam);
        UINT y = GET_Y_LPARAM(lParam);
        // actually SM_C?SIZEFRAME is too big, but we get away w/ it
        // since we've been initiated by a WM_NCHITTEST so we know
        // we're on *some* edge
        UINT cx = GetSystemMetrics(SM_CXSIZEFRAME);
        UINT cy = GetSystemMetrics(SM_CYSIZEFRAME);
        if (_eMode == WBM_BBOTTOMMOST)
            cx *= 2;

        lRet = HTCAPTION;
        if (x > rc.right-cx) {
            lRet = HTRIGHT;
        } else if (x < rc.left+cx) {
            lRet = HTLEFT;
        } else if (y < rc.top+cy) {
            lRet = HTTOP;
        } else if (y > rc.bottom-cy) {
            lRet = HTBOTTOM;
        }
    }

    return lRet;
}

//***
//
void CDockingBar::_DragEnter(UINT uMsg, int x, int y, RECT* rcFeed)
{
    ASSERT(_fDragging == 0);

    if ((!(_eMode & WBM_FLOATING)) && uMsg == WM_MOVING)
    {
        // APPCOMPAT workaround USER non-full-drag drag rect bug
        // by forcing rcFeed back to exact current location (rather than
        // leaving at initial offset that USER gave us).
        //
        // w/o this code a drag from right to top in non-full-drag mode
        // will leave drag-rect droppings at the top of the original
        //
        // APPCOMPAT but, this seems to make things *worse* if !ISWBM_DESKTOP(),
        // so we don't do it in that case...  (sigh).
        _MoveSizeHelper(_eMode, _uSide, _hMon, NULL, rcFeed, FALSE, FALSE);
    }

    _eModePending = _eMode;
    _uSidePending = _uSide;
    _xyPending = MAKELPARAM(x, y);
    _hMonPending = _hMon;
    ASSERT(rcFeed != 0);
    if (rcFeed != 0)
        CopyRect(&_rcPending, rcFeed);

#if XXX_CANCEL
    RECT rcTmp;

    GetWindowRect(_hwnd, &rcTmp);
    TraceMsg(DM_DRAG2,
        "cwb.de: rcTmp=(%d,%d,%d,%d) (%dx%d) _rcCapture=(%d,%d,%d,%d) (%dx%d)",
        rcTmp.left, rcTmp.top, rcTmp.right, rcTmp.bottom,
        RECTWIDTH(rcTmp), RECTHEIGHT(rcTmp),
        _rcCapture.left, _rcCapture.top, _rcCapture.right, _rcCapture.bottom,
        RECTWIDTH(_rcCapture), RECTHEIGHT(_rcCapture));
#endif

    switch (uMsg) {
    case WM_MOVING: _fDragging = DRAG_MOVE; break;
    case WM_SIZING: _fDragging = DRAG_SIZE; break;

    default: ASSERT(0); break;
    }

    if (_fDragging == DRAG_MOVE) {
        // turn off size negotiation to prevent horz/vert pblms.
        //
        // e.g. when we drag a floating guy to horz/vert, there's
        // a period of time during which we have a horz/vert size,
        // but still think we're floating, which screws up size
        // negotiation royally.
        _ExecDrag(DRAG_MOVE);
    }

    return;
}

//***
//
void CDockingBar::_DragTrack(UINT uMsg, int x, int y, RECT* rcFeed, int eState)
{
#if DM_API
    TraceMsg(DM_DRAG2,
        "cwb.dt: API s=%d xy=(%d,%d) rc=(%d,%d,%d,%d) (%dx%d)",
        eState, x, y,
        _PM(rcFeed,left), _PM(rcFeed,right), _PM(rcFeed,bottom), _PM(rcFeed,right),
        _PX(rcFeed,RECTWIDTH(*rcFeed)), _PX(rcFeed,RECTHEIGHT(*rcFeed)));
#endif

    ASSERT(_fDragging != 0);

    switch (eState) {
    case 0:     // WM_MOVING
        {
            BOOL fImmediate = ((!_fDesktop) && uMsg == WM_SIZING) ? TRUE:FALSE;

            // remember for eventual commit
            _xyPending = MAKELPARAM(x, y);
            ASSERT(rcFeed != NULL);
            CopyRect(&_rcPending, rcFeed);

            // snap and give feedback
            _TrackSliding(x, y, rcFeed, fImmediate, fImmediate);

            break;
        }
    case 1:     // WM_MOVE
        TraceMsg(DM_DRAG2,
            "cwb.dt: %s _xyPend=(%d,%d) xy=(%d,%d)",
            (_xyPending != MAKELPARAM(x, y)) ? "noop/cancel" : "commit",
            GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending), x, y);

        break;

    default: ASSERT(0); break;
    }

    return;
}

//***
//
void CDockingBar::_DragLeave(int x, int y, BOOL fCommit)
{
#if DM_API
    TraceMsg(DM_DRAG,
        "cwb.dl: API xy=(%d,%d) fCommit=%d",
        x, y, fCommit);
#endif

    if (_fDragging == 0) {
        // when we're inside a browser and you move the browser window
        // we get WM_ENTERSIZEMOVE/ WM_EXITSIZEMOVE but never any
        // WM_MOVING/WM_MOVE/WM_SIZING/WM_SIZE
        return;
    }

    switch (_fDragging) {
    case DRAG_MOVE:
    case DRAG_SIZE:
        break;
    default: ASSERT(0); break;
    }

#if XXX_CANCEL
    RECT rcTmp;

    GetWindowRect(_hwnd, &rcTmp);
    TraceMsg(DM_DRAG2,
        "cwb.dl: rcTmp=(%d,%d,%d,%d) (%dx%d) _rcCapture=(%d,%d,%d,%d) (%dx%d)",
        rcTmp.left, rcTmp.top, rcTmp.right, rcTmp.bottom,
        RECTWIDTH(rcTmp), RECTHEIGHT(rcTmp),
        _rcCapture.left, _rcCapture.top, _rcCapture.right, _rcCapture.bottom,
        RECTWIDTH(_rcCapture), RECTHEIGHT(_rcCapture));
    TraceMsg(DM_DRAG2, "cwb.dl: %s",
        EqualRect(&rcTmp, &_rcCapture) ? "noop/cancel" : "commit");
#endif

    BOOL fCancel = FALSE;       // FEATURE: todo: cancel NYI

    if (!fCancel) {
        if (_fDragging == DRAG_MOVE) {
            // nt5:187720 do this *before* the final move.
            // o.w. addr band ends up w/ 80-high default rather than
            // snapped to correct/negotiated size.
            //
            // why are we able to turn this on here when in general it
            // had to be off during the drag?  well, the preview of the
            // drag went thru MoveSizeHelper which did a NotifyModeChange
            // which told our client what its orientation really is.  so
            // by now things should be in sync.

            // size negotiation had been turned off (to prevent horz/vert
            // pblms).  turn it on before the final move so that we'll
            // recalc correctly.
            _ExecDrag(0);
        }

        // (we're done w/ _rcPending so o.k. to pass it in and trash it)
        // fMove==TRUE even though USER has already done the move for us,
        // since it's only done the move not the resize (?).  if we use
        // fMove==FALSE we end up in the new location but w/ the old size,
        // despite the fact that rcFeed has been updated along the way.
        // this is because USER sets SWP_NOSIZE when it does the move.
        _TrackSliding(GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending),
            &_rcPending, TRUE, TRUE);

        // if we got a preferred child sizewhild dragging, set ourselves to that now.
        // sizing up   (cx > min), _szChild.cx == 0 and call a noop.
        // sizing down (cx < min), _szChild.cx != 0 and call does something.
        //ASSERT(_szChild.cx == 0);   // 0 => _AdjustToChildSize is nop
        _AdjustToChildSize();
    }
    else {
        _MoveSizeHelper(_eMode, _uSide, _hMon, NULL, NULL, TRUE, FALSE);   // FEATURE: fMove?
    }

    _fDragging = 0;
    
    return;
}

#ifdef DEBUG
int g_dbNoExecDrag = 0;     // to play w/ ExecDrag w/o recompiling
#endif

void DBC_ExecDrag(IUnknown *pDBC, int eDragging)
{
    VARIANTARG vaIn = {0};      // VariantInit

    ASSERT(eDragging == DRAG_MOVE || eDragging == 0);

#ifdef DEBUG
    if (g_dbNoExecDrag)
        return;
#endif

    vaIn.vt = VT_I4;
    vaIn.lVal = eDragging;      // n.b. currently only 0/1 is supported 
    IUnknown_Exec(pDBC, &CGID_DeskBarClient, DBCID_ONDRAG, OLECMDEXECOPT_DONTPROMPTUSER, &vaIn, NULL);
    // VariantClear

    return;
}

void CDockingBar::_ExecDrag(int eDragging)
{
    DBC_ExecDrag(_pDBC, eDragging);
    return;
}

//***   _Recalc -- force recalc using current settings
//
void CDockingBar::_Recalc(void)
{
    _MoveSizeHelper(_eMode, _uSide, _hMon, NULL, NULL, TRUE, TRUE);
    return;
}

//***   _MoveSizeHelper -- shared code for menu and dragging forms of move/size
//
void CDockingBar::_MoveSizeHelper(UINT eModeNew, UINT eSideNew, HMONITOR hMonNew,
    POINT* ptTrans, RECT* rcFeed, BOOL fCommit, BOOL fMove)
{
    UINT eModeOld, eSideOld;

    RECT rcNew;

    // only desktop guys can go to TOPMOST
    ASSERT(eModeNew != WBM_TOPMOST || ISWBM_DESKTOP());

    eModeOld = _eMode;
    eSideOld = _uSide;

    ASSERT(CHKWBM_CHANGE(eModeNew, _eMode));
    _eModePending = eModeNew;   // for drag feedback, before commit
    _uSidePending = eSideNew;
    _hMonPending = hMonNew;

    if (fCommit)
    {
        // we need to be careful when we call _ChangeHide or we'll recurse
        BOOL fChangeHide = (_fWantHide &&
            (eSideNew != _uSide || eModeNew != _eMode || hMonNew != _hMon));

        if (fChangeHide)
            _DoHide(AHO_KILLDO|AHO_UNREG);

        _SetModeSide(eModeNew, eSideNew, hMonNew, FALSE);

        if (fChangeHide)
        {
            // don't do AHO_SETDO now, wait for WM_ACTIVATE(deactivate)
            _DoHide(AHO_REG);
        }
    }

    // negotiate (and possibly commit to negotiation)
    _ProtoRect(&rcNew, eModeNew, eSideNew, hMonNew, ptTrans);
    _NegotiateRect(eModeNew, eSideNew, hMonNew, &rcNew, fCommit);

    // commit
    if (fCommit)
        _SetVRect(&rcNew);

    // feedback
    if (rcFeed != 0)
    {
        CopyRect(rcFeed, &rcNew);
    }
    
    if (fMove)
    {
        // If we're in theater mode, out parent manages our width and
        // horizontal position, unless we're being forced to a new
        // size by szChild.
        if (_fTheater && !_fDragging)
        {
            RECT rcCur;
            GetWindowRect(_hwnd, &rcCur);
            rcNew.left = rcCur.left;
            rcNew.right = rcCur.right;
        }

        // aka ScreenToClient
        MapWindowPoints(HWND_DESKTOP, GetParent(_hwnd), (POINT*) &rcNew, 2);
        
        if (_fCanHide && eModeNew == eModeOld && eSideNew == eSideOld)
        {
            // if we're [un]hiding to the same state, we can do SlideWindow
            ASSERT(ISWBM_HIDEABLE(eModeNew));
            DAD_ShowDragImage(FALSE);   // unlock the drag sink if we are dragging.
            SlideWindow(_hwnd, &rcNew, _hMon, !_fHiding);
            DAD_ShowDragImage(TRUE);    // restore the lock state.
        }
        else
        {
            MoveWindow(_hwnd, rcNew.left, rcNew.top,
                       RECTWIDTH(rcNew), RECTHEIGHT(rcNew), TRUE);
        }
    }

    // WARNING: rcNew is no longer in consistent coords! (ScreenToClient)

    // notify the child of changes
    _NotifyModeChange(0);
}

void CDockingBar::_NotifyModeChange(DWORD dwMode)
{
    UINT eMode, uSide;

    eMode = ((_fDragging == DRAG_MOVE) ? _eModePending : _eMode);
    uSide = ((_fDragging == DRAG_MOVE) ? _uSidePending : _uSide);
    //hMon = ((_fDragging == DRAG_MOVE) ? _hMonPending : _hMon);

    if (ISWBM_FLOAT(eMode))
        dwMode |= DBIF_VIEWMODE_FLOATING;
    else if (!ABE_HORIZ(uSide))
        dwMode |= DBIF_VIEWMODE_VERTICAL;

    SUPERCLASS::_NotifyModeChange(dwMode);
    
}

void CDockingBar::_TrackSliding(int x, int y, RECT* rcFeed,
    BOOL fCommit, BOOL fMove)
{
    TraceMsg(DM_DRAG2,
        "cwb.ts: _TrackSliding(x=%d, y=%d, rcFeed=(%d,%d,%d,%d)(%dx%d), fCommit=%d, fMove=%d)",
        x, y,
        _PM(rcFeed,left), _PM(rcFeed,top), _PM(rcFeed,right), _PM(rcFeed,bottom),
        _PX(rcFeed,RECTWIDTH(*rcFeed)), _PX(rcFeed,RECTHEIGHT(*rcFeed)),
        fCommit, fMove);

    POINT pt = { x, y };
    UINT eModeNew, uSideNew;
    HMONITOR hMonNew;
    if (_fDragging == DRAG_MOVE) {
        // moving...

        if (fCommit) {
            // use last feedback position.
            // o.w. (if we recompute) we end up in the wrong place since
            // WM_MOVE gives us the (left,top), which often is in another
            // docking zone.
            ASSERT(x == GET_X_LPARAM(_xyPending) && y == GET_Y_LPARAM(_xyPending));
            //eModeNew = _eModePending;
            //uSideNew = _uSidePending;
        }

        //
        // figure out snap position,
        // and do a few special-case hacks to fix it up if necessary
        //
        uSideNew = _CalcDragPlace(pt, &hMonNew);
        if (uSideNew == ABE_XFLOATING) {
            // dock->float or float->float
            eModeNew = _eMode | WBM_FLOATING;
            uSideNew = _uSide;          // FEATURE: _uSidePending? This seems to work correctly as is.
        }
        else {
            // float->dock or dock->dock
            eModeNew = _eMode & ~WBM_FLOATING;
        }

        TraceMsg(DM_DRAG2,
            "cwb.ts: (m,s) _x=(%d,%d) _xPend=(%d,%d) xNew=(%d,%d)",
            _eMode, _uSide, _eModePending, _uSidePending, eModeNew, uSideNew);

        // 970725: we now allow bottom->float (for the desktop, not browser)
        if (ISWBM_FLOAT(eModeNew) && ISWBM_BOTTOM(_eMode) && !ISWBM_DESKTOP()) {
            // special case: don't allow switch from BTMMOST to FLOATING
            ASSERT(CHKWBM_CHANGE(eModeNew, _eMode));
            eModeNew = _eModePending;   // the dead zone...
            uSideNew = _uSidePending;   // QUESTION: init case?
            hMonNew = _hMonPending;
            TraceMsg(DM_DRAG2,
                "cwb.ts: (m,s) btm->flt override     xNew=(%d,%d)",
                eModeNew, uSideNew);
            ASSERT(!ISWBM_FLOAT(eModeNew));
        }

        //
        // smooth things out so we don't jump around
        //
        _SmoothDragPlace(eModeNew, uSideNew, hMonNew, &pt, rcFeed);

        //
        // now do the move
        //
        // | with _eMode & WBMF_BROWSER because dragging around doesn't change the
        // browser owned bit
        _MoveSizeHelper(eModeNew | (_eMode & WBMF_BROWSER), uSideNew, hMonNew, 
            ISWBM_FLOAT(eModeNew) ? &pt : NULL, rcFeed, fCommit, fMove);
    }
    else {
        ASSERT(_fDragging == DRAG_SIZE);

        // truncate to max size if necessary
        _SmoothDragPlace(_eMode, _uSide, _hMon, NULL, rcFeed);

        if (!fCommit) {
            // USER does everything for us
            return;
        }
        ASSERT(MAKELPARAM(x, y) != XY_NIL);

        // APPCOMPAT: we're gonna commit so just blast it in here...
        RECT rcNew;

        GetWindowRect(_hwnd, &rcNew);   // PERF: already set?
        _SetVRect(&rcNew);
        _MoveSizeHelper(_eMode, _uSide, _hMon,
            NULL, NULL,                 // FEATURE: &rcNew?
            fCommit, fMove);
    }

    return;
}

/***    _CalcDragPlace -- compute where drag will end up
 * NOTES
 *      FEATURE: prelim version
 */
UINT CDockingBar::_CalcDragPlace(POINT& pt, HMONITOR * phMon)
{
    TraceMsg(DM_DRAG2,
        "cwb.cdp: _CalcDragPlace(pt=(%d,%d))",
        pt.x, pt.y);

    SIZE screen, error;
    UINT uHorzEdge, uVertEdge, uPlace;
    RECT rcDisplay = {0};  // _GetBorderRect doesn't always set rect.

    // Get the correct hMonitor.
    ASSERT(phMon);
    *phMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
    // FEATURE: todo: make hwndSite and rcDisplay args, then this can be
    // a generic helper func
    _GetBorderRect(*phMon, &rcDisplay);

    // if we're outside our 'parent' (browser or desktop), we float.
    // this really only applies to the browser case, since we'll never
    // be outside the desktop (what about multi-monitor?).
    if (!PtInRect(&rcDisplay, pt) || !_ptbSite) {
        TraceMsg(DM_DRAG2,
            "cwb.cdp: pt=(%d,%d) uSideNew=%u",
            pt.x, pt.y, ABE_XFLOATING);
        return ABE_XFLOATING;
    }

    // if we're not w/in min threshhold from edge, we float
    {
        RECT rcFloat;   // FEATURE can just use rcDisplay
        int cx = CXFLOAT();
        int cy = CYFLOAT();

        CopyRect(&rcFloat, &rcDisplay);
        InflateRect(&rcFloat, -cx, -cy);

        if (PtInRect(&rcFloat, pt)) {
            TraceMsg(DM_DRAG2,
                "cwb.cdp: pt=(%d,%d) uSideNew=%u",
                pt.x, pt.y, ABE_XFLOATING);
            return ABE_XFLOATING;
        }
    }

    //
    // re-origin at zero to make calculations simpler
    //
    screen.cx =  RECTWIDTH(rcDisplay);
    screen.cy = RECTHEIGHT(rcDisplay);
    pt.x -= rcDisplay.left;
    pt.y -= rcDisplay.top;

    //
    // are we closer to the left or right side of this display?
    //
    if (pt.x < (screen.cx / 2)) {
        uVertEdge = ABE_LEFT;
        error.cx = pt.x;
    }
    else {
        uVertEdge = ABE_RIGHT;
        error.cx = screen.cx - pt.x;
    }

    //
    // are we closer to the top or bottom side of this display?
    //
    if (pt.y < (screen.cy / 2)) {
        uHorzEdge = ABE_TOP;
        error.cy = pt.y;
    }
    else {
        uHorzEdge = ABE_BOTTOM;
        error.cy = screen.cy - pt.y;
    }

    //
    // closer to a horizontal or vertical edge?
    //
    uPlace = ((error.cy * screen.cx) > (error.cx * screen.cy))?
        uVertEdge : uHorzEdge;

    TraceMsg(DM_DRAG2,
        "cwb.cdp: pt=(%d,%d) uSideNew=%u",
        pt.x, pt.y, uPlace);

    return uPlace;
}

//***   _SmoothDragPlace -- do some magic to smooth out dragging
// ENTRY/EXIT
//      eModeNew        where we're snapping to
//      eSideNew        ...
//      [_eModePending] where we're snapping from
//      [_eSidePending] ...
//      pt              INOUT cursor position
//      rcFeed          USER's original drag feedback rect
// NOTES
//      this is the place to put excel-like heuristics.  e.g. when coming
//      back off the right side we could put the cursor at the top right of
//      the floating rect (rather than the top left) to allow us to float
//      as close as possible to the other side w/o docking.  hmm, but how
//      would we tell USER where to put the cursor...
//
void CDockingBar::_SmoothDragPlace(UINT eModeNew, UINT eSideNew, HMONITOR hMonNew,
    INOUT POINT* pt, RECT* rcFeed)
{
    if (_fDragging == DRAG_MOVE) {
        if (ISWBM_FLOAT(eModeNew) && ISWBM_FLOAT(_eModePending) && rcFeed != 0 && pt) {
            // use the feedback rect from USER to keep things smooth.
            // o.w. if we use the cursor position we'll jump at the
            // beginning (to move the left-top corner to the starting
            // cursor position).
            pt->x = rcFeed->left;
            pt->y = rcFeed->top;
        }
    }
    else {
        ASSERT(_fDragging == DRAG_SIZE);
        ASSERT(eModeNew == _eMode && eSideNew == _uSide && hMonNew == _hMon);
        if (!ISWBM_FLOAT(_eMode)) {
            // truncate to max size (1/2 of screen) if necessary

            int iWH;
            RECT rcScreen;

            // we'd like to use 1/2 of browser, not 1/2 of screen.  however
            // this causes pblms if you maximize, grow to 1/2, and restore.
            // then the 1st time you resize the bar it 'jumps' down to 1/2
            // of the *current* size from 1/2 of the old size.  kind of a
            // hack, sigh...
            //
            // also note that there's still a bug here: if you size down
            // the browser gradually, we don't go thru this logic, so you
            // end up w/ a bar width > browser width so you the right edge
            // is clipped and there's no way to size it down.  probably
            // when the browser resize is done we should re-smooth the bar.
            //_GetBorderRect(_hMon, &rcScreen);
            GetMonitorRect(_hMon, &rcScreen);   // aka GetSystemMetrics(SM_CXSCREEN)
            iWH = RECTGETWH(_uSide, &rcScreen);
            iWH /= 2;
            if (RECTGETWH(_uSide, rcFeed) > iWH) {
                TraceMsg(DM_TRACE, "cwb.sdp: truncate iWH'=%d", iWH);
                RectXform(rcFeed, RX_OPPOSE, rcFeed, NULL, iWH, _uSide, NULL);
            }
        }
    }

    return;
}

/***
 */
LRESULT CDockingBar::_OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LRESULT lres = 0;

    if (_CheckForwardWinEvent(uMsg, wParam, lParam, &lres))
        return lres;
    
    if ((Command_GetID(wParam) <= IDM_AB_LAST) &&
        (Command_GetID(wParam) >= IDM_AB_FIRST)) {
        _AppBarOnCommand(Command_GetID(wParam));
    }

    return lres;
}

/***    CDockingBar::_AppBarRegister -- register/unregister AppBar
 * DESCRIPTION
 *      updates _fAppRegistered
 *      does nothings if it's already regisrered or unregistered
 */
void CDockingBar::_AppBarRegister(BOOL fRegister)
{
    APPBARDATA abd;

    abd.cbSize = sizeof(APPBARDATA);
    abd.hWnd = _hwnd;

    if (fRegister && !_fAppRegistered) {
        abd.uCallbackMessage = APPBAR_CALLBACK;
        TraceMsg(DM_APPBAR, "cwb.abr: call ABM_NEW");
        UINT_PTR bT = SHAppBarMessage(ABM_NEW, &abd);
        ASSERT(bT);
        if (bT) {
            _fAppRegistered = TRUE;

            // fake a callback to set initial state
            // #if XXX_TASKMAN
            TraceMsg(DM_APPBAR, "cwb.abr: fake ABN_STATECHANGE");
            _AppBarCallback(_hwnd, APPBAR_CALLBACK, ABN_STATECHANGE, 0);
            // #endif
        }
    }
    else if (!fRegister && _fAppRegistered) {
        TraceMsg(DM_APPBAR, "cwb.abr: call ABM_REMOVE");
        // n.b. sensitive phase ordering, must set flag before send message
        // since the message causes a bunch of callbacks
        _fAppRegistered = FALSE;
        SHAppBarMessage(ABM_REMOVE, &abd);
    }
}

//***   _SetVRect -- set our 'virtual rect' to reflect window state
//
void CDockingBar::_SetVRect(RECT* rcNew)
{
    UINT eModeNew, uSideNew;

    //ASSERT(_fDragging == 0);  // o.w. we should look at _xxxPending

    eModeNew = _eMode;
    uSideNew = _uSide;


    if (_fHiding && ISWBM_HIDEABLE(eModeNew)) {
        TraceMsg(DM_HIDE, "cwb.svr: _fHiding => suppress rcNew=(%d,%d,%d,%d)",
            rcNew->left, rcNew->top, rcNew->right, rcNew->bottom);
        return;
    }


    if (ISWBM_FLOAT(eModeNew)) {
        CopyRect(&_rcFloat, rcNew);
    }
    else {
        _adEdge[uSideNew] = ABE_HORIZ(uSideNew) ? RECTHEIGHT(*rcNew) : RECTWIDTH(*rcNew);
    }
    return;
}

//***   _ChangeTopMost -- switch back and forth btwn TopMost and BottomMost
// ENTRY/EXIT
//      eModeNew        new mode we're switching to
//
void CDockingBar::_ChangeTopMost(UINT eModeNew)
{
    BOOL fShouldRegister = (eModeNew & WBM_TOPMOST) && !(eModeNew & WBM_FLOATING);
    
    // here's what's legal...
//              to...................
// from         btm     top     float
// ----         ---     ---     -----
// btm(desk)    -       top+    y(1)    (1) force to top
// top          top-    -       'undock'
// float        y(2)    'dock'  -       (2) force to right
// btm(app)     -       x(3)    y(4)    (3) foster child (4) 'owned' window


#if 0
    // (1,4) going from BTMMOST to FLOATING is illegal (and NYI) unless desktop
    ASSERT(eModeNew != WBM_FLOATING || _eMode != WBM_BOTTOMMOST || ISWBM_DESKTOP());
#endif

    // (3) only desktop guys can go to TOPMOST
    ASSERT(eModeNew != WBM_TOPMOST || ISWBM_DESKTOP());

    // _uSide should always be laying around (even if floating)
    ASSERT(_eMode == WBM_NIL || ISABE_DOCK(_uSide));

    // note the ordering here, make sure window bits are right
    // before doing resume new or else new will have unexpected state
    _ChangeWindowStateAndParent(eModeNew);
    _eMode = eModeNew;
    _ChangeZorder();

    // resume new
    switch (_eMode) {
    case WBM_NIL:
        // dummy state for termination
        return;

    case WBM_BOTTOMMOST:
        _ResetZorder();
#if ! XXX_BROWSEROWNED
        // fall through
    case WBM_BBOTTOMMOST:
#endif
        break;
    }
    
    _AppBarRegister(fShouldRegister);
}

//***   _ChangeZorder -- set z-order appropriately
// NOTES
//  currently doesn't account for 'raised' mode (i.e. caller must call
//  _ChangeZorder before _ResetZorder)
void CDockingBar::_ChangeZorder()
{
    BOOL fWantTopmost = BOOLIFY(WBM_IS_TOPMOST());
    BOOL fIsTopmost = BOOLIFY(GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST);
    if (fWantTopmost != fIsTopmost)
        SetWindowPos(_hwnd, fWantTopmost ? HWND_TOPMOST : HWND_NOTOPMOST,
                     0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    return;
}

//***    _ResetZorder -- toggle DockingBars between 'normal' and 'raised' mode
// DESCRIPTION
//  queries desktop state and does appropriate '_OnRaise'
//
void CDockingBar::_ResetZorder()
{
    HRESULT hr;
    VARIANTARG vaIn = {0};      // VariantInit
    VARIANTARG vaOut = {0};     // VariantInit

    vaIn.vt = VT_I4;
    vaIn.lVal = DTRF_QUERY;
    hr = IUnknown_Exec(_ptbSite, &CGID_ShellDocView, SHDVID_RAISE, OLECMDEXECOPT_DONTPROMPTUSER,
        &vaIn, &vaOut);
    if (SUCCEEDED(hr) && vaOut.vt == VT_I4)
        _OnRaise(vaOut.lVal);
    // VariantClear
    return;
}

//***   _OnRaise -- handle desktop 'raise' command
// DESCRIPTION
//  changes DockingBar z-order depending on desktop raise state:
//      desktop     DockingBar
//      raised      force on top (so visible)
//      restored    return to normal
// NOTES
//  FEATURE: should we handle WBM_FLOATING too?
//  FEATURE: should add ZORD_xxx to deskbar.h and handle non-WBM_BOTTOMMOST
void CDockingBar::_OnRaise(UINT flags)
{
    HWND hwndZorder;

    if (_eMode != WBM_BOTTOMMOST)
        return;

    switch (flags) {
    case DTRF_RAISE:
        hwndZorder = HWND_TOPMOST;
        break;

    case DTRF_LOWER:
        hwndZorder = HWND_NOTOPMOST;
        break;
    
    default:
        ASSERT(0);
        return;
    }

    SetWindowPos(_hwnd, hwndZorder, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);

    return;
}

#if XXX_BTMFLOAT && 0 // see 'NOTES'
//***   _MayReWindow -- change/restore window state for dragging
// DESCRIPTION
//      USER won't let us drag outside of the browser unless we reparent
//      ourselves.
// NOTES
//      need to call this *before* we enter USER's move/size loop.
//      i.e. on LBUTTONDOWN and on EXITSIZEMOVE.  this gets a bit
//      tricky due to CANCEL etc., since the LBUTTONUP may come thru
//      either before or after we're done.
//
void CDockingBar::_MayReWindow(BOOL fToFloat)
{

    if (ISWBM_DESKTOP() || _eMode != WBM_BOTTOMMOST)
        return;

    // do style bits 1st or re-parenting breaks
    SHSetWindowBits(_hwnd, GWL_STYLE, WS_CHILD | WS_POPUP, fToFloat ? WS_POPUP | WS_CHILD);

    if (!fToFloat) {
        // float->btm

        // nuke owner
        SHSetParentHwnd(_hwnd, NULL);

        // parent
        SetParent(_hwnd, _hwndSite);
    }


    if (fToFloat) {
        // btm->float, set owner

        // parent
        SetParent(_hwnd, PARENT_FLOATING);

        // set owner
        ASSERT(_hwndSite != NULL);
        SHSetParentHwnd(_hwnd, _hwndSite);
    }
}
#endif


void CDockingBar::_GetStyleForMode(UINT eMode, LONG* plStyle, LONG* plExStyle, HWND* phwndParent)
{
    switch (eMode) {
    case WBM_NIL:
        *plStyle = WS_NIL;
        *plExStyle= WS_EX_NIL;
        *phwndParent = PARENT_NIL;
        break;

    case WBM_BBOTTOMMOST:
        *plStyle = WS_BBTMMOST;
        *plExStyle= WS_EX_BBTMMOST;
        *phwndParent = PARENT_BBTMMOST();
        break;

    case WBM_BOTTOMMOST:
        *plStyle = WS_BTMMOST;
        *plExStyle= WS_EX_BTMMOST;
        *phwndParent = PARENT_BTMMOST();
        break;

    case WBM_BFLOATING:
        // FEATURE: todo: FLOATING NYI
        *plStyle = WS_BFLOATING;
        *plExStyle = WS_EX_BFLOATING;
        *phwndParent = _hwndSite;
        break;

    case (WBM_FLOATING | WBM_TOPMOST):
    case WBM_FLOATING:
        // FEATURE: todo: FLOATING NYI
        *plStyle = WS_FLOATING;
        *plExStyle = WS_EX_FLOATING;
        *phwndParent = PARENT_FLOATING;
        break;

    case WBM_TOPMOST:
        *plStyle = WS_XTOPMOST;
        *plExStyle= WS_EX_XTOPMOST;
        *phwndParent = PARENT_XTOPMOST;
        break;
    }
#ifdef DEBUG // {
    if (_eMode == eMode) {
        // style, exstyle
        ASSERT(BITS_SET(GetWindowLong(_hwnd, GWL_STYLE), *plStyle));
        ASSERT(BITS_SET(GetWindowLong(_hwnd, GWL_EXSTYLE), *plExStyle & ~WS_EX_TOPMOST));

        // id
        ASSERT(GetWindowLong(_hwnd, GWL_ID) == 0);

        // parent 
        ASSERT(GetParent(_hwnd) == *phwndParent ||
               (ISWBM_OWNED(_eMode) && GetParent(_hwnd)==_hwndSite));
    }
#endif // }
}

//***   _ChangeWindowStateAndParent --
// NOTES
//      todo: make table-driven (ws1, ws2, etc.)
//
void CDockingBar::_ChangeWindowStateAndParent(UINT eModeNew)
{
    LONG ws1, wsx1, ws2, wsx2;
    HWND hwnd;

    if (eModeNew == _eMode) {
        // same mode, nothing to do
        return;
    }

    //
    // nuke old bits
    //
    _GetStyleForMode(_eMode, &ws1, &wsx1, &hwnd);


    //
    // set new bits
    //
    _GetStyleForMode(eModeNew, &ws2, &wsx2, &hwnd);

    // if it's going to be owned by the browser, 
    // override hwnd to our site's hwnd
    if (eModeNew & WBMF_BROWSER)
        hwnd = _hwndSite;

    // style, exstyle
    // (SWB can't do WS_EX_TOPMOST, we do it in caller w/ SWP)
    SHSetWindowBits(_hwnd, GWL_STYLE, ws1|ws2 , ws2);
    SHSetWindowBits(_hwnd, GWL_EXSTYLE, (wsx1|wsx2) & ~WS_EX_TOPMOST, wsx2);

    // id
    // (unchanged)
    HWND hwndParent = GetParent(_hwnd); 
    if (hwndParent != hwnd) {
        if (hwndParent != HWND_DESKTOP) {
            // float->btm, nuke owner
            SHSetParentHwnd(_hwnd, NULL);
        }

        // parent
        SetParent(_hwnd, hwnd);

        if (hwnd == _hwndSite) {
            // btm->float, set owner
            ASSERT(_hwndSite != NULL);
            SHSetParentHwnd(_hwnd, _hwndSite);
        }
    }
    //
    // force redraw
    //
    SetWindowPos(_hwnd, NULL, 0, 0, 0, 0,
        SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);

    return;
}

//***   _SetNewMonitor --
// When the Desktop is our Docking Site, set the new monitor I am on
// and return the old monitor 
HMONITOR CDockingBar::_SetNewMonitor(HMONITOR hMonNew)
{
    HMONITOR hMonOld = NULL;
    if (ISWBM_DESKTOP() && _ptbSite)
    {
        IMultiMonitorDockingSite * pdds;
        HRESULT hresT = _ptbSite->QueryInterface(IID_IMultiMonitorDockingSite, (LPVOID *)&pdds);
        if (SUCCEEDED(hresT))
        {
            HMONITOR hMon;
            ASSERT(pdds);
            if (SUCCEEDED(pdds->GetMonitor(SAFECAST(this, IDockingWindow*), &hMon)))
            {
                if (hMon != hMonNew)
                {
                    pdds->RequestMonitor(SAFECAST(this, IDockingWindow*), &hMonNew);
                    pdds->SetMonitor(SAFECAST(this, IDockingWindow*), hMonNew, &hMonOld);
                    // These two should be the same, otherwise something wierd is happening -- dli
                    ASSERT(hMonOld == hMon);
                }
            }
            pdds->Release();
        }
    }
    
    return hMonOld;
}

//***   _GetBorderRect --
// NOTES
//      result in screen coordinates
//
void CDockingBar::_GetBorderRect(HMONITOR hMon, RECT* prc)
{
    if (!ISWBM_BOTTOM(_eMode)) {
        // FEATURE: todo: should use:
        // floating: _hwndSite (not strictly correct, but good enough)
        // topmost: UnionRect of:
        //     GetWindowRect(_hwndSite);        // non-appbar rect
        //     GetWindowRect(self)              // plus my personal appbar
        ASSERT(IsWindow(_hwndSite));
        if (ISWBM_DESKTOP())
            GetMonitorRect(hMon, prc);
        else
            GetWindowRect(_hwndSite, prc);  
#ifdef DEBUG
#if 0
        RECT rcTmp;

        // these asserts often fail.  e.g. when dragging topmost right->top.
        // weird: _hwndSite ends up being PROGMAN's hwnd.
        // weird: also, the GetWindowRect fails.
        ASSERT(_hwndSite == PARENT_XTOPMOST);
        // _hwndSite is PROGMAN
        GetWindowRect(PARENT_XTOPMOST, &rcTmp);
        ASSERT(EqualRect(prc, &rcTmp));
#endif
#endif
    }
    else if (_ptbSite) {
        HMONITOR hMonOld = _SetNewMonitor(hMon);
        _ptbSite->GetBorderDW(SAFECAST(this, IDockingWindow*), prc);
        if (hMonOld)
            _SetNewMonitor(hMonOld);
        ASSERT(_hwndSite != NULL);
        //ASSERT(GetParent(_hwnd) == _hwndSite);  // FEATURE ISWBM_OWNED?
        // convert if necessary
        // aka ClientToScreen
        MapWindowPoints(_hwndSite, HWND_DESKTOP, (POINT*) prc, 2);
    }

    return;
}

//***   _HideRegister -- (un)register auto-hide w/ edge
// ENTRY/EXIT
//      fToHide         TRUE if turning AutoHide on, FALSE if turning off
//      _fCanHide       [OUT] TRUE if successfully set autohide on; o.w. FALSE 
//      other           pops up dialog if operation fails
//
void CDockingBar::_HideRegister(BOOL fToHide)
{
    BOOL fSuccess;
    APPBARDATA abd;

    if (! ISWBM_HIDEABLE(_eMode))
        return;

    // (try to) register or unregister it
    // n.b. we're allowed to do this even if we're not an AppBar
    // that's good, because we want at most one autohide deskbar 
    // on an edge regardless of mode
    abd.cbSize = SIZEOF(abd);
    abd.hWnd = _hwnd;
    abd.uEdge = _uSide;
    abd.lParam = fToHide;

    // FEATURE should we do a ABM_GETAUTOHIDEBAR at some point?
    // (tray.c does, and so does the AB sample code...)
    //ASSERT(_fAppRegistered);
    fSuccess = (BOOL) SHAppBarMessage(ABM_SETAUTOHIDEBAR, &abd);

    // set our state
    _fCanHide = BOOLIFY(fSuccess);
    // FEATURE: how handle failure?

    // init some stuff
    if (fToHide)
    {
        if (_fCanHide)
        {
            RECT rc;

            ASSERT(_fCanHide);  // so we won't SetVRect

            ASSERT(!_fHiding);  // (paranoia)

            // force a '0-width' rectangle so we don't take up any space
            RectXform(&rc, RX_EDGE|RX_OPPOSE|RX_ADJACENT, &rc, NULL,
                0, _uSide, _hMon);

            switch (_eMode) {
            case WBM_TOPMOST:
                // negotiate/commit it
                APPBARDATA abd;
                abd.cbSize = sizeof(APPBARDATA);
                abd.hWnd = _hwnd;
                ASSERT(_fCanHide);
                // we used to do:
                //  _fCanHide = FALSE;  // hack: so we surrender AppBar's space
                //  AppBarQuerySetPos(&rc, _uSide, &rc, &abd, TRUE);
                //  _fCanHide = TRUE;   // hack: restore
                // but the instant we do the ABSetPos the shell does a recalc
                // by doing a ShowDW of all toolbars, which does a _Recalc,
                // which does a MSH, which ends up doing ProtoRect w/ our
                // 'temporary' _fCanHide=0, which ends up taking space (oops!).
                //
                // so instead we call the low-level ABQueryPos/ABSetPos guys
                // directly.
                AppBarQueryPos(&rc, _uSide, _hMon, &rc, &abd, TRUE);
                AppBarSetPos0(_uSide, &rc, &abd);
                break;
            }

            // do *not* start the hide here
            // it's up to the caller, since a) might want delay or
            // immediate and b) recursion pblms w/ _MoveSizeHelper
        }
        else
        {
            // FEATURE: do PostMessage a la tray.c?
            MLShellMessageBox(_hwnd,
                MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
                MAKEINTRESOURCE(IDS_WEBBARTITLE),
                MB_OK | MB_ICONINFORMATION);
            ASSERT(!_fCanHide);
        }
    }
    else
    {
        // do *not* start the unhide here
        // it's up to the caller, since a) might want delay or
        // immediate and b) recursion pblms w/ _MoveSizeHelper

        _fCanHide = FALSE;
    }

    return;
}

//***   IsNearPoint -- am i currently near specified point?
// ENTRY/EXIT
//  pptBase     (INOUT) IN previous cursor pos, OUT updated to current if !fNear
//  fNear       (ret) TRUE if near, o.w. FALSE
// NOTES
//  heuristic stolen from explorer/tray.c!TraySetUnhideTimer
//
BOOL IsNearPoint(/*INOUT*/ POINT *pptBase)
{
    POINT ptCur;
    int dx, dy, dOff, dNear;

    GetCursorPos(&ptCur);
    dx = pptBase->x - ptCur.x;
    dy = pptBase->y - ptCur.y;
    dOff = dx * dx + dy * dy;
    dNear = GetSystemMetrics(SM_CXDOUBLECLK) * GetSystemMetrics(SM_CYDOUBLECLK);
    if (dOff <= dNear)
        return TRUE;
    TraceMsg(DM_HIDE2, "cwb.inp: ret=0 dOff=%d dNear=%d", dOff, dNear);
    *pptBase = ptCur;
    return FALSE;
}

//***   _DoHide --
// DESCRIPTION
//      AHO_KILLDO              kill timer for 'do'   operation
//      AHO_SETDO               set  timer for 'do'   operation
//      AHO_KILLUN              kill timer for 'undo' operation
//      AHO_SETUN               set  timer for 'undo' operation
//      AHO_REG                 register
//      AHO_UNREG               unregister
//      AHO_MOVEDO              do the actual hide
//      AHO_MOVEUN              do the actual unhide
// NOTES
//  the _fIdtXxHide stuff stops us from doing a 2nd SetTimer before the
// 1st one comes in, which makes us never get the 'earlier' ticks.
//  this fixes nt5:142686: drag-over doesn't unhide.  it was caused by us
// getting a bunch of WM_NCHITTESTs in rapid succession (OLE asking us on
// a fast timer?).
//  REARCHITECT: i think there's a tiny race window on _fIdtXxHide (between the
// call to Set/Kill and the shadowing in _fIdtXxHide).  not sure we can
// even hit it, but if we do, i think the worst that happens is somebody
// doesn't hide or unhide for a while.
//
void CDockingBar::_DoHide(UINT uOpMask)
{
    TraceMsg(DM_HIDE, "cwb.dh enter(uOpMask=0x%x(%s))",
        uOpMask, DbMaskToMneStr(uOpMask, AHO_MNE));

    if (!ISWBM_HIDEABLE(_eMode)) {
        TraceMsg(DM_HIDE, "cwb.dh !ISWBM_HIDEABLE(_eMode) => suppress");
        return;
    }

    // nuke old timer
    if (uOpMask & AHO_KILLDO) {
        TraceMsg(DM_HIDE, "cwb.dh: KillTimer(idt_autohide)");
        KillTimer(_hwnd, IDT_AUTOHIDE);
        _fIdtDoHide = FALSE;
    }
    if (uOpMask & AHO_KILLUN) {
        TraceMsg(DM_HIDE, "cwb.dh: KillTimer(idt_autoUNhide)");
        KillTimer(_hwnd, IDT_AUTOUNHIDE);
        _fIdtUnHide = FALSE;
        _ptIdtUnHide.x = _ptIdtUnHide.y = -1;
    }

    if (uOpMask & (AHO_REG|AHO_UNREG)) {
        _HideRegister(uOpMask & AHO_REG);
    }

    if (uOpMask & (AHO_MOVEDO|AHO_MOVEUN)) {
        // tricky, tricky...
        // all the smarts are in _MoveSizeHelper, driven by _fHiding (and _fCanHide)
        // use correct one of (tiny,real)
        _fHiding = (uOpMask & AHO_MOVEDO) ? HIDE_AUTO : FALSE;

        TraceMsg(DM_HIDE, "cwb.dh: move _fHiding=%d", _fHiding);
        ASSERT(_fCanHide);                      // suppress SetVRect
        _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
    }

    // start new timer
    if (_fCanHide) {
        if (uOpMask & AHO_SETDO) {
            TraceMsg(DM_HIDE, "cwb.dh: SetTimer(idt_autohide) fAlready=%d", _fIdtDoHide);
            if (!_fIdtDoHide) {
                _fIdtDoHide = TRUE;
                SetTimer(_hwnd, IDT_AUTOHIDE, DLY_AUTOHIDE, NULL);
            }
        }
        if (uOpMask & AHO_SETUN) {
            TraceMsg(DM_HIDE, "cwb.dh: SetTimer(idt_autoUNhide) fAlready=%d", _fIdtUnHide);
            // IsNearPoint hysteresis prevents us from unhiding when we happen
            // to be passed over on the way to something unrelated
            if (!IsNearPoint(&_ptIdtUnHide) || !_fIdtUnHide) {
                _fIdtUnHide = TRUE;
                SetTimer(_hwnd, IDT_AUTOUNHIDE, DLY_AUTOUNHIDE, NULL);
            }
        }
    }
    else {
#ifdef DEBUG
        if ((uOpMask & (AHO_SETDO|AHO_SETUN))) {
            TraceMsg(DM_HIDE, "cwb.dh: !_fCanHide => suppress AHO_SET*");
        }
#endif
    }

    return;
}

//***   SlideWindow -- sexy slide effect
// NOTES
//      stolen from tray.c
void SlideWindow(HWND hwnd, RECT *prc, HMONITOR hMonClip, BOOL fShow)
{
    RECT rcMonitor, rcClip;
    BOOL fRegionSet = FALSE; 

    SetRectEmpty(&rcMonitor);
    if (GetNumberOfMonitors() > 1)
    {
        GetMonitorRect(hMonClip, &rcMonitor);
        // aka ScreenToClient
        MapWindowPoints(HWND_DESKTOP, GetParent(hwnd), (LPPOINT)&rcMonitor, 2);     }

    // Future: We could loop on the following code for the slide effect 
    IntersectRect(&rcClip, &rcMonitor, prc);
    if (!IsRectEmpty(&rcClip))
    {
        HRGN hrgnClip;

        // Change the clip region to be relative to the upper left corner of prc
        // NOTE: this is not converting rcClip to prc client coordinate
        OffsetRect(&rcClip, -prc->left, -prc->top);
        
        hrgnClip = CreateRectRgnIndirect(&rcClip);
        // LINTASSERT(hrgnClip || !hgnClip);    // 0 semi-ok for SetWindowRgn
        // nt5:149630: always repaint, o.w. auto-unhide BitBlt's junk
        // from hide position
        fRegionSet = SetWindowRgn(hwnd, hrgnClip, /*fRepaint*/TRUE);
    }
    MoveWindow(hwnd, prc->left, prc->top, RECTWIDTH(*prc), RECTHEIGHT(*prc), TRUE);

    // Turn off the region stuff if we don't hide any more
    if (fRegionSet && fShow)
        SetWindowRgn(hwnd, NULL, TRUE);

    return;
}

/***    AppBarQueryPos -- negotiate position
 * ENTRY/EXIT
 *      return  width (height) from docked edge to opposing edge
 */
int CDockingBar::AppBarQueryPos(RECT* prcOut, UINT uEdge, HMONITOR hMon, const RECT* prcReq,
    PAPPBARDATA pabd, BOOL fCommit)
{
    int iWH;

    ASSERT(ISWBM_DESKTOP());

    // snap to edge (in case another AppBar disappeared w/o us knowing),
    // readjust opposing side to reflect that snap,
    // and max out adjacent sides to fill up full strip.
    iWH = RectGetWH(prcReq, uEdge);
    
    RectXform(&(pabd->rc), RX_EDGE|RX_OPPOSE|RX_ADJACENT|(_fHiding ? RX_HIDE : 0), prcReq, NULL, iWH, uEdge, hMon);

    ASSERT(EqualRect(&(pabd->rc), prcReq));     // caller guarantees?

    // negotiate
    // if we're dragging we might not be registered yet (floating->docked)
    // in that case we'll just use the requested size (w/o negotiating).
    // ditto for if we're in the middle of a top/non-top mode switch.
    if (_fAppRegistered) {
        pabd->uEdge = uEdge;
        TraceMsg(DM_APPBAR, "cwb.abqp: call ABM_QUERYPOS");
        SHAppBarMessage(ABM_QUERYPOS, pabd);
    }

    // readjust opposing side to reflect the negotiation (which only
    // adjusts the moved edge-most side, not the opposing edge).
    // FEATURE: (dli) need to find the right hmonitor to pass  in
    RectXform(prcOut, RX_OPPOSE, &(pabd->rc), NULL, iWH, uEdge, hMon);

    return RectGetWH(prcOut, uEdge);
}

//***   AppBarSetPos --
// NOTES
//      does *not* do _SetVRect and MoveWindow, that's up to caller
//
void CDockingBar::AppBarSetPos(UINT uEdge, const RECT* prcReq, PAPPBARDATA pabd)
{
    ASSERT(_eMode == WBM_TOPMOST);

    if (!_fCanHide && _fAppRegistered)
        AppBarSetPos0(uEdge, prcReq, pabd);

    return;
}

void CDockingBar::AppBarSetPos0(UINT uEdge, const RECT* prcReq, PAPPBARDATA pabd)
{
    CopyRect(&(pabd->rc), prcReq);
    pabd->uEdge = uEdge;

    TraceMsg(DM_APPBAR, "cwb.absp: call ABM_SETPOS");
    ASSERT(_fAppRegistered);
    SHAppBarMessage(ABM_SETPOS, pabd);

    // APPCOMPAT workaround explorer bug: during dragging we get:
    //  querypos*; wm_winposchanged; querypos; setpos
    // the lack of a wm_winposchanged at the end screws up the
    // autohide bring-to-top code.
    ASSERT(pabd->cbSize == sizeof(APPBARDATA));
    ASSERT(pabd->hWnd == _hwnd);
    TraceMsg(DM_APPBAR, "cwb.absp: call ABM_WINPOSCHGED");
    SHAppBarMessage(ABM_WINDOWPOSCHANGED, pabd);

    // n.b. _SetVRect and MoveWindow done by caller

    return;
}

//***   AppBarQuerySetPos --
//
void CDockingBar::AppBarQuerySetPos(RECT* prcOut, UINT uEdge, HMONITOR hMon, const RECT* prcReq,
    PAPPBARDATA pabd, BOOL fCommit)
{
    RECT rcTmp;

    if (prcOut == NULL)
        prcOut = &rcTmp;

    AppBarQueryPos(prcOut, uEdge, hMon, prcReq, pabd, fCommit);
    if (fCommit) {
        AppBarSetPos(uEdge, prcOut, pabd);
        ASSERT(EqualRect(prcOut, &(pabd->rc))); // callers assume prcOut correct
    }

    return;
}

void CDockingBar::_AppBarOnSize()
{
    RECT rc;
    APPBARDATA abd;

    ASSERT(_eMode == WBM_TOPMOST);
    ASSERT(ISABE_DOCK(_uSide));

    if (!_fAppRegistered)
        return;

    // don't commit until done
    if (_fDragging)
        return;

    abd.cbSize = sizeof(APPBARDATA);
    abd.hWnd = _hwnd;

    GetWindowRect(_hwnd, &rc);
    AppBarQuerySetPos(NULL, _uSide, _hMon, &rc, &abd, TRUE);

    return;
}

void CDockingBar::_RemoveToolbar(DWORD dwFlags)
{
    if (_ptbSite) {
        // WM_DESTROY will do _ChangeTopMost(WBM_NIL) for us

        IDockingWindowFrame* ptbframe;
        HRESULT hresT=_ptbSite->QueryInterface(IID_IDockingWindowFrame, (LPVOID*)&ptbframe);
        if (SUCCEEDED(hresT)) {
            AddRef();   // guard against self destruction
            ptbframe->RemoveToolbar(SAFECAST(this, IDockingWindow*), dwFlags);
            ptbframe->Release();
            Release();
        }
    } else {
        CloseDW(0);
    }
}

void CDockingBar::_AppBarOnCommand(UINT idCmd)
{
    UINT eModeNew;

    switch (idCmd) {
    case IDM_AB_TOPMOST:
        eModeNew = _eMode ^ WBM_TOPMOST;
        _MoveSizeHelper(eModeNew, _uSide, _hMon, NULL, NULL, TRUE, TRUE);
        break;

    case IDM_AB_AUTOHIDE:
        if (_fWantHide)
        {
            // on->off
            _DoHide(AHO_KILLDO|AHO_UNREG);      // _ChangeHide
            _fWantHide = FALSE;
        }
        else
        {
            // off->on
            _fWantHide = TRUE;
            // don't do AHO_SETDO now, wait for WM_ACTIVATE(deactivate)
            _DoHide(AHO_REG);     // _ChangeHide
        }

        // force it to happen *now*
        // REARCHITECT potential race condition w/ the AHO_SETDO above,
        // but worst case that should cause a 2nd redraw (?).
        _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);

        if (SHIsChildOrSelf(GetActiveWindow(), _hwnd) != S_OK)
        {
            // nt5:148444: if we're already deactive, we need to kick off
            // the hide now.  this is needed e.g. for login when we load
            // persisted auto-hide deskbars.  they come up inactive so we
            // never get the initial deact to hide them.
            _OnActivate(MAKEWPARAM(WA_INACTIVE, FALSE), (LPARAM)(HWND)0);
        }

        break;
#ifdef DEBUG
    case IDM_AB_ACTIVATE:
        // REARCHITECT temporary until we make browser tell us about activation

        // note that since we're faking this w/ a menu our (normal) assumption
        // in WM_ENTERMENU is bogus so make sure you keep the mouse over
        // the BrowserBar during activation or it will hide away out from under
        // you and the Activate won't work...
        _OnActivate(MAKEWPARAM(_fActive ? WA_INACTIVE : WA_ACTIVE, FALSE),
            (LPARAM) (HWND) 0);
        _fActive = !_fActive;
        break;
#endif

    case IDM_AB_CLOSE:
        _OnCloseBar(TRUE);
        break;

    default:
        MessageBeep(0);
        break;
    }
}

BOOL CDockingBar::_OnCloseBar(BOOL fConfirm)
{
    _RemoveToolbar(0);
    return TRUE;
}

void CDockingBar::_AppBarOnWM(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) {
    case WM_WINDOWPOSCHANGED:
    case WM_ACTIVATE:
        {
            APPBARDATA abd;

            abd.cbSize = sizeof(APPBARDATA);
            abd.hWnd = _hwnd;
            abd.lParam = (long) NULL;
            if (uMsg == WM_WINDOWPOSCHANGED) {
                TraceMsg(DM_APPBAR, "cwb.WM_WPC: call ABM_WINPOSCHGED");
                SHAppBarMessage(ABM_WINDOWPOSCHANGED, &abd);
            }
            else {
                //if (LOWORD(wParam) != WA_INACTIVE)
                // just do it always, doesn't hurt...
                TraceMsg(DM_APPBAR, "cwb.WM_ACT: call ABM_ACTIVATE");
                SHAppBarMessage(ABM_ACTIVATE, &abd);
            }
        }
        break;

    default:
        ASSERT(0);
        break;
    }

    return;
}

// try to preserve our thinkness
void CDockingBar::_AppBarOnPosChanged(PAPPBARDATA pabd)
{
    RECT rcWindow;

    ASSERT(_eMode == WBM_TOPMOST);

    GetWindowRect(pabd->hWnd, &rcWindow);
    RectXform(&rcWindow, RX_EDGE|RX_OPPOSE, &rcWindow, NULL, RectGetWH(&rcWindow, _uSide), _uSide, _hMon);

    _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
    return;
}

/***    _InitPos4 -- initialize edge positions
 * ENTRY/EXIT
 *  fCtor       TRUE if called from constructor; o.w. FALSE
 */
void CDockingBar::_InitPos4(BOOL fCtor)
{
    RECT rcSite;

    TraceMsg(DM_PERSIST, "cdb.ip4(fCtor=%d) enter", fCtor);

    if (fCtor)
    {
        // set some worst-case defaults for the Load(bag) case
        _adEdge[ABE_TOP]    = 80;
        _adEdge[ABE_BOTTOM] = 80;
        _adEdge[ABE_LEFT]   = 80;
        _adEdge[ABE_RIGHT]  = 80;

        SetRect(&_rcFloat, 10, 10, 310, 310);       // FEATURE: todo: NYI
        _hMon = GetPrimaryMonitor();
    }
    else
    {
        // set up semi-reasonable defaults for the InitNew case
        ASSERT(_eInitLoaded == IPS_INITNEW);    // not req'd, but expected
        ASSERT(IsWindow(_hwndSite));
        GetWindowRect(_hwndSite, &rcSite);

        _adEdge[ABE_TOP]    = AB_THEIGHT(rcSite);
        _adEdge[ABE_BOTTOM] = AB_BHEIGHT(rcSite);
        _adEdge[ABE_LEFT]   = AB_LWIDTH(rcSite);
        _adEdge[ABE_RIGHT]  = AB_RWIDTH(rcSite);
        
        // FEATURE: (dli) should we ask _hwndSite for it's hmonitor?
        // This current implementation already seems acceptable -justmann
        _hMon = MonitorFromRect(&rcSite, MONITOR_DEFAULTTONULL);
        if (!_hMon)
        {
            POINT ptCenter;
            ptCenter.x = (rcSite.left + rcSite.right) / 2;
            ptCenter.y = (rcSite.top + rcSite.bottom) / 2;
            _hMon = MonitorFromPoint(ptCenter, MONITOR_DEFAULTTONEAREST);
        }

    }

    return;
}

/***    RectXform -- transform RECT
 * ENTRY/EXIT
 *      prcOut
 *      uRxMask
 *      prcIn           initial rect
 *      prcBound        bounding rect specifying min/max dimensions
 *      iWH
 *      uSide
 * DESCRIPTION
 *      RX_EDGE         set edgemost side  to extreme (0 or max)
 *      RX_OPPOSE       set opposing side  to edge + width
 *      RX_ADJACENT     set adjacent sides to extremes (0 and max)
 *      RX_GETWH        get distance to opposing side
 *
 *      Two common calls are:
 *      ...
 * NOTES
 *      Note that rcOut, rcIn, and rcSize can all be the same.
 */
int CDockingBar::RectXform(RECT* prcOut, UINT uRxMask,
    const RECT* prcIn, RECT* prcBound, int iWH, UINT uSide, HMONITOR hMon)
{
    RECT rcDef;
    int  iRet = 0;
    BOOL bMirroredWnd=FALSE;

    if (prcOut != prcIn && prcOut != NULL) {
        ASSERT(prcIn != NULL);  // used to do SetRect(prcOut,0,0,0,0)
        CopyRect(prcOut, prcIn);
    }

#ifdef DEBUG
    if (! (uRxMask & (RX_OPPOSE|RX_GETWH))) {
        ASSERT(iWH == -1);
        iWH = -1;       // try to force something to go wrong...
    }
#endif

    if (uRxMask & (RX_EDGE|RX_ADJACENT)) {
        if (prcBound == NULL) {
            prcBound = &rcDef;
            ASSERT(hMon);
            GetMonitorRect(hMon, prcBound);     // aka GetSystemMetrics(SM_CXSCREEN)
        }

        #define iXMin (prcBound->left)
        #define iYMin (prcBound->top)
        #define iXMax (prcBound->right);
        #define iYMax (prcBound->bottom);
    }

    if (uRxMask & (RX_EDGE|RX_OPPOSE|RX_HIDE|RX_GETWH)) {

        //
        // If docking is happening on a horizontal size, then...
        // 
        if ((ABE_LEFT == uSide) || (ABE_RIGHT == uSide)) {
            bMirroredWnd = (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)));
        }

        switch (uSide) {
        case ABE_TOP:
            if (prcOut)
            {
                if (uRxMask & RX_EDGE)
                    prcOut->top = iYMin;
                if (uRxMask & RX_OPPOSE)
                    prcOut->bottom = prcOut->top + iWH;
                if (uRxMask & RX_HIDE)
                    MoveRect(prcOut, prcOut->left, prcOut->top - iWH + CXYHIDE(uSide));
            }
            if (uRxMask & RX_GETWH)
                iRet = RECTHEIGHT(*prcIn);

            break;
        case ABE_BOTTOM:
            if (prcOut)
            {
                if (uRxMask & RX_EDGE)
                    prcOut->bottom = iYMax;
                if (uRxMask & RX_OPPOSE)
                    prcOut->top = prcOut->bottom - iWH;
                if (uRxMask & RX_HIDE)
                    MoveRect(prcOut, prcOut->left, prcOut->bottom - CXYHIDE(uSide));
            }
            if (uRxMask & RX_GETWH)
                iRet = RECTHEIGHT(*prcIn);

            break;
        case ABE_LEFT:
            if (prcOut)
            {
                if (uRxMask & RX_EDGE)
                    prcOut->left = iXMin;
                if (uRxMask & RX_OPPOSE) {
                    //
                    // If the parent of this docked window is mirrored, then it is placed and
                    // aligned to the right. [samera]
                    //
                    if (bMirroredWnd)
                        prcOut->left = prcOut->right - iWH;
                    else
                        prcOut->right = prcOut->left + iWH;
                }
                if (uRxMask & RX_HIDE)
                    MoveRect(prcOut, prcOut->left - iWH + CXYHIDE(uSide), prcOut->top);
            }
            if (uRxMask & RX_GETWH)
                iRet = RECTWIDTH(*prcIn);

            break;
        case ABE_RIGHT:
            if (prcOut)
            {
                if (uRxMask & RX_EDGE)
                    prcOut->right = iXMax;
                if (uRxMask & RX_OPPOSE) {
                    //
                    // If the parent of this docked window is mirrored, then it is placed and
                    // aligned to the left
                    //
                    if (bMirroredWnd)
                        prcOut->right = prcOut->left + iWH;
                    else
                        prcOut->left = prcOut->right - iWH;
                }
                if (uRxMask & RX_HIDE)
                    MoveRect(prcOut, prcOut->right - CXYHIDE(uSide), prcOut->top);
            }
            if (uRxMask & RX_GETWH)
                iRet = RECTWIDTH(*prcIn);

            break;
        }
    }

    if ((uRxMask & RX_ADJACENT) && prcOut)
    {
        if (uSide == ABE_LEFT || uSide == ABE_RIGHT) {
            prcOut->top    = iYMin;
            prcOut->bottom = iYMax;
        }
        else {
            prcOut->left   = iXMin;
            prcOut->right  = iXMax;
        }
    }

    return iRet;
}

//***   _ProtoRect -- create best-guess proto rect for specified location
//
void CDockingBar::_ProtoRect(RECT* prcOut, UINT eModeNew, UINT uSideNew, HMONITOR hMonNew, POINT* ptXY)
{
    if (ISWBM_FLOAT(eModeNew))
    {
        // start at last position/size, and move to new left-top if requested
        CopyRect(prcOut, &_rcFloat);
        if (ptXY != NULL)
            MoveRect(prcOut, ptXY->x, ptXY->y);

        // if we're (e.g.) floating on the far right and the display shrinks,
        // we need to reposition ourselves
        // PERF: wish we could do this at resolution-change time but
        // WM_DISPLAYCHANGE comes in too early (before our [pseudo] parent
        // has changed).
        if (eModeNew == WBM_FLOATING)
        {
            // make sure we're still visible
            // FEATURE todo: multi-mon
            RECT rcTmp;

            _GetBorderRect(hMonNew, &rcTmp);

            if (prcOut->left > rcTmp.right || prcOut->top > rcTmp.bottom)
            {
                // WARNING note we don't explicitly account for other toolbars
                // this may be a bug (though other apps seem to behave the
                // same way)
                MoveRect(prcOut,
                    prcOut->left <= rcTmp.right ? prcOut->left :
                        rcTmp.right - CXFLOAT(),
                    prcOut->top  <= rcTmp.bottom ? prcOut->top  :
                        rcTmp.bottom - CYFLOAT()
                );
            }

        }
    }
    else
    {
        ASSERT(ISABE_DOCK(uSideNew));
        if (_fCanHide && ISWBM_HIDEABLE(eModeNew))
        {
            // force a 'tiny' rectangle
            // (WARNING prcBound==NULL bogus for XXX_HIDEALL && XXX_BROWSEROWNED)
            RectXform(prcOut, RX_EDGE|RX_OPPOSE|RX_ADJACENT|(_fHiding ? RX_HIDE : 0),
                prcOut, NULL, _adEdge[uSideNew], uSideNew, hMonNew);
        }
        else
        {
            // get current rect, adjust opposing side per request
            _GetBorderRect(hMonNew, prcOut);    
            RectXform(prcOut, RX_OPPOSE, prcOut, NULL, _adEdge[uSideNew], uSideNew, hMonNew);

        }
    }

    return;
}

//***   _NegotiateRect --
// NOTES
//      will only return an approximate result in the non-commit case.
//
void CDockingBar::_NegotiateRect(UINT eModeNew, UINT uSideNew, HMONITOR hMonNew,
    RECT* rcReq, BOOL fCommit)
{
    switch (eModeNew) {
    case WBM_TOPMOST:
        APPBARDATA abd;
        abd.cbSize = sizeof(APPBARDATA);
        abd.hWnd = _hwnd;

        AppBarQuerySetPos(rcReq, uSideNew, hMonNew, rcReq, &abd, fCommit);
        if (_fCanHide)
        {
            // we did a query to adjust the adjacent sides (e.g. so we don't
            // cover up the 'start' menu when we unhide).  however that may
            // have also moved us in from the edge, which we don't want.
            // so snap back to edge.
            int iWH;

            iWH = RectGetWH(rcReq, uSideNew);
            RectXform(rcReq, RX_EDGE|RX_OPPOSE|(_fHiding ? RX_HIDE : 0), rcReq, NULL, iWH, uSideNew, hMonNew);
        }
        goto Ldefault;

    default:
    Ldefault:
        // everyone else just gives us what we want

        // but, we need to free up border
        _NegotiateBorderRect(NULL, NULL, fCommit);     // free up space

        break;

    case WBM_BOTTOMMOST:
    case WBM_BBOTTOMMOST:
        _NegotiateBorderRect(rcReq, rcReq, fCommit);
        break;
    }


    return;
}

void CDockingBar::_AppBarCallback(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    APPBARDATA abd;

    ASSERT(_eMode == WBM_TOPMOST);

    abd.cbSize = sizeof(abd);
    abd.hWnd = hwnd;

    switch (wParam) {
    case ABN_FULLSCREENAPP:
        // when 1st  app goes   full-screen, move ourselves to BOTTOM;
        // when last app leaves full-screen, move ourselves back
        // todo: FullScreen(flg)
        {
            BOOL fIsTopmost = BOOLIFY(GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST);
            if (!lParam != fIsTopmost)
            {
                SetWindowPos(hwnd,
                    lParam ? HWND_BOTTOM : HWND_TOPMOST,
                    0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
            }
        }
        break;

    case ABN_POSCHANGED:
        TraceMsg(DM_APPBAR, "cwb.abcb: ABN_POSCHANGED");

        // note that we do this even if _fHiding.  while we want
        // to stay snapped to the edge as a 'tiny' rect, a change
        // in someone else *should* effect our adjacent edges.
        //
        // FEATURE: unfortunately this currently causes 'jiggle' of a hidden
        // guy when another appbar moves (due to a SlideWindow of a 0-width
        // hidden guy and a rounded-up 8-pixel wide guy).  when we switch
        // to explorer's new offscreen hide that should go away.
        _AppBarOnPosChanged(&abd);
        break;
    }

    return;
}

HRESULT CDockingBar::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
    static const QITAB qit[] = {
        QITABENT(CDockingBar, IDockingWindow),        // IID_IDockingWindow
        QITABENT(CDockingBar, IObjectWithSite),       // IID_IObjectWithSite
        QITABENT(CDockingBar, IPersistStreamInit),    // IID_IPersistStreamInit
        QITABENTMULTI(CDockingBar, IPersistStream, IPersistStreamInit), // IID_IPersistStream
        QITABENTMULTI(CDockingBar, IPersist, IPersistStreamInit), // IID_IPersist
        QITABENT(CDockingBar, IPersistPropertyBag),   // IID_IPersistPropertyBag
        { 0 },
    };

    HRESULT hres = QISearch(this, qit, riid, ppvObj);

    if (FAILED(hres))
        hres = SUPERCLASS::QueryInterface(riid, ppvObj);

    return hres;
}

HRESULT CDockingBar::QueryService(REFGUID guidService,
                                REFIID riid, void **ppvObj)
{
    HRESULT hres = E_FAIL;
    *ppvObj = NULL; // assume error

    //  Block IID_ITargetFrame, so we don't look like a frame of the
    //  window we are attached to
    if (IsEqualGUID(guidService, IID_ITargetFrame)
        ||IsEqualGUID(guidService, IID_ITargetFrame2)) {
        return hres;
    }

    hres = SUPERCLASS::QueryService(guidService, riid, ppvObj);
    if (FAILED(hres))
    {
        const GUID* pguidService = &guidService;
    
        if (IsEqualGUID(guidService, SID_SProxyBrowser)) {
            pguidService = &SID_STopLevelBrowser;
        }
    
        if (_ptbSite) {
            hres = IUnknown_QueryService(_ptbSite, *pguidService, riid, ppvObj);
        }
    }

    return hres;
}

void CDockingBar::_GrowShrinkBar(DWORD dwDirection)
{
    RECT    rcNew, rcOld;
    int     iMin;

    iMin = GetSystemMetrics(SM_CXVSCROLL) * 4;

    GetWindowRect(_hwnd, &rcNew);   
    rcOld = rcNew;
    
    switch(_uSide)
    {
        case ABE_TOP:
            if (VK_DOWN == dwDirection)
                rcNew.bottom += GetSystemMetrics(SM_CYFRAME);

            if (VK_UP == dwDirection)
                rcNew.bottom -= GetSystemMetrics(SM_CYFRAME);

            if ((rcNew.bottom - rcNew.top) < iMin)
                rcNew.bottom = rcNew.top + iMin;
            break;

        case ABE_BOTTOM:
            if (VK_UP == dwDirection)
                rcNew.top -= GetSystemMetrics(SM_CYFRAME);

            if (VK_DOWN == dwDirection)
                rcNew.top += GetSystemMetrics(SM_CYFRAME);

            if ((rcNew.bottom - rcNew.top) < iMin)
                rcNew.top = rcNew.bottom - iMin;
            break;

        case ABE_LEFT:
            if (VK_RIGHT == dwDirection)
                rcNew.right += GetSystemMetrics(SM_CXFRAME);

            if (VK_LEFT == dwDirection)
                rcNew.right -= GetSystemMetrics(SM_CXFRAME);

            if ((rcNew.right - rcNew.left) < iMin)
                rcNew.right = rcNew.left + iMin;
            break;
            
        case ABE_RIGHT:
            if (VK_LEFT == dwDirection)
                rcNew.left -= GetSystemMetrics(SM_CXFRAME);

            if (VK_RIGHT == dwDirection)
                rcNew.left += GetSystemMetrics(SM_CXFRAME);

            if ((rcNew.right - rcNew.left) < iMin)
                rcNew.left = rcNew.right - iMin;
            break;

    }

    if (!EqualRect(&rcOld, &rcNew))
    {
        int iWH;
        RECT rcScreen;

        // don't let the new size get > MonitorRect/2
        GetMonitorRect(_hMon, &rcScreen);   // aka GetSystemMetrics(SM_CXSCREEN)
        iWH = RECTGETWH(_uSide, &rcScreen);
        iWH /= 2;
        if (RECTGETWH(_uSide, &rcNew) > iWH) 
        {
            RectXform(&rcNew, RX_OPPOSE, &rcNew, NULL, iWH, _uSide, NULL);
        }

        _SetVRect(&rcNew);
        _Recalc();
    }
}


//*** CDockingBar::IOleCommandTarget::* {

HRESULT CDockingBar::Exec(const GUID *pguidCmdGroup,
    DWORD nCmdID, DWORD nCmdexecopt,
    VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
    if (pguidCmdGroup == NULL) {
        /*NOTHING*/
    }
    else if (IsEqualGUID(CGID_ShellDocView, *pguidCmdGroup)) {
        switch (nCmdID) {
        case SHDVID_RAISE:
            ASSERT(pvarargIn && pvarargIn->vt == VT_I4);
            if (pvarargIn->vt == VT_I4 && pvarargIn->lVal != DTRF_QUERY) {
                _OnRaise(pvarargIn->lVal);
                return S_OK;
            }
            break;  // e.g. DTRF_QUERY
        default:
            // note that this means we may get OLECMDERR_E_UNKNOWNGROUP
            // rather than OLECMDERR_E_NOTSUPPORTED for unhandled guys...
            break;
        }
    } 
    else if (IsEqualGUID(CGID_DeskBarClient, *pguidCmdGroup)) 
    {
        if (DBCID_RESIZE == nCmdID)
        {
            _GrowShrinkBar(nCmdexecopt);
            return S_OK;
        }
    }
    
    return SUPERCLASS::Exec(pguidCmdGroup, nCmdID, nCmdexecopt,
        pvarargIn, pvarargOut);
}
// }

//*** CDockingBar::IDockingWindow::* {
//

HRESULT CDockingBar::SetSite(IUnknown* punkSite)
{
    ATOMICRELEASE(_ptbSite);

    if (punkSite)
    {
        HRESULT hresT;
        hresT = punkSite->QueryInterface(IID_IDockingWindowSite, (LPVOID*)&_ptbSite);

        IUnknown_GetWindow(punkSite, &_hwndSite);

        //
        // Check if we are under the desktop browser or not and set
        // the initial state correctly. (Always on top for Desktop)
        //
        IUnknown* punkT;
        hresT = punkSite->QueryInterface(SID_SShellDesktop, (LPVOID*)&punkT);
        if (SUCCEEDED(hresT))
        {
            _fDesktop = TRUE;
            punkT->Release();
        }

        if (!_fInitSited)
        {
            if (!_eInitLoaded)
            {
                // if we haven't initialized, do it now.
                InitNew();
                _eMode = WBM_BOTTOMMOST;
            }
                
            ASSERT(_eInitLoaded);
            if (_eInitLoaded == IPS_INITNEW)
            {
                _InitPos4(FALSE);
                _eMode = _fDesktop ? WBM_TOPMOST : WBM_BBOTTOMMOST;
            }
        }
        ASSERT(_eMode != WBM_NIL);
        // WARNING actually we could also be owned floating...
        ASSERT(ISWBM_DESKTOP() == _fDesktop);
        ASSERT(_fDesktop || _eMode == WBM_BBOTTOMMOST);
        ASSERT(ISWBM_DESKTOP() == _fDesktop);
        ASSERT(ISWBM_DESKTOP() || _eMode == WBM_BBOTTOMMOST);
    }

    _fInitSited = TRUE;     // done w/ 1st-time init

    return S_OK;
}

HRESULT CDockingBar::ShowDW(BOOL fShow)
{
    fShow = BOOLIFY(fShow);     // so comparisons and assigns to bitfields work

    // we used to early out if BOOLIFY(_fShow) == fShow.
    // however we now count on ShowDW(TRUE) to force a refresh
    // (e.g. when screen resolution changes CBB::v_ShowHideChildWindows
    // calls us)
    if (BOOLIFY(_fShow) == fShow)
        return S_OK;

    _fShow = fShow;

    if (!_fInitShowed)
    {
        ASSERT(_fInitSited && _eInitLoaded);
        _Initialize();
        ASSERT(_fInitShowed);
    }

    if (_fShow)
    {
        // FEATURE: switch to using _ChangeTopMost, it already does this... 
        // Tell itself to resize.

        // use _MoveSizeHelper (not just _NegotiateBorderRect) since we might
        // actually be moving to a new position...
        _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
        // _NegotiateBorderRect(NULL, NULL, FALSE)

        if (_pDBC)
            _pDBC->UIActivateDBC(DBC_SHOW);

        // nt5:148444: SW_SHOWNA (vs. SW_SHOW) so we don't unhide on create
        // this fix will cause a new bug -- newly created bars don't have
        // focus (e.g. drag a band to floating, the new floating bar won't
        // have focus) -- but that should be the lesser of evils.
        //ShowWindow(_hwnd, ISWBM_FLOAT(_eMode) ? SW_SHOWNORMAL : SW_SHOWNA);
        ShowWindow(_hwnd, SW_SHOWNA);
        _OnSize();
    }
    else
    {
        ShowWindow(_hwnd, SW_HIDE);
        if (EVAL(_pDBC))
            _pDBC->UIActivateDBC(DBC_SHOWOBSCURE);
        UIActivateIO(FALSE, NULL);
        
        // Tell itself to resize.

        // don't call MoveSizeHelper here since it will do (e.g.)
        // negotiation, which will cause flicker and do destructive stuff.
        //_Recalc();  //_MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
        _NegotiateBorderRect(NULL, NULL, TRUE);     // hide=>0 border space
    }

    return S_OK;
}

HRESULT CDockingBar::ResizeBorderDW(LPCRECT prcBorder,
    IUnknown* punkToolbarSite, BOOL fReserved)
{
    _Recalc();  // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
    return S_OK;    // FEATURE _NegotiateBorderRect()?
}

HRESULT CDockingBar::_NegotiateBorderRect(RECT* prcOut, RECT* prcReq, BOOL fCommit)
{
    UINT eMode, uSide;
    HMONITOR hMon;
    int iWH;

    // FEATURE: should be params like MSH etc.
    eMode = ((_fDragging == DRAG_MOVE) ? _eModePending : _eMode);
    uSide = ((_fDragging == DRAG_MOVE) ? _uSidePending : _uSide);
    hMon = ((_fDragging == DRAG_MOVE) ? _hMonPending : _hMon);

    if (prcOut != prcReq && prcOut != NULL && prcReq != NULL)
        CopyRect(prcOut, prcReq);

    if (_ptbSite) {
        RECT rcRequest = { 0, 0, 0, 0 };

        if (_fShow && ISWBM_BOTTOM(eMode)) {

            if (prcReq)
            {
                iWH = RectGetWH(prcReq, uSide);
                ASSERT(iWH == _adEdge[uSide]);
                if ((!_fCanHide) && uSide != ABE_NIL)
                    ((int*)&rcRequest)[uSide] = iWH;
            }
                
            if (_fTheater) {
                // MOVE TO CBROWSERBAR

                
                // we override the left that we request from the browser, but
                // we need to notify theater what the user has requested for the expaneded width
                VARIANTARG v = { 0 };
                v.vt = VT_I4;
                v.lVal = rcRequest.left;
                IUnknown_Exec(_ptbSite, &CGID_Theater, THID_SETBROWSERBARWIDTH, 0, &v, NULL);
                _iTheaterWidth = v.lVal;
                
                // if we're in theater mode, we can only be on the left and we only grab left border
                ASSERT(uSide == ABE_LEFT);

                // if we're in autohide mode, we request no space
                if (!_fNoAutoHide)
                    rcRequest.left = 0;

                // END MOVE TO CBROWSERBAR                
            }
        }

        // FEATURE: leave alone (at 0 from HideRegister?) if _fHiding==HIDE_AUTO
        HMONITOR hMonOld = _SetNewMonitor(hMon);  

        _ptbSite->RequestBorderSpaceDW(SAFECAST(this, IDockingWindow*), &rcRequest);
        if (fCommit) {
            RECT rcMirRequest;
            LPRECT lprcRequest = &rcRequest; 

            if (IS_WINDOW_RTL_MIRRORED(_hwnd) && 
                !IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd))) {
                // Swap left and right.
                rcMirRequest.left   = rcRequest.right;
                rcMirRequest.right  = rcRequest.left;
                rcMirRequest.top    = rcRequest.top;
                rcMirRequest.bottom = rcRequest.bottom;

                lprcRequest = &rcMirRequest;
            }
            _ptbSite->SetBorderSpaceDW(SAFECAST(this, IDockingWindow*), lprcRequest);
        }

        if (_fShow && ISWBM_BOTTOM(eMode) && !_fTheater) {
            // were'd we end up (as a real rect not just a size)?
            // start w/ our full border area, then apply negotiated width.
            // however that may have also moved us in from the edge, which
            // we don't want if we're autohide, so snap back to edge if so.
            _ptbSite->GetBorderDW(SAFECAST(this, IDockingWindow*), prcOut);

            // aka ClientToScreen
            if (prcOut)
                MapWindowPoints(_hwndSite, HWND_DESKTOP, (POINT*) prcOut, 2);

            if ((!_fCanHide) && uSide != ABE_NIL)
                iWH = ((int*)&rcRequest)[uSide];
            
            RectXform(prcOut, (_fCanHide ? RX_EDGE : 0)|RX_OPPOSE|(_fHiding ? RX_HIDE : 0), prcOut, NULL, iWH, uSide, hMon);
        }
        
        if (hMonOld)
            _SetNewMonitor(hMonOld);

    }

    return S_OK;
}

// }

//*** CDockingBar::IPersistStream*::* {
//

HRESULT CDockingBar::IsDirty(void)
{
    return S_FALSE; // Never be dirty
}

//
// Persisted CDockingBar
//
struct SWebBar
{
    DWORD   cbSize;
    DWORD   cbVersion;
    UINT    uSide : 3;
    UINT    fWantHide :1;
    INT     adEdge[4];  // FEATURE: wordsize dependent
    RECT    rcFloat;    
    POINT   ptSiteCenter; // Center of the docking site -- in case of multiple docking sites

    UINT    eMode;
    UINT    fAlwaysOnTop;

    RECT    rcChild;
};

#define SWB_VERSION 8

HRESULT CDockingBar::Load(IStream *pstm)
{
    SWebBar swb = {0};
    ULONG cbRead;

    TraceMsg(DM_PERSIST, "cwb.l enter(this=%x pstm=%x) tell()=%x", this, pstm, DbStreamTell(pstm));

    ASSERT(!_eInitLoaded);
    HRESULT hres = pstm->Read(&swb, SIZEOF(swb), &cbRead);
#ifdef DEBUG
    // just in case we toast ourselves (offscreen or something)...
    static BOOL fNoPersist = FALSE;
    if (fNoPersist)
        hres = E_FAIL;
#endif
    
    if (hres==S_OK && cbRead==SIZEOF(swb)) {
        // REARCHITECT: this is not forward compatible!
        if (swb.cbSize==SIZEOF(SWebBar) && swb.cbVersion==SWB_VERSION) {

            _eMode = swb.eMode;
            _uSide = swb.uSide;
            _hMon  = MonitorFromPoint(swb.ptSiteCenter, MONITOR_DEFAULTTONEAREST);
            // don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize
            _fWantHide = swb.fWantHide;
            memcpy(_adEdge, swb.adEdge, SIZEOF(_adEdge));
            _rcFloat = swb.rcFloat;
            _NotifyModeChange(0);

            // child (e.g. bandsite)
            ASSERT(_pDBC != NULL);
            if (_pDBC != NULL) {
                // require IPersistStreamInit?
                IPersistStream *ppstm;
                hres = _pDBC->QueryInterface(IID_IPersistStream, (LPVOID*)&ppstm);
                if (SUCCEEDED(hres)) {

                    // set the child size first because initialization layout might depend on it
                    SetWindowPos(_hwndChild, 0,
                                 swb.rcChild.left, swb.rcChild.top, RECTWIDTH(swb.rcChild), RECTHEIGHT(swb.rcChild),
                                 SWP_NOACTIVATE|SWP_NOZORDER);
                    
                    ppstm->Load(pstm);
                    ppstm->Release();
                }
            }

            _eInitLoaded = IPS_LOAD;    // what if OLFS of bands fails?
            TraceMsg(DM_PERSIST, "CDockingBar::Load succeeded");
        } else {
            TraceMsg(DM_ERROR, "CWB::Load failed swb.cbSize==SIZEOF(SWebBar) && swb.cbVersion==SWB_VERSION");
            hres = E_FAIL;
        }
    } else {
        TraceMsg(DM_ERROR, "CWB::Load failed (hres==S_OK && cbRead==SIZEOF(_adEdge)");
        hres = E_FAIL;
    }
    TraceMsg(DM_PERSIST, "cwb.l leave tell()=%x", DbStreamTell(pstm));
    return hres;
}

HRESULT CDockingBar::Save(IStream *pstm, BOOL fClearDirty)
{
    HRESULT hres;
    SWebBar swb = {0};
    RECT rcMonitor;

    swb.cbSize = SIZEOF(SWebBar);
    swb.cbVersion = SWB_VERSION;
    swb.uSide = _uSide;
    swb.eMode = _eMode;
    swb.fWantHide = _fWantHide;
    memcpy(swb.adEdge, _adEdge, SIZEOF(_adEdge));
    swb.rcFloat = _rcFloat;
    GetWindowRect(_hwndChild, &swb.rcChild);
    MapWindowRect(HWND_DESKTOP, _hwnd, &swb.rcChild);

    ASSERT(_hMon);
    GetMonitorRect(_hMon, &rcMonitor);
    swb.ptSiteCenter.x = (rcMonitor.left + rcMonitor.right) / 2;
    swb.ptSiteCenter.y = (rcMonitor.top + rcMonitor.bottom) / 2;
    
    hres = pstm->Write(&swb, SIZEOF(swb), NULL);
    if (SUCCEEDED(hres))
    {
        IPersistStream* ppstm;
        hres = _pDBC->QueryInterface(IID_IPersistStream, (LPVOID*)&ppstm);
        if (SUCCEEDED(hres))
        {
            hres = ppstm->Save(pstm, TRUE);
            ppstm->Release();
        }
    }
    
    return hres;
}

HRESULT CDockingBar::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
    ULARGE_INTEGER cbMax = { SIZEOF(SWebBar), 0 };
    *pcbSize = cbMax;
    return S_OK;
}

HRESULT CDockingBar::InitNew(void)
{
    ASSERT(!_eInitLoaded);
    _eInitLoaded = IPS_INITNEW;
    TraceMsg(DM_PERSIST, "CDockingBar::InitNew called");

    // can't call _InitPos4 until set site in SetSite
    // don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize

    // derived class (e.g. CBrowserBarApp) does the _Populate...

    // on first creation, before bands are added, but the bandsite IS created, we need to notify the bandsite of the new position
    _NotifyModeChange(0);
    return S_OK;
}

HRESULT CDockingBar::Load(IPropertyBag *pPropBag, IErrorLog *pErrorLog)
{
    ASSERT(!_eInitLoaded);

    _eInitLoaded = IPS_LOADBAG;

    // TODO: We'll read following properties.
    //
    //  URL = "..."
    //  Mode = 0 - TopMost, 1 - Bottom, 2 - Undocked
    //  Side = 0 - Right, 1 - Top, 2 - Left, 3 - Bottom
    //  Left/Right/Top/Bottom = Initial docked size
    //


    UINT uSide;
    UINT eMode = _eMode;

    if (WBM_NIL == eMode)
        eMode = WBM_BOTTOMMOST;
    
    eMode = PropBag_ReadInt4(pPropBag, L"Mode", eMode);
    uSide = PropBag_ReadInt4(pPropBag, L"Side", _uSide);
    _adEdge[ABE_LEFT] = PropBag_ReadInt4(pPropBag, L"Left", _adEdge[ABE_LEFT]);
    _adEdge[ABE_RIGHT] = PropBag_ReadInt4(pPropBag, L"Right", _adEdge[ABE_RIGHT]);
    _adEdge[ABE_TOP] = PropBag_ReadInt4(pPropBag, L"Top", _adEdge[ABE_TOP]);
    _adEdge[ABE_BOTTOM] = PropBag_ReadInt4(pPropBag, L"Bottom", _adEdge[ABE_BOTTOM]);

    int x = PropBag_ReadInt4(pPropBag, L"X", _rcFloat.left);
    int y = PropBag_ReadInt4(pPropBag, L"Y", _rcFloat.top);
    OffsetRect(&_rcFloat, x - _rcFloat.left, y - _rcFloat.top);

    int cx = PropBag_ReadInt4(pPropBag, L"CX", RECTWIDTH(_rcFloat));
    int cy = PropBag_ReadInt4(pPropBag, L"CY", RECTHEIGHT(_rcFloat));
    _rcFloat.right = _rcFloat.left + cx;
    _rcFloat.bottom = _rcFloat.top + cy;

    // set up vars for eventual CDockingBar::_Initialize call
    ASSERT(!CDB_INITED());
    _eMode = eMode;
    _uSide = uSide;
    
    POINT pt = {x, y};
    // (dli) compute the new hMonitor 
    _hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);

    // don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize

    // derived class (e.g. CBrowserBarApp) does the _Populate...

    // on first creation, before bands are added, but the bandsite IS created, we need to notify the bandsite of the new position
    _NotifyModeChange(0);
    return S_OK;
}

HRESULT CDockingBar::Save(IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
{
    // We don't need to support this for now.
    return E_NOTIMPL;
}

// }

//*** CDockingBar::IDocHostUIHandler::* {
//

HRESULT CDockingBar::ShowContextMenu(DWORD dwID,
    POINT* ppt,
    IUnknown* pcmdtReserved,
    IDispatch* pdispReserved)
{
    if (dwID==0) {
        TraceMsg(DM_MENU, "cdb.scm: intercept");
        return _TrackPopupMenu(ppt);
    }
    return S_FALSE;
}


// }


void CDockingBar::_SetModeSide(UINT eMode, UINT uSide, HMONITOR hMonNew, BOOL fNoMerge) 
{
    _ChangeTopMost(eMode);
    _uSide = uSide;
    _hMon = hMonNew;
    _SetNewMonitor(hMonNew);
}


// *** IInputObjectSite methods ***

HRESULT CDockingBar::OnFocusChangeIS(IUnknown *punk, BOOL fSetFocus)
{
    return IUnknown_OnFocusChangeIS(_ptbSite, SAFECAST(this, IInputObject*), fSetFocus);
}


////////////////////////////////////////////////////////////////
//
//  A deskbar property bag
//////
HRESULT CDockingBarPropertyBag_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
    CDockingBarPropertyBag* p = new CDockingBarPropertyBag();
    if (p != NULL)
    {
        *ppunk = SAFECAST(p, IPropertyBag*);
        return S_OK;
    }

    *ppunk = NULL;
    return E_OUTOFMEMORY;
}

ULONG CDockingBarPropertyBag::AddRef()
{
    _cRef++;
    return _cRef;
}

ULONG CDockingBarPropertyBag::Release()
{
    ASSERT(_cRef > 0);
    _cRef--;

    if (_cRef > 0)
        return _cRef;

    delete this;
    return 0;
}

HRESULT CDockingBarPropertyBag::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
    static const QITAB qit[] = {
        QITABENT(CDockingBarPropertyBag, IPropertyBag),     // IID_IPropertyBag
        QITABENT(CDockingBarPropertyBag, IDockingBarPropertyBagInit),     // IID_IDockingBarPropertyBagInit
        { 0 },
    };

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


const WCHAR * const c_szPropNames[] = {
    L"Side",
    L"Mode",
    L"Left",
    L"Top",
    L"Right",
    L"Bottom",
    L"Deleteable",
    L"X",
    L"Y",
    L"CX",
    L"CY"
};


HRESULT CDockingBarPropertyBag::Read( 
                    /* [in] */ LPCOLESTR pszPropName,
                    /* [out][in] */ VARIANT *pVar,
                    /* [in] */ IErrorLog *pErrorLog)
{
    int epropdata;

    for (epropdata = 0; epropdata < (int)PROPDATA_COUNT; epropdata++) {
        if (!StrCmpW(pszPropName, c_szPropNames[epropdata])) {
            break;
        }
    }

    if (epropdata < PROPDATA_COUNT && 
        _props[epropdata]._fSet) {
        pVar->lVal = _props[epropdata]._dwData;
        pVar->vt = VT_I4;
        return S_OK;
    }
    
    return E_FAIL;
}




#ifdef DEBUG
//***   DbCheckWindow --
// NOTES
//  FEATURE: Its a bad idea, why break working code, but here is the suggestion:
//  nuke the 'hwndClient' param and just use GetParent (but what
//  about 'owned' windows, does GetParent give the correct answer?)
BOOL DbCheckWindow(HWND hwnd, RECT *prcExp, HWND hwndClient)
{
    RECT rcAct;

    GetWindowRect(hwnd, &rcAct);
    hwndClient = GetParent(hwnd);   // nuke this param
    if (hwndClient != NULL) {
        // aka ClientToScreen
        MapWindowPoints(HWND_DESKTOP, hwndClient, (POINT*) &rcAct, 2);
    }
    if (!EqualRect(&rcAct, prcExp)) {
        TraceMsg(DM_TRACE,
            "cwb.dbcw: !EqualRect rcAct=(%d,%d,%d,%d) (%dx%d) rcExp=(%d,%d,%d,%d) (%dx%d) hwndClient=0x%x",
            rcAct.left, rcAct.top, rcAct.right, rcAct.bottom,
            RECTWIDTH(rcAct), RECTHEIGHT(rcAct),
            prcExp->left, prcExp->top, prcExp->right, prcExp->bottom,
            RECTWIDTH(*prcExp), RECTHEIGHT(*prcExp),
            hwndClient);
        return FALSE;
    }
    return TRUE;
}

//***   DbStreamTell -- get position in stream (low part only)
//
unsigned long DbStreamTell(IStream *pstm)
{
    if (pstm == 0)
        return (unsigned long) -1;

    ULARGE_INTEGER liEnd;

    pstm->Seek(c_li0, STREAM_SEEK_CUR, &liEnd);
    if (liEnd.HighPart != 0)
        TraceMsg(DM_TRACE, "DbStreamTell: hi!=0");
    return liEnd.LowPart;
}

//***   DbMaskToMneStr -- pretty-print a bit mask in mnemonic form
// ENTRY/EXIT
//  uMask       bit mask
//  szMne       mnemonics, sz[0] for bit 0 .. sz[N] for highest bit
//  return      ptr to *static* buffer
// NOTES
//  n.b.: non-reentrant!!!
TCHAR *DbMaskToMneStr(UINT uMask, TCHAR *szMnemonics)
{
    static TCHAR buf[33];       // FEATURE: non-reentrant!!!
    TCHAR *p;

    p = &buf[ARRAYSIZE(buf) - 1];       // point at EOS
    ASSERT(*p == '\0');
    for (;;) {
        if (*szMnemonics == 0) {
            ASSERT(uMask == 0);
            break;
        }

        --p;
        *p = (uMask & 1) ? *szMnemonics : TEXT('-');

        ++szMnemonics;
        uMask >>= 1;
    }

    return p;
}
#endif