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
struct	THREAD_PARAMS
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	_ILGetDriveType (LPCITEMIDLIST pidl)
static BOOL	TryToLockOrUnlockDrive (HANDLE hDrive, BOOL bLock)
static BOOL	DoEjectDrive (const WCHAR *physical, UINT nDriveType, INT *pnStringID)
static BOOL CALLBACK	EnumStubProc (HWND hwnd, LPARAM lParam)
static BOOL CALLBACK	EnumStubProc2 (HWND hwnd, LPARAM lParam)
static unsigned __stdcall	format_drive_thread (void *args)
static HRESULT	DoFormatDrive (HWND hwnd, UINT nDriveNumber)
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	getLabelForDrive (LPWSTR wszPath, LPWSTR wszLabel)
BOOL	IsDriveFloppyA (LPCSTR pszDriveRoot)
HRESULT	CDrivesExtractIcon_CreateInstance (IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)

Variables
static int	iDriveIconIds [7]
static int	iDriveTypeIds [7]
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 73 of file CDrivesFolder.cpp.

RETRY_SLEEP

#define RETRY_SLEEP   250

Definition at line 74 of file CDrivesFolder.cpp.

Function Documentation

_ILGetDriveType()

BOOL _ILGetDriveType

(

LPCITEMIDLIST

pidl

)

Definition at line 58 of file CDrivesFolder.cpp.

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

Referenced by CDrivesFolder::GetAttributesOf().

CDrivesContextMenu_CreateInstance()

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

Definition at line 419 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 501 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 95 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().

DoFormatDrive()

static HRESULT DoFormatDrive ( HWND  hwnd, UINT  nDriveNumber  )

static

Definition at line 250 of file CDrivesFolder.cpp.

{
    THREAD_PARAMS *params = new THREAD_PARAMS;
    params->nDriveNumber = nDriveNumber;
 
    // Create thread to avoid locked.
    unsigned tid;
    HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, format_drive_thread, params, 0, &tid);
    if (hThread == NULL)
    {
        delete params;
        return E_FAIL;
    }
 
    CloseHandle(hThread);
 
    return S_OK;
}

Referenced by DrivesContextMenuCallback().

DrivesContextMenuCallback()

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

Definition at line 269 of file CDrivesFolder.cpp.

{
    if (uMsg != DFM_MERGECONTEXTMENU && uMsg != DFM_INVOKECOMMAND)
        return S_OK;
 
    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;
 
    char szDrive[8] = {0};
    if (!_ILGetDrive(apidl[0], szDrive, sizeof(szDrive)))
    {
        ERR("pidl is not a drive\n");
        SHFree(pidlFolder);
        _ILFreeaPidl(apidl, cidl);
        return E_FAIL;
    }
    nDriveType = GetDriveTypeA(szDrive);
    GetVolumeInformationA(szDrive, NULL, 0, NULL, NULL, &dwFlags, NULL, 0);
 
// 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)
        {
            /* 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
    }
    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)
        {
            // pdtobj should be valid at this point!
            ATLASSERT(pdtobj);
            hr = SH_ShowDriveProperties(wszBuf, pdtobj) ? S_OK : E_UNEXPECTED;
            if (FAILED(hr))
            {
                dwError = ERROR_CAN_NOT_COMPLETE;
                nStringID = IDS_CANTSHOWPROPERTIES;
            }
        }
        else
        {
            if (wParam == CMDID_FORMAT)
            {
                hr = DoFormatDrive(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().

EnumStubProc()

static BOOL CALLBACK EnumStubProc ( HWND  hwnd, LPARAM  lParam  )

static

Definition at line 158 of file CDrivesFolder.cpp.

{
    CSimpleArray<HWND> *pStubs = reinterpret_cast<CSimpleArray<HWND> *>(lParam);
 
    WCHAR szClass[64];
    GetClassNameW(hwnd, szClass, _countof(szClass));
 
    if (lstrcmpiW(szClass, L"StubWindow32") == 0)
    {
        pStubs->Add(hwnd);
    }
 
    return TRUE;
}

Referenced by format_drive_thread().

EnumStubProc2()

static BOOL CALLBACK EnumStubProc2 ( HWND  hwnd, LPARAM  lParam  )

static

Definition at line 175 of file CDrivesFolder.cpp.

{
    HWND *phwnd = reinterpret_cast<HWND *>(lParam);
 
    if (phwnd[0] == GetWindow(hwnd, GW_OWNER))
    {
        phwnd[1] = hwnd;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by format_drive_thread().

format_drive_thread()

static unsigned __stdcall format_drive_thread ( void *  args )

static

Definition at line 194 of file CDrivesFolder.cpp.

{
    THREAD_PARAMS *params = (THREAD_PARAMS *)args;
    UINT nDriveNumber = params->nDriveNumber;
    LONG_PTR nProp = nDriveNumber | 0x7F00;
 
    // Search the stub windows that already exist.
    CSimpleArray<HWND> old_stubs;
    EnumWindows(EnumStubProc, (LPARAM)&old_stubs);
 
    for (INT n = 0; n < old_stubs.GetSize(); ++n)
    {
        HWND hwndStub = old_stubs[n];
 
        // The target stub window has the prop.
        if (GetPropW(hwndStub, L"DriveNumber") == (HANDLE)nProp)
        {
            // Found.
            HWND ahwnd[2];
            ahwnd[0] = hwndStub;
            ahwnd[1] = NULL;
            EnumWindows(EnumStubProc2, (LPARAM)ahwnd);
 
            // Activate.
            BringWindowToTop(ahwnd[1]);
 
            delete params;
            return 0;
        }
    }
 
    // Create a stub window.
    DWORD style = WS_DISABLED | WS_CLIPSIBLINGS | WS_CAPTION;
    DWORD exstyle = WS_EX_WINDOWEDGE | WS_EX_APPWINDOW;
    CStubWindow32 stub;
    if (!stub.Create(NULL, NULL, NULL, style, exstyle))
    {
        ERR("StubWindow32 creation failed\n");
        delete params;
        return 0;
    }
 
    // Add prop to the target stub window.
    SetPropW(stub, L"DriveNumber", (HANDLE)nProp);
 
    // Do format.
    SHFormatDrive(stub, nDriveNumber, SHFMT_ID_DEFAULT, 0);
 
    // Clean up.
    RemovePropW(stub, L"DriveNumber");
    stub.DestroyWindow();
    delete params;
 
    return 0;
}

Referenced by DoFormatDrive().

getIconLocationForDrive()

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

static

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

getLabelForDrive()

static HRESULT getLabelForDrive ( LPWSTR  wszPath, LPWSTR  wszLabel  )

static

Definition at line 478 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(wszLabel, _countof(wszTemp), wszTemp);
        return S_OK;
    }
 
    return E_FAIL;
}

Referenced by CDrivesFolder::GetDisplayNameOf().

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().

TryToLockOrUnlockDrive()

static BOOL TryToLockOrUnlockDrive ( HANDLE  hDrive, BOOL  bLock  )

static

Definition at line 75 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

Definition at line 619 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

dwControlPanelAttributes

const DWORD dwControlPanelAttributes

static

Initial value:

=
    SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK

Definition at line 622 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

Definition at line 624 of file CDrivesFolder.cpp.

Referenced by CDrivesFolder::GetAttributesOf().

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 40 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 49 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 611 of file CDrivesFolder.cpp.

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