windows-xp/Source/XPSP1/NT/shell/shell32/fstree.cpp

#include "shellprv.h"
#include "filefldr.h"
#include <shellp.h>
#include <shguidp.h>
#include "idlcomm.h"
#include "pidl.h"
#include "views.h"
#include "ids.h"
#include "shitemid.h"
#include "datautil.h"
#include "prop.h"
#include "basefvcb.h"
#include "brutil.h"
#include "enumuicommand.h"
#include "enumidlist.h"
#include "wia.h"
#include "shimgvw.h"
#include "cdburn.h"
#include "foldertypes.h"
#include "htmlhelp.h"
#include "buytasks.h"
#include <crypto\md5.h>     // for MD5DIGESTLEN

const SHOP_INFO c_BuySampleMusic =    { L"BuyURL",      L"http://go.microsoft.com/fwlink/?LinkId=730&clcid={SUB_CLCID}", FALSE};
const SHOP_INFO c_BuyMusic          = { L"MusicBuyURL", L"http://go.microsoft.com/fwlink/?LinkId=493&clcid={SUB_CLCID}", TRUE};
const SHOP_INFO c_BuySamplePictures = { L"BuyURL",      L"http://go.microsoft.com/fwlink/?LinkId=625&clcid={SUB_CLCID}", TRUE};

class CFSFolderViewCB : public CBaseShellFolderViewCB
{
public:
    CFSFolderViewCB(CFSFolder *pfsf);
    STDMETHODIMP RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);

    STDMETHODIMP SetSite(IUnknown* pUnkSite);

private:
    ~CFSFolderViewCB();

    HRESULT OnSize(DWORD pv, UINT cx, UINT cy);
    HRESULT OnGetPane(DWORD pv, LPARAM dwPaneID, DWORD *pdwPane);
    HRESULT OnGetCCHMax(DWORD pv, LPCITEMIDLIST pidlItem, UINT *pcchMax);
    HRESULT OnWindowCreated(DWORD pv, HWND wP);
    HRESULT OnInsertDeleteItem(int iMul, LPCITEMIDLIST wP);
    HRESULT OnSelChange(DWORD pv, UINT wPl, UINT wPh, SFVM_SELCHANGE_DATA*lP);
    HRESULT OnUpdateStatusBar(DWORD pv, BOOL wP);
    HRESULT OnRefresh(DWORD pv, BOOL fPreRefresh);
    HRESULT OnSelectAll(DWORD pv);
    HRESULT OnGetWorkingDir(DWORD pv, UINT wP, LPTSTR lP);
    HRESULT OnEnumeratedItems(DWORD pv, UINT celt, LPCITEMIDLIST* rgpidl);
    HRESULT OnGetViewData(DWORD pv, UINT uViewMode, SFVM_VIEW_DATA* pvi);
    HRESULT OnGetWebViewTemplate(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_TEMPLATE_DATA* pvit);
    HRESULT OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData);
    HRESULT OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData);
    HRESULT OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks);
    HRESULT OnGetWebViewTheme(DWORD pv, SFVM_WEBVIEW_THEME_DATA* pTheme);
    HRESULT OnDefViewMode(DWORD pv, FOLDERVIEWMODE*lP);
    HRESULT OnGetCustomViewInfo(DWORD pv, SFVM_CUSTOMVIEWINFO_DATA* pData);
    HRESULT OnSupportsIdentity(DWORD pv);
    HRESULT OnQueryReuseExtView(DWORD pv, BOOL *pfReuseAllowed);
    HRESULT OnGetNotify(DWORD pv, LPITEMIDLIST*wP, LONG*lP);
    HRESULT OnGetDeferredViewSettings(DWORD pv, SFVM_DEFERRED_VIEW_SETTINGS* pSettings);

    BOOL _CollectDefaultFolderState();
    PERCEIVED _GetFolderPerceivedType(LPCIDFOLDER pidf);
    HRESULT _GetStringForFolderType(int iType, LPWSTR pszFolderType, UINT cchBuf);
    BOOL _IsBarricadedFolder();

    UINT _cItems;

    FSSELCHANGEINFO _fssci;
    CFSFolder* _pfsf;
    BOOL _fStatusInitialized;

    TRIBIT _fHasWIADevices;

    IPreview3 * _pPreview;
    HRESULT _GetPreview3(IPreview3** ppPreview3);

    HRESULT _GetShoppingBrowsePidl(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc, const SHOP_INFO *pShopInfo, LPITEMIDLIST *ppidl);
    HRESULT _GetShoppingURL(const SHOP_INFO *pShopInfo, LPTSTR pszURL, DWORD cchURL);


    HRESULT _DataObjectFromItemsOrFolder(IShellItemArray *psiItemArray, IDataObject **ppdto);

public:
    // webview task implementations:
    static HRESULT _HasWiaDevices(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _HasItems(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanOrderPrints(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanPrintPictures(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanBuyPictures(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanWallpaper(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanPlayMusic(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanPlayVideos(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanSendToAudioCD(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _CanSendToCD(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
    static HRESULT _OnCommonDocumentsHelp(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnPlayMusic(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnPlayVideos(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnShopForMusicOnline(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnShopForPicturesOnline(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnSendToAudioCD(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnGetFromCamera(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnSlideShow(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnWallpaper(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnOrderPrints(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnPrintPictures(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
    static HRESULT _OnSendToCD(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);

    static HRESULT _CanPlay(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState, int fDATAOBJCB);
    static HRESULT _OnPlay(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc, int fDATAOBJCB);
};

#define FS_EVENTS (SHCNE_DISKEVENTS | SHCNE_ASSOCCHANGED | SHCNE_NETSHARE | SHCNE_NETUNSHARE)

CFSFolderViewCB::CFSFolderViewCB(CFSFolder *pfsf) : CBaseShellFolderViewCB(pfsf->_pidl, FS_EVENTS), _pfsf(pfsf)
{ 
    _pfsf->AddRef();

    ZeroMemory(&_fssci, sizeof(_fssci));

    // _fssci.szDrive[0] == '\0' means "unknown" / "not available"
    _fssci.cbFree = -1;        // this field uses -1 to mean
                               // "unknown" / "not available"

    _pPreview = NULL;
    ASSERT(!_fStatusInitialized);
}

CFSFolderViewCB::~CFSFolderViewCB()
{
    if (_pPreview)
    {
        IUnknown_SetSite(_pPreview, NULL);
        _pPreview->Release();
    }

    _pfsf->Release();
}

STDMETHODIMP CFSFolderViewCB::SetSite(IUnknown* punkSite)
{
    if (_pPreview)
    {
        IUnknown_SetSite(_pPreview, punkSite);
    }
    return CBaseShellFolderViewCB::SetSite(punkSite);
}

HRESULT CFSFolderViewCB::OnSize(DWORD pv, UINT cx, UINT cy)
{
    ResizeStatus(_punkSite, cx);
    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetPane(DWORD pv, LPARAM dwPaneID, DWORD *pdwPane)
{
    if (PANE_ZONE == dwPaneID)
        *pdwPane = 2;
    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetCCHMax(DWORD pv, LPCITEMIDLIST pidlItem, UINT *pcchMax)
{
    TCHAR szName[MAX_PATH];
    if (SUCCEEDED(DisplayNameOf(_pfsf, pidlItem, SHGDN_FORPARSING | SHGDN_INFOLDER, szName, ARRAYSIZE(szName))))
    {
        _pfsf->GetMaxLength(szName, (int *)pcchMax);
    }
    return S_OK;
}

HRESULT CFSFolderViewCB::OnWindowCreated(DWORD pv, HWND wP)
{
    if (SUCCEEDED(_pfsf->_GetPath(_fssci.szDrive)))
    {
        _fssci.cbFree = -1;                            // not known yet

        if (!_fStatusInitialized)
        {
            InitializeStatus(_punkSite);
            _fStatusInitialized = TRUE;
        }
        
        return S_OK;
    
    }
    return E_FAIL;
}

HRESULT CFSFolderViewCB::OnInsertDeleteItem(int iMul, LPCITEMIDLIST wP)
{
    ViewInsertDeleteItem(_pfsf, &_fssci, wP, iMul);

    // Tell the FSFolder that it needs to update the extended columns
    // when we get an insert item.  This will cause the next call to
    // IColumnProvider::GetItemData to flush it's row-wise cache.
    if (1 == iMul)
    {
        _pfsf->_bUpdateExtendedCols = TRUE;
    }
    return S_OK;
}

HRESULT CFSFolderViewCB::OnSelChange(DWORD pv, UINT wPl, UINT wPh, SFVM_SELCHANGE_DATA*lP)
{
    ViewSelChange(_pfsf, lP, &_fssci);
    return S_OK;
}

HRESULT CFSFolderViewCB::OnUpdateStatusBar(DWORD pv, BOOL wP)
{
    if (!_fStatusInitialized)
    {
        InitializeStatus(_punkSite);
        _fStatusInitialized = TRUE;
    }

    // if initializing, force refresh of disk free space
    if (wP)
        _fssci.cbFree = -1;
    return ViewUpdateStatusBar(_punkSite, _pidl, &_fssci);
}

HRESULT CFSFolderViewCB::OnRefresh(DWORD pv, BOOL fPreRefresh)
{
    // pre refresh...
    if (fPreRefresh)
    {
        _fHasWIADevices = TRIBIT_UNDEFINED; // so we re-query
    }
    else
    {
        _fssci.cHiddenFiles = _pfsf->_cHiddenFiles;
        _fssci.cbSize = _pfsf->_cbSize;
    }
    return S_OK;
}

HRESULT CFSFolderViewCB::OnSelectAll(DWORD pv)
{
    HRESULT hr = S_OK;

    if (_fssci.cHiddenFiles > 0) 
    {
        if (ShellMessageBox(HINST_THISDLL, _hwndMain, 
            MAKEINTRESOURCE(IDS_SELECTALLBUTHIDDEN), 
            MAKEINTRESOURCE(IDS_SELECTALL), MB_OKCANCEL | MB_SETFOREGROUND | MB_ICONWARNING, 
            _fssci.cHiddenFiles) == IDCANCEL)
        {
            hr = S_FALSE;
        }
    }
    return hr;
}

HRESULT CFSFolderViewCB::OnGetWorkingDir(DWORD pv, UINT wP, LPTSTR lP)
{
    return _pfsf->_GetPath(lP);
}

int GetSysDriveId()
{
    int idDriveSys = -1;
    
    TCHAR szSystemDir[MAX_PATH];
    if (SHGetSpecialFolderPath(NULL, szSystemDir, CSIDL_SYSTEM, 0))
    {
        idDriveSys = PathGetDriveNumber(szSystemDir);
    }
    return idDriveSys;
}


HRESULT CFSFolderViewCB::_HasWiaDevices(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    if (TRIBIT_UNDEFINED == pThis->_fHasWIADevices && fOkToBeSlow)
    {
        pThis->_fHasWIADevices = TRIBIT_FALSE;

        // strings stolen from stiregi.h
        // REGSTR_PATH_SOFT_STI, REGSTR_VAL_WIA_PRESEN

        if (ERROR_SUCCESS == SHGetValue(HKEY_LOCAL_MACHINE, 
            TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\StillImage"), 
            TEXT("WIADevicePresent"), NULL, NULL, NULL))
        {
            IWiaDevMgr* pwia;
            if (SUCCEEDED(CoCreateInstance(CLSID_WiaDevMgr, NULL, CLSCTX_LOCAL_SERVER, IID_PPV_ARG(IWiaDevMgr, &pwia))))
            {
                IEnumWIA_DEV_INFO* penum;
                if (S_OK == pwia->EnumDeviceInfo(0, &penum))
                {
                    ULONG cItems;
                    if ((S_OK == penum->GetCount(&cItems)) &&
                        cItems > 0)
                    {
                        pThis->_fHasWIADevices = TRIBIT_TRUE;
                    }
                    penum->Release();
                }
                pwia->Release();
            }
        }
    }

    *puisState = (TRIBIT_TRUE == pThis->_fHasWIADevices) ? UIS_ENABLED : UIS_HIDDEN;
    return TRIBIT_UNDEFINED == pThis->_fHasWIADevices ? E_PENDING : S_OK;
}

HRESULT CFSFolderViewCB::_HasItems(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    *puisState = UIS_ENABLED;

    if (!psiItemArray)
    {
        // empty folders don't want this task
        *puisState = UIS_DISABLED;

        IFolderView* pfv;
        IDataObject *pdo;

        if (pThis->_punkSite && SUCCEEDED(pThis->_punkSite->QueryInterface(IID_PPV_ARG(IFolderView, &pfv))))
        {
            if (SUCCEEDED(pfv->Items(SVGIO_ALLVIEW, IID_PPV_ARG(IDataObject, &pdo))))
            {
                *puisState = UIS_ENABLED;
                pdo->Release();
            }

            pfv->Release();
        }

    }

    return S_OK;
}

// Image options
#define IMAGEOPTION_CANROTATE    0x00000001
#define IMAGEOPTION_CANWALLPAPER 0x00000002

HRESULT CFSFolderViewCB::_CanWallpaper(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    *puisState = UIS_DISABLED;
    IDataObject *pdo;

    if (psiItemArray && SUCCEEDED(psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo))))
    {
        LPITEMIDLIST pidl;
        if (SUCCEEDED(PidlFromDataObject(pdo, &pidl))) // could get this dircetly from ShellItemArray
        {
            IAssociationArray *paa;
            if (SUCCEEDED(SHGetUIObjectOf(pidl, NULL, IID_PPV_ARG(IAssociationArray, &paa))))
            {
                DWORD dwFlags, cb = sizeof(dwFlags);
                if (SUCCEEDED(paa->QueryDword(ASSOCELEM_MASK_QUERYNORMAL, AQN_NAMED_VALUE, L"ImageOptionFlags", &dwFlags)) &&
                    (dwFlags & IMAGEOPTION_CANWALLPAPER))
                {
                    *puisState = UIS_ENABLED;
                }
                paa->Release();
            }
            ILFree(pidl);
        }

        pdo->Release();
    }

    return S_OK;
}

enum
{
    DATAOBJCB_IMAGE = 0x1,
    DATAOBJCB_MUSIC = 0x2,
    DATAOBJCB_VIDEO = 0x4,

    DATAOBJCB_ONLYCHECKEXISTENCE = 0x80000000
};
class CDataObjectCallback : public INamespaceWalkCB
{
public:
    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);

    // INamespaceWalkCB
    STDMETHODIMP FoundItem(IShellFolder *psf, LPCITEMIDLIST pidl);
    STDMETHODIMP EnterFolder(IShellFolder *psf, LPCITEMIDLIST pidl);
    STDMETHODIMP LeaveFolder(IShellFolder *psf, LPCITEMIDLIST pidl);
    STDMETHODIMP InitializeProgressDialog(LPWSTR *ppszTitle, LPWSTR *ppszCancel);

    CDataObjectCallback(DWORD dwFlags);
    BOOL Found();

private:
    DWORD _dwFlags;
    BOOL _fAlreadyFound;
};

STDMETHODIMP_(ULONG) CDataObjectCallback::AddRef()
{
    return 3;
}

STDMETHODIMP_(ULONG) CDataObjectCallback::Release()
{
    return 2;
}

CDataObjectCallback::CDataObjectCallback(DWORD dwFlags)
{
    _dwFlags = dwFlags;
    _fAlreadyFound = FALSE;
}

BOOL CDataObjectCallback::Found()
{
    return _fAlreadyFound;
}

STDMETHODIMP CDataObjectCallback::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = 
    {
        QITABENT(CDataObjectCallback, INamespaceWalkCB),
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}

STDMETHODIMP CDataObjectCallback::FoundItem(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    // a slight misuse of the walker -- we bail out early if we know we've already found
    // what we're looking for
    if ((_dwFlags & DATAOBJCB_ONLYCHECKEXISTENCE) && _fAlreadyFound)
        return E_FAIL;

    PERCEIVED gen = GetPerceivedType(psf, pidl);
    if ((_dwFlags & DATAOBJCB_IMAGE) && (gen == GEN_IMAGE) ||
        (_dwFlags & DATAOBJCB_MUSIC) && (gen == GEN_AUDIO) ||
        (_dwFlags & DATAOBJCB_VIDEO) && (gen == GEN_VIDEO))
    {
        if (_dwFlags & DATAOBJCB_ONLYCHECKEXISTENCE)
        {
            _fAlreadyFound = TRUE;
        }
        return S_OK;
    }

    return S_FALSE;
}

STDMETHODIMP CDataObjectCallback::EnterFolder(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    if ((_dwFlags & DATAOBJCB_ONLYCHECKEXISTENCE) && _fAlreadyFound)
        return E_FAIL;
    return S_OK;
}

STDMETHODIMP CDataObjectCallback::LeaveFolder(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    return S_OK;
}

STDMETHODIMP CDataObjectCallback::InitializeProgressDialog(LPWSTR *ppszTitle, LPWSTR *ppszCancel)
{
    *ppszCancel = NULL; // use default

    TCHAR szMsg[128];
    LoadString(HINST_THISDLL, IDS_WALK_PROGRESS_TITLE, szMsg, ARRAYSIZE(szMsg));
    return SHStrDup(szMsg, ppszTitle);
}

HRESULT InvokeVerbsOnItems(HWND hwndOwner, const LPCSTR rgszVerbs[], UINT cVerbs, LPITEMIDLIST *ppidls, UINT cItems)
{
    IContextMenu *pcm;
    HRESULT hr = SHGetUIObjectFromFullPIDL(ppidls[0], NULL, IID_PPV_ARG(IContextMenu, &pcm));
    if (SUCCEEDED(hr))
    {
        ITEMIDLIST id = {0};
        IDataObject *pdtobj;
        hr = SHCreateFileDataObject(&id, cItems, (LPCITEMIDLIST *)ppidls, NULL, &pdtobj);
        if (SUCCEEDED(hr))
        {
            IShellExtInit *psei;
            hr = pcm->QueryInterface(IID_PPV_ARG(IShellExtInit, &psei));
            if (SUCCEEDED(hr))
            {
                psei->Initialize(NULL, pdtobj, NULL);
                psei->Release();
            }
            pdtobj->Release();
        }

        hr = SHInvokeCommandsOnContextMenu(hwndOwner, NULL, pcm, 0, rgszVerbs, cVerbs);
        pcm->Release();
    }
    return hr;
}

HRESULT PlayFromUnk(IUnknown *punk, HWND hwndOwner, int fDATAOBJCB)
{
    INamespaceWalk *pnsw;
    HRESULT hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC, IID_PPV_ARG(INamespaceWalk, &pnsw));
    if (SUCCEEDED(hr))
    {
        CDataObjectCallback cb(fDATAOBJCB);
        hr = pnsw->Walk(punk, NSWF_NONE_IMPLIES_ALL | NSWF_ONE_IMPLIES_ALL | NSWF_SHOW_PROGRESS | NSWF_FLAG_VIEWORDER, 10, &cb);
        if (SUCCEEDED(hr))
        {
            UINT cItems;
            LPITEMIDLIST *ppidls;
            hr = pnsw->GetIDArrayResult(&cItems, &ppidls);
            if (SUCCEEDED(hr))
            {
                if (cItems)
                {
                    const LPCSTR c_rgszVerbs[] = { "Play", "Open" };

                    hr = InvokeVerbsOnItems(hwndOwner, c_rgszVerbs, ARRAYSIZE(c_rgszVerbs), ppidls, cItems);
                }
                else
                {
                    ShellMessageBox(
                        HINST_THISDLL,
                        hwndOwner,
                        MAKEINTRESOURCE(IDS_PLAYABLEFILENOTFOUND),
                        NULL,
                        MB_OK | MB_ICONERROR);
                    hr = S_FALSE;
                }
                FreeIDListArray(ppidls, cItems);
            }
        }
        pnsw->Release();
    }
    return hr;
}

HRESULT CFSFolderViewCB::_OnCommonDocumentsHelp(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    SHELLEXECUTEINFO sei = { 0 };

    sei.cbSize = sizeof(sei);
    sei.fMask = 0;
    sei.hwnd = ((CFSFolderViewCB*)(void*)pv)->_hwndMain;
    sei.nShow = SW_SHOWNORMAL;
    sei.lpFile = L"hcp://services/subsite?node=TopLevelBucket_2/Networking_and_the_Web&topic=MS-ITS%3A%25HELP_LOCATION%25%5Cfilefold.chm%3A%3A/using_shared_documents_folder.htm&select=TopLevelBucket_2/Networking_and_the_Web/Sharing_files__printers__and_other_resources";

    return ShellExecuteEx(&sei) ? S_OK : E_FAIL;
}

HRESULT CFSFolderViewCB::_CanOrderPrints(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    // TODO:  Use fOkToBeSlow (with a return of E_PENDING) to allow walk to
    // occur on a background task thread (for performance reasons).  However,
    // it doesn't work at present because it's completely specialized for WIA
    // stuff, and it will not be trivial to adapt to the general case.  Thus,
    // we make assumptions as best we can in determining the state for now.

    *puisState = UIS_DISABLED;

    IDataObject *pdo = NULL;
    HRESULT hr = psiItemArray ? psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo)) : S_OK;
    if (SUCCEEDED(hr))
    {
        if (pThis->_fssci.nItems > 0)   // Files selected.  Determine if any images...
        {
            INamespaceWalk *pnsw;
            hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC, IID_PPV_ARG(INamespaceWalk, &pnsw));
            if (SUCCEEDED(hr))
            {
                CDataObjectCallback cb(DATAOBJCB_IMAGE | DATAOBJCB_ONLYCHECKEXISTENCE);
                pnsw->Walk(psiItemArray ? pdo : pThis->_punkSite, NSWF_NONE_IMPLIES_ALL | NSWF_DONT_ACCUMULATE_RESULT, 0, &cb);
                if (cb.Found())
                {
                    *puisState = UIS_ENABLED;
                }
                pnsw->Release();
            }
        }
        else
        {
            *puisState = UIS_ENABLED;   // No files selected.  Assume image files exist.
            hr = S_OK;                  // Note we "assume" for the TODO perf reason above.
        }

        ATOMICRELEASE(pdo);
    }

    return hr;
}

HRESULT CFSFolderViewCB::_CanPrintPictures(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    HRESULT hr;

    // TODO:  Use fOkToBeSlow (with a return of E_PENDING) to allow walk to
    // occur on a background task thread (for performance reasons).  However,
    // it doesn't work at present because it's completely specialized for WIA
    // stuff, and it will not be trivial to adapt to the general case.  Thus,
    // we make assumptions as best we can in determining the state for now.

    if (psiItemArray)
    {
        *puisState = UIS_DISABLED;

        IDataObject *pdo;
        hr = psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo));
        if (SUCCEEDED(hr))
        {
            INamespaceWalk *pnsw;
            hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC, IID_PPV_ARG(INamespaceWalk, &pnsw));
            if (SUCCEEDED(hr))
            {
                CDataObjectCallback cb(DATAOBJCB_IMAGE | DATAOBJCB_ONLYCHECKEXISTENCE);
                pnsw->Walk(pdo, NSWF_DONT_ACCUMULATE_RESULT, 0, &cb);
                if (cb.Found())
                {
                    *puisState = UIS_ENABLED;
                }
                pnsw->Release();
            }

            pdo->Release();
        }
    }
    else
    {
        *puisState = UIS_ENABLED;   // No files selected.  Assume image files exist.
        hr = S_OK;                  // Note we "assume" for the TODO perf reason above.
    }

    return hr;
}


HRESULT CFSFolderViewCB::_CanBuyPictures(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    *puisState = UIS_DISABLED;

    // If there is a BuyURL in the desktop.ini, then we'll show the buy pictures task.
    WCHAR szIniPath[MAX_PATH];
    if (pThis->_pfsf->_CheckDefaultIni(NULL, szIniPath) && PathFileExistsAndAttributes(szIniPath, NULL))
    {
        WCHAR szURLArguments[MAX_PATH];
        if (GetPrivateProfileString(L".ShellClassInfo", c_BuySamplePictures.szURLKey, L"", szURLArguments, ARRAYSIZE(szURLArguments), szIniPath))
        {
            // Yes - there's something.
            *puisState = UIS_ENABLED;
        }
    }

    return S_OK;
}


HRESULT CFSFolderViewCB::_CanPlayMusic(IUnknown* pv,IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    return _CanPlay(pv, psiItemArray, fOkToBeSlow, puisState, DATAOBJCB_MUSIC | DATAOBJCB_VIDEO);
}

HRESULT CFSFolderViewCB::_CanPlayVideos(IUnknown* pv,IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    return _CanPlay(pv, psiItemArray, fOkToBeSlow, puisState, DATAOBJCB_VIDEO);
}

HRESULT CFSFolderViewCB::_CanPlay(IUnknown* pv,IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState, int fDATAOBJCB)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    *puisState = UIS_DISABLED;

    // TODO:  Use fOkToBeSlow (with a return of E_PENDING) to allow walk to
    // occur on a background task thread (for performance reasons).  However,
    // it doesn't work at present because it's completely specialized for WIA
    // stuff, and it will not be trivial to adapt to the general case.  Thus,
    // we make assumptions as best we can in determining the state for now.

    IDataObject *pdo = NULL;
    HRESULT hr = psiItemArray ? psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo)) : S_OK;
    if (SUCCEEDED(hr))
    {
        RIPMSG(!psiItemArray || pdo, "CFSFolderViewCB::_CanPlay - BindToHandler returned S_OK but NULL pdo");
        RIPMSG(psiItemArray || pThis->_punkSite, "CFSFolderViewCB::_CanPlay - no _punkSite!");

        if (pThis->_fssci.cFiles > 0)
        {
            if (pThis->_fssci.nItems > 0)   // Files selected.  Determine if any playable...
            {
                INamespaceWalk *pnsw;
                hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC, IID_PPV_ARG(INamespaceWalk, &pnsw));
                if (SUCCEEDED(hr))
                {
                    CDataObjectCallback cb(fDATAOBJCB | DATAOBJCB_ONLYCHECKEXISTENCE);
                    pnsw->Walk(psiItemArray ? pdo : pThis->_punkSite, NSWF_DONT_ACCUMULATE_RESULT, 4, &cb);
                    if (cb.Found())
                    {
                        *puisState = UIS_ENABLED;
                    }
                    pnsw->Release();
                }
            }
            else
                *puisState = UIS_ENABLED;   // No files selected.  Assume playable files exist.
        }                                   // Note we "assume" for the TODO perf reason above.

        ATOMICRELEASE(pdo);
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnPlayMusic(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    return _OnPlay(pv, psiItemArray, pbc, DATAOBJCB_MUSIC | DATAOBJCB_VIDEO);
}

HRESULT CFSFolderViewCB::_OnPlayVideos(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    return _OnPlay(pv, psiItemArray, pbc, DATAOBJCB_VIDEO);
}

HRESULT CFSFolderViewCB::_OnPlay(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc, int fDATAOBJCB)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    HRESULT hr;

    if (psiItemArray)
    {
        IDataObject *pdo;
        hr = psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo));
        if (SUCCEEDED(hr))
        {
            hr = PlayFromUnk(pdo, pThis->_hwndMain, fDATAOBJCB);
            pdo->Release();
        }
    }
    else
    {
        hr = PlayFromUnk(pThis->_punkSite, pThis->_hwndMain, fDATAOBJCB);
    }

    return hr;
}

HRESULT CFSFolderViewCB::_GetShoppingURL(const SHOP_INFO *pShopInfo, LPTSTR pszURL, DWORD cchURL)
{
    HRESULT hr = URLSubstitution(pShopInfo->szURLPrefix, pszURL, cchURL, URLSUB_CLCID);

    if (SUCCEEDED(hr))
    {
        WCHAR szIniPath[MAX_PATH];

        // If we can't just use the fwlink with no arguments, then assume failure.
         hr = pShopInfo->bUseDefault ? S_OK : E_FAIL;

        if (_pfsf->_CheckDefaultIni(NULL, szIniPath) && PathFileExistsAndAttributes(szIniPath, NULL))
        {
            WCHAR szURLArguments[MAX_PATH];
            if (GetPrivateProfileString(L".ShellClassInfo", pShopInfo->szURLKey, L"", szURLArguments, ARRAYSIZE(szURLArguments), szIniPath))
            {
                StrCatBuff(pszURL, L"&", cchURL);
                StrCatBuff(pszURL, szURLArguments, cchURL);

                // Got some arguments - we're definitely ok.
                hr = S_OK;
            }
        }
    }
    return hr;
}

HRESULT CFSFolderViewCB::_GetShoppingBrowsePidl(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc, const SHOP_INFO *pShopInfo, LPITEMIDLIST *ppidl)
{
    WCHAR wszShoppingURL[MAX_URL_STRING];
    HRESULT hr = _GetShoppingURL(pShopInfo, wszShoppingURL, ARRAYSIZE(wszShoppingURL));
    if (SUCCEEDED(hr))
    {
        IShellFolder *psfDesktop;
        hr = SHGetDesktopFolder(&psfDesktop);
        if (SUCCEEDED(hr))
        {
            hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszShoppingURL, NULL, ppidl, NULL);
            psfDesktop->Release();
        }
    }

    return hr;
}



HRESULT CFSFolderViewCB::_OnShopForMusicOnline(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    LPITEMIDLIST pidl;

    // See if there is a sample music BuyURL
    // (do this check first, because the regular music buy URL should always succeed)
    HRESULT hr = pThis->_GetShoppingBrowsePidl(pv, psiItemArray, pbc, &c_BuySampleMusic, &pidl);
    if (SUCCEEDED(hr))
    {
        hr = pThis->_BrowseObject(pidl, SBSP_NEWBROWSER);
        ILFree(pidl);
    }
    else
    {
        // Nope - look for the regular music buy URL
        hr = pThis->_GetShoppingBrowsePidl(pv, psiItemArray, pbc, &c_BuyMusic, &pidl);
        if (SUCCEEDED(hr))
        {
            hr = pThis->_BrowseObject(pidl, SBSP_NEWBROWSER);           
            ILFree(pidl);
        }
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnShopForPicturesOnline(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    LPITEMIDLIST pidl;
    HRESULT hr = pThis->_GetShoppingBrowsePidl(pv, psiItemArray, pbc, &c_BuySamplePictures, &pidl);
    if (SUCCEEDED(hr))
    {
        hr = pThis->_BrowseObject(pidl, SBSP_NEWBROWSER);
        ILFree(pidl);
    }

    return hr;
}


HRESULT CFSFolderViewCB::_DataObjectFromItemsOrFolder(IShellItemArray *psiItemArray, IDataObject **ppdto)
{
    *ppdto = NULL;

    HRESULT hr;
    if (psiItemArray)
    {
        // Something selected -- work with selected items.
        hr = psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, ppdto));
    }
    else
    {
        // Nothing selected -- imply folder selected.
        hr = SHGetUIObjectOf(_pidl, NULL, IID_PPV_ARG(IDataObject, ppdto));
    }
    return hr;
}

HRESULT CFSFolderViewCB::_CanSendToAudioCD(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    *puisState = UIS_DISABLED;

    IDataObject *pdo;
    HRESULT hr = pThis->_DataObjectFromItemsOrFolder(psiItemArray, &pdo);
    if (SUCCEEDED(hr))
    {
        // todo: use fOkToBeSlow to get off the UI thread -- right now it wont work because
        // its specialized just for the WIA stuff and things that have global state
        ICDBurn *pcdb;
        if (SUCCEEDED(CoCreateInstance(CLSID_CDBurn, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(ICDBurn, &pcdb))))
        {
            // media player will get invoked, so we only worry about if the system has a
            // recordable drive at all -- whether the shell burning is enabled or not doesnt matter
            BOOL fHasRecorder;
            if (SUCCEEDED(pcdb->HasRecordableDrive(&fHasRecorder)) && fHasRecorder)
            {
                IUnknown *punk;
                // if this probe works, we can get something thats good to go and itll burn cds.
                if (SUCCEEDED(CDBurn_GetExtensionObject(CDBE_TYPE_MUSIC, pdo, IID_PPV_ARG(IUnknown, &punk))))
                {
                    *puisState = UIS_ENABLED;
                    punk->Release();
                }
            }
            pcdb->Release();
        }

        pdo->Release();
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnSendToAudioCD(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    IDataObject *pdo;
    HRESULT hr = pThis->_DataObjectFromItemsOrFolder(psiItemArray, &pdo);
    if (SUCCEEDED(hr))
    {
        IDropTarget *pdt;
        hr = CDBurn_GetExtensionObject(CDBE_TYPE_MUSIC, pdo, IID_PPV_ARG(IDropTarget, &pdt));
        if (SUCCEEDED(hr))
        {
            hr = SHSimulateDrop(pdt, pdo, 0, NULL, NULL);
            pdt->Release();
        }
        pdo->Release();
    }
    return hr;
}

HRESULT CFSFolderViewCB::_CanSendToCD(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
{
    *puisState = UIS_DISABLED;

    WCHAR szDrive[4];
    if (SUCCEEDED(CDBurn_GetRecorderDriveLetter(szDrive, ARRAYSIZE(szDrive))))
    {
        // if this succeeds, shell cd burning is enabled.
        *puisState = UIS_ENABLED;
    }

    return S_OK;
}

HRESULT CFSFolderViewCB::_OnSendToCD(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    IDataObject *pdo;
    HRESULT hr = pThis->_DataObjectFromItemsOrFolder(psiItemArray, &pdo);
    if (SUCCEEDED(hr))
    {
        WCHAR szDrive[4];
        hr = CDBurn_GetRecorderDriveLetter(szDrive, ARRAYSIZE(szDrive));
        if (SUCCEEDED(hr))
        {
            LPITEMIDLIST pidl;
            hr = SHILCreateFromPath(szDrive, &pidl, NULL);
            if (SUCCEEDED(hr))
            {
                IDropTarget *pdt;
                hr = SHGetUIObjectOf(pidl, NULL, IID_PPV_ARG(IDropTarget, &pdt));
                if (SUCCEEDED(hr))
                {
                    hr = SHSimulateDropWithSite(pdt, pdo, 0, NULL, NULL, pThis->_punkSite);
                    pdt->Release();
                }
                ILFree(pidl);
            }
        }
        pdo->Release();
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnGetFromCamera(IUnknown* pv,IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    SHELLEXECUTEINFO sei = {0};
    sei.cbSize = sizeof(sei);
    sei.lpFile = TEXT("wiaacmgr.exe");
    sei.lpParameters = TEXT("/SelectDevice");
    sei.nShow = SW_SHOWNORMAL;

    return ShellExecuteEx(&sei) ? S_OK : E_FAIL;
}

HRESULT CFSFolderViewCB::_GetPreview3(IPreview3** ppPreview3)
{
    HRESULT hr = E_FAIL;
    *ppPreview3 = NULL;

    if (!_pPreview)
    {
        hr = CoCreateInstance(CLSID_Preview, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IPreview3, &_pPreview));
        if (SUCCEEDED(hr))
        {
            IUnknown_SetSite(_pPreview, _punkSite);
        }
    }

    if (_pPreview)
    {
        *ppPreview3 = _pPreview;
        _pPreview->AddRef();
        hr = S_OK;
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnSlideShow(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    IPreview3* pPreview3;
    HRESULT hr = pThis->_GetPreview3(&pPreview3);
    if (SUCCEEDED(hr))
    {
        hr = pPreview3->SlideShow();
        pPreview3->Release();
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnWallpaper(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;

    HRESULT hr = E_FAIL;
    IDataObject *pdo;

    if (psiItemArray && SUCCEEDED(psiItemArray->BindToHandler(NULL, BHID_DataObject, IID_PPV_ARG(IDataObject, &pdo))))
    {
        IPreview3* pPreview3;
        if (SUCCEEDED(pThis->_GetPreview3(&pPreview3)))
        {
            TCHAR szPath[MAX_PATH];
            if (SUCCEEDED(PathFromDataObject(pdo, szPath, ARRAYSIZE(szPath))))
            {
                hr = pPreview3->SetWallpaper(szPath);
            }
            pPreview3->Release();
        }

        pdo->Release();
    }

    return hr;
}

HRESULT CFSFolderViewCB::_OnOrderPrints(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    IDataObject *pdo;
    HRESULT hr = pThis->_DataObjectFromItemsOrFolder(psiItemArray, &pdo);
    if (SUCCEEDED(hr))
    {
        hr = SHSimulateDropOnClsid(CLSID_InternetPrintOrdering, pThis->_punkSite, pdo);
        pdo->Release();
    }   

    return hr;
}

HRESULT CFSFolderViewCB::_OnPrintPictures(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFSFolderViewCB* pThis = (CFSFolderViewCB*)(void*)pv;
    IDataObject *pdo;
    HRESULT hr = pThis->_DataObjectFromItemsOrFolder(psiItemArray, &pdo);
    if (SUCCEEDED(hr))
    {
        hr = SHSimulateDropOnClsid(CLSID_PrintPhotosDropTarget, pThis->_punkSite, pdo);
        pdo->Release();
    }

    return hr;
}

const WVTASKITEM c_CommonDocumentsSpecialTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_COMMONDOCUMENTS, IDS_HEADER_COMMONDOCUMENTS_TT);
const WVTASKITEM c_CommonDocumentsSpecialTaskList[] =
{
    WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_COMMONDOCUMENTSHELP, IDS_TASK_COMMONDOCUMENTSHELP_TT, IDI_TASK_HELP, NULL, CFSFolderViewCB::_OnCommonDocumentsHelp),
};
const LPCTSTR c_DocumentsOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_PERSONAL), MAKEINTRESOURCE(CSIDL_COMMON_DOCUMENTS), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };

const WVTASKITEM c_MusicSpecialTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_MUSIC, IDS_HEADER_MUSIC_TT);
const WVTASKITEM c_MusicSpecialTaskList[] =
{
    WVTI_ENTRY_ALL_TITLE(UICID_PlayMusic,    L"shell32.dll", IDS_TASK_PLAYALL,          IDS_TASK_PLAYALL,       IDS_TASK_PLAY,          IDS_TASK_PLAY,          IDS_TASK_PLAY_TT,               IDI_TASK_PLAY_MUSIC,    CFSFolderViewCB::_CanPlayMusic,     CFSFolderViewCB::_OnPlayMusic),
    WVTI_ENTRY_ALL(UICID_ShopForMusicOnline, L"shell32.dll", IDS_TASK_SHOPFORMUSICONLINE,                                                                       IDS_TASK_SHOPFORMUSICONLINE_TT, IDI_TASK_BUY_MUSIC,     NULL,                               CFSFolderViewCB::_OnShopForMusicOnline),
    WVTI_ENTRY_ALL_TITLE(GUID_NULL,          L"shell32.dll", IDS_TASK_COPYTOAUDIOCDALL, IDS_TASK_COPYTOAUDIOCD, IDS_TASK_COPYTOAUDIOCD, IDS_TASK_COPYTOAUDIOCD, IDS_TASK_COPYTOAUDIOCD_TT,      IDI_TASK_SENDTOAUDIOCD, CFSFolderViewCB::_CanSendToAudioCD, CFSFolderViewCB::_OnSendToAudioCD),
};
const LPCTSTR c_MusicOtherPlaces[]   = { MAKEINTRESOURCE(CSIDL_MYMUSIC), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };
const LPCTSTR c_MyMusicOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_COMMON_MUSIC), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };

const WVTASKITEM c_PicturesSpecialTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_PICTURES, IDS_HEADER_PICTURES_TT);
const WVTASKITEM c_PicturesSpecialTaskList[] =
{
    WVTI_ENTRY_ALL(UICID_GetFromCamera, L"shell32.dll", IDS_TASK_GETFROMCAMERA,                                                                                             IDS_TASK_GETFROMCAMERA_TT,  IDI_TASK_GETFROMCAMERA, CFSFolderViewCB::_HasWiaDevices,    CFSFolderViewCB::_OnGetFromCamera),
    WVTI_ENTRY_ALL(UICID_SlideShow,     L"shell32.dll", IDS_TASK_SLIDESHOW,                                                                                                 IDS_TASK_SLIDESHOW_TT,      IDI_TASK_SLIDESHOW,     CFSFolderViewCB::_HasItems,         CFSFolderViewCB::_OnSlideShow),
    WVTI_ENTRY_ALL(CLSID_NULL,          L"shell32.dll", IDS_TASK_ORDERPRINTS,                                                                                               IDS_TASK_ORDERPRINTS_TT,    IDI_TASK_ORDERPRINTS,   CFSFolderViewCB::_CanOrderPrints,   CFSFolderViewCB::_OnOrderPrints),
    WVTI_ENTRY_ALL_TITLE(CLSID_NULL,    L"shell32.dll", IDS_TASK_PRINT_PICTURE_FOLDER,  IDS_TASK_PRINT_PICTURE, IDS_TASK_PRINT_PICTURE_FOLDER,  IDS_TASK_PRINT_PICTURES,    IDS_TASK_PRINT_PICTURES_TT, IDI_TASK_PRINTPICTURES, CFSFolderViewCB::_CanPrintPictures, CFSFolderViewCB::_OnPrintPictures),
    WVTI_ENTRY_FILE(UICID_SetAsWallpaper,L"shell32.dll",IDS_TASK_SETASWALLPAPER,                                                                                            IDS_TASK_SETASWALLPAPER_TT, IDI_TASK_SETASWALLPAPER,CFSFolderViewCB::_CanWallpaper,     CFSFolderViewCB::_OnWallpaper),
    WVTI_ENTRY_ALL_TITLE(CLSID_NULL,    L"shell32.dll", IDS_TASK_COPYTOCDALL,           IDS_TASK_COPYTOCD,      IDS_TASK_COPYTOCD,              IDS_TASK_COPYTOCD,          IDS_TASK_COPYTOCD_TT,       IDI_TASK_SENDTOCD,      CFSFolderViewCB::_CanSendToCD,      CFSFolderViewCB::_OnSendToCD),
    // Note: temporarily using IDI_ORDERPRINTS for the following task:
    WVTI_ENTRY_ALL(UICID_ShopForPicturesOnline, L"shell32.dll", IDS_TASK_SHOPFORPICTURESONLINE,                                                                             IDS_TASK_SHOPFORPICTURESONLINE_TT, IDI_TASK_ORDERPRINTS, CFSFolderViewCB::_CanBuyPictures, CFSFolderViewCB::_OnShopForPicturesOnline),
};
const LPCTSTR c_PicturesOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_MYPICTURES), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };
const LPCTSTR c_MyPicturesOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_COMMON_PICTURES), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };

const WVTASKITEM c_VideosSpecialTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_VIDEOS, IDS_HEADER_VIDEOS_TT);
const WVTASKITEM c_VideosSpecialTaskList[] =
{
    WVTI_ENTRY_ALL_TITLE(CLSID_NULL,    L"shell32.dll", IDS_TASK_PLAYALL,               IDS_TASK_PLAYALL,       IDS_TASK_PLAY,                  IDS_TASK_PLAY,              IDS_TASK_PLAY_VIDEOS_TT,    IDI_TASK_PLAY_MUSIC,    CFSFolderViewCB::_CanPlayVideos,    CFSFolderViewCB::_OnPlayVideos),
    WVTI_ENTRY_ALL(UICID_GetFromCamera, L"shell32.dll", IDS_TASK_GETFROMCAMERA,                                                                                             IDS_TASK_GETFROMCAMERA_TT,  IDI_TASK_GETFROMCAMERA, CFSFolderViewCB::_HasWiaDevices,    CFSFolderViewCB::_OnGetFromCamera),
    WVTI_ENTRY_ALL_TITLE(CLSID_NULL,    L"shell32.dll", IDS_TASK_COPYTOCDALL,           IDS_TASK_COPYTOCD,      IDS_TASK_COPYTOCD,              IDS_TASK_COPYTOCD,          IDS_TASK_COPYTOCD_TT,       IDI_TASK_SENDTOCD,      CFSFolderViewCB::_CanSendToCD,      CFSFolderViewCB::_OnSendToCD)
};
const LPCTSTR c_VideosOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_MYVIDEO), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };
const LPCTSTR c_MyVideosOtherPlaces[] = { MAKEINTRESOURCE(CSIDL_COMMON_VIDEO), MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_NETWORK) };

typedef struct {
    const WVTASKITEM *pwvIntroText;
    const WVTASKITEM *pwvSpecialHeader;
    const WVTASKITEM *pwvSpecialTaskList;
    UINT              cSpecialTaskList;
    const WVTASKITEM *pwvFolderHeader;
    const WVTASKITEM *pwvFolderTaskList;
    UINT              cFolderTaskList;
    const LPCTSTR    *pdwOtherPlacesList;
    UINT              cOtherPlacesList;
    LPCWSTR           pszThemeInfo;
} WVCONTENT_DATA;

#define WVCONTENT_DEFVIEWDEFAULT(op) { NULL, NULL, NULL, 0, NULL, NULL, 0, (op), ARRAYSIZE(op), NULL }
#define WVCONTENT_FOLDER(fh, ft, op) { NULL, NULL, NULL, 0, &(fh), (ft), ARRAYSIZE(ft), (op), ARRAYSIZE(op), NULL }
#define WVCONTENT_SPECIAL(sh, st, op, th) { NULL, &(sh), (st), ARRAYSIZE(st), NULL, NULL, 0, (op), ARRAYSIZE(op), (th) }

const WVCONTENT_DATA c_wvContent[] =
{
    WVCONTENT_DEFVIEWDEFAULT(c_DocumentsOtherPlaces),                                                                                   // FVCBFT_DOCUMENTS
    WVCONTENT_DEFVIEWDEFAULT(c_DocumentsOtherPlaces),                                                                                   // FVCBFT_MYDOCUMENTS
    WVCONTENT_SPECIAL(c_PicturesSpecialTaskHeader,          c_PicturesSpecialTaskList,          c_PicturesOtherPlaces,      L"picture"),// FVCBFT_PICTURES
    WVCONTENT_SPECIAL(c_PicturesSpecialTaskHeader,          c_PicturesSpecialTaskList,          c_MyPicturesOtherPlaces,    L"picture"),// FVCBFT_MYPICTURES
    WVCONTENT_SPECIAL(c_PicturesSpecialTaskHeader,          c_PicturesSpecialTaskList,          c_PicturesOtherPlaces,      L"picture"),// FVCBFT_PHOTOALBUM
    WVCONTENT_SPECIAL(c_MusicSpecialTaskHeader,             c_MusicSpecialTaskList,             c_MusicOtherPlaces,         L"music"),  // FVCBFT_MUSIC
    WVCONTENT_SPECIAL(c_MusicSpecialTaskHeader,             c_MusicSpecialTaskList,             c_MyMusicOtherPlaces,       L"music"),  // FVCBFT_MYMUSIC
    WVCONTENT_SPECIAL(c_MusicSpecialTaskHeader,             c_MusicSpecialTaskList,             c_MusicOtherPlaces,         L"music"),  // FVCBFT_MUSICARTIST
    WVCONTENT_SPECIAL(c_MusicSpecialTaskHeader,             c_MusicSpecialTaskList,             c_MusicOtherPlaces,         L"music"),  // FVCBFT_MUSICALBUM
    WVCONTENT_SPECIAL(c_VideosSpecialTaskHeader,            c_VideosSpecialTaskList,            c_VideosOtherPlaces,        L"video"),  // FVCBFT_VIDEOS
    WVCONTENT_SPECIAL(c_VideosSpecialTaskHeader,            c_VideosSpecialTaskList,            c_MyVideosOtherPlaces,      L"video"),  // FVCBFT_MYVIDEOS
    WVCONTENT_SPECIAL(c_VideosSpecialTaskHeader,            c_VideosSpecialTaskList,            c_VideosOtherPlaces,        L"video"),  // FVCBFT_VIDEOALBUM
    WVCONTENT_DEFVIEWDEFAULT(c_DocumentsOtherPlaces),// stub, it should not be used as legacy htts wont have DUI view.                  // FVCBFT_USELEGACYHTT
    WVCONTENT_SPECIAL(c_CommonDocumentsSpecialTaskHeader,   c_CommonDocumentsSpecialTaskList,   c_DocumentsOtherPlaces,     NULL),      // FVCBFT_COMMONDOCUMENTS
};

// This structure describes what a Folder Type can control:
//
typedef struct {
    BOOL              fIncludeThumbstrip;
    FOLDERVIEWMODE    fvmFew;
    FOLDERVIEWMODE    fvmMid;
    FOLDERVIEWMODE    fvmMany;
    const SHCOLUMNID* pscidSort;
    int               iSortDirection;
} FVCBFOLDERTYPEDATA;

// Here are all the Folder Types we know about:
const FVCBFOLDERTYPEDATA c_rgFolderType[] =
{  // flmstrip  // <25         // 25..49      //50...        //sort by           //sort dir
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_ICON,      &SCID_NAME,         1},    // FVCBFT_DOCUMENTS
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_ICON,      &SCID_NAME,         1},    // FVCBFT_MYDOCUMENTS
    { TRUE,     FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_PICTURES
    { TRUE,     FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_MYPICTURES
    { TRUE,     FVM_THUMBSTRIP,FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_PHOTOALBUM
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_DETAILS,   &SCID_NAME,         1},    // FVCBFT_MUSIC
    { FALSE,    FVM_THUMBNAIL, FVM_TILE,      FVM_LIST,      &SCID_NAME,         1},    // FVCBFT_MYMUSIC
    { FALSE,    FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,        -1},    // FVCBFT_MUSICARTIST
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_DETAILS,   &SCID_NAME,         1},    // FVCBFT_MUSICALBUM, SCID_MUSIC_Track is the same as SCID_NAME
    { FALSE,    FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_VIDEOS
    { FALSE,    FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_MYVIDEOS
    { FALSE,    FVM_THUMBNAIL, FVM_THUMBNAIL, FVM_THUMBNAIL, &SCID_NAME,         1},    // FVCBFT_VIDEOALBUM
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_ICON,      &SCID_NAME,         1},    // FVCBFT_USELEGACYHTT, only for listview state to look like FVCBFT_DOCUMENTS
    { FALSE,    FVM_TILE,      FVM_TILE,      FVM_ICON,      &SCID_NAME,         1},    // FVCBFT_COMMONDOCUMENTS
};

// This is used to sniff the Folder Type based on folder location:
typedef struct {
    UINT           csidl;
    FVCBFOLDERTYPE ft;
    DWORD          dwFlags;
} FVCBDATA;

#define FVCBDF_SUBFOLDERS_ONLY    1
#define FVCBDF_THISFOLDER_ONLY    2

const FVCBDATA c_rgFolderState[] =
{
    {CSIDL_COMMON_PICTURES, FVCBFT_PHOTOALBUM,      FVCBDF_SUBFOLDERS_ONLY},
    {CSIDL_MYPICTURES,      FVCBFT_PHOTOALBUM,      FVCBDF_SUBFOLDERS_ONLY},
    {CSIDL_COMMON_PICTURES, FVCBFT_PICTURES,        FVCBDF_THISFOLDER_ONLY},
    {CSIDL_MYPICTURES,      FVCBFT_MYPICTURES,      FVCBDF_THISFOLDER_ONLY},
    {CSIDL_COMMON_MUSIC,    FVCBFT_MUSIC,           FVCBDF_THISFOLDER_ONLY},
    {CSIDL_MYMUSIC,         FVCBFT_MYMUSIC,         FVCBDF_THISFOLDER_ONLY},
    {CSIDL_MYMUSIC,         FVCBFT_MUSICARTIST,     FVCBDF_SUBFOLDERS_ONLY},
    {CSIDL_COMMON_VIDEO,    FVCBFT_VIDEOS,          0},
    {CSIDL_MYVIDEO,         FVCBFT_MYVIDEOS,        0},
    {CSIDL_COMMON_DOCUMENTS,FVCBFT_COMMONDOCUMENTS, FVCBDF_THISFOLDER_ONLY},
    {CSIDL_PERSONAL,        FVCBFT_MYDOCUMENTS,     FVCBDF_THISFOLDER_ONLY},
};

// these are special folders that used to be web view folders.  we override the "support legacy" for this list:
const UINT c_rgFolderStateNoLegacy[] =
{
    CSIDL_WINDOWS,
    CSIDL_SYSTEM,
    CSIDL_PROGRAM_FILES,
};

// This is used to map desktop.ini's folder type into our Folder Type
const struct {
    LPCWSTR pszType;
    FVCBFOLDERTYPE ft;
} c_rgPropBagFolderType[] =
{
    {STR_TYPE_DOCUMENTS,        FVCBFT_DOCUMENTS},
    {STR_TYPE_MYDOCUMENTS,      FVCBFT_MYDOCUMENTS},
    {STR_TYPE_PICTURES,         FVCBFT_PICTURES},
    {STR_TYPE_MYPICTURES,       FVCBFT_MYPICTURES},
    {STR_TYPE_PHOTOALBUM,       FVCBFT_PHOTOALBUM},
    {STR_TYPE_MUSIC,            FVCBFT_MUSIC},
    {STR_TYPE_MYMUSIC,          FVCBFT_MYMUSIC},
    {STR_TYPE_MUSICARTIST,      FVCBFT_MUSICARTIST},
    {STR_TYPE_MUSICALBUM,       FVCBFT_MUSICALBUM},
    {STR_TYPE_VIDEOS,           FVCBFT_VIDEOS},
    {STR_TYPE_MYVIDEOS,         FVCBFT_MYVIDEOS},
    {STR_TYPE_VIDEOALBUM,       FVCBFT_VIDEOALBUM},
    {STR_TYPE_USELEGACYHTT,     FVCBFT_USELEGACYHTT},
    {STR_TYPE_COMMONDOCUMENTS,  FVCBFT_COMMONDOCUMENTS},
};

const struct 
{
    PERCEIVED gen;
    FVCBFOLDERTYPE ft;
} 
c_rgSniffType[] =
{
    {GEN_AUDIO,    FVCBFT_MUSIC},
    {GEN_IMAGE,    FVCBFT_PHOTOALBUM},
    {GEN_VIDEO,    FVCBFT_VIDEOS},
};

HRESULT _GetFolderTypeForString(LPCWSTR pszFolderType, FVCBFOLDERTYPE *piType)
{
    HRESULT hr = E_FAIL;
    for (int i = 0; i < ARRAYSIZE(c_rgPropBagFolderType); i++)
    {
        if (!StrCmpI(c_rgPropBagFolderType[i].pszType, pszFolderType))
        {
            *piType = c_rgPropBagFolderType[i].ft;
            hr = S_OK;
            break;
        }
    }
    return hr;
}

HRESULT CFSFolderViewCB::_GetStringForFolderType(int iType, LPWSTR pszFolderType, UINT cchBuf)
{
    HRESULT hr = E_FAIL;
    for (int i = 0; i < ARRAYSIZE(c_rgPropBagFolderType); i++)
    {
        if (c_rgPropBagFolderType[i].ft == iType)
        {
            StrCpyN(pszFolderType, c_rgPropBagFolderType[i].pszType, cchBuf);
            hr = S_OK;
            break;
        }
    }
    return hr;
}

extern HRESULT GetTemplateInfoFromHandle(HANDLE h, UCHAR * pKey, DWORD *pdwSize);

FVCBFOLDERTYPE _GetFolderType(LPCWSTR pszPath, LPCITEMIDLIST pidl, BOOL fIsSystemFolder)
{
    // Assume we don't find a match
    FVCBFOLDERTYPE nFolderType = FVCBFT_NOTSPECIFIED;
    WCHAR szFolderType[MAX_PATH];
    szFolderType[0] = 0;

    // peruser is first
    if (FVCBFT_NOTSPECIFIED == nFolderType)
    {
        IPropertyBag *ppb;
        if (SUCCEEDED(SHGetViewStatePropertyBag(pidl, VS_BAGSTR_EXPLORER, SHGVSPB_PERUSER | SHGVSPB_PERFOLDER, IID_PPV_ARG(IPropertyBag, &ppb))))
        {
            SHPropertyBag_ReadStr(ppb, L"FolderType", szFolderType, ARRAYSIZE(szFolderType));
            if (szFolderType[0])
                _GetFolderTypeForString(szFolderType, &nFolderType);

            ppb->Release();
        }
    }
    
    // next, alluser
    if ((FVCBFT_NOTSPECIFIED == nFolderType) && fIsSystemFolder)
    {
        GetFolderString(pszPath, NULL, szFolderType, ARRAYSIZE(szFolderType), TEXT("FolderType"));
        if (szFolderType[0])
        {
            _GetFolderTypeForString(szFolderType, &nFolderType);
        }
    }

    // Check the location of this folder is next
    //
    if (FVCBFT_NOTSPECIFIED == nFolderType)
    {
        for (int i = 0; i < ARRAYSIZE(c_rgFolderState); i++)
        {
            if (FVCBDF_THISFOLDER_ONLY & c_rgFolderState[i].dwFlags)
            {
                if (PathIsOneOf(pszPath, &(c_rgFolderState[i].csidl), 1))
                {
                    nFolderType = c_rgFolderState[i].ft;
                    break;
                }
            }
            else if (FVCBDF_SUBFOLDERS_ONLY & c_rgFolderState[i].dwFlags)
            {
                if (PathIsDirectChildOf(MAKEINTRESOURCE(c_rgFolderState[i].csidl), pszPath))
                {
                    nFolderType = c_rgFolderState[i].ft;
                    break;
                }
            }
            else if (PathIsEqualOrSubFolder(MAKEINTRESOURCE(c_rgFolderState[i].csidl), pszPath))
            {
                nFolderType = c_rgFolderState[i].ft;
                break;
            }
        }
    }

    // Upgrade old webviews to their DUI equivalents, if we can
    if (FVCBFT_NOTSPECIFIED == nFolderType && fIsSystemFolder  && SHRestricted(REST_ALLOWLEGACYWEBVIEW))
    {
        // Don't check for legacy webview on our special folders
        if (!PathIsOneOf(pszPath, c_rgFolderStateNoLegacy, ARRAYSIZE(c_rgFolderStateNoLegacy)))
        {        
            SFVM_WEBVIEW_TEMPLATE_DATA wvData;
            if (SUCCEEDED(DefaultGetWebViewTemplateFromPath(pszPath, &wvData)))
            {
                if (StrStrI(wvData.szWebView, L"ImgView.htt"))
                {
                    nFolderType = FVCBFT_PHOTOALBUM;
                }
                else if (StrStrI(wvData.szWebView, L"classic.htt")  ||
                         StrStrI(wvData.szWebView, L"default.htt")  ||
                         StrStrI(wvData.szWebView, L"standard.htt"))
                {
                    // map all of these to "documents", since DUI should take care
                    // of what the old templates did automatically
                    nFolderType = FVCBFT_DOCUMENTS;
                }
                else if (StrStrI(wvData.szWebView, L"folder.htt"))
                {
                    LPTSTR pszFilePrefix = StrStrI(wvData.szWebView, L"file://");
                    HANDLE hfile = CreateFileWrapW(
                        pszFilePrefix && (&pszFilePrefix[6] < &wvData.szWebView[MAX_PATH - 1]) ? &pszFilePrefix[7] : wvData.szWebView,
                        GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
                    if (INVALID_HANDLE_VALUE != hfile)
                    {
                        DWORD dwSize;
                        UCHAR pKey[MD5DIGESTLEN];
                        if (SUCCEEDED(GetTemplateInfoFromHandle(hfile, pKey, &dwSize)))
                        {
                            static const struct {
                                UCHAR pKey[MD5DIGESTLEN];
                                FVCBFOLDERTYPE nFolderType;
                            } c_paLegacyKeyMap[] = {
                                { { 0xf6, 0xad, 0x42, 0xbd, 0xfa, 0x92, 0xb6, 0x61, 0x08, 0x13, 0xd3, 0x71, 0x32, 0x18, 0x85, 0xc7 }, FVCBFT_DOCUMENTS },  // Win98 Gold Program Files
                                { { 0x80, 0xea, 0xcb, 0xc7, 0x85, 0x1e, 0xbb, 0x99, 0x12, 0x7b, 0x9d, 0xc7, 0x80, 0xa6, 0x55, 0x2f }, FVCBFT_DOCUMENTS },  // Win98 Gold System
                              //{ { 0x80, 0xea, 0xcb, 0xc7, 0x85, 0x1e, 0xbb, 0x99, 0x12, 0x7b, 0x9d, 0xc7, 0x80, 0xa6, 0x55, 0x2f }, FVCBFT_DOCUMENTS },  // Win98 Gold Windows
                                { { 0x13, 0x0b, 0xe7, 0xaa, 0x42, 0x6f, 0x9c, 0x2e, 0xab, 0x6b, 0x90, 0x77, 0xce, 0x2d, 0xd1, 0x04 }, FVCBFT_DOCUMENTS },  // Win98 Gold - folder.htt
                              //{ { 0xf6, 0xad, 0x42, 0xbd, 0xfa, 0x92, 0xb6, 0x61, 0x08, 0x13, 0xd3, 0x71, 0x32, 0x18, 0x85, 0xc7 }, FVCBFT_DOCUMENTS },  // Win98 SE Program Files
                                { { 0xc4, 0xab, 0x8f, 0x60, 0xf8, 0xfc, 0x5d, 0x07, 0x9e, 0x16, 0xd8, 0xea, 0x12, 0x2c, 0xad, 0x5c }, FVCBFT_DOCUMENTS },  // Win98 SE System
                              //{ { 0xc4, 0xab, 0x8f, 0x60, 0xf8, 0xfc, 0x5d, 0x07, 0x9e, 0x16, 0xd8, 0xea, 0x12, 0x2c, 0xad, 0x5c }, FVCBFT_DOCUMENTS },  // Win98 SE Windows
                              //{ { 0x13, 0x0b, 0xe7, 0xaa, 0x42, 0x6f, 0x9c, 0x2e, 0xab, 0x6b, 0x90, 0x77, 0xce, 0x2d, 0xd1, 0x04 }, FVCBFT_DOCUMENTS },  // Win98 SE - folder.htt
                                { { 0xef, 0xd0, 0x3e, 0x9e, 0xd8, 0x5e, 0xf3, 0xc5, 0x7e, 0x40, 0xbd, 0x8e, 0x52, 0xbc, 0x9c, 0x67 }, FVCBFT_DOCUMENTS },  // WinME Program Files
                                { { 0x49, 0xdb, 0x25, 0x79, 0x7a, 0x5c, 0xb2, 0x8a, 0xe2, 0x57, 0x59, 0xde, 0x2b, 0xd2, 0xa6, 0x70 }, FVCBFT_DOCUMENTS },  // WinME System
                              //{ { 0x49, 0xdb, 0x25, 0x79, 0x7a, 0x5c, 0xb2, 0x8a, 0xe2, 0x57, 0x59, 0xde, 0x2b, 0xd2, 0xa6, 0x70 }, FVCBFT_DOCUMENTS },  // WinME Windows
                                { { 0x2b, 0xcd, 0xc3, 0x11, 0x72, 0x28, 0x34, 0x46, 0xfa, 0x88, 0x31, 0x34, 0xfc, 0xee, 0x7a, 0x3b }, FVCBFT_DOCUMENTS },  // WinME - classic.htt
                                { { 0x68, 0x20, 0xa0, 0xa1, 0x6c, 0xba, 0xbf, 0x67, 0x80, 0xfe, 0x1e, 0x70, 0xdf, 0xcb, 0xd6, 0x34 }, FVCBFT_DOCUMENTS },  // WinME - folder.htt
                                { { 0x5e, 0x18, 0xaf, 0x48, 0xb1, 0x9f, 0xb8, 0x12, 0x58, 0x64, 0x4a, 0xa2, 0xf5, 0x12, 0x0f, 0x01 }, FVCBFT_PHOTOALBUM }, // WinME - imgview.htt
                                { { 0x33, 0x94, 0x21, 0x3b, 0x17, 0x31, 0x2b, 0xeb, 0xac, 0x93, 0x84, 0x13, 0xb8, 0x1f, 0x95, 0x24 }, FVCBFT_DOCUMENTS },  // WinME - standard.htt
                                { { 0x47, 0x03, 0x19, 0xf8, 0x0c, 0x20, 0xc4, 0x4f, 0x10, 0xfd, 0x63, 0xf1, 0x2d, 0x2d, 0x0a, 0xcb }, FVCBFT_DOCUMENTS },  // WinME - starter.htt
                                { { 0x60, 0x7d, 0xea, 0xa5, 0xaf, 0x5e, 0xbb, 0x9b, 0x10, 0x18, 0xf9, 0x59, 0x9e, 0x43, 0x89, 0x62 }, FVCBFT_DOCUMENTS },  // Win2k Program Files
                                { { 0x1c, 0xa6, 0x22, 0xd4, 0x4a, 0x31, 0x57, 0x93, 0xa7, 0x26, 0x68, 0x3c, 0x87, 0x95, 0x8c, 0xce }, FVCBFT_DOCUMENTS },  // Win2k System32
                              //{ { 0x1c, 0xa6, 0x22, 0xd4, 0x4a, 0x31, 0x57, 0x93, 0xa7, 0x26, 0x68, 0x3c, 0x87, 0x95, 0x8c, 0xce }, FVCBFT_DOCUMENTS },  // Win2k Windows (WinNT)
                                { { 0x03, 0x43, 0x48, 0xed, 0xe4, 0x9f, 0xd6, 0xc0, 0x58, 0xf7, 0x72, 0x3f, 0x1b, 0xd0, 0xa7, 0x10 }, FVCBFT_DOCUMENTS },  // Win2k - classic.htt
                                { { 0xa8, 0x84, 0xf9, 0x37, 0x84, 0x10, 0xde, 0x7c, 0x0b, 0x34, 0x90, 0x37, 0x23, 0x9e, 0x54, 0x35 }, FVCBFT_DOCUMENTS },  // Win2k - folder.htt
                                { { 0x75, 0x1f, 0xcf, 0xca, 0xdd, 0xc7, 0x1d, 0xc7, 0xe1, 0xaf, 0x0c, 0x3e, 0x1e, 0xae, 0x18, 0x51 }, FVCBFT_PHOTOALBUM }, // Win2k - imgview.htt
                                { { 0xcc, 0x3f, 0x15, 0xce, 0x4b, 0xfa, 0x36, 0xdf, 0x9b, 0xd8, 0x24, 0x82, 0x3a, 0x9c, 0x0b, 0xa7 }, FVCBFT_DOCUMENTS },  // Win2k - standard.htt
                                { { 0x6c, 0xd1, 0xbf, 0xcf, 0xf9, 0x24, 0x24, 0x24, 0x22, 0xfa, 0x1a, 0x8d, 0xd2, 0x1a, 0x41, 0x73 }, FVCBFT_DOCUMENTS },  // Win2k - starter.htt
                            };
                            static const size_t c_nLegacyKeys = ARRAYSIZE(c_paLegacyKeyMap);

                            for (size_t i = 0; i < c_nLegacyKeys; i++)
                            {
                                if (0 == memcmp(pKey, c_paLegacyKeyMap[i].pKey, sizeof(UCHAR) * MD5DIGESTLEN))
                                {
                                    // It's a known legacy folder.htt.
                                    nFolderType = c_paLegacyKeyMap[i].nFolderType;
                                    break;
                                }
                            }
                        }

                        CloseHandle(hfile);
                    }

                    // If we can't say it's a known legacy folder.htt...
                    if (FVCBFT_NOTSPECIFIED == nFolderType)
                    {
                        // ...don't map it to a DUI folder type (preserve customizations).
                        nFolderType = FVCBFT_USELEGACYHTT;
                    }
                }
                else
                {
                    nFolderType = FVCBFT_USELEGACYHTT;
                }
            }
        }
    }

    return nFolderType;
}

BOOL CFSFolderViewCB::_IsBarricadedFolder()
{
    BOOL bResult = FALSE;
    TCHAR szPath[MAX_PATH];

    if (SUCCEEDED(_pfsf->_GetPath(szPath)))
    {
        const UINT uiFolders[] = {CSIDL_PROGRAM_FILES, CSIDL_WINDOWS, CSIDL_SYSTEM};
        if (PathIsOneOf(szPath, uiFolders, ARRAYSIZE(uiFolders)))
            bResult = TRUE;
        else
        {
            TCHAR szSystemDrive[4];
            ExpandEnvironmentStrings(TEXT("%SystemDrive%\\"), szSystemDrive, ARRAYSIZE(szSystemDrive));
            if (!lstrcmpi(szPath, szSystemDrive))
                bResult = TRUE;
        }
    }

    return bResult;
}

static const struct { FVCBFOLDERTYPE type; PCWSTR pszClass; PERCEIVED gen;} c_rgDirectoryClasses[] = 
{
    {FVCBFT_PICTURES,    L"Directory.Image",    GEN_IMAGE},
    {FVCBFT_MYPICTURES,  L"Directory.Image",    GEN_IMAGE},
    {FVCBFT_PHOTOALBUM,  L"Directory.Image",    GEN_IMAGE},
    {FVCBFT_MUSIC,       L"Directory.Audio",    GEN_AUDIO},
    {FVCBFT_MYMUSIC,     L"Directory.Audio",    GEN_AUDIO},
    {FVCBFT_MUSICARTIST, L"Directory.Audio",    GEN_AUDIO},
    {FVCBFT_MUSICALBUM,  L"Directory.Audio",    GEN_AUDIO},
    {FVCBFT_VIDEOS,      L"Directory.Video",    GEN_VIDEO},
    {FVCBFT_MYVIDEOS,    L"Directory.Video",    GEN_VIDEO},
    {FVCBFT_VIDEOALBUM,  L"Directory.Video",    GEN_VIDEO},
};

LPCWSTR _GetDirectoryClass(LPCWSTR pszPath, LPCITEMIDLIST pidl, BOOL fIsSystemFolder)
{
    FVCBFOLDERTYPE type = _GetFolderType(pszPath, pidl, fIsSystemFolder);
    if (type != FVCBFT_NOTSPECIFIED)
    {
        for (int i = 0; i < ARRAYSIZE(c_rgDirectoryClasses); i++)
        {
            if (c_rgDirectoryClasses[i].type == type)
                return c_rgDirectoryClasses[i].pszClass;
        }
    }
    return NULL;
}

PERCEIVED CFSFolderViewCB::_GetFolderPerceivedType(LPCIDFOLDER pidf)
{
    PERCEIVED gen = GEN_FOLDER;
    WCHAR szPath[MAX_PATH];
    if (SUCCEEDED(_pfsf->_GetPathForItem(pidf, szPath)))
    {
        LPITEMIDLIST pidl = ILCombine(_pfsf->_GetIDList(), (LPCITEMIDLIST)pidf);
        if (pidl)
        {
            FVCBFOLDERTYPE type = _GetFolderType(szPath, pidl, CFSFolder::_IsSystemFolder(pidf));
            if (type != -1)
            {
                for (int i = 0; i < ARRAYSIZE(c_rgDirectoryClasses); i++)
                {
                    if (c_rgDirectoryClasses[i].type == type)
                    {
                        gen = c_rgDirectoryClasses[i].gen;
                        break;
                    }
                }
            }
            ILFree(pidl);
        }
    }
    return gen;
}


HRESULT CFSFolderViewCB::OnEnumeratedItems(DWORD pv, UINT celt, LPCITEMIDLIST* rgpidl)
{
    // Remember the count of items
    _cItems = celt;

    FVCBFOLDERTYPE nFolderType = FVCBFT_NOTSPECIFIED;
    WCHAR szHere[MAX_PATH];
    if (SUCCEEDED(_pfsf->_GetPath(szHere)))
    {
        nFolderType = _GetFolderType(szHere, _pfsf->_GetIDList(), _pfsf->_CheckDefaultIni(NULL, NULL));
    }

    if (FVCBFT_NOTSPECIFIED == nFolderType)
    {
        if (_IsBarricadedFolder())
        {
            nFolderType = FVCBFT_DOCUMENTS;
        }
    }

    // Our location didn't do the trick, so look at the enumerated contents
    if (FVCBFT_NOTSPECIFIED == nFolderType && celt > 0)
    {
        DWORD dwExtCount[ARRAYSIZE(c_rgSniffType)] = {0};

        // look at each pidl -> what type is it
        //
        // But don't look at too many pidls or we really slow down folder
        // creation time.  If we can't figure it out in the first 100, give up.
        //
        DWORD dwTotalCount = 0;
        for (UINT n = 0; n < celt && dwTotalCount < 100; n++)
        {
            LPCIDFOLDER pidf = CFSFolder_IsValidID(rgpidl[n]);
            ASSERT(pidf);
            CFileSysItemString fsi(pidf);
            PERCEIVED gen = fsi.PerceivedType();

            if (gen == GEN_FOLDER)
            {
                gen = _GetFolderPerceivedType(pidf);
            }
                
            for (int i = 0; i < ARRAYSIZE(c_rgSniffType); i++)
            {
                if (c_rgSniffType[i].gen == gen)
                {
                    dwExtCount[i]++;
                    break;
                }
            }

            if (gen != GEN_FOLDER)
                dwTotalCount++;
        }

        // if we found files we determine the overall folder type
        if (dwTotalCount > 0)
        {
            DWORD dwSixtyPercent = MulDiv(dwTotalCount, 3, 5);
            for (int i = 0; i < ARRAYSIZE(c_rgSniffType); i++)
            {
                if (dwExtCount[i] >= dwSixtyPercent)
                {
                    nFolderType = c_rgSniffType[i].ft;
                    break;
                }
            }
        }
    }

    // if at this point we've already decided on a folder type, then it either came from sniffing
    // or the folder location and we can safely persist that out.
    // if celt != 0 then we've sniffed it and we dont want to sniff again, so persist that out.
    // otherwise we're in a random folder with 0 elements and we'll sniff it next time.
    BOOL fCommit = (FVCBFT_NOTSPECIFIED != nFolderType) || (celt != 0);

    // Last resort, assume we're a document folder:
    if (FVCBFT_NOTSPECIFIED == nFolderType)
    {
        nFolderType = FVCBFT_DOCUMENTS;
    }

    // store what we found out back into the bag.
    IPropertyBag *ppb;
    if (fCommit && SUCCEEDED(SHGetViewStatePropertyBag(_pfsf->_GetIDList(), VS_BAGSTR_EXPLORER, SHGVSPB_PERUSER | SHGVSPB_PERFOLDER, IID_PPV_ARG(IPropertyBag, &ppb))))
    {
        WCHAR szFolderType[MAX_PATH];
        if (SUCCEEDED(_GetStringForFolderType(nFolderType, szFolderType, ARRAYSIZE(szFolderType))))
        {
            SHPropertyBag_WriteStr(ppb, PROPSTR_FOLDERTYPE, szFolderType);
        }
        ppb->Release();
    }

    _pfsf->_nFolderType = nFolderType;

    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetViewData(DWORD pv, UINT uViewMode, SFVM_VIEW_DATA* pvi)
{
    // Normally whatever defview wants is good for us
    pvi->dwOptions = SFVMQVI_NORMAL;

    // If our sniff type likes THUMBSTRIP, then override defview
    //
    if (FVM_THUMBSTRIP == uViewMode)
    {
        if (c_rgFolderType[_pfsf->_nFolderType].fIncludeThumbstrip)
        {
            pvi->dwOptions = SFVMQVI_INCLUDE;
        }
    }

    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetWebViewTemplate(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_TEMPLATE_DATA* pvit)
{
    HRESULT hr = E_FAIL;

    if (FVCBFT_USELEGACYHTT == _pfsf->_nFolderType)
    {
        TCHAR szHere[MAX_PATH];
        if (SUCCEEDED(_pfsf->_GetPath(szHere)) && _pfsf->_CheckDefaultIni(NULL, NULL))
        {
            hr = DefaultGetWebViewTemplateFromPath(szHere, pvit);
        }
    }
    return hr;
}

// Note: defview provides this implementation, this is only for testing
// so the WIA guys can override defview's behavior (and as a way for us
// to force DUI in the presence of HTML content)
//
HRESULT CFSFolderViewCB::OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData)
{
    HRESULT hr = E_FAIL;

    if (FVCBFT_USELEGACYHTT != _pfsf->_nFolderType)
    {
        ZeroMemory(pData, sizeof(*pData));

        pData->dwLayout = SFVMWVL_NORMAL | SFVMWVL_FILES;

        if (FVM_THUMBSTRIP == uViewMode)
        {        
            pData->dwLayout = SFVMWVL_PREVIEW | SFVMWVL_FILES;
            // duiview will do a release on this pointer when the control is destroyed
            _GetPreview3((IPreview3 **)&pData->punkPreview);
        }

        // RAID 242382
        //  If we have an image folder, we want to unconditionally hide DefView's
        //  default "Print this file" folder task since we will supply a context
        //  appropriate "Print pictures" special task.
        //
        // RAID 359567
        //  If we have a music folder, we want to unconditionally hide DefView's
        //  default "Publish this file" folder task.  Not sure the rationale
        //  behind this, but perhaps they don't want us to be seen as a Napster.
        //
        // Note:
        //  This is a HACK added for Whistler, which should be removed in Blackcomb.
        //
        switch (_pfsf->_nFolderType)
        {
        case FVCBFT_PICTURES:
        case FVCBFT_MYPICTURES:
        case FVCBFT_PHOTOALBUM:
        case FVCBFT_VIDEOS:
        case FVCBFT_MYVIDEOS:
        case FVCBFT_VIDEOALBUM:
            pData->dwLayout |= SFVMWVL_NOPRINT;
            break;

        case FVCBFT_MUSIC:
        case FVCBFT_MYMUSIC:
        case FVCBFT_MUSICARTIST:
        case FVCBFT_MUSICALBUM:
            pData->dwLayout |= SFVMWVL_NOPUBLISH;
            break;
        }

        hr = S_OK;
    }

    return hr;
}


HRESULT CFSFolderViewCB::OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData)
{
    ZeroMemory(pData, sizeof(*pData));

    // Check if the folder we are currently over is one of the blockaded folders.
    if (_IsBarricadedFolder())
    {
        pData->dwFlags = SFVMWVF_BARRICADE;
    }

    if (c_wvContent[_pfsf->_nFolderType].pwvIntroText)
        Create_IUIElement(c_wvContent[_pfsf->_nFolderType].pwvIntroText, &(pData->pIntroText));

    if (c_wvContent[_pfsf->_nFolderType].pwvSpecialHeader && c_wvContent[_pfsf->_nFolderType].pwvSpecialTaskList)
        Create_IUIElement(c_wvContent[_pfsf->_nFolderType].pwvSpecialHeader, &(pData->pSpecialTaskHeader));

    if (c_wvContent[_pfsf->_nFolderType].pwvFolderHeader && c_wvContent[_pfsf->_nFolderType].pwvFolderTaskList)
        Create_IUIElement(c_wvContent[_pfsf->_nFolderType].pwvFolderHeader, &(pData->pFolderTaskHeader));

    if (c_wvContent[_pfsf->_nFolderType].pdwOtherPlacesList)
        CreateIEnumIDListOnCSIDLs(_pfsf->_pidl, (LPCTSTR *)c_wvContent[_pfsf->_nFolderType].pdwOtherPlacesList, c_wvContent[_pfsf->_nFolderType].cOtherPlacesList, &(pData->penumOtherPlaces));

    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks)
{
    ZeroMemory(pTasks, sizeof(*pTasks));

    if (c_wvContent[_pfsf->_nFolderType].pwvSpecialHeader && c_wvContent[_pfsf->_nFolderType].pwvSpecialTaskList)
    {
        Create_IEnumUICommand((IUnknown*)(void*)this, c_wvContent[_pfsf->_nFolderType].pwvSpecialTaskList, c_wvContent[_pfsf->_nFolderType].cSpecialTaskList, &pTasks->penumSpecialTasks);
    }

    if (c_wvContent[_pfsf->_nFolderType].pwvFolderHeader && c_wvContent[_pfsf->_nFolderType].pwvFolderTaskList)
    {
        Create_IEnumUICommand((IUnknown*)(void*)this, c_wvContent[_pfsf->_nFolderType].pwvFolderTaskList, c_wvContent[_pfsf->_nFolderType].cFolderTaskList, &pTasks->penumFolderTasks);
    }

    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetWebViewTheme(DWORD pv, SFVM_WEBVIEW_THEME_DATA* pTheme)
{
    ZeroMemory(pTheme, sizeof(*pTheme));

    pTheme->pszThemeID = c_wvContent[_pfsf->_nFolderType].pszThemeInfo;
    
    return S_OK;
}

HRESULT CFSFolderViewCB::OnDefViewMode(DWORD pv, FOLDERVIEWMODE* pfvm)
{
    HRESULT hr = E_FAIL;

    IPropertyBag* pPB;
    if (SUCCEEDED(SHGetViewStatePropertyBag(_pfsf->_GetIDList(), VS_BAGSTR_EXPLORER, SHGVSPB_FOLDER, IID_PPV_ARG(IPropertyBag, &pPB))))
    {
        SHELLVIEWID vidDefault;
        if (SUCCEEDED(SHPropertyBag_ReadGUID(pPB, L"ExtShellFolderViews\\Default", &vidDefault)))
        {
            hr = ViewModeFromSVID(&vidDefault, pfvm);
        }
        pPB->Release();
    }

    if (FAILED(hr))
    {
        if (_cItems < DEFVIEW_FVM_FEW_CUTOFF)
            *pfvm = c_rgFolderType[_pfsf->_nFolderType].fvmFew;
        else if (_cItems < DEFVIEW_FVM_MANY_CUTOFF)
            *pfvm = c_rgFolderType[_pfsf->_nFolderType].fvmMid;
        else
            *pfvm = c_rgFolderType[_pfsf->_nFolderType].fvmMany;
        hr = S_OK;
    }

    return hr;
}

HRESULT CFSFolderViewCB::OnGetDeferredViewSettings(DWORD pv, SFVM_DEFERRED_VIEW_SETTINGS* pSettings)
{
    HRESULT hr = OnDefViewMode(pv, &pSettings->fvm);
    if (SUCCEEDED(hr))
    {
        pSettings->fGroupView     = (_cItems >= 100) && !IsEqualSCID(SCID_NAME, *c_rgFolderType[_pfsf->_nFolderType].pscidSort);
        pSettings->iSortDirection = c_rgFolderType[_pfsf->_nFolderType].iSortDirection;

        if (pSettings->fvm == FVM_THUMBNAIL || pSettings->fvm == FVM_THUMBSTRIP || pSettings->fvm == FVM_TILE)
            pSettings->fFlags = FWF_AUTOARRANGE;

        if (FAILED(_pfsf->_MapSCIDToColumn(c_rgFolderType[_pfsf->_nFolderType].pscidSort, &pSettings->uSortCol)))
            pSettings->uSortCol = 0;
    }

    return hr;
}


HRESULT CFSFolderViewCB::OnGetCustomViewInfo(DWORD pv, SFVM_CUSTOMVIEWINFO_DATA* pData)
{
    HRESULT hr = E_FAIL;

    TCHAR szIniFile[MAX_PATH];
    if (_pfsf->_CheckDefaultIni(NULL, szIniFile))
    {
        if (PathFileExistsAndAttributes(szIniFile, NULL))
        {
            // Read the custom colors
            //
            const LPCTSTR c_szCustomColors[CRID_COLORCOUNT] =
            {
                TEXT("IconArea_TextBackground"),
                TEXT("IconArea_Text")
            };
            for (int i = 0; i < CRID_COLORCOUNT; i++)
                pData->crCustomColors[i] = GetPrivateProfileInt(TEXT("{BE098140-A513-11D0-A3A4-00C04FD706EC}"),
                                               c_szCustomColors[i], CLR_MYINVALID, szIniFile);

            // Read the background image
            TCHAR szTemp[MAX_PATH];
            GetPrivateProfileString(TEXT("{BE098140-A513-11D0-A3A4-00C04FD706EC}"),  // VID_FolderState
                TEXT("IconArea_Image"), TEXT(""), szTemp, ARRAYSIZE(szTemp), szIniFile);
            if (szTemp[0])
            {
                SHExpandEnvironmentStrings(szTemp, pData->szIconAreaImage, ARRAYSIZE(pData->szIconAreaImage));   // Expand the env vars if any

                TCHAR szHere[MAX_PATH];
                if (SUCCEEDED(_pfsf->_GetPath(szHere)))
                {
                    PathCombine(pData->szIconAreaImage, szHere, pData->szIconAreaImage);
                }
            }

            // Success if we have any real data
            hr = (*(pData->szIconAreaImage) ||
                  pData->crCustomColors[0]!=CLR_MYINVALID ||
                  pData->crCustomColors[1]!=CLR_MYINVALID)
                 ? S_OK : E_FAIL;
        }
    }

    return hr;
}


const CLSID *c_rgFilePages[] = {
    &CLSID_FileTypes,
    &CLSID_OfflineFilesOptions
};

// add optional pages to Explore/Options.

HRESULT SFVCB_OnAddPropertyPages(DWORD pv, SFVM_PROPPAGE_DATA *ppagedata)
{
    for (int i = 0; i < ARRAYSIZE(c_rgFilePages); i++)
    {
        IShellPropSheetExt * pspse;

        HRESULT hr = SHCoCreateInstance(NULL, c_rgFilePages[i], NULL, IID_PPV_ARG(IShellPropSheetExt, &pspse));
        if (SUCCEEDED(hr))
        {
            pspse->AddPages(ppagedata->pfn, ppagedata->lParam);
            pspse->Release();
        }
    }

    return S_OK;
}

HRESULT CFSFolderViewCB::OnGetNotify(DWORD pv, LPITEMIDLIST*wP, LONG*lP) 
{
    if (IsExplorerModeBrowser(_punkSite))
        _lEvents |= SHCNE_FREESPACE; // need free space info here too

    return E_FAIL;  // return failure to let base guy do the rest
}

STDMETHODIMP CFSFolderViewCB::RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    HANDLE_MSG(0, SFVM_GETCCHMAX, OnGetCCHMax);
    HANDLE_MSG(0, SFVM_WINDOWCREATED, OnWindowCreated);
    HANDLE_MSG(1 , SFVM_INSERTITEM, OnInsertDeleteItem);
    HANDLE_MSG(-1, SFVM_DELETEITEM, OnInsertDeleteItem);
    HANDLE_MSG(0, SFVM_SELCHANGE, OnSelChange);
    HANDLE_MSG(0, SFVM_UPDATESTATUSBAR, OnUpdateStatusBar);
    HANDLE_MSG(0, SFVM_REFRESH, OnRefresh);
    HANDLE_MSG(0, SFVM_SELECTALL, OnSelectAll);
    HANDLE_MSG(0, SFVM_GETWORKINGDIR, OnGetWorkingDir);
    HANDLE_MSG(0, SFVM_ENUMERATEDITEMS, OnEnumeratedItems);
    HANDLE_MSG(0, SFVM_GETVIEWDATA, OnGetViewData);
    HANDLE_MSG(0, SFVM_GETWEBVIEW_TEMPLATE, OnGetWebViewTemplate);
    HANDLE_MSG(0, SFVM_GETWEBVIEWLAYOUT, OnGetWebViewLayout);
    HANDLE_MSG(0, SFVM_GETWEBVIEWCONTENT, OnGetWebViewContent);
    HANDLE_MSG(0, SFVM_GETWEBVIEWTASKS, OnGetWebViewTasks);
    HANDLE_MSG(0, SFVM_GETWEBVIEWTHEME, OnGetWebViewTheme);
    HANDLE_MSG(0, SFVM_DEFVIEWMODE, OnDefViewMode);
    HANDLE_MSG(0, SFVM_GETCUSTOMVIEWINFO, OnGetCustomViewInfo);
    HANDLE_MSG(0, SFVM_ADDPROPERTYPAGES, SFVCB_OnAddPropertyPages);
    HANDLE_MSG(0, SFVM_SIZE, OnSize);
    HANDLE_MSG(0, SFVM_GETPANE, OnGetPane);
    HANDLE_MSG(0, SFVM_GETNOTIFY, OnGetNotify);
    HANDLE_MSG(0, SFVM_GETDEFERREDVIEWSETTINGS, OnGetDeferredViewSettings);

    default:
        return E_FAIL;
    }

    return S_OK;
}


STDAPI CFSFolderCallback_Create(CFSFolder *pfsf, IShellFolderViewCB **ppsfvcb)
{
    *ppsfvcb = new CFSFolderViewCB(pfsf);
    return *ppsfvcb ? S_OK : E_OUTOFMEMORY;
}