CDrivesFolder.cpp File Reference

#include <precomp.h>
#include <process.h>

Include dependency graph for CDrivesFolder.cpp:

Go to the source code of this file.

Classes
class	CDrivesFolderEnum

Macros
#define	RETRY_COUNT   3
#define	RETRY_SLEEP   250
#define	CMDID_FORMAT   1
#define	CMDID_EJECT   2
#define	CMDID_DISCONNECT   3

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static const CLSID *	IsRegItem (PCUITEMID_CHILD pidl)
static bool	IsRegItem (PCUITEMID_CHILD pidl, REFCLSID clsid)
static INT8	GetDriveNumber (PCUITEMID_CHILD pidl)
static INT8	GetDriveNumber (PCWSTR DrivePath)
static UINT	GetCachedDriveType (INT8 DrvNum)
static UINT	GetCachedDriveType (PCWSTR DrivePath)
static bool	IsFloppyDrive (PCWSTR DrivePath)
INT8	GetDrivePath (PCUITEMID_CHILD pidl, PWSTR Path)
static UINT	_ILGetRemovableTypeId (LPCITEMIDLIST pidl)
UINT	_ILGetDriveType (LPCITEMIDLIST pidl)
static UINT	SHELL_GetAutoRunInfPath (PCWSTR DrvPath, PWSTR AriPath, BOOL ForInvoke=FALSE)
BOOL	SHELL32_IsShellFolderNamespaceItemHidden (LPCWSTR SubKey, REFCLSID Clsid)
	Returns true if the item should be hidden in DefView but not in the Explorer folder tree.
static BOOL	TryToLockOrUnlockDrive (HANDLE hDrive, BOOL bLock)
static BOOL	DoEjectDrive (const WCHAR *physical, UINT nDriveType, INT *pnStringID)
static DWORD CALLBACK	DoFormatDriveThread (LPVOID args)
static HRESULT	DoFormatDriveAsync (HWND hwnd, UINT nDrive)
HRESULT CALLBACK	DrivesContextMenuCallback (IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
HRESULT	CDrivesContextMenu_CreateInstance (PCIDLIST_ABSOLUTE pidlFolder, HWND hwnd, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, IShellFolder *psf, IContextMenu **ppcm)
static HRESULT	getIconLocationForDrive (_In_ PCWSTR pszDrivePath, _Out_writes_z_(cchMax) PWSTR szIconFile, _In_ UINT cchMax, _Out_ int *piIndex, _Out_ UINT *pGilOut)
static HRESULT	getLabelForDriveFromAutoRun (PCWSTR wszPath, LPWSTR szLabel, UINT cchMax)
static HRESULT	GetRawDriveLabel (PCWSTR DrivePath, LPWSTR szLabel, UINT cchMax)
static HRESULT	GetDriveLabel (PCWSTR DrivePath, LPWSTR szLabel, UINT cchMax)
static bool	GetRegCustomizedDriveIcon (_In_ INT8 DriveNum, _Out_writes_z_(cchMax) PWSTR szIconFile, _In_ UINT cchMax, _Out_ int *piIndex, _Out_ UINT *pGilOut)
HRESULT	CDrivesExtractIcon_CreateInstance (IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)

Variables
static int	iDriveIconIds [7]
static int	iDriveTypeIds [7]
static const REQUIREDREGITEM	g_RequiredItems []
static const REGFOLDERINFO	g_RegFolderInfo
UINT	g_IsFloppyCache = 0
static const shvheader	MyComputerSFHeader []
static const DWORD	dwComputerAttributes
static const DWORD	dwControlPanelAttributes
static const DWORD	dwDriveAttributes

Macro Definition Documentation

CMDID_DISCONNECT

#define CMDID_DISCONNECT   3

CMDID_EJECT

#define CMDID_EJECT   2

CMDID_FORMAT

#define CMDID_FORMAT   1

RETRY_COUNT

#define RETRY_COUNT   3

Definition at line 206 of file CDrivesFolder.cpp.

RETRY_SLEEP

#define RETRY_SLEEP   250

Definition at line 207 of file CDrivesFolder.cpp.

Function Documentation

_ILGetDriveType()

UINT _ILGetDriveType

(

LPCITEMIDLIST

pidl

)

Definition at line 156 of file CDrivesFolder.cpp.

{
    WCHAR szDrive[8];
    if (!_ILGetDrive(pidl, szDrive, _countof(szDrive)))
    {
        ERR("pidl %p is not a drive\n", pidl);
        return DRIVE_UNKNOWN;
    }
    return GetCachedDriveType(GetDriveNumber(szDrive));
}

Referenced by CDrivesFolder::GetAttributesOf(), and CDrivesFolder::GetDetailsEx().

_ILGetRemovableTypeId()

static UINT _ILGetRemovableTypeId ( LPCITEMIDLIST  pidl )

inlinestatic

Definition at line 148 of file CDrivesFolder.cpp.

{
    WCHAR buf[8];
    if (GetDrivePath(pidl, buf) >= 0 && IsFloppyDrive(buf))
        return SHDID_COMPUTER_DRIVE35; // TODO: 3.5-inch vs 5.25-inch
    return SHDID_COMPUTER_REMOVABLE;
}

Referenced by CDrivesFolder::GetDetailsEx().

CDrivesContextMenu_CreateInstance()

HRESULT CDrivesContextMenu_CreateInstance	(	PCIDLIST_ABSOLUTE	pidlFolder,
		HWND	hwnd,
		UINT	cidl,
		PCUITEMID_CHILD_ARRAY	apidl,
		IShellFolder *	psf,
		IContextMenu **	ppcm
	)

Definition at line 458 of file CDrivesFolder.cpp.

{
    CRegKeyHandleArray keys;
    AddClassKeyToArray(L"Drive", keys, keys);
    AddClassKeyToArray(L"Folder", keys, keys);
    return CDefFolderMenu_Create2(pidlFolder, hwnd, cidl, apidl, psf, DrivesContextMenuCallback, keys, keys, ppcm);
}

Referenced by CDrivesFolder::GetUIObjectOf().

CDrivesExtractIcon_CreateInstance()

HRESULT CDrivesExtractIcon_CreateInstance	(	IShellFolder *	psf,
		LPCITEMIDLIST	pidl,
		REFIID	riid,
		LPVOID *	ppvOut
	)

Definition at line 562 of file CDrivesFolder.cpp.

{
    CComPtr<IDefaultExtractIconInit> initIcon;
    HRESULT hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &initIcon));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    WCHAR wTemp[MAX_PATH], szDrive[8];
    int icon_idx, reg_idx = 0;
    UINT GilOut = 0;
    BOOL bFloppy = FALSE;
    INT8 DriveNum = GetDrivePath(pidl, szDrive);
    UINT DriveType = GetCachedDriveType(DriveNum);
    if (DriveType > DRIVE_RAMDISK)
        DriveType = DRIVE_FIXED;
 
    switch (DriveType)
    {
        case DRIVE_REMOVABLE:
            bFloppy = IsFloppyDrive(szDrive);
            reg_idx = bFloppy ? IDI_SHELL_3_14_FLOPPY : IDI_SHELL_REMOVEABLE;
            break;
        case DRIVE_FIXED:
            reg_idx = IDI_SHELL_DRIVE;
            break;
        case DRIVE_REMOTE:
            reg_idx = IDI_SHELL_NETDRIVE;
            break;
        case DRIVE_CDROM:
            reg_idx = IDI_SHELL_CDROM;
            break;
        case DRIVE_RAMDISK:
            reg_idx = IDI_SHELL_RAMDISK;
            break;
    }
 
    hr = getIconLocationForDrive(szDrive, wTemp, _countof(wTemp),
                                 &icon_idx, &GilOut);
    if (SUCCEEDED(hr))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else if (DriveType > DRIVE_NO_ROOT_DIR &&
             GetRegCustomizedDriveIcon(DriveNum, wTemp, _countof(wTemp), &icon_idx, &GilOut))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else if (reg_idx && HLM_GetIconW(reg_idx - 1, wTemp, _countof(wTemp), &icon_idx))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else if (DriveType == DRIVE_FIXED &&
             HCR_GetIconW(L"Drive", wTemp, NULL, _countof(wTemp), &icon_idx))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else
    {
        if (DriveType == DRIVE_REMOVABLE && bFloppy)
            icon_idx = IDI_SHELL_3_14_FLOPPY;
        else
            icon_idx = iDriveIconIds[DriveType];
        initIcon->SetNormalIcon(swShell32Name, -icon_idx);
    }
 
    return initIcon->QueryInterface(riid, ppvOut);
}

Referenced by CDrivesFolder::GetUIObjectOf().

DoEjectDrive()

static BOOL DoEjectDrive ( const WCHAR *  physical, UINT  nDriveType, INT *  pnStringID  )

static

Definition at line 228 of file CDrivesFolder.cpp.

{
    /* GENERIC_WRITE isn't needed for umount */
    DWORD dwAccessMode = GENERIC_READ;
    DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
 
    HANDLE hDrive = CreateFile(physical, dwAccessMode, dwShareMode, 0, OPEN_EXISTING, 0, NULL);
    if (hDrive == INVALID_HANDLE_VALUE)
        return FALSE;
 
    BOOL bResult, bNeedUnlock = FALSE;
    DWORD dwBytesReturned, dwError = NO_ERROR;
    PREVENT_MEDIA_REMOVAL removal;
    do
    {
        bResult = TryToLockOrUnlockDrive(hDrive, TRUE);
        if (!bResult)
        {
            dwError = GetLastError();
            *pnStringID = IDS_CANTLOCKVOLUME; /* Unable to lock volume */
            break;
        }
        bResult = DeviceIoControl(hDrive, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
        if (!bResult)
        {
            dwError = GetLastError();
            *pnStringID = IDS_CANTDISMOUNTVOLUME; /* Unable to dismount volume */
            bNeedUnlock = TRUE;
            break;
        }
        removal.PreventMediaRemoval = FALSE;
        bResult = DeviceIoControl(hDrive, IOCTL_STORAGE_MEDIA_REMOVAL, &removal, sizeof(removal), NULL,
                                  0, &dwBytesReturned, NULL);
        if (!bResult)
        {
            *pnStringID = IDS_CANTEJECTMEDIA; /* Unable to eject media */
            dwError = GetLastError();
            bNeedUnlock = TRUE;
            break;
        }
        bResult = DeviceIoControl(hDrive, IOCTL_STORAGE_EJECT_MEDIA, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
        if (!bResult)
        {
            *pnStringID = IDS_CANTEJECTMEDIA; /* Unable to eject media */
            dwError = GetLastError();
            bNeedUnlock = TRUE;
            break;
        }
    } while (0);
 
    if (bNeedUnlock)
    {
        TryToLockOrUnlockDrive(hDrive, FALSE);
    }
 
    CloseHandle(hDrive);
 
    SetLastError(dwError);
    return bResult;
}

Referenced by DrivesContextMenuCallback().

DoFormatDriveAsync()

static HRESULT DoFormatDriveAsync ( HWND  hwnd, UINT  nDrive  )

static

Definition at line 301 of file CDrivesFolder.cpp.

{
    BOOL succ = SHCreateThread(DoFormatDriveThread, UlongToPtr(nDrive), CTF_PROCESS_REF, NULL);
    return succ ? S_OK : E_FAIL;
}

Referenced by DrivesContextMenuCallback().

DoFormatDriveThread()

static DWORD CALLBACK DoFormatDriveThread ( LPVOID  args )

static

Definition at line 289 of file CDrivesFolder.cpp.

{
    UINT nDrive = PtrToUlong(args);
    WCHAR szPath[] = { LOWORD(L'A' + nDrive), L'\0' }; // Arbitrary, just needs to include nDrive
    CStubWindow32 stub;
    HRESULT hr = stub.CreateStub(CStubWindow32::TYPE_FORMATDRIVE, szPath, NULL);
    if (FAILED(hr))
        return hr;
    SHFormatDrive(stub, nDrive, SHFMT_ID_DEFAULT, 0);
    return stub.DestroyWindow();
}

Referenced by DoFormatDriveAsync().

DrivesContextMenuCallback()

HRESULT CALLBACK DrivesContextMenuCallback	(	IShellFolder *	psf,
		HWND	hwnd,
		IDataObject *	pdtobj,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 307 of file CDrivesFolder.cpp.

{
    if (uMsg != DFM_MERGECONTEXTMENU && uMsg != DFM_INVOKECOMMAND)
        return SHELL32_DefaultContextMenuCallBack(psf, pdtobj, uMsg);
 
    PIDLIST_ABSOLUTE pidlFolder;
    PUITEMID_CHILD *apidl;
    UINT cidl;
    DWORD dwFlags;
    HRESULT hr = SH_GetApidlFromDataObject(pdtobj, &pidlFolder, &apidl, &cidl);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    WCHAR szDrive[8] = {0};
    if (!_ILGetDrive(apidl[0], szDrive, _countof(szDrive)))
    {
        ERR("pidl is not a drive\n");
        SHFree(pidlFolder);
        _ILFreeaPidl(apidl, cidl);
        return E_FAIL;
    }
    UINT nDriveType = GetCachedDriveType(szDrive);
    if (!GetVolumeInformationW(szDrive, NULL, 0, NULL, NULL, &dwFlags, NULL, 0))
    {
        if (nDriveType >= DRIVE_REMOTE)
            dwFlags = FILE_READ_ONLY_VOLUME;
        else
            dwFlags = 0; // Assume drive with unknown filesystem, allow format
    }
 
// custom command IDs
#if 0 // Disabled until our menu building system is fixed
#define CMDID_FORMAT        0
#define CMDID_EJECT         1
#define CMDID_DISCONNECT    2
#else
/* FIXME: These IDs should start from 0, however there is difference
 * between ours and Windows' menu building systems, which should be fixed. */
#define CMDID_FORMAT        1
#define CMDID_EJECT         2
#define CMDID_DISCONNECT    3
#endif
 
    if (uMsg == DFM_MERGECONTEXTMENU)
    {
        QCMINFO *pqcminfo = (QCMINFO *)lParam;
 
        UINT idCmdFirst = pqcminfo->idCmdFirst;
        UINT idCmd = 0;
        if (!(dwFlags & FILE_READ_ONLY_VOLUME) && nDriveType != DRIVE_REMOTE && cidl == 1)
        {
            /* add separator and Format */
            idCmd = idCmdFirst + CMDID_FORMAT;
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, idCmd, MFT_STRING, MAKEINTRESOURCEW(IDS_FORMATDRIVE), MFS_ENABLED);
        }
        if (nDriveType == DRIVE_REMOVABLE || nDriveType == DRIVE_CDROM)
        {
            /* add separator and Eject */
            idCmd = idCmdFirst + CMDID_EJECT;
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, idCmd, MFT_STRING, MAKEINTRESOURCEW(IDS_EJECT), MFS_ENABLED);
        }
        if (nDriveType == DRIVE_REMOTE)
        {
            /* add separator and Disconnect */
            idCmd = idCmdFirst + CMDID_DISCONNECT;
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
            _InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, idCmd, MFT_STRING, MAKEINTRESOURCEW(IDS_DISCONNECT), MFS_ENABLED);
        }
 
        if (idCmd)
#if 0 // see FIXME above
            pqcminfo->idCmdFirst = ++idCmd;
#else
            pqcminfo->idCmdFirst = (idCmd + 2);
#endif
        hr = S_OK;
    }
    else if (uMsg == DFM_INVOKECOMMAND)
    {
        WCHAR wszBuf[4] = L"A:\\";
        wszBuf[0] = (WCHAR)szDrive[0];
 
        INT nStringID = 0;
        DWORD dwError = NO_ERROR;
 
        if (wParam == DFM_CMD_PROPERTIES)
        {
            ATLASSERT(pdtobj);
            hr = SHELL32_ShowFilesystemItemPropertiesDialogAsync(pdtobj);
            // Not setting nStringID because SHOpenPropSheet already displayed an error box
        }
        else
        {
            if (wParam == CMDID_FORMAT)
            {
                hr = DoFormatDriveAsync(hwnd, szDrive[0] - 'A');
            }
            else if (wParam == CMDID_EJECT)
            {
                /* do eject */
                WCHAR physical[10];
                wsprintfW(physical, _T("\\\\.\\%c:"), szDrive[0]);
 
                if (DoEjectDrive(physical, nDriveType, &nStringID))
                {
                    SHChangeNotify(SHCNE_MEDIAREMOVED, SHCNF_PATHW | SHCNF_FLUSHNOWAIT, wszBuf, NULL);
                }
                else
                {
                    dwError = GetLastError();
                }
            }
            else if (wParam == CMDID_DISCONNECT)
            {
                /* do disconnect */
                wszBuf[2] = UNICODE_NULL;
                dwError = WNetCancelConnection2W(wszBuf, 0, FALSE);
                if (dwError == NO_ERROR)
                {
                    SHChangeNotify(SHCNE_DRIVEREMOVED, SHCNF_PATHW | SHCNF_FLUSHNOWAIT, wszBuf, NULL);
                }
                else
                {
                    nStringID = IDS_CANTDISCONNECT;
                }
            }
        }
 
        if (nStringID != 0)
        {
            /* show error message */
            WCHAR szFormat[128], szMessage[128];
            LoadStringW(shell32_hInstance, nStringID, szFormat, _countof(szFormat));
            wsprintfW(szMessage, szFormat, dwError);
            MessageBoxW(hwnd, szMessage, NULL, MB_ICONERROR);
        }
    }
 
    SHFree(pidlFolder);
    _ILFreeaPidl(apidl, cidl);
 
    return hr;
}

Referenced by CDrivesContextMenu_CreateInstance().

GetCachedDriveType() [1/2]

static UINT GetCachedDriveType ( INT8  DrvNum )

static

Definition at line 104 of file CDrivesFolder.cpp.

{
    if (DrvNum < 0 || DrvNum >= 26)
        return DRIVE_UNKNOWN;
    if (g_IsFloppyCache & (1 << DrvNum))
        return DRIVE_REMOVABLE;
    WCHAR DrvPath[] = { LOWORD('A' + DrvNum), ':', '\\', '\0' };
    return ::GetDriveTypeW(DrvPath);
}

Referenced by _ILGetDriveType(), CDrivesExtractIcon_CreateInstance(), DrivesContextMenuCallback(), GetCachedDriveType(), CDrivesFolder::GetDetailsOf(), CDrivesFolder::GetDisplayNameOf(), IsFloppyDrive(), and SHELL_GetAutoRunInfPath().

GetCachedDriveType() [2/2]

static UINT GetCachedDriveType ( PCWSTR  DrivePath )

inlinestatic

Definition at line 114 of file CDrivesFolder.cpp.

{
    return GetCachedDriveType(GetDriveNumber(DrivePath));
}

GetDriveLabel()

static HRESULT GetDriveLabel ( PCWSTR  DrivePath, LPWSTR  szLabel, UINT  cchMax  )

static

Definition at line 533 of file CDrivesFolder.cpp.

{
    HRESULT hr = getLabelForDriveFromAutoRun(DrivePath, szLabel, cchMax);
    return hr == S_OK ? S_OK : GetRawDriveLabel(DrivePath, szLabel, cchMax);
}

Referenced by CDrivesFolder::GetDisplayNameOf().

GetDriveNumber() [1/2]

static INT8 GetDriveNumber ( PCUITEMID_CHILD  pidl )

static

Definition at line 87 of file CDrivesFolder.cpp.

{
    if (!_ILIsDrive(pidl))
        return -1;
    BYTE letter = ((PIDLDATA*)pidl->mkid.abID)->u.drive.szDriveName[0];
    BYTE number = (letter | 32) - 'a';
    return number < 26 ? number : -1;
}

Referenced by _ILGetDriveType(), GetCachedDriveType(), GetDrivePath(), IsFloppyDrive(), CDrivesFolder::MessageSFVCB(), and SHELL_GetAutoRunInfPath().

GetDriveNumber() [2/2]

static INT8 GetDriveNumber ( PCWSTR  DrivePath )

static

Definition at line 96 of file CDrivesFolder.cpp.

{
    WORD number = (DrivePath[0] | 32) - 'a';
    return number < 26 ? number : -1;
}

GetDrivePath()

INT8 GetDrivePath	(	PCUITEMID_CHILD	pidl,
		PWSTR	Path
	)

Definition at line 136 of file CDrivesFolder.cpp.

{
    INT8 number = GetDriveNumber(pidl);
    if (number < 0)
        return number;
    Path[0] = 'A' + number;
    Path[1] = ':';
    Path[2] = '\\';
    Path[3] = '\0';
    return number;
}

Referenced by _ILGetRemovableTypeId(), CDrivesExtractIcon_CreateInstance(), CDrivesFolder::GetDetailsOf(), CDrivesFolder::GetDisplayNameOf(), and CDrivesFolder::SetNameOf().

getIconLocationForDrive()

static HRESULT getIconLocationForDrive ( _In_ PCWSTR  pszDrivePath, _Out_writes_z_(cchMax) PWSTR  szIconFile, _In_ UINT  cchMax, _Out_ int *  piIndex, _Out_ UINT *  pGilOut  )

static

Definition at line 472 of file CDrivesFolder.cpp.

{
    WCHAR wszPath[MAX_PATH];
    WCHAR wszAutoRunInfPath[MAX_PATH];
    WCHAR wszValue[MAX_PATH], wszTemp[MAX_PATH];
 
    if (!SHELL_GetAutoRunInfPath(pszDrivePath, wszAutoRunInfPath))
        return E_FAIL;
    wcscpy(wszPath, pszDrivePath);
 
    // autorun.inf --> wszValue
    if (GetPrivateProfileStringW(L"autorun", L"icon", NULL, wszValue, _countof(wszValue),
                                 wszAutoRunInfPath) && wszValue[0] != 0)
    {
        // wszValue --> wszTemp
        ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
 
        *piIndex = PathParseIconLocationW(wszTemp);
 
        // wszPath + wszTemp --> wszPath
        if (PathIsRelativeW(wszTemp))
            PathAppendW(wszPath, wszTemp);
        else
            StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
 
        // wszPath --> szIconFile
        GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
        return S_OK;
    }
    return E_FAIL;
}

Referenced by CDrivesExtractIcon_CreateInstance().

getLabelForDriveFromAutoRun()

static HRESULT getLabelForDriveFromAutoRun ( PCWSTR  wszPath, LPWSTR  szLabel, UINT  cchMax  )

static

Definition at line 510 of file CDrivesFolder.cpp.

{
    WCHAR wszAutoRunInfPath[MAX_PATH];
    WCHAR wszTemp[MAX_PATH];
 
    if (!SHELL_GetAutoRunInfPath(wszPath, wszAutoRunInfPath))
        return E_FAIL;
 
    if (GetPrivateProfileStringW(L"autorun", L"label", NULL, wszTemp, _countof(wszTemp),
                                 wszAutoRunInfPath) && wszTemp[0] != 0)
    {
        return StringCchCopyW(szLabel, cchMax, wszTemp);
    }
    return E_FAIL;
}

Referenced by GetDriveLabel().

GetRawDriveLabel()

static HRESULT GetRawDriveLabel ( PCWSTR  DrivePath, LPWSTR  szLabel, UINT  cchMax  )

inlinestatic

Definition at line 526 of file CDrivesFolder.cpp.

{
    if (GetVolumeInformationW(DrivePath, szLabel, cchMax, NULL, NULL, NULL, NULL, 0))
        return *szLabel ? S_OK : S_FALSE;
    return HResultFromWin32(GetLastError());
}

Referenced by GetDriveLabel().

GetRegCustomizedDriveIcon()

static bool GetRegCustomizedDriveIcon ( _In_ INT8  DriveNum, _Out_writes_z_(cchMax) PWSTR  szIconFile, _In_ UINT  cchMax, _Out_ int *  piIndex, _Out_ UINT *  pGilOut  )

static

Definition at line 539 of file CDrivesFolder.cpp.

{
    WCHAR szKey[200], chDrv = 'A' + DriveNum;
    wsprintfW(szKey, L"%s\\DriveIcons\\%c\\DefaultIcon", REGSTR_PATH_EXPLORER, chDrv);
    DWORD cb = cchMax * sizeof(*szIconFile);
    DWORD err = RegGetValueW(HKEY_LOCAL_MACHINE, szKey, NULL, RRF_RT_REG_SZ, NULL, szIconFile, &cb);
    if (err != ERROR_SUCCESS)
    {
        cb = cchMax * sizeof(*szIconFile);
        wsprintfW(szKey, L"Applications\\Explorer.exe\\Drives\\%c\\DefaultIcon", chDrv);
        err = RegGetValueW(HKEY_CLASSES_ROOT, szKey, NULL, RRF_RT_REG_SZ, NULL, szIconFile, &cb);
    }
    if (err != ERROR_SUCCESS)
        return false;
    *piIndex = PathParseIconLocationW(szIconFile);
    return *szIconFile != UNICODE_NULL;
}

Referenced by CDrivesExtractIcon_CreateInstance().

IsFloppyDrive()

static bool IsFloppyDrive ( PCWSTR  DrivePath )

static

Definition at line 119 of file CDrivesFolder.cpp.

{
    extern BOOL IsDriveFloppyW(LPCWSTR pszDriveRoot);
    INT8 DrvNum = GetDriveNumber(DrivePath);
    if (DrvNum < 0)
        return false;
    if (g_IsFloppyCache & (1 << DrvNum))
        return true;
    UINT Type = GetCachedDriveType(DrvNum);
    if (Type == DRIVE_REMOVABLE && IsDriveFloppyW(DrivePath))
    {
        g_IsFloppyCache |= (1 << DrvNum);
        return true;
    }
    return false;
}

Referenced by _ILGetRemovableTypeId(), CDrivesExtractIcon_CreateInstance(), CDrivesFolder::GetDetailsOf(), CDrivesFolder::GetDisplayNameOf(), and SHELL_GetAutoRunInfPath().

IsRegItem() [1/2]

static const CLSID * IsRegItem ( PCUITEMID_CHILD  pidl )

static

Definition at line 71 of file CDrivesFolder.cpp.

{
    if (pidl && pidl->mkid.cb == 2 + 2 + sizeof(CLSID))
    {
        if (pidl->mkid.abID[0] == PT_SHELLEXT || pidl->mkid.abID[0] == PT_GUID) // FIXME: Remove PT_GUID when CRegFolder is fixed
            return (const CLSID*)(&pidl->mkid.abID[2]);
    }
    return NULL;
}

Referenced by IsRegItem().

IsRegItem() [2/2]

static bool IsRegItem ( PCUITEMID_CHILD  pidl, REFCLSID  clsid  )

static

Definition at line 81 of file CDrivesFolder.cpp.

{
    const CLSID *pClass = IsRegItem(pidl);
    return pClass && *pClass == clsid;
}

SHELL32_IsShellFolderNamespaceItemHidden()

BOOL SHELL32_IsShellFolderNamespaceItemHidden	(	LPCWSTR	SubKey,
		REFCLSID	Clsid
	)

Returns true if the item should be hidden in DefView but not in the Explorer folder tree.

Definition at line 193 of file CDrivesFolder.cpp.

{
    WCHAR path[MAX_PATH], name[CHARS_IN_GUID];
    wsprintfW(path, L"%s\\%s", REGSTR_PATH_EXPLORER, SubKey);
    SHELL32_GUIDToStringW(Clsid, name);
    // Check the value in both HKEY_CURRENT_USER and HKEY_LOCAL_MACHINE
    return SHRegGetBoolUSValue(path, name, FALSE, FALSE);
}

Referenced by CDesktopFolderViewCB::ShouldShow(), and CDrivesFolder::ShouldShow().

SHELL_GetAutoRunInfPath()

static UINT SHELL_GetAutoRunInfPath ( PCWSTR  DrvPath, PWSTR  AriPath, BOOL  ForInvoke = FALSE  )

static

Definition at line 167 of file CDrivesFolder.cpp.

{
    INT8 DrvNum = GetDriveNumber(DrvPath);
    if (DrvNum < 0 || DrvPath[1] != ':' || (DrvPath[2] && (DrvPath[2] != '\\' || DrvPath[3])))
        return 0;
    if (!ForInvoke && IsFloppyDrive(DrvPath))
        return 0; // Don't read label nor icon from floppy
    if (GetCachedDriveType(DrvNum) <= DRIVE_NO_ROOT_DIR)
        return 0;
    return wsprintfW(AriPath, L"%c:\\autorun.inf", DrvPath[0]);
}

Referenced by getIconLocationForDrive(), and getLabelForDriveFromAutoRun().

TryToLockOrUnlockDrive()

static BOOL TryToLockOrUnlockDrive ( HANDLE  hDrive, BOOL  bLock  )

static

Definition at line 208 of file CDrivesFolder.cpp.

{
    DWORD dwError, dwBytesReturned;
    DWORD dwCode = (bLock ? FSCTL_LOCK_VOLUME : FSCTL_UNLOCK_VOLUME);
    for (DWORD i = 0; i < RETRY_COUNT; ++i)
    {
        if (DeviceIoControl(hDrive, dwCode, NULL, 0, NULL, 0, &dwBytesReturned, NULL))
            return TRUE;
 
        dwError = GetLastError();
        if (dwError == ERROR_INVALID_FUNCTION)
            break; /* don't sleep if function is not implemented */
 
        Sleep(RETRY_SLEEP);
    }
    SetLastError(dwError);
    return FALSE;
}

Referenced by DoEjectDrive().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

dwComputerAttributes

const DWORD dwComputerAttributes

static

Initial value:

=
    SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
    SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_CANLINK

Definition at line 672 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

dwControlPanelAttributes

const DWORD dwControlPanelAttributes

static

Initial value:

=
    SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK

Definition at line 675 of file CDrivesFolder.cpp.

Referenced by CControlPanelFolder::GetAttributesOf(), and CDrivesFolder::GetAttributesOf().

dwDriveAttributes

const DWORD dwDriveAttributes

static

Initial value:

=
    SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR |
    SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANRENAME | SFGAO_CANLINK | SFGAO_CANCOPY

Definition at line 677 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

g_IsFloppyCache

UINT g_IsFloppyCache = 0

Definition at line 102 of file CDrivesFolder.cpp.

Referenced by GetCachedDriveType(), IsFloppyDrive(), and CDrivesFolder::MessageSFVCB().

g_RegFolderInfo

const REGFOLDERINFO g_RegFolderInfo

static

Initial value:

=
{
    PT_COMPUTER_REGITEM,
    _countof(g_RequiredItems), g_RequiredItems,
    CLSID_MyComputer,
    L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}",
    L"MyComputer",
}

Definition at line 62 of file CDrivesFolder.cpp.

g_RequiredItems

const REQUIREDREGITEM g_RequiredItems[]

static

Initial value:

=
{
    { CLSID_ControlPanel, NULL, REGITEMORDER_MYCOMPUTER_CONTROLS },
}

Definition at line 58 of file CDrivesFolder.cpp.

iDriveIconIds

int iDriveIconIds[7]

static

Initial value:

= { IDI_SHELL_NOT_CONNECTED_HDD, 
                                IDI_SHELL_NOT_CONNECTED_HDD, 
                                IDI_SHELL_REMOVEABLE,        
                                IDI_SHELL_DRIVE,             
                                IDI_SHELL_NETDRIVE,          
                                IDI_SHELL_CDROM,             
                                IDI_SHELL_RAMDISK            
                                }

Definition at line 40 of file CDrivesFolder.cpp.

Referenced by CDrivesExtractIcon_CreateInstance().

iDriveTypeIds

int iDriveTypeIds[7]

static

Initial value:

= { IDS_DRIVE_FIXED,             
                                IDS_DRIVE_FIXED,             
                                IDS_DRIVE_REMOVABLE,         
                                IDS_DRIVE_FIXED,             
                                IDS_DRIVE_NETWORK,           
                                IDS_DRIVE_CDROM,             
                                IDS_DRIVE_FIXED   
                                }

Definition at line 49 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetDetailsOf(), and CDrivesFolder::GetDisplayNameOf().

MyComputerSFHeader

const shvheader MyComputerSFHeader[]

static

Initial value:

= {
    {IDS_SHV_COLUMN_NAME, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 15},
    {IDS_SHV_COLUMN_TYPE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 10},
    {IDS_SHV_COLUMN_DISK_CAPACITY, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
    {IDS_SHV_COLUMN_DISK_AVAILABLE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
    {IDS_SHV_COLUMN_COMMENTS, SHCOLSTATE_TYPE_STR, LVCFMT_LEFT, 10},
}

Definition at line 664 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::CompareIDs(), CDrivesFolder::GetDefaultColumnState(), CDrivesFolder::GetDetailsOf(), and CDrivesFolder::MapColumnToSCID().