windows-xp/Source/XPSP1/NT/shell/explorer/trayprop.cpp

//---------------------------------------------------------------------------
// This file contains Taskbar and Start Menu property sheet code
//---------------------------------------------------------------------------
#include "cabinet.h"
#include "rcids.h"
#include "util.h"
#include <help.h>       // help ids
#include <regstr.h>
#include <atlstuff.h>

#include "dlg.h"
#include "tray.h"
#include "traycmn.h"
#include "startmnu.h"
#include "desktop2.h"
#include "uemapp.h"

#define GROUPID_CURRENTITEMS    5
#define GROUPID_PASTITEMS       6

#define MAX_PROGS_ALLOWED   30

const static DWORD aInitStartMenuHelpIDs[] = {
    IDC_NO_HELP_1,       NO_HELP,
    IDC_NO_HELP_2,       NO_HELP,
    IDC_NO_HELP_3,       NO_HELP,
    IDC_NO_HELP_4,       NO_HELP,
    IDC_GROUPBOX,        IDH_COMM_GROUPBOX,
    IDC_GROUPBOX_2,      IDH_MENUCONFIG_CLEAR,
    IDC_GROUPBOX_3,      IDH_COMM_GROUPBOX,
    IDC_ADDSHORTCUT,     IDH_TRAY_ADD_PROGRAM,
    IDC_DELSHORTCUT,     IDH_TRAY_REMOVE_PROGRAM,
    IDC_EXPLOREMENUS,    IDH_TRAY_ADVANCED,
    IDC_KILLDOCUMENTS,   IDH_MENUCONFIG_CLEAR,
    IDC_RESORT,          IDH_TRAY_RESORT_BUTTON,
    IDC_STARTMENUSETTINGSTEXT, IDH_TRAY_START_MENU_SETTINGS,
    0, 0
};

const static DWORD aTaskOptionsHelpIDs[] = {  // Context Help IDs
    IDC_TASKBARAPPEARANCE,IDH_TASKBAR_OPTIONS_BITMAP,
    IDC_NOTIFYAPPEARANCE, IDH_TASKBAR_OPTIONS_BITMAP,
    IDC_TRAYOPTAUTOHIDE,  IDH_TRAY_TASKBAR_AUTOHIDE,
    IDC_TRAYOPTSHOWCLOCK, IDH_TRAY_SHOW_CLOCK,
    IDC_TRAYOPTONTOP,     IDH_TRAY_TASKBAR_ONTOP,
    IDC_LOCKTASKBAR,      IDH_TRAY_ENABLEMOVERESIZE,
    IDC_GROUPITEMS,       IDH_TRAY_GROUPING,
    IDC_NOTIFYMAN,        IDH_TRAY_HIDE_ICONS,
    IDC_CUSTOMIZE,        IDH_TRAY_CUSTOMIZE_ICONS,
    IDC_QUICKLAUNCH,      IDH_TRAY_QUICKLAUNCH,
    0, 0
};

const static DWORD aNotifyOptionsHelpIDs[] = {  // Context Help IDs
    IDC_NOTIFY_TEXT,            NO_HELP,
    IDC_NOTIFY_TEXT2,           NO_HELP,
    IDC_COMBO_ACTION,           NO_HELP,
    IDC_NOTIFY_ITEMS,           NO_HELP,
    IDB_NOTIFY_RESTOREDEFAULTS, IDH_TRAY_RESTOREDEFBUTTON,
    0, 0
};

const static DWORD aStartTabHelpIDs[] = {
    IDC_STARTMENUPREVIEW,   IDH_START_PREVIEW,
    IDC_NEWSCHOOL,          IDH_START_SELECTPERSONAL,
    IDC_OLDSCHOOL,          IDH_START_SELECTCLASSIC,
    IDC_NEWSTARTCUSTOMIZE,  IDH_START_CUSTOMIZEPERSONAL,
    IDC_OLDSTARTCUSTOMIZE,  IDH_START_CUSTOMIZECLASSIC,
    0, 0
};

const static DWORD aStartCustGeneralTabHelpIDs[] = {
    IDC_SPCUST_ICONLARGE,       IDH_START_SPCUST_LARGE,
    IDC_SPCUST_ICONSMALL,       IDH_START_SPCUST_SMALL,
    IDC_SPCUST_LARGE,           IDH_START_SPCUST_LARGE,
    IDC_SPCUST_SMALL,           IDH_START_SPCUST_SMALL,
    IDC_SPCUST_MINPROGS,        IDH_START_SPCUST_MINPROGS,
    IDC_SPCUST_MINPROGS_ARROW,  IDH_START_SPCUST_MINPROGS,
    IDB_SPCUST_CLEARPROG,       IDH_START_SPCUST_CLEARPROG,
    IDC_SPCUST_INTERNET,        IDH_START_SPCUST_INTERNET,
    IDC_SPCUST_INTERNETCB,      IDH_START_SPCUST_INTERNETCB,
    IDC_SPCUST_EMAIL,           IDH_START_SPCUST_EMAIL,
    IDC_SPCUST_EMAILCB,         IDH_START_SPCUST_EMAILCB,
    0, 0
};

const static DWORD aStartCustAdvancedTabHelpIDs[] = {
    IDC_SPCUST_HOVEROPEN,       IDH_START_SPCUST_HOVEROPEN,
    IDC_SPCUST_NOTIFYNEW,       IDH_START_SPCUST_NOTIFYNEW,
    IDC_STARTMENUSETTINGS,      IDH_START_STARTMENUSETTINGS,
    IDC_SPCUST_RECENT_GROUPBOX, NO_HELP,
    IDC_SPCUST_RECENT_TEXT,     NO_HELP,
    IDC_SPCUST_RECENT,          IDH_START_SPCUST_RECENT,
    IDB_SPCUST_CLEARDOCS,       IDH_START_SPCUST_CLEARDOCS,
    0, 0
};

#define REGSTR_VAL_LARGEICONSTEMP TEXT("Start_LargeIcons")
#define REGSTR_VAL_ADMINTOOLSTEMP TEXT("Start_AdminToolsTemp")

void SetDlgItemBitmap(HWND hDlg, int idStatic, int iResource);
void SetDlgItemIcon(HWND hDlg, int idStatic, HICON hi);
void SetProgramIcon(HWND hDlg, int idLarge, int idSmall);

void _TaskbarOptionsUpdateDisplay(HWND hDlg);
void _TaskbarOptionsSizeControls(HWND hDlg);
void _TaskbarOptionsDestroyBitmaps(HWND hDlg);

BOOL_PTR WINAPI AdvancedOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);


typedef struct
{
    HWND hwndTree;
    IRegTreeOptions *pTO;
} SMADVANCED;

void SendPSMChanged(HWND hDlg)
{
    SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
}

class CPinHelper
{
public:
    CPinHelper();
    ~CPinHelper();

    void Save(BOOL bShowEmail, BOOL bShowBrowser);
    void GetPinInfo(BOOL *pbPinBrowser, BOOL *pbPinEmail);

private:
    void SavePinInfo(LPCITEMIDLIST pidlVictim, BOOL bOld, BOOL bNew);

    LPITEMIDLIST _pidlBrowser;
    LPITEMIDLIST _pidlEmail;

    IStartMenuPin *_psmp;
};

CPinHelper::CPinHelper()
{
    _pidlBrowser = ILCreateFromPath(TEXT("shell:::{2559a1f4-21d7-11d4-bdaf-00c04f60b9f0}"));
    _pidlEmail   = ILCreateFromPath(TEXT("shell:::{2559a1f5-21d7-11d4-bdaf-00c04f60b9f0}"));
    CoCreateInstance(CLSID_StartMenuPin, NULL, CLSCTX_INPROC_SERVER,
                     IID_PPV_ARG(IStartMenuPin, &_psmp));
}


CPinHelper::~CPinHelper()
{
    ILFree(_pidlBrowser);
    ILFree(_pidlEmail);
    ATOMICRELEASE(_psmp);
}

void CPinHelper::GetPinInfo(BOOL *pbPinBrowser, BOOL *pbPinEmail)
{
    *pbPinBrowser = FALSE;
    *pbPinEmail = FALSE;
    if (_psmp)
    {
        IEnumIDList *peidl;
        if (SUCCEEDED(_psmp->EnumObjects(&peidl)))
        {
            LPITEMIDLIST pidl;
            while (peidl->Next(1, &pidl, NULL) == S_OK)
            {
                if (ILIsEqual(pidl, _pidlBrowser)) *pbPinBrowser = TRUE;
                if (ILIsEqual(pidl, _pidlEmail))   *pbPinEmail = TRUE;
                ILFree(pidl);
            }
            peidl->Release();
        }
    }

}


void CPinHelper::SavePinInfo(LPCITEMIDLIST pidlVictim, BOOL bOld, BOOL bNew)
{
    ASSERT(bOld == TRUE || bOld == FALSE);
    ASSERT(bNew == TRUE || bNew == FALSE);

    if (pidlVictim && _psmp && bOld != bNew)
    {
        if (bNew)
        {
            _psmp->Modify(NULL, pidlVictim);
            _psmp->Modify(pidlVictim, SMPIN_POS(0));
        }
        else
        {
            _psmp->Modify(pidlVictim, NULL);
        }
    }
}

void CPinHelper::Save(BOOL bShowEmail, BOOL bShowBrowser)
{
    // Get old settings
    BOOL bShowBrowserOld, bShowEmailOld;
    GetPinInfo(&bShowBrowserOld, &bShowEmailOld);

    //
    //  Do in reverse order because we insert at the top of the list.
    //
    SavePinInfo(_pidlEmail, bShowEmailOld, bShowEmail);
    SavePinInfo(_pidlBrowser, bShowBrowserOld, bShowBrowser);
}

class ATL_NO_VTABLE CNotificationsDlg : 
    public CComObjectRootEx<CComSingleThreadModel>,
    public CDialogImpl<CNotificationsDlg>, 
    public INotificationCB
{
public:
    CNotificationsDlg() 
    { 
        _pTrayNotify = NULL; 
        _fItemChanged = FALSE;
        _hPlaceholderIcon = NULL;
        _nIndex = -1;
        _fComboBoxActive = FALSE;
    };
    virtual ~CNotificationsDlg() 
    { 
        if (_pTrayNotify) 
        { 
            _pTrayNotify->Release(); 
            _pTrayNotify = NULL;
        } 
    };

    DECLARE_NOT_AGGREGATABLE(CNotificationsDlg)

    BEGIN_COM_MAP(CNotificationsDlg)
        COM_INTERFACE_ENTRY(INotificationCB)
    END_COM_MAP()

    enum {IDD = DLG_NOTIFY};
    BEGIN_MSG_MAP_EX(CNotificationsDlg)
        MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
        MESSAGE_HANDLER(WM_CONTEXTMENU, OnContextMenu)
        MESSAGE_HANDLER(WM_HELP, OnHelp)
        NOTIFY_HANDLER_EX(IDC_NOTIFY_ITEMS, LVN_ITEMCHANGED, OnItemChanged)
        NOTIFY_HANDLER_EX(IDC_NOTIFY_ITEMS, LVN_ENDSCROLL, OnEndScroll)
        NOTIFY_CODE_HANDLER(HDN_ITEMCHANGED, OnHeaderItemChanged)
        COMMAND_HANDLER_EX(IDC_COMBO_ACTION, CBN_SELENDOK, OnComboSelEnd) 
        COMMAND_ID_HANDLER_EX(IDB_NOTIFY_RESTOREDEFAULTS, OnRestoreDefaults)
        COMMAND_RANGE_HANDLER(IDOK, IDNO, OnCloseCmd)
    END_MSG_MAP()

    //*** INotificationCB ***
    STDMETHODIMP Notify(DWORD dwMessage, LPNOTIFYITEM pNotifyItem);

    //*** Message Callbacks ***
    LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
    LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
    LRESULT OnHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
    LRESULT OnItemChanged(LPNMHDR pnmh);
    LRESULT OnEndScroll(LPNMHDR pnmh);
    LRESULT OnHeaderItemChanged(WPARAM wParam, LPNMHDR pnmh, LPARAM lParam);
    LRESULT OnComboSelEnd(UINT uMsg, UINT uID , HWND hwnd);

    LRESULT OnRestoreDefaults(UINT uMsg, UINT uID , HWND hwnd);
    LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);

    static LRESULT CALLBACK s_ListViewSubClassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
        LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);

    static LRESULT CALLBACK s_ComboBoxSubClassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
        LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);

    //*** Other ***
    void ApplyChanges(void);

private:
    HRESULT _AddItem(CNotificationItem& ni, int iIndex);
    void _ShowComboBox();
    int _GetCurSel();
    void _LoadAndSetLVItemText(UINT uResourceID, DWORD nRow, DWORD nCol);

    CSimpleArray<CNotificationItem> _saItems; //copy of the data, initialized by user
    BOOL _fItemChanged;
    ITrayNotify* _pTrayNotify;
    int _nPrevIndex;
    HWND _hwndCombo;
    HWND _hwndListView;
    RECT _rcOldPos;
    HICON _hPlaceholderIcon;
    BOOL _fComboBoxActive;
    int _nIndex;
};

HRESULT CNotificationsDlg::_AddItem(CNotificationItem& ni, int iIndex)
{
    HIMAGELIST himl = ListView_GetImageList(_hwndListView, LVSIL_SMALL);
    BOOL fInsert = FALSE;
    LV_ITEM lvitem = {0};
    int iImage = -1;

    if (!ni.hIcon)
    {
        if (!_hPlaceholderIcon)
        {
            _hPlaceholderIcon = (HICON)LoadImage(hinstCabinet, 
                MAKEINTRESOURCE(ICO_TRAYPROP_PLACEHOLDER), IMAGE_ICON,
                GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 
                LR_LOADMAP3DCOLORS);
        }

        if (_hPlaceholderIcon)
            ni.hIcon = CopyIcon(_hPlaceholderIcon);
    }
    
    if (iIndex == -1)
    {
        iIndex = _saItems.GetSize();
        iImage = ImageList_AddIcon(himl, ni.hIcon);
        fInsert = TRUE;
    }
    else
    {
        lvitem.mask = LVIF_IMAGE;
        lvitem.iItem = iIndex;
        lvitem.iSubItem = 0;
        ListView_GetItem(_hwndListView, &lvitem);
        ImageList_ReplaceIcon(himl, lvitem.iImage, ni.hIcon);
        iImage = lvitem.iImage;
        fInsert = FALSE;
    }

    if (!ni.pszIconText || ni.pszIconText[0] == 0)
    {
        TCHAR szTemp[MAX_PATH];
        if (LoadString(hinstCabinet, IDS_NOTITLE, szTemp, ARRAYSIZE(szTemp)))
            ni.SetIconText(szTemp);
        // ni.m_strText.LoadString(IDS_NOTITLE);
    }
    else
    // Replace '\n' with ' '
    {
        LPTSTR szTemp = NULL;
        while (NULL != (szTemp = StrChr(ni.pszIconText, TEXT('\n'))))
        {
            ni.pszIconText[szTemp-ni.pszIconText] = TEXT(' ');
        }
    }

    lvitem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_GROUPID;
    lvitem.iItem = iIndex;
    lvitem.iSubItem = 0;
    lvitem.pszText = ni.pszIconText;
    lvitem.iImage = iImage;
    lvitem.iGroupId = (ni.hWnd == NULL) ? GROUPID_PASTITEMS : GROUPID_CURRENTITEMS;
    if (fInsert)
        ListView_InsertItem(_hwndListView, &lvitem);
    else
        ListView_SetItem(_hwndListView, &lvitem);

    lvitem.mask = LVIF_TEXT;
    lvitem.iItem = iIndex;
    lvitem.iSubItem = 1;

    CString str;
    str.LoadString(IDS_NOTIFY_FIRST + ni.dwUserPref);
    lvitem.pszText = (LPTSTR)(LPCTSTR)str;
    ListView_SetItem(_hwndListView, &lvitem);

    if (fInsert)
    {
        _saItems.Add(ni);
    }
    else
    {
        _saItems[iIndex] = ni;
    }

    return S_OK;
}

HRESULT CNotificationsDlg::Notify(DWORD dwMessage, NOTIFYITEM * pNotifyItem)
{
    if (!pNotifyItem || (!pNotifyItem->hWnd && !pNotifyItem->pszExeName))
        return E_INVALIDARG;

    ASSERT(pNotifyItem);        
    CNotificationItem ni = *pNotifyItem;

    switch (dwMessage)
    {
    case NIM_ADD:
    case NIM_MODIFY:
        {
            // We never need to modify a Past Item
            for (int i = 0; (i < _saItems.GetSize() && ni.hWnd); i++)
            {
                // If the Item is already in the list just update it
                if (_saItems[i] == ni)
                {
                    return _AddItem(ni, i);
                }
            }

            // If it is not in the list add it
            return _AddItem(ni, -1);
        }
        break;

    case NIM_DELETE:
        {
            for (int i = 0; (i < _saItems.GetSize()); i++)
            {
                if (_saItems[i] == ni)
                {
                    _saItems.RemoveAt(i);
                    ListView_DeleteItem(_hwndListView, i);
                    _ShowComboBox();

                    return S_OK;
                }
            }
            break;
        }
    }

    return E_INVALIDARG;
}

LRESULT CNotificationsDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    _hwndListView = GetDlgItem(IDC_NOTIFY_ITEMS);
    _nPrevIndex = -2;
    _rcOldPos.top = -500;

    CImageList il;
    int iSize = GetSystemMetrics(SM_CXSMICON);
    il.Create(iSize, iSize, SHGetImageListFlags(_hwndListView), _saItems.GetSize(), 4);
    if (il)
    {
        CString str;
        //list view control holding all the items
        ListView_SetExtendedListViewStyle(_hwndListView, LVS_EX_FULLROWSELECT);
        ListView_EnableGroupView(_hwndListView, TRUE);

        static const struct {
            int ids;
            int idGroup;
        } groupData[] =  {{ IDS_NOTIFY_CURRENTITEMS, GROUPID_CURRENTITEMS }, 
                          { IDS_NOTIFY_PASTITEMS, GROUPID_PASTITEMS }};

        for (int i = 0; i < ARRAYSIZE(groupData); i++)
        {
            str.LoadString(groupData[i].ids);
            LVGROUP lvgrp = { sizeof(LVGROUP) };
            lvgrp.mask = LVGF_HEADER | LVGF_GROUPID;
            lvgrp.pszHeader = (LPTSTR)(LPCTSTR)str;
            lvgrp.cchHeader = lstrlen(lvgrp.pszHeader);
            lvgrp.iGroupId = groupData[i].idGroup;
            SendMessage(_hwndListView, LVM_INSERTGROUP, -1, (LPARAM)&lvgrp);
        }

        //Split width of columns 3/5, 2/5
        RECT rc;
        ::GetClientRect(_hwndListView, &rc);
        int width = rc.right - rc.left - GetSystemMetrics(SM_CXHSCROLL);
        int width0 = 3*width/5;
        int width1 = width-width0;

        LV_COLUMN lvcol = {0};
        lvcol.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
        str.LoadString(IDS_NOTIFYNAME);
        lvcol.pszText = (LPTSTR)(LPCTSTR)str;
        lvcol.cx = width0;
        lvcol.iSubItem = 0;
        ListView_InsertColumn(_hwndListView, 0, &lvcol);

        str.LoadString(IDS_BEHAVIOR);
        lvcol.pszText = (LPTSTR)(LPCTSTR)str;
        lvcol.cx = width1;
        lvcol.iSubItem = 1;
        ListView_InsertColumn(_hwndListView, 1, &lvcol);

        il.SetBkColor(GetSysColor(COLOR_WINDOW));
        ListView_SetImageList(_hwndListView, il, LVSIL_SMALL);
        il.Detach();

        _hwndCombo = GetDlgItem(IDC_COMBO_ACTION);
        // make sure combo box uses same font as list view
        ::SendMessage(_hwndCombo, WM_SETFONT, (WPARAM)::SendMessage(_hwndListView, WM_GETFONT, 0, 0), MAKELPARAM(TRUE, 0));
        for (int i = IDS_NOTIFY_FIRST; i < IDS_NOTIFY_LAST; i++)
        {
            CString strTemp;
            strTemp.LoadString(i);
            ComboBox_AddString(_hwndCombo, strTemp);
        }

        ::SetParent(_hwndCombo, _hwndListView);
        HWND hwndHeader = ListView_GetHeader(_hwndListView);
        ::SetWindowPos(_hwndCombo, hwndHeader, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREDRAW);

        ::SetWindowSubclass(_hwndListView, s_ListViewSubClassWndProc, 0, 
                reinterpret_cast<DWORD_PTR>(this));

        ::SetWindowSubclass(_hwndCombo, s_ComboBoxSubClassWndProc, 0, 
                reinterpret_cast<DWORD_PTR>(this));
    }

    _saItems.RemoveAll();
    
    if (_pTrayNotify)
    {
        _pTrayNotify->Release();
        _pTrayNotify = NULL;
    }

    if (SUCCEEDED(CoCreateInstance(CLSID_TrayNotify, NULL, CLSCTX_LOCAL_SERVER, IID_PPV_ARG(ITrayNotify, &_pTrayNotify))))
    {
        INotificationCB* pCB;

        if (SUCCEEDED(QueryInterface(IID_PPV_ARG(INotificationCB, &pCB))))
        {
            _pTrayNotify->RegisterCallback(pCB);
            pCB->Release();
        }
    }

    // Set the selected and focused state to the first item
    // ListView_SetItemState(hwndLV, 0, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);

    bHandled = TRUE;
    return 0;
}

LRESULT CNotificationsDlg::OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    ::WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(void *)aNotifyOptionsHelpIDs);
    bHandled = TRUE;
    return 0;
}

LRESULT CNotificationsDlg::OnHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    ::WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aNotifyOptionsHelpIDs);
    bHandled = TRUE;
    return 0;
}

LRESULT CNotificationsDlg::OnItemChanged(LPNMHDR pnmh)
{
    _ShowComboBox();
    return 0;
}

LRESULT CNotificationsDlg::OnEndScroll(LPNMHDR pnmh)
{
    _ShowComboBox();
    return 0;
}

LRESULT CNotificationsDlg::OnHeaderItemChanged(WPARAM wParam, LPNMHDR pnmh, LPARAM lParam)
{
    HWND hwndHeader = ListView_GetHeader(_hwndListView);
    if (pnmh->hwndFrom == hwndHeader)
    {
        _ShowComboBox();
    }

    return 0;
}

int CNotificationsDlg::_GetCurSel()
{
    return (int)::SendMessage(_hwndListView, LVM_GETNEXTITEM, -1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0));
}

void CNotificationsDlg::_LoadAndSetLVItemText(UINT uResourceID, DWORD nRow, DWORD nCol)
{
    CString str;
    str.LoadString(uResourceID);
    ListView_SetItemText(_hwndListView, nRow, nCol, (LPTSTR)(LPCTSTR)str);
}

LRESULT CNotificationsDlg::OnComboSelEnd(UINT uMsg, UINT uID ,HWND hwnd)
{
    int nCurIndex = _fComboBoxActive ? _nIndex : _GetCurSel();
    if (nCurIndex != -1)
    {
        DWORD dwUserPref = ComboBox_GetCurSel(_hwndCombo);
        if (dwUserPref != _saItems[nCurIndex].dwUserPref)
        {
            _fItemChanged = TRUE;
            _saItems[nCurIndex].dwUserPref = dwUserPref;
            _LoadAndSetLVItemText(IDS_NOTIFY_FIRST + dwUserPref, nCurIndex, 1);
        }
    }

    return 0;
}

LRESULT CNotificationsDlg::OnRestoreDefaults(UINT uMsg, UINT uID , HWND hwnd)
{
    for (int i=0;i<_saItems.GetSize();i++)
    {
        if (_saItems[i].dwUserPref != TNUP_AUTOMATIC)
        {
            _fItemChanged = TRUE;
            _saItems[i].dwUserPref = TNUP_AUTOMATIC;
            _LoadAndSetLVItemText(IDS_AUTOMATIC, i, 1);
        }
    }

    return 0;
}

LRESULT CNotificationsDlg::OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
    if (wID == IDOK)
    {
        ApplyChanges();
    }

    if (_hPlaceholderIcon)
    {
        DestroyIcon(_hPlaceholderIcon);
        _hPlaceholderIcon = NULL;
    }

    _saItems.RemoveAll();

    if (_hwndListView)
    {
        RemoveWindowSubclass(_hwndListView, s_ListViewSubClassWndProc, 0);
    }

    if (_hwndCombo)
    {
        RemoveWindowSubclass(_hwndCombo, s_ComboBoxSubClassWndProc, 0);
    }

    if (_pTrayNotify)
    {
        _pTrayNotify->RegisterCallback(NULL);
    }

    bHandled = TRUE;
    ::EndDialog(m_hWnd, wID);
    return 0;
}

LRESULT CALLBACK CNotificationsDlg::s_ListViewSubClassWndProc( HWND hwnd, UINT uMsg, 
    WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
    CNotificationsDlg * pNotificationsDlg = reinterpret_cast<CNotificationsDlg*>(dwRefData);
    AssertMsg((pNotificationsDlg != NULL), TEXT("pNotificationsDlg SHOULD NOT be NULL."));

    switch (uMsg)
    {
        case WM_KEYDOWN:
        {
            if (wParam == VK_RIGHT && !pNotificationsDlg->_fComboBoxActive)
            {
                int nIndex = pNotificationsDlg->_GetCurSel();
                if (nIndex != -1)
                {
                    pNotificationsDlg->_nIndex = nIndex;
                    pNotificationsDlg->_fComboBoxActive = TRUE;
                    ::SetFocus(pNotificationsDlg->_hwndCombo);
                }
                return 0;
            }
        }
        break;
    }

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

LRESULT CALLBACK CNotificationsDlg::s_ComboBoxSubClassWndProc( HWND hwnd, UINT uMsg, 
    WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
    CNotificationsDlg * pNotificationsDlg = reinterpret_cast<CNotificationsDlg*>(dwRefData);
    AssertMsg((pNotificationsDlg != NULL), TEXT("pNotificationsDlg SHOULD NOT be NULL."));

    switch (uMsg)
    {
        case WM_KEYDOWN:
        {
            if (pNotificationsDlg->_fComboBoxActive)
            {
                if (wParam == VK_LEFT)
                {
                    pNotificationsDlg->_fComboBoxActive = FALSE;
                    pNotificationsDlg->_nIndex = 0;
                    ::SetFocus(pNotificationsDlg->_hwndListView);
                    return 0;
                }
                else if (wParam == VK_RIGHT)
                {
                    // Disable selection in combo on right button
                    return 0;
                }
            }
        }
        break;

        case WM_KILLFOCUS:
        {
            if (pNotificationsDlg->_fComboBoxActive)
            {
                pNotificationsDlg->_fComboBoxActive = FALSE;
                pNotificationsDlg->_nIndex = 0;
            }
        }
        break;
    }

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

void CNotificationsDlg::ApplyChanges(void)
{
    if (!_fItemChanged)
        return;
        
    if (_pTrayNotify)
    {
        for (int i = 0; i < _saItems.GetSize(); i++)
        {
            _pTrayNotify->SetPreference(&_saItems[i]);
        }
    }
}

void CNotificationsDlg::_ShowComboBox(void)
{
    int nCurIndex = _GetCurSel();
        
    if (!_fComboBoxActive && nCurIndex == -1)
    {
        ::ShowWindow(_hwndCombo, SW_HIDE);
    }
    else if (nCurIndex != -1)
    {
        RECT rcListView;
        ::GetClientRect(_hwndListView, &rcListView);

        RECT rc;
        ListView_GetItemRect(_hwndListView, nCurIndex, &rc, LVIR_BOUNDS);

        RECT rcHeader;
        HWND hwndHeader = ListView_GetHeader(_hwndListView);
        Header_GetItemRect(hwndHeader, 1, &rcHeader);
        rc.left = rcHeader.left;
        rc.right = rcHeader.right;

        if (!EqualRect(&_rcOldPos, &rc))
        {
            _rcOldPos = rc;
            ::MoveWindow(_hwndCombo, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, TRUE);
        }

        if (!::IsWindowVisible(_hwndCombo))
        {
            ::ShowWindow(_hwndCombo, SW_SHOW);
            ComboBox_SetCurSel(_hwndCombo, _saItems[nCurIndex].dwUserPref);
        }
    }
}


//This is the property sheet for all of the task bar stuff
class CTaskBarPropertySheet : public CPropertySheetImpl<CTaskBarPropertySheet>
{
public:
    CTaskBarPropertySheet(UINT nStartPage, HWND hwndParent, DWORD dwFlags) : 
        CPropertySheetImpl<CTaskBarPropertySheet>((LPCTSTR)NULL, nStartPage, hwndParent),
        _dwFlags(dwFlags)
    {
        LoadString(hinstCabinet, IDS_STARTMENUANDTASKBAR, szPath, ARRAYSIZE(szPath));
        SetTitle(szPath);

        HPROPSHEETPAGE hpage;
        PROPSHEETPAGE psp;

        psp.dwSize = sizeof(psp);
        psp.dwFlags = PSP_DEFAULT;
        psp.hInstance = hinstCabinet;

        //taskbar page
        psp.pszTemplate = MAKEINTRESOURCE(DLG_TRAY_OPTIONS);
        psp.pfnDlgProc = s_TaskbarOptionsDlgProc;
        psp.lParam = (LPARAM) this;
        hpage = CreatePropertySheetPage(&psp);
        if (hpage)
            AddPage(hpage);

        //start page
        psp.pszTemplate = MAKEINTRESOURCE(DLG_START);
        psp.pfnDlgProc = s_StartMenuDlgProc;
        psp.lParam = (LPARAM) this;
        hpage = CreatePropertySheetPage(&psp);
        if (hpage)
            AddPage(hpage);

        //
        //   We really want to have the tree-options work like the StartPageOptionHelper class above, but 
        // it stores state in the treeview, which goes away when the child dialog is closed.  So for now, 
        // have it save when the customize dialog is closed, not when the parent is closed.
        //   Still, have the lifetime of the object be controlled by the parent.
        //
        if (FAILED(CoCreateInstance(CLSID_CRegTreeOptions, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IRegTreeOptions, &_Adv.pTO))))
        {
            TraceMsg(TF_WARNING, "ctbps failed to create CRegTreeOptions");
        }

        _pDlgNotify = new CComObject<CNotificationsDlg>;
        if (_pDlgNotify)
        {
            _pDlgNotify->AddRef();
        }
    }

    ~CTaskBarPropertySheet()
    {
        ATOMICRELEASE(_Adv.pTO);
        ATOMICRELEASE(_pDlgNotify);
    }

    // We aren't handling any messages special, so we just make an empty map
    DECLARE_EMPTY_MSG_MAP()
private:

    // dlgproc's for the various pages
    static BOOL_PTR s_TaskbarOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    static BOOL_PTR s_StartMenuDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    BOOL_PTR TaskbarOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    BOOL_PTR StartMenuDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

    void _ApplyTaskbarOptionsFromDialog(HWND hDlg);
    void _ApplyStartOptionsFromDialog(HWND hDlg);

    // for the old style customize dialog
    SMADVANCED  _Adv;
    //need to keep storage for the title until the property sheet is created
    TCHAR szPath[MAX_PATH];
    CComObject<CNotificationsDlg>* _pDlgNotify;

    DWORD _dwFlags;
};

//
// RegSaveDefaultClient
//
void RegSaveDefaultClient(HWND hwndCB, LPCTSTR pszPath)
{
    int iSelected = ComboBox_GetCurSel(hwndCB);
    if (iSelected >= 0)
    {
        LPTSTR pszKey = (LPTSTR)ComboBox_GetItemData(hwndCB, iSelected);
        if (pszKey)
        {
            if (SHSetValue(HKEY_CURRENT_USER, pszPath, NULL, REG_SZ, pszKey, sizeof(TCHAR) * (1 + lstrlen(pszKey))) == ERROR_SUCCESS)
            {
                SHSendMessageBroadcast(WM_SETTINGCHANGE, 0, (LPARAM)pszPath);
            }
        }
    }
}

BOOL RegGetDefaultClient(HWND hwndCB, HKEY hkRoot, LPCTSTR pszPath)
{
    TCHAR szCurrent[MAX_PATH];
    LONG cb = sizeof(szCurrent);

    cb = sizeof(szCurrent);
    if (RegQueryValue(hkRoot, pszPath, szCurrent, &cb) != ERROR_SUCCESS ||
        szCurrent[0] == TEXT('\0'))
    {
        return FALSE;
    }

    // Now make sure the selected client exists
    int i = ComboBox_GetCount(hwndCB);
    while (--i >= 0)
    {
        LPTSTR pszKey = (LPTSTR)ComboBox_GetItemData(hwndCB, i);
        // Use StrCmpIC so we don't get faked out by Hungarian locale...
        if (pszKey && StrCmpIC(pszKey, szCurrent) == 0)
        {
            ComboBox_SetCurSel(hwndCB, i);
            return TRUE;
        }
    }

    return FALSE;
}


void RegPopulateComboBox(HWND hwndCB, LPCTSTR pszPath)
{
    TCHAR           szFriendlyName      [MAX_PATH];
    TCHAR           szKeyName           [MAX_PATH];

    DWORD   i;              // Index counter

    HKEY    hkeyProtocol;

    // See if the clients key even exists...
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszPath, 0, KEY_READ, &hkeyProtocol) != ERROR_SUCCESS)
        return;

    // populate the dropdown
    for(i=0;                    // always start with 0
        ERROR_SUCCESS==RegEnumKey(hkeyProtocol, i, szKeyName, ARRAYSIZE(szKeyName));
        i++)                    // get next entry
    {
        // get the friendly name of the client
        if (SUCCEEDED(SHLoadLegacyRegUIString(hkeyProtocol, szKeyName, szFriendlyName, ARRAYSIZE(szFriendlyName))))
        {
            // save its key name so we can find it later
            LPTSTR pszKeyName = StrDup(szKeyName);
            if (pszKeyName)
            {
                // add name to dropdown
                int iAdded = ComboBox_AddString(hwndCB, szFriendlyName);
                if (iAdded >= 0)
                {
                    ComboBox_SetItemData(hwndCB, iAdded, pszKeyName);
                }
                else
                {
                    LocalFree(pszKeyName);
                }
            }
        }
    }

    RegCloseKey(hkeyProtocol);

    // Do this after populating the dropdown because we need to look into
    // the dropdown to see if the current value is valid or not

    //
    //  First try HKCU; then try HKLM...
    //
    if (!RegGetDefaultClient(hwndCB, HKEY_CURRENT_USER, pszPath))
    {
        RegGetDefaultClient(hwndCB, HKEY_LOCAL_MACHINE, pszPath);
    }
}

void RegClearClientComboBox(HWND hDlg, UINT idc)
{
    HWND hwndCB = GetDlgItem(hDlg, idc);

    int i = ComboBox_GetCount(hwndCB);
    while (--i >= 0)
    {
        LPTSTR pszKey = (LPTSTR)ComboBox_GetItemData(hwndCB, i);
        LocalFree(pszKey);
    }
}

void HandleClearButtonClick(HWND hwndClear);
void SetDocButton(HWND hDlg, int id);

//This is the property sheet for the "Customize Simple Start Menu" dlg
class CCustomizeSPPropSheet : public CPropertySheetImpl<CCustomizeSPPropSheet>
{
public:
    CCustomizeSPPropSheet(HWND hwndParent) : 
        CPropertySheetImpl<CCustomizeSPPropSheet>((LPCTSTR)NULL, 0, hwndParent)
      , _fInsideInit(FALSE)
    {
        HPROPSHEETPAGE hpage;
        PROPSHEETPAGE psp;

        // We are heap-allocated so these should be pre-initialized properly
        ASSERT(_bDirtyTree == FALSE);
        ASSERT(_prto == NULL);
        ASSERT(_pph == NULL);

        LoadString(hinstCabinet, IDS_SPCUST_TITLE, _szTitle, ARRAYSIZE(_szTitle));
        SetTitle(_szTitle);

        m_psh.dwFlags |= PSH_NOAPPLYNOW;

        psp.dwSize = sizeof(psp);
        psp.dwFlags = PSP_DEFAULT;
        psp.hInstance = hinstCabinet;

        //General page
        psp.pszTemplate = MAKEINTRESOURCE(DLG_PAGE_SMGENERAL);
        psp.pfnDlgProc = s_GeneralTabDlgProc;
        psp.lParam = (LPARAM) this;
        hpage = CreatePropertySheetPage(&psp);
        if (hpage)
            AddPage(hpage);

        //Advanced page
        psp.pszTemplate = MAKEINTRESOURCE(DLG_PAGE_SMADVANCED);
        psp.pfnDlgProc = s_AdvancedTabDlgProc;
        psp.lParam = (LPARAM) this;
        hpage = CreatePropertySheetPage(&psp);
        if (hpage)
            AddPage(hpage);

    };

    ~CCustomizeSPPropSheet()
    {
        if (_pph)
            delete _pph;

        ATOMICRELEASE(_prto);
    }

private:

    // dlgproc's for the various pages
    static BOOL_PTR s_GeneralTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    static BOOL_PTR s_AdvancedTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    BOOL_PTR GeneralTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    BOOL_PTR AdvancedTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
    BOOL GeneralTabInit(HWND hDlg);
    BOOL AdvancedTabInit(HWND hDlg);

    BOOL OnCommand(UINT id, UINT code, HWND hwndCtl, HWND hwndDlg); // shared command handler
    BOOL OnGeneralApply(HWND hwndDlg);
    BOOL_PTR OnAdvancedNotify(HWND hwndDlg, NMHDR * pnm);
    BOOL_PTR OnAdvancedHelp(HWND hDlg, HELPINFO *phi);

    void _InitMagicEntries();
    void _SaveMagicEntries();

    //helpers
    DWORD _ReadStartPageSetting(LPCTSTR pszVal, DWORD dwDefault)
    {
        DWORD dw, cb=sizeof(dw), dwType;
        SHRegGetUSValue(REGSTR_PATH_STARTPANE_SETTINGS, pszVal, &dwType, &dw, &cb, FALSE, &dwDefault, sizeof(dwDefault));
        return dw; // since we passed a default value, above fn will return our default on failure
    }
    BOOL _ReadStartPageCUSetting(LPCTSTR pszVal, DWORD *pdw) // returns TRUE/FALSE for present under CU or not, actual value in pdw
    {
        DWORD cb=sizeof(*pdw), dwType;
        return NO_ERROR == SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_STARTPANE_SETTINGS, pszVal, &dwType, pdw, &cb);
    }
    BOOL _WriteStartPageSetting(LPCTSTR pszVal, DWORD dwVal)
    {
        return SHSetValue(HKEY_CURRENT_USER, REGSTR_PATH_STARTPANE_SETTINGS, pszVal, REG_DWORD, &dwVal, sizeof(DWORD)) == NO_ERROR;
    }
    BOOL _ClearStartPageSetting(LPCTSTR pszVal)
    {
        return SHDeleteValue(HKEY_CURRENT_USER, REGSTR_PATH_STARTPANE_SETTINGS, pszVal) == NO_ERROR;
    }

    // State
    BOOL _bLargeIcons;
    IRegTreeOptions *_prto;

    // Dirty Flags
    BOOL _bDirtyTree;       // to avoid saving the tree if we don't need to
    BOOL _bDirtyClients;    // to avoid saving the clients if we don't need to
    BOOL _bDirtyPinList;    // to avoid re-persisting the pin list (and possibly changing the order)
    BOOL _bCustNetPlaces;   // Did the user previously have net places customized?
    BOOL _bCustNetConn;     // Did the user previously have net connections customized?

    // random bits
    CPinHelper *_pph;
    TCHAR _szTitle[80];      // needed for the propsheet title...

    // We need this to take care of initialization!
    BOOL  _fInsideInit;
};

BOOL_PTR CCustomizeSPPropSheet::s_GeneralTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CCustomizeSPPropSheet* self = NULL;

    if (uMsg == WM_INITDIALOG)
    {
        ::SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        self = (CCustomizeSPPropSheet*) ((PROPSHEETPAGE*)lParam)->lParam;
    }
    else
    {
        PROPSHEETPAGE* psp = (PROPSHEETPAGE*)::GetWindowLongPtr(hDlg, DWLP_USER);
        if (psp)
            self = (CCustomizeSPPropSheet*)psp->lParam;
    }

    if (self)
    {
        return self->GeneralTabDlgProc(hDlg, uMsg, wParam, lParam);
    }
    else
    {
        return FALSE;
    }
}

BOOL_PTR CCustomizeSPPropSheet::s_AdvancedTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CCustomizeSPPropSheet* self = NULL;

    if (uMsg == WM_INITDIALOG)
    {
        ::SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        self = (CCustomizeSPPropSheet*) ((PROPSHEETPAGE*)lParam)->lParam;
    }
    else
    {
        PROPSHEETPAGE* psp = (PROPSHEETPAGE*)::GetWindowLongPtr(hDlg, DWLP_USER);
        if (psp)
            self = (CCustomizeSPPropSheet*)psp->lParam;
    }

    if (self)
    {
        return self->AdvancedTabDlgProc(hDlg, uMsg, wParam, lParam);
    }
    else
    {
        return FALSE;
    }
}

BOOL_PTR CCustomizeSPPropSheet::GeneralTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
            return GeneralTabInit(hDlg);
        case WM_COMMAND:
            return OnCommand(LOWORD(wParam), HIWORD(wParam), (HWND) lParam, hDlg);
        case WM_DESTROY:
            {
                SetDlgItemIcon(hDlg, IDC_SPCUST_ICONSMALL, NULL);
                SetDlgItemIcon(hDlg, IDC_SPCUST_ICONLARGE, NULL);
                RegClearClientComboBox(hDlg, IDC_SPCUST_EMAILCB);
                RegClearClientComboBox(hDlg, IDC_SPCUST_INTERNETCB);
                break;
            }
        case WM_NOTIFY:
            switch (((NMHDR*)lParam)->code)
            {
                case PSN_APPLY:
                    return OnGeneralApply(hDlg);

            }
            break;

        case WM_HELP:
            ::WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aStartCustGeneralTabHelpIDs);
            break;

        case WM_CONTEXTMENU:
            ::WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(void *)aStartCustGeneralTabHelpIDs);
            break;
    }
    return FALSE;
}

BOOL CCustomizeSPPropSheet::GeneralTabInit(HWND hDlg)
{
    _fInsideInit = TRUE; //We are getting inside initilization!
    
    ::SendMessage(::GetDlgItem(hDlg, IDC_SPCUST_MINPROGS_ARROW), UDM_SETRANGE, 0, (LPARAM)MAKELONG(MAX_PROGS_ALLOWED, 0));
    
    // set up icon size
    _bLargeIcons = _ReadStartPageSetting(REGSTR_VAL_DV2_LARGEICONS, /*bDefault*/ TRUE);
    ::CheckDlgButton(hDlg, IDC_SPCUST_LARGE, _bLargeIcons);
    ::CheckDlgButton(hDlg, IDC_SPCUST_SMALL, !_bLargeIcons);

    SetProgramIcon(hDlg, IDC_SPCUST_ICONLARGE, IDC_SPCUST_ICONSMALL);

    // Set up the Number of programs dropdown
    DWORD dwMinMFU = _ReadStartPageSetting(REGSTR_VAL_DV2_MINMFU, REGSTR_VAL_DV2_MINMFU_DEFAULT);
    ::SetDlgItemInt(hDlg, IDC_SPCUST_MINPROGS, dwMinMFU, FALSE);

    // Set up internet, email checkboxes and comboboxes
    BOOL bInternet=FALSE, bMail=FALSE;
    RegPopulateComboBox(::GetDlgItem(hDlg, IDC_SPCUST_EMAILCB), TEXT("SOFTWARE\\Clients\\mail"));
    RegPopulateComboBox(::GetDlgItem(hDlg, IDC_SPCUST_INTERNETCB), TEXT("SOFTWARE\\Clients\\StartMenuInternet"));

    // if this fails, its not fatal, we just won't be able to persist the pin info
    _pph = new CPinHelper();
    if (_pph)
    {
        _pph->GetPinInfo(&bInternet, &bMail);
    }

    ::CheckDlgButton(hDlg, IDC_SPCUST_INTERNET, bInternet);
    ::CheckDlgButton(hDlg, IDC_SPCUST_EMAIL,    bMail);
    ::EnableWindow(::GetDlgItem(hDlg, IDC_SPCUST_INTERNETCB), bInternet);
    ::EnableWindow(::GetDlgItem(hDlg, IDC_SPCUST_EMAILCB),   bMail);

    _fInsideInit = FALSE;  //We are done initializing.
    
    return TRUE;
}

// Temp until the new UEM code gets in...
void ClearUEMData()
{
    HKEY hk;

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER TEXT("\\UserAssist\\{75048700-EF1F-11D0-9888-006097DEACF9}\\Count"), 
        0, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE | KEY_SET_VALUE,
        &hk))
    {
        int cValues;
        if (ERROR_SUCCESS == RegQueryInfoKey(hk, NULL, NULL, NULL, NULL, NULL, NULL, (DWORD*) &cValues, NULL, NULL, NULL, NULL))
        {
            while (cValues >= 0)
            {
                TCHAR szValue[MAX_PATH];
                DWORD cch = ARRAYSIZE(szValue);
                DWORD cbData;
                if (ERROR_SUCCESS != RegEnumValue(hk, --cValues, szValue, &cch, NULL, NULL, NULL, &cbData))
                    break;
                // don't nuke the session value
                if (cbData > 8)
                    RegDeleteValue(hk, szValue);
            }
#ifdef DEBUG
            RegQueryInfoKey(hk, NULL, NULL, NULL, NULL, NULL, NULL, (DWORD*) &cValues, NULL, NULL, NULL, NULL);
            ASSERT(cValues == 1);           // the session info value should still exist
#endif
        }

        RegCloseKey(hk);

        // Set the "Apps installed prior to this point are not interesting"
        // to the current time.  Since we deleted all the usages, we have to
        // do something to prevent all the user's apps from being redetected
        // as "newly installed and not yet run".

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


        // Start a new session - this kick-starts anybody who is listening
        // to UEM events to tell them their cache is invalid
        UEMFireEvent(&UEMIID_SHELL, UEME_CTLSESSION, UEMF_XEVENT, TRUE, -1);
    }
}

void AdjustNumOfProgsOnStartMenu(HWND hwndDlg, UINT Id)
{
    BOOL fTranslated;
    int iNumOfProgs = (int)GetDlgItemInt(hwndDlg, Id, &fTranslated, FALSE);
    int iNewNumOfProgs = min(max(iNumOfProgs, 0), MAX_PROGS_ALLOWED);
    if((iNumOfProgs != iNewNumOfProgs) || (!fTranslated))
    {
        SetDlgItemInt(hwndDlg, Id, (UINT)iNewNumOfProgs, FALSE);
        SendPSMChanged(hwndDlg);
    }
}

// NOTE - shared WM_COMMAND handler
//
BOOL CCustomizeSPPropSheet::OnCommand(UINT id, UINT code, HWND hwndCtl, HWND hwndDlg)
{
    switch (id)
    {
        ////// General Tab Controls
        case IDC_SPCUST_LARGE:
        case IDC_SPCUST_SMALL:
            _bLargeIcons = (id == IDC_SPCUST_LARGE);
            SendPSMChanged(hwndDlg);
            return FALSE;
        case IDC_SPCUST_MINPROGS:
            if(code == EN_KILLFOCUS)
                AdjustNumOfProgsOnStartMenu(hwndDlg, id);
            else
            {
                if ((_fInsideInit == FALSE) && (code == EN_CHANGE))
                    SendPSMChanged(hwndDlg);
            }
            return FALSE;
            
        case IDB_SPCUST_CLEARPROG:
            ClearUEMData();
            return FALSE;

        case IDC_SPCUST_INTERNET:
        case IDC_SPCUST_EMAIL:
            COMPILETIME_ASSERT(IDC_SPCUST_INTERNETCB == IDC_SPCUST_INTERNET+1);
            COMPILETIME_ASSERT(IDC_SPCUST_EMAILCB == IDC_SPCUST_EMAIL+1);
            ::EnableWindow(::GetDlgItem(hwndDlg, id+1), ::IsDlgButtonChecked(hwndDlg, id));
            _bDirtyPinList = TRUE;
            SendPSMChanged(hwndDlg);
            return FALSE;

        case IDC_SPCUST_INTERNETCB:
        case IDC_SPCUST_EMAILCB:
            if (code == CBN_SELCHANGE)
            {
                _bDirtyClients = TRUE;
                SendPSMChanged(hwndDlg);
            }
            return FALSE;


        ////// Advanced Tab Controls
        case IDC_SPCUST_RECENT:
            SendPSMChanged(hwndDlg);
            return FALSE;
        case IDB_SPCUST_CLEARDOCS:
            HandleClearButtonClick(hwndCtl);
            return FALSE;

        case IDC_SPCUST_HOVEROPEN:
        case IDC_SPCUST_NOTIFYNEW:
            SendPSMChanged(hwndDlg);
            return FALSE;
            break;

    }
    return TRUE;
}

BOOL CCustomizeSPPropSheet::OnGeneralApply(HWND hDlg)
{
    TraceMsg(TF_ALWAYS, "cspps.General apply", _bDirtyTree);

    _WriteStartPageSetting(REGSTR_VAL_DV2_LARGEICONS,  _bLargeIcons);

    if (_pph && _bDirtyPinList)
    {
        BOOL bInternet  = ::IsDlgButtonChecked(hDlg, IDC_SPCUST_INTERNET);
        BOOL bMail      = ::IsDlgButtonChecked(hDlg, IDC_SPCUST_EMAIL);
        _pph->Save(bMail, bInternet);
    }
    if (_bDirtyClients)
    {
        // persist Internet, Mail comboboxes
        RegSaveDefaultClient(::GetDlgItem(hDlg, IDC_SPCUST_EMAILCB), TEXT("Software\\Clients\\mail"));
        RegSaveDefaultClient(::GetDlgItem(hDlg, IDC_SPCUST_INTERNETCB), TEXT("SOFTWARE\\Clients\\StartMenuInternet"));
    }

    BOOL bTranslated;
    DWORD dwMinMFU = ::GetDlgItemInt(hDlg, IDC_SPCUST_MINPROGS, &bTranslated, FALSE);
    if (EVAL(bTranslated))
    {
        dwMinMFU = min(max(dwMinMFU, 0), MAX_PROGS_ALLOWED);
        _WriteStartPageSetting(REGSTR_VAL_DV2_MINMFU, dwMinMFU);
    }

    return TRUE;

}

BOOL_PTR CCustomizeSPPropSheet::OnAdvancedNotify(HWND hwndDlg, NMHDR * pnm)
{
    ::SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, 0); // handled
    switch (pnm->code)
    {
        case PSN_APPLY:
            TraceMsg(TF_ALWAYS, "cspps.Advanced apply - _bDirtyTree=%d", _bDirtyTree);
            if (_bDirtyTree)
            {
                _prto->WalkTree(WALK_TREE_SAVE);
            }

            _WriteStartPageSetting(REGSTR_VAL_DV2_SHOWRECDOCS,  ::IsDlgButtonChecked(hwndDlg, IDC_SPCUST_RECENT) ? 2 : 0);  // 2 so that it cascades
            _WriteStartPageSetting(REGSTR_VAL_DV2_AUTOCASCADE,  ::IsDlgButtonChecked(hwndDlg, IDC_SPCUST_HOVEROPEN));
            _WriteStartPageSetting(REGSTR_VAL_DV2_NOTIFYNEW,    ::IsDlgButtonChecked(hwndDlg, IDC_SPCUST_NOTIFYNEW));
            // fall through to PSN_RESET case...

        case PSN_RESET:
            _SaveMagicEntries(); // this must be called on both cancel and apply, so that it cleans up properly...
            break;

        case TVN_KEYDOWN:
        {
            TV_KEYDOWN *pnmtv = (TV_KEYDOWN*)pnm;
            if (pnmtv->wVKey == VK_SPACE)
            {
                HWND hwndTree = ::GetDlgItem(hwndDlg, IDC_STARTMENUSETTINGS);
                _prto->ToggleItem((HTREEITEM)SendMessage(hwndTree, TVM_GETNEXTITEM, (WPARAM)TVGN_CARET, 0L));
                _bDirtyTree = TRUE;
                SendPSMChanged(hwndDlg);
                ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, TRUE); // eat the key
            }
            break;
        }

        case NM_CLICK:
        case NM_DBLCLK:
            // is this click in our tree?
            if ( pnm->idFrom == IDC_STARTMENUSETTINGS )
            {
                HWND hwndTree = ::GetDlgItem(hwndDlg, IDC_STARTMENUSETTINGS);
                TV_HITTESTINFO ht;

                DWORD dwPos = GetMessagePos();                  // get where we were hit
                ht.pt.x = GET_X_LPARAM(dwPos);
                ht.pt.y = GET_Y_LPARAM(dwPos);
                ::ScreenToClient(hwndTree, &ht.pt);       // translate it to our window

                // retrieve the item hit
                HTREEITEM hti = TreeView_HitTest(hwndTree, &ht);
                if (hti)
                {
                    _prto->ToggleItem(hti);
                    _bDirtyTree = TRUE;
                    SendPSMChanged(hwndDlg);
                }
            }

            break;
        // no help yet- needs ids/text from UA
#if 0
        case NM_RCLICK:      // right mouse click
            if (pnm->hwndFrom == hwndTree)
            {
                _DoTreeHelp(pAdv, (WPARAM)pnm->hwndFrom);
                SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, TRUE); // eat the click
                return TRUE;
            }
            break;
#endif 
    }
    return TRUE;
}

BOOL_PTR CCustomizeSPPropSheet::OnAdvancedHelp(HWND hDlg, HELPINFO *phi)
{
    if (phi->iCtrlId != IDC_STARTMENUSETTINGS)
    {
        ::WinHelp((HWND)(phi->hItemHandle), NULL, HELP_WM_HELP, (ULONG_PTR)(LPTSTR)aStartCustAdvancedTabHelpIDs);
    }
    else
    {
        HTREEITEM hItem;
        HWND hwndTree = ::GetDlgItem(hDlg, IDC_STARTMENUSETTINGS);

        //Is this help invoked throught F1 key
        if (GetAsyncKeyState(VK_F1) < 0)
        {
            // Yes. WE need to give help for the currently selected item
            hItem = TreeView_GetSelection(hwndTree);
        }
        else
        {
            //No, We need to give help for the item at the cursor position
            TV_HITTESTINFO ht;
            ht.pt = phi->MousePos;
            ::ScreenToClient(hwndTree, &ht.pt); // Translate it to our window
            hItem = TreeView_HitTest(hwndTree, &ht);
        }

        if (hItem)
            _prto->ShowHelp(hItem, HELP_WM_HELP);
    }
    return TRUE;
}

BOOL_PTR CCustomizeSPPropSheet::AdvancedTabDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
            return AdvancedTabInit(hDlg);
        case WM_COMMAND:
            return OnCommand(LOWORD(wParam), HIWORD(wParam), (HWND) lParam, hDlg);
        case WM_NOTIFY:
            return OnAdvancedNotify(hDlg, (NMHDR*)lParam);
        case WM_HELP:
            return OnAdvancedHelp(hDlg, (HELPINFO*) lParam);
            break;
        case WM_CONTEXTMENU:
            ::WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(void *)aStartCustAdvancedTabHelpIDs);
            break;
    }
    return FALSE;
}

int DefaultNetConValue()
{
    return ShouldShowConnectTo() ? 2 : 0;      // default to menu-style (2)
}

int DefaultNetPlacesValue()
{
    return ShouldShowNetPlaces() ? 1 : 0;      // default to link -style (1)
}

// These two "magic" functions maintain the proper behavior of the network places and network connections settings
// which, by default, turn on when there are n or more items in the folder.  But they can also be customized by the
// user to force them on or off.

void CCustomizeSPPropSheet::_InitMagicEntries()
{
    BOOL bNewNetPlaces;
    BOOL bNewNetConn;

    _bCustNetPlaces = _ReadStartPageCUSetting(REGSTR_VAL_DV2_SHOWNETPL, (DWORD*) &bNewNetPlaces);
    _bCustNetConn = _ReadStartPageCUSetting(REGSTR_VAL_DV2_SHOWNETCONN, (DWORD*) &bNewNetConn);
    // if the user didn't previously customize these settings, then use the auto-magic setting
    if (!_bCustNetPlaces)
        bNewNetPlaces = DefaultNetPlacesValue();
    if (!_bCustNetConn)
        bNewNetConn   = DefaultNetConValue();

    // Write it out, so the rgtreeoption control will reflect either the user's customization, or the magic value
    _WriteStartPageSetting(REGSTR_VAL_DV2_SHOWNETPL, bNewNetPlaces);
    _WriteStartPageSetting(REGSTR_VAL_DV2_SHOWNETCONN, bNewNetConn);

    // for the admin tools radio buttons:
    // 0 = don't show anywhere
    // 1 = display in all programs (StartMenuAdminTools = 1, Start_AdminToolsRoot = 0)
    // 2 = display in all programs and root (StartMenuAdminTools = 1, Start_AdminToolsRoot = 2)
    int iAdminToolsTemp = _ReadStartPageSetting(REGSTR_VAL_DV2_ADMINTOOLSROOT, FALSE) ? 2 :
                          (_ReadStartPageSetting(TEXT("StartMenuAdminTools"), FALSE) ? 1 : 0);

    _WriteStartPageSetting(REGSTR_VAL_ADMINTOOLSTEMP, iAdminToolsTemp);
}

void CCustomizeSPPropSheet::_SaveMagicEntries()
{
    BOOL bNewNetPlaces = _ReadStartPageSetting(REGSTR_VAL_DV2_SHOWNETPL, FALSE);
    BOOL bNewNetConn   = _ReadStartPageSetting(REGSTR_VAL_DV2_SHOWNETCONN, FALSE);

    // if the user previously had it customized, then we don't need to clear it since it will either
    // contain the original value we loaded in _InitMagicEntries, or the updated value if the user changed it.
    // if it wasn't originally customized, then we need to clear it if the tree isn't even dirty, or the current value is the magic value we loaded

    if (!_bCustNetPlaces && (!_bDirtyTree || bNewNetPlaces == DefaultNetPlacesValue()))
        _ClearStartPageSetting(REGSTR_VAL_DV2_SHOWNETPL);

    if (!_bCustNetConn && (!_bDirtyTree || bNewNetConn == DefaultNetConValue()))
        _ClearStartPageSetting(REGSTR_VAL_DV2_SHOWNETCONN);

    if (_bDirtyTree)
    {
        // see comment above for how this should work
        int iAdminToolsTemp = _ReadStartPageSetting(REGSTR_VAL_ADMINTOOLSTEMP, FALSE);
        int iATRoot = 0;
        int iATPrograms = 0;

        if (iAdminToolsTemp >= 1)
        {
            iATPrograms = 1;
            if (iAdminToolsTemp == 2)
            {
                iATRoot = 2;
            }
        }
        _WriteStartPageSetting(REGSTR_VAL_DV2_ADMINTOOLSROOT, iATRoot);
        _WriteStartPageSetting(TEXT("StartMenuAdminTools"), iATPrograms);
    }
    _ClearStartPageSetting(REGSTR_VAL_ADMINTOOLSTEMP);
}

BOOL CCustomizeSPPropSheet::AdvancedTabInit(HWND hDlg)
{
    if (SUCCEEDED(CoCreateInstance(CLSID_CRegTreeOptions, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IRegTreeOptions, &_prto))))
    {
        HRESULT hr;
        HWND hwndTV = ::GetDlgItem(hDlg, IDC_STARTMENUSETTINGS);

        // Compute the magic entries before we init the RegTreeOptions
        // (so we will have correct information for him!)
        _InitMagicEntries();

        // HACKHACK - IRegTreeOptions is ANSI, so we temporarily turn off UNICODE
        #undef TEXT
        #define TEXT(s) s
        hr = _prto->InitTree(hwndTV, HKEY_LOCAL_MACHINE, REGSTR_PATH_SMADVANCED "\\StartPanel", NULL);

        #undef TEXT
        #define TEXT(s) __TEXT(s)

        TreeView_SelectSetFirstVisible(hwndTV, TreeView_GetRoot(hwndTV));

        ::CheckDlgButton(hDlg, IDC_SPCUST_RECENT,   _ReadStartPageSetting(REGSTR_VAL_DV2_SHOWRECDOCS, IsOS(OS_PERSONAL) ? FALSE : TRUE));
        ::CheckDlgButton(hDlg, IDC_SPCUST_HOVEROPEN,_ReadStartPageSetting(REGSTR_VAL_DV2_AUTOCASCADE, TRUE));
        ::CheckDlgButton(hDlg, IDC_SPCUST_NOTIFYNEW,_ReadStartPageSetting(REGSTR_VAL_DV2_NOTIFYNEW, TRUE));

        if(SHRestricted(REST_NORECENTDOCSMENU))
        {
            //Since this policy is present, hide all the relevant controls
            ::ShowWindow(::GetDlgItem(hDlg, IDC_SPCUST_RECENT_GROUPBOX), FALSE);// Group box
            ::ShowWindow(::GetDlgItem(hDlg, IDC_SPCUST_RECENT_TEXT), FALSE);    // Description Text.
            ::ShowWindow(::GetDlgItem(hDlg, IDC_SPCUST_RECENT), FALSE);         // Check box
            ::ShowWindow(::GetDlgItem(hDlg, IDB_SPCUST_CLEARDOCS), FALSE);      // Clear button.
        }

        SetDocButton(hDlg, IDB_SPCUST_CLEARDOCS);

        return TRUE;
    }

    
    return FALSE;
}

BOOL_PTR CTaskBarPropertySheet::s_TaskbarOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CTaskBarPropertySheet* self = NULL;

    if (uMsg == WM_INITDIALOG)
    {
        ::SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        self = (CTaskBarPropertySheet*) ((PROPSHEETPAGE*)lParam)->lParam;
    }
    else
    {
        PROPSHEETPAGE* psp = (PROPSHEETPAGE*)::GetWindowLongPtr(hDlg, DWLP_USER);
        if (psp)
            self = (CTaskBarPropertySheet*)psp->lParam;
    }

    
    BOOL_PTR fValue = FALSE;
    if (self)
    {
        self->TaskbarOptionsDlgProc(hDlg, uMsg, wParam, lParam);
    }

    return fValue;
}

void _TaskbarOptions_OnInitDialog(HWND hDlg)
{
    TRAYVIEWOPTS tvo;
    c_tray.GetTrayViewOpts(&tvo);
    
    CheckDlgButton(hDlg, IDC_QUICKLAUNCH, tvo.fShowQuickLaunch);
    CheckDlgButton(hDlg, IDC_TRAYOPTONTOP, tvo.fAlwaysOnTop);
    CheckDlgButton(hDlg, IDC_TRAYOPTAUTOHIDE, (tvo.uAutoHide & AH_ON));
    CheckDlgButton(hDlg, IDC_TRAYOPTSHOWCLOCK, !tvo.fHideClock);
    if (SHRestricted(REST_HIDECLOCK))
    {
        EnableWindow(GetDlgItem(hDlg, IDC_TRAYOPTSHOWCLOCK), FALSE);
    }

    if (SHRestricted(REST_NOTOOLBARSONTASKBAR))
    {
        EnableWindow(GetDlgItem(hDlg, IDC_QUICKLAUNCH), FALSE);
    }
    // Restriction- either the tray is disabled by policy, or the "smart" auto tray 
    // is disabled by policy
    if (tvo.fNoTrayItemsDisplayPolicyEnabled || tvo.fNoAutoTrayPolicyEnabled) 
    {
        EnableWindow(GetDlgItem(hDlg, IDC_NOTIFYMAN), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_CUSTOMIZE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_STATIC_NOTIFY), FALSE);
    }
    else
    {
        EnableWindow(GetDlgItem(hDlg, IDC_CUSTOMIZE), tvo.fAutoTrayEnabledByUser);
        CheckDlgButton(hDlg, IDC_NOTIFYMAN, tvo.fAutoTrayEnabledByUser);
    }

    CheckDlgButton(hDlg, IDC_LOCKTASKBAR, !_IsSizeMoveEnabled());
    BOOL fEnable = !_IsSizeMoveRestricted();
    EnableWindow(GetDlgItem(hDlg, IDC_LOCKTASKBAR), fEnable);

    if (SHRestricted(REST_NOTASKGROUPING))
    {
        // If there is a restriction of any kine, hide the window
        ShowWindow(GetDlgItem(hDlg, IDC_GROUPITEMS), FALSE);
    }
    else if (SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarGlomming"),
                        FALSE, TRUE))
    {
        CheckDlgButton(hDlg, IDC_GROUPITEMS, TRUE);
    }

    _TaskbarOptionsSizeControls(hDlg);
    _TaskbarOptionsUpdateDisplay(hDlg);
}

BOOL_PTR CTaskBarPropertySheet::TaskbarOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    INSTRUMENT_WNDPROC(SHCNFI_TRAYVIEWOPTIONS_DLGPROC, hDlg, uMsg, wParam, lParam);

    switch (uMsg)
    {
    case WM_COMMAND:
        if (GET_WM_COMMAND_ID(wParam, lParam) == IDC_CUSTOMIZE)
        {
            if (_pDlgNotify)
            {
                _pDlgNotify->DoModal();
            }
        }

        _TaskbarOptionsUpdateDisplay(hDlg);
        SendPSMChanged(hDlg);

        break;

    case WM_INITDIALOG:
        _TaskbarOptions_OnInitDialog(hDlg);
        if (_dwFlags & TPF_INVOKECUSTOMIZE)
        {
            ::PostMessage(hDlg, WM_COMMAND, IDC_CUSTOMIZE, 0);
        }
        break;

    case WM_SYSCOLORCHANGE:
        _TaskbarOptionsUpdateDisplay(hDlg);
        return TRUE;

    case WM_DESTROY:
        _TaskbarOptionsDestroyBitmaps(hDlg);
        break;

    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code)
        {
        case PSN_APPLY:
            // save settings here

            _ApplyTaskbarOptionsFromDialog(hDlg);
            return TRUE;

        case PSN_KILLACTIVE:
        case PSN_SETACTIVE:
            return TRUE;

        }
        break;

    case WM_HELP:
        ::WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aTaskOptionsHelpIDs);
        break;

    case WM_CONTEXTMENU:
        ::WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(void *)aTaskOptionsHelpIDs);
        break;
    }

    return FALSE;
}

void _StartOptions_OnInitDialog(HWND hDlg)
{
    // If StartPanel UI is turned off, then this check box should not show up! 
    if (SHRestricted(REST_NOSTARTPANEL))
    {
        //If the restriction exists, then hide this check box.
        ShowWindow(::GetDlgItem(hDlg, IDC_NEWSCHOOL), FALSE);
        ShowWindow(::GetDlgItem(hDlg, IDC_NEWSCHOOLDESCRIPTION), FALSE);
        ShowWindow(::GetDlgItem(hDlg, IDC_NEWSTARTCUSTOMIZE), FALSE);

        // And the only thing you can do is check the OldSchool button
        CheckDlgButton(hDlg, IDC_OLDSCHOOL, TRUE);

        // TODO - PM's need to figure out what to do in the case where new start menu is restricted
        //        or not available.  This propsheet page is rather pointless in that case...
        SetDlgItemBitmap(hDlg, IDC_STARTMENUPREVIEW, IDB_STARTPREVIEWCLASSIC);
    }
    else
    {
        SHELLSTATE  ss = {0};
        SHGetSetSettings(&ss, SSF_STARTPANELON, FALSE);
        CheckDlgButton(hDlg, IDC_NEWSCHOOL, BOOLIFY(ss.fStartPanelOn));
        CheckDlgButton(hDlg, IDC_OLDSCHOOL, !BOOLIFY(ss.fStartPanelOn));

        SetDlgItemBitmap(hDlg, IDC_STARTMENUPREVIEW,
            ss.fStartPanelOn ? IDB_STARTPREVIEWNEW : IDB_STARTPREVIEWCLASSIC);
        
        // disable "customize" for the style thats off.
        EnableWindow(GetDlgItem(hDlg, ss.fStartPanelOn ? IDC_OLDSTARTCUSTOMIZE : IDC_NEWSTARTCUSTOMIZE), FALSE);
    }
}

// On destroy, clean up the bitmaps we loaded so we don't leak them
void _StartOptions_OnDestroy(HWND hDlg)
{
    SetDlgItemBitmap(hDlg, IDC_STARTMENUPREVIEW, 0);
}

BOOL_PTR CTaskBarPropertySheet::s_StartMenuDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CTaskBarPropertySheet* self = NULL;

    if (uMsg == WM_INITDIALOG)
    {
        ::SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        self = (CTaskBarPropertySheet*) ((PROPSHEETPAGE*)lParam)->lParam;
    }
    else
    {
        PROPSHEETPAGE* psp = (PROPSHEETPAGE*)::GetWindowLongPtr(hDlg, DWLP_USER);
        if (psp)
            self = (CTaskBarPropertySheet*)psp->lParam;
    }

    BOOL_PTR fValue = FALSE;
    if (self)
    {
        self->StartMenuDlgProc(hDlg, uMsg, wParam, lParam);
    }

    return fValue;
}


BOOL_PTR CTaskBarPropertySheet::StartMenuDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_COMMAND:
        switch (GET_WM_COMMAND_ID(wParam, lParam))
        {
            case IDC_NEWSCHOOL:
            case IDC_OLDSCHOOL:
                if (HIWORD(wParam) == BN_CLICKED)
                {
                    ::EnableWindow(::GetDlgItem(hDlg, IDC_NEWSTARTCUSTOMIZE), GET_WM_COMMAND_ID(wParam, lParam) == IDC_NEWSCHOOL);
                    ::EnableWindow(::GetDlgItem(hDlg, IDC_OLDSTARTCUSTOMIZE), GET_WM_COMMAND_ID(wParam, lParam) == IDC_OLDSCHOOL);
                    SetDlgItemBitmap(hDlg, IDC_STARTMENUPREVIEW,
                        GET_WM_COMMAND_ID(wParam, lParam) == IDC_NEWSCHOOL ? IDB_STARTPREVIEWNEW : IDB_STARTPREVIEWCLASSIC);
    
                    SendPSMChanged(hDlg);
                }
                break;


            case IDC_NEWSTARTCUSTOMIZE:
            {
                CCustomizeSPPropSheet *pps = new CCustomizeSPPropSheet(hDlg);
                if (pps)
                {
                    if (pps->DoModal() == IDOK)
                    {
                        // if anything changed, let the propsheet know
                        SendPSMChanged(hDlg);
                    }
                    delete pps;
                }
                break;
            }
            case IDC_OLDSTARTCUSTOMIZE:
            {
                if (DialogBoxParam(hinstCabinet, MAKEINTRESOURCE(DLG_STARTMENU_CONFIG), hDlg, AdvancedOptDlgProc, (LPARAM)&_Adv))
                {
                    // if anything changed, let the propsheet know
                    SendPSMChanged(hDlg);
                }
                break;
            }
        }

        break;

    case WM_INITDIALOG:
        {
            _StartOptions_OnInitDialog(hDlg);

        }
        break;

    case WM_DESTROY:
        _StartOptions_OnDestroy(hDlg);
        break;

    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code)
        {
        case PSN_APPLY:
            // save settings here

            _ApplyStartOptionsFromDialog(hDlg);
            return TRUE;

        case PSN_KILLACTIVE:
        case PSN_SETACTIVE:
            return TRUE;

        }
        break;

    case WM_HELP:
        ::WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aStartTabHelpIDs);
        break;

    case WM_CONTEXTMENU:
        ::WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(void *)aStartTabHelpIDs);
        break;
    }

    return FALSE;
}

void _UpdateNotifySetting(BOOL fNotifySetting)
{
    ITrayNotify * pTrayNotify = NULL;
    if (SUCCEEDED(CoCreateInstance(CLSID_TrayNotify, NULL, CLSCTX_LOCAL_SERVER, IID_PPV_ARG(ITrayNotify, &pTrayNotify))))
    {
        pTrayNotify->EnableAutoTray(fNotifySetting);
        pTrayNotify->Release();
    }
}

void CTaskBarPropertySheet ::_ApplyTaskbarOptionsFromDialog(HWND hDlg)
{
    // We need to get the Cabinet structure from the property sheet info.
    BOOL fAlwaysOnTop;
    BOOL fAutoHide;
    BOOL fChanged;
    LONG lRet;
    TRAYVIEWOPTS tvo;

    // First check for Always on Top
    fAlwaysOnTop = ::IsDlgButtonChecked(hDlg, IDC_TRAYOPTONTOP);
    c_tray._UpdateAlwaysOnTop(fAlwaysOnTop);

    // And change the Autohide state
    fAutoHide = ::IsDlgButtonChecked(hDlg, IDC_TRAYOPTAUTOHIDE);
    lRet = c_tray._SetAutoHideState(fAutoHide);
    c_tray.GetTrayViewOpts(&tvo);
    if (!HIWORD(lRet) && fAutoHide)
    {
        // we tried and failed.
        if (!(tvo.uAutoHide & AH_ON))
        {
            ::CheckDlgButton(hDlg, IDC_TRAYOPTAUTOHIDE, FALSE);
            _TaskbarOptionsUpdateDisplay(hDlg);
        }
    }
    fChanged = LOWORD(lRet);

    if (fChanged)
       c_tray._AppBarNotifyAll(NULL, ABN_STATECHANGE, NULL, 0);

    // show/hide the clock
    tvo.fHideClock = !::IsDlgButtonChecked(hDlg, IDC_TRAYOPTSHOWCLOCK);

    if (!tvo.fNoTrayItemsDisplayPolicyEnabled && !tvo.fNoAutoTrayPolicyEnabled)
    {
        BOOL fNotifySetting = ::IsDlgButtonChecked(hDlg, IDC_NOTIFYMAN);
        if (tvo.fAutoTrayEnabledByUser != fNotifySetting)
        {
            tvo.fAutoTrayEnabledByUser = fNotifySetting;
            _UpdateNotifySetting(fNotifySetting);
        }
    }
        
    tvo.fShowQuickLaunch = ::IsDlgButtonChecked(hDlg, IDC_QUICKLAUNCH);

    c_tray.SetTrayViewOpts(&tvo);
    SendMessage(c_tray.GetTrayNotifyHWND(), TNM_HIDECLOCK, 0, tvo.fHideClock);

    c_tray.SizeWindows();

    // Update registry for locked taskbar
    DWORD dwEnableSizeMove = !::IsDlgButtonChecked(hDlg, IDC_LOCKTASKBAR);
    SHRegSetUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarSizeMove"),
        REG_DWORD, &dwEnableSizeMove, sizeof(DWORD), SHREGSET_FORCE_HKCU);

    //Update registry for grouping behavior
    DWORD dwGlom = ::IsDlgButtonChecked(hDlg, IDC_GROUPITEMS);
    SHRegSetUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarGlomming"),
        REG_DWORD, &dwGlom, sizeof(DWORD), SHREGSET_FORCE_HKCU);

    ::SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, NULL, (LPARAM)TEXT("TraySettings"), SMTO_NOTIMEOUTIFNOTHUNG, 1000, NULL);
}

void CTaskBarPropertySheet::_ApplyStartOptionsFromDialog(HWND hDlg)
{
    if(!SHRestricted(REST_NOSTARTPANEL))
    {
        //Get the current state of the check box
        BOOL    fStartPanelOn = BOOLIFY(::IsDlgButtonChecked(hDlg, IDC_NEWSCHOOL) );
        SHELLSTATE  ss = {0};
        //See if Startpage is currently on or off.
        SHGetSetSettings(&ss, SSF_STARTPANELON, FALSE);
        //Check if the check box has been toggled
        if(fStartPanelOn != BOOLIFY(ss.fStartPanelOn))
        {
            // Toggle the setting
            ss.fStartPanelOn = fStartPanelOn;
            SHGetSetSettings(&ss, SSF_STARTPANELON, TRUE);

            //Tell the desktop window so it can add/remove the desktop icons
            ::PostMessage(v_hwndDesktop, DTM_STARTPAGEONOFF, 0, 0);
        }

        // Tell the Start Menu to rebuild itself now that we changed it
        // (This part is unconditional since the user may have merely
        // changed a setting with the Start Menu)
        ::PostMessage(v_hwndTray, SBM_REBUILDMENU, 0, 0);

    }
}

//---------------------------------------------------------------------------
void _TaskbarOptionsDestroyBitmaps(HWND hDlg)
{
    SetDlgItemBitmap(hDlg, IDC_TASKBARAPPEARANCE, 0);
    SetDlgItemBitmap(hDlg, IDC_NOTIFYAPPEARANCE, 0);
}

typedef struct
{
    int idc;
    int iAdd;
}
CONTROLBITMAP;

int _TaskbarPickBitmap(HWND hDlg, int iBmpBase, const CONTROLBITMAP* pca, int cca)
{
    for (int i = 0; i < cca; i++)
    {
        if (!IsDlgButtonChecked(hDlg, pca[i].idc))
        {
            iBmpBase += pca[i].iAdd;
        }
    }
    return iBmpBase;
}

void _TaskbarOptionsUpdateDisplay(HWND hDlg)
{
    static const CONTROLBITMAP c_caTaskbar[] =
    {
        { IDC_LOCKTASKBAR, 1 },
        { IDC_GROUPITEMS,  2 },
        { IDC_QUICKLAUNCH, 4 },
    };
    static const CONTROLBITMAP c_caNotify[] =
    {
        { IDC_TRAYOPTSHOWCLOCK, 1 },
        { IDC_NOTIFYMAN,        2 },
    };

    //
    // top preview
    //
    int iBmp;
    if (IsDlgButtonChecked(hDlg, IDC_TRAYOPTAUTOHIDE))
    {
        iBmp = IDB_TAAUTOHIDE;
    }
    else
    {
        iBmp = _TaskbarPickBitmap(hDlg, IDB_TAQLLOCKGROUP, c_caTaskbar, ARRAYSIZE(c_caTaskbar));
    }
    SetDlgItemBitmap(hDlg, IDC_TASKBARAPPEARANCE, iBmp);

    //
    // bottom preview
    //
    iBmp = _TaskbarPickBitmap(hDlg, IDB_NACLOCKCLEAN, c_caNotify, ARRAYSIZE(c_caNotify));
    SetDlgItemBitmap(hDlg, IDC_NOTIFYAPPEARANCE, iBmp);

    //
    // customize button
    //
    EnableWindow(GetDlgItem(hDlg, IDC_CUSTOMIZE), IsDlgButtonChecked(hDlg, IDC_NOTIFYMAN));
}


#define CX_PREVIEW  336
#define CY_PREVIEW  35

// need to do this by hand because dialog units to pixels will change,
// but the bitmaps won't
void _TaskbarOptionsSizeControls(HWND hDlg)
{
    static const int c_IDC[] =
    {
        IDC_TASKBARAPPEARANCE,
        IDC_NOTIFYAPPEARANCE
    };

    for (int i = 0; i < ARRAYSIZE(c_IDC); i++)
    {
        SetWindowPos(GetDlgItem(hDlg, c_IDC[i]), NULL, 0, 0, CX_PREVIEW, CY_PREVIEW,
                        SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
    }
}

typedef BOOL (* PFCFGSTART) (HWND, BOOL);

void CallAppWiz(HWND hDlg, BOOL bDelItems)
{
    HINSTANCE hmodWiz = LoadLibrary(TEXT("AppWiz.Cpl"));
    if (hmodWiz)
    {
        PFCFGSTART pfnCfgStart = (PFCFGSTART)GetProcAddress(hmodWiz, "ConfigStartMenu");
        if (pfnCfgStart)
        {
            pfnCfgStart(hDlg, bDelItems);
        }
        FreeLibrary(hmodWiz);
    }
}

BOOL ExecExplorerAtStartMenu(HWND hDlg)
{
    SHELLEXECUTEINFO ei;
    BOOL fWorked= FALSE;
    TCHAR    szParams[MAX_PATH];

    ei.cbSize = sizeof(ei);
    ei.hwnd = hDlg;
    ei.lpVerb = NULL;
    ei.fMask = 0;
    ei.lpFile = TEXT("Explorer.exe");

    if (IsUserAnAdmin())
    {
        lstrcpy(szParams, TEXT("/E,"));
        SHGetSpecialFolderPath(hDlg, &(szParams[ARRAYSIZE(TEXT("/E,"))-1]),
                                CSIDL_STARTMENU, FALSE);
    }
    else
    {
        lstrcpy(szParams, TEXT("/E,/Root,"));
        SHGetSpecialFolderPath(hDlg, &(szParams[ARRAYSIZE(TEXT("/E,/Root,"))-1]),
                                CSIDL_STARTMENU, FALSE);
    }

    ei.lpParameters = szParams;
    ei.lpDirectory = NULL;
    ei.lpClass = NULL;
    ei.nShow = SW_SHOWDEFAULT;
    ei.hInstApp = hinstCabinet;

    return(ShellExecuteEx(&ei));
}

const TCHAR *c_szRegMruKeysToDelete[] =
{
    TEXT("Software\\Microsoft\\Internet Explorer\\TypedURLs"),
    TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU"),
    TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Doc Find Spec MRU"),

    // New for Whistler (should've been in Windows 2000 and Millennium but we forgot)
    TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Comdlg32\\OpenSaveMRU"),
    TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Comdlg32\\LastVisitedMRU"),
};

void SetDocButton(HWND hDlg, int id)
{
    LPITEMIDLIST pidl;
    BOOL    bAreDocs = FALSE;

    HRESULT hr = SHGetSpecialFolderLocation(hDlg, CSIDL_RECENT, &pidl);
    if (SUCCEEDED(hr))
    {
        IShellFolder *psf = BindToFolder(pidl);
        if (psf)
        {
            HRESULT hres;
            LPENUMIDLIST penum;
            hres = psf->EnumObjects(hDlg, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &penum);
            if (SUCCEEDED(hres))
            {
                unsigned long celt;
                LPITEMIDLIST pidlenum;
                if ((S_OK == penum->Next(1, &pidlenum, &celt)) && (celt == 1))
                {
                    SHFree(pidlenum);
                    bAreDocs = TRUE;
                }
                penum->Release();
            }
            psf->Release();
        }
        SHFree(pidl);
    }

    // Check other MRU registry keys
    if (!bAreDocs)
    {
        int  i;
        for (i = 0; i < ARRAYSIZE(c_szRegMruKeysToDelete); i++)
        {
            HKEY hkey;
            if (RegOpenKeyEx(HKEY_CURRENT_USER, c_szRegMruKeysToDelete[i], 0L, KEY_ALL_ACCESS, &hkey) == ERROR_SUCCESS)
            {
                bAreDocs = TRUE;
                RegCloseKey(hkey);
            }
        }
    }
    
    Button_Enable(GetDlgItem(hDlg, id), bAreDocs);
}

void ClearRecentDocumentsAndMRUStuff(BOOL fBroadcastChange)
{
    int i;
    SHAddToRecentDocs(0, NULL);

    // Flush other MRUs in the registry for privacy
    for (i = 0; i < ARRAYSIZE(c_szRegMruKeysToDelete); i++)
    {
        SHDeleteKey(HKEY_CURRENT_USER, c_szRegMruKeysToDelete[i]);

        if (fBroadcastChange)
            SHSendMessageBroadcast(WM_SETTINGCHANGE, 0,
                        (LPARAM)c_szRegMruKeysToDelete[i]);
    }    
}

void HandleClearButtonClick(HWND hwndClear)
{
    HCURSOR hc = SetCursor(LoadCursor(NULL, IDC_WAIT));
    ClearRecentDocumentsAndMRUStuff(TRUE);
    SetCursor(hc);

    //
    //  Before disabling the button, shove focus off it.
    //
    if (GetFocus() == hwndClear)
    {
        SendMessage(GetParent(hwndClear), WM_NEXTDLGCTL, 0, MAKELONG(FALSE, 0));
    }

    Button_Enable(hwndClear, FALSE);
}

void Reorder(HDPA hdpa)
{
    for (int i = DPA_GetPtrCount(hdpa) - 1; i >= 0; i--)
    {
        PORDERITEM poi = (PORDERITEM)DPA_FastGetPtr(hdpa, i);
        poi->nOrder = i;
    }
}

void MenuOrderSort(HKEY hkeyRoot, IShellFolder* psf);

void MenuOrderSortKeyWithFolder(HKEY hkeyRoot, LPTSTR pszKey, IShellFolder* psf)
{
    HKEY hkey;
    if (ERROR_SUCCESS == RegOpenKeyEx(hkeyRoot, pszKey, 0, KEY_READ | KEY_WRITE, &hkey))
    {
        MenuOrderSort(hkey, psf);
        RegCloseKey(hkey);
    }
}

// Binds to the Key pszKey, under hkey root, using psf, and sorts the resultant order.
void MenuOrderSortSubKey(HKEY hkeyRoot, LPTSTR szFolder, LPTSTR pszKey, IShellFolder* psf)
{
    LPITEMIDLIST pidl;
    DWORD cbEaten;
    DWORD dwAttrib;
    WCHAR wszKey[MAX_PATH];
    SHTCharToUnicode(szFolder, wszKey, ARRAYSIZE(wszKey));

    if (SUCCEEDED(psf->ParseDisplayName(NULL, NULL, wszKey, &cbEaten, &pidl, &dwAttrib)))
    {
        IShellFolder* psfSub;
        if (SUCCEEDED(psf->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfSub))))
        {
            MenuOrderSortKeyWithFolder(hkeyRoot, pszKey, psfSub);
            psfSub->Release();
        }
        ILFree(pidl);
    }
}


void MenuOrderSort(HKEY hkeyRoot, IShellFolder* psf)
{
    // Try to open Value Order
    IStream* pstm = SHOpenRegStream(hkeyRoot, TEXT(""), TEXT("Order"), STGM_READWRITE);
    if (pstm)
    {
        IOrderList2* pol2;
        if (SUCCEEDED(CoCreateInstance(CLSID_OrderListExport, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IOrderList2, &pol2))))
        {
            HDPA hdpa;
            if (SUCCEEDED(pol2->LoadFromStream(pstm, &hdpa, psf)))
            {
                // Since it's stored ordered by name, this should be no problem.
                Reorder(hdpa);

                // Set the seek pointer at the beginning.
                LARGE_INTEGER liZero = {0};
                pstm->Seek(liZero, STREAM_SEEK_SET, NULL);

                pol2->SaveToStream(pstm, hdpa);
                DPA_Destroy(hdpa);
            }
            pol2->Release();
        }
        pstm->Release();
    }

    // Now enumerate sub keys.

    TCHAR szKey[MAX_PATH];
    DWORD cbKey = ARRAYSIZE(szKey);
    int iIndex = 0;
    while (ERROR_SUCCESS == RegEnumKeyEx(hkeyRoot, iIndex, szKey, &cbKey, NULL, NULL, NULL, NULL))
    {
        MenuOrderSortSubKey(hkeyRoot, szKey, szKey, psf);
        iIndex++;
        cbKey = ARRAYSIZE(szKey);
    }
}

// Defined in Tray.c
IShellFolder* BindToFolder(LPCITEMIDLIST pidl);

void StartMenuSort()
{
    IShellFolder* psf = NULL;
    LPITEMIDLIST pidl;

    HRESULT hr = SHGetSpecialFolderLocation(NULL, CSIDL_STARTMENU, &pidl);
    if (SUCCEEDED(hr))
    {
        LPITEMIDLIST pidl2;
        if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_STARTMENU, &pidl2)))
        {
            IAugmentedShellFolder2* pasf;
            IShellFolder* psfCommon;
            IShellFolder* psfUser;
            HRESULT hres = CoCreateInstance(CLSID_MergedFolder, NULL, CLSCTX_INPROC, 
                                    IID_PPV_ARG(IAugmentedShellFolder2, &pasf));
            if (SUCCEEDED(hres))
            {
                psfUser = BindToFolder(pidl);
                if (psfUser)
                {
                    pasf->AddNameSpace(NULL, psfUser, pidl, ASFF_DEFAULT | ASFF_DEFNAMESPACE_ALL);
                    psfUser->Release();
                }

                psfCommon = BindToFolder(pidl2);

                if (psfCommon)
                {
                    pasf->AddNameSpace(NULL, psfCommon, pidl2, ASFF_DEFAULT);
                    psfCommon->Release();
                }

                hres = pasf->QueryInterface(IID_PPV_ARG(IShellFolder, &psf));
                pasf->Release();
            }

            ILFree(pidl2);
        }
        else
        {
            psf = BindToFolder(pidl);
        }
        ILFree(pidl);                        
    }

    if (psf)
    {
        HKEY hkeyRoot;

        // Recursivly sort the orders. Should this be on another thread?
        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, STRREG_STARTMENU,
            0, KEY_READ | KEY_WRITE, &hkeyRoot))
        {
            MenuOrderSort(hkeyRoot, psf);

            // Sort the My Documents menu item:
            LPITEMIDLIST pidlMyDocs;
            SHGetFolderLocation(NULL, CSIDL_PERSONAL, NULL, 0, &pidlMyDocs);
            if (pidlMyDocs)
            {
                IShellFolder* psfMyDocs;
                if (SUCCEEDED(SHBindToObjectEx(NULL, pidlMyDocs, NULL, IID_PPV_ARG(IShellFolder, &psfMyDocs))))
                {
                    MenuOrderSortKeyWithFolder(hkeyRoot, TEXT("MyDocuments"), psfMyDocs);
                    psfMyDocs->Release();
                }
                ILFree(pidlMyDocs);
            }

            // What happens if the Filesystem programs is not equal to the hard coded string "Programs"? This
            // happens on German: Programme != Programs and we fail to sort. So let's verify:
            TCHAR szPath[MAX_PATH];
            SHGetFolderPath(NULL, CSIDL_PROGRAMS, NULL, 0, szPath);
            LPTSTR pszName = PathFindFileName(szPath);

            if (StrCmpI(pszName, TEXT("Programs")) != 0)
            {
                // Ok, It's not the same, so go bind to that sub tree and sort it.
                MenuOrderSortSubKey(hkeyRoot, pszName, TEXT("Programs"), psf);
            }
            RegCloseKey(hkeyRoot);
        }
        psf->Release();
    }
}

BOOL Advanced_OnInitDialog(HWND hwndDlg, SMADVANCED* pAdv)
{
    if (!pAdv || !pAdv->pTO)
    {
        EndDialog(hwndDlg, 0);
        return FALSE;   // no memory?
    }

    SetWindowPtr(hwndDlg, DWLP_USER, pAdv);

    // since the large icon setting is stored in the tray state, not as a standalone reg key, we need to have a temp reg key for the regtreeop to use...
    TRAYVIEWOPTS tvo;
    c_tray.GetTrayViewOpts(&tvo);
    BOOL fLargePrev = !tvo.fSMSmallIcons;
    SHSetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_LARGEICONSTEMP, REG_DWORD, (void*) &fLargePrev, sizeof(fLargePrev));

    pAdv->hwndTree = GetDlgItem( hwndDlg, IDC_STARTMENUSETTINGS );

    // HACKHACK - IRegTreeOptions is ANSI, so we temporarily turn off UNICODE
    #undef TEXT
    #define TEXT(s) s
    HRESULT hr = pAdv->pTO->InitTree(pAdv->hwndTree, HKEY_LOCAL_MACHINE, REGSTR_PATH_SMADVANCED "\\StartMenu", NULL);

    #undef TEXT
    #define TEXT(s) __TEXT(s)

    // find the first root and make sure that it is visible
    TreeView_EnsureVisible(pAdv->hwndTree, TreeView_GetRoot( pAdv->hwndTree ));

    SetDocButton(hwndDlg, IDC_KILLDOCUMENTS);

    return SUCCEEDED(hr);
}

void InitStartMenu_DoTreeHelp(SMADVANCED* pAdv, WPARAM wParam)
{
    TV_HITTESTINFO ht;

    GetCursorPos( &ht.pt );                         // get where we were hit

    if (pAdv->hwndTree == WindowFromPoint(ht.pt))
    {
        ScreenToClient( pAdv->hwndTree, &ht.pt );       // translate it to our window

        // retrieve the item hit
        pAdv->pTO->ShowHelp(TreeView_HitTest( pAdv->hwndTree, &ht),HELP_CONTEXTMENU);
    }
    else
    {
        WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
            (ULONG_PTR)(LPVOID)aInitStartMenuHelpIDs);
    }
}

BOOL_PTR CALLBACK AdvancedOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    SMADVANCED* pAdv = (SMADVANCED*)GetWindowPtr(hwndDlg, DWLP_USER);
    INSTRUMENT_WNDPROC(SHCNFI_INITSTARTMENU_DLGPROC, hwndDlg, msg, wParam, lParam);

    if (msg != WM_INITDIALOG && !pAdv)
    {
        // We've been re-entered after being destroyed.  Bail.
        return FALSE;
    }

    switch (msg) 
    {
    case WM_COMMAND:
        switch(GET_WM_COMMAND_ID(wParam, lParam)) 
        {
        case IDC_ADDSHORTCUT:
            CallAppWiz(hwndDlg, FALSE);
            break;

        case IDC_DELSHORTCUT:
            CallAppWiz(hwndDlg, TRUE);
            break;
            
        case IDC_RESORT:
        {
            SHChangeDWORDAsIDList dwidl;

            StartMenuSort();

            // Notify everyone that the order changed
            dwidl.cb      = sizeof(dwidl) - sizeof(dwidl.cbZero);
            dwidl.dwItem1 = SHCNEE_ORDERCHANGED;
            dwidl.dwItem2 = 0; 
            dwidl.cbZero  = 0;

            SHChangeNotify(SHCNE_EXTENDED_EVENT, SHCNF_FLUSH, (LPCITEMIDLIST)&dwidl, NULL);
            break;
        }
        
        case IDC_EXPLOREMENUS:
            ExecExplorerAtStartMenu(hwndDlg);
            break;

        case IDC_KILLDOCUMENTS:
            {
                HandleClearButtonClick(GET_WM_COMMAND_HWND(wParam, lParam));
            }
            break;

        case IDOK:
            {
                pAdv->pTO->WalkTree(WALK_TREE_SAVE);

                TRAYVIEWOPTS tvo;
                c_tray.GetTrayViewOpts(&tvo);
                BOOL fSmallPrev = tvo.fSMSmallIcons;
                // note that we are loading the classic setting for large icons here....
                BOOL fSmallNew = !SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_LARGEICONSTEMP, FALSE, TRUE /* default to large*/);
                if (fSmallPrev != fSmallNew)
                {
                    tvo.fSMSmallIcons = fSmallNew;
                    c_tray.SetTrayViewOpts(&tvo);
                    IMenuPopup_SetIconSize(c_tray.GetStartMenu(), fSmallNew ? BMICON_SMALL : BMICON_LARGE);
                }

                ::SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, NULL, (LPARAM)TEXT("TraySettings"), SMTO_NOTIMEOUTIFNOTHUNG, 1000, NULL);
            }
            // fall through

        case IDCANCEL:
            SHDeleteValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_LARGEICONSTEMP);
            EndDialog(hwndDlg, FALSE); // false to not enable parent's apply
            break;
        }
        break;

    case WM_INITDIALOG:
        return Advanced_OnInitDialog(hwndDlg, (SMADVANCED *)lParam);

    case WM_NOTIFY:
    {
        LPNMHDR pnm = (NMHDR *)lParam;
        SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, 0); // handled
        switch (pnm->code)
        {
            case TVN_KEYDOWN:
            {
                TV_KEYDOWN *pnmKeyDown = (TV_KEYDOWN*)((NMHDR *)lParam);
                if (pnmKeyDown->wVKey == VK_SPACE)
                {
                    pAdv->pTO->ToggleItem((HTREEITEM)SendMessage(pAdv->hwndTree, TVM_GETNEXTITEM, (WPARAM)TVGN_CARET, 0L));
                    SendMessage(GetParent(hwndDlg), PSM_CHANGED, (WPARAM)hwndDlg, 0L);
                    SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, TRUE); // eat the key
                }
                break;
            }

            case NM_CLICK:
            case NM_DBLCLK:
                // is this click in our tree?
                if ( pnm->idFrom == IDC_STARTMENUSETTINGS )
                {
                    TV_HITTESTINFO ht;

                    DWORD dwPos = GetMessagePos();                  // get where we were hit
                    ht.pt.x = GET_X_LPARAM(dwPos);
                    ht.pt.y = GET_Y_LPARAM(dwPos);
                    ScreenToClient( pAdv->hwndTree, &ht.pt );       // translate it to our window

                    // retrieve the item hit
                    pAdv->pTO->ToggleItem(TreeView_HitTest( pAdv->hwndTree, &ht));
                    SendMessage(GetParent(hwndDlg), PSM_CHANGED, (WPARAM)hwndDlg, 0L);
                }

                break;

            case NM_RCLICK:      // right mouse click
                if (pnm->hwndFrom == pAdv->hwndTree)
                {
                    InitStartMenu_DoTreeHelp(pAdv, (WPARAM)pnm->hwndFrom);
                    SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, TRUE); // eat the click
                    return TRUE;
                }
                break;
        }
        break;
    }

    case WM_HELP:                   // F1
    {
        LPHELPINFO phi = (LPHELPINFO)lParam;

        if (phi->iCtrlId != IDC_STARTMENUSETTINGS)
        {
            WinHelp( (HWND)(phi->hItemHandle), NULL,
                HELP_WM_HELP, (ULONG_PTR)(LPTSTR)aInitStartMenuHelpIDs);
        }
        else
        {
            HTREEITEM hItem;
            //Is this help invoked throught F1 key
            if (GetAsyncKeyState(VK_F1) < 0)
            {
                // Yes. WE need to give help for the currently selected item
                hItem = TreeView_GetSelection(pAdv->hwndTree);
            }
            else
            {
                //No, We need to give help for the item at the cursor position
                TV_HITTESTINFO ht;
                ht.pt = phi->MousePos;
                ScreenToClient(pAdv->hwndTree, &ht.pt); // Translate it to our window
                hItem = TreeView_HitTest(pAdv->hwndTree, &ht);
            }

            pAdv->pTO->ShowHelp(hItem, HELP_WM_HELP);
        }
        break;
    }

    case WM_CONTEXTMENU:        // right mouse click
    {
        InitStartMenu_DoTreeHelp(pAdv, wParam);
        break;
    }
        
    case WM_DESTROY:
        {
            // will be free'd when our parent is destroyed
            pAdv->pTO->WalkTree(WALK_TREE_DELETE);

            // make sure we don't re-enter
            SetWindowPtr( hwndDlg, DWLP_USER, NULL );
        }
        break; // WM_DESTORY

    default:
        return FALSE;
    }

    return TRUE;
}

#define TPF_PAGEFLAGS   (TPF_STARTMENUPAGE | TPF_TASKBARPAGE)

void DoTaskBarProperties(HWND hwnd, DWORD dwFlags)
{
    ASSERT(((dwFlags & TPF_PAGEFLAGS) == TPF_STARTMENUPAGE) ||
            ((dwFlags & TPF_PAGEFLAGS) == TPF_TASKBARPAGE));

    UINT nStartPage = (dwFlags & TPF_TASKBARPAGE) ? 0 : 1;
    CTaskBarPropertySheet sheet(nStartPage, hwnd, dwFlags);

    sheet.DoModal(hwnd);
}

// Passing iResource=0 deletes the bitmap in the control

void SetDlgItemBitmap(HWND hDlg, int idStatic, int iResource)
{
    HBITMAP hbm;

    if (iResource)
    {
        hbm = (HBITMAP)LoadImage(hinstCabinet, MAKEINTRESOURCE(iResource), IMAGE_BITMAP, 0,0, LR_LOADMAP3DCOLORS);
    }
    else
    {
        hbm = NULL;
    }

    hbm = (HBITMAP)SendDlgItemMessage(hDlg, idStatic, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
    if (hbm)
        DeleteObject(hbm);

}

void SetDlgItemIcon(HWND hDlg, int idStatic, HICON hIcon)
{
    HICON hiOld = (HICON)SendDlgItemMessage(hDlg, idStatic, STM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
    if (hiOld)
        DestroyIcon(hiOld);
}

// REVIEW - use SHGetFileInfo?
void SetProgramIcon(HWND hDlg, int idLarge, int idSmall)
{
    HICON hIconLarge = NULL;
    HICON hIconSmall = NULL;
    LPITEMIDLIST pidlMyComp = ILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}")); // CLSID_MyComputer;
    if (pidlMyComp)
    {
        IShellFolder *psfDesktop;
        if (SUCCEEDED(SHGetDesktopFolder(&psfDesktop)))
        {
            IExtractIcon *pxi;
            if (SUCCEEDED(psfDesktop->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST*)&pidlMyComp, IID_PPV_ARG_NULL(IExtractIcon, &pxi))))
            {
                TCHAR szIconFile[MAX_PATH];
                int iIndex;
                UINT wFlags;
                if (S_OK == pxi->GetIconLocation(GIL_FORSHELL, szIconFile, ARRAYSIZE(szIconFile), &iIndex, &wFlags))
                {
                    pxi->Extract(szIconFile, iIndex, &hIconLarge, &hIconSmall, (GetSystemMetrics(SM_CXSMICON)<<16) | GetSystemMetrics(SM_CXICON));
                }
                pxi->Release();
            }
            psfDesktop->Release();
        }
        ILFree(pidlMyComp);
    }

    if (hIconLarge)
        SetDlgItemIcon(hDlg, idLarge, hIconLarge);
    if (hIconSmall)
        SetDlgItemIcon(hDlg, idSmall, hIconSmall);
}