windows-server-2003/shell/explorer/traynot.cpp

#include "cabinet.h"
#include "trayclok.h"
#include <atlstuff.h>
#include "traynot.h"
#include "rcids.h"
#include "tray.h"
#include "util.h"
#include "shellapi.h"

#include "strsafe.h"

//
// Tray Notify Icon area implementation notes / details:
//
// - The icons are held in a toolbar with CTrayItem * on each button's lParam
//

//
// #defines for TrayNotify
//

// Internal Tray Notify Timer IDs
#define TID_DEMOTEDMENU         2
#define TID_BALLOONPOP          3
#define TID_BALLOONPOPWAIT      4
#define TID_BALLOONSHOW         5
#define TID_RUDEAPPHIDE         6               // When a fullscreen (rude) app has gone away


#define KEYBOARD_VERSION        3

#define TT_CHEVRON_INFOTIP_INTERVAL                  30000         //  30 seconds
#define TT_BALLOONPOP_INTERVAL                       50
#define TT_BALLOONPOP_INTERVAL_INCREMENT            30
#define TT_BALLOONSHOW_INTERVAL                     3000          // 3 seconds
#define TT_RUDEAPPHIDE_INTERVAL                    10000          // 10 seconds

#define TT_DEMOTEDMENU_INTERVAL                (2 * g_uDoubleClick)

#define MAX_TIP_WIDTH           300

#define MIN_INFO_TIME           10000  // 10 secs is minimum time a balloon can be up
#define MAX_INFO_TIME           60000  // 1 min is the max time it can be up


// Atleast 2 items are necessary to "demote" them under the chevron...
#define MIN_DEMOTED_ITEMS_THRESHOLD         2

#define PGMP_RECALCSIZE  200

#define BALLOON_INTERVAL_MAX                    10000
#define BALLOON_INTERVAL_MEDIUM                  3000
#define BALLOON_INTERVAL_MIN                     1000

const TCHAR CTrayNotify::c_szTrayNotify[]                   = TEXT("TrayNotifyWnd");
const WCHAR CTrayNotify::c_wzTrayNotifyTheme[]              = L"TrayNotify";
const WCHAR CTrayNotify::c_wzTrayNotifyHorizTheme[]         = L"TrayNotifyHoriz";
const WCHAR CTrayNotify::c_wzTrayNotifyVertTheme[]          = L"TrayNotifyVert";
const WCHAR CTrayNotify::c_wzTrayNotifyHorizOpenTheme[]     = L"TrayNotifyHorizOpen";
const WCHAR CTrayNotify::c_wzTrayNotifyVertOpenTheme[]      = L"TrayNotifyVertOpen";

//
// Global functions...
//
int CALLBACK DeleteDPAPtrCB(TNINFOITEM *pItem, void *pData);

int CALLBACK DeleteDPAPtrCB(TNINFOITEM *pItem, void *pData)
{
    LocalFree(pItem);
    return TRUE;
}

//
// Stub for CTrayNotify, so as to not break the COM rules of refcounting a static object
//
class ATL_NO_VTABLE CTrayNotifyStub :
    public CComObjectRootEx<CComSingleThreadModel>,
    public CComCoClass<CTrayNotifyStub, &CLSID_TrayNotify>,
    public ITrayNotify
{
public:
    CTrayNotifyStub() {};
    virtual ~CTrayNotifyStub() {};

    DECLARE_NOT_AGGREGATABLE(CTrayNotifyStub)

    BEGIN_COM_MAP(CTrayNotifyStub)
        COM_INTERFACE_ENTRY(ITrayNotify)
    END_COM_MAP()

    // *** ITrayNotify method ***
    STDMETHODIMP SetPreference(LPNOTIFYITEM pNotifyItem);
    STDMETHODIMP RegisterCallback(INotificationCB* pNotifyCB);
    STDMETHODIMP EnableAutoTray(BOOL bTraySetting);
};

//
// CTrayNotifyStub functions...
//
HRESULT CTrayNotifyStub::SetPreference(LPNOTIFYITEM pNotifyItem)
{
    return c_tray._trayNotify.SetPreference(pNotifyItem);
}

HRESULT CTrayNotifyStub::RegisterCallback(INotificationCB* pNotifyCB)
{
    return c_tray._trayNotify.RegisterCallback(pNotifyCB);
}

HRESULT CTrayNotifyStub::EnableAutoTray(BOOL bTraySetting)
{
    return c_tray._trayNotify.EnableAutoTray(bTraySetting);
}

HRESULT CTrayNotifyStub_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk)
{
    if (pUnkOuter != NULL)
        return CLASS_E_NOAGGREGATION;

    CComObject<CTrayNotifyStub> *pStub = new CComObject<CTrayNotifyStub>;
    if (pStub)
        return pStub->QueryInterface(IID_PPV_ARG(IUnknown, ppunk));
    else
        return E_OUTOFMEMORY;
}


//
// CTrayNotify Methods..
//

// IUnknown methods
STDMETHODIMP_(ULONG) CTrayNotify::AddRef()
{
    return InterlockedIncrement(&m_cRef);
}

STDMETHODIMP_(ULONG) CTrayNotify::Release()
{
    ASSERT( 0 != m_cRef );
    ULONG cRef = InterlockedDecrement(&m_cRef);
    if ( 0 == cRef )
    {
        //
        //  TODO:   gpease  27-FEB-2002
        //
        // delete this; Why is this statement missing? If on purpose, why even 
        //  bother with InterlockedXXX and even the refer counter?!?
        //
    }
    return cRef;
}

#ifdef FULL_DEBUG

void CTrayNotify::_TestNotify()
{
    // Loop thru the toolbar
    INT_PTR iCount = m_TrayItemManager.GetItemCount();
    for (int i = 0; i < iCount; i++)
    {
        TBBUTTONINFO tbbi;
        TCHAR szButtonText[MAX_PATH];

        tbbi.cbSize = sizeof(TBBUTTONINFO);
        tbbi.dwMask = TBIF_BYINDEX | TBIF_IMAGE | TBIF_TEXT | TBIF_COMMAND;
        tbbi.pszText = szButtonText;
        tbbi.cchText = ARRAYSIZE(szButtonText);

        INT_PTR j = SendMessage(_hwndToolbar, TB_GETBUTTONINFO, i, (LPARAM)&tbbi);
        if (j != -1)
        {
            TCHAR tempBuf[MAX_PATH];
            StringCchPrintf(tempBuf, ARRAYSIZE(tempBuf), TEXT("Toolbar pos i = %d ==> idCommand = %d, iImage = %d, pszText = %s"), i, tbbi.idCommand, tbbi.iImage, tbbi.pszText);

            MessageBox(NULL, tempBuf, TEXT("My Test Message"), MB_OK);
        }
    }
}

#endif  // DEBUG

void CTrayNotify::_TickleForTooltip(CNotificationItem *pni)
{
    if (pni->pszIconText == NULL || *pni->pszIconText == 0)
    {
        //
        // item hasn't set tooltip yet, tickle it by sending
        // mouse-moved notification
        //
        CTrayItem *pti = m_TrayItemManager.GetItemDataByIndex(
            m_TrayItemManager.FindItemAssociatedWithHwndUid(pni->hWnd, pni->uID));
        if (pti)
        {
            _SendNotify(pti, WM_MOUSEMOVE);
        }
    }
}

HRESULT CTrayNotify::RegisterCallback(INotificationCB* pNotifyCB)
{
    if (!_fNoTrayItemsDisplayPolicyEnabled)
    {
        ATOMICRELEASE(_pNotifyCB);
        if (pNotifyCB)
        {
            pNotifyCB->AddRef();

            // Add Current Items
            int i = 0;
            BOOL bStat = FALSE;
            do 
            {
                CNotificationItem ni;
                if (m_TrayItemManager.GetTrayItem(i++, &ni, &bStat))
                {
                    if (bStat)
                    {
                        pNotifyCB->Notify(NIM_ADD, &ni);
                        _TickleForTooltip(&ni);
                    }
                }
                else
                    break;
            } while (TRUE);

            // Add Past Items
            i = 0;
            bStat = FALSE;
            do 
            {
                CNotificationItem ni;
                if (m_TrayItemRegistry.GetTrayItem(i++, &ni, &bStat))
                {
                    if (bStat)
                        pNotifyCB->Notify(NIM_ADD, &ni);
                }
                else
                    break;
            } while (TRUE);
        }

        _pNotifyCB = pNotifyCB;
    }
    else
    {
        _pNotifyCB = NULL;
    }

    return S_OK;
}

HRESULT CTrayNotify::SetPreference(LPNOTIFYITEM pNotifyItem)
{
    // This function should NEVER be called if the NoTrayItemsDisplayPolicy is enabled...
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    ASSERT(!GetIsNoAutoTrayPolicyEnabled());

    ASSERT( pNotifyItem->dwUserPref == TNUP_AUTOMATIC   ||
            pNotifyItem->dwUserPref == TNUP_DEMOTED     ||
            pNotifyItem->dwUserPref == TNUP_PROMOTED );

    INT_PTR iItem = -1;

    if (pNotifyItem->hWnd)
    {
        iItem = m_TrayItemManager.FindItemAssociatedWithHwndUid(pNotifyItem->hWnd, pNotifyItem->uID);
        if (iItem != -1)
        {
            CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(iItem);
            if (pti && pti->dwUserPref != pNotifyItem->dwUserPref)
            {
                pti->dwUserPref = pNotifyItem->dwUserPref;
                // If the preference changes, the accumulated time must start again...
                if (pti->IsStartupIcon())
                    pti->uNumSeconds = 0;

                _PlaceItem(iItem, pti, TRAYEVENT_ONAPPLYUSERPREF);
                _Size();

                return S_OK;
            }
        }
    }
    else
    {
        if (m_TrayItemRegistry.SetPastItemPreference(pNotifyItem))
            return S_OK;
    }

    return E_INVALIDARG;
}

UINT CTrayNotify::_GetAccumulatedTime(CTrayItem * pti)
{
    // The global user event timer...
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    IUserEventTimer * pUserEventTimer = _CreateTimer(TF_ICONDEMOTE_TIMER);
    UINT uTimerElapsed = 0;
    if (pUserEventTimer)
    {
        if (SUCCEEDED(pUserEventTimer->GetUserEventTimerElapsed(pti->hWnd, pti->uIconDemoteTimerID, &uTimerElapsed)))
        {
            uTimerElapsed /= 1000;
        }
    }

    return uTimerElapsed;
}

void CTrayNotify::_RemoveImage(UINT uIMLIndex)
{
    INT_PTR nCount;
    INT_PTR i;

    if (uIMLIndex != (UINT)-1) 
    {
        ImageList_Remove(_himlIcons, uIMLIndex);

        nCount = m_TrayItemManager.GetItemCount();
        for (i = nCount - 1; i >= 0; i--) 
        {
            int iImage = m_TrayItemManager.GetTBBtnImage(i);
            if (iImage > (int)uIMLIndex)
                m_TrayItemManager.SetTBBtnImage(i, iImage - 1);
        }
    }
}

//---------------------------------------------------------------------------
// Returns TRUE if either the images are OK as they are or they needed
// resizing and the resize process worked. FALSE otherwise.
BOOL CTrayNotify::_CheckAndResizeImages()
{
    HIMAGELIST himlOld, himlNew;
    int cxSmIconNew, cySmIconNew, cxSmIconOld, cySmIconOld;
    int i, cItems;
    HICON hicon;
    BOOL fOK = TRUE;

    // if (!ptnd)
    //    return 0;

    if (_fNoTrayItemsDisplayPolicyEnabled)
        return fOK;

    himlOld = _himlIcons;

    // Do dimensions match current icons?
    cxSmIconNew = GetSystemMetrics(SM_CXSMICON);
    cySmIconNew = GetSystemMetrics(SM_CYSMICON);
    ImageList_GetIconSize(himlOld, &cxSmIconOld, &cySmIconOld);
    if (cxSmIconNew != cxSmIconOld || cySmIconNew != cySmIconOld)
    {
        // Nope, we're gonna need a new imagelist.
        himlNew = ImageList_Create(cxSmIconNew, cySmIconNew, SHGetImageListFlags(_hwndToolbar), 0, 1);
        if (himlNew)
        {
            // Copy the images over to the new image list.
            cItems = ImageList_GetImageCount(himlOld);
            for (i = 0; i < cItems; i++)
            {
                // REVIEW - there's no way to copy images to an empty
                // imagelist, resizing it on the way.
                hicon = ImageList_GetIcon(himlOld, i, ILD_NORMAL);
                if (hicon)
                {
                    if (ImageList_AddIcon(himlNew, hicon) == -1)
                    {
                        // Couldn't copy image so bail.
                        fOK = FALSE;
                    }
                    DestroyIcon(hicon);
                }
                else
                {
                    fOK = FALSE;
                }

                // FU - bail.
                if (!fOK)
                    break;
            }

            // Did everything copy over OK?
            if (fOK)
            {
                // Yep, Set things up to use the new one.
                _himlIcons = himlNew;
                m_TrayItemManager.SetIconList(_himlIcons);
                // Destroy the old icon cache.
                ImageList_Destroy(himlOld);
                SendMessage(_hwndToolbar, TB_SETIMAGELIST, 0, (LPARAM) _himlIcons);
                SendMessage(_hwndToolbar, TB_AUTOSIZE, 0, 0);
            }
            else
            {
                // Nope, stick with what we have.
                ImageList_Destroy(himlNew);
            }
        }
    }

    return fOK;
}

void CTrayNotify::_ActivateTips(BOOL bActivate)
{
    if (_fNoTrayItemsDisplayPolicyEnabled)
        return;

    if (bActivate && !_CanActivateTips())
        return;

    if (_hwndToolbarInfoTip)
        SendMessage(_hwndToolbarInfoTip, TTM_ACTIVATE, (WPARAM)bActivate, 0);
}

// x,y in client coords

void CTrayNotify::_InfoTipMouseClick(int x, int y, BOOL bRightMouseButtonClick)
{
    if (!_fNoTrayItemsDisplayPolicyEnabled && _pinfo)
    {
        RECT rect;
        GetWindowRect(_hwndInfoTip, &rect);
        // x & y are mapped to our window so map the rect to our window as well
        MapWindowRect(HWND_DESKTOP, _hwndNotify, &rect);   // screen -> client

        POINT pt = {x, y};
        if (PtInRect(&rect, pt))
        {
            SHAllowSetForegroundWindow(_pinfo->hWnd);

            _beLastBalloonEvent = (bRightMouseButtonClick ? BALLOONEVENT_USERRIGHTCLICK : BALLOONEVENT_USERLEFTCLICK);
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, 
                FALSE, (bRightMouseButtonClick ? NIN_BALLOONTIMEOUT : NIN_BALLOONUSERCLICK));
        }
    }
}

void CTrayNotify::_PositionInfoTip()
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if (_pinfo)
    {
        int x = 0;
        int y = 0;

        // if (_pinfo->hWnd == _hwndNotify && _pinfo->uID == UID_CHEVRONBUTTON)
        if (_IsChevronInfoTip(_pinfo->hWnd, _pinfo->uID))
        {
            RECT rc;
            GetWindowRect(_hwndChevron, &rc);
            x = rc.left;
            y = rc.top;
        }
        else
        {
            INT_PTR iIndex = m_TrayItemManager.FindItemAssociatedWithHwndUid(_pinfo->hWnd, _pinfo->uID);
            if (iIndex != -1)
            {
                RECT rc;
                if (SendMessage(_hwndToolbar, TB_GETITEMRECT, iIndex, (LPARAM)&rc))
                {
                    MapWindowRect(_hwndToolbar, HWND_DESKTOP, &rc);
                    x = (rc.left + rc.right)/2;
                    y = (rc.top  + rc.bottom)/2;
                }
            
            }
        }

        SendMessage(_hwndInfoTip, TTM_TRACKPOSITION, 0, MAKELONG(x, y));
    }
}

BOOL CTrayNotify::_IsScreenSaverRunning()
{
    BOOL fRunning;
    if (SystemParametersInfo(SPI_GETSCREENSAVERRUNNING, 0, &fRunning, 0))
    {
        return fRunning;
    }

    return FALSE;
}

UINT CTrayNotify::_GetQueueCount()
{
    return _dpaInfo ? _dpaInfo.GetPtrCount() : 0;
}

// NOTE: sligtly different versions of this exist in...
//      SHPlaySound() -> shell32
//      IEPlaySound() -> shdocvw/browseui

STDAPI_(void) ExplorerPlaySound(LPCTSTR pszSound)
{
    // note, we have access only to global system sounds here as we use "Apps\.Default"
    TCHAR szKey[256];
    StringCchPrintf(szKey, ARRAYSIZE(szKey), TEXT("AppEvents\\Schemes\\Apps\\.Default\\%s\\.current"), pszSound);

    TCHAR szFileName[MAX_PATH];
    szFileName[0] = 0;
    LONG cbSize = sizeof(szFileName);

    // test for an empty string, PlaySound will play the Default Sound if we
    // give it a sound it cannot find...

    if ((RegQueryValue(HKEY_CURRENT_USER, szKey, szFileName, &cbSize) == ERROR_SUCCESS)
        && szFileName[0])
    {
        // flags are relevant, we try to not stomp currently playing sounds
        PlaySound(szFileName, NULL, SND_FILENAME | SND_ASYNC | SND_NODEFAULT | SND_NOSTOP);
    }
}

DWORD CTrayNotify::_ShowBalloonTip(LPTSTR szTitle, DWORD dwInfoFlags, UINT uTimeout, DWORD dwLastSoundTime)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    DWORD dwCurrentSoundTime = dwLastSoundTime;
    
    SendMessage(_hwndInfoTip, TTM_SETTITLE, dwInfoFlags & NIIF_ICON_MASK, (LPARAM)szTitle);
    if (!(dwInfoFlags & NIIF_NOSOUND))
    {
        // make sure at least 5 seconds pass between sounds, avoid annoying balloons
        if ((GetTickCount() - dwLastSoundTime) >= 5000)
        {
            dwCurrentSoundTime = GetTickCount();
            ExplorerPlaySound(TEXT("SystemNotification"));
        }
    }

    _PositionInfoTip();

    // if tray is in auto hide mode unhide it
    c_tray.Unhide();
    c_tray._fBalloonUp = TRUE;

    TOOLINFO ti = {0};
    ti.cbSize       = sizeof(ti);
    ti.hwnd         = _hwndNotify;
    ti.uId          = (INT_PTR)_hwndNotify;
    ti.lpszText     = _pinfo->szInfo;

    SendMessage(_hwndInfoTip, TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);

    // disable regular tooltips
    _fInfoTipShowing = TRUE;
    _ActivateTips(FALSE);

    // show the balloon
    SendMessage(_hwndInfoTip, TTM_TRACKACTIVATE, (WPARAM)TRUE, (LPARAM)&ti);

    _SetTimer(TF_INFOTIP_TIMER, TNM_INFOTIPTIMER, uTimeout, &_uInfoTipTimer);    

    return dwCurrentSoundTime;
}

void CTrayNotify::_HideBalloonTip()
{
    _litsLastInfoTip = LITS_BALLOONDESTROYED;

    SendMessage(_hwndInfoTip, TTM_TRACKACTIVATE, (WPARAM)FALSE, (LPARAM)0);

    TOOLINFO ti = {0};
    ti.cbSize = sizeof(ti);
    ti.hwnd = _hwndNotify;
    ti.uId = (INT_PTR)_hwndNotify;
    ti.lpszText = NULL;
    
    SendMessage(_hwndInfoTip, TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);
}

void CTrayNotify::_DisableCurrentInfoTip(CTrayItem * ptiTemp, UINT uReason, BOOL bBalloonShowing)
{
    _KillTimer(TF_INFOTIP_TIMER, _uInfoTipTimer);
    _uInfoTipTimer = 0;

    if (ptiTemp)
    {
        if (!uReason)
        {
            uReason = NIN_BALLOONTIMEOUT;
        }
        _SendNotify(ptiTemp, uReason);
    }
    
    delete _pinfo;
    _pinfo = NULL;

    if (bBalloonShowing)
        _HideBalloonTip();
}

void CTrayNotify::_EmptyInfoTipQueue()
{
    delete _pinfo;
    _pinfo = NULL;
    _dpaInfo.EnumCallback(DeleteDPAPtrCB, NULL);
    _dpaInfo.DeleteAllPtrs();
}

BOOL CTrayNotify::_CanShowBalloon()
{
    if (!_bStartMenuAllowsTrayBalloon || _bWaitingBetweenBalloons || _bWorkStationLocked 
        		|| _bRudeAppLaunched || IsDirectXAppRunningFullScreen() || _bWaitAfterRudeAppHide)
        return FALSE;

    return TRUE;
}

void CTrayNotify::_ShowInfoTip(HWND hwnd, UINT uID, BOOL bShow, BOOL bAsync, UINT uReason)
{
    if (_fNoTrayItemsDisplayPolicyEnabled)
        return;

    // make sure we only show/hide what we intended to show/hide
    if (_pinfo && _pinfo->hWnd == hwnd && _pinfo->uID == uID)
    {
        CTrayItem * pti = NULL;
        INT_PTR nIcon = ( _IsChevronInfoTip(hwnd, uID) ? 
                            -1 : 
                            m_TrayItemManager.FindItemAssociatedWithHwndUid(hwnd, uID) );
        if (nIcon != -1)
            pti = m_TrayItemManager.GetItemDataByIndex(nIcon);

        BOOL bNotify = TRUE;

        if (bShow && pti)
        {
            if (!_fEnableUserTrackedInfoTips || pti->dwUserPref == TNUP_DEMOTED)
            {
                _SendNotify(pti, NIN_BALLOONSHOW);
                _SendNotify(pti, NIN_BALLOONTIMEOUT);
            }
        }

        if ( !_IsChevronInfoTip(hwnd, uID) &&
                ( !pti || pti->IsHidden() 
                  || pti->dwUserPref == TNUP_DEMOTED
                  || !_fEnableUserTrackedInfoTips
                )
            )
        {
            // icon is hidden, cannot show its balloon
            bNotify = !bShow;
            bShow = FALSE; //show the next balloon instead
        }

        if (bShow)
        {
            if (bAsync)
            {
                PostMessage(_hwndNotify, TNM_ASYNCINFOTIP, (WPARAM)hwnd, (LPARAM)uID);
            }
            else if (_CanShowBalloon())
            {
                DWORD dwLastSoundTime = 0;

                if ((nIcon != -1) && pti)
                {
                    _PlaceItem(nIcon, pti, TRAYEVENT_ONINFOTIP);
                    dwLastSoundTime = pti->dwLastSoundTime;
                }

                dwLastSoundTime = _ShowBalloonTip(_pinfo->szTitle, _pinfo->dwInfoFlags, _pinfo->uTimeout, dwLastSoundTime);

                if ((nIcon != -1) && pti)
                {
                    pti->dwLastSoundTime = dwLastSoundTime;
                    _SendNotify(pti, NIN_BALLOONSHOW);
                }
            }
        }
        else
        {
            if (_IsChevronInfoTip(hwnd, uID))
            {
                // If the user clicked on the chevron info tip, we dont want to show the
                // chevron any more, otherwise we want to show it once more the next session
                // for a maximum of 5 sessions...
                m_TrayItemRegistry.IncChevronInfoTipShownInRegistry(uReason == NIN_BALLOONUSERCLICK);
            }

            _DisableCurrentInfoTip(pti, uReason, TRUE);

            _bWaitingBetweenBalloons = TRUE;

            c_tray._fBalloonUp = FALSE;
            _fInfoTipShowing = FALSE;
            _ActivateTips(TRUE);

            // we are hiding the current balloon. are there any waiting? yes, then show the first one
            if (_GetQueueCount())
            {
                _pinfo = _dpaInfo.DeletePtr(0);
                SetTimer(_hwndNotify, TID_BALLOONPOPWAIT, _GetBalloonWaitInterval(_beLastBalloonEvent), NULL);
            }
            else
            {
                _bWaitingBetweenBalloons = FALSE;
                UpdateWindow(_hwndToolbar);
            }
        }
    }
    else if (_pinfo && !bShow)
    {
        // we wanted to hide something that wasn't showing up
        // maybe it's in the queue

        // Remove only the first info tip from this (hwnd, uID)
        _RemoveInfoTipFromQueue(hwnd, uID, TRUE);
    }
}

void CTrayNotify::_SetInfoTip(HWND hWnd, UINT uID, LPTSTR pszInfo, LPTSTR pszInfoTitle,
        DWORD dwInfoFlags, UINT uTimeout, BOOL bAsync)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    // show the new one...
    if (pszInfo[0])
    {
        TNINFOITEM *pii = new TNINFOITEM;
        if (pii)
        {
            pii->hWnd = hWnd;
            pii->uID = uID;
            StringCchCopy(pii->szInfo, ARRAYSIZE(pii->szInfo), pszInfo);
            StringCchCopy(pii->szTitle, ARRAYSIZE(pii->szTitle), pszInfoTitle);
            pii->uTimeout = uTimeout;
            if (pii->uTimeout < MIN_INFO_TIME)
                pii->uTimeout = MIN_INFO_TIME;
            else if (pii->uTimeout > MAX_INFO_TIME)
                pii->uTimeout = MAX_INFO_TIME;
            pii->dwInfoFlags  = dwInfoFlags;

            // if _pinfo is non NULL then we have a balloon showing right now
            if (_pinfo || _GetQueueCount())
            {
                // if this is a different icon making the change request
                // we might have to queue this up
                if (hWnd != _pinfo->hWnd || uID != _pinfo->uID)
                {
                    // if the current balloon has not been up for the minimum 
                    // show delay or there are other items in the queue
                    // add this to the queue
                    if (!_dpaInfo || _dpaInfo.AppendPtr(pii) == -1)
                    {
                        delete pii;
                    }
                    return;
                }

                CTrayItem * ptiTemp = NULL;
                INT_PTR nIcon = m_TrayItemManager.FindItemAssociatedWithHwndUid(_pinfo->hWnd, _pinfo->uID);
                if (nIcon != -1)
                    ptiTemp = m_TrayItemManager.GetItemDataByIndex(nIcon);

                _DisableCurrentInfoTip(ptiTemp, NIN_BALLOONTIMEOUT, FALSE);
            }

            _pinfo = pii;  // in with the new

            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, bAsync, 0);
        }
    }
    else
    {
        // empty text means get rid of the balloon
        _beLastBalloonEvent = BALLOONEVENT_BALLOONHIDE;
        _ShowInfoTip(hWnd, uID, FALSE, FALSE, NIN_BALLOONHIDE);
    }
}

DWORD CTrayNotify::_GetBalloonWaitInterval(BALLOONEVENT be)
{
    switch (be)
    {
        case BALLOONEVENT_USERLEFTCLICK:
            return BALLOON_INTERVAL_MAX;

        case BALLOONEVENT_TIMEOUT:
        case BALLOONEVENT_NONE:
        case BALLOONEVENT_APPDEMOTE:
        case BALLOONEVENT_BALLOONHIDE:
            return BALLOON_INTERVAL_MEDIUM;

        case BALLOONEVENT_USERRIGHTCLICK:
        case BALLOONEVENT_USERXCLICK:
        default:
            return BALLOON_INTERVAL_MIN;
    }
}

BOOL CTrayNotify::_ModifyNotify(PNOTIFYICONDATA32 pnid, INT_PTR nIcon, BOOL *pbRefresh, BOOL bFirstTime)
{
    BOOL fResize = FALSE;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(nIcon);
    if (!pti)
    {
        return FALSE;
    }

    _CheckAndResizeImages();

    if (pnid->uFlags & NIF_STATE) 
    {
#define NIS_VALIDMASK (NIS_HIDDEN | NIS_SHAREDICON)
        DWORD dwOldState = pti->dwState;

        // validate mask
        if (pnid->dwStateMask & ~NIS_VALIDMASK)
        {
            return FALSE;
        }

        pti->dwState = (pnid->dwState & pnid->dwStateMask) | (pti->dwState & ~pnid->dwStateMask);
        
        if (pnid->dwStateMask & NIS_HIDDEN)
        {
            if (pti->IsHidden())
            {
                m_TrayItemManager.SetTBBtnStateHelper(nIcon, TBSTATE_ENABLED, FALSE);
                _PlaceItem(nIcon, pti, TRAYEVENT_ONICONHIDE);
            }
            else 
            {
                // When the icon is inserted the first time, this function is called..
                // If the icon ended the previous session in the secondary tray, then it would
                // start this session in the secondary tray, in which case, the icon should not
                // be enabled...
                if (!bFirstTime)
                {
                    m_TrayItemManager.SetTBBtnStateHelper(nIcon, TBSTATE_ENABLED, TRUE);
                    _PlaceItem(nIcon, pti, TRAYEVENT_ONICONUNHIDE);
                }
            }                
        }

        if ((pnid->dwState ^ dwOldState) & NIS_SHAREDICON) 
        {
            if (dwOldState & NIS_SHAREDICON) 
            {
                // if we're going from shared to not shared, 
                // clear the icon
                m_TrayItemManager.SetTBBtnImage(nIcon, -1);
                pti->hIcon = NULL;
            }
        }
        fResize |= ((pnid->dwState ^ dwOldState) & NIS_HIDDEN);
    }

    if (pnid->uFlags & NIF_GUID)
    {
        memcpy(&(pti->guidItem), &(pnid->guidItem), sizeof(pnid->guidItem));
    }
    
    // The icon is the only thing that can fail, so I will do it first
    if (pnid->uFlags & NIF_ICON)
    {
        int iImageNew, iImageOld;
        HICON hIcon1 = NULL, hIcon2 = NULL;
        BOOL bIsEqualIcon = FALSE;

        iImageOld = m_TrayItemManager.GetTBBtnImage(nIcon);

        if (!bFirstTime)
        {
            if (iImageOld != -1)
            {
                if (_himlIcons)
                {
                    hIcon1 = ImageList_GetIcon(_himlIcons, iImageOld, ILD_NORMAL);
                }

                if (hIcon1)
                {
                    hIcon2 = GetHIcon(pnid);
                }
            }

            if (iImageOld != -1 && hIcon1 && hIcon2)
            {
                bIsEqualIcon = SHAreIconsEqual(hIcon1, hIcon2);
            }

            if (hIcon1)
                DestroyIcon(hIcon1);
        }

        if (pti->IsIconShared()) 
        {
            iImageNew = m_TrayItemManager.FindImageIndex(GetHIcon(pnid), TRUE);
            if (iImageNew == -1)
            {
                return FALSE;
            }
        } 
        else 
        {
            if (GetHIcon(pnid))
            {
                // Replace icon knows how to handle -1 for add
                iImageNew = ImageList_ReplaceIcon(_himlIcons, iImageOld, GetHIcon(pnid));
                if (iImageNew < 0)
                {
                    return FALSE;
                }
            }
            else
            {
                _RemoveImage(iImageOld);
                iImageNew = -1;
            }
            
            if (pti->IsSharedIconSource())
            {
                INT_PTR iCount = m_TrayItemManager.GetItemCount();
                // if we're the source of shared icons, we need to go update all the other icons that
                // are using our icon
                for (INT_PTR i = 0; i < iCount; i++) 
                {
                    if (m_TrayItemManager.GetTBBtnImage(i) == iImageOld) 
                    {
                        CTrayItem * ptiTemp = m_TrayItemManager.GetItemDataByIndex(i);
                        ptiTemp->hIcon = GetHIcon(pnid);
                        m_TrayItemManager.SetTBBtnImage(i, iImageNew);
                    }
                }
            }

            if (iImageOld == -1 || iImageNew == -1)
                fResize = TRUE;
        }
        pti->hIcon = GetHIcon(pnid);
        m_TrayItemManager.SetTBBtnImage(nIcon, iImageNew);

        // Dont count HICON_MODIFies the first time...
        if (!pti->IsHidden() && !bFirstTime)
        {
            pti->SetItemSameIconModify(bIsEqualIcon);
            _PlaceItem(nIcon, pti, TRAYEVENT_ONICONMODIFY);
        }
    }

    if (pnid->uFlags & NIF_MESSAGE)
    {
        pti->uCallbackMessage = pnid->uCallbackMessage;
    }

    if (pnid->uFlags & NIF_TIP)
    {
        m_TrayItemManager.SetTBBtnText(nIcon, pnid->szTip);
        //
        // pnid - NOTIFYICONDATA struct has an szTip of 64 or 128
        // szIconText - CTrayItem has an szTip of MAX_PATH
        // We ensure that pnid->szTip is NULL terminated, but the right thing to do is ensure that we 
        // copy only as many characters as we need, and dont overflow the buffer.
        StringCchCopy(pti->szIconText, min(ARRAYSIZE(pnid->szTip), ARRAYSIZE(pti->szIconText)), pnid->szTip);
    }

    if (fResize)
        _OnSizeChanged(FALSE);

    // need to have info stuff done after resize because we need to
    // position the infotip relative to the hwndToolbar
    if (pnid->uFlags & NIF_INFO)
    {
        // if button is hidden we don't show infotip
        if (!pti->IsHidden())
        {
            _SetInfoTip(pti->hWnd, pti->uID, pnid->szInfo, pnid->szInfoTitle, pnid->dwInfoFlags, 
                    pnid->uTimeout, (bFirstTime || fResize));
        }
    }

    if (!bFirstTime)
        _NotifyCallback(NIM_MODIFY, nIcon, -1);

    return TRUE;
}

BOOL CTrayNotify::_SetVersionNotify(PNOTIFYICONDATA32 pnid, INT_PTR nIcon)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(nIcon);
    if (!pti)
        return FALSE;

    if (pnid->uVersion < NOTIFYICON_VERSION) 
    {
        pti->uVersion = 0;
        return TRUE;
    } 
    else if (pnid->uVersion == NOTIFYICON_VERSION) 
    {
        pti->uVersion = NOTIFYICON_VERSION;
        return TRUE;
    } 
    else 
    {
        return FALSE;
    }
}

void CTrayNotify::_NotifyCallback(DWORD dwMessage, INT_PTR nCurrentItem, INT_PTR nPastItem)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    if (_pNotifyCB)
    {
        CNotificationItem * pni = new CNotificationItem;
        if (pni)
        {
            BOOL bStat = FALSE;
            if (nCurrentItem != -1 && m_TrayItemManager.GetTrayItem(nCurrentItem, pni, &bStat) && bStat)
            {
                PostMessage(_hwndNotify, TNM_NOTIFY, dwMessage, (LPARAM)pni);
            }
            else if (nCurrentItem == -1 && nPastItem != -1)
            {
                bStat = FALSE;
                m_TrayItemRegistry.GetTrayItem(nPastItem, pni, &bStat);

                if (bStat)
                    PostMessage(_hwndNotify, TNM_NOTIFY, dwMessage, (LPARAM)pni);
                else
                    delete pni;
            }
            else
                delete pni;
        }
    }
}

void CTrayNotify::_RemoveInfoTipFromQueue(HWND hWnd, UINT uID, BOOL bRemoveFirstOnly /* Default = FALSE */)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    int cItems = _GetQueueCount();

    for (int i = 0; _dpaInfo && (i < cItems); i++)
    {
        TNINFOITEM * pii = _dpaInfo.GetPtr(i);

        if (pii->hWnd == hWnd && pii->uID == uID)
        {
            _dpaInfo.DeletePtr(i);      // this removes the element from the dpa
            delete pii;

            if (bRemoveFirstOnly)
            {
                return;
            }
            else
            {
                i = i-1;
                cItems = _GetQueueCount();
            }
        }
    }
}

BOOL CTrayNotify::_DeleteNotify(INT_PTR nIcon, BOOL bShutdown, BOOL bShouldSaveIcon)
{
    BOOL bRet = FALSE;

    if (_fNoTrayItemsDisplayPolicyEnabled)
        return bRet;

    _NotifyCallback(NIM_DELETE, nIcon, -1);
    CTrayItem *pti = m_TrayItemManager.GetItemDataByIndex(nIcon);
    if (pti)
    {
        _RemoveInfoTipFromQueue(pti->hWnd, pti->uID);

        // delete info tip if showing
        if (_pinfo && _pinfo->hWnd == pti->hWnd && _pinfo->uID == pti->uID)
        {
            // frees pinfo and shows the next balloon if any
            _beLastBalloonEvent = BALLOONEVENT_BALLOONHIDE;
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, TRUE, NIN_BALLOONHIDE); 
        }

        // Save the icon info only if needed...
        if (bShouldSaveIcon && pti->ShouldSaveIcon())
        {
            if (pti->IsStartupIcon() && !pti->IsDemoted() && pti->dwUserPref == TNUP_AUTOMATIC)
                pti->uNumSeconds = _GetAccumulatedTime(pti);

            // On Delete, add the icon to the past icons list, and the item to the past items list
            HICON hIcon = NULL;
            if (_himlIcons)
            {
                hIcon = ImageList_GetIcon(_himlIcons, m_TrayItemManager.GetTBBtnImage(nIcon), ILD_NORMAL);
            }

            int nPastSessionIndex = m_TrayItemRegistry.DoesIconExistFromPreviousSession(pti, pti->szIconText, hIcon);

            if (nPastSessionIndex != -1)
            {
                _NotifyCallback(NIM_DELETE, -1, nPastSessionIndex);
                m_TrayItemRegistry.DeletePastItem(nPastSessionIndex);
            }

            if (m_TrayItemRegistry.AddToPastItems(pti, hIcon))
                _NotifyCallback(NIM_ADD, -1, 0);

            if (hIcon)
                DestroyIcon(hIcon);
        }
        
        _KillItemTimer(pti);

        bRet = (BOOL) SendMessage(_hwndToolbar, TB_DELETEBUTTON, nIcon, 0);

        if (!bShutdown)
        {
            _UpdateChevronState(_fBangMenuOpen, FALSE, TRUE);
            _OnSizeChanged(FALSE);
        }
    }
    else
    {
        TraceMsg(TF_ERROR, "Removing nIcon %x - pti is NULL", nIcon);
    }

    return bRet;
}


BOOL CTrayNotify::_InsertNotify(PNOTIFYICONDATA32 pnid)
{
    TBBUTTON tbb;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    // First insert a totally "default" icon
    CTrayItem * pti = new CTrayItem;
    if (!pti)
    {
        return FALSE;
    }

    pti->hWnd = GetHWnd(pnid);
    pti->uID = pnid->uID;
    if (_bStartupIcon)
        pti->SetStartupIcon(TRUE);

    if (!SUCCEEDED(SHExeNameFromHWND(pti->hWnd, pti->szExeName, ARRAYSIZE(pti->szExeName))))
    {
        pti->szExeName[0] = '\0';
    }

    INT_PTR nPastSessionIndex = m_TrayItemRegistry.CheckAndRestorePersistentIconSettings( pti,
                                    ((pnid->uFlags & NIF_TIP) ? pnid->szTip : NULL),
                                    ((pnid->uFlags & NIF_ICON) ? GetHIcon(pnid) : NULL) );

    tbb.dwData = (DWORD_PTR)pti;
    tbb.iBitmap = -1;
    tbb.idCommand = Toolbar_GetUniqueID(_hwndToolbar);
    tbb.fsStyle = BTNS_BUTTON;
    tbb.fsState = TBSTATE_ENABLED;

    // The "Show Always" flag should be special-cased...
    // If the item didnt exist before, and is added for the first time
    if (nPastSessionIndex == -1)
    {
        if (pnid->dwStateMask & NIS_SHOWALWAYS)
        {
            // Make sure that only the explorer process is setting this mask...
            if ( pti->szExeName && _szExplorerExeName && 
                    lstrcmpi(pti->szExeName, _szExplorerExeName) )
            {
                pti->dwUserPref = TNUP_PROMOTED;
            }
        }
    }
    pnid->dwStateMask &= ~NIS_SHOWALWAYS;

    // If one of the icons had been placed in the secondary tray in the previous session...
    if (pti->IsDemoted() && m_TrayItemRegistry.IsAutoTrayEnabled())
    {   
        tbb.fsState |= TBSTATE_HIDDEN;
    }

    tbb.iString = -1;

    BOOL fRet = TRUE;

    BOOL fRedraw = _SetRedraw(FALSE);

    // Insert at the zeroth position (from the beginning)
    INT_PTR iInsertPos = 0;
    if (SendMessage(_hwndToolbar, TB_INSERTBUTTON, iInsertPos, (LPARAM)&tbb))
    {    
        // Then modify this icon with the specified info
        if (!_ModifyNotify(pnid, iInsertPos, NULL, TRUE))
        {
            _DeleteNotify(iInsertPos, FALSE, FALSE);
            fRet = FALSE;
        }
        // BUG : 404477, Re-entrancy case where traynotify gets a TBN_DELETINGBUTTON
        // when processing a TB_INSERTBUTTON. In this re-entrant scenario, pti is
        // invalid after the TB_INSERTBUTTON above, even though it was created fine
        // before the TB_INSERTBUTTON.
        // Hence check for pti...
        else if (!pti)
        {
            fRet = FALSE;
        }
        else
        {
            // The item has been successfully added to the tray, and the user's
            // settings have been honored. So it can be deleted from the Past Items 
            // list and the Past Items bucket...
            if (nPastSessionIndex != -1)
            {
                _NotifyCallback(NIM_DELETE, -1, nPastSessionIndex);
                m_TrayItemRegistry.DeletePastItem(nPastSessionIndex);
            }

            if (!_PlaceItem(0, pti, TRAYEVENT_ONNEWITEMINSERT))
            {
                _UpdateChevronState(_fBangMenuOpen, FALSE, TRUE);
                _OnSizeChanged(FALSE);
            }
            // _hwndToolbar might not be large enough to hold new icon
            _Size();
        }
    }

    _SetRedraw(fRedraw);

    if (fRet)
        _NotifyCallback(NIM_ADD, iInsertPos, -1);
    
    return fRet;
}



// set the mouse cursor to the center of the button.
// do this becaus our tray notifies don't have enough data slots to
// pass through info about the button's position.
void CTrayNotify::_SetCursorPos(INT_PTR i)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    RECT rc;
    if (SendMessage(_hwndToolbar, TB_GETITEMRECT, i, (LPARAM)&rc)) 
    {
        MapWindowPoints(_hwndToolbar, HWND_DESKTOP, (LPPOINT)&rc, 2);
        SetCursorPos((rc.left + rc.right) / 2, (rc.top + rc.bottom) / 2);
    }
}

LRESULT CTrayNotify::_SendNotify(CTrayItem * pti, UINT uMsg)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if (pti->uCallbackMessage && pti->hWnd)
       return SendNotifyMessage(pti->hWnd, pti->uCallbackMessage, pti->uID, uMsg);
    return 0;
}

void CTrayNotify::_SetToolbarHotItem(HWND hWndToolbar, UINT nToolbarIcon)
{
    if (!_fNoTrayItemsDisplayPolicyEnabled && hWndToolbar && nToolbarIcon != -1)
    {
        SetFocus(hWndToolbar);
        InvalidateRect(hWndToolbar, NULL, TRUE);
        SendMessage(hWndToolbar, TB_SETHOTITEM, nToolbarIcon, 0);
    }
}

LRESULT CALLBACK CTrayNotify::ChevronSubClassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
    LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
    CTrayNotify * pTrayNotify = reinterpret_cast<CTrayNotify*>(dwRefData);
    AssertMsg((pTrayNotify != NULL), TEXT("pTrayNotify SHOULD NOT be NULL, as passed to ChevronSubClassWndProc."));

    if (pTrayNotify->_fNoTrayItemsDisplayPolicyEnabled)
    {
        return DefSubclassProc(hwnd, uMsg, wParam, lParam);
    }

    static BOOL bBangMenuOpenLastTime = pTrayNotify->_fBangMenuOpen;

    switch(uMsg)
    {
        case WM_KEYDOWN:
        {
            BOOL fLastHot = FALSE;
            switch(wParam)
            {
                case VK_UP:
                case VK_LEFT:
                    fLastHot = TRUE;
                    // Fall through...

                case VK_DOWN:
                case VK_RIGHT:
                {
                    INT_PTR nToolbarIconSelected = pTrayNotify->_GetToolbarFirstVisibleItem(
                                    pTrayNotify->_hwndToolbar, fLastHot);

                    pTrayNotify->_fChevronSelected = FALSE;
                    if (!fLastHot)
                    {
                        if (nToolbarIconSelected != -1)
                        // The toolbar has been selected
                        {
                            pTrayNotify->_SetToolbarHotItem(pTrayNotify->_hwndToolbar, nToolbarIconSelected);
                        }
                        else if (pTrayNotify->_hwndClock)
                        {
                            SetFocus(pTrayNotify->_hwndClock);
                        }
                        else
                        // No visible items on the tray, no clock, so nothing happens
                        {
                            pTrayNotify->_fChevronSelected = TRUE;
                        }
                    }
                    else
                    {
                        if (pTrayNotify->_hwndClock)
                        {
                            SetFocus(pTrayNotify->_hwndClock);
                        }
                        else if (nToolbarIconSelected != -1)
                        {
                            pTrayNotify->_SetToolbarHotItem(pTrayNotify->_hwndToolbar, nToolbarIconSelected);
                        }
                        else
                        {
                            pTrayNotify->_fChevronSelected = TRUE;
                        }                        
                    }
                    return 0;
                }
                break;

                case VK_RETURN:
                case VK_SPACE:
                    pTrayNotify->_ToggleDemotedMenu();
                    return 0;
            }
        }
        break;

        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            {
                if (pTrayNotify->_hTheme)
                {
                    pTrayNotify->_fHasFocus = (uMsg == WM_SETFOCUS);
                }
            }
            break;

        default:
            if (InRange(uMsg, WM_MOUSEFIRST, WM_MOUSELAST))
            {
                if (bBangMenuOpenLastTime != pTrayNotify->_fBangMenuOpen)
                {
                    TOOLINFO ti = {0};
                    ti.cbSize = sizeof(ti);
                    ti.hwnd = pTrayNotify->_hwndNotify;
                    ti.uId = (UINT_PTR)pTrayNotify->_hwndChevron;
                    ti.lpszText = (LPTSTR)MAKEINTRESOURCE(!pTrayNotify->_fBangMenuOpen ? IDS_SHOWDEMOTEDTIP : IDS_HIDEDEMOTEDTIP);
                    ti.hinst = hinstCabinet;

                    SendMessage(pTrayNotify->_hwndChevronToolTip, TTM_UPDATETIPTEXT, 0, (LPARAM)(LPTOOLINFO)&ti); 
                    bBangMenuOpenLastTime = pTrayNotify->_fBangMenuOpen;
                }

                MSG msg = {0};
                msg.lParam = lParam;
                msg.wParam = wParam;
                msg.message = uMsg;
                msg.hwnd = hwnd;

                SendMessage(pTrayNotify->_hwndChevronToolTip, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)&msg);
            }
            break;
    }

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

LRESULT CALLBACK CTrayNotify::s_ToolbarWndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
    LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
    BOOL fClickDown = FALSE;

    CTrayNotify * pTrayNotify = reinterpret_cast<CTrayNotify*>(dwRefData);
    AssertMsg((pTrayNotify != NULL), TEXT("pTrayNotify SHOULD NOT be NULL, as passed to s_ToolbarWndProc."));

    if (pTrayNotify->_fNoTrayItemsDisplayPolicyEnabled)
    {
        return DefSubclassProc(hwnd, uMsg, wParam, lParam);    
    }

    switch (uMsg)
    {
    case WM_KEYDOWN:
        pTrayNotify->_fReturn = (wParam == VK_RETURN);
        break;

    case WM_CONTEXTMENU:
        {
            INT_PTR i = SendMessage(pTrayNotify->_hwndToolbar, TB_GETHOTITEM, 0, 0);
            if (i != -1)
            {
                CTrayItem * pti = pTrayNotify->m_TrayItemManager.GetItemDataByIndex(i);
                if (lParam == (LPARAM)-1)
                    pTrayNotify->_fKey = TRUE;

                if (pTrayNotify->_fKey)
                {
                    pTrayNotify->_SetCursorPos(i);
                }

                if (pTrayNotify->_hwndToolbarInfoTip)
                    SendMessage(pTrayNotify->_hwndToolbarInfoTip, TTM_POP, 0, 0);
                
                if (pti)
                {
                    SHAllowSetForegroundWindow(pti->hWnd);
                    if (pti->uVersion >= KEYBOARD_VERSION)
                    {
                        pTrayNotify->_SendNotify(pti, WM_CONTEXTMENU);
                    }
                    else
                    {
                        if (pTrayNotify->_fKey)
                        {
                            pTrayNotify->_SendNotify(pti, WM_RBUTTONDOWN);
                            pTrayNotify->_SendNotify(pti, WM_RBUTTONUP);
                        }
                    }
                }
                return 0;
            }
        }
        break;

    default:
        if (InRange(uMsg, WM_MOUSEFIRST, WM_MOUSELAST))
        {
            pTrayNotify->_OnMouseEvent(uMsg, wParam, lParam);
        }
        break;
    }
        
    return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}

void CTrayNotify::_ToggleTrayItems(BOOL bEnable)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    for (INT_PTR i = m_TrayItemManager.GetItemCount()-1; i >= 0; i--)
    {
        CTrayItem *pti = m_TrayItemManager.GetItemDataByIndex(i);

        if (pti)
        {
            if (bEnable)
            {
                _PlaceItem(i, pti, TRAYEVENT_ONAPPLYUSERPREF);
            }
            else // if (disable)
            {
                _PlaceItem(i, pti, TRAYEVENT_ONDISABLEAUTOTRAY);
                if (_pinfo && _IsChevronInfoTip(_pinfo->hWnd, _pinfo->uID))
                {
                    //hide the balloon 
                    _beLastBalloonEvent = BALLOONEVENT_NONE;
                    _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONHIDE);
                }
            }
        }
    }    
}

HRESULT CTrayNotify::EnableAutoTray(BOOL bTraySetting)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    // This function will NEVER be called if the auto tray is disabled by policy,
    // or if the system tray is made invisible by policy...
    ASSERT(m_TrayItemRegistry.IsNoAutoTrayPolicyEnabled() == FALSE);

    if (bTraySetting != m_TrayItemRegistry.IsAutoTrayEnabledByUser())
    {
        // NOTENOTE : Always assign this value BEFORE calling _ToggleTrayItems, since the timers
        // are started ONLY if auto tray is enabled..
        m_TrayItemRegistry.SetIsAutoTrayEnabledInRegistry(bTraySetting); 

        // Update the duration that the icon was present in the tray
        _SetUsedTime();

        _ToggleTrayItems(bTraySetting);
    }
    return S_OK;
}

void CTrayNotify::_ShowChevronInfoTip()
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    if (m_TrayItemRegistry.ShouldChevronInfoTipBeShown() && !SHRestricted(REST_NOSMBALLOONTIP))
    {
        TCHAR szInfoTitle[64];
        LoadString(hinstCabinet, IDS_BANGICONINFOTITLE, szInfoTitle, ARRAYSIZE(szInfoTitle));

        TCHAR szInfoTip[256];
        LoadString(hinstCabinet, IDS_BANGICONINFOTIP1, szInfoTip, ARRAYSIZE(szInfoTip));

        _SetInfoTip(_hwndNotify, UID_CHEVRONBUTTON, szInfoTip, szInfoTitle, 
                TT_CHEVRON_INFOTIP_INTERVAL, NIIF_INFO, FALSE);
    }
}

void CTrayNotify::_SetUsedTime()
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    for (INT_PTR i = m_TrayItemManager.GetItemCount()-1; i >= 0; i--)
    {
        CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(i);
        ASSERT(pti);
        if (pti->IsStartupIcon())
        {
            pti->uNumSeconds = (pti->IsIconTimerCurrent() ? _GetAccumulatedTime(pti) 
                                : pti->uNumSeconds);
        }
    }
}

BOOL CTrayNotify::GetTrayItemCB(INT_PTR nIndex, void *pCallbackData, TRAYCBARG trayCallbackArg, 
        TRAYCBRET * pOutData)
{
    ASSERT(pOutData);

    if (pCallbackData)
    {
        CTrayNotify * pTrayNotify = (CTrayNotify *) pCallbackData;

        ASSERT(!pTrayNotify->_fNoTrayItemsDisplayPolicyEnabled);

        if ( (nIndex < 0) || (nIndex >= pTrayNotify->m_TrayItemManager.GetItemCount()) )
            return FALSE;

        switch(trayCallbackArg)
        {
            case TRAYCBARG_ALL:
            case TRAYCBARG_PTI:
                {
                    CTrayItem * pti = pTrayNotify->m_TrayItemManager.GetItemDataByIndex(nIndex);

                    ASSERT(pti);
                    if (pti->IsStartupIcon())
                        pti->uNumSeconds = (pti->IsIconTimerCurrent() ? pTrayNotify->_GetAccumulatedTime(pti) : pti->uNumSeconds);

                    pOutData->pti = pti;
                }
                if (trayCallbackArg == TRAYCBARG_PTI)
                {
                    return TRUE;
                }
                //
                // else fall through..
                //

            case TRAYCBARG_HICON:
                {
                    int nImageIndex = pTrayNotify->m_TrayItemManager.GetTBBtnImage(nIndex);
                    pOutData->hIcon = NULL;
                    if (pTrayNotify->_himlIcons)
                    {
                        pOutData->hIcon = ImageList_GetIcon(pTrayNotify->_himlIcons, nImageIndex, ILD_NORMAL);
                    }
                }
                return TRUE;
        }
    }

    return FALSE;
}

LRESULT CTrayNotify::_Create(HWND hWnd)
{
    LRESULT lres = -1;

    _nMaxHorz = 0x7fff;
    _nMaxVert = 0x7fff;
    _fAnimateMenuOpen       = ShouldTaskbarAnimate();
    _fRedraw                = TRUE;
    _bStartupIcon           = TRUE;
    _fInfoTipShowing        = FALSE;
    _fItemClicked           = FALSE;
    _fChevronSelected       = FALSE;
    _fEnableUserTrackedInfoTips = TRUE;
    _fBangMenuOpen          = FALSE;

    _bWorkStationLocked     = FALSE;
    _bRudeAppLaunched       = FALSE;
    _bWaitAfterRudeAppHide  = FALSE;

    _bWaitingBetweenBalloons   = FALSE;

     // Assume that the start menu has been auto-popped
    _bStartMenuAllowsTrayBalloon       = FALSE;
    _beLastBalloonEvent     = BALLOONEVENT_NONE;

    _litsLastInfoTip        = LITS_BALLOONNONE;

    _fNoTrayItemsDisplayPolicyEnabled = (SHRestricted(REST_NOTRAYITEMSDISPLAY) != 0);
    
    _idMouseActiveIcon      = -1;

    _hwndNotify = hWnd;
    _hwndClock   = ClockCtl_Create(_hwndNotify, IDC_CLOCK, hinstCabinet);

    _hwndPager = CreateWindowEx(0, WC_PAGESCROLLER, NULL,
                        WS_CHILD | WS_TABSTOP | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | PGS_HORZ,
                        0, 0, 0, 0, _hwndNotify, (HMENU) 0, 0, NULL);
    _hwndToolbar = CreateWindowEx(WS_EX_TOOLWINDOW, TOOLBARCLASSNAME, NULL,
                        WS_VISIBLE | WS_CHILD | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | WS_CLIPCHILDREN | TBSTYLE_TRANSPARENT |
                        WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | TBSTYLE_WRAPABLE,
                        0, 0, 0, 0, _hwndPager, 0, hinstCabinet, NULL);
                        
    _hwndChevron = CreateWindowEx(  0, WC_BUTTON, NULL, 
                        WS_VISIBLE | WS_CHILD, 
                        0, 0, 0, 0, _hwndNotify, (HMENU)IDC_TRAYNOTIFY_CHEVRON, hinstCabinet, NULL);

    if (_hwndNotify)
    {
        DWORD dwExStyle = 0;
        if (IS_WINDOW_RTL_MIRRORED(_hwndNotify))
            dwExStyle |= WS_EX_LAYOUTRTL;

        _hwndChevronToolTip = CreateWindowEx( dwExStyle, TOOLTIPS_CLASS, NULL,
                                WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
                                0, 0, 0, 0, _hwndNotify, NULL, hinstCabinet, NULL);

        _hwndInfoTip = CreateWindowEx( dwExStyle, TOOLTIPS_CLASS, NULL,
                                WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP | TTS_BALLOON | TTS_CLOSE,
                                0, 0, 0, 0, _hwndNotify, NULL, hinstCabinet, NULL);

        _himlIcons = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
                                        SHGetImageListFlags(_hwndToolbar), 0, 1);
    }

    // Check to see if any windows failed to create, if so bail
    if (_himlIcons && _hwndNotify && _hwndClock && _hwndToolbar && _hwndPager && _hwndChevron && _hwndChevronToolTip && _hwndInfoTip)
    {
        // Get the explorer exe name, the complete launch path..
        if (!SUCCEEDED(SHExeNameFromHWND(_hwndNotify, _szExplorerExeName, ARRAYSIZE(_szExplorerExeName))))
        {
            _szExplorerExeName[0] = TEXT('\0');
        }

        SetWindowTheme(_hwndClock, c_wzTrayNotifyTheme, NULL);

        SendMessage(_hwndInfoTip, TTM_SETWINDOWTHEME, 0, (LPARAM)c_wzTrayNotifyTheme);
        SendMessage(_hwndToolbar, TB_SETWINDOWTHEME, 0, (LPARAM)c_wzTrayNotifyTheme);

        SetWindowPos(_hwndInfoTip, HWND_TOPMOST,
                     0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

        TOOLINFO ti = {0};
        RECT     rc = {0,-2,0,0};
        ti.cbSize = sizeof(ti);
        ti.hwnd = _hwndNotify;
        ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT;
        ti.uId = (UINT_PTR)_hwndNotify;

        // set the version so we can have non buggy mouse event forwarding
        SendMessage(_hwndInfoTip, CCM_SETVERSION, COMCTL32_VERSION, 0);
        SendMessage(_hwndInfoTip, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
        SendMessage(_hwndInfoTip, TTM_SETMAXTIPWIDTH, 0, (LPARAM)MAX_TIP_WIDTH);
        SendMessage(_hwndInfoTip, TTM_SETMARGIN, 0, (LPARAM)&rc);
        ASSERT(_dpaInfo == NULL);
        _dpaInfo = DPA_Create(10);
    
        // Tray toolbar is a child of the pager control
        SendMessage(_hwndPager, PGM_SETCHILD, 0, (LPARAM)_hwndToolbar);
        
        // Set the window title to help out accessibility apps
        TCHAR szTitle[64];
        LoadString(hinstCabinet, IDS_TRAYNOTIFYTITLE, szTitle, ARRAYSIZE(szTitle));
        SetWindowText(_hwndToolbar, szTitle);

        // Toolbar settings - customize the tray toolbar...
        SendMessage(_hwndToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
        SendMessage(_hwndToolbar, TB_SETPADDING, 0, MAKELONG(2, 2));
        SendMessage(_hwndToolbar, TB_SETMAXTEXTROWS, 0, 0);
        SendMessage(_hwndToolbar, CCM_SETVERSION, COMCTL32_VERSION, 0);
        SendMessage(_hwndToolbar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_INVERTIBLEIMAGELIST | TBSTYLE_EX_DOUBLEBUFFER | TBSTYLE_EX_TOOLTIPSEXCLUDETOOLBAR);
        SendMessage(_hwndToolbar, TB_SETIMAGELIST, 0, (LPARAM)_himlIcons);

        _hwndToolbarInfoTip = (HWND)SendMessage(_hwndToolbar, TB_GETTOOLTIPS, 0, 0);
        if (_hwndToolbarInfoTip)
        {
            SHSetWindowBits(_hwndToolbarInfoTip, GWL_STYLE, TTS_ALWAYSTIP, TTS_ALWAYSTIP);
            SetWindowZorder(_hwndToolbarInfoTip, HWND_TOPMOST);
        }

        // if this fails, not that big a deal... we'll still show, but won't handle clicks
        SetWindowSubclass(_hwndToolbar, s_ToolbarWndProc, 0, reinterpret_cast<DWORD_PTR>(this));

        ti.cbSize = sizeof(ti);
        ti.hwnd = _hwndNotify;
        ti.uFlags = TTF_IDISHWND | TTF_EXCLUDETOOLAREA;
        ti.uId = (UINT_PTR)_hwndChevron;
        ti.lpszText = (LPTSTR)MAKEINTRESOURCE(IDS_SHOWDEMOTEDTIP);
        ti.hinst = hinstCabinet;

        SetWindowZorder(_hwndChevronToolTip, HWND_TOPMOST);
        // Set the Chevron as the tool for the tooltip
        SendMessage(_hwndChevronToolTip, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);

        // Subclass the Chevron button, so we can forward mouse messages to the tooltip
        SetWindowSubclass(_hwndChevron, ChevronSubClassWndProc, 0, reinterpret_cast<DWORD_PTR>(this));

        _OpenTheme();

        m_TrayItemRegistry.InitRegistryValues(SHGetImageListFlags(_hwndToolbar));

        m_TrayItemManager.SetTrayToolbar(_hwndToolbar);
        m_TrayItemManager.SetIconList(_himlIcons);

        lres = 0; // Yeah we succeeded
    }

    return lres;
}


LRESULT CTrayNotify::_Destroy()
{
    if (!_fNoTrayItemsDisplayPolicyEnabled)
    {
        for (INT_PTR i = m_TrayItemManager.GetItemCount() - 1; i >= 0; i--)
        {
            _DeleteNotify(i, TRUE, TRUE);
        }
        if (_pinfo)
        {
            delete _pinfo;
            _pinfo = NULL;
        }    
    }
    else
    {
        AssertMsg((_pinfo == NULL), TEXT("_pinfo is being leaked"));
        AssertMsg((!_himlIcons || (ImageList_GetImageCount(_himlIcons) == 0)), TEXT("image list info being leaked"));
    }

    if (_dpaInfo)
    {
        _dpaInfo.DestroyCallback(DeleteDPAPtrCB, NULL);
    }
    
    if (_himlIcons)
    {
        ImageList_Destroy(_himlIcons);
        _himlIcons = NULL;
    }
    
    if (_hwndClock)
    {
        DestroyWindow(_hwndClock);
        _hwndClock = NULL;
    }
    
    if (_hwndToolbar)
    {
        RemoveWindowSubclass(_hwndToolbar, s_ToolbarWndProc, 0);
        DestroyWindow(_hwndToolbar);
        _hwndToolbar = NULL;
    }
    
    if (_hwndChevron)
    {
        RemoveWindowSubclass(_hwndChevron, ChevronSubClassWndProc, 0);
        DestroyWindow(_hwndChevron);
        _hwndChevron = NULL;
    }
    
    if (_hwndInfoTip)
    {
        DestroyWindow(_hwndInfoTip);
        _hwndInfoTip = NULL;
    }
    
    if (_hwndPager)
    {
        DestroyWindow(_hwndPager);
        _hwndPager = NULL;
    }
    
    if (_hTheme)
    {
        CloseThemeData(_hTheme);
        _hTheme = NULL;
    }

    if (_hwndChevronToolTip)
    {
        DestroyWindow(_hwndChevronToolTip);
        _hwndChevronToolTip = NULL;
    }

    if (_pszCurrentThreadDesktopName)
    {
        LocalFree(_pszCurrentThreadDesktopName);
    }

    // Takes care of clearing up registry-related data
    m_TrayItemRegistry.Delete();

    return 0;
}

LRESULT CTrayNotify::_Paint(HDC hdcIn)
{
    PAINTSTRUCT ps;
    HDC hPaintDC = NULL;
    HDC hMemDC = NULL;
    HBITMAP hMemBm = NULL, hOldBm = NULL;

    if (hdcIn)
    {
        hPaintDC = hdcIn;
        GetClipBox(hPaintDC, &ps.rcPaint);
    }
    else
    {
        BeginPaint(_hwndNotify, &ps);

        if (_fRedraw)
        {
            // Create memory surface and map rendering context if double buffering
            // Only make large enough for clipping region
            hMemDC = CreateCompatibleDC(ps.hdc);
            if (hMemDC)
            {
                hMemBm = CreateCompatibleBitmap(ps.hdc, RECTWIDTH(ps.rcPaint), RECTHEIGHT(ps.rcPaint));
                if (hMemBm)
                {
                    hOldBm = (HBITMAP) SelectObject(hMemDC, hMemBm);

                    // Offset painting to paint in region
                    OffsetWindowOrgEx(hMemDC, ps.rcPaint.left, ps.rcPaint.top, NULL);
                    hPaintDC = hMemDC;
                }
                else
                {
                    DeleteDC(hMemDC);
                    hPaintDC = NULL;                
                }
            }
        }
        else
        {
            _fRepaint = TRUE;
            hPaintDC = NULL;
        }
    }
    
    if (hPaintDC)
    {
        RECT rc;
        GetClientRect(_hwndNotify, &rc);

        if (_hTheme)
        {
            SHSendPrintRect(GetParent(_hwnd), _hwnd, hPaintDC, &ps.rcPaint);
            
            if (_fAnimating)
            {
                if (_fVertical)
                {
                    rc.top  = rc.bottom - _rcAnimateCurrent.bottom;
                }
                else
                {
                    rc.left = rc.right - _rcAnimateCurrent.right;
                }
            }

            DrawThemeBackground(_hTheme, hPaintDC, TNP_BACKGROUND, 0, &rc, 0);

            if (_fHasFocus)
            {
                LRESULT lRes = SendMessage(_hwndChevron, WM_QUERYUISTATE, 0, 0);
                if (!(LOWORD(lRes) & UISF_HIDEFOCUS))
                {
                    RECT rcFocus = {0};
                    GetClientRect(_hwndChevron, &rcFocus);
                    MapWindowRect(_hwndChevron, _hwndNotify, &rcFocus);
                    // InflateRect(&rcFocus, 2, 2);
                    DrawFocusRect(hPaintDC, &rcFocus);
                }
            }

        }
        else
        {
            FillRect(hPaintDC, &rc, (HBRUSH)(COLOR_3DFACE + 1));
        }
    }

    if (!hdcIn)
    {
        if (hMemDC)
        {
            BitBlt(ps.hdc, ps.rcPaint.left, ps.rcPaint.top, RECTWIDTH(ps.rcPaint), RECTHEIGHT(ps.rcPaint), hMemDC, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);

            SelectObject(hMemDC, hOldBm);

            DeleteObject(hMemBm);
            DeleteDC(hMemDC);
        }

        EndPaint(_hwndNotify, &ps);
    }

    return 0;
}

LRESULT CTrayNotify::_HandleCustomDraw(LPNMCUSTOMDRAW pcd)
{
    LRESULT lres = CDRF_DODEFAULT;

    // If this policy is enabled, the chevron should NEVER be shown, and if it is not
    // shown, no question about its WM_NOTIFY message handler...
    // ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    if (_fNoTrayItemsDisplayPolicyEnabled)
    {
        return lres;
    }
    else if (!_hTheme)
    {
        switch (pcd->dwDrawStage)
        {
        case CDDS_PREERASE:
            {
                DWORD dwFlags = 0;
                if (pcd->uItemState & CDIS_HOT)
                {
                    // The chevron is under the pointer, hence the item is hot
                    _fChevronSelected = TRUE;
                    dwFlags |= DCHF_HOT;
                }
                if (!_fVertical)
                {
                    dwFlags |= DCHF_HORIZONTAL;
                }
                if ((!_fBangMenuOpen && _fVertical) || (_fBangMenuOpen && !_fVertical))
                {
                    dwFlags |= DCHF_FLIPPED;
                }
                if (pcd->uItemState & CDIS_FOCUS)
                {
                    if (_fChevronSelected)
                        dwFlags |= DCHF_HOT;
                }

                if (!(pcd->uItemState & CDIS_FOCUS || pcd->uItemState & CDIS_HOT))
                {
                    _fChevronSelected = FALSE;
                }

                DrawChevron(pcd->hdc, &(pcd->rc), dwFlags);
                lres = CDRF_SKIPDEFAULT;
            }
            break;
        }
    }

    return lres;
}

void CTrayNotify::_SizeWindows(int nMaxHorz, int nMaxVert, LPRECT prcTotal, BOOL fSizeWindows)
{
    RECT rcClock, rcPager, rcChevron;
    SIZE szNotify;
    RECT rcBound = { 0, 0, nMaxHorz, nMaxVert };
    RECT rcBorder = rcBound;

    rcChevron.left = rcChevron.top = 0;
    rcChevron.right = !_fNoTrayItemsDisplayPolicyEnabled && _fHaveDemoted ? _szChevron.cx : 0;
    rcChevron.bottom = !_fNoTrayItemsDisplayPolicyEnabled && _fHaveDemoted ? _szChevron.cy : 0;

    if (_hTheme)
    {
        GetThemeBackgroundContentRect(_hTheme, NULL, TNP_BACKGROUND, 0, &rcBound, &rcBorder);
    }
    else
    {
        rcBorder.top += g_cyBorder;
        rcBorder.left += g_cxBorder;
        rcBorder.bottom -= g_cyBorder + 2;
        rcBorder.right -= g_cxBorder + 2;
    }

    static LRESULT s_lRes = 0;
    static int s_nMaxVert = -1;
    if (s_nMaxVert != nMaxVert)
    {
        s_lRes = SendMessage(_hwndClock, WM_CALCMINSIZE, nMaxHorz, nMaxVert);
    }
    rcClock.left = rcClock.top = 0;
    rcClock.right = LOWORD(s_lRes);
    rcClock.bottom = HIWORD(s_lRes);

    szNotify.cx = RECTWIDTH(rcBorder);
    szNotify.cy = RECTHEIGHT(rcBorder);
    SendMessage(_hwndToolbar, TB_GETIDEALSIZE, _fVertical, (LPARAM)&szNotify);

    if (_fVertical)
    {
        int cxButtonSize = LOWORD(SendMessage(_hwndToolbar, TB_GETBUTTONSIZE, 0, 0));
        szNotify.cx -= szNotify.cx % (cxButtonSize ? cxButtonSize : 16);

        // Vertical Taskbar, place the clock on the bottom and icons on the top
        rcChevron.left = rcClock.left = rcBorder.left;
        rcChevron.right = rcClock.right = rcBorder.right;
        rcPager.left = (RECTWIDTH(rcBorder) - szNotify.cx) / 2 + rcBorder.left;
        rcPager.right = rcPager.left + szNotify.cx;
        if (_hTheme)
        {
            rcChevron.left = (nMaxHorz - _szChevron.cx) / 2;
            rcChevron.right = rcChevron.left + _szChevron.cx;
        }
        prcTotal->left = 0;
        prcTotal->right = nMaxHorz;

        // If Notification Icons take up more space than available then just set them to the maximum available size
        int cyTemp = max(rcChevron.bottom, rcBorder.top);
        int cyTotal = cyTemp + rcClock.bottom + (nMaxVert - rcBorder.bottom);
        rcPager.top = 0;
        rcPager.bottom = min(szNotify.cy, nMaxVert - cyTemp);
        
        OffsetRect(&rcPager, 0, cyTemp);
        OffsetRect(&rcClock, 0, rcPager.bottom);

        prcTotal->top = 0;
        prcTotal->bottom = rcClock.bottom + (nMaxVert - rcBorder.bottom);
    }
    else
    {
        int cyButtonSize = HIWORD(SendMessage(_hwndToolbar, TB_GETBUTTONSIZE, 0, 0));
        szNotify.cy -= szNotify.cy % (cyButtonSize ? cyButtonSize : 16);

        // Horizontal Taskbar, place the clock on the right and icons on the left
        rcChevron.top = rcClock.top = rcBorder.top;
        rcChevron.bottom = rcClock.bottom = rcBorder.bottom;
        rcPager.top = ((RECTHEIGHT(rcBorder) - szNotify.cy) / 2) + rcBorder.top;
        rcPager.bottom = rcPager.top + szNotify.cy;
        if (_hTheme)
        {
            rcChevron.top = ((RECTHEIGHT(rcBorder) - _szChevron.cy) / 2) + rcBorder.top;
            rcChevron.bottom = rcChevron.top + _szChevron.cy;
        }
        prcTotal->top    = 0;
        prcTotal->bottom = nMaxVert;

        // If Notification Icons take up more space than available then just set them to the maximum available size
        int cxTemp = max(rcChevron.right, rcBorder.left);
        int cxTotal = cxTemp + rcClock.right + (nMaxHorz - rcBorder.right);
        rcPager.left = 0;
        rcPager.right = min(szNotify.cx, nMaxHorz - cxTemp);
        
        OffsetRect(&rcPager, cxTemp, 0);
        OffsetRect(&rcClock, rcPager.right, 0);

        prcTotal->left = 0;
        prcTotal->right = rcClock.right + (nMaxHorz - rcBorder.right);
    }

    if (fSizeWindows)
    {
        if (_fAnimating)
        {
            RECT rcWin;
            GetWindowRect(_hwndNotify, &rcWin);
            int offsetX = _fVertical ? 0: RECTWIDTH(rcWin) - RECTWIDTH(*prcTotal);
            int offsetY = _fVertical ? RECTHEIGHT(rcWin) - RECTHEIGHT(*prcTotal) : 0;
            OffsetRect(&rcClock, offsetX, offsetY);
            OffsetRect(&rcPager, offsetX, offsetY);
            OffsetRect(&rcChevron, offsetX, offsetY);
        }

        SetWindowPos(_hwndClock,   NULL, rcClock.left,   rcClock.top,   RECTWIDTH(rcClock),   RECTHEIGHT(rcClock),   SWP_NOZORDER);
        SetWindowPos(_hwndToolbar, NULL, 0,              0,             szNotify.cx,          szNotify.cy,           SWP_NOZORDER | SWP_NOCOPYBITS);
        SetWindowPos(_hwndPager,   NULL, rcPager.left,   rcPager.top,   RECTWIDTH(rcPager),   RECTHEIGHT(rcPager),   SWP_NOZORDER | SWP_NOCOPYBITS);
        SetWindowPos(_hwndChevron, NULL, rcChevron.left, rcChevron.top, RECTWIDTH(rcChevron), RECTHEIGHT(rcChevron), SWP_NOZORDER | SWP_NOCOPYBITS);

        SendMessage(_hwndPager, PGMP_RECALCSIZE, (WPARAM) 0, (LPARAM) 0);
    }

    if (_fAnimating)
    {
        _rcAnimateCurrent = *prcTotal;
        *prcTotal = _rcAnimateTotal;
    }

    if (fSizeWindows)
    {
        RECT rcInvalid = *prcTotal;
        if (_fVertical)
        {
            rcInvalid.bottom = rcPager.bottom;
        }
        else
        {
            rcInvalid.right = rcPager.right;
        }
        InvalidateRect(_hwndNotify, &rcInvalid, FALSE);
        UpdateWindow(_hwndNotify);
    }
}

LRESULT CTrayNotify::_CalcMinSize(int nMaxHorz, int nMaxVert)
{
    RECT rcTotal;

    _nMaxHorz = nMaxHorz;
    _nMaxVert = nMaxVert;

    if (!(GetWindowLong(_hwndClock, GWL_STYLE) & WS_VISIBLE) && !m_TrayItemManager.GetItemCount()) 
    {
        // If we are visible, but have nothing to show, then hide ourselves
        ShowWindow(_hwndNotify, SW_HIDE);
        return 0L;
    } 
    else if (!IsWindowVisible(_hwndNotify))
    {
        ShowWindow(_hwndNotify, SW_SHOW);
    }

    _SizeWindows(nMaxHorz, nMaxVert, &rcTotal, FALSE);

    // Add on room for borders
    return(MAKELRESULT(rcTotal.right, rcTotal.bottom));
}

LRESULT CTrayNotify::_Size()
{
    RECT rcTotal;
    // use GetWindowRect because _SizeWindows includes the borders
    GetWindowRect(_hwndNotify, &rcTotal);
    // Account for borders on the left and right
    _SizeWindows(RECTWIDTH(rcTotal), RECTHEIGHT(rcTotal), &rcTotal, TRUE);

    return(0);
}

void CTrayNotify::_OnInfoTipTimer()
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    _KillTimer(TF_INFOTIP_TIMER, _uInfoTipTimer);
    _uInfoTipTimer = 0;
    if (_pinfo)
    {
        _beLastBalloonEvent = BALLOONEVENT_TIMEOUT;
        _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONTIMEOUT); // hide this balloon and show new one
    }
}

LRESULT CTrayNotify::_OnTimer(UINT_PTR uTimerID)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    if (uTimerID == TID_DEMOTEDMENU)
    {
        if (_fBangMenuOpen)
            _ToggleDemotedMenu();
    }
    else if (uTimerID == TID_BALLOONPOP)
    {
        // When the user clicks the 'X' to close a balloon tip, this timer is set.
        // Ensure that the currently showing balloon tip (the one on which the user
        // clicked the 'X') is completely hidden, before showing the next balloon in
        // the queue.
        // 
        // Tooltips are layered windows, and comctl32 implements a fadeout effect on
        // them. So there is a time period during which a tooltip is still visible
        // after it has been asked to be deleted/hidden.
        if (IsWindowVisible(_hwndInfoTip))
        {
            SetTimer(_hwndNotify, TID_BALLOONPOP, TT_BALLOONPOP_INTERVAL_INCREMENT, NULL);
        }
        else
        {
            KillTimer(_hwndNotify, TID_BALLOONPOP);
            if (_pinfo)
            {
                _beLastBalloonEvent = BALLOONEVENT_USERXCLICK;
                _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONTIMEOUT);
            }
            // This is called only when the user has clicked the 'X'.
            _litsLastInfoTip = LITS_BALLOONXCLICKED;
        }
    }
    else if (uTimerID == TID_BALLOONPOPWAIT)
    {
        KillTimer(_hwndNotify, TID_BALLOONPOPWAIT);
        _bWaitingBetweenBalloons = FALSE;
        if (_pinfo)
        {
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, TRUE, 0);
        }
    }
    else if (uTimerID == TID_BALLOONSHOW)
    {
        KillTimer(_hwndNotify, TID_BALLOONSHOW);

        _bStartMenuAllowsTrayBalloon = TRUE;
        if (_pinfo)
        {
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, TRUE, NIN_BALLOONSHOW);
        }
    }
    else if (uTimerID == TID_RUDEAPPHIDE)
    {
        KillTimer(_hwndNotify, TID_RUDEAPPHIDE);

        if (_pinfo && _bWaitAfterRudeAppHide)
        {
            _bWaitAfterRudeAppHide = FALSE;
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, TRUE, NIN_BALLOONSHOW);            
        }

        _bWaitAfterRudeAppHide = FALSE;
    }
    else
    {
        AssertMsg(FALSE, TEXT("CTrayNotify::_OnTimer() not possible"));
    }

    return 0;
}

BOOL _IsClickDown(UINT uMsg)
{
    switch (uMsg)
    {
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_LBUTTONDBLCLK:
    case WM_MBUTTONDBLCLK:
    case WM_RBUTTONDBLCLK:
        return TRUE;
    }
    return FALSE;
}

BOOL _UseCachedIcon(UINT uMsg)
{
    switch (uMsg)
    {
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_MOUSEMOVE:
    case WM_MOUSEWHEEL:
        return FALSE;
    }
    return TRUE;
}

LRESULT CTrayNotify::_OnMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Icons can jump around between the time we get a down-click message and
    // the time we get a double-click or up-click message.  E.g. clicking on
    // the bang icon expands the hidden stuff, or an icon might delete itself
    // in response to the down-click.
    //
    // It's undesirable for a different icon to get the corresponding double-
    // or up-click in this case (very annoying to the user).
    //
    // To deal with this, cache the icon down-clicked and use that cached value
    // (instead of the button the mouse is currently over) on double- or up-click.


    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    // The mouse cursor has moved over the toolbar, so if the chevron was selected
    // earlier, it should not be anymore.
    _fChevronSelected = FALSE;

    BOOL fClickDown = _IsClickDown(uMsg);
    BOOL fUseCachedIcon = _UseCachedIcon(uMsg);

    INT_PTR i = -1;

    if (fUseCachedIcon)
    {
        i = ToolBar_CommandToIndex(_hwndToolbar, _idMouseActiveIcon);
    }

    if (i == -1)
    {
        POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
        i = SendMessage(_hwndToolbar, TB_HITTEST, 0, (LPARAM)&pt);
        if (fClickDown)
            _idMouseActiveIcon = ToolBar_IndexToCommand(_hwndToolbar, i);
    }

    CTrayItem *pti = m_TrayItemManager.GetItemDataByIndex(i);
    if (pti) 
    {
        if (IsWindow(pti->hWnd)) 
        {
            if (fClickDown) 
            {
                SHAllowSetForegroundWindow(pti->hWnd);

                if (_pinfo && _pinfo->hWnd == pti->hWnd && _pinfo->uID == pti->uID)
                {
                    if (uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONDBLCLK)
                        _beLastBalloonEvent = BALLOONEVENT_USERRIGHTCLICK;
                    else
                        _beLastBalloonEvent = BALLOONEVENT_USERLEFTCLICK;
                    _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONUSERCLICK);
                }

                if (fClickDown)
                {
                    // down clicks count as activation
                    _PlaceItem(i, pti, TRAYEVENT_ONITEMCLICK);
                }
                
                _fItemClicked = TRUE;
                _ActivateTips(FALSE);
            }
                
            _SendNotify(pti, uMsg);
        } 
        else 
        {
            _DeleteNotify(i, FALSE, TRUE);
        }
        return 1;
    }
    return 0;
}

LRESULT CTrayNotify::_OnCDNotify(LPNMTBCUSTOMDRAW pnm)
{
    switch (pnm->nmcd.dwDrawStage)
    {
        case CDDS_PREPAINT:
            return CDRF_NOTIFYITEMDRAW;
        
        case CDDS_ITEMPREPAINT:
        {
            LRESULT lRet = TBCDRF_NOOFFSET;

            // notify us for the hot tracked item please
            if (pnm->nmcd.uItemState & CDIS_HOT)
                lRet |= CDRF_NOTIFYPOSTPAINT;

            // we want the buttons to look totally flat all the time
            pnm->nmcd.uItemState = 0;

            return  lRet;
        }

        case CDDS_ITEMPOSTPAINT:
        {
            // draw the hot tracked item as a focus rect, since
            // the tray notify area doesn't behave like a button:
            //   you can SINGLE click or DOUBLE click or RCLICK
            //   (kybd equiv: SPACE, ENTER, SHIFT F10)
            //
            LRESULT lRes = SendMessage(_hwndNotify, WM_QUERYUISTATE, 0, 0);
            if (!(LOWORD(lRes) & UISF_HIDEFOCUS) && _hwndToolbar == GetFocus())
            {
                DrawFocusRect(pnm->nmcd.hdc, &pnm->nmcd.rc);
            }
            break;
        }
    }

    return CDRF_DODEFAULT;
}

LRESULT CTrayNotify::_Notify(LPNMHDR pNmhdr)
{
    LRESULT lRes = 0;
    switch (pNmhdr->code)
    {
    case TTN_POP:               // a balloontip/tooltip is about to be hidden...
        if (pNmhdr->hwndFrom == _hwndInfoTip)
        {
            // If this infotip was hidden by means other than the user click on the
            // 'X', the code path sets _litsLastInfoTip to LITS_BALLOONDESTROYED
            // before the infotip is to be hidden...
            //
            // If _litsLastInfoTip is not set to LITS_BALLOONDESTROYED, the infotip
            // was deleted by the user click on the 'X' (that being the only other
            // way to close the infotip). comctl32 sends us a TTN_POP *before* it 
            // hides the infotip. Don't set the next infotip to show immediately.
            // (The hiding code would then hide the infotip for the next tool, since the
            // hwnds are the same). Set a timer in this case, and show the
            // next infotip, after ensuring that the current one is truly hidden...
            if ( (_litsLastInfoTip == LITS_BALLOONXCLICKED) ||
                 (_litsLastInfoTip == LITS_BALLOONNONE) )
            {
                _KillTimer(TF_INFOTIP_TIMER, _uInfoTipTimer);
                SetTimer(_hwndNotify, TID_BALLOONPOP, TT_BALLOONPOP_INTERVAL, NULL);
            }
            _litsLastInfoTip = LITS_BALLOONXCLICKED;
        }
        break;

    case NM_KEYDOWN:
        _fKey = TRUE;
        break;

    case TBN_ENDDRAG:
        _fKey = FALSE;
        break;

    case TBN_DELETINGBUTTON:
        {
            ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
            TBNOTIFY* ptbn = (TBNOTIFY*)pNmhdr;
            CTrayItem *pti = (CTrayItem *)(void *)ptbn->tbButton.dwData;
            // can be null if its a blank button used for the animation
            if (pti)
            {
                //if it wasn't sharing an icon with another guy, go ahead and delete it
                if (!pti->IsIconShared()) 
                    _RemoveImage(ptbn->tbButton.iBitmap);

                delete pti;
            }
        }
        break;

    case BCN_HOTITEMCHANGE:
    case TBN_HOTITEMCHANGE:
        {
            ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
            DWORD dwFlags = (pNmhdr->code == BCN_HOTITEMCHANGE) ? ((LPNMBCHOTITEM)pNmhdr)->dwFlags : ((LPNMTBHOTITEM)pNmhdr)->dwFlags;

            if (dwFlags & HICF_LEAVING)
            {
                _fItemClicked = FALSE;
                _ActivateTips(TRUE);
            }
            
            if (_fBangMenuOpen)
            {
                if (dwFlags & HICF_LEAVING)
                {
                    //
                    // When hottracking moves between button and toolbar,
                    // we get the HICF_ENTERING for one before we get the
                    // HICF_LEAVING for the other.  So before setting the
                    // timer to hide the bang menu, we check to see if the
                    // other control has a hot item.
                    //
                    BOOL fOtherHot;
                    if (pNmhdr->code == BCN_HOTITEMCHANGE)
                    {
                        fOtherHot = (SendMessage(_hwndToolbar, TB_GETHOTITEM, 0, 0) != -1);
                    }
                    else
                    {
                        fOtherHot = BOOLIFY(SendMessage(_hwndChevron, BM_GETSTATE, 0, 0) & BST_HOT);
                    }

                    if (!fOtherHot)
                    {
                        SetTimer(_hwndNotify, TID_DEMOTEDMENU, TT_DEMOTEDMENU_INTERVAL, NULL);
                    }
                }
                else if (dwFlags & HICF_ENTERING)
                {
                    KillTimer(_hwndNotify, TID_DEMOTEDMENU);
                }
            }
        }
        break;

    case TBN_WRAPHOTITEM:
        {
            ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
            NMTBWRAPHOTITEM * pnmWrapHotItem = (NMTBWRAPHOTITEM *) pNmhdr;

            // If the user hit a key on the tray toolbar icon and it was the first 
            // visible item in the tray toolbar, then maybe we want to go to the 
            // chevron button...
            switch (pnmWrapHotItem->iDir)
            {
                // Left/Up
                case -1:
                    if (_fHaveDemoted)
                    {
                        SetFocus(_hwndChevron);
                        _fChevronSelected = TRUE;
                    }
                    else if (_hwndClock)
                    {
                        SetFocus(_hwndClock);
                        _fChevronSelected = FALSE;
                    }
                    else
                    // do nothing
                    {
                        _fChevronSelected = FALSE;
                    }
                    break;

                // Right/Down
                case 1:
                    if (_hwndClock)
                    {
                        SetFocus(_hwndClock);
                        _fChevronSelected = FALSE;
                    }
                    else if (_fHaveDemoted)
                    {
                        SetFocus(_hwndChevron);
                        _fChevronSelected = TRUE;
                    }
                    else
                    {
                        _fChevronSelected = FALSE;
                    }
                    break;
                }
                break;
        }
        break;

    // NOTENOTE: This notification DOESNT need to be checked. Pager forwards its notifications
    // to our child toolbar control, and TBN_HOTITEMCHANGE above handles this case..    
    case PGN_HOTITEMCHANGE:
        {
            LPNMTBHOTITEM pnmhot = (LPNMTBHOTITEM)pNmhdr;

            if  (pnmhot->dwFlags & HICF_LEAVING)
            {
                _fItemClicked = FALSE;
                _ActivateTips(TRUE);
            }
            
            if (_fBangMenuOpen)
            {
                if (pnmhot->dwFlags & HICF_LEAVING)
                {
                    SetTimer(_hwndNotify, TID_DEMOTEDMENU, TT_DEMOTEDMENU_INTERVAL, NULL);
                }
                else if (pnmhot->dwFlags & HICF_ENTERING)
                {
                    KillTimer(_hwndNotify, TID_DEMOTEDMENU);
                }
            }
        }
        break;

    case PGN_CALCSIZE:
        {
            LPNMPGCALCSIZE   pCalcSize = (LPNMPGCALCSIZE)pNmhdr;

            switch(pCalcSize->dwFlag)
            {
                case PGF_CALCWIDTH:
                {
                    //Get the optimum WIDTH of the toolbar.
                    RECT rcToolBar;
                    GetWindowRect(_hwndToolbar, &rcToolBar);
                    pCalcSize->iWidth = RECTWIDTH(rcToolBar);
                }
                break;

                case PGF_CALCHEIGHT:
                {
                    //Get the optimum HEIGHT of the toolbar.
                    RECT rcToolBar;
                    GetWindowRect(_hwndToolbar, &rcToolBar);
                    pCalcSize->iHeight = RECTHEIGHT(rcToolBar);
                }
                break;
            }
        }

    case NM_CUSTOMDRAW:
        if (pNmhdr->hwndFrom == _hwndChevron)
        {
            return _HandleCustomDraw((LPNMCUSTOMDRAW)pNmhdr);
        }
        else
        {
            return _OnCDNotify((LPNMTBCUSTOMDRAW)pNmhdr);
        }
        break;
    }

    return lRes;
}

void CTrayNotify::_OnSysChange(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    if (uMsg == WM_WININICHANGE)
    {
        _CheckAndResizeImages();
        if (lParam == SPI_SETMENUANIMATION || lParam == SPI_SETUIEFFECTS || (!wParam && 
            (!lParam || (lstrcmpi((LPTSTR)lParam, TEXT("Windows")) == 0))))
        {
            _fAnimateMenuOpen = ShouldTaskbarAnimate();
        }
    }

    if (_hwndClock)
        SendMessage(_hwndClock, uMsg, wParam, lParam);
}

void CTrayNotify::_OnCommand(UINT id, UINT uCmd)
{
    if (id == IDC_TRAYNOTIFY_CHEVRON)
    {
        AssertMsg(!_fNoTrayItemsDisplayPolicyEnabled, TEXT("Impossible-the chevron shouldnt be shown"));
        switch(uCmd)
        {
            case BN_SETFOCUS:
                break;

            default:
                _ToggleDemotedMenu();
                break;
        }
    }
    else
    {
        switch (uCmd)
        {
            case BN_CLICKED:
            {
                ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
                CTrayItem *pti = m_TrayItemManager.GetItemData(id, FALSE, _hwndToolbar);
                if (pti)
                {
                    if (_fKey)
                        _SetCursorPos(SendMessage(_hwndToolbar, TB_COMMANDTOINDEX, id, 0));

                    SHAllowSetForegroundWindow(pti->hWnd);
                    if (pti->uVersion >= KEYBOARD_VERSION)
                    {
                        // if they are a new version that understands the keyboard messages,
                        // send the real message to them.
                        _SendNotify(pti, _fKey ? NIN_KEYSELECT : NIN_SELECT);
                        // Hitting RETURN is like double-clicking (which in the new
                        // style means keyselecting twice)
                        if (_fKey && _fReturn)
                            _SendNotify(pti, NIN_KEYSELECT);
                    }
                    else
                    {
                        // otherwise mock up a mouse event if it was a keyboard select
                        // (if it wasn't a keyboard select, we assume they handled it already on
                        // the WM_MOUSE message
                        if (_fKey)
                        {
                            _SendNotify(pti, WM_LBUTTONDOWN);
                            _SendNotify(pti, WM_LBUTTONUP);
                            if (_fReturn)
                            {
                                _SendNotify(pti, WM_LBUTTONDBLCLK);
                                _SendNotify(pti, WM_LBUTTONUP);
                            }
                        }
                    }
                }
                break;
            }
        }
    }
}

void CTrayNotify::_OnSizeChanged(BOOL fForceRepaint)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    if (_pinfo)
    {
        // if balloon is up we have to move it, but we cannot straight up
        // position it because traynotify will be moved around by tray
        // so we do it async

        PostMessage(_hwndNotify, TNM_ASYNCINFOTIPPOS, 0, 0);
    }
    c_tray.VerifySize(TRUE);

    if (fForceRepaint)
        UpdateWindow(_hwndToolbar);
}

#define TT_ANIMATIONLENGTH  20    // sum of all the animation steps
#define TT_ANIMATIONPAUSE  30      // extra pause for last step

DWORD CTrayNotify::_GetStepTime(int iStep, int cSteps)
{
    // our requirements here are:
    //
    // - animation velocity should decrease linearly with time
    //
    // - total animation time should be a constant, TT_ANIMATIONLENGTH
    //   (it should not vary with number of icons)
    //
    // - figure this out without using floating point math
    //
    // hence the following formula
    //

    if (cSteps == 0)
    {
        return 0;
    }
    else if (iStep == cSteps && cSteps > 2)
    {
        return TT_ANIMATIONPAUSE;
    }
    else
    {
        int iNumerator = (TT_ANIMATIONLENGTH - cSteps) * iStep;
        int iDenominator = (cSteps + 1) * cSteps;

        return (iNumerator / iDenominator);
    }
}

void CTrayNotify::_ToggleDemotedMenu()
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    _ActivateTips(FALSE);

    int iAnimStep = 1;  // animation steps are 1-based
    int cNumberDemoted = (int) m_TrayItemManager.GetDemotedItemCount();

    if (_fAnimateMenuOpen)
    {
        if (!_fBangMenuOpen)
        {
            _BlankButtons(0, cNumberDemoted, TRUE);
        }

        GetWindowRect(_hwndNotify, &_rcAnimateTotal);
        _SizeWindows(_fVertical ? RECTWIDTH(_rcAnimateTotal) : _nMaxHorz, _fVertical ? _nMaxVert : RECTHEIGHT(_rcAnimateTotal), &_rcAnimateTotal, FALSE);

        if (!_fBangMenuOpen)
        {
            _BlankButtons(0, cNumberDemoted, FALSE); 
        }

        _fAnimating = TRUE;   // Begin Animation loop

        if (!_fBangMenuOpen)
        {
            _OnSizeChanged(TRUE);
        }
    }

    for (INT_PTR i = m_TrayItemManager.GetItemCount() - 1; i >= 0; i--)
    {
        CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(i);
        if (!pti->IsHidden() && pti->IsDemoted())
        {
            DWORD dwSleep = _GetStepTime(iAnimStep, cNumberDemoted);
            iAnimStep++;

            if (_fBangMenuOpen)
            {
                m_TrayItemManager.SetTBBtnStateHelper(i, TBSTATE_HIDDEN, TRUE);
            }

            if (_fAnimateMenuOpen)
            {
                _AnimateButtons((int) i, dwSleep, cNumberDemoted, !_fBangMenuOpen);
            }

            if (!_fBangMenuOpen)
            {
                m_TrayItemManager.SetTBBtnStateHelper(i, TBSTATE_HIDDEN, FALSE);
            }

            if (_fAnimateMenuOpen)
            {
                _SizeWindows(_fVertical ? RECTWIDTH(_rcAnimateTotal) : _nMaxHorz, _fVertical ? _nMaxVert : RECTHEIGHT(_rcAnimateTotal), &_rcAnimateTotal, TRUE);
            }
        }
    }

    _fAnimating = FALSE;   // End Animation loop

    if (_fBangMenuOpen)
    {
        KillTimer(_hwndNotify, TID_DEMOTEDMENU);
    }

    _ActivateTips(TRUE);
    _UpdateChevronState(!_fBangMenuOpen, FALSE, _fBangMenuOpen);
    _OnSizeChanged(TRUE);
}

void CTrayNotify::_BlankButtons(int iPos, int iNumberOfButtons, BOOL fAddButtons)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    BOOL fRedraw = _SetRedraw(FALSE);

    TBBUTTON tbb;
    tbb.dwData = NULL;
    tbb.iBitmap = -1;
    tbb.fsStyle = BTNS_BUTTON;
    tbb.iString = -1;
    tbb.fsState = TBSTATE_INDETERMINATE;
    
    for (int i = 0; i < iNumberOfButtons; i++)
    {
        if (fAddButtons)
        {
            tbb.idCommand = Toolbar_GetUniqueID(_hwndToolbar);
        }
        //insert all blank buttons at the front of the toolbar
        SendMessage(_hwndToolbar, fAddButtons ? TB_INSERTBUTTON : TB_DELETEBUTTON, iPos, fAddButtons ? (LPARAM)&tbb : 0);
    }

    _SetRedraw(fRedraw);
}

#define TT_ANIMATIONSTEP 3
#define TT_ANIMATIONSTEPBASE 100
#define TT_ANIMATIONWRAPPAUSE  25 // pause for no animation for row wraps

void CTrayNotify::_AnimateButtons(int iIndex, DWORD dwSleep, int iNumberItems, BOOL fGrow)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    BOOL fInSameRow = TRUE;

    _BlankButtons((int) iIndex, 1, TRUE);

    if ((iIndex + 2 < m_TrayItemManager.GetItemCount()) && (iIndex > 0))
    {
        RECT rcItem1, rcItem2;
        SendMessage(_hwndToolbar, TB_GETITEMRECT, fGrow ? iIndex + 2 : iIndex - 1, (LPARAM)&rcItem1);
        SendMessage(_hwndToolbar, TB_GETITEMRECT, iIndex, (LPARAM)&rcItem2);
        fInSameRow = (rcItem1.top == rcItem2.top);
    }

    if (fInSameRow)
    {
        // target width of button
        WORD wWidth = LOWORD(SendMessage(_hwndToolbar, TB_GETBUTTONSIZE, 0, 0));

        int iAnimationStep = (iNumberItems * iNumberItems) / TT_ANIMATIONSTEPBASE;
        iAnimationStep = max(iAnimationStep, TT_ANIMATIONSTEP);

        TBBUTTONINFO tbbi;
        tbbi.cbSize = sizeof(TBBUTTONINFO);
        tbbi.dwMask = TBIF_SIZE | TBIF_BYINDEX;

        // Set the size of the buttons
        for (WORD cx = 1; cx < wWidth; cx += (WORD) iAnimationStep) 
        {
            tbbi.cx = fGrow ? cx : wWidth - cx;
            SendMessage(_hwndToolbar, TB_SETBUTTONINFO, iIndex, (LPARAM) &tbbi);

            RECT rcBogus;
            _SizeWindows(_fVertical ? RECTWIDTH(_rcAnimateTotal) : _nMaxHorz, _fVertical ? _nMaxVert : RECTHEIGHT(_rcAnimateTotal), &rcBogus, TRUE);

            Sleep(dwSleep);
        }

        if (fGrow)
        {
            // set the grow button back to normal size
            tbbi.cx = 0;
            SendMessage(_hwndToolbar, TB_SETBUTTONINFO, iIndex, (LPARAM) &tbbi);
        }
    }

    _BlankButtons((int) iIndex, 1, FALSE);
}

BOOL CTrayNotify::_SetRedraw(BOOL fRedraw)
{
    BOOL fOldRedraw = _fRedraw;
    _fRedraw = fRedraw;

    SendMessage(_hwndToolbar, WM_SETREDRAW, fRedraw, 0);
    if (_fRedraw)
    {
        if (_fRepaint)
        {
            InvalidateRect(_hwndNotify, NULL, FALSE);
            UpdateWindow(_hwndNotify);
        }
    }
    else
    {
        _fRepaint = FALSE;
    }

    return fOldRedraw;
}

void CTrayNotify::_OnIconDemoteTimer(WPARAM wParam, LPARAM lParam)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    INT_PTR nIcon = m_TrayItemManager.FindItemAssociatedWithTimer(lParam);
    if (nIcon >= 0)
    {
        CTrayItem *pti = m_TrayItemManager.GetItemDataByIndex(nIcon);
        ASSERT(pti);

        _PlaceItem(nIcon, pti, TRAYEVENT_ONICONDEMOTETIMER);
    }
    else
    {
        // It looks like a timer for a now-defunct icon.  Go ahead and kill it.
        // Though we do handle this case, it's odd for it to happen, so spew a
        // warning.
        TraceMsg(TF_WARNING, "CTrayNotify::_OnIconDemoteTimer -- killing zombie timer %x", lParam);
        _KillTimer(TF_ICONDEMOTE_TIMER, (UINT) lParam);
    }
}

BOOL CTrayNotify::_UpdateTrayItems(BOOL bUpdateDemotedItems)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    BOOL bDemoteItemsOverThreshold = ( m_TrayItemRegistry.IsAutoTrayEnabled() ? 
                                       m_TrayItemManager.DemotedItemsPresent(MIN_DEMOTED_ITEMS_THRESHOLD) :
                                       FALSE );

    if (bUpdateDemotedItems || !m_TrayItemRegistry.IsAutoTrayEnabled())
    {
        _HideAllDemotedItems(bDemoteItemsOverThreshold);
    }

    return bDemoteItemsOverThreshold;
}

void CTrayNotify::_HideAllDemotedItems(BOOL bHide)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    for (INT_PTR i = m_TrayItemManager.GetItemCount()-1; i >= 0; i--)
    {
        CTrayItem * pti = m_TrayItemManager.GetItemDataByIndex(i);
        ASSERT(pti);

        if (!pti->IsHidden() && pti->IsDemoted() && (pti->dwUserPref == TNUP_AUTOMATIC))
        {
            m_TrayItemManager.SetTBBtnStateHelper(i, TBSTATE_HIDDEN, bHide);
        }
    }
}

BOOL CTrayNotify::_PlaceItem(INT_PTR nIcon, CTrayItem * pti, TRAYEVENT tTrayEvent)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    BOOL bDemoteStatusChange = FALSE;
    if (!pti)
        return bDemoteStatusChange;

    TRAYITEMPOS tiPos = _TrayItemPos(pti, tTrayEvent, &bDemoteStatusChange);

    if (bDemoteStatusChange || tiPos == TIPOS_HIDDEN)
    {
        if (pti->IsStartupIcon() && (pti->IsDemoted() || tiPos == TIPOS_HIDDEN))
            pti->uNumSeconds = 0;

        if (!_fBangMenuOpen || pti->IsHidden())
        {
            if ( (pti->IsDemoted() || tiPos == TIPOS_HIDDEN) && 
                        _pinfo && (_pinfo->hWnd == pti->hWnd) && (_pinfo->uID == pti->uID) )
            {
                //hide the balloon
                _beLastBalloonEvent = BALLOONEVENT_APPDEMOTE;
                _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONHIDE);
            }

            // hide/show
            m_TrayItemManager.SetTBBtnStateHelper( nIcon, 
                                TBSTATE_HIDDEN, 
                                (pti->IsHidden() || (m_TrayItemRegistry.IsAutoTrayEnabled() && pti->IsDemoted())) );

            if (bDemoteStatusChange)
            {
                _UpdateChevronState(_fBangMenuOpen, FALSE, TRUE);
                _OnSizeChanged(FALSE);
            }
        }
    }

    _SetOrKillIconDemoteTimer(pti, tiPos);

    return bDemoteStatusChange;
}

TRAYITEMPOS CTrayNotify::_TrayItemPos(CTrayItem * pti, TRAYEVENT tTrayEvent, BOOL *bDemoteStatusChange)
{   
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    TRAYITEMPOS tiPos      = TIPOS_STATUSQUO;

    *bDemoteStatusChange = FALSE;

    if (!pti)
        return tiPos;

    switch(tTrayEvent)
    {
        case TRAYEVENT_ONDISABLEAUTOTRAY:
            if (!pti->IsHidden())
            {
                tiPos = TIPOS_ALWAYS_PROMOTED;

                if (pti->IsStartupIcon() && !pti->IsDemoted() && pti->dwUserPref == TNUP_AUTOMATIC)
                    pti->uNumSeconds = _GetAccumulatedTime(pti);

                *bDemoteStatusChange = TRUE;

                pti->SetOnceVisible(TRUE);
                pti->SetItemClicked(FALSE);
            }
            break;

        case TRAYEVENT_ONITEMCLICK:
        case TRAYEVENT_ONICONMODIFY:
        case TRAYEVENT_ONINFOTIP:
            if (!pti->IsHidden())
                pti->SetOnceVisible(TRUE);

            if (m_TrayItemRegistry.IsAutoTrayEnabled() && !pti->IsHidden())
            {
                if ( (tTrayEvent == TRAYEVENT_ONICONMODIFY) &&
                     (pti->IsItemSameIconModify()) )
                {
                    break;
                }
                else if (pti->dwUserPref == TNUP_AUTOMATIC)
                {
                    // If the item has been clicked on, note it...
                    if (tTrayEvent == TRAYEVENT_ONITEMCLICK)
                    {
                        pti->SetItemClicked(TRUE);
                    }

                    tiPos = TIPOS_PROMOTED;
                    if (pti->IsDemoted())
                    {
                        pti->SetDemoted(FALSE);
                        *bDemoteStatusChange = TRUE;
                    }
                }
            }
            break;

        case TRAYEVENT_ONAPPLYUSERPREF:
        case TRAYEVENT_ONNEWITEMINSERT:
            if (!pti->IsHidden())
                pti->SetOnceVisible(TRUE);

            if (m_TrayItemRegistry.IsAutoTrayEnabled() && !pti->IsHidden())
            {
                if (pti->dwUserPref == TNUP_AUTOMATIC)
                {
                    tiPos = (pti->IsDemoted() ? TIPOS_DEMOTED : TIPOS_PROMOTED);
                    if (pti->IsDemoted())
                    {
                        // (1) New Item Insert : The new item is inserted. If it was demoted in the 
                        //     previous session, the setting has carried over, and is copied over
                        //     before this function is called (in InsertNotify->_PlaceItem). Use this
                        //     setting to determine if the item is to be demoted.
                        // (2) Apply User Pref : This is called in two cases :
                        //     (a) SetPreference : When the user clicks OK on the Notifications Prop
                        //         dialog. Since dwUserPref is TNUP_AUTOMATIC, use the current demoted
                        //         setting of the item. Do not change the demoted setting of the item
                        //     (b) EnableAutoTray : The AutoTray feature has been enabled. Demote the
                        //         icon only if it was already demoted before. When the icon was 
                        //         inserted, its previous demote setting was copied. So if its previous
                        //         demote setting was TRUE, then the item should be demoted, otherwise
                        //         it shouldnt be.
                        // So, in effect, in all these cases, if dwUserPref was TNUP_AUTOMATIC, there
                        // is no necessity to change the demote setting, but some cases, it is necessary
                        // to hide the icon.
                        *bDemoteStatusChange = TRUE;
                    }
                }
                else
                {
                    pti->SetDemoted(pti->dwUserPref == TNUP_DEMOTED);

                    tiPos = ((pti->dwUserPref == TNUP_DEMOTED) ? TIPOS_ALWAYS_DEMOTED : TIPOS_ALWAYS_PROMOTED);

                    *bDemoteStatusChange = TRUE;

                    pti->SetItemClicked(FALSE);
                }
            }
            break;

        case TRAYEVENT_ONICONDEMOTETIMER:
            // Hidden items cannot have timers, and we will never get this event if 
            // the item was hidden...
            ASSERT(!pti->IsHidden());
            ASSERT(m_TrayItemRegistry.IsAutoTrayEnabled());

            tiPos = TIPOS_DEMOTED;
            if (!pti->IsDemoted())
            {
                pti->SetDemoted(TRUE);
                *bDemoteStatusChange = TRUE;
            }
            pti->SetItemClicked(FALSE);
            break;

        case TRAYEVENT_ONICONHIDE:
            tiPos = TIPOS_HIDDEN;
            if (pti->IsDemoted() || pti->dwUserPref == TNUP_DEMOTED)
            {
                pti->SetDemoted(FALSE);
                *bDemoteStatusChange = TRUE;
            }
            pti->SetItemClicked(FALSE);
            break; 

        case TRAYEVENT_ONICONUNHIDE:
            pti->SetOnceVisible(TRUE);
            *bDemoteStatusChange = TRUE;

            if (m_TrayItemRegistry.IsAutoTrayEnabled())
            {
                if ((pti->dwUserPref == TNUP_AUTOMATIC) || (pti->dwUserPref == TNUP_PROMOTED))
                {
                    tiPos = ((pti->dwUserPref == TNUP_AUTOMATIC) ? TIPOS_PROMOTED : TIPOS_ALWAYS_PROMOTED);
                    if (pti->IsDemoted())
                    {
                        pti->SetDemoted(FALSE);
                    }
                }
                else
                {
                    ASSERT(pti->dwUserPref == TNUP_DEMOTED);
                    tiPos = TIPOS_ALWAYS_DEMOTED;
                    if (!pti->IsDemoted())
                    {
                        pti->SetDemoted(TRUE);
                    }
                }
            }
            else 
            // NO-AUTO-TRAY mode...
            {
                tiPos = TIPOS_ALWAYS_PROMOTED;
            }
            pti->SetItemClicked(FALSE);
            break;
    }

    return tiPos;
}


void CTrayNotify::_SetOrKillIconDemoteTimer(CTrayItem * pti, TRAYITEMPOS tiPos)
{
    switch(tiPos)
    {
    case TIPOS_PROMOTED:
        _SetItemTimer(pti);
        break;

    case TIPOS_DEMOTED:
    case TIPOS_HIDDEN:
    case TIPOS_ALWAYS_DEMOTED:
    case TIPOS_ALWAYS_PROMOTED:
        _KillItemTimer(pti);
        break;

    case TIPOS_STATUSQUO:
        break;
    }
}

LRESULT CTrayNotify::_OnKeyDown(WPARAM wChar, LPARAM lFlags)
{
    if (_hwndClock && _hwndClock == GetFocus())
    {
        BOOL fLastHot = FALSE;

        //
        // handle keyboard messages forwarded by clock
        //
        switch (wChar)
        {
        case VK_UP:
        case VK_LEFT:
            fLastHot = TRUE;
            //
            // fall through
            //

        case VK_DOWN:
        case VK_RIGHT:
            {
                if (_fNoTrayItemsDisplayPolicyEnabled)
                {
                    SetFocus(_hwndClock);
                    // this is moot, since the chevron will not be shown
                    _fChevronSelected = FALSE;
                    return 0;
                }
                else
                {
                    INT_PTR nToolbarIconSelected = -1;
                    if (fLastHot || !_fHaveDemoted)
                    {
                        nToolbarIconSelected = _GetToolbarFirstVisibleItem(_hwndToolbar, fLastHot);
                    }

                    if (nToolbarIconSelected != -1)
                    {
                        //
                        // make it the hot item
                        //
                        _SetToolbarHotItem(_hwndToolbar, nToolbarIconSelected);
                        _fChevronSelected = FALSE;
                    }
                    else if (_fHaveDemoted)
                    {
                        SetFocus(_hwndChevron);
                        _fChevronSelected = TRUE;
                    }

                    return 0;
                }
            }

        case VK_RETURN:
        case VK_SPACE:
            //
            // run the default applet in timedate.cpl
            //
            SHRunControlPanel(TEXT("timedate.cpl"), _hwnd);
            return 0;
        }
    }

    return 1;
}

void CTrayNotify::_OnWorkStationLocked(BOOL bLocked)
{
    _bWorkStationLocked = bLocked;

    if (!_bWorkStationLocked && !_fNoTrayItemsDisplayPolicyEnabled && 
        _fEnableUserTrackedInfoTips && _pinfo)
    {
        _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, TRUE, NIN_BALLOONSHOW);
    }
}

void CTrayNotify::_OnRudeApp(BOOL bRudeApp)
{
    if (_bRudeAppLaunched != bRudeApp)
    {
        _bWaitAfterRudeAppHide = FALSE;
        
        _bRudeAppLaunched = bRudeApp;

        if (!bRudeApp)
        {
            if (_pinfo)
            {
                SetTimer(_hwndNotify, TID_RUDEAPPHIDE, TT_RUDEAPPHIDE_INTERVAL, 0);
                _bWaitAfterRudeAppHide = TRUE;

                // _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, TRUE, TRUE, NIN_BALLOONSHOW);
            }
        }
        else
        {
            _KillTimer(TF_INFOTIP_TIMER, _uInfoTipTimer);
            _uInfoTipTimer = 0;

            // NOTENOTE : *DO NOT* delete _pinfo, we will show the balloon tip after the fullscreen app has 
            // gone away. 
            _HideBalloonTip();
        }
    }
}

// WndProc as defined in CImpWndProc. s_WndProc function in base class calls
// virtual v_WndProc, which handles all the messages in the derived class.
LRESULT CTrayNotify::v_WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    //
    // protect against re-entrancy after we've been partially destroyed
    //
    if (_hwndToolbar == NULL)
    {
        if (uMsg != WM_CREATE &&
            uMsg != WM_DESTROY)
        {
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
        }
    }
    
    switch (uMsg)
    {        
    case WM_CREATE:
        return _Create(hWnd);
        
    case WM_DESTROY:
        return _Destroy();

    case WM_COMMAND:
        if (!_fNoTrayItemsDisplayPolicyEnabled)
            _OnCommand(GET_WM_COMMAND_ID(wParam, lParam), GET_WM_COMMAND_CMD(wParam, lParam));
        break;

    case WM_SETFOCUS:
        {
            if (_fNoTrayItemsDisplayPolicyEnabled)
            {
                SetFocus(_hwndClock);
                _fChevronSelected = FALSE;
            }
            else
            {
                BOOL bFocusSet = FALSE;
                //
                // if there's a balloon tip up, start with focus on that icon
                //
                if (_pinfo)
                {
                    INT_PTR nIcon = m_TrayItemManager.FindItemAssociatedWithHwndUid(_pinfo->hWnd, _pinfo->uID);
                    if (nIcon != -1 && ToolBar_IsVisible(_hwndToolbar, nIcon))
                    {
                        _SetToolbarHotItem(_hwndToolbar, nIcon);
                        _fChevronSelected = FALSE;
                        bFocusSet = TRUE;
                    }
                }
                if (!bFocusSet && _fHaveDemoted)
                {
                    SetFocus(_hwndChevron);
                    _fChevronSelected = TRUE;
                    bFocusSet = TRUE;
                }
        
                if (!bFocusSet)
                {
                    INT_PTR nToolbarIcon = _GetToolbarFirstVisibleItem(_hwndToolbar, FALSE);
                    if (nToolbarIcon != -1)
                    {
                        _SetToolbarHotItem(_hwndToolbar, nToolbarIcon);
                        _fChevronSelected = FALSE;
                    }
                    else
                    {
                        SetFocus(_hwndClock);
                        _fChevronSelected = FALSE;
                    }
                }
            }
        }
        break;

    case WM_SETREDRAW:
        return _SetRedraw((BOOL) wParam);

    case WM_ERASEBKGND:
        if (_hTheme)
        {
            return 1;
        }
        else
        {
            _Paint((HDC)wParam);
        }
        break;


    case WM_PAINT:
    case WM_PRINTCLIENT:
        return _Paint((HDC)wParam);

    case WM_CALCMINSIZE:
        return _CalcMinSize((int)wParam, (int)lParam);

    case WM_KEYDOWN:
        return _OnKeyDown(wParam, lParam);

    case WM_NCHITTEST:
        return(IsPosInHwnd(lParam, _hwndClock) ? HTTRANSPARENT : HTCLIENT);

    case WM_NOTIFY:
        return(_Notify((LPNMHDR)lParam));

    case TNM_GETCLOCK:
        return (LRESULT)_hwndClock;

    case TNM_TRAYHIDE:
        if (lParam && IsWindowVisible(_hwndClock))
            SendMessage(_hwndClock, TCM_RESET, 0, 0);
        break;

    case TNM_HIDECLOCK:
        ShowWindow(_hwndClock, lParam ? SW_HIDE : SW_SHOW);
        break;

    case TNM_TRAYPOSCHANGED:
        if (_pinfo && !_fNoTrayItemsDisplayPolicyEnabled)
            PostMessage(_hwndNotify, TNM_ASYNCINFOTIPPOS, 0, 0);
        break;
    
    case TNM_ASYNCINFOTIPPOS:
        ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
        _PositionInfoTip();
        break;

    case TNM_ASYNCINFOTIP:
        ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
        _ShowInfoTip((HWND)wParam, (UINT)lParam, TRUE, FALSE, 0);
        break;

    case TNM_NOTIFY:
        {
            ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
            CNotificationItem* pni = (CNotificationItem*)lParam;
            if (pni)
            {
                if (_pNotifyCB)
                {
                    _pNotifyCB->Notify((UINT)wParam, pni);
                    if (wParam == NIM_ADD)
                    {
                        _TickleForTooltip(pni);
                    }
                }
                delete pni;
            }
        }
        break;

    case WM_SIZE:
        _Size();
        break;

    case WM_TIMER:
        _OnTimer(wParam);
        break;

    case TNM_UPDATEVERTICAL:
        {
            _UpdateVertical((BOOL)lParam);
        }
        break;        

    // only button down, mouse move msgs are forwarded down to us from info tip
    //case WM_LBUTTONUP:
    //case WM_MBUTTONUP:
    //case WM_RBUTTONUP:
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
        _InfoTipMouseClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (uMsg == WM_RBUTTONDOWN));
        break;

    case TNM_ICONDEMOTETIMER:
        ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
        _OnIconDemoteTimer(wParam, lParam);
        break;

    case TNM_INFOTIPTIMER:
        ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
        _OnInfoTipTimer();
        break;

    case TNM_SAVESTATE:
        if (!_fNoTrayItemsDisplayPolicyEnabled)
        {
            _SetUsedTime();
            m_TrayItemRegistry.InitTrayItemStream(STGM_WRITE, this->GetTrayItemCB, this);
        }
        break;

    case TNM_STARTUPAPPSLAUNCHED:
        _bStartupIcon = FALSE;
        break;

    // This message is sent by a shimmed Winstone app, to prevent the launching of
    // user-tracked balloons. These "new" balloons last till the user has been at
    // the machine for a minimum of 10 seconds. But automated Winstone tests cause
    // this balloon to stay up forever, and screws up the tests. So we shim Winstone
    // to pass us this message, and allow normal balloon tips for such a machine.
    case TNM_ENABLEUSERTRACKINGINFOTIPS:
        if ((BOOL) wParam == FALSE)
        {
            if (!_fNoTrayItemsDisplayPolicyEnabled && _fEnableUserTrackedInfoTips && _pinfo)
            {
                _fEnableUserTrackedInfoTips = (BOOL) wParam;
                _beLastBalloonEvent = BALLOONEVENT_NONE;
                _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONHIDE);
            }
        }
        _fEnableUserTrackedInfoTips = (BOOL) wParam;
        break;

    case TNM_WORKSTATIONLOCKED:
        _OnWorkStationLocked((BOOL)wParam);
        break;

    case TNM_RUDEAPP:
        _OnRudeApp((BOOL)wParam);
        break;

    case TNM_SHOWTRAYBALLOON:
        // If we enable display of tray balloons...
        if (wParam)
        {
            // If we had disabled display of tray balloons earlier...
            if (!_bStartMenuAllowsTrayBalloon)
            {
                SetTimer(_hwndNotify, TID_BALLOONSHOW, TT_BALLOONSHOW_INTERVAL, 0);
            }
        }
        else
        {
            KillTimer(_hwndNotify, TID_BALLOONSHOW);
            _bStartMenuAllowsTrayBalloon = FALSE;

            // TO DO : Should we hide the balloon ?
        }
        break;

    case WM_THEMECHANGED:
        _OpenTheme();
        break;

    case WM_TIMECHANGE:
    case WM_WININICHANGE:
    case WM_POWERBROADCAST:
    case WM_POWER:
        _OnSysChange(uMsg, wParam, lParam);
        // Fall through...

    default:
        return (DefWindowProc(hWnd, uMsg, wParam, lParam));
    }

    return 0;
}

INT_PTR CTrayNotify::_GetToolbarFirstVisibleItem(HWND hWndToolbar, BOOL bFromLast)
{
    INT_PTR nToolbarIconSelected = -1;

    if (_fNoTrayItemsDisplayPolicyEnabled)
        return -1;

    INT_PTR nTrayItemCount = m_TrayItemManager.GetItemCount()-1;

    INT_PTR i = ((nTrayItemCount > 0) ? ((bFromLast) ? nTrayItemCount : 0) : -1);

    if (i == -1)
        return i;

    do
    {
        if (ToolBar_IsVisible(hWndToolbar, i))
        {
            nToolbarIconSelected = i;
            break;
        }
        i = (bFromLast ? ((i > 0) ? i-1 : -1) : ((i < nTrayItemCount) ? i+1 : -1));
    }
    while (i != -1);

    return nToolbarIconSelected;
}

BOOL CTrayNotify::_TrayNotifyIcon(PTRAYNOTIFYDATA pnid, BOOL *pbRefresh)
{
    // we want to refrain from re-painting if possible...
    if (pbRefresh)
        *pbRefresh = FALSE;

    PNOTIFYICONDATA32 pNID = &pnid->nid;
    if (pNID->cbSize < sizeof(NOTIFYICONDATA32))
    {
        return FALSE;
    }

    if (_fNoTrayItemsDisplayPolicyEnabled)
    {
        if (pnid->dwMessage == NIM_SETFOCUS)
        {
            if (_hwndClock)
            {
                SetFocus(_hwndClock);
                _fChevronSelected = FALSE;
            }
        }
        return TRUE;
    }

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);    
    INT_PTR nIcon = m_TrayItemManager.FindItemAssociatedWithHwndUid(GetHWnd(pNID), pNID->uID);
    
    BOOL bRet = FALSE;
    switch (pnid->dwMessage)
    {
    case NIM_SETFOCUS:
        // the notify client is trying to return focus to us
        if (nIcon >= 0)
        {
            if (!(_bRudeAppLaunched || IsDirectXAppRunningFullScreen()))
            {
                SetForegroundWindow(v_hwndTray);
                if (ToolBar_IsVisible(_hwndToolbar, nIcon))
                {
                    _SetToolbarHotItem(_hwndToolbar, nIcon);
                    _fChevronSelected = FALSE;
                }
                else if (_fHaveDemoted)
                {
                    SetFocus(_hwndChevron);
                    _fChevronSelected = TRUE;
                }
                else
                {
                    INT_PTR nToolbarIcon = _GetToolbarFirstVisibleItem(_hwndToolbar, FALSE);
                    if (nToolbarIcon != -1)
                    {
                        _SetToolbarHotItem(_hwndToolbar, nToolbarIcon);
                        _fChevronSelected = FALSE;
                    }
                    else
                    {
                        SetFocus(_hwndClock);
                        _fChevronSelected = FALSE;
                    }
                }
            }
            else
            {
                SHAllowSetForegroundWindow(v_hwndTray);
            }

            if (pbRefresh)
                *pbRefresh = TRUE;
        }
        else
        {
            if (_hwndClock)
            {
                SetFocus(_hwndClock);
                _fChevronSelected = FALSE;
            }
        }
        bRet = TRUE;
        break;
        
    case NIM_ADD:
        // The icon doesnt already exist, and we dont insert again...
        if (nIcon < 0)
        {
            bRet = _InsertNotify(pNID);
            if (bRet && pbRefresh)
                *pbRefresh = TRUE;
        }
        break;

    case NIM_MODIFY:
        if (nIcon >= 0)
        {
            BOOL bRefresh;
            int nCountBefore = -1, nCountAfter = -1;
            if (pbRefresh)
            {
                nCountBefore = m_TrayItemManager.GetPromotedItemCount();
                if (m_TrayItemManager.GetDemotedItemCount() > 0)
                    nCountBefore ++;
            }

            bRet = _ModifyNotify(pNID, nIcon, &bRefresh, FALSE);

            if (bRet && pbRefresh)
            {
                nCountAfter = m_TrayItemManager.GetPromotedItemCount();
                if (m_TrayItemManager.GetDemotedItemCount() > 0)
                    nCountAfter ++;

                *pbRefresh = (nCountBefore != nCountAfter);
            }
        }
        break;

    case NIM_DELETE:
        if (nIcon >= 0)
        {
            bRet = _DeleteNotify(nIcon, FALSE, TRUE);
            if (bRet)
            {
                if (pbRefresh)
                {
                    *pbRefresh = TRUE;
                }
            }
        }
        break;

    case NIM_SETVERSION:
        if (nIcon >= 0)
        {
            // There is no point in handling NIM_SETVERSION if the "No-Tray-Items-Display" 
            // policy is in effect. The version enables proper keyboard and mouse notification
            // messages to be sent to the apps, depending on the version of the shell 
            // specified. 
            // Since the policy prevents the display of any icons, there is no point in
            // setting the correct version..
            bRet = _SetVersionNotify(pNID, nIcon);
            
            // No activity occurs in SetVersionNotify, so no need to refresh 
            // screen - pbRefresh is not set to TRUE...
        }
        break;

    default:
        break;
    }

    return bRet;
}


// Public
LRESULT CTrayNotify::TrayNotify(HWND hwndNotify, HWND hwndFrom, PCOPYDATASTRUCT pcds, BOOL *pbRefresh)
{
    PTRAYNOTIFYDATA pnid;

    if (!hwndNotify || !pcds)
    {
        return FALSE;
    }

    if (pcds->cbData < sizeof(TRAYNOTIFYDATA))
    {
        return FALSE;
    }

    // We'll add a signature just in case
    pnid = (PTRAYNOTIFYDATA)pcds->lpData;
    if (pnid->dwSignature != NI_SIGNATURE)
    {
        return FALSE;
    }

    return _TrayNotifyIcon(pnid, pbRefresh);
}

// Public
HWND CTrayNotify::TrayNotifyCreate(HWND hwndParent, UINT uID, HINSTANCE hInst)
{
    WNDCLASSEX wc;

    ZeroMemory(&wc, sizeof(wc));
    wc.cbSize = sizeof(WNDCLASSEX);

    if (!GetClassInfoEx(hInst, c_szTrayNotify, &wc))
    {
        wc.lpszClassName = c_szTrayNotify;
        wc.style = CS_DBLCLKS;
        wc.lpfnWndProc = s_WndProc;
        wc.hInstance = hInst;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = NULL;
        wc.cbWndExtra = sizeof(CTrayNotify *);

        if (!RegisterClassEx(&wc))
        {
            return(NULL);
        }

        if (!ClockCtl_Class(hInst))
        {
            return(NULL);
        }
    }

    return (CreateWindowEx(0, c_szTrayNotify,
            NULL, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | WS_CLIPCHILDREN, 0, 0, 0, 0,
            hwndParent, IntToPtr_(HMENU,uID), hInst, (void *)this));
}

void CTrayNotify::_UpdateChevronSize()
{
    if (_hTheme)
    {
        HTHEME hTheme = OpenThemeData(_hwndChevron, L"Button");
        if (hTheme)
        {
            HDC hdc = GetDC(_hwndChevron);
            GetThemePartSize(hTheme, hdc, BP_PUSHBUTTON, PBS_DEFAULTED, NULL, TS_TRUE, &_szChevron);
            ReleaseDC(_hwndChevron, hdc);
            CloseThemeData(hTheme);
        }
    }
    else
    {
        _szChevron.cx = GetSystemMetrics(SM_CXSMICON);
        _szChevron.cy = GetSystemMetrics(SM_CYSMICON);
    }
}

void CTrayNotify::_UpdateChevronState( BOOL fBangMenuOpen, 
                    BOOL fTrayOrientationChanged, BOOL fUpdateDemotedItems)
{
    BOOL fChange = FALSE;

    if (_fNoTrayItemsDisplayPolicyEnabled)
        return;

    BOOL fHaveDemoted = _UpdateTrayItems(fUpdateDemotedItems);

    if (_fHaveDemoted != fHaveDemoted)
    {
        _fHaveDemoted = fHaveDemoted;
        ShowWindow(_hwndChevron, _fHaveDemoted ? SW_SHOW : SW_HIDE);
        if (!_fHaveDemoted)
        {
            if (_fBangMenuOpen)
            {
                fBangMenuOpen = FALSE;
            }
        }
        fChange = TRUE;

        if (_fHaveDemoted && !_fBangMenuOpen)
        {
            _ShowChevronInfoTip();
        }
        else if ( (!_fHaveDemoted || (_fBangMenuOpen != fBangMenuOpen)) && 
                  _pinfo && _IsChevronInfoTip(_pinfo->hWnd, _pinfo->uID) )
        {
            _beLastBalloonEvent = BALLOONEVENT_NONE;
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONHIDE);         
        }
    }

    if ( fChange || fTrayOrientationChanged ||
                        ( _fHaveDemoted && (_fBangMenuOpen != fBangMenuOpen) )
        )
    {
        if ((_fBangMenuOpen != fBangMenuOpen) && _pinfo && _IsChevronInfoTip(_pinfo->hWnd, _pinfo->uID))
        {
            _beLastBalloonEvent = BALLOONEVENT_NONE;
            _ShowInfoTip(_pinfo->hWnd, _pinfo->uID, FALSE, FALSE, NIN_BALLOONHIDE); 
        }

        _fBangMenuOpen = fBangMenuOpen;
        LPCWSTR pwzTheme;

        if (_fBangMenuOpen)
        {
            pwzTheme = _fVertical ? c_wzTrayNotifyVertOpenTheme : c_wzTrayNotifyHorizOpenTheme;
        }
        else
        {
            pwzTheme = _fVertical ? c_wzTrayNotifyVertTheme : c_wzTrayNotifyHorizTheme;
        }

        SetWindowTheme(_hwndChevron, pwzTheme, NULL);
        _UpdateChevronSize();
    }
}


void CTrayNotify::_UpdateVertical(BOOL fVertical)
{
    _fVertical = fVertical;
    LPCWSTR pwzTheme = _fVertical ? c_wzTrayNotifyVertTheme : c_wzTrayNotifyHorizTheme;

    SetWindowTheme(_hwndNotify, pwzTheme, NULL);
    _UpdateChevronState(_fBangMenuOpen, TRUE, TRUE);
}

void CTrayNotify::_OpenTheme()
{
    if (_hTheme)
    {
        CloseThemeData(_hTheme);
        _hTheme = NULL;
    }
    _hTheme = OpenThemeData(_hwndNotify, L"TrayNotify");

    _UpdateChevronSize();
    SetWindowStyleEx(_hwndNotify, WS_EX_STATICEDGE, !_hTheme);

    InvalidateRect(_hwndNotify, NULL, FALSE);
}

// *** Helper functions for UserEventTimer..
HRESULT CTrayNotify::_SetItemTimer(CTrayItem * pti)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if(pti)
    {
        ASSERT(pti->dwUserPref == TNUP_AUTOMATIC);

        UINT uTimerInterval = m_TrayItemRegistry._uPrimaryCountdown;
        if (pti->IsItemClicked())
        {
            // If the item has been clicked on, add 8 hours to its staying time
            // in the tray...
            uTimerInterval += TT_ICON_COUNTDOWN_INCREMENT;
        }
        if (pti->IsStartupIcon())
        {
            uTimerInterval -= (pti->uNumSeconds)*1000;
        }

        hr = _SetTimer(TF_ICONDEMOTE_TIMER, TNM_ICONDEMOTETIMER, uTimerInterval, &(pti->uIconDemoteTimerID));
    }

    return hr;
}

HRESULT CTrayNotify::_SetTimer(int nTimerFlag, UINT uCallbackMessage, UINT uTimerInterval, ULONG * puTimerID)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if (puTimerID)
    {
        IUserEventTimer * pUserEventTimer = _CreateTimer(nTimerFlag);
        if (pUserEventTimer)
        {
            if (FAILED(hr = pUserEventTimer->SetUserEventTimer( _hwndNotify, 
                uCallbackMessage, uTimerInterval, NULL, puTimerID)))
            {
                *puTimerID = 0;
            }
        }
        else
        {
            *puTimerID = 0;
        }
    }

    return hr;
}

HRESULT CTrayNotify::_KillItemTimer(CTrayItem *pti)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if (pti)
    {
        hr = _KillTimer(TF_ICONDEMOTE_TIMER, pti->uIconDemoteTimerID);
        // Irrespective of whether the timer ID was valid or not...
        pti->uIconDemoteTimerID = 0;
    }

    return hr;
}

HRESULT CTrayNotify::_KillTimer(int nTimerFlag, ULONG uTimerID)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);

    if (uTimerID)
    {
        IUserEventTimer * pUserEventTimer = _CreateTimer(nTimerFlag);
        if (pUserEventTimer)
        {
            hr = pUserEventTimer->KillUserEventTimer(_hwndNotify, uTimerID);

            // If we are finished with the user tracking timer, we should release it
            if (_ShouldDestroyTimer(nTimerFlag))
            {
                pUserEventTimer->Release();
                _NullifyTimer(nTimerFlag);
            }
        }
    }

    return hr;
}

void CTrayNotify::_NullifyTimer(int nTimerFlag)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    
    switch(nTimerFlag)
    {
        case TF_ICONDEMOTE_TIMER:
            m_pIconDemoteTimer = NULL;
            break;

        case TF_INFOTIP_TIMER:
            m_pInfoTipTimer = NULL;
            break;
            
    }
}

BOOL CTrayNotify::_ShouldDestroyTimer(int nTimerFlag)
{
    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    
    switch(nTimerFlag)
    {
        case TF_ICONDEMOTE_TIMER:
            return (!m_TrayItemRegistry.IsAutoTrayEnabled() || m_TrayItemManager.GetPromotedItemCount() == 0);

        case TF_INFOTIP_TIMER:
            return (!_GetQueueCount());

        default:
            AssertMsg(TF_ERROR, TEXT("No other timer ids are possible"));
            return FALSE;
    }
}

IUserEventTimer * CTrayNotify::_CreateTimer(int nTimerFlag)
{
    IUserEventTimer ** ppUserEventTimer = NULL;
    UINT uTimerTickInterval = 0;

    ASSERT(!_fNoTrayItemsDisplayPolicyEnabled);
    
    switch(nTimerFlag)
    {
        case TF_ICONDEMOTE_TIMER:
            ppUserEventTimer = &m_pIconDemoteTimer;
            break;

        case TF_INFOTIP_TIMER:
            ppUserEventTimer = &m_pInfoTipTimer;
            break;

        default:
            AssertMsg(TF_ERROR, TEXT("No other Timers are possible"));
            return NULL;
    }

    if (ppUserEventTimer && !*ppUserEventTimer)
    {
        if ( !SUCCEEDED(SHCoCreateInstance(NULL, &CLSID_UserEventTimer, NULL, 
                                IID_PPV_ARG(IUserEventTimer, ppUserEventTimer))) )
        {
            *ppUserEventTimer = NULL;
        }
        else
        {
            uTimerTickInterval = m_TrayItemRegistry.GetTimerTickInterval(nTimerFlag);

            (*ppUserEventTimer)->InitTimerTickInterval(uTimerTickInterval);
        }
    }

    return *ppUserEventTimer;
}