windows-xp/Source/XPSP1/NT/shell/explorer/desktop2/deskhost.cpp

#include "stdafx.h"
#include <startids.h>           // for IDM_PROGRAMS et al
#include "regstr.h"
#include "rcids.h"
#include <desktray.h>
#include "tray.h"
#include "startmnu.h"
#include "hostutil.h"
#include "deskhost.h"
#include "shdguid.h"

#define REGSTR_EXPLORER_ADVANCED REGSTR_PATH_EXPLORER TEXT("\\Advanced")

#define TF_DV2HOST  0
// #define TF_DV2HOST TF_CUSTOM1

#define TF_DV2DIALOG  0
// #define TF_DV2DIALOG TF_CUSTOM1

EXTERN_C HINSTANCE hinstCabinet;
HRESULT StartMenuHost_Create(IMenuPopup** ppmp, IMenuBand** ppmb);
void RegisterDesktopControlClasses();

const WCHAR c_wzStartMenuTheme[] = L"StartMenu";

//*****************************************************************

CPopupMenu::~CPopupMenu()
{
    IUnknown_SetSite(_pmp, NULL);
    ATOMICRELEASE(_pmp);
    ATOMICRELEASE(_pmb);
    ATOMICRELEASE(_psm);
}

HRESULT CPopupMenu::Popup(RECT *prcExclude, DWORD dwFlags)
{
    COMPILETIME_ASSERT(sizeof(RECT) == sizeof(RECTL));
    return _pmp->Popup((POINTL*)prcExclude, (RECTL*)prcExclude, dwFlags);
}


HRESULT CPopupMenu::Initialize(IShellMenu *psm, IUnknown *punkSite, HWND hwnd)
{
    HRESULT hr;

    // We should have been zero-initialized
    ASSERT(_pmp == NULL);
    ASSERT(_pmb == NULL);
    ASSERT(_psm == NULL);

    hr = CoCreateInstance(CLSID_MenuDeskBar, NULL, CLSCTX_INPROC_SERVER,
                          IID_PPV_ARG(IMenuPopup, &_pmp));
    if (SUCCEEDED(hr))
    {
        IUnknown_SetSite(_pmp, punkSite);

        IBandSite *pbs;
        hr = CoCreateInstance(CLSID_MenuBandSite, NULL, CLSCTX_INPROC_SERVER,
                              IID_PPV_ARG(IBandSite, &pbs));
        if (SUCCEEDED(hr))
        {
            hr = _pmp->SetClient(pbs);
            if (SUCCEEDED(hr))
            {
                IDeskBand *pdb;
                if (SUCCEEDED(psm->QueryInterface(IID_PPV_ARG(IDeskBand, &pdb))))
                {
                    hr = pbs->AddBand(pdb);
                    if (SUCCEEDED(hr))
                    {
                        DWORD dwBandID;
                        hr = pbs->EnumBands(0, &dwBandID);
                        if (SUCCEEDED(hr))
                        {
                            hr = pbs->GetBandObject(dwBandID, IID_PPV_ARG(IMenuBand, &_pmb));
                        }
                    }
                    pdb->Release();
                }
            }
            pbs->Release();
        }
    }

    if (SUCCEEDED(hr))
    {
        // Failure to set the theme is nonfatal
        IShellMenu2* psm2;
        if (SUCCEEDED(psm->QueryInterface(IID_PPV_ARG(IShellMenu2, &psm2))))
        {
            BOOL fThemed = IsAppThemed();
            psm2->SetTheme(fThemed ? c_wzStartMenuTheme : NULL);
            psm2->SetNoBorder(fThemed ? TRUE : FALSE);
            psm2->Release();
        }

        // Tell the popup that we are the window to parent UI on
        // This will fail on purpose so don't freak out
        psm->SetMenu(NULL, hwnd, 0);
    }

    if (SUCCEEDED(hr))
    {
        _psm = psm;
        psm->AddRef();
        hr = S_OK;
    }

    return hr;
}

HRESULT CPopupMenu_CreateInstance(IShellMenu *psm,
                                  IUnknown *punkSite,
                                  HWND hwnd,
                                  CPopupMenu **ppmOut)
{
    HRESULT hr;
    *ppmOut = NULL;
    CPopupMenu *ppm = new CPopupMenu();
    if (ppm)
    {
        hr = ppm->Initialize(psm, punkSite, hwnd);
        if (FAILED(hr))
        {
            ppm->Release();
        }
        else
        {
            *ppmOut = ppm;  // transfer ownership to called
        }
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }
    return hr;
}

//*****************************************************************

const STARTPANELMETRICS g_spmDefault = {
    {380,440},
    {
        {WC_USERPANE,   0,                      SPP_USERPANE,      {380,  40}, NULL, NULL},
        {WC_SFTBARHOST, WS_TABSTOP,             SPP_PROGLIST,      {190, 330}, NULL, NULL},
        {WC_MOREPROGRAMS, 0,                    SPP_MOREPROGRAMS,  {190,  30}, NULL, NULL},
        {WC_SFTBARHOST, 0,                      SPP_PLACESLIST,    {190, 360}, NULL, NULL},
        {WC_LOGOFF,     0,                      SPP_LOGOFF,        {380,  40}, NULL, NULL},
    }
};

HRESULT
CDesktopHost::Initialize()
{
    ASSERT(_hwnd == NULL);

    //
    //  Load some settings.
    //
    _fAutoCascade = SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("Start_AutoCascade"), FALSE, TRUE);

    return S_OK;
}

HRESULT CDesktopHost::QueryInterface(REFIID riid, void **ppvObj)
{
    static const QITAB qit[] =
    {
        QITABENT(CDesktopHost, IMenuPopup),
        QITABENT(CDesktopHost, IDeskBar),       // IMenuPopup derives from IDeskBar
        QITABENTMULTI(CDesktopHost, IOleWindow, IMenuPopup),  // IDeskBar derives from IOleWindow

        QITABENT(CDesktopHost, IMenuBand),
        QITABENT(CDesktopHost, IServiceProvider),
        QITABENT(CDesktopHost, IOleCommandTarget),
        QITABENT(CDesktopHost, IObjectWithSite),

        QITABENT(CDesktopHost, ITrayPriv),      // going away
        QITABENT(CDesktopHost, ITrayPriv2),     // going away
        { 0 },
    };

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

HRESULT CDesktopHost::SetSite(IUnknown *punkSite)
{
    CObjectWithSite::SetSite(punkSite);
    if (!_punkSite)
    {
        // This is our cue to break the recursive reference loop
        // The _ppmpPrograms contains multiple backreferences to
        // the CDesktopHost (we are its site, it also references
        // us via CDesktopShellMenuCallback...)
        ATOMICRELEASE(_ppmPrograms);
    }
    return S_OK;
}

CDesktopHost::~CDesktopHost()
{
    if (_hbmCachedSnapshot)
    {
        DeleteObject(_hbmCachedSnapshot);
    }

    ATOMICRELEASE(_ppmPrograms);
    ATOMICRELEASE(_ppmTracking);

    if (_hwnd)
    {
        ASSERT(GetWindowThreadProcessId(_hwnd, NULL) == GetCurrentThreadId());
        DestroyWindow(_hwnd);
    }
    ATOMICRELEASE(_ptFader);

}

BOOL CDesktopHost::Register()
{
    _wmDragCancel = RegisterWindowMessage(TEXT("CMBDragCancel"));

    WNDCLASSEX  wndclass;

    wndclass.cbSize         = sizeof(wndclass);
    wndclass.style          = CS_DROPSHADOW;
    wndclass.lpfnWndProc    = WndProc;
    wndclass.cbClsExtra     = 0;
    wndclass.cbWndExtra     = 0;
    wndclass.hInstance      = hinstCabinet;
    wndclass.hIcon          = NULL;
    wndclass.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground  = GetStockBrush(HOLLOW_BRUSH);
    wndclass.lpszMenuName   = NULL;
    wndclass.lpszClassName  = WC_DV2;
    wndclass.hIconSm        = NULL;
    
    return (0 != RegisterClassEx(&wndclass));
}

inline int _ClipCoord(int x, int xMin, int xMax)
{
    if (x < xMin) x = xMin;
    if (x > xMax) x = xMax;
    return x;
}

//
//  Everybody conspires against us.
//
//  CTray does not pass us any MPPF_POS_MASK flags to tell us where we
//  need to pop up relative to the point, so there's no point looking
//  at the dwFlags parameter.  Which is for the better, I guess, because
//  the MPPF_* flags are not the same as the TPM_* flags.  Go figure.
//
//  And then the designers decided that the Start Menu should pop up
//  in a location different from the location that the standard
//  TrackPopupMenuEx function chooses, so we need a custom positioning
//  algorithm anyway.
//
//  And finally, the AnimateWindow function takes AW_* flags, which are
//  not the same as TPM_*ANIMATE flags.  Go figure.  But since we gave up
//  on trying to map IMenuPopup::Popup to TrackPopupMenuEx anyway, we
//  don't have to do any translation here anyway.
//
//  Returns animation direction.
//
void CDesktopHost::_ChoosePopupPosition(POINT *ppt, LPCRECT prcExclude, LPRECT prcWindow)
{
    //
    // Calculate the monitor BEFORE we adjust the point.  Otherwise, we might
    // move the point offscreen.  In which case, we will end up pinning the
    // popup to the primary display, which is wron_
    //
    HMONITOR hmon = MonitorFromPoint(*ppt, MONITOR_DEFAULTTONEAREST);
    MONITORINFO minfo;
    minfo.cbSize = sizeof(minfo);
    GetMonitorInfo(hmon, &minfo);

    // Clip the exclude rectangle to the monitor

    RECT rcExclude;
    if (prcExclude)
    {
        // We can't use IntersectRect because it turns the rectangle
        // into (0,0,0,0) if the intersection is empty (which can happen if
        // the taskbar is autohide) but we want to glue it to the nearest
        // valid edge.
        rcExclude.left   = _ClipCoord(prcExclude->left,   minfo.rcMonitor.left, minfo.rcMonitor.right);
        rcExclude.right  = _ClipCoord(prcExclude->right,  minfo.rcMonitor.left, minfo.rcMonitor.right);
        rcExclude.top    = _ClipCoord(prcExclude->top,    minfo.rcMonitor.top, minfo.rcMonitor.bottom);
        rcExclude.bottom = _ClipCoord(prcExclude->bottom, minfo.rcMonitor.top, minfo.rcMonitor.bottom);
    }
    else
    {
        rcExclude.left = rcExclude.right = ppt->x;
        rcExclude.top = rcExclude.bottom = ppt->y;
    }

    _ComputeActualSize(&minfo, &rcExclude);

    // initialize the height and width from what the layout asked for
    int cy=RECTHEIGHT(_rcActual);
    int cx=RECTWIDTH(_rcActual);

    ASSERT(cx && cy); // we're in trouble if these are zero
    
    int x, y;

    //
    //  First: Determine whether we are going to pop upwards or downwards.
    //

    BOOL fSide = FALSE;

    if (rcExclude.top - cy >= minfo.rcMonitor.top)
    {
        // There is room above.
        y = rcExclude.top - cy;
    }
    else if (rcExclude.bottom - cy >= minfo.rcMonitor.top)
    {
        // There is room above if we slide to the side.
        y = rcExclude.bottom - cy;
        fSide = TRUE;
    }
    else if (rcExclude.bottom + cy <= minfo.rcMonitor.bottom)
    {
        // There is room below.
        y = rcExclude.bottom;
    }
    else if (rcExclude.top + cy <= minfo.rcMonitor.bottom)
    {
        // There is room below if we slide to the side.
        y = rcExclude.top;
        fSide = TRUE;
    }
    else
    {
        // We don't fit anywhere.  Pin to the appropriate edge of the screen.
        // And we have to go to the side, too.
        fSide = TRUE;

        if (rcExclude.top - minfo.rcMonitor.top < minfo.rcMonitor.bottom - rcExclude.bottom)
        {
            // Start button at top of screen; pin to top
            y = minfo.rcMonitor.top;
        }
        else
        {
            // Start button at bottom of screen; pin to bottom
            y = minfo.rcMonitor.bottom - cy;
        }
    }

    //
    //  Now choose whether we will pop left or right.  Try right first.
    //

    x = fSide ? rcExclude.right : rcExclude.left;
    if (x + cx > minfo.rcMonitor.right)
    {
        // Doesn't fit to the right; pin to the right edge.
        // Notice that we do *not* try to pop left.  For some reason,
        // the start menu never pops left.

        x = minfo.rcMonitor.right - cx;
    }

    SetRect(prcWindow, x, y, x+cx, y+cy);
}

int GetDesiredHeight(HWND hwndHost, SMPANEDATA *psmpd)
{
    SMNGETMINSIZE nmgms = {0};
    nmgms.hdr.hwndFrom = hwndHost;
    nmgms.hdr.code = SMN_GETMINSIZE;
    nmgms.siz = psmpd->size;

    SendMessage(psmpd->hwnd, WM_NOTIFY, nmgms.hdr.idFrom, (LPARAM)&nmgms);

    return nmgms.siz.cy;
}

//
// Query each item to see if it has any size requirements.
// Position all the items at their final locations.
//
void CDesktopHost::_ComputeActualSize(MONITORINFO *pminfo, LPCRECT prcExclude)
{
    // Compute the maximum permissible space above/below the Start Menu.
    // Designers don't want the Start Menu to slide horizontally; it must
    // fit entirely above or below.

    int cxMax = RECTWIDTH(pminfo->rcWork);
    int cyMax = max(prcExclude->top - pminfo->rcMonitor.top,
                    pminfo->rcMonitor.bottom - prcExclude->bottom);

    // Start at the minimum size and grow as necesary
    _rcActual = _rcDesired;

    // Ask the windows if they wants any adjustments
    int iMFUHeight = GetDesiredHeight(_hwnd, &_spm.panes[SMPANETYPE_MFU]);
    int iPlacesHeight = GetDesiredHeight(_hwnd, &_spm.panes[SMPANETYPE_PLACES]);
    int iMoreProgHeight = _spm.panes[SMPANETYPE_MOREPROG].size.cy;

    // Figure out the maximum size for each pane
    int cyPlacesMax = cyMax - (_spm.panes[SMPANETYPE_USER].size.cy + _spm.panes[SMPANETYPE_LOGOFF].size.cy);
    int cyMFUMax    = cyPlacesMax - _spm.panes[SMPANETYPE_MOREPROG].size.cy;


    TraceMsg(TF_DV2HOST, "MFU Desired Height=%d(cur=%d,max=%d), Places Desired Height=%d(cur=%d,max=%d)",
        iMFUHeight, _spm.panes[SMPANETYPE_MFU].size.cy, cyMFUMax, 
        iPlacesHeight, _spm.panes[SMPANETYPE_PLACES].size.cy, cyPlacesMax);

    // Clip each pane to its max - the smaller of (The largest possible or The largest we want to be)
    _fClipped = FALSE;
    if (iMFUHeight > cyMFUMax)
    {
        iMFUHeight = cyMFUMax;
        _fClipped = TRUE;
    }

    if (iPlacesHeight > cyPlacesMax)
    {
        iPlacesHeight = cyPlacesMax;
        _fClipped = TRUE;
    }

    // ensure that places == mfu + moreprog by growing the smaller of the two.
    if (iPlacesHeight > iMFUHeight + iMoreProgHeight)
        iMFUHeight = iPlacesHeight - iMoreProgHeight;
    else
        iPlacesHeight = iMFUHeight + iMoreProgHeight;

    //
    // move the actual windows
    // See diagram of layout in deskhost.h for the hardcoded assumptions here.
    //  this could be made more flexible/variable, but we want to lock in this layout
    //

    // helper variables...
    DWORD dwUserBottomEdge = _spm.panes[SMPANETYPE_USER].size.cy;
    DWORD dwMFURightEdge =   _spm.panes[SMPANETYPE_MFU].size.cx;
    DWORD dwMFUBottomEdge =  dwUserBottomEdge + iMFUHeight;
    DWORD dwMoreProgBottomEdge = dwMFUBottomEdge + iMoreProgHeight;

    // set the size of the overall pane
    _rcActual.right = _spm.panes[SMPANETYPE_USER].size.cx;
    _rcActual.bottom = dwMoreProgBottomEdge + _spm.panes[SMPANETYPE_LOGOFF].size.cy;

    HDWP hdwp = BeginDeferWindowPos(5);
    const DWORD dwSWPFlags = SWP_NOACTIVATE | SWP_NOZORDER;
    DeferWindowPos(hdwp, _spm.panes[SMPANETYPE_USER].hwnd, NULL,    0, 0, _rcActual.right, dwUserBottomEdge, dwSWPFlags);
    DeferWindowPos(hdwp, _spm.panes[SMPANETYPE_MFU].hwnd, NULL,     0, dwUserBottomEdge, dwMFURightEdge, iMFUHeight, dwSWPFlags);
    DeferWindowPos(hdwp, _spm.panes[SMPANETYPE_MOREPROG].hwnd, NULL,0, dwMFUBottomEdge, dwMFURightEdge, iMoreProgHeight, dwSWPFlags);
    DeferWindowPos(hdwp, _spm.panes[SMPANETYPE_PLACES].hwnd, NULL,  dwMFURightEdge, dwUserBottomEdge, _rcActual.right-dwMFURightEdge, iPlacesHeight, dwSWPFlags);
    DeferWindowPos(hdwp, _spm.panes[SMPANETYPE_LOGOFF].hwnd, NULL,  0, dwMoreProgBottomEdge, _rcActual.right, _spm.panes[SMPANETYPE_LOGOFF].size.cy, dwSWPFlags);
    EndDeferWindowPos(hdwp);
}

HWND CDesktopHost::_Create()
{
    TCHAR szTitle[MAX_PATH];

    LoadString(hinstCabinet, IDS_STARTMENU, szTitle, MAX_PATH);

    Register();

    // Must load metrics early to determine whether we are themed or not
    LoadPanelMetrics();

    DWORD dwExStyle = WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
    if (IS_BIDI_LOCALIZED_SYSTEM())
    {
        dwExStyle |= WS_EX_LAYOUTRTL;
    }

    DWORD dwStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;  // We will make it visible as part of animation
    if (!_hTheme)
    {
        // Normally the theme provides the border effects, but if there is
        // no theme then we have to do it ourselves.
        dwStyle |= WS_DLGFRAME;
    }

    _hwnd = CreateWindowEx(
        dwExStyle,
        WC_DV2,
        szTitle,
        dwStyle,
        0, 0,
        0, 0,
        v_hwndTray,
        NULL,
        hinstCabinet,
        this);

    v_hwndStartPane = _hwnd;

    return _hwnd;
}

void CDesktopHost::_ReapplyRegion()
{
    SMNMAPPLYREGION ar;

    // If we fail to create a rectangular region, then remove the region
    // entirely so we don't carry the old (bad) region around.
    // Yes it means you get ugly black corners, but it's better than
    // clipping away huge chunks of the Start Menu!

    ar.hrgn = CreateRectRgn(0, 0, _sizWindowPrev.cx, _sizWindowPrev.cy);
    if (ar.hrgn)
    {
        // Let all the clients take a bite out of it
        ar.hdr.hwndFrom = _hwnd;
        ar.hdr.idFrom = 0;
        ar.hdr.code = SMN_APPLYREGION;

        SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&ar, SPM_SEND | SPM_ONELEVEL);
    }

    if (!SetWindowRgn(_hwnd, ar.hrgn, FALSE))
    {
        // SetWindowRgn takes ownership on success
        // On failure we need to free it ourselves
        if (ar.hrgn)
        {
            DeleteObject(ar.hrgn);
        }
    }
}


//
//  We need to use PrintWindow because WM_PRINT messes up RTL.
//  PrintWindow requires that the window be visible.
//  Making the window visible causes the shadow to appear.
//  We don't want the shadow to appear until we are ready.
//  So we have to do a lot of goofy style mangling to suppress the
//  shadow until we're ready.
//
BOOL ShowCachedWindow(HWND hwnd, SIZE sizWindow, HBITMAP hbmpSnapshot, BOOL fRepaint)
{
    BOOL fSuccess = FALSE;
    if (hbmpSnapshot)
    {
        // Turn off the shadow so it won't get triggered by our SetWindowPos
        DWORD dwClassStylePrev = GetClassLong(hwnd, GCL_STYLE);
        SetClassLong(hwnd, GCL_STYLE, dwClassStylePrev & ~CS_DROPSHADOW);

        // Show the window and tell it not to repaint; we'll do that
        SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER |
                     SWP_NOREDRAW | SWP_SHOWWINDOW);

        // Turn the shadow back on
        SetClassLong(hwnd, GCL_STYLE, dwClassStylePrev);

        // Disable WS_CLIPCHILDREN because we need to draw over the kids for our BLT
        DWORD dwStylePrev = SHSetWindowBits(hwnd, GWL_STYLE, WS_CLIPCHILDREN, 0);

        HDC hdcWindow = GetDCEx(hwnd, NULL, DCX_WINDOW | DCX_CACHE);
        if (hdcWindow)
        {
            HDC hdcMem = CreateCompatibleDC(hdcWindow);
            if (hdcMem)
            {
                HBITMAP hbmPrev = (HBITMAP)SelectObject(hdcMem, hbmpSnapshot);

                // PrintWindow only if fRepaint says it's necessary
                if (!fRepaint || PrintWindow(hwnd, hdcMem, 0))
                {
                    // Do this horrible dance because sometimes GDI takes a long
                    // time to do a BitBlt so you end up seeing the shadow for
                    // a half second before the bits show up.
                    //
                    // So show the bits first, then show the shadow.

                    if (BitBlt(hdcWindow, 0, 0, sizWindow.cx, sizWindow.cy, hdcMem, 0, 0, SRCCOPY))
                    {
                        // Tell USER to attach the shadow
                        // Do this by hiding the window and then showing it
                        // again, but do it in this goofy way to avoid flicker.
                        // (If we used ShowWindow(SW_HIDE), then the window
                        // underneath us would repaint pointlessly.)

                        SHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
                        SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
                                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER |
                                     SWP_NOREDRAW | SWP_SHOWWINDOW);

                        // Validate the window now that we've drawn it
                        RedrawWindow(hwnd, NULL, NULL, RDW_NOERASE | RDW_NOFRAME |
                                     RDW_NOINTERNALPAINT | RDW_VALIDATE);
                        fSuccess = TRUE;
                    }
                }

                SelectObject(hdcMem, hbmPrev);
                DeleteDC(hdcMem);
            }
            ReleaseDC(hwnd, hdcWindow);
        }

        SetWindowLong(hwnd, GWL_STYLE, dwStylePrev);
    }

    if (!fSuccess)
    {
        // re-hide the window so USER knows it's all invalid again
        ShowWindow(hwnd, SW_HIDE);
    }
    return fSuccess;
}




BOOL CDesktopHost::_TryShowBuffered()
{
    BOOL fSuccess = FALSE;
    BOOL fRepaint = FALSE;

    if (!_hbmCachedSnapshot)
    {
        HDC hdcWindow = GetDCEx(_hwnd, NULL, DCX_WINDOW | DCX_CACHE);
        if (hdcWindow)
        {
            _hbmCachedSnapshot = CreateCompatibleBitmap(hdcWindow, _sizWindowPrev.cx, _sizWindowPrev.cy);
            fRepaint = TRUE;
            ReleaseDC(_hwnd, hdcWindow);
        }
    }
    if (_hbmCachedSnapshot)
    {
        fSuccess = ShowCachedWindow(_hwnd, _sizWindowPrev, _hbmCachedSnapshot, fRepaint);
        if (!fSuccess)
        {
            DeleteObject(_hbmCachedSnapshot);
            _hbmCachedSnapshot = NULL;
        }
    }
    return fSuccess;
}

LRESULT CDesktopHost::OnNeedRepaint()
{
    if (_hwnd && _hbmCachedSnapshot)
    {
        // This will force a repaint the next time the window is shown
        DeleteObject(_hbmCachedSnapshot);
        _hbmCachedSnapshot = NULL;
    }
    return 0;
}

HRESULT CDesktopHost::_Popup(POINT *ppt, RECT *prcExclude, DWORD dwFlags)
{
    if (_hwnd)
    {
        RECT rcWindow;
        _ChoosePopupPosition(ppt, prcExclude, &rcWindow);
        SIZE sizWindow = { RECTWIDTH(rcWindow), RECTHEIGHT(rcWindow) };

        MoveWindow(_hwnd, rcWindow.left, rcWindow.top,
                          sizWindow.cx, sizWindow.cy, TRUE);

        if (sizWindow.cx != _sizWindowPrev.cx ||
            sizWindow.cy != _sizWindowPrev.cy)
        {
            _sizWindowPrev = sizWindow;
            _ReapplyRegion();
            // We need to repaint since our size has changed
            OnNeedRepaint();
        }

        // If the user toggles the tray between topmost and nontopmost
        // our own topmostness can get messed up, so re-assert it here.
        SetWindowZorder(_hwnd, HWND_TOPMOST);

        if (GetSystemMetrics(SM_REMOTESESSION))
        {
            // If running remotely, then don't cache the Start Menu
            // or double-buffer.  Show the keyboard cues accurately
            // from the start (to avoid flicker).

            SendMessage(_hwnd, WM_CHANGEUISTATE, UIS_INITIALIZE, 0);
            if (dwFlags & MPPF_KEYBOARD)
            {
                _EnableKeyboardCues();
            }
            ShowWindow(_hwnd, SW_SHOW);
        }
        else
        {
            // If running locally, then force keyboard cues off so our
            // cached bitmap won't have underlines.  Then draw the
            // Start Menu, then turn on keyboard cues if necessary.

            SendMessage(_hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);

            if (!_TryShowBuffered())
            {
                ShowWindow(_hwnd, SW_SHOW);
            }

            NotifyWinEvent(EVENT_SYSTEM_MENUPOPUPSTART, _hwnd, OBJID_CLIENT, CHILDID_SELF);

            if (dwFlags & MPPF_KEYBOARD)
            {
                _EnableKeyboardCues();
            }
        }

        // Tell tray that the start pane is active, so it knows to eat
        // mouse clicks on the Start Button.
        Tray_SetStartPaneActive(TRUE);

        _fOpen = TRUE;
        _fMenuBlocked = FALSE;
        _fMouseEntered = FALSE;
        _fOfferedNewApps = FALSE;

        _MaybeOfferNewApps();
        _MaybeShowClipBalloon();

        // Tell all our child windows it's time to maybe revalidate
        NMHDR nm = { _hwnd, 0, SMN_POSTPOPUP };
        SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nm, SPM_SEND | SPM_ONELEVEL);

        ExplorerPlaySound(TEXT("MenuPopup"));


        return S_OK;
    }
    else
    {
        return E_FAIL;
    }
}

HRESULT CDesktopHost::Popup(POINTL *pptl, RECTL *prclExclude, DWORD dwFlags)
{
    COMPILETIME_ASSERT(sizeof(POINTL) == sizeof(POINT));
    POINT *ppt = reinterpret_cast<POINT*>(pptl);

    COMPILETIME_ASSERT(sizeof(RECTL) == sizeof(RECT));
    RECT *prcExclude = reinterpret_cast<RECT*>(prclExclude);

    if (_hwnd == NULL)
    {
        _hwnd = _Create();
    }

    return _Popup(ppt, prcExclude, dwFlags);
}

LRESULT CDesktopHost::OnHaveNewItems(NMHDR *pnm)
{
    PSMNMHAVENEWITEMS phni = (PSMNMHAVENEWITEMS)pnm;

    _hwndNewHandler = pnm->hwndFrom;

    // We have a new "new app" list, so tell the cached Programs menu
    // its cache is no longer valid and it should re-query us
    // so we can color the new apps appropriately.

    if (_ppmPrograms)
    {
        _ppmPrograms->Invalidate();
    }

    //
    //  Were any apps in the list installed since the last time the
    //  user acknowledged a new app?
    //

    FILETIME ftBalloon = { 0, 0 };      // assume never
    DWORD dwSize = sizeof(ftBalloon);

    SHRegGetUSValue(DV2_REGPATH, DV2_NEWAPP_BALLOON_TIME, NULL,
                    &ftBalloon, &dwSize, FALSE, NULL, 0);

    if (CompareFileTime(&ftBalloon, &phni->ftNewestApp) < 0)
    {
        _iOfferNewApps = NEWAPP_OFFER_COUNT;
        _MaybeOfferNewApps();
    }

    return 1;
}

void CDesktopHost::_MaybeOfferNewApps()
{
    // Display the balloon tip only once per pop-open,
    // and only if there are new apps to offer
    // and only if we're actually visible
    if (_fOfferedNewApps || !_iOfferNewApps || !IsWindowVisible(_hwnd) || 
        !SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_DV2_NOTIFYNEW, FALSE, TRUE))
    {
        return;
    }

    _fOfferedNewApps = TRUE;
    _iOfferNewApps--;

    SMNMBOOL nmb = { { _hwnd, 0, SMN_SHOWNEWAPPSTIP }, TRUE };
    SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nmb, SPM_SEND | SPM_ONELEVEL);
}

void CDesktopHost::OnSeenNewItems()
{
    _iOfferNewApps = 0; // Do not offer More Programs balloon tip again

    // Remember the time the user acknowledged the balloon so we only
    // offer the balloon if there is an app installed after this point.

    FILETIME ftNow;
    GetSystemTimeAsFileTime(&ftNow);
    SHRegSetUSValue(DV2_REGPATH, DV2_NEWAPP_BALLOON_TIME, REG_BINARY,
                    &ftNow, sizeof(ftNow), SHREGSET_FORCE_HKCU);
}


void CDesktopHost::_MaybeShowClipBalloon()
{
    if (_fClipped && !_fWarnedClipped)
    {
        _fWarnedClipped = TRUE;

        RECT rc;
        GetWindowRect(_spm.panes[SMPANETYPE_MFU].hwnd, &rc);    // show the clipped ballon pointing to the bottom of the MFU

        _hwndClipBalloon = CreateBalloonTip(_hwnd,
                                            (rc.right+rc.left)/2, rc.bottom,
                                            NULL,
                                            IDS_STARTPANE_CLIPPED_TITLE,
                                            IDS_STARTPANE_CLIPPED_TEXT);
        if (_hwndClipBalloon)
        {
            SetProp(_hwndClipBalloon, PROP_DV2_BALLOONTIP, DV2_BALLOONTIP_CLIP);
        }
    }
}

void CDesktopHost::OnContextMenu(LPARAM lParam)
{
    if (!IsRestrictedOrUserSetting(HKEY_CURRENT_USER, REST_NOTRAYCONTEXTMENU, TEXT("Advanced"), TEXT("TaskbarContextMenu"), ROUS_KEYALLOWS | ROUS_DEFAULTALLOW))
    {
        HMENU hmenu = SHLoadMenuPopup(hinstCabinet, MENU_STARTPANECONTEXT);
        if (hmenu)
        {
            POINT pt;
            if (IS_WM_CONTEXTMENU_KEYBOARD(lParam))
            {
                pt.x = pt.y = 0;
                MapWindowPoints(_hwnd, HWND_DESKTOP, &pt, 1);
            }
            else
            {
                pt.x = GET_X_LPARAM(lParam);
                pt.y = GET_Y_LPARAM(lParam);
            }

            int idCmd = TrackPopupMenuEx(hmenu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
                                         pt.x, pt.y, _hwnd, NULL);
            if (idCmd == IDSYSPOPUP_STARTMENUPROP)
            {
                DesktopHost_Dismiss(_hwnd);
                Tray_DoProperties(TPF_STARTMENUPAGE);
            }
            DestroyMenu(hmenu);
        }
    }
}

BOOL CDesktopHost::_ShouldIgnoreFocusChange(HWND hwndFocusRecipient)
{
    // Ignore focus changes when a popup menu is up
    if (_ppmTracking)
    {
        return TRUE;
    }

    // If a focus change from a special balloon, this means that the
    // user is clicking a tooltip.  So dismiss the ballon and not the Start Menu.
    HANDLE hProp = GetProp(hwndFocusRecipient, PROP_DV2_BALLOONTIP);
    if (hProp)
    {
        SendMessage(hwndFocusRecipient, TTM_POP, 0, 0);
        if (hProp == DV2_BALLOONTIP_MOREPROG)
        {
            OnSeenNewItems();
        }
        return TRUE;
    }

    // Otherwise, dismiss ourselves
    return FALSE;

}

HRESULT CDesktopHost::TranslatePopupMenuMessage(MSG *pmsg, LRESULT *plres)
{
    BOOL fDismissOnlyPopup = FALSE;

    // If the user drags an item off of a popup menu, the popup menu
    // will autodismiss itself.  If the user is over our window, then
    // we only want it to dismiss up to our level.

    // (under low memory conditions, _wmDragCancel might be WM_NULL)
    if (pmsg->message == _wmDragCancel && pmsg->message != WM_NULL)
    {
        RECT rc;
        POINT pt;
        if (GetWindowRect(_hwnd, &rc) &&
            GetCursorPos(&pt) &&
            PtInRect(&rc, pt))
        {
            fDismissOnlyPopup = TRUE;
        }
    }

    if (fDismissOnlyPopup)
        _fDismissOnlyPopup++;

    HRESULT hr = _ppmTracking->TranslateMenuMessage(pmsg, plres);

    if (fDismissOnlyPopup)
        _fDismissOnlyPopup--;

    return hr;
}

LRESULT CALLBACK CDesktopHost::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CDesktopHost *pdh = (CDesktopHost *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    LPCREATESTRUCT pcs;

    if (pdh && pdh->_ppmTracking)
    {
        MSG msg = { hwnd, uMsg, wParam, lParam };
        LRESULT lres;
        if (pdh->TranslatePopupMenuMessage(&msg, &lres) == S_OK)
        {
            return lres;
        }
        wParam = msg.wParam;
        lParam = msg.lParam;
    }

    switch(uMsg)
    {
    case WM_NCCREATE:
        pcs = (LPCREATESTRUCT)lParam;
        pdh = (CDesktopHost *)pcs->lpCreateParams;
        SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pdh);
        break;
        
    case WM_CREATE:
        pdh->OnCreate(hwnd);
        break;

    case WM_ACTIVATEAPP:
        if (!wParam)
        {
            DesktopHost_Dismiss(hwnd);
        }
        break;

    case WM_ACTIVATE:
        if (pdh)
        {
            if (LOWORD(wParam) == WA_INACTIVE)
            {
                pdh->_SaveChildFocus();
                HWND hwndAncestor = GetAncestor((HWND) lParam, GA_ROOTOWNER);
                if (hwnd != hwndAncestor &&
                    !(hwndAncestor == v_hwndTray && pdh->_ShouldIgnoreFocusChange((HWND)lParam)) &&
                    !pdh->_ppmTracking)
                    // Losing focus to somebody unrelated to us = dismiss
                {
#ifdef FULL_DEBUG
                    if (! (GetAsyncKeyState(VK_SHIFT) <0) )
#endif
                        DesktopHost_Dismiss(hwnd);
                }
            }
            else
            {
                pdh->_RestoreChildFocus();
            }
        }
        break;
        
    case WM_DESTROY:
        pdh->OnDestroy();
        break;
        
    case WM_SHOWWINDOW:
        /*
         *  If hiding the window, save the focus for restoration later.
         */
        if (!wParam)
        {
            pdh->_SaveChildFocus();
        }
        break;

    case WM_SETFOCUS:
        pdh->OnSetFocus((HWND)wParam);
        break;

    case WM_ERASEBKGND:
        pdh->OnPaint((HDC)wParam, TRUE);
        return TRUE;

#if 0
    // currently, the host doesn't do anything on WM_PAINT
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC         hdc;

            if(hdc = BeginPaint(hwnd, &ps))
            {
                pdh->OnPaint(hdc, FALSE);
                EndPaint(hwnd, &ps);
            }
        }

        break;
#endif

    case WM_NOTIFY:
        {
            LPNMHDR pnm = (LPNMHDR)lParam;
            switch (pnm->code)
            {
            case SMN_HAVENEWITEMS:
                return pdh->OnHaveNewItems(pnm);
            case SMN_COMMANDINVOKED:
                return pdh->OnCommandInvoked(pnm);
            case SMN_FILTEROPTIONS:
                return pdh->OnFilterOptions(pnm);

            case SMN_NEEDREPAINT:
                return pdh->OnNeedRepaint();

            case SMN_TRACKSHELLMENU:
                pdh->OnTrackShellMenu(pnm);
                return 0;

            case SMN_BLOCKMENUMODE:
                pdh->_fMenuBlocked = ((SMNMBOOL*)pnm)->f;
                break;
            case SMN_SEENNEWITEMS:
                pdh->OnSeenNewItems();
                break;

            case SMN_CANCELSHELLMENU:
                pdh->_DismissTrackShellMenu();
                break;
            }
        }
        break;

    case WM_CONTEXTMENU:
        pdh->OnContextMenu(lParam);
        return 0;                   // do not bubble up

    case WM_SETTINGCHANGE:
        if ((wParam == SPI_ICONVERTICALSPACING) ||
            ((wParam == 0) && (lParam != 0) && (StrCmpIC((LPCTSTR)lParam, TEXT("Policy")) == 0)))
        {
            // A change in icon vertical spacing is how the themes control
            // panel tells us that it changed the Large Icons setting (!)
            ::PostMessage(v_hwndTray, SBM_REBUILDMENU, 0, 0);
        }

        // Toss our cached bitmap because the user may have changed something
        // that affects our appearance (e.g., toggled keyboard cues)
        pdh->OnNeedRepaint();

        SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL); // forward to kids
        break;


    case WM_DISPLAYCHANGE:
    case WM_SYSCOLORCHANGE:
        // Toss our cached bitmap because these settings may affect our
        // appearance (e.g., color changes)
        pdh->OnNeedRepaint();

        SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL); // forward to kids
        break;

    case WM_TIMER:
        switch (wParam)
        {
        case IDT_MENUCHANGESEL:
            pdh->_OnMenuChangeSel();
            return 0;
        }
        break;

    case DHM_DISMISS:
        pdh->_OnDismiss((BOOL)wParam);
        break;

    // Alt+F4 dismisses the window, but doesn't destroy it
    case WM_CLOSE:
        pdh->_OnDismiss(FALSE);
        return 0;

    case WM_SYSCOMMAND:
        switch (wParam & ~0xF) // must ignore bottom 4 bits
        {
        case SC_SCREENSAVE:
            DesktopHost_Dismiss(hwnd);
            break;
        }
        break;

    }
    
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

//
//  If the user executes something or cancels out, we dismiss ourselves.
//
HRESULT CDesktopHost::OnSelect(DWORD dwSelectType)
{
    HRESULT hr = E_NOTIMPL;

    switch (dwSelectType)
    {
    case MPOS_EXECUTE:
    case MPOS_CANCELLEVEL:
        _DismissMenuPopup();
        hr = S_OK;
        break;

    case MPOS_FULLCANCEL:
        if (!_fDismissOnlyPopup)
        {
            _DismissMenuPopup();
        }
        // Don't _CleanupTrackShellMenu yet; wait for
        // _smTracking.IsMenuMessage() to return E_FAIL
        // because it might have some modal UI up
        hr = S_OK;
        break;

    case MPOS_SELECTLEFT:
        _DismissTrackShellMenu();
        hr = S_OK;
        break;
    }
    return hr;
}

void CDesktopHost::_DismissTrackShellMenu()
{
    if (_ppmTracking)
    {
        _fDismissOnlyPopup++;
        _ppmTracking->OnSelect(MPOS_FULLCANCEL);
        _fDismissOnlyPopup--;
    }
}

void CDesktopHost::_CleanupTrackShellMenu()
{
    ATOMICRELEASE(_ppmTracking);
    _hwndTracking = NULL;
    _hwndAltTracking = NULL;
    KillTimer(_hwnd, IDT_MENUCHANGESEL);

    NMHDR nm = { _hwnd, 0, SMN_SHELLMENUDISMISSED };
    SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nm, SPM_SEND | SPM_ONELEVEL);
}

void CDesktopHost::_DismissMenuPopup()
{
    DesktopHost_Dismiss(_hwnd);
}

//
//  The PMs want custom keyboard navigation behavior on the Start Panel,
//  so we have to do it all manually.
//
BOOL CDesktopHost::_IsDialogMessage(MSG *pmsg)
{
    //
    //  If this is a keyboard message or a mouse click, then remove the
    //  Start Menu lock.
    if ((pmsg->message >= WM_KEYFIRST && pmsg->message <= WM_KEYLAST) ||
        pmsg->message == WM_LBUTTONDOWN ||
        pmsg->message == WM_RBUTTONDOWN)
    {
        Tray_UnlockStartPane();
    }

    //
    //  If the menu isn't even open or if menu mode is blocked, then
    //  do not mess with the message.
    //
    if (!_fOpen || _fMenuBlocked) {
        return FALSE;
    }

    //
    //  Tapping the ALT key dismisses menus.
    //
    if (pmsg->message == WM_SYSKEYDOWN && pmsg->wParam == VK_MENU)
    {
        DesktopHost_Dismiss(_hwnd);
        // For accessibility purposes, dismissing the
        // Start Menu should place focus on the Start Button.
        SetFocus(c_tray._hwndStart);
        return TRUE;
    }

    if (SHIsChildOrSelf(_hwnd, pmsg->hwnd) != S_OK) {
        //
        //  If this is an uncaptured mouse move message, then eat it.
        //  That's what menus do -- they eat mouse moves.
        //  Let clicks go through, however, so the user
        //  can click away to dismiss the menu and activate
        //  whatever they clicked on.
        if (!GetCapture() && pmsg->message == WM_MOUSEMOVE) {
            return TRUE;
        }

        return FALSE;
    }

    //
    // Destination window must be a grandchild of us.  The child is the
    // host control; the grandchild is the real control.  Note also that
    // we do not attempt to modify the behavior of great-grandchildren,
    // because that would mess up inplace editing (which creates an
    // edit control as a child of the listview).

    HWND hwndTarget = GetParent(pmsg->hwnd);
    if (hwndTarget != NULL && GetParent(hwndTarget) != _hwnd)
    {
        hwndTarget = NULL;
    }

    //
    //  Intercept mouse messages so we can do mouse hot tracking goo.
    //  (But not if a client has blocked menu mode because it has gone
    //  into some modal state.)
    //
    switch (pmsg->message) {
    case WM_MOUSEMOVE:
        _FilterMouseMove(pmsg, hwndTarget);
        break;

    case WM_MOUSELEAVE:
        _FilterMouseLeave(pmsg, hwndTarget);
        break;

    case WM_MOUSEHOVER:
        _FilterMouseHover(pmsg, hwndTarget);
        break;

    }

    //
    //  Keyboard messages require a valid target.
    //
    if (hwndTarget == NULL) {
        return FALSE;
    }

    //
    //  Okay, hwndTarget is the host control that understands our
    //  wacky notification messages.
    //

    switch (pmsg->message)
    {
    case WM_KEYDOWN:
        _EnableKeyboardCues();

        switch (pmsg->wParam)
        {
        case VK_LEFT:
        case VK_RIGHT:
        case VK_UP:
        case VK_DOWN:
            return _DlgNavigateArrow(hwndTarget, pmsg);

        case VK_ESCAPE:
        case VK_CANCEL:
            DesktopHost_Dismiss(_hwnd);
            // For accessibility purposes, hitting ESC to dismiss the
            // Start Menu should place focus on the Start Button.
            SetFocus(c_tray._hwndStart);
            return TRUE;

        case VK_RETURN:
            _FindChildItem(hwndTarget, NULL, SMNDM_INVOKECURRENTITEM | SMNDM_KEYBOARD);
            return TRUE;

        // Eat space
        case VK_SPACE:
            return TRUE;

        default:
            break;
        }
        return FALSE;

    // Must dispatch there here so Tray's TranslateAccelerator won't see them
    case WM_SYSKEYDOWN:
    case WM_SYSKEYUP:
    case WM_SYSCHAR:
        DispatchMessage(pmsg);
        return TRUE;

    case WM_CHAR:
        return _DlgNavigateChar(hwndTarget, pmsg);

    }

    return FALSE;
}

LRESULT CDesktopHost::_FindChildItem(HWND hwnd, SMNDIALOGMESSAGE *pnmdm, UINT smndm)
{
    SMNDIALOGMESSAGE nmdm;
    if (!pnmdm)
    {
        pnmdm = &nmdm;
    }

    pnmdm->hdr.hwndFrom = _hwnd;
    pnmdm->hdr.idFrom = 0;
    pnmdm->hdr.code = SMN_FINDITEM;
    pnmdm->flags = smndm;

    LRESULT lres = ::SendMessage(hwnd, WM_NOTIFY, 0, (LPARAM)pnmdm);

    if (lres && (smndm & SMNDM_SELECT))
    {
        SetFocus(::GetWindow(hwnd, GW_CHILD));
    }

    return lres;
}

void CDesktopHost::_EnableKeyboardCues()
{
    SendMessage(_hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);
}


//
//  _DlgFindItem does the grunt work of walking the group/tab order
//  looking for an item.
//
//  hwndStart = window after which to start searching
//  pnmdm = structure to receive results
//  smndm = flags for _FindChildItem call
//  GetNextDlgItem = GetNextDlgTabItem or GetNextDlgGroupItem
//  fl = flags (DFI_*)
//
//  DFI_INCLUDESTARTLAST:  Include hwndStart at the end of the search.
//                         Otherwise do not search in hwndStart.
//
//  Returns the found window, or NULL.
//

#define DFI_FORWARDS            0x0000
#define DFI_BACKWARDS           0x0001

#define DFI_INCLUDESTARTLAST    0x0002

HWND CDesktopHost::_DlgFindItem(
    HWND hwndStart, SMNDIALOGMESSAGE *pnmdm, UINT smndm,
    GETNEXTDLGITEM GetNextDlgItem, UINT fl)
{
    HWND hwndT = hwndStart;
    int iLoopCount = 0;

    while ((hwndT = GetNextDlgItem(_hwnd, hwndT, fl & DFI_BACKWARDS)) != NULL)
    {
        if (!(fl & DFI_INCLUDESTARTLAST) && hwndT == hwndStart)
        {
            return NULL;
        }

        if (_FindChildItem(hwndT, pnmdm, smndm))
        {
            return hwndT;
        }

        if (hwndT == hwndStart)
        {
            ASSERT(fl & DFI_INCLUDESTARTLAST);
            return NULL;
        }

        if (++iLoopCount > 10)
        {
            // If this assert fires, it means that the controls aren't
            // playing nice with WS_TABSTOP and WS_GROUP and we got stuck.
            ASSERT(iLoopCount < 10);
            return NULL;
        }

    }
    return NULL;
}

BOOL CDesktopHost::_DlgNavigateArrow(HWND hwndStart, MSG *pmsg)
{
    HWND hwndT;
    SMNDIALOGMESSAGE nmdm;
    MSG msg;
    nmdm.pmsg = pmsg;   // other fields will be filled in by _FindChildItem

    TraceMsg(TF_DV2DIALOG, "idm.arrow(%04x)", pmsg->wParam);

    // If RTL, then flip the left and right arrows
    UINT vk = (UINT)pmsg->wParam;
    BOOL fRTL = GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL;
    if (fRTL)
    {
        if (vk == VK_LEFT) vk = VK_RIGHT;
        else if (vk == VK_RIGHT) vk = VK_LEFT;
        // Put the flipped arrows into the MSG structure so clients don't
        // have to know anything about RTL.
        msg = *pmsg;
        nmdm.pmsg = &msg;
        msg.wParam = vk;
    }
    BOOL fBackwards = vk == VK_LEFT || vk == VK_UP;
    BOOL fVerticalKey = vk == VK_UP || vk == VK_DOWN;


    //
    //  First see if the navigation can be handled by the control natively.
    //  We have to let the control get first crack because it might want to
    //  override default behavior (e.g., open a menu when VK_RIGHT is pressed
    //  instead of moving to the right).
    //

    //
    //  Holding the shift key while hitting the Right [RTL:Left] arrow
    //  suppresses the attempt to cascade.
    //

    DWORD dwTryCascade = 0;
    if (vk == VK_RIGHT && GetKeyState(VK_SHIFT) >= 0)
    {
        dwTryCascade |= SMNDM_TRYCASCADE;
    }

    if (_FindChildItem(hwndStart, &nmdm, dwTryCascade | SMNDM_FINDNEXTARROW | SMNDM_SELECT | SMNDM_KEYBOARD))
    {
        // That was easy
        return TRUE;
    }

    //
    //  If the arrow key is in alignment with the control's orientation,
    //  then walk through the other controls in the group until we find
    //  one that contains an item, or until we loop back.
    //

    ASSERT(nmdm.flags & (SMNDM_VERTICAL | SMNDM_HORIZONTAL));

    // Save this because subsequent callbacks will wipe it out.
    DWORD dwDirection = nmdm.flags;

    //
    //  Up/Down arrow always do prev/next.  Left/right arrow will
    //  work if we are in a horizontal control.
    //
    if (fVerticalKey || (dwDirection & SMNDM_HORIZONTAL))
    {
        // Search for next/prev control in group.

        UINT smndm = fBackwards ? SMNDM_FINDLAST : SMNDM_FINDFIRST;
        UINT fl = fBackwards ? DFI_BACKWARDS : DFI_FORWARDS;

        hwndT = _DlgFindItem(hwndStart, &nmdm,
                             smndm | SMNDM_SELECT | SMNDM_KEYBOARD,
                             GetNextDlgGroupItem,
                             fl | DFI_INCLUDESTARTLAST);

        // Always return TRUE to eat the message
        return TRUE;
    }

    //
    //  Navigate to next column or row.  Look for controls that intersect
    //  the x (or y) coordinate of the current item and ask them to select
    //  the nearest available item.
    //
    //  Note that in this loop we do not want to let the starting point
    //  try again because it already told us that the navigation key was
    //  trying to leave the starting point.
    //

    //
    //  Note: For RTL compatibility, we must map rectangles.
    //
    RECT rcSrc = { nmdm.pt.x, nmdm.pt.y, nmdm.pt.x, nmdm.pt.y };
    MapWindowRect(hwndStart, HWND_DESKTOP, &rcSrc);
    hwndT = hwndStart;

    while ((hwndT = GetNextDlgGroupItem(_hwnd, hwndT, fBackwards)) != NULL &&
           hwndT != hwndStart)
    {
        // Does this window intersect in the desired direction?
        RECT rcT;
        BOOL fIntersect;

        GetWindowRect(hwndT, &rcT);
        if (dwDirection & SMNDM_VERTICAL)
        {
            rcSrc.left = rcSrc.right = fRTL ? rcT.right : rcT.left;
            fIntersect = rcSrc.top >= rcT.top && rcSrc.top < rcT.bottom;
        }
        else
        {
            rcSrc.top = rcSrc.bottom = rcT.top;
            fIntersect = rcSrc.left >= rcT.left && rcSrc.left < rcT.right;
        }

        if (fIntersect)
        {
            rcT = rcSrc;
            MapWindowRect(HWND_DESKTOP, hwndT, &rcT);
            nmdm.pt.x = rcT.left;
            nmdm.pt.y = rcT.top;
            if (_FindChildItem(hwndT, &nmdm,
                               SMNDM_FINDNEAREST | SMNDM_SELECT | SMNDM_KEYBOARD))
            {
                return TRUE;
            }
        }
    }

    // Always return TRUE to eat the message
    return TRUE;
}

//
// Find the next/prev tabstop and tell it to select its first item.
// Keep doing this until we run out of controls or we find a control
// that is nonempty.
//

HWND CDesktopHost::_FindNextDlgChar(HWND hwndStart, SMNDIALOGMESSAGE *pnmdm, UINT smndm)
{
    //
    //  See if there is a match in the hwndStart control.
    //
    if (_FindChildItem(hwndStart, pnmdm, SMNDM_FINDNEXTMATCH | SMNDM_KEYBOARD | smndm))
    {
        return hwndStart;
    }

    //
    //  Oh well, look for some other control, possibly wrapping back around
    //  to the start.
    //
    return _DlgFindItem(hwndStart, pnmdm,
                        SMNDM_FINDFIRSTMATCH | SMNDM_KEYBOARD | smndm,
                        GetNextDlgGroupItem,
                        DFI_FORWARDS | DFI_INCLUDESTARTLAST);

}

//
//  Find the next item that begins with the typed letter and
//  invoke it if it is unique.
//
BOOL CDesktopHost::_DlgNavigateChar(HWND hwndStart, MSG *pmsg)
{
    SMNDIALOGMESSAGE nmdm;
    nmdm.pmsg = pmsg;   // other fields will be filled in by _FindChildItem

    //
    //  See if there is a match in the hwndStart control.
    //
    HWND hwndFound = _FindNextDlgChar(hwndStart, &nmdm, SMNDM_SELECT);
    if (hwndFound)
    {
        LRESULT idFound = nmdm.itemID;

        //
        //  See if there is another match for this character.
        //  We are only looking, so don't pass SMNDM_SELECT.
        //
        HWND hwndFound2 = _FindNextDlgChar(hwndFound, &nmdm, 0);
        if (hwndFound2 == hwndFound && nmdm.itemID == idFound)
        {
            //
            //  There is only one item that begins with this character.
            //  Invoke it!
            //
            UpdateWindow(_hwnd);
            _FindChildItem(hwndFound2, &nmdm, SMNDM_INVOKECURRENTITEM | SMNDM_KEYBOARD);
        }
    }

    return TRUE;
}

void CDesktopHost::_FilterMouseMove(MSG *pmsg, HWND hwndTarget)
{

    if (!_fMouseEntered) {
        _fMouseEntered = TRUE;
        TRACKMOUSEEVENT tme;
        tme.cbSize = sizeof(tme);
        tme.dwFlags = TME_LEAVE;
        tme.hwndTrack = pmsg->hwnd;
        TrackMouseEvent(&tme);
    }

    //
    //  If the mouse is in the same place as last time, then ignore it.
    //  We can get spurious "no-motion" messages when the user is
    //  keyboard navigating.
    //
    if (_hwndLastMouse == pmsg->hwnd &&
        _lParamLastMouse == pmsg->lParam)
    {
        return;
    }

    _hwndLastMouse = pmsg->hwnd;
    _lParamLastMouse = pmsg->lParam;

    //
    //  See if the target window can hit-test this item successfully.
    //
    LRESULT lres;
    if (hwndTarget)
    {
        SMNDIALOGMESSAGE nmdm;
        nmdm.pt.x = GET_X_LPARAM(pmsg->lParam);
        nmdm.pt.y = GET_Y_LPARAM(pmsg->lParam);
        lres = _FindChildItem(hwndTarget, &nmdm, SMNDM_HITTEST | SMNDM_SELECT);
    }
    else
    {
        lres = 0;               // No target, so no hit-test
    }

    if (!lres)
    {
        _RemoveSelection();
    }
    else
    {
        //
        //  We selected a guy.  Turn on the hover timer so we can
        //  do the auto-open thingie.
        //
        if (_fAutoCascade)
        {
            TRACKMOUSEEVENT tme;
            tme.cbSize = sizeof(tme);
            tme.dwFlags = TME_HOVER;
            tme.hwndTrack = pmsg->hwnd;
            if (!SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &tme.dwHoverTime, 0))
            {
                tme.dwHoverTime = HOVER_DEFAULT;
            }
            TrackMouseEvent(&tme);
        }
    }

}

void CDesktopHost::_FilterMouseLeave(MSG *pmsg, HWND hwndTarget)
{
    _fMouseEntered = FALSE;
    _hwndLastMouse = NULL;

    // If we got a WM_MOUSELEAVE due to a menu popping up, don't
    // give up the focus since it really didn't leave yet.
    if (!_ppmTracking)
    {
        _RemoveSelection();
    }
}

void CDesktopHost::_FilterMouseHover(MSG *pmsg, HWND hwndTarget)
{
    _FindChildItem(hwndTarget, NULL, SMNDM_OPENCASCADE);
}

//
//  Remove the menu selection and put it in the "dead space" above
//  the first visible item.
//
void CDesktopHost::_RemoveSelection()
{
        // Put focus on first valid child control
        // The real control is the grandchild
        HWND hwndChild = GetNextDlgTabItem(_hwnd, NULL, FALSE);
        if (hwndChild)
        {
            // The inner ::GetWindow will always succeed
            // because all our controls contain inner windows
            // (and if they failed to create their inner window,
            // they would've failed their WM_CREATE message)
            HWND hwndInner = ::GetWindow(hwndChild, GW_CHILD);
            SetFocus(hwndInner);

            //
            //  Now lie to the control and make it think it lost
            //  focus.  This will cause the selection to clear.
            //
            NMHDR hdr;
            hdr.hwndFrom = hwndInner;
            hdr.idFrom = GetDlgCtrlID(hwndInner);
            hdr.code = NM_KILLFOCUS;
            ::SendMessage(hwndChild, WM_NOTIFY, hdr.idFrom, (LPARAM)&hdr);
        }
}

HRESULT CDesktopHost::IsMenuMessage(MSG *pmsg)
{
    if (_hwnd)
    {
        if (_ppmTracking)
        {
            HRESULT hr = _ppmTracking->IsMenuMessage(pmsg);
            if (hr == E_FAIL)
            {
                _CleanupTrackShellMenu();
                hr = S_FALSE;
            }
            if (hr == S_OK)
            {
                return hr;
            }
        }

        if (_IsDialogMessage(pmsg))
        {
            return S_OK;    // message handled
        }
        else
        {
            return S_FALSE; // message not handled
        }
    }
    else
    {
        return E_FAIL;      // Menu is gone
    }
}

HRESULT CDesktopHost::TranslateMenuMessage(MSG *pmsg, LRESULT *plres)
{
    if (_ppmTracking)
    {
        return _ppmTracking->TranslateMenuMessage(pmsg, plres);
    }
    return E_NOTIMPL;
}

// IServiceProvider::QueryService
STDMETHODIMP CDesktopHost::QueryService(REFGUID guidService, REFIID riid, void ** ppvObject)
{
    if(IsEqualGUID(guidService,SID_SMenuPopup))
        return QueryInterface(riid,ppvObject);

    return E_FAIL;
}

// *** IOleCommandTarget ***
STDMETHODIMP  CDesktopHost::QueryStatus (const GUID * pguidCmdGroup,
    ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
{
    return E_NOTIMPL;
}

STDMETHODIMP  CDesktopHost::Exec (const GUID * pguidCmdGroup,
    DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
    if (IsEqualGUID(CLSID_MenuBand,*pguidCmdGroup))
    {
        switch (nCmdID)
        {
        case MBANDCID_REFRESH:
            {
                // There was a session or WM_DEVICECHANGE, we need to refresh our logoff options
                NMHDR nm = { _hwnd, 0, SMN_REFRESHLOGOFF};
                SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nm, SPM_SEND | SPM_ONELEVEL);
                OnNeedRepaint();
            }
            break;
        default:
            break;
        }
    }

    return NOERROR;
}

// ITrayPriv2::ModifySMInfo
HRESULT CDesktopHost::ModifySMInfo(IN LPSMDATA psmd, IN OUT SMINFO *psminfo)
{
    if (_hwndNewHandler)
    {
        SMNMMODIFYSMINFO nmsmi;
        nmsmi.hdr.hwndFrom = _hwnd;
        nmsmi.hdr.idFrom = 0;
        nmsmi.hdr.code = SMN_MODIFYSMINFO;
        nmsmi.psmd = psmd;
        nmsmi.psminfo = psminfo;
        SendMessage(_hwndNewHandler, WM_NOTIFY, 0, (LPARAM)&nmsmi);
    }

    return S_OK;
}

BOOL CDesktopHost::AddWin32Controls()
{
    RegisterDesktopControlClasses();

    // we create the controls with an arbitrary size, since we won't know how big we are until we pop up...

    // Note that we do NOT set WS_EX_CONTROLPARENT because we want the
    // dialog manager to think that our child controls are the interesting
    // objects, not the inner grandchildren.
    //
    // Setting the control ID equal to the internal index number is just
    // for the benefit of the test automation tools.

    for (int i=0; i<ARRAYSIZE(_spm.panes); i++)
    {
        _spm.panes[i].hwnd = CreateWindowExW(0, _spm.panes[i].pszClassName,
                                            NULL,
                                            _spm.panes[i].dwStyle | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
                                            0, 0, _spm.panes[i].size.cx, _spm.panes[i].size.cy,
                                            _hwnd, IntToPtr_(HMENU, i), NULL,
                                            &_spm.panes[i]);
    }

    return TRUE;
}

void CDesktopHost::OnPaint(HDC hdc, BOOL bBackground)
{
}

void CDesktopHost::_ReadPaneSizeFromTheme(SMPANEDATA *psmpd)
{
    RECT rc;
    if (SUCCEEDED(GetThemeRect(psmpd->hTheme, psmpd->iPartId, 0, TMT_DEFAULTPANESIZE, &rc)))
    {
        // semi-hack to take care of the fact that if one the start panel parts is missing a property, 
        // themes will use the next level up (to the panel itself)
        if ((rc.bottom != _spm.sizPanel.cy) || (rc.right != _spm.sizPanel.cx))
        {
            psmpd->size.cx = RECTWIDTH(rc); 
            psmpd->size.cy = RECTHEIGHT(rc);
        }
    }
}

void RemapSizeForHighDPI(SIZE *psiz)
{
    static int iLPX, iLPY;

    if (!iLPX || !iLPY)
    {
        HDC hdc = GetDC(NULL);
        iLPX = GetDeviceCaps(hdc, LOGPIXELSX);
        iLPY = GetDeviceCaps(hdc, LOGPIXELSY);
        ReleaseDC(NULL, hdc);
    }

    // 96 DPI is small fonts, so scale based on the multiple of that.
    psiz->cx = (psiz->cx * iLPX)/96;
    psiz->cy = (psiz->cy * iLPY)/96;
}



void CDesktopHost::LoadResourceInt(UINT ids, LONG *pl)
{
    TCHAR sz[64];
    if (LoadString(hinstCabinet, ids, sz, ARRAYSIZE(sz)))
    {
        int i = StrToInt(sz);
        if (i)
        {
            *pl = i;
        }
    }
}

void CDesktopHost::LoadPanelMetrics()
{
    // initialize our copy of the panel metrics from the default...
    _spm = g_spmDefault;

    // Adjust for localization
    LoadResourceInt(IDS_STARTPANE_TOTALHEIGHT,   &_spm.sizPanel.cy);
    LoadResourceInt(IDS_STARTPANE_TOTALWIDTH,    &_spm.sizPanel.cx);
    LoadResourceInt(IDS_STARTPANE_USERHEIGHT,    &_spm.panes[SMPANETYPE_USER].size.cy);
    LoadResourceInt(IDS_STARTPANE_MOREPROGHEIGHT,&_spm.panes[SMPANETYPE_MOREPROG].size.cy);
    LoadResourceInt(IDS_STARTPANE_LOGOFFHEIGHT,  &_spm.panes[SMPANETYPE_LOGOFF].size.cy);

    // wacky raymondc logic to scale using the values in g_spmDefault as relative ratio's
    // Now apply those numbers; widths are easy
    int i;
    for (i = 0; i < ARRAYSIZE(_spm.panes); i++)
    {
        _spm.panes[i].size.cx = MulDiv(g_spmDefault.panes[i].size.cx,
                                       _spm.sizPanel.cx,
                                       g_spmDefault.sizPanel.cx);
    }

    // Places gets all height not eaten by User and Logoff
    _spm.panes[SMPANETYPE_PLACES].size.cy = _spm.sizPanel.cy
                                          - _spm.panes[SMPANETYPE_USER].size.cy
                                          - _spm.panes[SMPANETYPE_LOGOFF].size.cy;

    // MFU gets Places minus More Programs
    _spm.panes[SMPANETYPE_MFU].size.cy = _spm.panes[SMPANETYPE_PLACES].size.cy
                                       - _spm.panes[SMPANETYPE_MOREPROG].size.cy;

    // End of adjustments for localization

    // load the theme file (which shouldn't be loaded yet)
    ASSERT(!_hTheme);
    // only try to use themes if our color depth is greater than 8bpp.
    if (SHGetCurColorRes() > 8)
        _hTheme = OpenThemeData(_hwnd, STARTPANELTHEME);

    if (_hTheme)
    {
        // if we fail reading the size from the theme, it will fall back to the defaul size....

        RECT rcT;
        if (SUCCEEDED(GetThemeRect(_hTheme, 0, 0, TMT_DEFAULTPANESIZE, &rcT))) // the overall pane
        {
            _spm.sizPanel.cx = RECTWIDTH(rcT);
            _spm.sizPanel.cy = RECTHEIGHT(rcT);
            for (int i=0;i<ARRAYSIZE(_spm.panes);i++)
            {
                _spm.panes[i].hTheme = _hTheme;
                _ReadPaneSizeFromTheme(&_spm.panes[i]);
            }
        }
    }

    // ASSERT that the layout matches up somewhat...
    ASSERT(_spm.sizPanel.cx == _spm.panes[SMPANETYPE_USER].size.cx);
    ASSERT(_spm.sizPanel.cx == _spm.panes[SMPANETYPE_MFU].size.cx + _spm.panes[SMPANETYPE_PLACES].size.cx );
    ASSERT(_spm.sizPanel.cx == _spm.panes[SMPANETYPE_LOGOFF].size.cx);
    ASSERT(_spm.panes[SMPANETYPE_MOREPROG].size.cx == _spm.panes[SMPANETYPE_MFU].size.cx);
    TraceMsg(TF_DV2HOST, "sizPanel.cy = %d, user = %d, MFU =%d, moreprog=%d, logoff=%d",
        _spm.sizPanel.cy, _spm.panes[SMPANETYPE_USER].size.cy, _spm.panes[SMPANETYPE_MFU].size.cy,
        _spm.panes[SMPANETYPE_MOREPROG].size.cy, _spm.panes[SMPANETYPE_LOGOFF].size.cy);

    ASSERT(_spm.sizPanel.cy == _spm.panes[SMPANETYPE_USER].size.cy + _spm.panes[SMPANETYPE_MFU].size.cy + _spm.panes[SMPANETYPE_MOREPROG].size.cy + _spm.panes[SMPANETYPE_LOGOFF].size.cy);

    // one final pass to adjust everything for DPI
    // note that things may not match up exactly after this due to rounding, but _ComputeActualSize can deal
    RemapSizeForHighDPI(&_spm.sizPanel);
    for (int i=0;i<ARRAYSIZE(_spm.panes);i++)
    {
        RemapSizeForHighDPI(&_spm.panes[i].size);
    }

    SetRect(&_rcDesired, 0, 0, _spm.sizPanel.cx, _spm.sizPanel.cy);
}

void CDesktopHost::OnCreate(HWND hwnd)
{
    _hwnd          = hwnd;
    TraceMsg(TF_DV2HOST, "Entering CDesktopHost::OnCreate");

    // Add the controls and background images
    AddWin32Controls();
}

void CDesktopHost::OnDestroy()
{
    _hwnd = NULL;
    if (_hTheme)
    {
        CloseThemeData(_hTheme);
        _hTheme = NULL;
    }
}

void CDesktopHost::OnSetFocus(HWND hwndLose)
{
    if (!_RestoreChildFocus())
    {
        _RemoveSelection();
    }
}

LRESULT CDesktopHost::OnCommandInvoked(NMHDR *pnm)
{
    // Invoking a command indicates explicit user activity
    Tray_UnlockStartPane();

    PSMNMCOMMANDINVOKED pci = (PSMNMCOMMANDINVOKED)pnm;

    ExplorerPlaySound(TEXT("MenuCommand"));
    BOOL fFade = FALSE;
    if (SystemParametersInfo(SPI_GETSELECTIONFADE, 0, &fFade, 0) && fFade)
    {
        if (!_ptFader)
        {
            CoCreateInstance(CLSID_FadeTask, NULL, CLSCTX_INPROC, IID_PPV_ARG(IFadeTask, &_ptFader));
        }
        if (_ptFader)
        {
            _ptFader->FadeRect(&pci->rcItem);
        }
    }

    return OnSelect(MPOS_EXECUTE);
}

LRESULT CDesktopHost::OnFilterOptions(NMHDR *pnm)
{
    PSMNFILTEROPTIONS popt = (PSMNFILTEROPTIONS)pnm;

    if ((popt->smnop & SMNOP_LOGOFF) &&
        !_ShowStartMenuLogoff())
    {
        popt->smnop &= ~SMNOP_LOGOFF;
    }

    if ((popt->smnop & SMNOP_TURNOFF) &&
        !_ShowStartMenuShutdown())
    {
        popt->smnop &= ~SMNOP_TURNOFF;
    }

    if ((popt->smnop & SMNOP_DISCONNECT) &&
        !_ShowStartMenuDisconnect())
    {
        popt->smnop &= ~SMNOP_DISCONNECT;
    }

    if ((popt->smnop & SMNOP_EJECT) &&
        !_ShowStartMenuEject())
    {
        popt->smnop &= ~SMNOP_EJECT;
    }

    return 0;
}

LRESULT CDesktopHost::OnTrackShellMenu(NMHDR *pnm)
{
    // Opening a menu indicates explicit user activity
    Tray_UnlockStartPane();

    PSMNTRACKSHELLMENU ptsm = CONTAINING_RECORD(pnm, SMNTRACKSHELLMENU, hdr);
    HRESULT hr;

    _hwndTracking = ptsm->hdr.hwndFrom;
    _itemTracking = ptsm->itemID;
    _hwndAltTracking = NULL;
    _itemAltTracking = 0;

    //
    //  Decide which direction we need to pop.
    //
    DWORD dwFlags;
    if (GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
    {
        dwFlags = MPPF_LEFT;
    }
    else
    {
        dwFlags = MPPF_RIGHT;
    }

    // Don't _CleanupTrackShellMenu because that will undo some of the
    // work we've already done and make the client think that the popup
    // they requested got dismissed.

    //
    // ISSUE raymondc: actually this abandons the trackpopupmenu that
    // may already be in progress - its mouse UI gets messed up as a result.
    //
    ATOMICRELEASE(_ppmTracking);

    if (_hwndTracking == _spm.panes[SMPANETYPE_MOREPROG].hwnd)
    {
        if (_ppmPrograms && _ppmPrograms->IsSame(ptsm->psm))
        {
            // It's already in our cache, woo-hoo!
            hr = S_OK;
        }
        else
        {
            ATOMICRELEASE(_ppmPrograms);
            _SubclassTrackShellMenu(ptsm->psm);
            hr = CPopupMenu_CreateInstance(ptsm->psm, GetUnknown(), _hwnd, &_ppmPrograms);
        }

        if (SUCCEEDED(hr))
        {
            _ppmTracking = _ppmPrograms;
            _ppmTracking->AddRef();
        }
    }
    else
    {
        _SubclassTrackShellMenu(ptsm->psm);
        hr = CPopupMenu_CreateInstance(ptsm->psm, GetUnknown(), _hwnd, &_ppmTracking);
    }

    if (SUCCEEDED(hr))
    {
        hr = _ppmTracking->Popup(&ptsm->rcExclude, ptsm->dwFlags | dwFlags);
    }

    if (FAILED(hr))
    {
        // In addition to freeing any partially-allocated objects,
        // this also sends a SMN_SHELLMENUDISMISSED so the client
        // knows to remove the highlight from the item being cascaded
        _CleanupTrackShellMenu();
    }

    return 0;
}

HRESULT CDesktopHost::_MenuMouseFilter(LPSMDATA psmd, BOOL fRemove, LPMSG pmsg)
{
    HRESULT hr = S_FALSE;
    SMNDIALOGMESSAGE nmdm;

    enum {
        WHERE_IGNORE,               // ignore this message
        WHERE_OUTSIDE,              // outside the Start Menu entirely
        WHERE_DEADSPOT,             // a dead spot on the Start Menu
        WHERE_ONSELF,               // over the item that initiated the popup
        WHERE_ONOTHER,              // over some other item in the Start Menu
    } uiWhere;

    //
    //  Figure out where the mouse is.
    //
    //  Note: ChildWindowFromPointEx searches only immediate
    //  children; it does not search grandchildren. Fortunately, that's
    //  exactly what we want...
    //

    HWND hwndTarget = NULL;

    if (fRemove)
    {
        if (psmd->punk)
        {
            // Inside a menuband - mouse has left our window
            uiWhere = WHERE_OUTSIDE;
        }
        else
        {
            POINT pt = { GET_X_LPARAM(pmsg->lParam), GET_Y_LPARAM(pmsg->lParam) };
            ScreenToClient(_hwnd, &pt);

            hwndTarget = ChildWindowFromPointEx(_hwnd, pt, CWP_SKIPINVISIBLE);
            if (hwndTarget == _hwnd)
            {
                uiWhere = WHERE_DEADSPOT;
            }
            else if (hwndTarget)
            {
                LRESULT lres;
                nmdm.pt = pt;
                HWND hwndChild = ::GetWindow(hwndTarget, GW_CHILD);
                MapWindowPoints(_hwnd, hwndChild, &nmdm.pt, 1);
                lres = _FindChildItem(hwndTarget, &nmdm, SMNDM_HITTEST | SMNDM_SELECT);
                if (lres)
                {
                    // Mouse is over something; is it over the current item?

                    if (nmdm.itemID == _itemTracking &&
                        hwndTarget == _hwndTracking)
                    {
                        uiWhere = WHERE_ONSELF;
                    }
                    else
                    {
                        uiWhere = WHERE_ONOTHER;
                    }
                }
                else
                {
                    uiWhere = WHERE_DEADSPOT;
                }
            }
            else
            {
                // ChildWindowFromPoint failed - user has left the Start Menu
                uiWhere = WHERE_OUTSIDE;
            }
        }
    }
    else
    {
        // Ignore PM_NOREMOVE messages; we'll pay attention to them when
        // they are PM_REMOVE'd.
        uiWhere = WHERE_IGNORE;
    }

    //
    //  Now do appropriate stuff depending on where the mouse is.
    //
    switch (uiWhere)
    {
    case WHERE_IGNORE:
        break;

    case WHERE_OUTSIDE:
        //
        // If you've left the menu entirely, then we return the menu to
        // its original state, which is to say, as if you are hovering
        // over the item that caused the popup to open in the first place.
        // as being in a dead zone.
        //
        // FALL THROUGH
        goto L_WHERE_ONSELF_HOVER;

    case WHERE_DEADSPOT:
        // To avoid annoying flicker as the user wanders over dead spots,
        // we ignore mouse motion over them (but dismiss if they click
        // in a dead spot).
        if (pmsg->message == WM_LBUTTONDOWN ||
            pmsg->message == WM_RBUTTONDOWN)
        {
            // Must explicitly dismiss; if we let it fall through to the
            // default handler, then it will dismiss for us, causing the
            // entire Start Menu to go away instead of just the tracking
            // part.
            _DismissTrackShellMenu();
            hr = S_OK;
        }
        break;

    case WHERE_ONSELF:
        if (pmsg->message == WM_LBUTTONDOWN ||
            pmsg->message == WM_RBUTTONDOWN)
        {
            _DismissTrackShellMenu();
            hr = S_OK;
        }
        else
        {
    L_WHERE_ONSELF_HOVER:
            _hwndAltTracking = NULL;
            _itemAltTracking = 0;
            nmdm.itemID = _itemTracking;
            _FindChildItem(_hwndTracking, &nmdm, SMNDM_FINDITEMID | SMNDM_SELECT);
            KillTimer(_hwnd, IDT_MENUCHANGESEL);
        }
        break;

    case WHERE_ONOTHER:
        if (pmsg->message == WM_LBUTTONDOWN ||
            pmsg->message == WM_RBUTTONDOWN)
        {
            _DismissTrackShellMenu();
            hr = S_OK;
        }
        else if (hwndTarget == _hwndAltTracking && nmdm.itemID == _itemAltTracking)
        {
            // Don't restart the timer if the user wiggles the mouse
            // within a single item
        }
        else
        {
            _hwndAltTracking = hwndTarget;
            _itemAltTracking = nmdm.itemID;

            DWORD dwHoverTime;
            if (!SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &dwHoverTime, 0))
            {
                dwHoverTime = 0;
            }
            SetTimer(_hwnd, IDT_MENUCHANGESEL, dwHoverTime, 0);
        }
        break;
    }

    return hr;
}

void CDesktopHost::_OnMenuChangeSel()
{
    KillTimer(_hwnd, IDT_MENUCHANGESEL);
    _DismissTrackShellMenu();
}

void CDesktopHost::_SaveChildFocus()
{
    if (!_hwndChildFocus)
    {
    HWND hwndFocus = GetFocus();
        if (hwndFocus && IsChild(_hwnd, hwndFocus))
        {
            _hwndChildFocus = hwndFocus;
        }
    }
}

// Returns non-NULL if focus was successfully restored
HWND CDesktopHost::_RestoreChildFocus()
{
    HWND hwndRet = NULL;
    if (IsWindow(_hwndChildFocus))
    {
        HWND hwndT = _hwndChildFocus;
        _hwndChildFocus = NULL;
        hwndRet = SetFocus(hwndT);
    }
    return hwndRet;
}


void CDesktopHost::_DestroyClipBalloon()
{
    if (_hwndClipBalloon)
    {
        DestroyWindow(_hwndClipBalloon);
        _hwndClipBalloon = NULL;
    }
}


void CDesktopHost::_OnDismiss(BOOL bDestroy)
{
    // Break the recursion loop:  Call IMenuPopup::OnSelect only if the
    // window was previously visible.
    _fOpen = FALSE;
    if (ShowWindow(_hwnd, SW_HIDE))
    {
        if (_ppmTracking)
        {
            _ppmTracking->OnSelect(MPOS_FULLCANCEL);
        }

        OnSelect(MPOS_FULLCANCEL);

        NMHDR nm = { _hwnd, 0, SMN_DISMISS };
        SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nm, SPM_SEND | SPM_ONELEVEL);

        _DestroyClipBalloon();

        // Allow clicking on Start button to pop the menu immediately
        Tray_SetStartPaneActive(FALSE);

        // Don't try to preserve child focus across popups
        _hwndChildFocus = NULL;

        Tray_OnStartMenuDismissed();

        NotifyWinEvent(EVENT_SYSTEM_MENUPOPUPEND, _hwnd, OBJID_CLIENT, CHILDID_SELF);
    }
    if (bDestroy)
    {
        v_hwndStartPane = NULL;
        ASSERT(GetWindowThreadProcessId(_hwnd, NULL) == GetCurrentThreadId());
        DestroyWindow(_hwnd);
    }
}

HRESULT CDesktopHost::Build()
{
    HRESULT hr = S_OK;
    if (_hwnd == NULL)
    {
        _hwnd = _Create();

        if (_hwnd)
        {
            // Tell all our child windows it's time to reinitialize
            NMHDR nm = { _hwnd, 0, SMN_INITIALUPDATE };
            SHPropagateMessage(_hwnd, WM_NOTIFY, 0, (LPARAM)&nm, SPM_SEND | SPM_ONELEVEL);
        }
    }
    
    if (_hwnd == NULL)
    {
        hr = E_OUTOFMEMORY;
    }
 
    return hr;
}


//*****************************************************************
//
//  CDeskHostShellMenuCallback
//
//  Create a wrapper IShellMenuCallback that picks off mouse
//  messages.
//
class CDeskHostShellMenuCallback
    : public CUnknown
    , public IShellMenuCallback
    , public IServiceProvider
    , public CObjectWithSite
{
    friend class CDesktopHost;

public:
    // *** IUnknown ***
    STDMETHODIMP QueryInterface(REFIID riid, void** ppvObj);
    STDMETHODIMP_(ULONG) AddRef(void) { return CUnknown::AddRef(); }
    STDMETHODIMP_(ULONG) Release(void) { return CUnknown::Release(); }

    // *** IShellMenuCallback ***
    STDMETHODIMP CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam);

    // *** IObjectWithSite ***
    STDMETHODIMP SetSite(IUnknown *punkSite);

    // *** IServiceProvider ***
    STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, void ** ppvObject);

private:
    CDeskHostShellMenuCallback(CDesktopHost *pdh)
    {
        _pdh = pdh; _pdh->AddRef();
    }

    ~CDeskHostShellMenuCallback()
    {
        ATOMICRELEASE(_pdh);
        IUnknown_SetSite(_psmcPrev, NULL);
        ATOMICRELEASE(_psmcPrev);
    }

    IShellMenuCallback *_psmcPrev;
    CDesktopHost *_pdh;
};

HRESULT CDeskHostShellMenuCallback::QueryInterface(REFIID riid, void **ppvObj)
{
    static const QITAB qit[] =
    {
        QITABENT(CDeskHostShellMenuCallback, IShellMenuCallback),
        QITABENT(CDeskHostShellMenuCallback, IObjectWithSite),
        QITABENT(CDeskHostShellMenuCallback, IServiceProvider),
        { 0 },
    };

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

BOOL FeatureEnabled(LPTSTR pszFeature)
{
    return SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, pszFeature,
                        FALSE, // Don't ignore HKCU
                        FALSE); // Disable this cool feature.
}


HRESULT CDeskHostShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_MOUSEFILTER:
        if (_pdh)
            return _pdh->_MenuMouseFilter(psmd, (BOOL)wParam, (MSG*)lParam);

    case SMC_GETSFINFOTIP:
        if (!FeatureEnabled(TEXT("ShowInfoTip")))
            return E_FAIL;  // E_FAIL means don't show. S_FALSE means show default
        break;

    }

    if (_psmcPrev)
        return _psmcPrev->CallbackSM(psmd, uMsg, wParam, lParam);

    return S_FALSE;
}

HRESULT CDeskHostShellMenuCallback::SetSite(IUnknown *punkSite)
{
    CObjectWithSite::SetSite(punkSite);
    // Each time our site changes, reassert ourselves as the site of
    // the inner object so he can try a new QueryService.
    IUnknown_SetSite(_psmcPrev, this->GetUnknown());

    // If the game is over, break our backreference
    if (!punkSite)
    {
        ATOMICRELEASE(_pdh);
    }

    return S_OK;
}

HRESULT CDeskHostShellMenuCallback::QueryService(REFGUID guidService, REFIID riid, void ** ppvObject)
{
    return IUnknown_QueryService(_punkSite, guidService, riid, ppvObject);
}

void CDesktopHost::_SubclassTrackShellMenu(IShellMenu *psm)
{
    CDeskHostShellMenuCallback *psmc = new CDeskHostShellMenuCallback(this);
    if (psmc)
    {
        UINT uId, uIdAncestor;
        DWORD dwFlags;
        if (SUCCEEDED(psm->GetMenuInfo(&psmc->_psmcPrev, &uId, &uIdAncestor, &dwFlags)))
        {
            psm->Initialize(psmc, uId, uIdAncestor, dwFlags);
        }
        psmc->Release();
    }
}

STDAPI DesktopV2_Build(void *pvStartPane)
{
    HRESULT hr = E_POINTER;
    if (pvStartPane)
    {
        hr = reinterpret_cast<CDesktopHost *>(pvStartPane)->Build();
    }
    return hr;
}


STDAPI DesktopV2_Create(
    IMenuPopup **ppmp, IMenuBand **ppmb, void **ppvStartPane)
{
    *ppmp = NULL;
    *ppmb = NULL;

    HRESULT hr;
    CDesktopHost *pdh = new CDesktopHost;
    if (pdh)
    {
        *ppvStartPane = pdh;
        hr = pdh->Initialize();
        if (SUCCEEDED(hr))
        {
            hr = pdh->QueryInterface(IID_PPV_ARG(IMenuPopup, ppmp));
            if (SUCCEEDED(hr))
            {
                hr = pdh->QueryInterface(IID_PPV_ARG(IMenuBand, ppmb));
            }
        }
        pdh->GetUnknown()->Release();
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    if (FAILED(hr))
    {
        ATOMICRELEASE(*ppmp);
        ATOMICRELEASE(*ppmb);
        ppvStartPane = NULL;
    }

    return hr;
}


HBITMAP CreateMirroredBitmap( HBITMAP hbmOrig)
{
    HDC     hdc, hdcMem1, hdcMem2;
    HBITMAP hbm = NULL, hOld_bm1, hOld_bm2;
    BITMAP  bm;
    int     IncOne = 0;

    if (!hbmOrig)
        return NULL;

    if (!GetObject(hbmOrig, sizeof(BITMAP), &bm))
        return NULL;

    // Grab the screen DC
    hdc = GetDC(NULL);

    if (hdc)
    {
        hdcMem1 = CreateCompatibleDC(hdc);

        if (!hdcMem1)
        {
            ReleaseDC(NULL, hdc);
            return NULL;
        }

        hdcMem2 = CreateCompatibleDC(hdc);
        if (!hdcMem2)
        {
            DeleteDC(hdcMem1);
            ReleaseDC(NULL, hdc);
            return NULL;
        }

        hbm = CreateCompatibleBitmap(hdc, bm.bmWidth, bm.bmHeight);

        if (!hbm)
        {
            ReleaseDC(NULL, hdc);
            DeleteDC(hdcMem1);
            DeleteDC(hdcMem2);
            return NULL;
        }

        //
        // Flip the bitmap
        //
        hOld_bm1 = (HBITMAP)SelectObject(hdcMem1, hbmOrig);
        hOld_bm2 = (HBITMAP)SelectObject(hdcMem2 , hbm );

        SET_DC_RTL_MIRRORED(hdcMem2);
        BitBlt(hdcMem2, IncOne, 0, bm.bmWidth, bm.bmHeight, hdcMem1, 0, 0, SRCCOPY);

        SelectObject(hdcMem1, hOld_bm1 );
        SelectObject(hdcMem1, hOld_bm2 );

        DeleteDC(hdcMem1);
        DeleteDC(hdcMem2);

        ReleaseDC(NULL, hdc);
    }

    return hbm;
}