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)
BOOL	IsDriveFloppyA (LPCSTR pszDriveRoot)
BOOL	IsDriveFloppyW (LPCWSTR pszDriveRoot)
static const CLSID *	IsRegItem (PCUITEMID_CHILD pidl)
static bool	IsRegItem (PCUITEMID_CHILD pidl, REFCLSID clsid)
static INT8	GetDriveNumber (PCUITEMID_CHILD pidl)
template<class T >
static T *	GetDrivePath (PCUITEMID_CHILD pidl, T *Path)
static UINT	_ILGetRemovableTypeId (LPCITEMIDLIST pidl)
BOOL	_ILGetDriveType (LPCITEMIDLIST pidl)
BOOL	SHELL32_IsShellFolderNamespaceItemHidden (LPCWSTR SubKey, REFCLSID Clsid)
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 (IShellFolder *psf, PCITEMID_CHILD pidl, UINT uFlags, LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
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)
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
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 144 of file CDrivesFolder.cpp.

RETRY_SLEEP

#define RETRY_SLEEP   250

Definition at line 145 of file CDrivesFolder.cpp.

Function Documentation

_ILGetDriveType()

BOOL _ILGetDriveType

(

LPCITEMIDLIST

pidl

)

Definition at line 119 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 ::GetDriveTypeW(szDrive);
}

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

_ILGetRemovableTypeId()

static UINT _ILGetRemovableTypeId ( LPCITEMIDLIST  pidl )

inlinestatic

Definition at line 111 of file CDrivesFolder.cpp.

{
    WCHAR buf[8];
    if (GetDrivePath(pidl, buf) && IsDriveFloppyW(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 397 of file CDrivesFolder.cpp.

{
    HKEY hKeys[2];
    UINT cKeys = 0;
    AddClassKeyToArray(L"Drive", hKeys, &cKeys);
    AddClassKeyToArray(L"Folder", hKeys, &cKeys);
 
    return CDefFolderMenu_Create2(pidlFolder, hwnd, cidl, apidl, psf, DrivesContextMenuCallback, cKeys, hKeys, ppcm);
}

Referenced by CDrivesFolder::GetUIObjectOf().

CDrivesExtractIcon_CreateInstance()

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

Definition at line 490 of file CDrivesFolder.cpp.

{
    CComPtr<IDefaultExtractIconInit> initIcon;
    HRESULT hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &initIcon));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CHAR* pszDrive = _ILGetDataPointer(pidl)->u.drive.szDriveName;
    UINT DriveType = GetDriveTypeA(pszDrive);
    if (DriveType > DRIVE_RAMDISK)
        DriveType = DRIVE_FIXED;
 
    WCHAR wTemp[MAX_PATH];
    int icon_idx, reg_idx;
    UINT flags = 0;
 
    switch (DriveType)
    {
        case DRIVE_FIXED:
        case DRIVE_UNKNOWN:
            reg_idx = IDI_SHELL_DRIVE;
            break;
        case DRIVE_CDROM:
            reg_idx = IDI_SHELL_CDROM;
            break;
        case DRIVE_REMOTE:
            reg_idx = IDI_SHELL_NETDRIVE;
            break;
        case DRIVE_REMOVABLE:
            if (!IsDriveFloppyA(pszDrive))
                reg_idx = IDI_SHELL_REMOVEABLE;
            else
                reg_idx = IDI_SHELL_3_14_FLOPPY;
            break;
        case DRIVE_RAMDISK:
            reg_idx = IDI_SHELL_RAMDISK;
            break;
        case DRIVE_NO_ROOT_DIR:
        default:
            reg_idx = IDI_SHELL_DOCUMENT;
            break;
    }
 
    hr = getIconLocationForDrive(psf, pidl, 0, wTemp, _countof(wTemp),
                                 &icon_idx, &flags);
    if (SUCCEEDED(hr))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else if (HLM_GetIconW(reg_idx - 1, wTemp, _countof(wTemp), &icon_idx))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else if ((DriveType == DRIVE_FIXED || DriveType == DRIVE_UNKNOWN) &&
             (HCR_GetIconW(L"Drive", wTemp, NULL, _countof(wTemp), &icon_idx)))
    {
        initIcon->SetNormalIcon(wTemp, icon_idx);
    }
    else
    {
        if (DriveType == DRIVE_REMOVABLE && !IsDriveFloppyA(pszDrive))
        {
            icon_idx = IDI_SHELL_REMOVEABLE;
        }
        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 166 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 239 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 227 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 245 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;
    UINT nDriveType;
    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;
    }
    nDriveType = GetDriveTypeW(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().

GetDriveLabel()

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

static

Definition at line 484 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()

static INT8 GetDriveNumber ( PCUITEMID_CHILD  pidl )

static

Definition at line 90 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 GetDrivePath(), and CDrivesFolder::MessageSFVCB().

GetDrivePath()

template<class T >

static T * GetDrivePath ( PCUITEMID_CHILD  pidl, T *  Path  )

static

Definition at line 99 of file CDrivesFolder.cpp.

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

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

getIconLocationForDrive()

static HRESULT getIconLocationForDrive ( IShellFolder *  psf, PCITEMID_CHILD  pidl, UINT  uFlags, LPWSTR  szIconFile, UINT  cchMax, int *  piIndex, UINT *  pwFlags  )

static

Definition at line 413 of file CDrivesFolder.cpp.

{
    WCHAR wszPath[MAX_PATH];
    WCHAR wszAutoRunInfPath[MAX_PATH];
    WCHAR wszValue[MAX_PATH], wszTemp[MAX_PATH];
 
    // get path
    if (!ILGetDisplayNameExW(psf, pidl, wszPath, 0))
        return E_FAIL;
    if (!PathIsDirectoryW(wszPath))
        return E_FAIL;
 
    // build the full path of autorun.inf
    StringCchCopyW(wszAutoRunInfPath, _countof(wszAutoRunInfPath), wszPath);
    PathAppendW(wszAutoRunInfPath, L"autorun.inf");
 
    // autorun.inf --> wszValue
    if (GetPrivateProfileStringW(L"autorun", L"icon", NULL, wszValue, _countof(wszValue),
                                 wszAutoRunInfPath) && wszValue[0] != 0)
    {
        // wszValue --> wszTemp
        ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
 
        // parse the icon location
        *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 456 of file CDrivesFolder.cpp.

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

Referenced by GetDriveLabel().

GetRawDriveLabel()

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

inlinestatic

Definition at line 477 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().

IsDriveFloppyA()

BOOL IsDriveFloppyA

(

LPCSTR

pszDriveRoot

)

Definition at line 386 of file drvdefext.cpp.

{
    WCHAR szRoot[8];
    MultiByteToWideChar(CP_ACP, 0, pszDriveRoot, -1, szRoot, _countof(szRoot));
    return IsDriveFloppyW(szRoot);
}

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

IsDriveFloppyW()

BOOL IsDriveFloppyW

(

LPCWSTR

pszDriveRoot

)

Definition at line 320 of file drvdefext.cpp.

{
    LPCWSTR RootPath = pszDriveRoot;
    WCHAR szRoot[16], szDeviceName[16];
    UINT uType;
    HANDLE hDevice;
    DEVICE_TYPE DeviceType;
    ULONG ulCharacteristics;
    BOOL ret;
 
    lstrcpynW(szRoot, RootPath, _countof(szRoot));
 
    if (L'a' <= szRoot[0] && szRoot[0] <= 'z')
    {
        szRoot[0] += ('A' - 'a');
    }
 
    if ('A' <= szRoot[0] && szRoot[0] <= L'Z' &&
        szRoot[1] == L':' && szRoot[2] == 0)
    {
        // 'C:' --> 'C:\'
        szRoot[2] = L'\\';
        szRoot[3] = 0;
    }
 
    if (!PathIsRootW(szRoot))
    {
        return FALSE;
    }
 
    uType = GetDriveTypeW(szRoot);
    if (uType == DRIVE_REMOVABLE)
    {
        if (szRoot[0] == L'A' || szRoot[0] == L'B')
            return TRUE;
    }
    else
    {
        return FALSE;
    }
 
    lstrcpynW(szDeviceName, L"\\\\.\\", _countof(szDeviceName));
    szDeviceName[4] = szRoot[0];
    szDeviceName[5] = L':';
    szDeviceName[6] = UNICODE_NULL;
 
    hDevice = CreateFileW(szDeviceName, FILE_READ_ATTRIBUTES,
                          FILE_SHARE_READ | FILE_SHARE_WRITE,
                          NULL, OPEN_EXISTING, 0, NULL);
    if (hDevice == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
 
    ret = FALSE;
    if (GetDriveTypeAndCharacteristics(hDevice, &DeviceType, &ulCharacteristics))
    {
        if ((ulCharacteristics & FILE_FLOPPY_DISKETTE) == FILE_FLOPPY_DISKETTE)
            ret = TRUE;
    }
 
    CloseHandle(hDevice);
 
    return ret;
}

Referenced by _ILGetRemovableTypeId(), and IsDriveFloppyA().

IsRegItem() [1/2]

static const CLSID * IsRegItem ( PCUITEMID_CHILD  pidl )

static

Definition at line 74 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 84 of file CDrivesFolder.cpp.

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

SHELL32_IsShellFolderNamespaceItemHidden()

BOOL SHELL32_IsShellFolderNamespaceItemHidden	(	LPCWSTR	SubKey,
		REFCLSID	Clsid
	)

Definition at line 130 of file CDrivesFolder.cpp.

{
    // If this function returns true, the item should be hidden in DefView but not in the Explorer folder tree.
    WCHAR path[MAX_PATH], name[CHARS_IN_GUID];
    wsprintfW(path, L"%s\\%s", REGSTR_PATH_EXPLORER, SubKey);
    SHELL32_GUIDToStringW(Clsid, name);
    DWORD data = 0, size = sizeof(data);
    return !RegGetValueW(HKEY_CURRENT_USER, path, name, RRF_RT_DWORD, NULL, &data, &size) && data;
}

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

TryToLockOrUnlockDrive()

static BOOL TryToLockOrUnlockDrive ( HANDLE  hDrive, BOOL  bLock  )

static

Definition at line 146 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 606 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

dwControlPanelAttributes

const DWORD dwControlPanelAttributes

static

Initial value:

=
    SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK

Definition at line 609 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 611 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

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 65 of file CDrivesFolder.cpp.

g_RequiredItems

const REQUIREDREGITEM g_RequiredItems[]

static

Initial value:

=
{
    { CLSID_ControlPanel, NULL, REGITEMORDER_MYCOMPUTER_CONTROLS },
}

Definition at line 61 of file CDrivesFolder.cpp.

iDriveIconIds

int iDriveIconIds[7]

static

Initial value:

= { IDI_SHELL_DRIVE,       
                                IDI_SHELL_CDROM,       
                                IDI_SHELL_3_14_FLOPPY, 
                                IDI_SHELL_DRIVE,       
                                IDI_SHELL_NETDRIVE,    
                                IDI_SHELL_CDROM,       
                                IDI_SHELL_RAMDISK      
                                }

Definition at line 43 of file CDrivesFolder.cpp.

Referenced by CDrivesExtractIcon_CreateInstance().

iDriveTypeIds

int iDriveTypeIds[7]

static

Initial value:

= { IDS_DRIVE_FIXED,       
                                IDS_DRIVE_FIXED,       
                                IDS_DRIVE_FLOPPY,      
                                IDS_DRIVE_FIXED,       
                                IDS_DRIVE_NETWORK,     
                                IDS_DRIVE_CDROM,       
                                IDS_DRIVE_FIXED        
                                }

Definition at line 52 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetDetailsOf().

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 598 of file CDrivesFolder.cpp.

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