#include "stdafx.h"
#include "specfldr.h"
#include "hostutil.h"
#include "rcids.h"              // for IDM_PROGRAMS etc.
#include "ras.h"
#include "raserror.h"
#include "netcon.h"
#include "netconp.h"
#include <cowsite.h>

//
//  This definition is stolen from shell32\unicpp\dcomp.h
//
#define REGSTR_PATH_HIDDEN_DESKTOP_ICONS_STARTPANEL \
     REGSTR_PATH_EXPLORER TEXT("\\HideDesktopIcons\\NewStartPanel")

HRESULT CRecentShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
HRESULT CNoSubdirShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
HRESULT CMyComputerShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
HRESULT CNoFontsShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
HRESULT CConnectToShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
LPTSTR _Static_LoadString(const struct SpecialFolderDesc *pdesc);
BOOL ShouldShowWindowsSecurity();
BOOL ShouldShowOEMLink();

typedef HRESULT (CALLBACK *CREATESHELLMENUCALLBACK)(IShellMenuCallback **ppsmc);
typedef BOOL (CALLBACK *SHOULDSHOWFOLDERCALLBACK)();

EXTERN_C HINSTANCE hinstCabinet;

void ShowFolder(UINT csidl);
BOOL IsNetConPidlRAS(IShellFolder2 *psfNetCon, LPCITEMIDLIST pidlNetConItem);

//****************************************************************************
//
//  SpecialFolderDesc
//
//  Describes a special folder.
//

#define SFD_SEPARATOR       ((LPTSTR)-1)

// Flags for SpecialFolderDesc._uFlags

enum {
    // These values are collectively known as the
    // "display mode" and match the values set by regtreeop.

    SFD_HIDE     = 0x0000,
    SFD_SHOW     = 0x0001,
    SFD_CASCADE  = 0x0002,
    SFD_MODEMASK = 0x0003,

    SFD_DROPTARGET      = 0x0004,
    SFD_CANCASCADE      = 0x0008,
    SFD_FORCECASCADE    = 0x0010,
    SFD_BOLD            = 0x0020,
    SFD_WASSHOWN        = 0x0040,
    SFD_PREFIX          = 0x0080,
    SFD_USEBGTHREAD     = 0x0100,
};

struct SpecialFolderDesc {
    typedef BOOL (SpecialFolderDesc::*CUSTOMFOLDERNAMECALLBACK)(LPTSTR *ppsz) const;

    LPCTSTR _pszTarget;         // or MAKEINTRESOURCE(csidl)
    RESTRICTIONS _rest;         // optional restriction
    LPCTSTR _pszShow;           // REGSTR_EXPLORER_ADVANCED!_pszShow
    UINT _uFlags;               // SFD_* values
    CREATESHELLMENUCALLBACK _CreateShellMenuCallback; // Which IShellMenuCallback do we want?
    LPCTSTR _pszCustomizeKey;   // Optional location where customizations are saved
    DWORD _dwShellFolderFlags;  // Optional restrictions for cascading folder
    UINT _idsCustomName;        // Optional override (CUSTOMFOLDERNAMECALLBACK)
    UINT _iToolTip;             // Optional resource ID for a custom tooltip
    CUSTOMFOLDERNAMECALLBACK _CustomName; // Over-ride the filesys name
    SHOULDSHOWFOLDERCALLBACK _ShowFolder;
    LPCTSTR _pszCanHideOnDesktop; // Optional {guid} that controls desktop visibility

    DWORD GetDisplayMode(BOOL *pbIgnoreRule) const;

    void AdjustForSKU();

    void SetDefaultDisplayMode(UINT iNewMode)
    {
        _uFlags = (_uFlags & ~SFD_MODEMASK) | iNewMode;
    }

    BOOL IsDropTarget() const { return _uFlags & SFD_DROPTARGET; }
    BOOL IsCacheable() const { return _uFlags & SFD_USEBGTHREAD; }

    int IsCSIDL() const { return IS_INTRESOURCE(_pszTarget); }
    BOOL IsBold() const { return _uFlags & SFD_BOLD; }
    int IsSeparator() const { return _pszTarget == SFD_SEPARATOR; }

    int GetCSIDL() const {
        ASSERT(IsCSIDL());
        return (short)PtrToLong(_pszTarget);
    }

    HRESULT CreateShellMenuCallback(IShellMenuCallback **ppsmc) const {
        return _CreateShellMenuCallback ? _CreateShellMenuCallback(ppsmc) : S_OK;
    }

    BOOL GetCustomName(LPTSTR *ppsz) const {
        if (_CustomName)
            return (this->*_CustomName)(ppsz);
        else
            return FALSE;
    }

    LPWSTR GetShowCacheRegName() const;
    BOOL LoadStringAsOLESTR(LPTSTR *ppsz) const;
    BOOL ConnectToName(LPTSTR *ppsz) const;
};

static SpecialFolderDesc s_rgsfd[] = {

    /* My Documents */
    {
        MAKEINTRESOURCE(CSIDL_PERSONAL),    // pszTarget
        REST_NOSMMYDOCS,                    // restriction
        REGSTR_VAL_DV2_SHOWMYDOCS,
        SFD_SHOW | SFD_DROPTARGET | SFD_CANCASCADE | SFD_BOLD,
                                            // show by default, is drop target
        NULL,                               // no custom cascade 
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        IDS_CUSTOMTIP_MYDOCS,
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        TEXT("{450D8FBA-AD25-11D0-98A8-0800361B1103}"), // desktop visibility control
    },

    /* Recent */
    {
        MAKEINTRESOURCE(CSIDL_RECENT),      // pszTarget
        REST_NORECENTDOCSMENU,              // restriction
        REGSTR_VAL_DV2_SHOWRECDOCS,         // customize show
        SFD_HIDE | SFD_CANCASCADE | SFD_BOLD | SFD_PREFIX, // hide by default
        CRecentShellMenuCallback_CreateInstance, // custom callback
        NULL,                               // no drag/drop customization
        SMINIT_RESTRICT_DRAGDROP,           // disallow drag/drop in cascaded menu
        IDS_STARTPANE_RECENT,               // override filesys name
        IDS_CUSTOMTIP_RECENT,
        &SpecialFolderDesc::LoadStringAsOLESTR, // override filesys name with _idsCustomName
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* My Pictures */
    {
        MAKEINTRESOURCE(CSIDL_MYPICTURES),  // pszTarget
        REST_NOSMMYPICS,                    // restriction
        REGSTR_VAL_DV2_SHOWMYPICS,
        SFD_SHOW | SFD_DROPTARGET | SFD_CANCASCADE | SFD_BOLD,
                                            // show by default, is drop target
        NULL,                               // no custom cascade 
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        IDS_CUSTOMTIP_MYPICS,
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)

    },

    /* My Music */
    {
        MAKEINTRESOURCE(CSIDL_MYMUSIC),     // pszTarget
        REST_NOSMMYMUSIC,                   // restriction
        REGSTR_VAL_DV2_SHOWMYMUSIC,
        SFD_SHOW | SFD_DROPTARGET | SFD_CANCASCADE | SFD_BOLD,
                                            // show by default, is drop target
        NULL,                               // no custom cascade 
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        IDS_CUSTOMTIP_MYMUSIC,
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Favorites */
    {
        MAKEINTRESOURCE(CSIDL_FAVORITES),   // pszTarget
        REST_NOFAVORITESMENU,               // restriction
        REGSTR_VAL_DV2_FAVORITES,           // customize show (shared w/classic)
        SFD_HIDE | SFD_DROPTARGET |
        SFD_CANCASCADE | SFD_FORCECASCADE | SFD_BOLD | SFD_PREFIX,
                                            // hide by default, is drop target
        NULL,                               // unrestricted cascading
        STRREG_FAVORITES,                   // drag/drop customization key
        0,                                  // no special flags for cascaded menu
        IDS_STARTPANE_FAVORITES,            // override filesys name
        0,                                  // no custom tip
        &SpecialFolderDesc::LoadStringAsOLESTR, // override filesys name with _idsCustomName
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* My Computer */
    {
        MAKEINTRESOURCE(CSIDL_DRIVES),      // pszTarget
        REST_NOMYCOMPUTERICON,              // restriction
        REGSTR_VAL_DV2_SHOWMC,              // customize show
        SFD_SHOW | SFD_CANCASCADE | SFD_BOLD, // show by default
        CMyComputerShellMenuCallback_CreateInstance, // custom callback
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        IDS_CUSTOMTIP_MYCOMP,
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        TEXT("{20D04FE0-3AEA-1069-A2D8-08002B30309D}"), // desktop visibility control
    },

    /* My Network Places */
    {
        MAKEINTRESOURCE(CSIDL_NETWORK),     // pszTarget
        REST_NOSMNETWORKPLACES,             // restriction
        REGSTR_VAL_DV2_SHOWNETPL,           // customize show
        SFD_SHOW | SFD_CANCASCADE | SFD_BOLD | SFD_USEBGTHREAD, // show by default
        CNoSubdirShellMenuCallback_CreateInstance, // only cascade one level
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        IDS_CUSTOMTIP_MYNETPLACES,
        NULL,                               // (no custom name)
        ShouldShowNetPlaces,
        TEXT("{208D2C60-3AEA-1069-A2D7-08002B30309D}"), // desktop visibility control
    },

    /* Separator line */
    {
        SFD_SEPARATOR,                      // separator
        REST_NONE,                          // no restriction
        NULL,                               // no customize show
        SFD_SHOW,                           // show by default
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Control Panel */
    {
        MAKEINTRESOURCE(CSIDL_CONTROLS),    // pszTarget
        REST_NOCONTROLPANEL,                // restriction
        REGSTR_VAL_DV2_SHOWCPL,
        SFD_SHOW | SFD_CANCASCADE | SFD_PREFIX, // show by default
        CNoFontsShellMenuCallback_CreateInstance, // custom callback
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        IDS_STARTPANE_CONTROLPANEL,         // override filesys name
        IDS_CUSTOMTIP_CTRLPANEL,            // no custom tip
        &SpecialFolderDesc::LoadStringAsOLESTR, // override filesys name with _idsCustomName
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Admin Tools */
    {
        // Using the ::{guid} gets the icon right
        TEXT("shell:::{D20EA4E1-3957-11d2-A40B-0C5020524153}"), // pszTarget
        REST_NONE,                          // no restriction
        REGSTR_VAL_DV2_ADMINTOOLSROOT,
        SFD_HIDE | SFD_CANCASCADE | SFD_FORCECASCADE,        // hide by default, force to cascade
        NULL,                               // no custom callback
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        NULL,                               // no custom name
        NULL,                               // no custom tip
        NULL,                               // no custom name
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Network Connections */
    {
        MAKEINTRESOURCE(CSIDL_CONNECTIONS), // pszTarget
        REST_NONETWORKCONNECTIONS,          // restriction
        REGSTR_VAL_DV2_SHOWNETCONN,         // customize show
        SFD_CASCADE | SFD_CANCASCADE | SFD_PREFIX | SFD_USEBGTHREAD, // cascade by default
        CConnectToShellMenuCallback_CreateInstance, // do special Connect To filtering
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        IDS_STARTPANE_CONNECTTO,            // override filesys name
        IDS_CUSTOMTIP_CONNECTTO,
        &SpecialFolderDesc::ConnectToName,  // override filesys name with _idsCustomName
        ShouldShowConnectTo,                // see if we should be shown
        NULL,                               // (no desktop visibility control)
    },

    /* Printers */
    {
        MAKEINTRESOURCE(CSIDL_PRINTERS),    // pszTarget
        REST_NONE,                          // no restriction
        REGSTR_VAL_DV2_SHOWPRINTERS,        // customize show
        SFD_HIDE,                           // hide by default, can't cascade
        NULL,                               // (not cascadable)
        NULL,                               // no drag/drop customization
        0,                                  // no special flags for cascaded menu
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Separator line */
    {
        SFD_SEPARATOR,                      // separator
        REST_NONE,                          // no restriction
        NULL,                               // no customize show
        SFD_SHOW,                           // show by default
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Help */
    {
        TEXT("shell:::{2559a1f1-21d7-11d4-bdaf-00c04f60b9f0}"), // pszTarget
        REST_NOSMHELP,                      // restriction
        REGSTR_VAL_DV2_SHOWHELP,            // customize show
        SFD_SHOW | SFD_PREFIX,              // show by default, use & prefix
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Search */
    {
        TEXT("shell:::{2559a1f0-21d7-11d4-bdaf-00c04f60b9f0}"), // pszTarget
        REST_NOFIND,                        // restriction
        REGSTR_VAL_DV2_SHOWSEARCH,          // customize show
        SFD_SHOW | SFD_PREFIX,              // show by default, use & prefix
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Run */
    {
        TEXT("shell:::{2559a1f3-21d7-11d4-bdaf-00c04f60b9f0}"), // pszTarget
        REST_NORUN,                         // restriction
        REGSTR_VAL_DV2_SHOWRUN,             // customize show
        SFD_SHOW | SFD_PREFIX,              // show by default, use & prefix
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Separator line */
    {
        SFD_SEPARATOR,                      // separator
        REST_NONE,                          // no restriction
        NULL,                               // no customize show
        SFD_SHOW,                           // show by default
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        NULL,                               // (no custom display rule)
        NULL,                               // (no desktop visibility control)
    },

    /* Windows Security */
    {
        TEXT("shell:::{2559a1f2-21d7-11d4-bdaf-00c04f60b9f0}"), // pszTarget
        REST_NOSECURITY,                    // restriction
        NULL,                               // not customizable
        SFD_SHOW | SFD_PREFIX,              // show by default, use & prefix
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        ShouldShowWindowsSecurity,          // custom display rule
        NULL,                               // (no desktop visibility control)
    },

    /* OEM Command */
    {
        TEXT("shell:::{2559a1f6-21d7-11d4-bdaf-00c04f60b9f0}"), // pszTarget
        REST_NONE,                          // no restriction
        REGSTR_VAL_DV2_SHOWOEM,             // customizable
        SFD_SHOW | SFD_PREFIX,              // show by default, use & prefix
        NULL,                               // (not cascadable)
        NULL,                               // (not cascadable)
        0,                                  // (not cascadable)
        0,                                  // (no custom name)
        0,                                  // no custom tip
        NULL,                               // (no custom name)
        ShouldShowOEMLink,                  // custom display rule
        NULL,                               // (no desktop visibility control)
    },

};

//
//  These are the items whose defaults change depending on the SKU.
//  Changing the defaults for the SKU means chasing down all the
//  places defaults are computed (here, the property sheets,
//  the regtreeop) and updating them all.  Someday, they should
//  be reduced down to one.
//
void SpecialFolderDesc::AdjustForSKU()
{
    if (IsCSIDL())
    {
        switch (GetCSIDL())
        {
            case CSIDL_MYPICTURES:
            case CSIDL_MYMUSIC:
                SetDefaultDisplayMode(IsOS(OS_ANYSERVER) ? SFD_HIDE : SFD_SHOW);
                break;

            case CSIDL_RECENT:
                SetDefaultDisplayMode(IsOS(OS_PERSONAL) ? SFD_HIDE : SFD_CASCADE);
                break;

            case CSIDL_PRINTERS:
                SetDefaultDisplayMode(IsOS(OS_PERSONAL) ? SFD_HIDE : SFD_SHOW);
                break;
        }
    }
}

LPWSTR SpecialFolderDesc::GetShowCacheRegName() const
{
    const WCHAR szCached[] = L"_ShouldShow";
    WCHAR *pszShowCache = (WCHAR *)LocalAlloc(LPTR, ((lstrlenW(_pszShow)+1) * sizeof (WCHAR)) + sizeof(szCached));
    if (pszShowCache)
    {
        StrCpy(pszShowCache, _pszShow);
        StrCat(pszShowCache, szCached);
    }
    return pszShowCache;
}


//
//  First try to read the display mode from the registry.
//  Failing that, use the default value.
//  Also fill in whether to ignore the custom display rule or not
//
DWORD SpecialFolderDesc::GetDisplayMode(BOOL *pbIgnoreRule) const
{
    *pbIgnoreRule = FALSE;

    // Restrictions always take top priority
    if (SHRestricted(_rest))
    {
        return SFD_HIDE;
    }

    DWORD dwMode = _uFlags & SFD_MODEMASK;

    // See if there is a user setting to override

    if (_pszShow)
    {
        DWORD dwNewMode, cb = sizeof(DWORD);
        if (SHRegGetUSValue(REGSTR_EXPLORER_ADVANCED, _pszShow, NULL, &dwNewMode, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
        {
            // User has forced show or forced no-show
            // Do not call the custom show logic
            dwMode = dwNewMode;
            *pbIgnoreRule = TRUE;
        }
        else
        {
            WCHAR *pszShowCache = GetShowCacheRegName();
            if (pszShowCache)
            {
                if (SHGetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, pszShowCache, NULL, &dwNewMode, &cb) == ERROR_SUCCESS)
                {
                    dwMode = dwNewMode;
                }
                LocalFree(pszShowCache);
            }
        }
    }

    //
    //  Some items are cascade-only (Favorites).
    //  Others never cascade (Run).
    //
    //  Enforce those rules here.
    //

    if (dwMode == SFD_CASCADE && !(_uFlags & SFD_CANCASCADE))
    {
        dwMode = SFD_SHOW;
    }
    else if (dwMode == SFD_SHOW && (_uFlags & SFD_FORCECASCADE))
    {
        dwMode = SFD_CASCADE;
    }

    return dwMode;
}

//****************************************************************************
//
//  SpecialFolderListItem
//
//  A PaneItem for the benefit of SFTBarHost.
//

class SpecialFolderListItem : public PaneItem
{

public:
    LPITEMIDLIST _pidl;             //  Full Pidl to each item
    const SpecialFolderDesc *_psfd; //  Describes this item

    TCHAR   _chMnem;                // Keyboard accelerator
    LPTSTR  _pszDispName;            // Display name
    HICON   _hIcon;                 // Icon

    SpecialFolderListItem(const SpecialFolderDesc *psfd) : _pidl(NULL), _psfd(psfd)
    {
        if (_psfd->IsSeparator())
        {
            // Make sure that SFD_SEPARATOR isn't accidentally recognized
            // as a separator.
            ASSERT(!_psfd->IsCSIDL());

            _iPinPos = PINPOS_SEPARATOR;
        }
        else if (_psfd->IsCSIDL())
        {
            SHGetSpecialFolderLocation(NULL, _psfd->GetCSIDL(), &_pidl);
        }
        else
        {
            SHILCreateFromPath(_psfd->_pszTarget, &_pidl, NULL);
        }
    };

    ~SpecialFolderListItem() 
    {
        ILFree(_pidl);
        if (_hIcon)
        {
            DestroyIcon(_hIcon);
        }
        SHFree(_pszDispName);
    };

    void ReplaceLastPidlElement(LPITEMIDLIST pidlNew)
    { 
        ASSERT(ILFindLastID(pidlNew) == pidlNew);   // the ILAppend below won't work otherwise
        ILRemoveLastID(_pidl);
        LPITEMIDLIST pidlCombined = ILAppendID(_pidl, &pidlNew->mkid, TRUE);
        if (pidlCombined)
            _pidl = pidlCombined;
    }

    //
    //  Values that are derived from CSIDL values need to be revalidated
    //  because the user can rename a special folder, and we need to track
    //  it to its new location.
    //
    BOOL IsStillValid()
    {
        BOOL fValid = TRUE;
        if (_psfd->IsCSIDL())
        {
            LPITEMIDLIST pidlNew;
            if (SHGetSpecialFolderLocation(NULL, _psfd->GetCSIDL(), &pidlNew) == S_OK)
            {
                UINT cbSizeNew = ILGetSize(pidlNew);
                if (cbSizeNew != ILGetSize(_pidl) ||
                    memcmp(_pidl, pidlNew, cbSizeNew) != 0)
                {
                    fValid = FALSE;
                }
                ILFree(pidlNew);
            }
        }
        return fValid;
    }
};

SpecialFolderList::~SpecialFolderList()
{
}

HRESULT SpecialFolderList::Initialize()
{
    for(int i=0;i < ARRAYSIZE(s_rgsfd); i++)
        s_rgsfd[i].AdjustForSKU();

    return S_OK;
}

// return TRUE if there are the requisite number of kids
BOOL MinKidsHelper(UINT csidl, BOOL bOnlyRASCON, DWORD dwMinKids)
{
    DWORD dwCount = 0;

    IShellFolder2 *psf;
    LPITEMIDLIST pidlBind = NULL;
    if (SHGetSpecialFolderLocation(NULL, csidl, &pidlBind) == S_OK)
    {
        if (SUCCEEDED(SHBindToObjectEx(NULL, pidlBind, NULL, IID_PPV_ARG(IShellFolder2, &psf))))
        {
            IEnumIDList *penum;
            if (S_OK == psf->EnumObjects(NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &penum))
            {
                LPITEMIDLIST pidl;
                ULONG celt;
                while (S_OK == penum->Next(1, &pidl, &celt))
                {
                    if (bOnlyRASCON)
                    {
                        ASSERT(csidl == CSIDL_CONNECTIONS); // we better be in the net con folder
                        if (IsNetConPidlRAS(psf, pidl))
                            dwCount++;
                    }
                    else
                        dwCount++;

                    SHFree(pidl);

                    if (dwCount >= dwMinKids)
                        break;
                }
                penum->Release();
            }
            psf->Release();
        }
        ILFree(pidlBind);
    }
    return dwCount >= dwMinKids;
}

BOOL ShouldShowNetPlaces()
{
    return MinKidsHelper(CSIDL_NETHOOD, FALSE, 1);  // see bug 317893 for details on when to show net places
}

BOOL ShouldShowConnectTo()
{
    return MinKidsHelper(CSIDL_CONNECTIONS, TRUE, 1); // see bug 226855 (and the associated spec) for when to show Connect To
}

BOOL ShouldShowWindowsSecurity()
{
    return SHGetMachineInfo(GMI_TSCLIENT);
}

BOOL ShouldShowOEMLink()
{
    // Only show the OEM link if the OPK tool has added the appropriate registry entries...
    BOOL bRet = FALSE;
    HKEY hk;
    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("CLSID\\{2559a1f6-21d7-11d4-bdaf-00c04f60b9f0}"), 0, KEY_READ, &hk))
    {
        DWORD cb;
        // Check to make sure its got a name, and a the parameter is registered properly...
        if (ERROR_SUCCESS == RegQueryValue(hk, NULL, NULL, (LONG*) &cb) &&
            ERROR_SUCCESS == SHGetValue(hk, TEXT("Instance\\InitPropertyBag"), TEXT("Param1"), NULL, NULL, &cb))
        {
            bRet = TRUE;
        }
        RegCloseKey(hk);
    }

    return bRet;
}


DWORD WINAPI SpecialFolderList::_HasEnoughChildrenThreadProc(void *pvData)
{
    SpecialFolderList *pThis = reinterpret_cast<SpecialFolderList *>(pvData);

    HRESULT hr = SHCoInitialize();
    if (SUCCEEDED(hr))
    {
        DWORD dwIndex;
        for (dwIndex = 0; dwIndex < ARRAYSIZE(s_rgsfd); dwIndex++)
        {
            const SpecialFolderDesc *pdesc = &s_rgsfd[dwIndex];

            BOOL bIgnoreRule;
            DWORD dwMode = pdesc->GetDisplayMode(&bIgnoreRule);

            if (pdesc->IsCacheable() && pdesc->_ShowFolder)
            {
                ASSERT(pdesc->_pszShow);

                // We need to recount now
                if (!bIgnoreRule && pdesc->_ShowFolder())
                {
                    // We have enough kids
                    // Let's see if the state changed from last time
                    if (!(dwMode & SFD_WASSHOWN))
                    {
                        WCHAR *pszShowCache = pdesc->GetShowCacheRegName();
                        if (pszShowCache)
                        {
                            dwMode |= SFD_WASSHOWN;
                            SHSetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, pszShowCache, REG_DWORD, &dwMode, sizeof(dwMode));
                            pThis->Invalidate();
                            LocalFree(pszShowCache);
                        }
                    }
                    continue;
                }

                // just create the item to get a pidl for it....
                SpecialFolderListItem *pitem = new SpecialFolderListItem(pdesc);

                if (pitem && pitem->_pidl)
                {
                    // We don't have enough kids but we might gain them dynamically.
                    // Register for notifications that can indicate that there are new
                    // items.
                    ASSERT(pThis->_cNotify < SFTHOST_MAXNOTIFY);
                    if (pThis->RegisterNotify(pThis->_cNotify, SHCNE_CREATE | SHCNE_MKDIR | SHCNE_UPDATEDIR,
                                       pitem->_pidl, FALSE))
                    {
                        pThis->_cNotify++;
                    }
                }
                delete pitem;

                // Let's see if the state changed from last time
                if (dwMode & SFD_WASSHOWN)
                {
                    // Reset it to the default
                    WCHAR *pszShowCache = pdesc->GetShowCacheRegName();
                    if (pszShowCache)
                    {
                        SHDeleteValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, pszShowCache);
                        pThis->Invalidate();
                        LocalFree(pszShowCache);
                    }
                }
            }
        }
        pThis->Release();
    }
    SHCoUninitialize(hr);
    return 0;
}

BOOL ShouldShowItem(const SpecialFolderDesc *pdesc, BOOL bIgnoreRule, DWORD dwMode)
{
    if (bIgnoreRule)
        return TRUE;        // registry is over-riding whatever special rules exist...

    // if we've got a special rule, then the background thread will check it, so return false for now unless we showed it last time
    if (pdesc->_ShowFolder) 
    {
        if (pdesc->IsCacheable())
        {
            if (dwMode & SFD_WASSHOWN)
            {
                // Last time we looked, there were enough kids so let's assume it hasn't changed for now
                return TRUE;
            }

            return FALSE;
        }
        else
        {
            return pdesc->_ShowFolder();
        }
    }

    return TRUE;
}

void SpecialFolderList::EnumItems()
{

    // Clean out any previous register notifies.
    UINT id;
    for (id = 0; id < _cNotify; id++)
    {
        UnregisterNotify(id);
    }
    _cNotify = 0;

    // Start background enum for the MinKids since they can get hung up on the network
    AddRef();
    if (!SHQueueUserWorkItem(SpecialFolderList::_HasEnoughChildrenThreadProc, this, 0, 0, NULL, NULL, 0))
    {
        Release();
    }

    DWORD dwIndex;

    // Restrictions may result in an entire section disappearing,
    // so don't create two separators in a row.  Preinitialize to TRUE
    // so we don't get separators at the top of the list.
    BOOL fIgnoreSeparators = TRUE;
    int  iItems=0;

    for (dwIndex = 0; dwIndex < ARRAYSIZE(s_rgsfd); dwIndex++)
    {
        const SpecialFolderDesc *pdesc = &s_rgsfd[dwIndex];

        BOOL bIgnoreRule;
        DWORD dwMode = pdesc->GetDisplayMode(&bIgnoreRule);

        if (dwMode != SFD_HIDE)
        {
            SpecialFolderListItem *pitem = new SpecialFolderListItem(pdesc);
            if (pitem)
            {
                if ((pitem->IsSeparator() && !fIgnoreSeparators) ||
                    (pitem->_pidl && ShouldShowItem(pdesc, bIgnoreRule, dwMode))) 
                {
                    if ((dwMode & SFD_MODEMASK) == SFD_CASCADE)
                    {
                        pitem->EnableCascade();
                    }
                    if (pdesc->IsDropTarget())
                    {
                        pitem->EnableDropTarget();
                    }

                    // Get the icon and display name now.
                    if (!pitem->IsSeparator())
                    {
                        IShellFolder *psf;
                        LPCITEMIDLIST pidlItem;

                        HRESULT hr = SHBindToIDListParent(pitem->_pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlItem);
                        if (SUCCEEDED(hr))
                        {
                            if (!pitem->_psfd->GetCustomName(&pitem->_pszDispName))
                                pitem->_pszDispName = _DisplayNameOf(psf, pidlItem, SHGDN_NORMAL);
                            pitem->_hIcon = _IconOf(psf, pidlItem, _cxIcon);
                            psf->Release();
                        }
                    }

                    fIgnoreSeparators = pitem->IsSeparator();
                    // add the item
                    AddItem(pitem, NULL, pitem->_pidl);
                    if (!pitem->IsSeparator())
                        iItems++;
                }
                else
                    delete pitem;
            }
        }
    }
    SetDesiredSize(0, iItems);
}

int SpecialFolderList::AddImageForItem(PaneItem *p, IShellFolder *psf, LPCITEMIDLIST pidl, int iPos)
{
    int iIcon = -1;     // assume no icon
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);

    if (pitem->_hIcon)
    {
        iIcon = AddImage(pitem->_hIcon);
        DestroyIcon(pitem->_hIcon);
        pitem->_hIcon = NULL;
    }
    return iIcon;
}

LPTSTR SpecialFolderList::DisplayNameOfItem(PaneItem *p, IShellFolder *psf, LPCITEMIDLIST pidlItem, SHGNO shgno)
{
    LPTSTR psz = NULL;
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    if (shgno == SHGDN_NORMAL && pitem->_pszDispName)
    {
        // We are going to transfer ownership
        psz = pitem->_pszDispName;
        pitem->_pszDispName = NULL;
    }
    else
    {
        if (!pitem->_psfd->GetCustomName(&psz))
        {
            psz = SFTBarHost::DisplayNameOfItem(p, psf, pidlItem, shgno);
        }
    }

    if ((pitem->_psfd->_uFlags & SFD_PREFIX) && psz)
    {
        SHFree(pitem->_pszAccelerator);
        pitem->_pszAccelerator = NULL;
        SHStrDup(psz, &pitem->_pszAccelerator); // if it fails, then tough, no mnemonic
        pitem->_chMnem = CharUpperChar(SHStripMneumonic(psz));
    }

    return psz;
}

int SpecialFolderList::CompareItems(PaneItem *p1, PaneItem *p2)
{
//    SpecialFolderListItem *pitem1 = static_cast<SpecialFolderListItem *>(p1);
//    SpecialFolderListItem *pitem2 = static_cast<SpecialFolderListItem *>(p2);

    return 0; // we added them in the right order the first time
}

HRESULT SpecialFolderList::GetFolderAndPidl(PaneItem *p,
        IShellFolder **ppsfOut, LPCITEMIDLIST *ppidlOut)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    return SHBindToIDListParent(pitem->_pidl, IID_PPV_ARG(IShellFolder, ppsfOut), ppidlOut);
}

void SpecialFolderList::GetItemInfoTip(PaneItem *p, LPTSTR pszText, DWORD cch)
{
    SpecialFolderListItem *pitem = (SpecialFolderListItem*)p;
    if (pitem->_psfd->_iToolTip)
        LoadString(_Module.GetResourceInstance(), pitem->_psfd->_iToolTip, pszText, cch);
    else
        SFTBarHost::GetItemInfoTip(p, pszText, cch);    // call the base class
}

HRESULT SpecialFolderList::ContextMenuRenameItem(PaneItem *p, LPCTSTR ptszNewName)
{
    SpecialFolderListItem *pitem = (SpecialFolderListItem*)p;
    IShellFolder *psf;
    LPCITEMIDLIST pidlItem;
    HRESULT hr = GetFolderAndPidl(pitem, &psf, &pidlItem);
    if (SUCCEEDED(hr))
    {
        LPITEMIDLIST pidlNew;
        hr = psf->SetNameOf(_hwnd, pidlItem, ptszNewName, SHGDN_INFOLDER, &pidlNew);
        if (SUCCEEDED(hr))
        {
            pitem->ReplaceLastPidlElement(pidlNew);
        }
        psf->Release();
    }

    return hr;
}

//
//  If we get any changenotify, it means that somebody added (or thought about
//  adding) an item to one of our minkids folders, so we'll have to look to see
//  if it crossed the minkids threshold.
//
void SpecialFolderList::OnChangeNotify(UINT id, LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    Invalidate();
    for (id = 0; id < _cNotify; id++)
    {
        UnregisterNotify(id);
    }
    _cNotify = 0;
    PostMessage(_hwnd, SFTBM_REFRESH, TRUE, 0);
}


BOOL SpecialFolderList::IsItemStillValid(PaneItem *p)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    return pitem->IsStillValid();
}

BOOL SpecialFolderList::IsBold(PaneItem *p)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    return pitem->_psfd->IsBold();
}

HRESULT SpecialFolderList::GetCascadeMenu(PaneItem *p, IShellMenu **ppsm)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    IShellFolder *psf;
    HRESULT hr = SHBindToObjectEx(NULL, pitem->_pidl, NULL, IID_PPV_ARG(IShellFolder, &psf));
    if (SUCCEEDED(hr))
    {
        IShellMenu *psm;
        hr = CoCreateInstance(CLSID_MenuBand, NULL, CLSCTX_INPROC_SERVER,
                              IID_PPV_ARG(IShellMenu, &psm));
        if (SUCCEEDED(hr))
        {

            //
            //  Recent Documents requires special treatment.
            //
            IShellMenuCallback *psmc = NULL;
            hr = pitem->_psfd->CreateShellMenuCallback(&psmc);

            if (SUCCEEDED(hr))
            {
                DWORD dwFlags = SMINIT_TOPLEVEL | SMINIT_VERTICAL | pitem->_psfd->_dwShellFolderFlags;
                if (IsRestrictedOrUserSetting(HKEY_CURRENT_USER, REST_NOCHANGESTARMENU,
                                              TEXT("Advanced"), TEXT("Start_EnableDragDrop"),
                                              ROUS_DEFAULTALLOW | ROUS_KEYALLOWS))
                {
                    dwFlags |= SMINIT_RESTRICT_DRAGDROP | SMINIT_RESTRICT_CONTEXTMENU;
                }
                psm->Initialize(psmc, 0, 0, dwFlags);

                HKEY hkCustom = NULL;
                if (pitem->_psfd->_pszCustomizeKey)
                {
                    RegCreateKeyEx(HKEY_CURRENT_USER, pitem->_psfd->_pszCustomizeKey,
                                   NULL, NULL, REG_OPTION_NON_VOLATILE,
                                   KEY_READ | KEY_WRITE, NULL, &hkCustom, NULL);
                }

                dwFlags = SMSET_USEBKICONEXTRACTION;
                hr = psm->SetShellFolder(psf, pitem->_pidl, hkCustom, dwFlags);
                if (SUCCEEDED(hr))
                {
                    // SetShellFolder takes ownership of hkCustom
                    *ppsm = psm;
                    psm->AddRef();
                }
                else
                {
                    // Clean up the registry key since SetShellFolder
                    // did not take ownership
                    if (hkCustom)
                    {
                        RegCloseKey(hkCustom);
                    }
                }

                ATOMICRELEASE(psmc); // psmc can be NULL
            }
            psm->Release();
        }
        psf->Release();
    }

    return hr;
}

TCHAR SpecialFolderList::GetItemAccelerator(PaneItem *p, int iItemStart)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);

    if (pitem->_chMnem)
    {
        return pitem->_chMnem;
    }
    else
    {
        // Default: First letter is accelerator.
        return SFTBarHost::GetItemAccelerator(p, iItemStart);
    }
}

LRESULT SpecialFolderList::OnWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_NOTIFY:
        switch (((NMHDR*)(lParam))->code)
        {
        // When the user connects/disconnects via TS, we need to recalc
        // the "Windows Security" item
        case SMN_REFRESHLOGOFF:
            Invalidate();
            break;
        }
    }

    // Else fall back to parent implementation
    return SFTBarHost::OnWndProc(hwnd, uMsg, wParam, lParam);
}

BOOL _IsItemHiddenOnDesktop(LPCTSTR pszGuid)
{
    return SHRegGetBoolUSValue(REGSTR_PATH_HIDDEN_DESKTOP_ICONS_STARTPANEL,
                               pszGuid, FALSE, FALSE);
}

UINT SpecialFolderList::AdjustDeleteMenuItem(PaneItem *p, UINT *puiFlags)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    if (pitem->_psfd->_pszCanHideOnDesktop)
    {
        // Set MF_CHECKED if the item is visible on the desktop
        if (!_IsItemHiddenOnDesktop(pitem->_psfd->_pszCanHideOnDesktop))
        {
            // Item is visible - show the checkbox
            *puiFlags |= MF_CHECKED;
        }

        return IDS_SFTHOST_SHOWONDESKTOP;
    }
    else
    {
        return 0; // not deletable
    }
}

HRESULT SpecialFolderList::ContextMenuInvokeItem(PaneItem *p, IContextMenu *pcm, CMINVOKECOMMANDINFOEX *pici, LPCTSTR pszVerb)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    HRESULT hr;

    if (StrCmpIC(pszVerb, TEXT("delete")) == 0)
    {
        ASSERT(pitem->_psfd->_pszCanHideOnDesktop);

        // Toggle the hide/unhide state
        DWORD dwHide = !_IsItemHiddenOnDesktop(pitem->_psfd->_pszCanHideOnDesktop);
        LONG lErr = SHRegSetUSValue(REGSTR_PATH_HIDDEN_DESKTOP_ICONS_STARTPANEL,
                                    pitem->_psfd->_pszCanHideOnDesktop,
                                    REG_DWORD, &dwHide, sizeof(dwHide),
                                    SHREGSET_FORCE_HKCU);
        hr = HRESULT_FROM_WIN32(lErr);
        if (SUCCEEDED(hr))
        {
            // explorer\rcids.h and shell32\unicpp\resource.h have DIFFERENT
            // VALUES FOR FCIDM_REFRESH!  We want the one in unicpp\resource.h
            // because that's the correct one...
#define FCIDM_REFRESH_REAL 0x0a220
            PostMessage(GetShellWindow(), WM_COMMAND, FCIDM_REFRESH_REAL, 0); // refresh desktop
        }
    }
    else
    {
        hr = SFTBarHost::ContextMenuInvokeItem(pitem, pcm, pici, pszVerb);
    }

    return hr;
}

HRESULT SpecialFolderList::_GetUIObjectOfItem(PaneItem *p, REFIID riid, LPVOID *ppv)
{
    SpecialFolderListItem *pitem = static_cast<SpecialFolderListItem *>(p);
    if (pitem->_psfd->IsCSIDL() && (CSIDL_RECENT == pitem->_psfd->GetCSIDL()))
    {
        *ppv = NULL;
        return E_NOTIMPL;
    }
    return SFTBarHost::_GetUIObjectOfItem(p, riid, ppv);
}



//****************************************************************************
//
//  IShellMenuCallback helper for Recent Documents
//
//  We want to restrict to the first MAXRECDOCS items.
//

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

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

private:
    friend HRESULT CRecentShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
    HRESULT _FilterRecentPidl(IShellFolder *psf, LPCITEMIDLIST pidlItem);

    int     _nShown;
    int     _iMaxRecentDocs;
};

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

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

HRESULT CRecentShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_BEGINENUM:
        _nShown = 0;
        _iMaxRecentDocs = SHRestricted(REST_MaxRecentDocs);
        if (_iMaxRecentDocs < 1)
            _iMaxRecentDocs = 15;       // default from shell32\recdocs.h
        return S_OK;

    case SMC_FILTERPIDL:
        ASSERT(psmd->dwMask & SMDM_SHELLFOLDER);
        return _FilterRecentPidl(psmd->psf, psmd->pidlItem);

    }
    return S_FALSE;
}

//
//  Return S_FALSE to allow the item to show, S_OK to hide it
//

HRESULT CRecentShellMenuCallback::_FilterRecentPidl(IShellFolder *psf, LPCITEMIDLIST pidlItem)
{
    HRESULT hrRc = S_OK;      // Assume hidden

    if (_nShown < _iMaxRecentDocs)
    {
        IShellLink *psl;
        if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, &pidlItem, IID_X_PPV_ARG(IShellLink, NULL, &psl))))
        {
            LPITEMIDLIST pidlTarget;
            if (SUCCEEDED(psl->GetIDList(&pidlTarget)) && pidlTarget)
            {
                DWORD dwAttr = SFGAO_FOLDER;
                if (SUCCEEDED(SHGetAttributesOf(pidlTarget, &dwAttr)) &&
                    !(dwAttr & SFGAO_FOLDER))
                {
                    // We found a shortcut to a nonfolder - keep it!
                    _nShown++;
                    hrRc = S_FALSE;
                }
                ILFree(pidlTarget);
            }

            psl->Release();
        }
    }

    return hrRc;
}

HRESULT CRecentShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc)
{
    *ppsmc = new CRecentShellMenuCallback;
    return *ppsmc ? S_OK : E_OUTOFMEMORY;
}

//****************************************************************************
//
//  IShellMenuCallback helper that disallows cascading into subfolders
//

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

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

private:
    friend HRESULT CNoSubdirShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
};

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

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

HRESULT CNoSubdirShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_GETSFINFO:
        {
            // Turn off the SMIF_SUBMENU flag on everybody.  This
            // prevents us from cascading more than one level deel.
            SMINFO *psminfo = reinterpret_cast<SMINFO *>(lParam);
            psminfo->dwFlags &= ~SMIF_SUBMENU;
            return S_OK;
        }
    }
    return S_FALSE;
}

HRESULT CNoSubdirShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc)
{
    *ppsmc = new CNoSubdirShellMenuCallback;
    return *ppsmc ? S_OK : E_OUTOFMEMORY;
}

//****************************************************************************
//
//  IShellMenuCallback helper for My Computer
//
//  Disallow cascading into subfolders and also force the default
//  drag/drop effect to DROPEFFECT_LINK.
//

class CMyComputerShellMenuCallback
    : public CNoSubdirShellMenuCallback
{
public:
    typedef CNoSubdirShellMenuCallback super;

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

private:
    friend HRESULT CMyComputerShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
};

HRESULT CMyComputerShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_BEGINDRAG:
        *(DWORD*)wParam = DROPEFFECT_LINK;
        return S_OK;

    }
    return super::CallbackSM(psmd, uMsg, wParam, lParam);
}

HRESULT CMyComputerShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc)
{
    *ppsmc = new CMyComputerShellMenuCallback;
    return *ppsmc ? S_OK : E_OUTOFMEMORY;
}

//****************************************************************************
//
//  IShellMenuCallback helper that prevents Fonts from cascading
//  Used by Control Panel.
//

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

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

private:
    friend HRESULT CNoFontsShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
};

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

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

BOOL _IsFontsFolderShortcut(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    TCHAR sz[MAX_PATH];
    return SUCCEEDED(DisplayNameOf(psf, pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, sz, ARRAYSIZE(sz))) &&
           lstrcmpi(sz, TEXT("::{D20EA4E1-3957-11d2-A40B-0C5020524152}")) == 0;
}

HRESULT CNoFontsShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_GETSFINFO:
        {
            // If this is the Fonts item, then remove the SUBMENU attribute.
            SMINFO *psminfo = reinterpret_cast<SMINFO *>(lParam);
            if ((psminfo->dwMask & SMIM_FLAGS) &&
                (psminfo->dwFlags & SMIF_SUBMENU) &&
                _IsFontsFolderShortcut(psmd->psf, psmd->pidlItem))
            {
                psminfo->dwFlags &= ~SMIF_SUBMENU;
            }
            return S_OK;
        }
    }
    return S_FALSE;
}

HRESULT CNoFontsShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc)
{
    *ppsmc = new CNoFontsShellMenuCallback;
    return *ppsmc ? S_OK : E_OUTOFMEMORY;
}

//****************************************************************************
//
//  IShellMenuCallback helper that filters the "connect to" menu
//

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

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

    // *** IObjectWithSite ***
    // inherited from CObjectWithSite

private:
    HRESULT _OnGetSFInfo(SMDATA *psmd, SMINFO *psminfo);
    HRESULT _OnGetInfo(SMDATA *psmd, SMINFO *psminfo);
    HRESULT _OnEndEnum(SMDATA *psmd);

    friend HRESULT CConnectToShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc);
    BOOL _bAnyRAS;
};

#define ICOL_NETCONMEDIATYPE       0x101 // from netshell
#define ICOL_NETCONSUBMEDIATYPE    0x102 // from netshell
#define ICOL_NETCONSTATUS          0x103 // from netshell
#define ICOL_NETCONCHARACTERISTICS 0x104 // from netshell

BOOL IsMediaRASType(NETCON_MEDIATYPE ncm)
{
    return (ncm == NCM_DIRECT || ncm == NCM_ISDN || ncm == NCM_PHONE || ncm == NCM_TUNNEL || ncm == NCM_PPPOE);  // REVIEW DIRECT correct?
}

BOOL IsNetConPidlRAS(IShellFolder2 *psfNetCon, LPCITEMIDLIST pidlNetConItem)
{
    BOOL bRet = FALSE;
    SHCOLUMNID scidMediaType, scidSubMediaType, scidCharacteristics;
    VARIANT v;
    
    scidMediaType.fmtid       = GUID_NETSHELL_PROPS;
    scidMediaType.pid         = ICOL_NETCONMEDIATYPE;

    scidSubMediaType.fmtid    = GUID_NETSHELL_PROPS;
    scidSubMediaType.pid      = ICOL_NETCONSUBMEDIATYPE;
    
    scidCharacteristics.fmtid = GUID_NETSHELL_PROPS;
    scidCharacteristics.pid   = ICOL_NETCONCHARACTERISTICS;

    if (SUCCEEDED(psfNetCon->GetDetailsEx(pidlNetConItem, &scidMediaType, &v)))
    {
        // Is this a RAS connection
        if (IsMediaRASType((NETCON_MEDIATYPE)v.lVal))
        {
            VariantClear(&v);
         
            // Make sure it's not incoming
            if (SUCCEEDED(psfNetCon->GetDetailsEx(pidlNetConItem, &scidCharacteristics, &v)))
            {
                if (!(NCCF_INCOMING_ONLY & v.lVal))
                    bRet = TRUE;
            }
        }

        // Is this a Wireless LAN connection?
        if (NCM_LAN == (NETCON_MEDIATYPE)v.lVal)
        {
            VariantClear(&v);
            
            if (SUCCEEDED(psfNetCon->GetDetailsEx(pidlNetConItem, &scidSubMediaType, &v)))
            {
                if (NCSM_WIRELESS == (NETCON_SUBMEDIATYPE)v.lVal)
                    bRet = TRUE;
            }
        }

        VariantClear(&v);
    }
    return bRet;
}

HRESULT CConnectToShellMenuCallback::_OnGetInfo(SMDATA *psmd, SMINFO *psminfo)
{
    HRESULT hr = S_FALSE;
    if (psminfo->dwMask & SMIM_ICON)
    {
        if (psmd->uId == IDM_OPENCONFOLDER)
        {
            LPITEMIDLIST pidl = SHCloneSpecialIDList(NULL, CSIDL_CONNECTIONS, FALSE);
            if (pidl)
            {
                LPCITEMIDLIST pidlObject;
                IShellFolder *psf;
                hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlObject);
                if (SUCCEEDED(hr))
                {
                    SHMapPIDLToSystemImageListIndex(psf, pidlObject, &psminfo->iIcon);
                    psminfo->dwFlags |= SMIF_ICON;
                    psf->Release();
                }
                ILFree(pidl);
            }
        }
    }
    return hr;
}

HRESULT CConnectToShellMenuCallback::_OnGetSFInfo(SMDATA *psmd, SMINFO *psminfo)
{
    IShellFolder2 *psf2;
    ASSERT(psminfo->dwMask & SMIM_FLAGS);                       // ??
    psminfo->dwFlags &= ~SMIF_SUBMENU;

    if (SUCCEEDED(psmd->psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
    {
        if (!IsNetConPidlRAS(psf2, psmd->pidlItem))
            psminfo->dwFlags |= SMIF_HIDDEN;
        else
            _bAnyRAS = TRUE;

        psf2->Release();
    }

    return S_OK;
}

HRESULT CConnectToShellMenuCallback::_OnEndEnum(SMDATA *psmd)
{
    HRESULT hr = S_FALSE;
    IShellMenu* psm;

    if (psmd->punk && SUCCEEDED(hr = psmd->punk->QueryInterface(IID_PPV_ARG(IShellMenu, &psm))))
    {
        // load the static portion of the connect to menu, and add it to the bottom
        HMENU hmStatic = LoadMenu(_Module.GetResourceInstance(), MAKEINTRESOURCE(MENU_CONNECTTO));

        if (hmStatic)
        {
            // if there aren't any dynamic items (RAS connections), then delete the separator
            if (!_bAnyRAS)
                DeleteMenu(hmStatic, 0, MF_BYPOSITION);

            HWND hwnd = NULL;
            IUnknown *punk;
            if (SUCCEEDED(IUnknown_QueryService(_punkSite, SID_SMenuPopup, IID_PPV_ARG(IUnknown, &punk))))
            {
                IUnknown_GetWindow(punk, &hwnd);
                punk->Release();
            }
            psm->SetMenu(hmStatic, hwnd, SMSET_NOEMPTY | SMSET_BOTTOM);
        }
        psm->Release();
    }
    return hr;
}


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

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

HRESULT CConnectToShellMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case SMC_GETINFO:
        return _OnGetInfo(psmd, (SMINFO *)lParam);

    case SMC_GETSFINFO:
        return _OnGetSFInfo(psmd, (SMINFO *)lParam);

    case SMC_BEGINENUM:
        _bAnyRAS = FALSE;

    case SMC_ENDENUM:
        return _OnEndEnum(psmd);

    case SMC_EXEC:
        switch (psmd->uId)
        {
            case IDM_OPENCONFOLDER:
                ShowFolder(CSIDL_CONNECTIONS);
                return S_OK;
        }
        break;
    }

    return S_FALSE;
}

HRESULT CConnectToShellMenuCallback_CreateInstance(IShellMenuCallback **ppsmc)
{
    *ppsmc = new CConnectToShellMenuCallback;
    return *ppsmc ? S_OK : E_OUTOFMEMORY;
}

BOOL SpecialFolderDesc::LoadStringAsOLESTR(LPTSTR *ppsz) const
{
    BOOL bRet = FALSE;
    TCHAR szTmp[MAX_PATH];
    if (_idsCustomName && LoadString(_Module.GetResourceInstance(), _idsCustomName, szTmp, ARRAYSIZE(szTmp)))
    {
        if (ppsz)
            SHStrDup(szTmp, ppsz);
        bRet = TRUE;
    }
    return bRet;
}

BOOL SpecialFolderDesc::ConnectToName(LPTSTR *ppsz) const
{
    BOOL bIgnoreRule;
    DWORD dwMode = GetDisplayMode(&bIgnoreRule);

    // if Connect To is displayed as a link, then don't over-ride the name (i.e. use Network Connections)
    if ((dwMode & SFD_MODEMASK) == SFD_SHOW)
        return FALSE;
    else
        return LoadStringAsOLESTR(ppsz);
}


void ShowFolder(UINT csidl)
{
    LPITEMIDLIST pidl;
    if (SUCCEEDED(SHGetFolderLocation(NULL, csidl, NULL, 0, &pidl)))
    {
        SHELLEXECUTEINFO shei = { 0 };

        shei.cbSize     = sizeof(shei);
        shei.fMask      = SEE_MASK_IDLIST;
        shei.nShow      = SW_SHOWNORMAL;
        shei.lpVerb     = TEXT("open");
        shei.lpIDList   = pidl;
        ShellExecuteEx(&shei);
        ILFree(pidl);
    }
}