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

#include "shellprv.h"
#pragma  hdrstop

#include <hwtab.h>
#include "fstreex.h"
#include "views.h"
#include "drives.h"
#include "propsht.h"
#include "infotip.h"
#include "datautil.h"
#include "netview.h"
#include "bitbuck.h"
#include "drawpie.h"
#include "shitemid.h"
#include "devguid.h"
#include "ids.h"
#include "idldrop.h"
#include "util.h"
#include "shcombox.h"
#include "hwcmmn.h"
#include "prop.h"

#include "mtpt.h"
#include "ftascstr.h"   // for CFTAssocStore
#include "ascstr.h"     // for IAssocInfo class
#include "apdlg.h"
#include "cdburn.h"

#define REL_KEY_DEFRAG TEXT("MyComputer\\defragpath")
#define REL_KEY_BACKUP TEXT("MyComputer\\backuppath")

///////////////////////////////////////////////////////////////////////////////
// Begin: Old C fct required externally
///////////////////////////////////////////////////////////////////////////////
STDAPI_(int) RealDriveTypeFlags(int iDrive, BOOL fOKToHitNet)
{
    int iType = DRIVE_NO_ROOT_DIR;
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive, TRUE, fOKToHitNet);

    if (pMtPt)
    {
        WCHAR szDrive[4];

        iType = GetDriveType(PathBuildRoot(szDrive, iDrive));
        iType |= pMtPt->GetDriveFlags();
        iType |= pMtPt->GetVolumeFlags();
        pMtPt->Release();
    }

    return iType;    
}

STDAPI_(int) RealDriveType(int iDrive, BOOL fOKToHitNet)
{
    WCHAR szDrive[4];

    return GetDriveType(PathBuildRoot(szDrive, iDrive)) & DRIVE_TYPE;    
}

STDAPI_(int) DriveType(int iDrive)
{
    return RealDriveType(iDrive, TRUE);
}

STDAPI_(DWORD) PathGetClusterSize(LPCTSTR pszPath)
{
    static TCHAR s_szRoot[MAX_PATH] = {'\0'};
    static int   s_nszRootLen = 0;
    static DWORD s_dwSize = 0;

    DWORD dwSize = 0;

    // Do we have a cache hit?  No need to hit the net if we can avoid it...
    if (s_nszRootLen)
    {
        ENTERCRITICAL;
        if (wcsncmp(pszPath, s_szRoot, s_nszRootLen) == 0)
        {
            dwSize = s_dwSize;
        }
        LEAVECRITICAL;
    }

    if (0 == dwSize)
    {
        TCHAR szRoot[MAX_PATH];

        lstrcpy(szRoot, pszPath);
        PathStripToRoot(szRoot);

        if (PathIsUNC(szRoot))
        {
            DWORD dwSecPerClus, dwBytesPerSec, dwClusters, dwTemp;

            PathAddBackslash(szRoot);

            if (GetDiskFreeSpace(szRoot, &dwSecPerClus, &dwBytesPerSec, &dwTemp, &dwClusters))
            {
                dwSize = dwSecPerClus * dwBytesPerSec;
            }
        }
        else
        {
            CMountPoint* pMtPt = CMountPoint::GetMountPoint(pszPath);

            if (pMtPt)
            {
                dwSize = pMtPt->GetClusterSize();
                pMtPt->Release();
            }
        }

        // Sometimes on Millennium, we get 0 as the cluster size.
        // Reason unknown.  Sanitize the value so we don't go insane.
        if (dwSize == 0)
            dwSize = 512;

        // Remember this for later - chances are we'll be queried for the same drive again
        ENTERCRITICAL;
        StrCpyN(s_szRoot, szRoot, ARRAYSIZE(s_szRoot));
        s_nszRootLen = lstrlen(s_szRoot);
        s_dwSize = dwSize;
        LEAVECRITICAL;
    }

    return dwSize;
}

STDAPI_(UINT) GetMountedVolumeIcon(LPCTSTR pszMountPoint, LPTSTR pszModule, DWORD cchModule)
{
    UINT iIcon = II_FOLDER;

    // zero-init string
    if (pszModule)
        *pszModule = 0;

    CMountPoint* pMtPt = CMountPoint::GetMountPoint(pszMountPoint);
    if (pMtPt)
    {
        iIcon = pMtPt->GetIcon(pszModule, cchModule);
        pMtPt->Release();
    }
    return iIcon;
}


STDAPI_(BOOL) IsDisconnectedNetDrive(int iDrive)
{
    BOOL fDisc = 0;
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive);

    if (pMtPt)
    {
        fDisc = pMtPt->IsDisconnectedNetDrive();
        pMtPt->Release();
    }
    return fDisc;
}

STDAPI_(BOOL) IsUnavailableNetDrive(int iDrive)
{
    BOOL fUnAvail = 0;
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive);

    if (pMtPt)
    {
        fUnAvail = pMtPt->IsUnavailableNetDrive();
        pMtPt->Release();
    }

    return fUnAvail;

}

STDMETHODIMP SetDriveLabel(HWND hwnd, IUnknown* punkEnableModless, int iDrive, LPCTSTR pszDriveLabel)
{
    HRESULT hr = E_FAIL;
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive);

    if (pMtPt)
    {
        hr = pMtPt->SetDriveLabel(hwnd, pszDriveLabel);
        pMtPt->Release();
    }

    return hr;
}

STDMETHODIMP GetDriveComment(int iDrive, LPTSTR pszComment, int cchComment)
{
    HRESULT hr = E_FAIL;
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive);

    if (pMtPt)
    {
        hr = pMtPt->GetComment(pszComment, cchComment);
        pMtPt->Release();
    }

    return hr;
}

///////////////////////////////////////////////////////////////////////////////
// End:   Old C fct required externally
///////////////////////////////////////////////////////////////////////////////

//
// fDoIt -- TRUE, if we make connections; FALSE, if just querying.
//
BOOL _MakeConnection(IDataObject *pDataObj, BOOL fDoIt)
{
    STGMEDIUM medium;
    FORMATETC fmte = {g_cfNetResource, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    BOOL fAnyConnectable = FALSE;

    if (SUCCEEDED(pDataObj->GetData(&fmte, &medium)))
    {
        LPNETRESOURCE pnr = (LPNETRESOURCE)LocalAlloc(LPTR, 1024);
        if (pnr)
        {
            UINT iItem, cItems = SHGetNetResource(medium.hGlobal, (UINT)-1, NULL, 0);
            for (iItem = 0; iItem < cItems; iItem++)
            {
                if (SHGetNetResource(medium.hGlobal, iItem, pnr, 1024) &&
                    pnr->dwUsage & RESOURCEUSAGE_CONNECTABLE &&
                    !(pnr->dwType & RESOURCETYPE_PRINT))
                {
                    fAnyConnectable = TRUE;
                    if (fDoIt)
                    {
                        SHNetConnectionDialog(NULL, pnr->lpRemoteName, pnr->dwType);
                        SHChangeNotifyHandleEvents();
                    }
                    else
                    {
                        break;  // We are just querying.
                    }
                }
            }
            LocalFree(pnr);
        }
        ReleaseStgMedium(&medium);
    }

    return fAnyConnectable;
}

//
// the entry of "make connection thread"
//
DWORD WINAPI MakeConnectionThreadProc(void *pv)
{
    IDataObject *pdtobj;
    if (SUCCEEDED(CoGetInterfaceAndReleaseStream((IStream *)pv, IID_PPV_ARG(IDataObject, &pdtobj))))
    {
        _MakeConnection(pdtobj, TRUE);
        pdtobj->Release();
    }

    return 0;
}

STDAPI CDrivesDropTarget_Create(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt);

class CDrivesDropTarget : public CIDLDropTarget
{
friend HRESULT CDrivesDropTarget_Create(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt);
public:
    CDrivesDropTarget(HWND hwnd) : CIDLDropTarget(hwnd) { };
    // IDropTarget methods overwirte
    STDMETHODIMP DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
    STDMETHODIMP Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
};


STDAPI CDrivesDropTarget_Create(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt)
{
    *ppdropt = NULL;

    HRESULT hr;
    CDrivesDropTarget *pCIDLDT = new CDrivesDropTarget(hwnd);
    if (pCIDLDT)
    {
        hr = pCIDLDT->_Init(pidl);
        if (SUCCEEDED(hr))
            pCIDLDT->QueryInterface(IID_PPV_ARG(IDropTarget, ppdropt));
        pCIDLDT->Release();
    }
    else
        hr = E_OUTOFMEMORY;
    return hr;
}

//
// puts DROPEFFECT_LINK in *pdwEffect, only if the data object
// contains one or more net resource.
//
STDMETHODIMP CDrivesDropTarget::DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    // Call the base class first.
    CIDLDropTarget::DragEnter(pDataObj, grfKeyState, pt, pdwEffect);

    *pdwEffect &= _MakeConnection(pDataObj, FALSE) ? DROPEFFECT_LINK : DROPEFFECT_NONE;

    m_dwEffectLastReturned = *pdwEffect;

    return S_OK;     // Notes: we should NOT return hr as it.
}

//
// creates a connection to a dropped net resource object.
//
STDMETHODIMP CDrivesDropTarget::Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
    HRESULT hr;

    if (m_dwData & DTID_NETRES)
    {
        *pdwEffect = DROPEFFECT_LINK;

        hr = CIDLDropTarget::DragDropMenu(DROPEFFECT_LINK, pDataObj,
            pt, pdwEffect, NULL, NULL, POPUP_DRIVES_NONDEFAULTDD, grfKeyState);

        if (hr == S_FALSE)
        {
            // we create another thread to avoid blocking the source thread.
            IStream *pstm;
            if (S_OK == CoMarshalInterThreadInterfaceInStream(IID_IDataObject, pDataObj, &pstm))
            {
                if (SHCreateThread(MakeConnectionThreadProc, pstm, CTF_COINIT, NULL))
                {
                    hr = S_OK;
                }
                else
                {
                    pstm->Release();
                    hr = E_OUTOFMEMORY;
                }
            }
        }
    }
    else
    {
        //
        // Because QueryGetData() failed, we don't call CIDLDropTarget_
        // DragDropMenu(). Therefore, we must call this explicitly.
        //
        DAD_DragLeave();
        hr = E_FAIL;
    }

    CIDLDropTarget::DragLeave();

    return hr;
}

STDAPI_(DWORD) DrivesPropertiesThreadProc(void *pv)
{
    PROPSTUFF *pps = (PROPSTUFF *)pv;
    STGMEDIUM medium;
    ULONG_PTR dwCookie = 0;
    BOOL bDidActivate = FALSE;
    
    //
    // This __try/__finally block is to ensure that the activation context gets
    // removed, even if there's an assertion elsewhere in this code.  A missing
    // DeactivateActCtx will lead to a very strange-looking assertion in one of
    // the RtlpDeactivateActCtx-variant functions from the caller.  Old code
    // was missing the deactivate in all circumstances.
    //
    // (jonwis) 1/2/2001
    //
    __try
    {
        bDidActivate = ActivateActCtx(NULL, &dwCookie);
   
        LPIDA pida = DataObj_GetHIDA(pps->pdtobj, &medium);

        BOOL bMountedDriveInfo = FALSE;

        // Were we able to get data for a HIDA?
        if (!pida)
        {
            // No, pida is first choice, but if not present check for mounteddrive info
            FORMATETC fmte;

            fmte.cfFormat = g_cfMountedVolume;
            fmte.ptd = NULL;
            fmte.dwAspect = DVASPECT_CONTENT;
            fmte.lindex = -1;
            fmte.tymed = TYMED_HGLOBAL;

            // Is data available for the MountedVolume format?
            if (SUCCEEDED(pps->pdtobj->GetData(&fmte, &medium)))
                // Yes
                bMountedDriveInfo = TRUE;
        }

        // Do we have data for a HIDA or a mountedvolume?
        if (pida || bMountedDriveInfo)
        {
            // Yes
            TCHAR szCaption[MAX_PATH];
            LPTSTR pszCaption = NULL;

            if (pida)
            {
                pszCaption = SHGetCaption(medium.hGlobal);
            }
            else
            {
                TCHAR szMountPoint[MAX_PATH];
                TCHAR szVolumeGUID[MAX_PATH];

                DragQueryFile((HDROP)medium.hGlobal, 0, szMountPoint, ARRAYSIZE(szMountPoint));
            
                GetVolumeNameForVolumeMountPoint(szMountPoint, szVolumeGUID, ARRAYSIZE(szVolumeGUID));
                szCaption[0] = 0;
                GetVolumeInformation(szVolumeGUID, szCaption, ARRAYSIZE(szCaption), NULL, NULL, NULL, NULL, 0);

                if (!(*szCaption))
                    LoadString(HINST_THISDLL, IDS_UNLABELEDVOLUME, szCaption, ARRAYSIZE(szCaption));        

                PathRemoveBackslash(szMountPoint);

                // Fix 330388
                // If the szMountPoint is not a valid local path, do not
                // display it in the properties dialog title:
                if (-1 != PathGetDriveNumber(szMountPoint))
                {
                    int nCaptionLength = lstrlen(szCaption) ;
                    wnsprintf(szCaption + nCaptionLength, ARRAYSIZE(szCaption) - nCaptionLength, TEXT(" (%s)"), szMountPoint);
                }
                pszCaption = szCaption;
            }

            //  NOTE - if we pass the name of the drive then we can get a lot more keys...
            HKEY rgk[MAX_ASSOC_KEYS];
            DWORD ck = CDrives_GetKeys(NULL, rgk, ARRAYSIZE(rgk));

            SHOpenPropSheet(pszCaption, rgk, ck,
                            &CLSID_ShellDrvDefExt, pps->pdtobj, NULL, pps->pStartPage);

            SHRegCloseKeys(rgk, ck);

            if (pida && pszCaption)
                SHFree(pszCaption);

            if (pida)
                HIDA_ReleaseStgMedium(pida, &medium);
            else
                ReleaseStgMedium(&medium);

        }
        else
        {
            TraceMsg(DM_TRACE, "no HIDA in data obj nor Mounted drive info");
        }
    }
    __finally
    {
        if ( bDidActivate )
        {
            DeactivateActCtx( 0, dwCookie );
        }
    }

    return 0;
}

//
// To be called back from within CDefFolderMenu
//
STDAPI CDrives_DFMCallBack(IShellFolder *psf, HWND hwnd,
                           IDataObject *pdtobj, UINT uMsg, 
                           WPARAM wParam, LPARAM lParam)
{
    HRESULT hr = S_OK;

    switch (uMsg)
    {
    case DFM_MERGECONTEXTMENU:
        if (pdtobj)
        {
            FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

            // Check if only file system objects are selected.
            if (pdtobj->QueryGetData(&fmte) == S_OK)
            {
                #define pqcm ((LPQCMINFO)lParam)

                STGMEDIUM medium;
                // Yes, only file system objects are selected.
                LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
                if (pida)
                {
                    LPIDDRIVE pidd = (LPIDDRIVE)IDA_GetIDListPtr(pida, 0);

                    if (pidd)
                    {
                        int iDrive = DRIVEID(pidd->cName);
                        UINT idCmdBase = pqcm->idCmdFirst;   // store it away

                        BOOL fIsEjectable = FALSE;

                        CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_DRIVES_ITEM, 0, pqcm);

                        CMountPoint* pmtpt = CMountPoint::GetMountPoint(DRIVEID(pidd->cName));

                        if (pmtpt)
                        {
                            if (!pmtpt->IsRemote() ||
                                SHRestricted( REST_NONETCONNECTDISCONNECT ))
                            {
                                DeleteMenu(pqcm->hmenu, idCmdBase + FSIDM_DISCONNECT, MF_BYCOMMAND);
                            }

                            if ((pida->cidl != 1) ||
                                (!pmtpt->IsFormattable()))
                            {
                                // Don't even try to format more than one disk
                                // Or a net drive, or a CD-ROM, or a RAM drive ...
                                // Note we are going to show the Format command on the
                                // boot drive, Windows drive, System drive, compressed
                                // drives, etc.  An appropriate error should be shown
                                // after the user chooses this command
                                DeleteMenu(pqcm->hmenu, idCmdBase + FSIDM_FORMAT, MF_BYCOMMAND);
                            }

                            if (pmtpt->IsEjectable())
                                fIsEjectable = TRUE;

                            pmtpt->Release();
                        }

                        if ((pida->cidl != 1) || (iDrive < 0) || !fIsEjectable)
                            DeleteMenu(pqcm->hmenu, idCmdBase + FSIDM_EJECT, MF_BYCOMMAND);

                    }

                    HIDA_ReleaseStgMedium(pida, &medium);    
                }

                #undef pqcm
            }
        }
        // Note that we always return S_OK from this function so that
        // default processing of menu items will occur
        ASSERT(hr == S_OK);
        break;

    case DFM_GETHELPTEXT:
        LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));;
        break;

    case DFM_GETHELPTEXTW:
        LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));;
        break;

    case DFM_MAPCOMMANDNAME:
        if (lstrcmpi((LPCTSTR)lParam, TEXT("eject")) == 0)
            *(int *)wParam = FSIDM_EJECT;
        else if (lstrcmpi((LPCTSTR)lParam, TEXT("format")) == 0)
            *(int *)wParam = FSIDM_FORMAT;
        else
            hr = E_FAIL;  // command not found
        break;

    case DFM_INVOKECOMMAND:
        switch (wParam)
        {
        case DFM_CMD_PROPERTIES:
            // lParam contains the page name to open
            hr = SHLaunchPropSheet(DrivesPropertiesThreadProc, pdtobj, (LPCTSTR)lParam, NULL, NULL);
            break;

        case FSIDM_EJECT:
        case FSIDM_FORMAT:
        {
            STGMEDIUM medium;

            LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);

            ASSERT(HIDA_GetCount(medium.hGlobal) == 1);

            LPIDDRIVE pidd = (LPIDDRIVE)IDA_GetIDListPtr(pida, 0);
            if (pidd)
            {
                UINT iDrive = DRIVEID(pidd->cName);

                ASSERT((int)iDrive >= 0);

                switch (wParam)
                {
                case FSIDM_FORMAT:
                    SHFormatDriveAsync(hwnd, iDrive, SHFMT_ID_DEFAULT, 0);
                    break;

                case FSIDM_EJECT:
                    {
                        CDBurn_OnEject(hwnd, iDrive);
                        CMountPoint* pMtPt = CMountPoint::GetMountPoint(iDrive);
                        if (pMtPt)
                        {
                            pMtPt->Eject(hwnd);
                            pMtPt->Release();
                        }
                        break;
                    }
                }
            }

            HIDA_ReleaseStgMedium(pida, &medium);
            break;
        }

        case FSIDM_DISCONNECT:

            if (pdtobj)
            {
                STGMEDIUM medium;
                LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
                if (pida)
                {
                    DISCDLGSTRUCT discd = {
                        sizeof(discd),          // cbStructure
                        hwnd,                   // hwndOwner
                        NULL,                   // lpLocalName
                        NULL,                   // lpRemoteName
                        DISC_UPDATE_PROFILE     // dwFlags
                    };
                    for (UINT iidl = 0; iidl < pida->cidl; iidl++)
                    {
                        LPIDDRIVE pidd = (LPIDDRIVE)IDA_GetIDListPtr(pida, iidl);

                        CMountPoint* pmtpt = CMountPoint::GetMountPoint(DRIVEID(pidd->cName));

                        if (pmtpt)
                        {
                            if (pmtpt->IsRemote())
                            {
                                TCHAR szPath[4], szDrive[4];
                                BOOL fUnavailable = pmtpt->IsUnavailableNetDrive();

                                SHAnsiToTChar(pidd->cName, szPath,  ARRAYSIZE(szPath));
                                SHAnsiToTChar(pidd->cName, szDrive, ARRAYSIZE(szDrive));
                                szDrive[2] = 0; // remove slash
                                discd.lpLocalName = szDrive;

                                if (SHWNetDisconnectDialog1(&discd) == WN_SUCCESS)
                                {
                                    // If it is a unavailable drive we get no
                                    // file system notification and as such
                                    // the drive will not disappear, so lets
                                    // set up to do it ourself...
                                    if (fUnavailable)
                                    {
                                        CMountPoint::NotifyUnavailableNetDriveGone(szPath);

                                        // Do we need this if we have the above?
                                        SHChangeNotify(SHCNE_DRIVEREMOVED, SHCNF_PATH, szPath, NULL);
                                    }
                                }
                            }

                            pmtpt->Release();
                        }
                    }

                    // flush them altogether
                    SHChangeNotifyHandleEvents();
                    HIDA_ReleaseStgMedium(pida, &medium);
                }
            }
            break;

        case FSIDM_CONNECT_PRN:
            SHNetConnectionDialog(hwnd, NULL, RESOURCETYPE_PRINT);
            break;

        case FSIDM_DISCONNECT_PRN:
            WNetDisconnectDialog(hwnd, RESOURCETYPE_PRINT);
            break;

        default:
            // This is one of view menu items, use the default code.
            hr = S_FALSE;
            break;
        }
        break;

    default:
        hr = E_NOTIMPL;
        break;
    }
    return hr;
}

#define REGSTR_LASTUNCHASH  TEXT("LastUNCHash")

STDMETHODIMP GetUNCPathHash(HKEY hkDrives, LPCTSTR pszUNCPath, LPTSTR pszUNCPathHash, int cchUNCPathHash)
{
    HRESULT hr = E_FAIL;
    DWORD dwLastUNCHash = 0;
    SHQueryValueEx(hkDrives, REGSTR_LASTUNCHASH, NULL, NULL, (BYTE *)&dwLastUNCHash, NULL);
    dwLastUNCHash++;
    if (RegSetValueEx(hkDrives, REGSTR_LASTUNCHASH, 0, REG_DWORD, (LPCBYTE)&dwLastUNCHash, sizeof(dwLastUNCHash)) == ERROR_SUCCESS)
    {
        hr = S_OK;
    }
    wnsprintf(pszUNCPathHash, cchUNCPathHash, TEXT("%lu"), (ULONG)dwLastUNCHash);
    return hr;
}

void _DrvPrshtSetSpaceValues(DRIVEPROPSHEETPAGE *pdpsp)
{
    LPITEMIDLIST pidl;
    TCHAR szFormat[30];
    TCHAR szTemp[30];
    TCHAR szBuffer[64]; // needs to be big enough to hold "99,999,999,999,999 bytes" + room for localization

    // reset the total/free values to start with
    pdpsp->qwTot = pdpsp->qwFree = 0;

    // lets try to ask the shellfolder for this information!
    HRESULT hr = SHILCreateFromPath(pdpsp->szDrive, &pidl, NULL);
    if (SUCCEEDED(hr))
    {
        IShellFolder2 *psf2;
        LPCITEMIDLIST pidlLast;

        hr = SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder2, &psf2), &pidlLast);
        if (SUCCEEDED(hr))
        {
            ULONGLONG ullFree;

            hr = GetLongProperty(psf2, pidlLast, &SCID_FREESPACE, &ullFree);
            if (SUCCEEDED(hr))
            {
                ULONGLONG ullTotal;

                hr = GetLongProperty(psf2, pidlLast, &SCID_CAPACITY, &ullTotal);
                if (SUCCEEDED(hr))
                {
                    pdpsp->qwTot = ullTotal;
                    pdpsp->qwFree = ullFree;
                }
            }
            psf2->Release();
        }
        ILFree(pidl);
    }

    // we want to use the IShellFolder stuff above so cdrom burning will be happy. However, the
    // above code fails for removable drives that have no media, so we need a fallback
    if (FAILED(hr))
    {
        ULARGE_INTEGER qwFreeUser;
        ULARGE_INTEGER qwTotal;
        ULARGE_INTEGER qwTotalFree;

        if (SHGetDiskFreeSpaceEx(pdpsp->szDrive, &qwFreeUser, &qwTotal, &qwTotalFree))
        {
            // Save away to use when drawing the pie
            pdpsp->qwTot = qwTotal.QuadPart;
            pdpsp->qwFree = qwFreeUser.QuadPart;
        }
    }
    
    LoadString(HINST_THISDLL, IDS_BYTES, szFormat, ARRAYSIZE(szFormat));

    // NT must be able to display 64-bit numbers; at least as much
    // as is realistic.  We've made the decision
    // that volumes up to 100 Terrabytes will display the byte value
    // and the short-format value.  Volumes of greater size will display
    // "---" in the byte field and the short-format value.  Note that the
    // short format is always displayed.
    const _int64 MaxDisplayNumber = 99999999999999; // 100TB - 1.

    if ((pdpsp->qwTot - pdpsp->qwFree) <= MaxDisplayNumber)
    {
        wnsprintf(szBuffer, ARRAYSIZE(szBuffer), szFormat, AddCommas64(pdpsp->qwTot - pdpsp->qwFree, szTemp, ARRAYSIZE(szTemp)));
        SetDlgItemText(pdpsp->hDlg, IDC_DRV_USEDBYTES, szBuffer);
    }

    if (pdpsp->qwFree <= MaxDisplayNumber)
    {
        wnsprintf(szBuffer, ARRAYSIZE(szBuffer), szFormat, AddCommas64(pdpsp->qwFree, szTemp, ARRAYSIZE(szTemp)));
        SetDlgItemText(pdpsp->hDlg, IDC_DRV_FREEBYTES, szBuffer);
    }

    if (pdpsp->qwTot <= MaxDisplayNumber)
    {
        wnsprintf(szBuffer, ARRAYSIZE(szBuffer), szFormat, AddCommas64(pdpsp->qwTot, szTemp, ARRAYSIZE(szTemp)));
        SetDlgItemText(pdpsp->hDlg, IDC_DRV_TOTBYTES, szBuffer);
    }

    ShortSizeFormat64(pdpsp->qwTot-pdpsp->qwFree, szBuffer, ARRAYSIZE(szBuffer));
    SetDlgItemText(pdpsp->hDlg, IDC_DRV_USEDMB, szBuffer);

    ShortSizeFormat64(pdpsp->qwFree, szBuffer, ARRAYSIZE(szBuffer));
    SetDlgItemText(pdpsp->hDlg, IDC_DRV_FREEMB, szBuffer);

    ShortSizeFormat64(pdpsp->qwTot, szBuffer, ARRAYSIZE(szBuffer));
    SetDlgItemText(pdpsp->hDlg, IDC_DRV_TOTMB, szBuffer);
}

void _DrvPrshtGetPieShadowHeight(DRIVEPROPSHEETPAGE* pdpsp)
{
    SIZE size;
    HDC hDC = GetDC(pdpsp->hDlg);

    // some bizzare black magic calculation for the pie size...
    GetTextExtentPoint(hDC, TEXT("W"), 1, &size);
    pdpsp->dwPieShadowHgt = size.cy * 2 / 3;
    ReleaseDC(pdpsp->hDlg, hDC);
}

void _DrvPrshtSetDriveIcon(DRIVEPROPSHEETPAGE* pdpsp, CMountPoint* pMtPt)
{
    TCHAR szModule[MAX_PATH];

    if (pMtPt)
    {
        UINT uIcon = pMtPt->GetIcon(szModule, ARRAYSIZE(szModule));

        if (uIcon)
        {
            HIMAGELIST hIL = NULL;

            Shell_GetImageLists(&hIL, NULL);

            if (hIL)
            {
                int iIndex = Shell_GetCachedImageIndex(szModule[0] ? szModule : c_szShell32Dll, uIcon, 0);
                HICON hIcon = ImageList_ExtractIcon(g_hinst, hIL, iIndex);

                if (hIcon)
                {
                    ReplaceDlgIcon(pdpsp->hDlg, IDC_DRV_ICON, hIcon);
                }
            }
        }
    }

}

void _DrvPrshtSetDriveAttributes(DRIVEPROPSHEETPAGE* pdpsp, CMountPoint* pMtPt)
{
    if (pMtPt)    
    {
        if (pMtPt->IsCompressible())
        {
            // file-based compression is supported (must be NTFS)
            pdpsp->fIsCompressionAvailable = TRUE;
        
            if (pMtPt->IsCompressed())
            {
                // the volume root is compressed
                pdpsp->asInitial.fCompress = TRUE;

                // if its compressed, compression better be available
                ASSERT(pdpsp->fIsCompressionAvailable);
            }
        }

        //
        // HACK (reinerf) - we dont have a FS_SUPPORTS_INDEXING so we 
        // use the FILE_SUPPORTS_SPARSE_FILES flag, because native index support
        // appeared first on NTFS5 volumes, at the same time sparse file support 
        // was implemented.
        //
        if (pMtPt->IsSupportingSparseFile())
        {
            // yup, we are on NTFS 5 or greater
            pdpsp->fIsIndexAvailable = TRUE;

            if (pMtPt->IsContentIndexed())
            {
                pdpsp->asInitial.fIndex = TRUE;
            }
        }
    }
    else
    {
        // if we don't have a mount point, we just leave everything alone
    }

    // Set the inital state of the compression / content index checkboxes
    if (!pdpsp->fIsCompressionAvailable)
    {
        // file-based compression is not supported
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDD_COMPRESS));
    }
    else
    {
        CheckDlgButton(pdpsp->hDlg, IDD_COMPRESS, pdpsp->asInitial.fCompress);
    }

    if (!pdpsp->fIsIndexAvailable)
    {
        // content index is only supported on NTFS 5 volumes
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDD_INDEX));
    }
    else
    {
        CheckDlgButton(pdpsp->hDlg, IDD_INDEX, pdpsp->asInitial.fIndex);
    }
}

void _DrvPrshtSetFileSystem(DRIVEPROPSHEETPAGE* pdpsp, CMountPoint* pMtPt)
{
    TCHAR szFileSystem[64];

    szFileSystem[0] = TEXT('\0');

    if (pMtPt)
    {
        if (!pMtPt->GetFileSystemName(szFileSystem, ARRAYSIZE(szFileSystem)) ||
            (*szFileSystem == TEXT('\0')))
        {
            if ((pMtPt->IsStrictRemovable() || pMtPt->IsFloppy() || pMtPt->IsCDROM()) &&
                !pMtPt->HasMedia())
            {
                // if this drive has removable media and it is empty, then fall back to "Unknown"
                LoadString(HINST_THISDLL, IDS_FMT_MEDIA0, szFileSystem, ARRAYSIZE(szFileSystem));
            }
            else
            {
                // for fixed drives, leave the text as "RAW" (set by default in dlg template)
                szFileSystem[0] = TEXT('\0');
            }
        }
    }

    if (*szFileSystem)
    {
        SetDlgItemText(pdpsp->hDlg, IDC_DRV_FS, szFileSystem);
    }    
}

void _DrvPrshtSetVolumeLabel(DRIVEPROPSHEETPAGE* pdpsp, CMountPoint* pMtPt)
{
    TCHAR szLabel[MAX_LABEL_NTFS + 1];
    UINT cchLabel = MAX_LABEL_FAT;  // assume the drive is FAT
    HWND hwndLabel = GetDlgItem(pdpsp->hDlg, IDC_DRV_LABEL);
    BOOL bAllowRename = TRUE;
    HRESULT hr = E_FAIL;

    szLabel[0] = TEXT('\0');

    if (pMtPt)
    {
        hr = pMtPt->GetLabelNoFancy(szLabel, ARRAYSIZE(szLabel));

        if (pMtPt->IsRemote() || 
            (pMtPt->IsCDROM() && !pMtPt->IsDVDRAMMedia()))
        {
            // ISSUE-2000/10/30-StephStm We probably want to distinguish between diff types of cdrom drives
            bAllowRename = FALSE;
        }
        
        if ( !bAllowRename && pMtPt->IsCDROM( ) )
        {
            //
            //  Check to see if it is CDFS, if not, make no assumptions about
            //  writing the label.
            //

            WCHAR szFS[ 10 ];   // random - just more than "CDFS\0"
            BOOL b = pMtPt->GetFileSystemName( szFS, ARRAYSIZE(szFS) );
            if (b && lstrcmpi(szFS, L"CDFS") != 0 ) 
            {
                //  Re-enable the label as we don't know if the FS doesn't support this
                //  until we actually try it.
                bAllowRename = TRUE;
            }
        }

        if (pMtPt->IsNTFS())
        {
            cchLabel = MAX_LABEL_NTFS;
        }
    }
    
    SetWindowText(hwndLabel, szLabel);

    if (FAILED(hr) || !bAllowRename)
    {
        Edit_SetReadOnly(hwndLabel, TRUE);
    }
    
    // limit the "Label" edit box based on the filesystem
    Edit_LimitText(hwndLabel, cchLabel);
    
    // make sure we don't recieve an EN_CHANGED message for the volume edit box
    // because we set it above
    Edit_SetModify(hwndLabel, FALSE);
}

void _DrvPrshtSetDriveType(DRIVEPROPSHEETPAGE* pdpsp, CMountPoint* pMtPt)
{
    TCHAR szDriveType[80];

    szDriveType[0] = TEXT('\0');

    if (pMtPt)
    {
        if (pMtPt->IsUnavailableNetDrive())
        {
            LoadString(HINST_THISDLL, IDS_DRIVES_NETUNAVAIL, szDriveType, ARRAYSIZE(szDriveType));
        }
        else
        {
            pMtPt->GetTypeString(szDriveType, ARRAYSIZE(szDriveType));
        }
    }

    SetDlgItemText(pdpsp->hDlg, IDC_DRV_TYPE, szDriveType);
}

void _DrvPrshtSetDriveLetter(DRIVEPROPSHEETPAGE* pdpsp)
{
    TCHAR szDriveLetterText[80];
    TCHAR szFormat[80];

    if (pdpsp->fMountedDrive)
    {
        TCHAR szLabel[MAX_LABEL_NTFS + 1];

        if (GetDlgItemText(pdpsp->hDlg, IDC_DRV_LABEL, szLabel, ARRAYSIZE(szLabel)))
        {
            LoadString(HINST_THISDLL, IDS_VOLUMELABEL, szFormat, ARRAYSIZE(szFormat));
            wnsprintf(szDriveLetterText, ARRAYSIZE(szDriveLetterText), szFormat, szLabel);
            SetDlgItemText(pdpsp->hDlg, IDC_DRV_LETTER, szDriveLetterText);
        }
    }
    else
    {
        LoadString(HINST_THISDLL, IDS_DRIVELETTER, szFormat, ARRAYSIZE(szFormat));
        wnsprintf(szDriveLetterText, ARRAYSIZE(szDriveLetterText), szFormat, pdpsp->iDrive + TEXT('A'));
        SetDlgItemText(pdpsp->hDlg, IDC_DRV_LETTER, szDriveLetterText);
    }
}

void _DrvPrshtSetDiskCleanup(DRIVEPROPSHEETPAGE* pdpsp)
{
    // if we have a cleanup path in the registry, turn on the Disk Cleanup button on
    // NOTE: disk cleanup and mounted volumes don't get along to well, so disable it for now.
    if (!pdpsp->fMountedDrive && GetDiskCleanupPath(NULL, 0) && IsBitBucketableDrive(pdpsp->iDrive))
    {
        ShowWindow(GetDlgItem(pdpsp->hDlg, IDC_DRV_CLEANUP), SW_SHOW);
        EnableWindow(GetDlgItem(pdpsp->hDlg, IDC_DRV_CLEANUP), TRUE);
    }
    else
    {
        ShowWindow(GetDlgItem(pdpsp->hDlg, IDC_DRV_CLEANUP), SW_HIDE);
        EnableWindow(GetDlgItem(pdpsp->hDlg, IDC_DRV_CLEANUP), FALSE);
    }
}

void _DrvPrshtInit(DRIVEPROPSHEETPAGE* pdpsp)
{
    HCURSOR hcurOld = SetCursor(LoadCursor(NULL, IDC_WAIT));

    // get the MountPoint object for this drive
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(pdpsp->szDrive);
    if ( !pMtPt )
    {
        pMtPt = CMountPoint::GetSimulatedMountPointFromVolumeGuid( pdpsp->szDrive );
    }

    _DrvPrshtGetPieShadowHeight(pdpsp);
    _DrvPrshtSetDriveIcon(pdpsp, pMtPt);
    _DrvPrshtSetDriveAttributes(pdpsp, pMtPt);
    _DrvPrshtSetFileSystem(pdpsp, pMtPt);
    _DrvPrshtSetVolumeLabel(pdpsp, pMtPt);
    _DrvPrshtSetDriveType(pdpsp, pMtPt);
    _DrvPrshtSetSpaceValues(pdpsp);
    _DrvPrshtSetDriveLetter(pdpsp);
    _DrvPrshtSetDiskCleanup(pdpsp);

    SetCursor(hcurOld);

    if (pMtPt)
    {
        pMtPt->Release();
    }
}

void _DrvPrshtUpdateInfo(DRIVEPROPSHEETPAGE* pdpsp)
{
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(pdpsp->szDrive);

    _DrvPrshtSetSpaceValues(pdpsp);
    _DrvPrshtSetDriveType(pdpsp, pMtPt);

    if (pMtPt)
    {
        pMtPt->Release();
    }
}

const COLORREF c_crPieColors[] =
{
    RGB(  0,   0, 255),      // Blue
    RGB(255,   0, 255),      // Red-Blue
    RGB(  0,   0, 128),      // 1/2 Blue
    RGB(128,   0, 128),      // 1/2 Red-Blue
};

STDAPI Draw3dPie(HDC hdc, RECT *prc, DWORD dwPer1000, const COLORREF *lpColors);
        
void DrawColorRect(HDC hdc, COLORREF crDraw, const RECT *prc)
{
    HBRUSH hbDraw = CreateSolidBrush(crDraw);
    if (hbDraw)
    {
        HBRUSH hbOld = (HBRUSH)SelectObject(hdc, hbDraw);
        if (hbOld)
        {
            PatBlt(hdc, prc->left, prc->top,
                prc->right - prc->left,
                prc->bottom - prc->top,
                PATCOPY);
            
            SelectObject(hdc, hbOld);
        }
        
        DeleteObject(hbDraw);
    }
}

void _DrvPrshtDrawItem(DRIVEPROPSHEETPAGE *pdpsp, const DRAWITEMSTRUCT * lpdi)
{
    switch (lpdi->CtlID)
    {
    case IDC_DRV_PIE:
        {
            DWORD dwPctX10 = pdpsp->qwTot ?
                (DWORD)((__int64)1000 * (pdpsp->qwTot - pdpsp->qwFree) / pdpsp->qwTot) : 
                1000;
#if 1
            DrawPie(lpdi->hDC, &lpdi->rcItem,
                dwPctX10, pdpsp->qwFree==0 || pdpsp->qwFree==pdpsp->qwTot,
                pdpsp->dwPieShadowHgt, c_crPieColors);
#else
            {
                RECT rcTemp = lpdi->rcItem;
                Draw3dPie(lpdi->hDC, &rcTemp, dwPctX10, c_crPieColors);
            }
#endif
        }
        break;
        
    case IDC_DRV_USEDCOLOR:
        DrawColorRect(lpdi->hDC, c_crPieColors[DP_USEDCOLOR], &lpdi->rcItem);
        break;
        
    case IDC_DRV_FREECOLOR:
        DrawColorRect(lpdi->hDC, c_crPieColors[DP_FREECOLOR], &lpdi->rcItem);
        break;
        
    default:
        break;
    }
}

BOOL_PTR CALLBACK DriveAttribsDlgProc(HWND hDlgRecurse, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    DRIVEPROPSHEETPAGE* pdpsp = (DRIVEPROPSHEETPAGE *)GetWindowLongPtr(hDlgRecurse, DWLP_USER);
    
    switch (uMessage)
    {
    case WM_INITDIALOG:
        {
            TCHAR szTemp[MAX_PATH];
            TCHAR szAttribsToApply[MAX_PATH];
            TCHAR szDriveText[MAX_PATH];
            TCHAR szFormatString[MAX_PATH];
            TCHAR szDlgText[MAX_PATH];
            int iLength;

            SetWindowLongPtr(hDlgRecurse, DWLP_USER, lParam);
            pdpsp = (DRIVEPROPSHEETPAGE *)lParam;

            // set the initial state of the radio button
            CheckDlgButton(hDlgRecurse, IDD_RECURSIVE, TRUE);
        
            szAttribsToApply[0] = 0;

            // set the IDD_ATTRIBSTOAPPLY based on what attribs we are applying
            if (pdpsp->asInitial.fIndex != pdpsp->asCurrent.fIndex)
            {
                if (pdpsp->asCurrent.fIndex)
                    LoadString(HINST_THISDLL, IDS_INDEX, szTemp, ARRAYSIZE(szTemp)); 
                else
                    LoadString(HINST_THISDLL, IDS_DISABLEINDEX, szTemp, ARRAYSIZE(szTemp)); 

                lstrcatn(szAttribsToApply, szTemp, ARRAYSIZE(szAttribsToApply));
            }

            if (pdpsp->asInitial.fCompress != pdpsp->asCurrent.fCompress)
            {
                if (pdpsp->asCurrent.fCompress)
                    LoadString(HINST_THISDLL, IDS_COMPRESS, szTemp, ARRAYSIZE(szTemp)); 
                else
                    LoadString(HINST_THISDLL, IDS_UNCOMPRESS, szTemp, ARRAYSIZE(szTemp)); 

                lstrcatn(szAttribsToApply, szTemp, ARRAYSIZE(szAttribsToApply));
            }

            // remove the trailing ", "
            iLength = lstrlen(szAttribsToApply);
            ASSERT(iLength >= 3);
            szAttribsToApply[iLength - 2] = 0;

            SetDlgItemText(hDlgRecurse, IDD_ATTRIBSTOAPPLY, szAttribsToApply);

            // this dialog was only designed for nice short paths like "c:\" not "\\?\Volume{GUID}\" paths
            if (lstrlen(pdpsp->szDrive) > 3)
            {
                // get the default string
                LoadString(HINST_THISDLL, IDS_THISVOLUME, szDriveText, ARRAYSIZE(szDriveText));
            }
            else
            {
                // Create the string "C:\"
                lstrcpyn(szDriveText, pdpsp->szDrive, ARRAYSIZE(szDriveText));
                PathAddBackslash(szDriveText);

                // sanity check; this better be a drive root!
                ASSERT(PathIsRoot(szDriveText));
            }
        
            // set the IDD_RECURSIVE_TXT text to have "C:\"
            GetDlgItemText(hDlgRecurse, IDD_RECURSIVE_TXT, szFormatString, ARRAYSIZE(szFormatString));
            wnsprintf(szDlgText, ARRAYSIZE(szDlgText), szFormatString, szDriveText);
            SetDlgItemText(hDlgRecurse, IDD_RECURSIVE_TXT, szDlgText);

            // set the IDD_NOTRECURSIVE raido button text to have "C:\"
            GetDlgItemText(hDlgRecurse, IDD_NOTRECURSIVE, szFormatString, ARRAYSIZE(szFormatString));
            wnsprintf(szDlgText, ARRAYSIZE(szDlgText), szFormatString, szDriveText);
            SetDlgItemText(hDlgRecurse, IDD_NOTRECURSIVE, szDlgText);

            // set the IDD_RECURSIVE raido button text to have "C:\"
            GetDlgItemText(hDlgRecurse, IDD_RECURSIVE, szFormatString, ARRAYSIZE(szFormatString));
            wnsprintf(szDlgText, ARRAYSIZE(szDlgText), szFormatString, szDriveText);
            SetDlgItemText(hDlgRecurse, IDD_RECURSIVE, szDlgText);
        }
        break;

    case WM_COMMAND:
        {
            UINT uID = GET_WM_COMMAND_ID(wParam, lParam);
            switch (uID)
            {
            case IDOK:
                pdpsp->fRecursive = (IsDlgButtonChecked(hDlgRecurse, IDD_RECURSIVE) == BST_CHECKED);
                // fall through
            case IDCANCEL:
                EndDialog(hDlgRecurse, (uID == IDCANCEL) ? FALSE : TRUE);
                break;
            }
        }

    default:
        return FALSE;
    }
    return TRUE;
}


BOOL _DrvPrshtApply(DRIVEPROPSHEETPAGE* pdpsp)
{
    BOOL bFctRet;
    HWND hCtl;

    // take care of compression / content indexing first
    pdpsp->asCurrent.fCompress = (IsDlgButtonChecked(pdpsp->hDlg, IDD_COMPRESS) == BST_CHECKED);
    pdpsp->asCurrent.fIndex = (IsDlgButtonChecked(pdpsp->hDlg, IDD_INDEX) == BST_CHECKED);
    pdpsp->asCurrent.fRecordingEnabled = (IsDlgButtonChecked(pdpsp->hDlg, IDC_RECORD_ENABLE) == BST_CHECKED);

    // check to see if something has changed before applying attribs
    if (memcmp(&pdpsp->asInitial, &pdpsp->asCurrent, sizeof(pdpsp->asInitial)) != 0)
    {
        // the user toggled the attributes, so ask them if they want to recurse
        BOOL_PTR bRet = DialogBoxParam(HINST_THISDLL, 
                              MAKEINTRESOURCE(DLG_ATTRIBS_RECURSIVE),
                              pdpsp->hDlg,
                              DriveAttribsDlgProc,
                              (LPARAM)pdpsp);
        if (bRet)
        {
            FILEPROPSHEETPAGE fpsp = {0};

            fpsp.pfci = Create_FolderContentsInfo();
            if (fpsp.pfci)
            {
                // we cook up a fpsp and call ApplySingleFileAttributes instead of 
                // rewriting the apply attributes code
                if (pdpsp->fMountedDrive)
                {
                    GetVolumeNameForVolumeMountPoint(pdpsp->szDrive, fpsp.szPath, ARRAYSIZE(fpsp.szPath));
                }
                else
                {
                    lstrcpyn(fpsp.szPath, pdpsp->szDrive, ARRAYSIZE(fpsp.szPath));
                }

                fpsp.hDlg = pdpsp->hDlg;
                fpsp.asInitial = pdpsp->asInitial;
                fpsp.asCurrent = pdpsp->asCurrent;
                fpsp.pfci->fIsCompressionAvailable = pdpsp->fIsCompressionAvailable;
                fpsp.pfci->ulTotalNumberOfBytes.QuadPart = pdpsp->qwTot - pdpsp->qwFree; // for progress calculations
                fpsp.fIsIndexAvailable = pdpsp->fIsIndexAvailable;
                fpsp.fRecursive = pdpsp->fRecursive;
                fpsp.fIsDirectory = TRUE;
            
                bRet = ApplySingleFileAttributes(&fpsp);

                Release_FolderContentsInfo(fpsp.pfci);
                fpsp.pfci = NULL;

                // update the free/used space after applying attribs because something could
                // have changed (eg compression frees up space)
                _DrvPrshtUpdateInfo(pdpsp);

                // update the initial attributes to reflect the ones we just applied, regardless
                // if the operation was sucessful or not. If they hit cancel, then the volume
                // root was most likely still changed so we need to update.
                pdpsp->asInitial = pdpsp->asCurrent;
            }
            else
            {
                bRet = FALSE;
            }
        }

        if (!bRet)
        {
            // the user hit cancel somewhere
            return FALSE;
        }
    }

    hCtl = GetDlgItem(pdpsp->hDlg, IDC_DRV_LABEL);

    bFctRet = TRUE;

    if (Edit_GetModify(hCtl))
    {
        bFctRet = FALSE;    // assume we fail to set the label

        TCHAR szLabel[MAX_LABEL_NTFS + 1];
        GetWindowText(hCtl, szLabel, ARRAYSIZE(szLabel));

        CMountPoint* pMtPt = CMountPoint::GetMountPoint(pdpsp->szDrive);

        if ( !pMtPt )
        {
            pMtPt = CMountPoint::GetSimulatedMountPointFromVolumeGuid( pdpsp->szDrive );
        }

        if (pMtPt)
        {
            if (SUCCEEDED(pMtPt->SetLabel(GetParent(pdpsp->hDlg), szLabel)))
                bFctRet = TRUE;

            pMtPt->Release();
        }
    }

    return bFctRet;
}

const static DWORD aDrvPrshtHelpIDs[] = {  // Context Help IDs
    IDC_DRV_ICON,          IDH_FCAB_DRV_ICON,
    IDC_DRV_LABEL,         IDH_FCAB_DRV_LABEL,
    IDC_DRV_TYPE_TXT,      IDH_FCAB_DRV_TYPE,
    IDC_DRV_TYPE,          IDH_FCAB_DRV_TYPE,
    IDC_DRV_FS_TXT,        IDH_FCAB_DRV_FS,
    IDC_DRV_FS,            IDH_FCAB_DRV_FS,
    IDC_DRV_USEDCOLOR,     IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_USEDBYTES_TXT, IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_USEDBYTES,     IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_USEDMB,        IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_FREECOLOR,     IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_FREEBYTES_TXT, IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_FREEBYTES,     IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_FREEMB,        IDH_FCAB_DRV_USEDCOLORS,
    IDC_DRV_TOTSEP,        NO_HELP,
    IDC_DRV_TOTBYTES_TXT,  IDH_FCAB_DRV_TOTSEP,
    IDC_DRV_TOTBYTES,      IDH_FCAB_DRV_TOTSEP,
    IDC_DRV_TOTMB,         IDH_FCAB_DRV_TOTSEP,
    IDC_DRV_PIE,           IDH_FCAB_DRV_PIE,
    IDC_DRV_LETTER,        IDH_FCAB_DRV_LETTER,
    IDC_DRV_CLEANUP,       IDH_FCAB_DRV_CLEANUP,
    IDD_COMPRESS,          IDH_FCAB_DRV_COMPRESS,
    IDD_INDEX,             IDH_FCAB_DRV_INDEX,
    0, 0
};

//
// Descriptions:
//   This is the dialog procedure for the "general" page of a property sheet.
//
BOOL_PTR CALLBACK _DrvGeneralDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    DRIVEPROPSHEETPAGE * pdpsp = (DRIVEPROPSHEETPAGE *)GetWindowLongPtr(hDlg, DWLP_USER);

    switch (uMessage) 
    {
    case WM_INITDIALOG:
        // REVIEW, we should store more state info here, for example
        // the hIcon being displayed and the FILEINFO pointer, not just
        // the file name ptr
        SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        pdpsp = (DRIVEPROPSHEETPAGE *)lParam;
        pdpsp->hDlg = hDlg;
        _DrvPrshtInit(pdpsp);
        break;

    case WM_DESTROY:
        ReplaceDlgIcon(hDlg, IDC_DRV_ICON, NULL);   // free the icon
        break;

    case WM_ACTIVATE:
        if (GET_WM_ACTIVATE_STATE(wParam, lParam) != WA_INACTIVE && pdpsp)
            _DrvPrshtUpdateInfo(pdpsp);
        return FALSE;   // Let DefDlgProc know we did not handle this

    case WM_DRAWITEM:
        _DrvPrshtDrawItem(pdpsp, (DRAWITEMSTRUCT *)lParam);
        break;

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

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

    case WM_COMMAND:
        switch (GET_WM_COMMAND_ID(wParam, lParam))
        {
        case IDC_DRV_LABEL:
            if (GET_WM_COMMAND_CMD(wParam, lParam) != EN_CHANGE)
                break;
            // else, fall through
        case IDD_COMPRESS:
        case IDD_INDEX:
            SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0);
            break;

        // handle disk cleanup button      
        case IDC_DRV_CLEANUP:
            LaunchDiskCleanup(hDlg, pdpsp->iDrive, DISKCLEANUP_NOFLAG);
            break;

        default:
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code) 
        {
        case PSN_SETACTIVE:
            break;

        case PSN_APPLY:
            if (!_DrvPrshtApply(pdpsp))
            {
                SetWindowLongPtr(hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
            }
            break;

        default:
            return FALSE;
        }
        break;

    default:
        return FALSE;
    }

    return TRUE;
}


void _DiskToolsPrshtInit(DRIVEPROPSHEETPAGE * pdpsp)
{
    TCHAR szFmt[MAX_PATH + 20];
    DWORD cbLen = sizeof(szFmt);

    BOOL bFoundBackup = SUCCEEDED(SKGetValue(SHELLKEY_HKLM_EXPLORER, REL_KEY_BACKUP, NULL, NULL, szFmt, &cbLen));
    // If no backup utility is installed, then remove everything in the backup groupbox
    if (!bFoundBackup)
    {
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDC_DISKTOOLS_BKPNOW));
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDC_DISKTOOLS_BKPICON));
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDC_DISKTOOLS_BKPDAYS));
        DestroyWindow(GetDlgItem(pdpsp->hDlg, IDC_DISKTOOLS_BKPTXT));
    }

    cbLen = sizeof(szFmt);
    BOOL bFoundFmt = SUCCEEDED(SKGetValue(SHELLKEY_HKLM_EXPLORER, REL_KEY_DEFRAG, NULL, NULL, szFmt, &cbLen)) && szFmt[0];
    // If no defrag utility is installed, replace the default defrag text with
    // the "No defrag installed" message.  Also grey out the "defrag now" button.
    if (!bFoundFmt)
    {
        TCHAR szMessage[50];  // WARNING:  IDS_DRIVES_NOOPTINSTALLED is currently 47
        //           characters long.  Resize this buffer if
        //           the string resource is lengthened.
        
        LoadString(HINST_THISDLL, IDS_DRIVES_NOOPTINSTALLED, szMessage, ARRAYSIZE(szMessage));
        SetDlgItemText(pdpsp->hDlg, IDC_DISKTOOLS_OPTDAYS, szMessage);
        Button_Enable(GetDlgItem(pdpsp->hDlg, IDC_DISKTOOLS_OPTNOW), FALSE);
    }
}

const static DWORD aDiskToolsHelpIDs[] = {  // Context Help IDs
    IDC_DISKTOOLS_TRLIGHT,    IDH_FCAB_DISKTOOLS_CHKNOW,
    IDC_DISKTOOLS_CHKDAYS,    IDH_FCAB_DISKTOOLS_CHKNOW,
    IDC_DISKTOOLS_CHKNOW,     IDH_FCAB_DISKTOOLS_CHKNOW,
    IDC_DISKTOOLS_BKPTXT,     IDH_FCAB_DISKTOOLS_BKPNOW,
    IDC_DISKTOOLS_BKPDAYS,    IDH_FCAB_DISKTOOLS_BKPNOW,
    IDC_DISKTOOLS_BKPNOW,     IDH_FCAB_DISKTOOLS_BKPNOW,
    IDC_DISKTOOLS_OPTDAYS,    IDH_FCAB_DISKTOOLS_OPTNOW,
    IDC_DISKTOOLS_OPTNOW,     IDH_FCAB_DISKTOOLS_OPTNOW,

    0, 0
};

BOOL _DiskToolsCommand(DRIVEPROPSHEETPAGE * pdpsp, WPARAM wParam, LPARAM lParam)
{
    // Add 20 for extra formatting
    TCHAR szFmt[MAX_PATH + 20];
    TCHAR szCmd[MAX_PATH + 20];
    LPCTSTR pszRegName, pszDefFmt;
    int nErrMsg = 0;

    switch (GET_WM_COMMAND_ID(wParam, lParam))
    {
        case IDC_DISKTOOLS_CHKNOW:
            SHChkDskDriveEx(pdpsp->hDlg, pdpsp->szDrive);
            return FALSE;

        case IDC_DISKTOOLS_OPTNOW:
            pszRegName = REL_KEY_DEFRAG;
            if (pdpsp->fMountedDrive)
            {
                pszDefFmt = TEXT("defrag.exe");
            }
            else
            {
                pszDefFmt = TEXT("defrag.exe %c:");
            }
            nErrMsg =  IDS_NO_OPTIMISE_APP;
            break;

        case IDC_DISKTOOLS_BKPNOW:
            pszRegName = REL_KEY_BACKUP;
            pszDefFmt = TEXT("ntbackup.exe");
            nErrMsg = IDS_NO_BACKUP_APP;
            break;

        default:
            return FALSE;
    }

    DWORD cbLen = sizeof(szFmt);
    if (FAILED(SKGetValue(SHELLKEY_HKLM_EXPLORER, pszRegName, NULL, NULL, szFmt, &cbLen)))
    {
        // failed to read out the reg value, just use the default
        lstrcpy(szFmt, pszDefFmt);
    }

    // some apps write REG_SZ keys to the registry even though they have env variables in them
    ExpandEnvironmentStrings(szFmt, szCmd, ARRAYSIZE(szCmd));
    lstrcpyn(szFmt, szCmd, ARRAYSIZE(szFmt));

    // Plug in the drive letter in case they want it
    wnsprintf(szCmd, ARRAYSIZE(szCmd), szFmt, pdpsp->iDrive + TEXT('A'));

    if (!ShellExecCmdLine(pdpsp->hDlg,
                          szCmd,
                          NULL,
                          SW_SHOWNORMAL,
                          NULL,
                          SECL_USEFULLPATHDIR | SECL_NO_UI))
    {
        // Something went wrong - app's probably not installed.
        if (nErrMsg)
        {
            ShellMessageBox(HINST_THISDLL,
                            pdpsp->hDlg,
                            MAKEINTRESOURCE(nErrMsg), NULL,
                            MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND);
        }
        return FALSE;
    }

    return TRUE;
}

//
// Descriptions:
//   This is the dialog procedure for the "Tools" page of a property sheet.
//
BOOL_PTR CALLBACK _DiskToolsDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    DRIVEPROPSHEETPAGE * pdpsp = (DRIVEPROPSHEETPAGE *)GetWindowLongPtr(hDlg, DWLP_USER);

    switch (uMessage) 
    {
    case WM_INITDIALOG:
        // REVIEW, we should store more state info here, for example
        // the hIcon being displayed and the FILEINFO pointer, not just
        // the file name ptr
        SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        pdpsp = (DRIVEPROPSHEETPAGE *)lParam;
        pdpsp->hDlg = hDlg;

        _DiskToolsPrshtInit(pdpsp);
        break;

    case WM_ACTIVATE:
        if (GET_WM_ACTIVATE_STATE(wParam, lParam) != WA_INACTIVE && pdpsp)
        {
            _DiskToolsPrshtInit(pdpsp);
        }
        return FALSE;   // Let DefDlgProc know we did not handle this

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

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

    case WM_COMMAND:
        return _DiskToolsCommand(pdpsp, wParam, lParam);

    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code) 
        {
        case PSN_SETACTIVE:
            break;

        case PSN_APPLY:
            return TRUE;

        default:
            return FALSE;
        }
        break;

    default:
        return FALSE;
    }

    return TRUE;
}

//
// This is the dialog procedure for the "Hardware" page.
//

const GUID c_rgguidDevMgr[] = 
{
    { 0x4d36e967, 0xe325, 0x11ce, { 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } }, // GUID_DEVCLASS_DISKDRIVE
    { 0x4d36e980, 0xe325, 0x11ce, { 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } }, // GUID_DEVCLASS_FLOPPYDISK
    { 0x4d36e965, 0xe325, 0x11ce, { 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } }, // GUID_DEVCLASS_CDROM
};

BOOL_PTR CALLBACK _DriveHWDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    switch (uMessage) 
    {
    case WM_INITDIALOG:
        {
            DRIVEPROPSHEETPAGE * pdpsp = (DRIVEPROPSHEETPAGE *)lParam;

            HWND hwndHW = DeviceCreateHardwarePageEx(hDlg, c_rgguidDevMgr, ARRAYSIZE(c_rgguidDevMgr), HWTAB_LARGELIST);
            if (hwndHW) 
            {
                TCHAR szBuf[MAX_PATH];
                LoadString(HINST_THISDLL, IDS_DRIVETSHOOT, szBuf, ARRAYSIZE(szBuf));
                SetWindowText(hwndHW, szBuf);

                LoadString(HINST_THISDLL, IDS_THESEDRIVES, szBuf, ARRAYSIZE(szBuf));
                SetDlgItemText(hwndHW, IDC_HWTAB_LVSTATIC, szBuf);
            } 
            else 
            {
                DestroyWindow(hDlg); // catastrophic failure
            }
        }
        return FALSE;
    }
    return FALSE;
}



BOOL CDrives_AddPage(LPPROPSHEETPAGE ppsp, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
{
    BOOL fSuccess;
    HPROPSHEETPAGE hpage = CreatePropertySheetPage(ppsp);
    if (hpage)
    {
        fSuccess = pfnAddPage(hpage, lParam);
        if (!fSuccess)
        {   // Couldn't add page
            DestroyPropertySheetPage(hpage);
            fSuccess = FALSE;
        }
    }
    else
    {   // Couldn't create page
        fSuccess = FALSE;
    }
    return fSuccess;
}


HRESULT CDrives_AddPagesHelper(DRIVEPROPSHEETPAGE* pdpsp, int iType,
                               LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
{
    if ((iType == DRIVE_NO_ROOT_DIR) ||
        (iType == DRIVE_REMOTE))
    {
        return S_OK;
    }
    
    CMountPoint* pMtPt = CMountPoint::GetMountPoint(pdpsp->szDrive);
    if (pMtPt)
    {
        if (IsShellServiceRunning())
        {
            if (pMtPt->IsStrictRemovable() || pMtPt->IsCDROM() ||
                (pMtPt->IsFixedDisk() && pMtPt->IsRemovableDevice()))
            {
                CAutoPlayDlg* papdlg = new CAutoPlayDlg();

                if (papdlg)
                {
                    // Autoplay
                    pdpsp->psp.pszTemplate = MAKEINTRESOURCE(DLG_AUTOPLAY);
                    pdpsp->psp.pfnDlgProc  = CAutoPlayDlg::BaseDlgWndProc;
                    pdpsp->psp.pfnCallback = CBaseDlg::BaseDlgPropSheetCallback;
                    pdpsp->psp.dwFlags     = PSP_DEFAULT | PSP_USECALLBACK;

                    papdlg->Init(pdpsp->szDrive, iType);
                    // for now
                    pdpsp->psp.lParam = (LPARAM)(CBaseDlg*)papdlg;

                    if (CDrives_AddPage(&pdpsp->psp, pfnAddPage, lParam))
                    {
                        papdlg->AddRef();
                    }

                    pdpsp->psp.lParam = NULL;
                    pdpsp->psp.pfnCallback = NULL;
                    pdpsp->psp.dwFlags = NULL;

                    papdlg->Release();
                }
            }
        }

        if ((iType != DRIVE_CDROM) || pMtPt->IsDVDRAMMedia())
        {
            // we add the tools page for non-cdrom and DVD-RAM disks
            pdpsp->psp.pszTemplate = MAKEINTRESOURCE(DLG_DISKTOOLS);
            pdpsp->psp.pfnDlgProc  = _DiskToolsDlgProc;

            CDrives_AddPage(&pdpsp->psp, pfnAddPage, lParam);
        }

        pMtPt->Release();
    }

    if (!SHRestricted(REST_NOHARDWARETAB))
    {           
        pdpsp->psp.pszTemplate = MAKEINTRESOURCE(DLG_DRV_HWTAB);
        pdpsp->psp.pfnDlgProc  = _DriveHWDlgProc;
        CDrives_AddPage(&pdpsp->psp, pfnAddPage, lParam);
    }

    return S_OK;
}

//
// We check if any of the IDList's points to a drive root.  If so, we use the
// drives property page.
// Note that drives should not be mixed with folders and files, even in a
// search window.
//
STDAPI CDrives_AddPages(IDataObject *pdtobj, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
{
    STGMEDIUM medium;
    FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    if (SUCCEEDED(pdtobj->GetData(&fmte, &medium)))
    {
        TCHAR szPath[MAX_PATH];
        int i, cItems = DragQueryFile((HDROP)medium.hGlobal, (UINT)-1, NULL, 0);

        for (i = 0; DragQueryFile((HDROP)medium.hGlobal, i, szPath, ARRAYSIZE(szPath)); i++)
        {
            DRIVEPROPSHEETPAGE dpsp = {0};
            TCHAR szTitle[80];

            if (lstrlen(szPath) > 3)
                continue;               // can't be a drive letter
            
            dpsp.psp.dwSize      = sizeof(dpsp);    // extra data
            dpsp.psp.dwFlags     = PSP_DEFAULT;
            dpsp.psp.hInstance   = HINST_THISDLL;
            dpsp.psp.pszTemplate = MAKEINTRESOURCE(DLG_DRV_GENERAL);
            dpsp.psp.pfnDlgProc  = _DrvGeneralDlgProc,
            lstrcpyn(dpsp.szDrive, szPath, ARRAYSIZE(dpsp.szDrive));
            dpsp.iDrive          = DRIVEID(szPath);

            // if more than one drive selected give each tab the title of the drive
            // otherwise use "General"

            if (cItems > 1)
            {
                CMountPoint* pMtPt = CMountPoint::GetMountPoint(dpsp.iDrive);
                if (pMtPt)
                {
                    dpsp.psp.dwFlags = PSP_USETITLE;
                    dpsp.psp.pszTitle = szTitle;

                    pMtPt->GetDisplayName(szTitle, ARRAYSIZE(szTitle));

                    pMtPt->Release();
                }
            }

            if (!CDrives_AddPage(&dpsp.psp, pfnAddPage, lParam))
                break;

            // if only one property page added add the disk tools
            // and Hardware tab too...
            if (cItems == 1)
            {
                CDrives_AddPagesHelper(&dpsp,
                                       RealDriveType(dpsp.iDrive, FALSE /* fOKToHitNet */),
                                       pfnAddPage,
                                       lParam);
            }
        }
        ReleaseStgMedium(&medium);
    }
    else
    {
        // try mounteddrive
        fmte.cfFormat = g_cfMountedVolume;

        // Can we retrieve the MountedVolume format?
        if (SUCCEEDED(pdtobj->GetData(&fmte, &medium)))
        {
            // Yes
            DRIVEPROPSHEETPAGE dpsp = {0};
            HPROPSHEETPAGE hpage;
            TCHAR szMountPoint[MAX_PATH];

            dpsp.psp.dwSize      = sizeof(dpsp);    // extra data
            dpsp.psp.dwFlags     = PSP_DEFAULT;
            dpsp.psp.hInstance   = HINST_THISDLL;
            dpsp.psp.pszTemplate = MAKEINTRESOURCE(DLG_DRV_GENERAL);
            dpsp.psp.pfnDlgProc  = _DrvGeneralDlgProc,
            dpsp.iDrive          = -1;
            dpsp.fMountedDrive   = TRUE;

            DragQueryFile((HDROP)medium.hGlobal, 0, szMountPoint, ARRAYSIZE(szMountPoint));

            lstrcpyn(dpsp.szDrive, szMountPoint, ARRAYSIZE(dpsp.szDrive));

            hpage = CreatePropertySheetPage(&dpsp.psp);
            if (hpage)
            {
                if (!pfnAddPage(hpage, lParam))
                {
                    DestroyPropertySheetPage(hpage);
                }
            }

            // Disk tools page
            CMountPoint* pMtPt = CMountPoint::GetMountPoint(szMountPoint);
            if (pMtPt)
            {
                CDrives_AddPagesHelper(&dpsp, GetDriveType(szMountPoint),
                               pfnAddPage, lParam);
                pMtPt->Release();
            }

            ReleaseStgMedium(&medium);
        }
    }
    return S_OK;
}