2413 lines
85 KiB
C++
2413 lines
85 KiB
C++
#include "shellprv.h"
|
|
#include "ids.h"
|
|
#include "mtpt.h"
|
|
#include "hwcmmn.h"
|
|
#pragma hdrstop
|
|
|
|
#include "apithk.h"
|
|
|
|
const static DWORD FmtaIds[] =
|
|
{
|
|
IDOK, IDH_FORMATDLG_START,
|
|
IDCANCEL, IDH_CANCEL,
|
|
IDC_CAPCOMBO, IDH_FORMATDLG_CAPACITY,
|
|
IDC_FSCOMBO, IDH_FORMATDLG_FILESYS,
|
|
IDC_ASCOMBO, IDH_FORMATDLG_ALLOCSIZE,
|
|
IDC_VLABEL, IDH_FORMATDLG_LABEL,
|
|
IDC_GROUPBOX_1, IDH_COMM_GROUPBOX,
|
|
IDC_QFCHECK, IDH_FORMATDLG_QUICKFULL,
|
|
IDC_ECCHECK, IDH_FORMATDLG_COMPRESS,
|
|
IDC_FMTPROGRESS, IDH_FORMATDLG_PROGRESS,
|
|
0,0
|
|
};
|
|
|
|
const static DWORD ChkaIds[] =
|
|
{
|
|
IDOK, IDH_CHKDSKDLG_START,
|
|
IDCANCEL, IDH_CHKDSKDLG_CANCEL,
|
|
IDC_GROUPBOX_1, IDH_COMM_GROUPBOX,
|
|
IDC_FIXERRORS, IDH_CHKDSKDLG_FIXERRORS,
|
|
IDC_RECOVERY, IDH_CHKDSKDLG_SCAN,
|
|
IDC_CHKDSKPROGRESS, IDH_CHKDSKDLG_PROGRESS,
|
|
IDC_PHASE, -1,
|
|
0,0
|
|
};
|
|
|
|
// The following structure encapsulates our calling into the FMIFS.DLL
|
|
typedef struct
|
|
{
|
|
HINSTANCE hFMIFS_DLL;
|
|
PFMIFS_FORMATEX_ROUTINE FormatEx;
|
|
PFMIFS_QSUPMEDIA_ROUTINE QuerySupportedMedia;
|
|
PFMIFS_ENABLECOMP_ROUTINE EnableVolumeCompression;
|
|
PFMIFS_CHKDSKEX_ROUTINE ChkDskEx;
|
|
PFMIFS_QUERY_DEVICE_INFO_ROUTINE QueryDeviceInformation;
|
|
} FMIFS;
|
|
|
|
typedef
|
|
HRESULT
|
|
(*PDISKCOPY_MAKEBOOTDISK_ROUTINE)(
|
|
IN HINSTANCE hInstance,
|
|
IN UINT iDrive,
|
|
IN BOOL* pfCancelled,
|
|
IN FMIFS_CALLBACK pCallback
|
|
);
|
|
|
|
// The following structure encapsulates our calling into the DISKCOPY.DLL
|
|
typedef struct
|
|
{
|
|
HINSTANCE hDISKCOPY_DLL;
|
|
PDISKCOPY_MAKEBOOTDISK_ROUTINE MakeBootDisk;
|
|
} DISKCOPY;
|
|
|
|
// This structure described the current formatting session
|
|
typedef struct
|
|
{
|
|
LONG cRef; // reference count on this structure
|
|
UINT drive; // 0-based index of drive to format
|
|
UINT fmtID; // Last format ID
|
|
UINT options; // options passed to us via the API
|
|
FMIFS fmifs; // above
|
|
DISKCOPY diskcopy; // above
|
|
HWND hDlg; // handle to the format dialog
|
|
BOOL fIsFloppy; // TRUE -> its a floppy
|
|
BOOL fIs35HDFloppy; // TRUE -> its a standard 3.5" High Density floppy
|
|
BOOL fIsMemoryStick; // TRUE -> its a memory stick (special formatting only)
|
|
BOOL fIsNTFSBlocked; // TRUE -> its a NTFS not-supported device
|
|
BOOL fEnableComp; // Last "Enable Comp" choice from user
|
|
BOOL fCancelled; // User cancelled the last format
|
|
BOOL fShouldCancel; // User has clicked cancel; pending abort
|
|
BOOL fWasFAT; // Was it FAT originally?
|
|
BOOL fFinishedOK; // Did format complete sucessfully?
|
|
BOOL fErrorAlready; // Did we put up an error dialog already?
|
|
BOOL fDisabled; // Is rgfControlEnabled[] valid?
|
|
DWORD dwClusterSize; // Orig NT cluster size, or last choice
|
|
WCHAR wszVolName[MAX_PATH]; // Volume Label
|
|
WCHAR wszDriveName[4]; // Root path to drive (eg: A:\)
|
|
HANDLE hThread; // Handle of format thread
|
|
|
|
// Array of media types supported by the device
|
|
// for NT5, we have an expanded list that includes japanese types.
|
|
FMIFS_MEDIA_TYPE rgMedia[IDS_FMT_MEDIA_J22-IDS_FMT_MEDIA_J0];
|
|
|
|
// Used to cache the enabled/disabled state of the dialog controls
|
|
BOOL rgfControlEnabled[DLG_FORMATDISK_NUMCONTROLS];
|
|
|
|
// should we create a boot disk rather than a traditional format
|
|
BOOL fMakeBootDisk;
|
|
|
|
} FORMATINFO;
|
|
|
|
//
|
|
// An enumeration to make the filesystem combo-box code more readble
|
|
//
|
|
|
|
typedef enum tagFILESYSENUM
|
|
{
|
|
e_FAT = 0,
|
|
e_NTFS,
|
|
e_FAT32
|
|
} FILESYSENUM;
|
|
|
|
#define FS_STR_NTFS TEXT("NTFS")
|
|
#define FS_STR_FAT32 TEXT("FAT32")
|
|
#define FS_STR_FAT TEXT("FAT")
|
|
|
|
//
|
|
// Private WM_USER messages we will use. For some unknown reason, USER sends
|
|
// us a WM_USER during initialization, so I start my private messages at
|
|
// WM_USER + 0x0100
|
|
//
|
|
|
|
typedef enum tagPRIVMSGS
|
|
{
|
|
PWM_FORMATDONE = WM_USER + 0x0100,
|
|
PWM_CHKDSKDONE
|
|
} PRIVMSGS;
|
|
|
|
//
|
|
// Synopsis: Loads FMIFS.DLL and sets up the function entry points for
|
|
// the member functions we are interested in.
|
|
//
|
|
HRESULT LoadFMIFS(FMIFS *pFMIFS)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Load the FMIFS DLL and query for the entry points we need
|
|
//
|
|
|
|
// SECURITY: what non-relative path do we use that will work on ia64 too?
|
|
if (NULL == (pFMIFS->hFMIFS_DLL = LoadLibrary(TEXT("FMIFS.DLL"))))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pFMIFS->FormatEx = (PFMIFS_FORMATEX_ROUTINE)
|
|
GetProcAddress(pFMIFS->hFMIFS_DLL, "FormatEx")))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pFMIFS->QuerySupportedMedia = (PFMIFS_QSUPMEDIA_ROUTINE)
|
|
GetProcAddress(pFMIFS->hFMIFS_DLL, "QuerySupportedMedia")))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pFMIFS->EnableVolumeCompression = (PFMIFS_ENABLECOMP_ROUTINE)
|
|
GetProcAddress(pFMIFS->hFMIFS_DLL, "EnableVolumeCompression")))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pFMIFS->ChkDskEx = (PFMIFS_CHKDSKEX_ROUTINE)
|
|
GetProcAddress(pFMIFS->hFMIFS_DLL, "ChkdskEx")))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pFMIFS->QueryDeviceInformation = (PFMIFS_QUERY_DEVICE_INFO_ROUTINE)
|
|
GetProcAddress(pFMIFS->hFMIFS_DLL, "QueryDeviceInformation")))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
//
|
|
// If anything failed, and we've got the DLL loaded, release the DLL
|
|
//
|
|
|
|
if (hr != S_OK && pFMIFS->hFMIFS_DLL)
|
|
{
|
|
FreeLibrary(pFMIFS->hFMIFS_DLL);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Synopsis: Loads DISKCOPY.DLL and sets up the function entry points for
|
|
// the member functions we are interested in.
|
|
//
|
|
HRESULT LoadDISKCOPY(DISKCOPY *pDISKCOPY)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Load the DISKCOPY DLL and query for the entry points we need
|
|
//
|
|
|
|
// SECURITY: what non-relative path do we use that will work on ia64 too?
|
|
if (NULL == (pDISKCOPY->hDISKCOPY_DLL = LoadLibrary(TEXT("DISKCOPY.DLL"))))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (NULL == (pDISKCOPY->MakeBootDisk = (PDISKCOPY_MAKEBOOTDISK_ROUTINE)
|
|
GetProcAddress(pDISKCOPY->hDISKCOPY_DLL, MAKEINTRESOURCEA(1)))) //MakeBootDisk is at ordinal 1 in diskcopy.dll
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
//
|
|
// If anything failed, and we've got the DLL loaded, release the DLL
|
|
//
|
|
|
|
if (hr != S_OK && pDISKCOPY->hDISKCOPY_DLL)
|
|
{
|
|
FreeLibrary(pDISKCOPY->hDISKCOPY_DLL);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
void AddRefFormatInfo(FORMATINFO *pFormatInfo)
|
|
{
|
|
InterlockedIncrement(&pFormatInfo->cRef);
|
|
}
|
|
|
|
void ReleaseFormatInfo(FORMATINFO *pFormatInfo)
|
|
{
|
|
if (InterlockedDecrement(&pFormatInfo->cRef) == 0)
|
|
{
|
|
if (pFormatInfo->fmifs.hFMIFS_DLL)
|
|
{
|
|
FreeLibrary(pFormatInfo->fmifs.hFMIFS_DLL);
|
|
}
|
|
|
|
if (pFormatInfo->diskcopy.hDISKCOPY_DLL)
|
|
{
|
|
FreeLibrary(pFormatInfo->diskcopy.hDISKCOPY_DLL);
|
|
}
|
|
|
|
if (pFormatInfo->hThread)
|
|
{
|
|
CloseHandle(pFormatInfo->hThread);
|
|
}
|
|
|
|
LocalFree(pFormatInfo);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Thread-Local Storage index for our FORMATINFO structure pointer
|
|
//
|
|
static DWORD g_iTLSFormatInfo = 0;
|
|
static LONG g_cTLSFormatInfo = 0; // Usage count
|
|
|
|
// Synopsis: Allocates a thread-local index slot for this thread's
|
|
// FORMATINFO pointer, if the index doesn't already exist.
|
|
// In any event, stores the FORMATINFO pointer in the slot
|
|
// and increments the index's usage count.
|
|
//
|
|
// Arguments: [pFormatInfo] -- The pointer to store
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
HRESULT StuffFormatInfoPtr(FORMATINFO *pFormatInfo)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Allocate an index slot for our thread-local FORMATINFO pointer, if one
|
|
// doesn't already exist, then stuff our FORMATINFO ptr at that index.
|
|
ENTERCRITICAL;
|
|
if (0 == g_iTLSFormatInfo)
|
|
{
|
|
if (0xFFFFFFFF == (g_iTLSFormatInfo = TlsAlloc()))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
g_cTLSFormatInfo = 0;
|
|
}
|
|
if (S_OK == hr)
|
|
{
|
|
if (TlsSetValue(g_iTLSFormatInfo, (void *) pFormatInfo))
|
|
{
|
|
g_cTLSFormatInfo++;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Synopsis: Decrements the usage count on our thread-local storage
|
|
// index, and if it goes to zero the index is free'd
|
|
//
|
|
// Arguments: [none]
|
|
//
|
|
// Returns: none
|
|
//
|
|
void UnstuffFormatInfoPtr()
|
|
{
|
|
ENTERCRITICAL;
|
|
if (0 == --g_cTLSFormatInfo)
|
|
{
|
|
TlsFree(g_iTLSFormatInfo);
|
|
g_iTLSFormatInfo = 0;
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// Synopsis: Retrieves this threads FORMATINFO ptr by grabbing the
|
|
// thread-local value previously stuff'd
|
|
//
|
|
// Arguments: [none]
|
|
//
|
|
// Returns: The pointer, of course
|
|
//
|
|
FORMATINFO *GetFormatInfoPtr()
|
|
{
|
|
return (FORMATINFO*)TlsGetValue(g_iTLSFormatInfo);
|
|
}
|
|
|
|
|
|
|
|
// Synopsis: Ghosts all controls except "Cancel", saving their
|
|
// previous state in the FORMATINFO structure
|
|
//
|
|
// Arguments: [pFormatInfo] -- Describes a format dialog session
|
|
//
|
|
// Notes: Also changes "Close" button text to read "Cancel"
|
|
//
|
|
void DisableControls(FORMATINFO *pFormatInfo)
|
|
{
|
|
WCHAR wszCancel[64];
|
|
|
|
// Do this only if we haven't disabled the controls yet, otherwise
|
|
// we double-disable and our rgfControlEnabled[] array gets corrupted.
|
|
if (!pFormatInfo->fDisabled)
|
|
{
|
|
int i;
|
|
pFormatInfo->fDisabled = TRUE;
|
|
for (i = 0; i < DLG_FORMATDISK_NUMCONTROLS; i++)
|
|
{
|
|
HWND hControl = GetDlgItem(pFormatInfo->hDlg, i + DLG_FORMATDISK_FIRSTCONTROL);
|
|
pFormatInfo->rgfControlEnabled[i] = !EnableWindow(hControl, FALSE);
|
|
}
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDOK), FALSE);
|
|
|
|
LoadString(HINST_THISDLL, IDS_FMT_CANCEL, wszCancel, ARRAYSIZE(wszCancel));
|
|
SetWindowText(GetDlgItem(pFormatInfo->hDlg, IDCANCEL), wszCancel);
|
|
}
|
|
|
|
// Synopsis: Restores controls to the enabled/disabled state they were
|
|
// before a previous call to DisableControls().
|
|
//
|
|
// Arguments: [pFormatInfo] -- Decribes a format dialog session
|
|
// [fReady] - If TRUE, then enable everything
|
|
// If FALSE, then enable combo boxes but leave
|
|
// buttons in limbo because there is still a format
|
|
// pending
|
|
//
|
|
// Notes: Also changes "Cancel" button to say "Close"
|
|
// Also sets focus to Cancel button instead of Start button
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void EnableControls(FORMATINFO *pFormatInfo, BOOL fReady)
|
|
{
|
|
WCHAR wszClose[64];
|
|
int i;
|
|
HWND hwnd;
|
|
|
|
// Do this only if we have valid info in rgfControlEnabled[].
|
|
// This catches the case where we give up on a format because it is
|
|
// unstuck, and then finally it unsticks itself and tells us,
|
|
// so we go and re-enable a second time.
|
|
if (pFormatInfo->fDisabled)
|
|
{
|
|
pFormatInfo->fDisabled = FALSE;
|
|
|
|
for (i = 0; i < DLG_FORMATDISK_NUMCONTROLS; i++)
|
|
{
|
|
HWND hControl = GetDlgItem(pFormatInfo->hDlg, i + DLG_FORMATDISK_FIRSTCONTROL);
|
|
EnableWindow(hControl, pFormatInfo->rgfControlEnabled[i]);
|
|
}
|
|
}
|
|
|
|
hwnd = GetDlgItem(pFormatInfo->hDlg, IDOK);
|
|
EnableWindow(hwnd, fReady);
|
|
SendMessage(hwnd, BM_SETSTYLE, BS_PUSHBUTTON, MAKELPARAM(TRUE,0));
|
|
|
|
LoadString(HINST_THISDLL, IDS_FMT_CLOSE, wszClose, ARRAYSIZE(wszClose));
|
|
hwnd = GetDlgItem(pFormatInfo->hDlg, IDCANCEL);
|
|
SetWindowText(hwnd, wszClose);
|
|
SendMessage(hwnd, BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE,0));
|
|
SendMessage(pFormatInfo->hDlg, DM_SETDEFID, IDCANCEL, 0);
|
|
|
|
// Shove focus only if it's on the OK button. Otherwise we end up
|
|
// yanking focus away from a user who is busy dorking with the dialog,
|
|
// or -- worse -- dorking with a completely unrelated dialog!
|
|
|
|
if (GetFocus() == GetDlgItem(pFormatInfo->hDlg, IDOK))
|
|
SetFocus(hwnd);
|
|
}
|
|
|
|
// Sets the dialog's title to "Format Floppy (A:)" or
|
|
// "Formatting Floppy (A:)"
|
|
void SetDriveWindowTitle(HWND hdlg, LPCWSTR pszDrive, UINT ids)
|
|
{
|
|
SHFILEINFO sfi;
|
|
WCHAR wszWinTitle[MAX_PATH]; // Format dialog window title
|
|
|
|
LoadString(HINST_THISDLL, ids, wszWinTitle, ARRAYSIZE(wszWinTitle));
|
|
|
|
if (SHGetFileInfo(pszDrive, FILE_ATTRIBUTE_DIRECTORY, &sfi, sizeof(sfi),
|
|
SHGFI_USEFILEATTRIBUTES | SHGFI_DISPLAYNAME))
|
|
{
|
|
lstrcat(wszWinTitle, sfi.szDisplayName);
|
|
}
|
|
|
|
SetWindowText(hdlg, wszWinTitle);
|
|
}
|
|
|
|
//
|
|
// Synopsis: Called when a user picks a filesystem in the dialog, this
|
|
// sets the states of the other relevant controls, such as
|
|
// Enable Compression, Allocation Size, etc.
|
|
//
|
|
// Arguments: [fsenum] -- One of e_FAT, e_NTFS, or e_FAT32
|
|
// [pFormatInfo] -- Current format dialog session
|
|
//
|
|
void FileSysChange(FILESYSENUM fsenum, FORMATINFO *pFormatInfo)
|
|
{
|
|
WCHAR wszTmp[MAX_PATH];
|
|
|
|
switch (fsenum)
|
|
{
|
|
case e_FAT:
|
|
case e_FAT32:
|
|
{
|
|
// un-check & disable the "Enable Compression" checkbox
|
|
CheckDlgButton(pFormatInfo->hDlg, IDC_ECCHECK, FALSE);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_ECCHECK), FALSE);
|
|
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_RESETCONTENT, 0, 0);
|
|
|
|
LoadString(HINST_THISDLL, IDS_FMT_ALLOC0, wszTmp, ARRAYSIZE(wszTmp));
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_ADDSTRING, 0, (LPARAM)wszTmp);
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 0, 0);
|
|
}
|
|
break;
|
|
|
|
case e_NTFS:
|
|
{
|
|
int i;
|
|
|
|
// un-check & disable the "Enable Compression" checkbox
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_ECCHECK), TRUE);
|
|
CheckDlgButton(pFormatInfo->hDlg, IDC_ECCHECK, pFormatInfo->fEnableComp);
|
|
|
|
// Set up the NTFS Allocation choices, and select the current choice
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_RESETCONTENT, 0, 0);
|
|
|
|
for (i = IDS_FMT_ALLOC0; i <= IDS_FMT_ALLOC4; i++)
|
|
{
|
|
LoadString(HINST_THISDLL, i, wszTmp, ARRAYSIZE(wszTmp));
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_ADDSTRING, 0, (LPARAM)wszTmp);
|
|
}
|
|
|
|
switch (pFormatInfo->dwClusterSize)
|
|
{
|
|
case 512:
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 1, 0);
|
|
break;
|
|
|
|
case 1024:
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 2, 0);
|
|
break;
|
|
|
|
case 2048:
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 3, 0);
|
|
break;
|
|
|
|
case 4096:
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 4, 0);
|
|
break;
|
|
|
|
default:
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_ASCOMBO, CB_SETCURSEL, 0, 0);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Is this drive a GPT drive?
|
|
// GPT drive: Guid-Partition Table - a replacement for the Master Boot Record, used on some IA64 machines, can only use NTFS
|
|
BOOL IsGPTDrive(int iDrive)
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
#ifdef _WIN64
|
|
HANDLE hDrive;
|
|
TCHAR szDrive[] = TEXT("\\\\.\\A:");
|
|
|
|
ASSERT(iDrive < 26);
|
|
szDrive[4] += (TCHAR)iDrive;
|
|
|
|
hDrive = CreateFile(szDrive, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (INVALID_HANDLE_VALUE != hDrive)
|
|
{
|
|
PARTITION_INFORMATION_EX partitionEx;
|
|
DWORD cbReturned;
|
|
if (DeviceIoControl(hDrive, IOCTL_DISK_GET_PARTITION_INFO_EX, NULL, 0, (void*)&partitionEx, sizeof(PARTITION_INFORMATION_EX), &cbReturned, NULL))
|
|
{
|
|
if (partitionEx.PartitionStyle == PARTITION_STYLE_GPT)
|
|
{
|
|
fRetVal = TRUE;
|
|
}
|
|
}
|
|
CloseHandle(hDrive);
|
|
}
|
|
#endif
|
|
return fRetVal;
|
|
}
|
|
|
|
BOOL IsDVDRAMMedia(int iDrive)
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
CMountPoint *pmtpt = CMountPoint::GetMountPoint(iDrive);
|
|
if (pmtpt)
|
|
{
|
|
DWORD dwMediaCap, dwDriveCap;
|
|
if (SUCCEEDED(pmtpt->GetCDInfo(&dwDriveCap, &dwMediaCap)))
|
|
{
|
|
fRetVal = (dwMediaCap & HWDMC_DVDRAM);
|
|
}
|
|
pmtpt->Release();
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
#define GIG_INBYTES (1024 * 1024 * 1024)
|
|
|
|
//
|
|
// FAT32 has some limit which prevents the number of clusters from being
|
|
// less than 65526. And minimum cluster size is 512 bytes. So minimum FAT32
|
|
// volume size is 65526*512.
|
|
|
|
#define FAT32_MIN ((ULONGLONG)65526*512)
|
|
|
|
#define FMTAVAIL_MASK_MIN 0x1
|
|
#define FMTAVAIL_MASK_MAX 0x2
|
|
#define FMTAVAIL_MASK_REQUIRE 0x3
|
|
#define FMTAVAIL_MASK_FORBID 0x4
|
|
|
|
#define FMTAVAIL_TYPE_FLOPPY 0x1
|
|
#define FMTAVAIL_TYPE_DVDRAM 0x2
|
|
#define FMTAVAIL_TYPE_GPT 0x4
|
|
#define FMTAVAIL_TYPE_MEMSTICK 0x8
|
|
#define FMTAVAIL_TYPE_NTFS_BLOCKED 0x10
|
|
|
|
typedef struct _FMTAVAIL
|
|
{
|
|
DWORD dwfs;
|
|
DWORD dwMask;
|
|
DWORD dwForbiddenTypes;
|
|
ULONGLONG qMinSize;
|
|
ULONGLONG qMaxSize;
|
|
} FMTAVAIL;
|
|
|
|
FMTAVAIL rgFmtAvail[] = {
|
|
{e_FAT, FMTAVAIL_MASK_MAX | FMTAVAIL_MASK_FORBID, FMTAVAIL_TYPE_DVDRAM | FMTAVAIL_TYPE_GPT, 0, ((ULONGLONG)2 * GIG_INBYTES) },
|
|
{e_FAT32, FMTAVAIL_MASK_MIN | FMTAVAIL_MASK_MAX | FMTAVAIL_MASK_FORBID, FMTAVAIL_TYPE_GPT | FMTAVAIL_TYPE_FLOPPY | FMTAVAIL_TYPE_MEMSTICK, FAT32_MIN, ((ULONGLONG)32 * GIG_INBYTES) },
|
|
{e_NTFS, FMTAVAIL_MASK_FORBID, FMTAVAIL_TYPE_DVDRAM | FMTAVAIL_TYPE_FLOPPY | FMTAVAIL_TYPE_MEMSTICK | FMTAVAIL_TYPE_NTFS_BLOCKED, 0, 0 }
|
|
};
|
|
|
|
// is a particular disk format available for a drive with given parameters and capacity?
|
|
BOOL FormatAvailable (DWORD dwfs, FORMATINFO* pFormatInfo, ULONGLONG* pqwCapacity)
|
|
{
|
|
BOOL fAvailable = TRUE;
|
|
DWORD dwType = 0;
|
|
|
|
if (pFormatInfo->fIsFloppy)
|
|
{
|
|
dwType |= FMTAVAIL_TYPE_FLOPPY;
|
|
}
|
|
if (IsDVDRAMMedia(pFormatInfo->drive))
|
|
{
|
|
dwType |= FMTAVAIL_TYPE_DVDRAM;
|
|
}
|
|
if (IsGPTDrive(pFormatInfo->drive))
|
|
{
|
|
dwType |= FMTAVAIL_TYPE_GPT;
|
|
}
|
|
if (pFormatInfo->fIsMemoryStick)
|
|
{
|
|
dwType |= FMTAVAIL_TYPE_MEMSTICK;
|
|
}
|
|
if (pFormatInfo->fIsNTFSBlocked)
|
|
{
|
|
dwType |= FMTAVAIL_TYPE_NTFS_BLOCKED;
|
|
}
|
|
|
|
for (int i = 0; i < ARRAYSIZE(rgFmtAvail); i++)
|
|
{
|
|
// check only entries that match the format we're looking for
|
|
if (rgFmtAvail[i].dwfs == dwfs)
|
|
{
|
|
// if a failure conditions is true, then this format is unavailable
|
|
if ((rgFmtAvail[i].dwMask & FMTAVAIL_MASK_FORBID) && (rgFmtAvail[i].dwForbiddenTypes & dwType))
|
|
{
|
|
fAvailable = FALSE;
|
|
break;
|
|
}
|
|
|
|
if ((rgFmtAvail[i].dwMask & FMTAVAIL_MASK_MIN) && (*pqwCapacity < rgFmtAvail[i].qMinSize))
|
|
{
|
|
fAvailable = FALSE;
|
|
break;
|
|
}
|
|
|
|
if ((rgFmtAvail[i].dwMask & FMTAVAIL_MASK_MAX) && (*pqwCapacity > rgFmtAvail[i].qMaxSize))
|
|
{
|
|
fAvailable = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return fAvailable;
|
|
}
|
|
|
|
HRESULT GetPartitionSizeInBytes(int iDrive, ULONGLONG* pqwPartitionSize)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HANDLE hFile;
|
|
TCHAR szDrive[] = TEXT("\\\\.\\A:");
|
|
|
|
*pqwPartitionSize = 0;
|
|
|
|
ASSERT(iDrive < 26);
|
|
szDrive[4] += (TCHAR)iDrive;
|
|
|
|
hFile = CreateFile(szDrive, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (INVALID_HANDLE_VALUE != hFile)
|
|
{
|
|
GET_LENGTH_INFORMATION LengthInfo;
|
|
DWORD cbReturned;
|
|
|
|
if (DeviceIoControl(hFile, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, (void*)&LengthInfo, sizeof(LengthInfo), &cbReturned, NULL) &&
|
|
LengthInfo.Length.QuadPart)
|
|
{
|
|
*pqwPartitionSize = LengthInfo.Length.QuadPart;
|
|
hr = S_OK;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// this helper function adds a string to a combo box with the associated dword (dwfs) as its itemdata
|
|
void _AddFSString(HWND hwndCB, WCHAR* pwsz, DWORD dwfs)
|
|
{
|
|
int iIndex = ComboBox_AddString(hwndCB, pwsz);
|
|
if (iIndex != CB_ERR)
|
|
{
|
|
ComboBox_SetItemData(hwndCB, iIndex, dwfs);
|
|
}
|
|
}
|
|
|
|
// We only support formatting these types of devices
|
|
const FMIFS_MEDIA_TYPE rgFmtSupported[] = { FmMediaRemovable, FmMediaFixed,
|
|
FmMediaF3_1Pt44_512, FmMediaF3_120M_512, FmMediaF3_200Mb_512};
|
|
|
|
//
|
|
// Synopsis: Initializes the format dialog to a default state. Examines
|
|
// the disk/partition to obtain default values.
|
|
//
|
|
// Arguments: [hDlg] -- Handle to the format dialog
|
|
// [pFormatInfo] -- Describes current format session
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
HRESULT InitializeFormatDlg(FORMATINFO *pFormatInfo)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG cMedia;
|
|
HWND hCapacityCombo;
|
|
HWND hFilesystemCombo;
|
|
HWND hDlg = pFormatInfo->hDlg;
|
|
WCHAR wszBuffer[256];
|
|
ULONGLONG qwCapacity = 0;
|
|
|
|
// Set up some typical default values
|
|
pFormatInfo->fEnableComp = FALSE;
|
|
pFormatInfo->dwClusterSize = 0;
|
|
pFormatInfo->fIsFloppy = TRUE;
|
|
pFormatInfo->fIsMemoryStick = FALSE;
|
|
pFormatInfo->fIsNTFSBlocked = FALSE;
|
|
pFormatInfo->fIs35HDFloppy = TRUE;
|
|
pFormatInfo->fWasFAT = TRUE;
|
|
pFormatInfo->fFinishedOK = FALSE;
|
|
pFormatInfo->fErrorAlready = FALSE;
|
|
pFormatInfo->wszVolName[0] = L'\0';
|
|
|
|
// Initialize the Quick Format checkbox based on option passed to the SHFormatDrive() API
|
|
Button_SetCheck(GetDlgItem(hDlg, IDC_QFCHECK), pFormatInfo->options & SHFMT_OPT_FULL);
|
|
|
|
// Set the dialog title to indicate which drive we are dealing with
|
|
PathBuildRootW(pFormatInfo->wszDriveName, pFormatInfo->drive);
|
|
SetDriveWindowTitle(pFormatInfo->hDlg, pFormatInfo->wszDriveName, IDS_FMT_FORMAT);
|
|
|
|
// Query the supported media types for the drive in question
|
|
if (!pFormatInfo->fmifs.QuerySupportedMedia(pFormatInfo->wszDriveName,
|
|
pFormatInfo->rgMedia,
|
|
ARRAYSIZE(pFormatInfo->rgMedia),
|
|
&cMedia))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
// For each of the formats that the drive can handle, add a selection
|
|
// to the capcity combobox.
|
|
if (S_OK == hr)
|
|
{
|
|
UINT olderror;
|
|
ULONG i;
|
|
ULONG j;
|
|
|
|
hCapacityCombo = GetDlgItem(hDlg, IDC_CAPCOMBO);
|
|
hFilesystemCombo = GetDlgItem(hDlg, IDC_FSCOMBO);
|
|
|
|
ASSERT(hCapacityCombo && hFilesystemCombo);
|
|
|
|
FMIFS_DEVICE_INFORMATION fmifsdeviceinformation;
|
|
BOOL fOk = pFormatInfo->fmifs.QueryDeviceInformation(
|
|
pFormatInfo->wszDriveName,
|
|
&fmifsdeviceinformation,
|
|
sizeof(fmifsdeviceinformation));
|
|
|
|
if (fOk)
|
|
{
|
|
if (fmifsdeviceinformation.Flags & FMIFS_SONY_MS)
|
|
{
|
|
pFormatInfo->fIsMemoryStick = TRUE;
|
|
}
|
|
|
|
if (fmifsdeviceinformation.Flags & FMIFS_NTFS_NOT_SUPPORTED)
|
|
{
|
|
pFormatInfo->fIsNTFSBlocked = TRUE;
|
|
}
|
|
}
|
|
|
|
// Allow only certain media types
|
|
j = 0;
|
|
for (i = 0; i < cMedia; i++)
|
|
{
|
|
for (int k = 0; k < ARRAYSIZE(rgFmtSupported); k++)
|
|
{
|
|
if (pFormatInfo->rgMedia[i] == rgFmtSupported[k])
|
|
{
|
|
pFormatInfo->rgMedia[j] = pFormatInfo->rgMedia[i];
|
|
j++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
cMedia = j;
|
|
|
|
if (0 == cMedia)
|
|
{
|
|
hr = ERROR_UNRECOGNIZED_MEDIA;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < cMedia; i++)
|
|
{
|
|
// If we find any non-floppy format, clear the fIsFloppy flag
|
|
if (FmMediaFixed == pFormatInfo->rgMedia[i] || FmMediaRemovable == pFormatInfo->rgMedia[i])
|
|
{
|
|
pFormatInfo->fIsFloppy = FALSE;
|
|
}
|
|
|
|
// if we find any non-3.5" HD floppy format, clear the fIs35HDFloppy flag
|
|
if (FmMediaF3_1Pt44_512 != pFormatInfo->rgMedia[i])
|
|
{
|
|
pFormatInfo->fIs35HDFloppy = FALSE;
|
|
}
|
|
|
|
// For fixed media we query the size, for floppys we present
|
|
// a set of options supported by the drive
|
|
if (FmMediaFixed == pFormatInfo->rgMedia[i] || (FmMediaRemovable == pFormatInfo->rgMedia[i]))
|
|
{
|
|
DWORD dwSectorsPerCluster,
|
|
dwBytesPerSector,
|
|
dwFreeClusters,
|
|
dwClusters;
|
|
|
|
if (SUCCEEDED(GetPartitionSizeInBytes(pFormatInfo->drive, &qwCapacity)))
|
|
{
|
|
// Add a capacity desciption to the combobox
|
|
ShortSizeFormat64(qwCapacity, wszBuffer, ARRAYSIZE(wszBuffer));
|
|
}
|
|
else
|
|
{
|
|
// Couldn't get the free space... prob. not fatal
|
|
LoadString(HINST_THISDLL, IDS_FMT_CAPUNKNOWN, wszBuffer, sizeof(wszBuffer));
|
|
}
|
|
ComboBox_AddString(hCapacityCombo, wszBuffer);
|
|
|
|
if (GetDiskFreeSpace(pFormatInfo->wszDriveName,
|
|
&dwSectorsPerCluster,
|
|
&dwBytesPerSector,
|
|
&dwFreeClusters,
|
|
&dwClusters))
|
|
{
|
|
pFormatInfo->dwClusterSize = dwBytesPerSector * dwSectorsPerCluster;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// removable media:
|
|
//
|
|
// add a capacity desciption to the combo baseed on the sequential list of
|
|
// media format descriptors
|
|
LoadString(HINST_THISDLL, IDS_FMT_MEDIA0 + pFormatInfo->rgMedia[i], wszBuffer, ARRAYSIZE(wszBuffer));
|
|
ComboBox_AddString(hCapacityCombo, wszBuffer);
|
|
}
|
|
}
|
|
|
|
|
|
// set capacity to default
|
|
ComboBox_SetCurSel(hCapacityCombo, 0);
|
|
|
|
// Add the appropriate filesystem selections to the combobox
|
|
// We now prioritize NTFS
|
|
if (FormatAvailable(e_NTFS, pFormatInfo, &qwCapacity))
|
|
{
|
|
_AddFSString(hFilesystemCombo, FS_STR_NTFS, e_NTFS);
|
|
}
|
|
|
|
if (FormatAvailable(e_FAT32, pFormatInfo, &qwCapacity))
|
|
{
|
|
|
|
_AddFSString(hFilesystemCombo, FS_STR_FAT32, e_FAT32);
|
|
}
|
|
|
|
if (FormatAvailable(e_FAT, pFormatInfo, &qwCapacity))
|
|
{
|
|
_AddFSString(hFilesystemCombo, FS_STR_FAT, e_FAT);
|
|
}
|
|
|
|
// By default, pick the 0-th entry in the _nonsorted_ combobox.
|
|
// NOTE: this can be overwritten below
|
|
ComboBox_SetCurSel(hFilesystemCombo, 0);
|
|
|
|
// If we can determine something other than FAT is being used,
|
|
// select it as the default in the combobox
|
|
olderror = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
if (GetVolumeInformation(pFormatInfo->wszDriveName,
|
|
pFormatInfo->wszVolName,
|
|
ARRAYSIZE(pFormatInfo->wszVolName),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
wszBuffer,
|
|
ARRAYSIZE(wszBuffer)))
|
|
{
|
|
// If we got a current volume label, stuff it in the edit control
|
|
if (pFormatInfo->wszVolName[0] != L'\0')
|
|
{
|
|
SetWindowText(GetDlgItem(pFormatInfo->hDlg, IDC_VLABEL), pFormatInfo->wszVolName);
|
|
}
|
|
|
|
// for non-floppies we default to keeping the FS the same as the current one
|
|
if (!pFormatInfo->fIsFloppy)
|
|
{
|
|
if (0 == lstrcmpi(FS_STR_NTFS, wszBuffer))
|
|
{
|
|
ComboBox_SelectString(hFilesystemCombo, -1, FS_STR_NTFS);
|
|
pFormatInfo->fWasFAT = FALSE;
|
|
}
|
|
else if (0 == lstrcmpi(FS_STR_FAT32, wszBuffer))
|
|
{
|
|
ComboBox_SelectString(hFilesystemCombo, -1, FS_STR_FAT32);
|
|
pFormatInfo->fWasFAT = TRUE;
|
|
pFormatInfo->dwClusterSize = 0;
|
|
}
|
|
else
|
|
{
|
|
ComboBox_SelectString(hFilesystemCombo, -1, FS_STR_FAT);
|
|
pFormatInfo->fWasFAT = TRUE;
|
|
pFormatInfo->dwClusterSize = 0;
|
|
}
|
|
}
|
|
// FEATURE - What about specialized file-systems? Don't care for now.
|
|
}
|
|
|
|
|
|
#ifndef _WIN64
|
|
// if not WIN64, enable boot-disk creation if we are a 3.5" HD floppy
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_BTCHECK), pFormatInfo->fIs35HDFloppy);
|
|
#else
|
|
// if WIN64, hide this option, since we can't use these boot floppies on WIN64
|
|
ShowWindow(GetDlgItem(pFormatInfo->hDlg, IDC_BTCHECK), FALSE);
|
|
#endif
|
|
|
|
|
|
// restore the old errormode
|
|
SetErrorMode(olderror);
|
|
|
|
// set the state of the chkboxes properly based on the FS chosen
|
|
FileSysChange((FILESYSENUM)ComboBox_GetItemData(hFilesystemCombo, ComboBox_GetCurSel(hFilesystemCombo)), pFormatInfo);
|
|
}
|
|
}
|
|
|
|
// If the above failed due to disk not in drive, notify the user
|
|
if (FAILED(hr))
|
|
{
|
|
switch (HRESULT_CODE(hr))
|
|
{
|
|
case ERROR_UNRECOGNIZED_MEDIA:
|
|
ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_UNFORMATTABLE_DISK),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK,
|
|
NULL);
|
|
|
|
break;
|
|
|
|
case ERROR_NOT_READY:
|
|
ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_DRIVENOTREADY),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK,
|
|
pFormatInfo->wszDriveName[0]);
|
|
break;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_ACCESSDENIED),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK,
|
|
pFormatInfo->wszDriveName[0]);
|
|
break;
|
|
|
|
case ERROR_WRITE_PROTECT:
|
|
ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_WRITEPROTECTED),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK,
|
|
pFormatInfo->wszDriveName[0]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Synopsis: Called from within the FMIFS DLL's Format function, this
|
|
// updates the format dialog's status bar and responds to
|
|
// format completion/error notifications.
|
|
//
|
|
// Arguments: [PacketType] -- Type of packet (ie: % complete, error, etc)
|
|
// [PacketLength] -- Size, in bytes, of the packet
|
|
// [pPacketData] -- Pointer to the packet
|
|
//
|
|
// Returns: BOOLEAN continuation value
|
|
//
|
|
BOOLEAN FormatCallback(FMIFS_PACKET_TYPE PacketType, ULONG PacketLength, void *pPacketData)
|
|
{
|
|
UINT iMessageID = IDS_FORMATFAILED;
|
|
BOOL fFailed = FALSE;
|
|
FORMATINFO* pFormatInfo = GetFormatInfoPtr();
|
|
|
|
ASSERT(g_iTLSFormatInfo);
|
|
|
|
// Grab the FORMATINFO structure for this thread
|
|
if (pFormatInfo)
|
|
{
|
|
if (!pFormatInfo->fShouldCancel)
|
|
{
|
|
switch(PacketType)
|
|
{
|
|
case FmIfsIncompatibleFileSystem:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_INCOMPATIBLEFS;
|
|
break;
|
|
|
|
case FmIfsIncompatibleMedia:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_INCOMPATIBLEMEDIA;
|
|
break;
|
|
|
|
case FmIfsAccessDenied:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_ACCESSDENIED;
|
|
break;
|
|
|
|
case FmIfsMediaWriteProtected:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_WRITEPROTECTED;
|
|
break;
|
|
|
|
case FmIfsCantLock:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_CANTLOCK;
|
|
break;
|
|
|
|
case FmIfsCantQuickFormat:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_CANTQUICKFORMAT;
|
|
break;
|
|
|
|
case FmIfsIoError:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_IOERROR;
|
|
// FUTURE Consider showing head/track etc where error was
|
|
break;
|
|
|
|
case FmIfsBadLabel:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_BADLABEL;
|
|
break;
|
|
|
|
case FmIfsPercentCompleted:
|
|
{
|
|
FMIFS_PERCENT_COMPLETE_INFORMATION * pPercent =
|
|
(FMIFS_PERCENT_COMPLETE_INFORMATION *) pPacketData;
|
|
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_FMTPROGRESS,
|
|
PBM_SETPOS,
|
|
pPercent->PercentCompleted, 0);
|
|
}
|
|
break;
|
|
|
|
case FmIfsFinished:
|
|
{
|
|
// Format is done; check for failure or success
|
|
FMIFS_FINISHED_INFORMATION* pFinishedInfo = (FMIFS_FINISHED_INFORMATION*)pPacketData;
|
|
|
|
pFormatInfo->fFinishedOK = pFinishedInfo->Success;
|
|
|
|
if (pFinishedInfo->Success)
|
|
{
|
|
// fmifs will "succeed" even if we already failed, so we need to double-check
|
|
// that we haven't already put up error UI
|
|
if (!pFormatInfo->fErrorAlready)
|
|
{
|
|
// If "Enable Compression" is checked, try to enable filesystem compression
|
|
if (IsDlgButtonChecked(pFormatInfo->hDlg, IDC_ECCHECK))
|
|
{
|
|
if (pFormatInfo->fmifs.EnableVolumeCompression(pFormatInfo->wszDriveName,
|
|
COMPRESSION_FORMAT_DEFAULT) == FALSE)
|
|
{
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pFormatInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_CANTENABLECOMP),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONINFORMATION | MB_OK);
|
|
}
|
|
}
|
|
|
|
// Even though its a quick format, the progress meter should
|
|
// show 100% when the "Format Complete" requester is up
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_FMTPROGRESS,
|
|
PBM_SETPOS,
|
|
100, // set %100 Complete
|
|
0);
|
|
|
|
// FUTURE Consider showing format stats, ie: ser no, bytes, etc
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pFormatInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_FORMATCOMPLETE),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONINFORMATION | MB_OK);
|
|
}
|
|
|
|
// Restore the dialog title, reset progress and flags
|
|
SendDlgItemMessage(pFormatInfo->hDlg,
|
|
IDC_FMTPROGRESS,
|
|
PBM_SETPOS,
|
|
0, // Reset Percent Complete
|
|
0);
|
|
|
|
// Set the focus onto the Close button
|
|
pFormatInfo->fCancelled = FALSE;
|
|
}
|
|
else
|
|
{
|
|
fFailed = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (fFailed && !pFormatInfo->fErrorAlready)
|
|
{
|
|
// If we received any kind of failure information, put up a final
|
|
// "Format Failed" message. UNLESS we've already put up some nice message
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pFormatInfo->hDlg,
|
|
MAKEINTRESOURCE(iMessageID),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
pFormatInfo->fErrorAlready = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// user hit cancel
|
|
pFormatInfo->fCancelled = TRUE;
|
|
fFailed = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no pFormatInfo? we're screwed
|
|
fFailed = TRUE;
|
|
}
|
|
|
|
return (BOOLEAN) (fFailed == FALSE);
|
|
}
|
|
|
|
//
|
|
// Synopsis: Spun off as its own thread, this ghosts all controls in the
|
|
// dialog except "Cancel", then does the actual format
|
|
//
|
|
// Arguments: [pIn] -- FORMATINFO structure pointer as a void *
|
|
//
|
|
// Returns: HRESULT thread exit code
|
|
//
|
|
DWORD WINAPI BeginFormat(void * pIn)
|
|
{
|
|
FORMATINFO *pFormatInfo = (FORMATINFO*)pIn;
|
|
HRESULT hr = S_OK;
|
|
|
|
// Save the FORAMTINFO ptr for this thread, to be used in the format
|
|
// callback function
|
|
hr = StuffFormatInfoPtr(pFormatInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
HWND hwndFileSysCB = GetDlgItem(pFormatInfo->hDlg, IDC_FSCOMBO);
|
|
int iCurSel;
|
|
|
|
// Set the window title to indicate format in proress...
|
|
SetDriveWindowTitle(pFormatInfo->hDlg, pFormatInfo->wszDriveName, IDS_FMT_FORMATTING);
|
|
|
|
// Determine the user's choice of filesystem
|
|
iCurSel = ComboBox_GetCurSel(hwndFileSysCB);
|
|
|
|
if (iCurSel != CB_ERR)
|
|
{
|
|
LPCWSTR pwszFileSystemName;
|
|
FMIFS_MEDIA_TYPE MediaType;
|
|
LPITEMIDLIST pidlFormat;
|
|
BOOLEAN fQuickFormat;
|
|
|
|
FILESYSENUM fseType = (FILESYSENUM)ComboBox_GetItemData(hwndFileSysCB, iCurSel);
|
|
|
|
switch (fseType)
|
|
{
|
|
case e_FAT:
|
|
pwszFileSystemName = FS_STR_FAT;
|
|
break;
|
|
|
|
case e_FAT32:
|
|
pwszFileSystemName = FS_STR_FAT32;
|
|
break;
|
|
|
|
case e_NTFS:
|
|
pwszFileSystemName = FS_STR_NTFS;
|
|
break;
|
|
}
|
|
|
|
// Determine the user's choice of media formats
|
|
iCurSel = ComboBox_GetCurSel(GetDlgItem(pFormatInfo->hDlg, IDC_CAPCOMBO));
|
|
if (iCurSel == CB_ERR)
|
|
{
|
|
iCurSel = 0;
|
|
}
|
|
MediaType = pFormatInfo->rgMedia[iCurSel];
|
|
|
|
// Get the cluster size. First selection ("Use Default") yields a zero,
|
|
// while the next 4 select 512, 1024, 2048, or 4096
|
|
iCurSel = ComboBox_GetCurSel(GetDlgItem(pFormatInfo->hDlg, IDC_ASCOMBO));
|
|
if ((iCurSel == CB_ERR) || (iCurSel == 0))
|
|
{
|
|
pFormatInfo->dwClusterSize = 0;
|
|
}
|
|
else
|
|
{
|
|
pFormatInfo->dwClusterSize = 256 << iCurSel;
|
|
}
|
|
|
|
// Quickformatting?
|
|
fQuickFormat = Button_GetCheck(GetDlgItem(pFormatInfo->hDlg, IDC_QFCHECK));
|
|
|
|
// Clear the error state.
|
|
pFormatInfo->fErrorAlready = FALSE;
|
|
|
|
// Tell the shell to get ready... Announce that the media is no
|
|
// longer valid (so people who have active views on it will navigate
|
|
// away) and tell the shell to close its FindFirstChangeNotifications.
|
|
if (SUCCEEDED(SHILCreateFromPath(pFormatInfo->wszDriveName, &pidlFormat, NULL)))
|
|
{
|
|
SHChangeNotify(SHCNE_MEDIAREMOVED, SHCNF_IDLIST | SHCNF_FLUSH, pidlFormat, 0);
|
|
SHChangeNotifySuspendResume(TRUE, pidlFormat, TRUE, 0);
|
|
}
|
|
else
|
|
{
|
|
pidlFormat = NULL;
|
|
}
|
|
|
|
if (!pFormatInfo->fMakeBootDisk)
|
|
{
|
|
// Do the format.
|
|
pFormatInfo->fmifs.FormatEx(pFormatInfo->wszDriveName,
|
|
MediaType,
|
|
(PWSTR)pwszFileSystemName,
|
|
pFormatInfo->wszVolName,
|
|
fQuickFormat,
|
|
pFormatInfo->dwClusterSize,
|
|
FormatCallback);
|
|
}
|
|
else
|
|
{
|
|
pFormatInfo->diskcopy.MakeBootDisk(pFormatInfo->diskcopy.hDISKCOPY_DLL, pFormatInfo->drive, &pFormatInfo->fCancelled, FormatCallback);
|
|
}
|
|
|
|
// Wake the shell back up.
|
|
if (pidlFormat)
|
|
{
|
|
SHChangeNotifySuspendResume(FALSE, pidlFormat, TRUE, 0);
|
|
ILFree(pidlFormat);
|
|
}
|
|
|
|
// Success or failure, we should fire a notification on the disk
|
|
// since we don't really know the state after the format
|
|
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATHW, (void *)pFormatInfo->wszDriveName, NULL);
|
|
}
|
|
else
|
|
{
|
|
// couldn't get the filesys CB selection
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
// Release the TLS index
|
|
UnstuffFormatInfoPtr();
|
|
}
|
|
|
|
// Post a message back to the DialogProc thread to let it know
|
|
// the format is done. We post the message since otherwise the
|
|
// DialogProc thread will be too busy waiting for this thread
|
|
// to exit to be able to process the PWM_FORMATDONE message
|
|
// immediately.
|
|
PostMessage(pFormatInfo->hDlg, (UINT) PWM_FORMATDONE, 0, 0);
|
|
|
|
ReleaseFormatInfo(pFormatInfo);
|
|
|
|
return (DWORD)hr;
|
|
}
|
|
|
|
BOOL_PTR CALLBACK FormatDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int iID = GET_WM_COMMAND_ID(wParam, lParam);
|
|
int iCMD = GET_WM_COMMAND_CMD(wParam, lParam);
|
|
|
|
// Grab our previously cached pointer to the FORMATINFO struct (see WM_INITDIALOG)
|
|
FORMATINFO *pFormatInfo = (FORMATINFO *) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
switch (wMsg)
|
|
{
|
|
case PWM_FORMATDONE:
|
|
// Format is done. Reset the window title and clear the progress meter
|
|
SetDriveWindowTitle(pFormatInfo->hDlg, pFormatInfo->wszDriveName, IDS_FMT_FORMAT);
|
|
SendDlgItemMessage(pFormatInfo->hDlg, IDC_FMTPROGRESS, PBM_SETPOS, 0 /* Reset Percent Complete */, 0);
|
|
EnableControls(pFormatInfo, TRUE);
|
|
|
|
if (pFormatInfo->fCancelled)
|
|
{
|
|
// Don't put up UI if the background thread finally finished
|
|
// long after the user issued the cancel
|
|
if (!pFormatInfo->fShouldCancel)
|
|
{
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pFormatInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_FORMATCANCELLED),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
pFormatInfo->fCancelled = FALSE;
|
|
}
|
|
|
|
if (pFormatInfo->hThread)
|
|
{
|
|
CloseHandle(pFormatInfo->hThread);
|
|
pFormatInfo->hThread = NULL;
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
// Initialize the dialog and cache the FORMATINFO structure's pointer
|
|
// as our dialog's DWLP_USER data
|
|
pFormatInfo = (FORMATINFO *) lParam;
|
|
pFormatInfo->hDlg = hDlg;
|
|
if (FAILED(InitializeFormatDlg(pFormatInfo)))
|
|
{
|
|
EndDialog(hDlg, 0);
|
|
return -1;
|
|
}
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
if (pFormatInfo && pFormatInfo->hDlg)
|
|
{
|
|
pFormatInfo->hDlg = NULL;
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if (iCMD == CBN_SELCHANGE)
|
|
{
|
|
// User made a selection in one of the combo boxes
|
|
if (iID == IDC_FSCOMBO)
|
|
{
|
|
// User selected a filesystem... update the rest of the dialog
|
|
// based on this choice
|
|
HWND hFilesystemCombo = (HWND)lParam;
|
|
int iCurSel = ComboBox_GetCurSel(hFilesystemCombo);
|
|
|
|
FileSysChange((FILESYSENUM)ComboBox_GetItemData(hFilesystemCombo, iCurSel), pFormatInfo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Codepath for controls other than combo boxes...
|
|
switch (iID)
|
|
{
|
|
case IDC_BTCHECK:
|
|
pFormatInfo->fMakeBootDisk = IsDlgButtonChecked(pFormatInfo->hDlg, IDC_BTCHECK);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_CAPCOMBO), !pFormatInfo->fMakeBootDisk);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_FSCOMBO), !pFormatInfo->fMakeBootDisk);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_ASCOMBO), !pFormatInfo->fMakeBootDisk);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_VLABEL), !pFormatInfo->fMakeBootDisk);
|
|
EnableWindow(GetDlgItem(pFormatInfo->hDlg, IDC_QFCHECK), !pFormatInfo->fMakeBootDisk);
|
|
break;
|
|
case IDC_ECCHECK:
|
|
pFormatInfo->fEnableComp = IsDlgButtonChecked(hDlg, IDC_ECCHECK);
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
// Get user verification for format, break out on CANCEL
|
|
if (IDCANCEL == ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_OKTOFORMAT),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OKCANCEL))
|
|
{
|
|
break;
|
|
}
|
|
|
|
ASSERT(pFormatInfo->hThread == NULL);
|
|
|
|
DisableControls(pFormatInfo);
|
|
pFormatInfo->fCancelled = FALSE;
|
|
pFormatInfo->fShouldCancel = FALSE;
|
|
GetWindowText(GetDlgItem(pFormatInfo->hDlg, IDC_VLABEL), pFormatInfo->wszVolName, MAX_PATH);
|
|
|
|
AddRefFormatInfo(pFormatInfo);
|
|
pFormatInfo->hThread = CreateThread(NULL,
|
|
0,
|
|
BeginFormat,
|
|
(void *)pFormatInfo,
|
|
0,
|
|
NULL);
|
|
if (!pFormatInfo->hThread)
|
|
{
|
|
// ISSUE: we should probably do something...
|
|
ReleaseFormatInfo(pFormatInfo);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
// If the format thread is running, wait for it. If not,
|
|
// exit the dialog
|
|
pFormatInfo->fShouldCancel = TRUE;
|
|
if (pFormatInfo->hThread)
|
|
{
|
|
DWORD dwWait;
|
|
|
|
do
|
|
{
|
|
dwWait = WaitForSingleObject(pFormatInfo->hThread, 10000);
|
|
}
|
|
while ((WAIT_TIMEOUT == dwWait) &&
|
|
(IDRETRY == ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_CANTCANCELFMT),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_RETRYCANCEL)));
|
|
|
|
// If the format doesn't admit to having been killed, it didn't
|
|
// give up peacefully. Just abandon it and let it clean up
|
|
// when it finally gets around to it, at which point we will
|
|
// enable the OK button to let the user take another stab.
|
|
//
|
|
// Careful: The format may have cleaned up while the dialog box
|
|
// was up, so revalidate.
|
|
if (pFormatInfo->hThread)
|
|
{
|
|
CloseHandle(pFormatInfo->hThread);
|
|
pFormatInfo->hThread = NULL;
|
|
pFormatInfo->fCancelled = TRUE;
|
|
EnableControls(pFormatInfo, FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EndDialog(hDlg, IDCANCEL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_HELP:
|
|
WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR) (LPSTR) FmtaIds);
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR) (LPSTR) FmtaIds);
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Synopsis: The SHFormatDrive API provides access to the Shell
|
|
// format dialog. This allows apps which want to format disks
|
|
// to bring up the same dialog that the Shell does to do it.
|
|
//
|
|
// NOTE that the user can format as many diskettes in the
|
|
// specified drive, or as many times, as he/she wishes to.
|
|
//
|
|
// Arguments: [hwnd] -- Parent window (Must NOT be NULL)
|
|
// [drive] -- 0 = A:, 1 = B:, etc.
|
|
// [fmtID] -- see below
|
|
// [options] -- SHFMT_OPT_FULL overrised default quickformat
|
|
// SHFMT_OPT_SYSONLY not support for NT
|
|
//
|
|
// Returns: See Notes
|
|
//
|
|
DWORD WINAPI SHFormatDrive(HWND hwnd, UINT drive, UINT fmtID, UINT options)
|
|
{
|
|
INT_PTR ret;
|
|
FORMATINFO *pFormatInfo = (FORMATINFO *)LocalAlloc(LPTR, sizeof(*pFormatInfo));
|
|
ASSERT(drive < 26);
|
|
|
|
if (!pFormatInfo)
|
|
return SHFMT_ERROR;
|
|
|
|
HRESULT hrCoInit = SHCoInitialize();
|
|
|
|
pFormatInfo->cRef = 1;
|
|
pFormatInfo->drive = drive;
|
|
pFormatInfo->fmtID = fmtID;
|
|
pFormatInfo->options = options;
|
|
|
|
// It makes no sense for NT to "SYS" a disk
|
|
if (pFormatInfo->options & SHFMT_OPT_SYSONLY)
|
|
{
|
|
ret = 0;
|
|
goto done;
|
|
}
|
|
|
|
// Load FMIFS.DLL and DISKCOPY.DLL and open the Format dialog
|
|
if (S_OK == LoadFMIFS(&pFormatInfo->fmifs) &&
|
|
S_OK == LoadDISKCOPY(&pFormatInfo->diskcopy))
|
|
{
|
|
DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_FORMATDISK),
|
|
hwnd, FormatDlgProc, (LPARAM) pFormatInfo);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0 && "Can't load FMIFS.DLL");
|
|
ret = SHFMT_ERROR;
|
|
goto done;
|
|
}
|
|
|
|
// Since time immemorial it has been almost impossible to
|
|
// get SHFMT_CANCEL as a return code. Most of the time, you get
|
|
// SHFMT_ERROR if the user cancels.
|
|
if (pFormatInfo->fCancelled)
|
|
{
|
|
ret = SHFMT_CANCEL;
|
|
}
|
|
else if (pFormatInfo->fFinishedOK)
|
|
{
|
|
// APPCOMPAT: (stephstm) We used to say that we return the Serial
|
|
// Number but we never did. So keep on returning 0 for success.
|
|
// Furthermore, Serial number values could conflict SHFMT_*
|
|
// error codes.
|
|
ret = 0;
|
|
}
|
|
else
|
|
{
|
|
ret = SHFMT_ERROR;
|
|
}
|
|
|
|
done:
|
|
ReleaseFormatInfo(pFormatInfo);
|
|
SHCoUninitialize(hrCoInit);
|
|
return (DWORD)ret;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CHKDSK
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// This structure described the current chkdsk session
|
|
//
|
|
typedef struct
|
|
{
|
|
UINT lastpercent; // last percentage complete received
|
|
UINT currentphase; // current chkdsk phase
|
|
FMIFS fmifs; // ptr to FMIFS structure, above
|
|
BOOL fRecovery; // Attempt to recover bad sectors
|
|
BOOL fFixErrors; // Fix filesystem errors as found
|
|
BOOL fCancelled; // Was chkdsk terminated early?
|
|
BOOL fShouldCancel; // User has clicked cancel; pending abort
|
|
HWND hDlg; // handle to the chkdsk dialog
|
|
HANDLE hThread;
|
|
BOOL fNoFinalMsg; // Do not put up a final failure message
|
|
WCHAR wszDriveName[MAX_PATH]; // For example, "A:\", or "C:\folder\mountedvolume\"
|
|
LONG cRef; // reference count on this structure
|
|
} CHKDSKINFO;
|
|
|
|
void AddRefChkDskInfo(CHKDSKINFO *pChkDskInfo)
|
|
{
|
|
InterlockedIncrement(&pChkDskInfo->cRef);
|
|
}
|
|
|
|
void ReleaseChkDskInfo(CHKDSKINFO *pChkDskInfo)
|
|
{
|
|
if (InterlockedDecrement(&pChkDskInfo->cRef) == 0)
|
|
{
|
|
if (pChkDskInfo->fmifs.hFMIFS_DLL)
|
|
{
|
|
FreeLibrary(pChkDskInfo->fmifs.hFMIFS_DLL);
|
|
}
|
|
|
|
if (pChkDskInfo->hThread)
|
|
{
|
|
CloseHandle(pChkDskInfo->hThread);
|
|
}
|
|
|
|
LocalFree(pChkDskInfo);
|
|
}
|
|
}
|
|
|
|
|
|
static DWORD g_iTLSChkDskInfo = 0;
|
|
static LONG g_cTLSChkDskInfo = 0; // Usage count
|
|
|
|
//
|
|
// Synopsis: Allocates a thread-local index slot for this thread's
|
|
// CHKDSKINFO pointer, if the index doesn't already exist.
|
|
// In any event, stores the CHKDSKINFO pointer in the slot
|
|
// and increments the index's usage count.
|
|
//
|
|
// Arguments: [pChkDskInfo] -- The pointer to store
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//
|
|
// Thread-Local Storage index for our CHKDSKINFO structure pointer
|
|
//
|
|
HRESULT StuffChkDskInfoPtr(CHKDSKINFO *pChkDskInfo)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Allocate an index slot for our thread-local CHKDSKINFO pointer, if one
|
|
// doesn't already exist, then stuff our CHKDSKINFO ptr at that index.
|
|
|
|
ENTERCRITICAL;
|
|
if (0 == g_iTLSChkDskInfo)
|
|
{
|
|
g_iTLSChkDskInfo = TlsAlloc();
|
|
|
|
if (g_iTLSChkDskInfo == (DWORD)-1)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
g_cTLSChkDskInfo = 0;
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
if (TlsSetValue(g_iTLSChkDskInfo, (void *)pChkDskInfo))
|
|
{
|
|
g_cTLSChkDskInfo++;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Synopsis: Decrements the usage count on our thread-local storage
|
|
// index, and if it goes to zero the index is free'd
|
|
//
|
|
// Arguments: [none]
|
|
//
|
|
// Returns: none
|
|
//
|
|
void UnstuffChkDskInfoPtr()
|
|
{
|
|
ENTERCRITICAL;
|
|
g_cTLSChkDskInfo--;
|
|
|
|
if (g_cTLSChkDskInfo == 0)
|
|
{
|
|
TlsFree(g_iTLSChkDskInfo);
|
|
g_iTLSChkDskInfo = 0;
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
//
|
|
// Synopsis: Retrieves this threads CHKDSKINFO ptr by grabbing the
|
|
// thread-local value previously stuff'd
|
|
//
|
|
// Arguments: [none]
|
|
//
|
|
// Returns: The pointer, of course
|
|
//
|
|
CHKDSKINFO *GetChkDskInfoPtr()
|
|
{
|
|
return (CHKDSKINFO *)TlsGetValue(g_iTLSChkDskInfo);
|
|
}
|
|
|
|
//
|
|
// Synopsis: Ghosts all controls except "Cancel", saving their
|
|
// previous state in the CHKDSKINFO structure
|
|
//
|
|
// Arguments: [pChkDskInfo] -- Describes a ChkDsk dialog session
|
|
//
|
|
// Notes: Also changes "Close" button text to read "Cancel"
|
|
//
|
|
void DisableChkDskControls(CHKDSKINFO *pChkDskInfo)
|
|
{
|
|
// We disable CANCEL because CHKDSK does not
|
|
// allow interruption at the filesystem level.
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDC_FIXERRORS), FALSE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDC_RECOVERY), FALSE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDOK), FALSE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDCANCEL), FALSE);
|
|
}
|
|
|
|
//
|
|
// Synopsis: Restores controls to the enabled/disabled state they were
|
|
// before a previous call to DisableControls().
|
|
//
|
|
// Arguments: [pChkDskInfo] -- Decribes a chkdsk dialog session
|
|
//
|
|
void EnableChkDskControls(CHKDSKINFO *pChkDskInfo)
|
|
{
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDC_FIXERRORS), TRUE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDC_RECOVERY), TRUE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDOK), TRUE);
|
|
EnableWindow(GetDlgItem(pChkDskInfo->hDlg, IDCANCEL), TRUE);
|
|
|
|
// Erase the current phase text
|
|
SetWindowText(GetDlgItem(pChkDskInfo->hDlg, IDC_PHASE), TEXT(""));
|
|
pChkDskInfo->lastpercent = 101;
|
|
pChkDskInfo->currentphase = 0;
|
|
}
|
|
|
|
//
|
|
// Synopsis: Called from within the FMIFS DLL's ChkDsk function, this
|
|
// updates the ChkDsk dialog's status bar and responds to
|
|
// chkdsk completion/error notifications.
|
|
//
|
|
// Arguments: [PacketType] -- Type of packet (ie: % complete, error, etc)
|
|
// [PacketLength] -- Size, in bytes, of the packet
|
|
// [pPacketData] -- Pointer to the packet
|
|
//
|
|
// Returns: BOOLEAN continuation value
|
|
//
|
|
BOOLEAN ChkDskCallback(FMIFS_PACKET_TYPE PacketType, ULONG PacketLength, void *pPacketData)
|
|
{
|
|
UINT iMessageID = IDS_CHKDSKFAILED;
|
|
BOOL fFailed = FALSE;
|
|
CHKDSKINFO* pChkDskInfo = GetChkDskInfoPtr();
|
|
|
|
ASSERT(g_iTLSChkDskInfo);
|
|
|
|
// Grab the CHKDSKINFO structure for this thread
|
|
if (pChkDskInfo)
|
|
{
|
|
if (!pChkDskInfo->fShouldCancel)
|
|
{
|
|
switch(PacketType)
|
|
{
|
|
case FmIfsAccessDenied:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_CHKACCESSDENIED;
|
|
break;
|
|
|
|
case FmIfsCheckOnReboot:
|
|
{
|
|
FMIFS_CHECKONREBOOT_INFORMATION * pRebootInfo = (FMIFS_CHECKONREBOOT_INFORMATION *)pPacketData;
|
|
|
|
// Check to see whether or not the user wants to schedule this
|
|
// chkdsk for the next reboot, since the drive cannot be locked
|
|
// right now.
|
|
if (IDYES == ShellMessageBox(HINST_THISDLL,
|
|
pChkDskInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_CHKONREBOOT),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONINFORMATION | MB_YESNO))
|
|
{
|
|
// Yes, have FMIFS schedule an autochk for us
|
|
pRebootInfo->QueryResult = TRUE;
|
|
pChkDskInfo->fNoFinalMsg = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Nope, just fail out with "cant lock drive"
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_CHKDSKFAILED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FmIfsMediaWriteProtected:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_WRITEPROTECTED;
|
|
break;
|
|
|
|
case FmIfsIoError:
|
|
fFailed = TRUE;
|
|
iMessageID = IDS_IOERROR;
|
|
// FUTURE Consider showing head/track etc where error was
|
|
break;
|
|
|
|
case FmIfsPercentCompleted:
|
|
{
|
|
FMIFS_PERCENT_COMPLETE_INFORMATION* pPercent = (FMIFS_PERCENT_COMPLETE_INFORMATION *)pPacketData;
|
|
|
|
SendMessage(GetDlgItem(pChkDskInfo->hDlg, IDC_CHKDSKPROGRESS),
|
|
PBM_SETPOS,
|
|
pPercent->PercentCompleted, // updatee % complete
|
|
0);
|
|
|
|
if (pPercent->PercentCompleted < pChkDskInfo->lastpercent)
|
|
{
|
|
WCHAR wszTmp[100];
|
|
WCHAR wszFormat[100];
|
|
|
|
// If this % complete is less than the last one seen,
|
|
// we have completed a phase of the chkdsk and should
|
|
// advance to the next one.
|
|
LoadString(HINST_THISDLL, IDS_CHKPHASE, wszFormat, ARRAYSIZE(wszFormat));
|
|
wsprintf(wszTmp, wszFormat, ++(pChkDskInfo->currentphase));
|
|
SetDlgItemText(pChkDskInfo->hDlg, IDC_PHASE, wszTmp);
|
|
}
|
|
|
|
pChkDskInfo->lastpercent = pPercent->PercentCompleted;
|
|
}
|
|
break;
|
|
|
|
case FmIfsFinished:
|
|
{
|
|
// ChkDsk is done; check for failure or success
|
|
FMIFS_FINISHED_INFORMATION * pFinishedInfo = (FMIFS_FINISHED_INFORMATION *) pPacketData;
|
|
|
|
// ChkDskEx now return the proper success value
|
|
if (pFinishedInfo->Success)
|
|
{
|
|
// Since we're done, force the progress gauge to 100%, so we
|
|
// don't sit here if the chkdsk code misled us
|
|
SendMessage(GetDlgItem(pChkDskInfo->hDlg, IDC_CHKDSKPROGRESS),
|
|
PBM_SETPOS,
|
|
100, // Percent Complete
|
|
0);
|
|
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pChkDskInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_CHKDSKCOMPLETE),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONINFORMATION | MB_OK);
|
|
|
|
SetDlgItemText(pChkDskInfo->hDlg, IDC_PHASE, TEXT(""));
|
|
|
|
SendMessage(GetDlgItem(pChkDskInfo->hDlg, IDC_CHKDSKPROGRESS),
|
|
PBM_SETPOS,
|
|
0, // reset Percent Complete
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
iMessageID = IDS_CHKDSKFAILED;
|
|
fFailed = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// If we received any kind of failure information, put up a final
|
|
// "ChkDsk Failed" message.
|
|
if (fFailed && (pChkDskInfo->fNoFinalMsg == FALSE))
|
|
{
|
|
pChkDskInfo->fNoFinalMsg = TRUE;
|
|
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pChkDskInfo->hDlg,
|
|
MAKEINTRESOURCE(iMessageID),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// If the user has signalled to abort the ChkDsk, return
|
|
// FALSE out of here right now
|
|
pChkDskInfo->fCancelled = TRUE;
|
|
fFailed = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fFailed = TRUE;
|
|
}
|
|
|
|
return (BOOLEAN) (fFailed == FALSE);
|
|
}
|
|
|
|
void DoChkDsk(CHKDSKINFO* pChkDskInfo, LPWSTR pwszFileSystem)
|
|
{
|
|
TCHAR szVolumeGUID[50]; // 50: from doc
|
|
FMIFS_CHKDSKEX_PARAM param = {0};
|
|
|
|
param.Major = 1;
|
|
param.Minor = 0;
|
|
param.Flags = pChkDskInfo->fRecovery ? FMIFS_CHKDSK_RECOVER : 0;
|
|
|
|
GetVolumeNameForVolumeMountPoint(pChkDskInfo->wszDriveName,
|
|
szVolumeGUID,
|
|
ARRAYSIZE(szVolumeGUID));
|
|
|
|
// the backslash at the end means check for fragmentation.
|
|
PathRemoveBackslash(szVolumeGUID);
|
|
|
|
pChkDskInfo->fmifs.ChkDskEx(szVolumeGUID,
|
|
pwszFileSystem,
|
|
(BOOLEAN)pChkDskInfo->fFixErrors,
|
|
¶m,
|
|
ChkDskCallback);
|
|
}
|
|
|
|
|
|
//
|
|
// Synopsis: Spun off as its own thread, this ghosts all controls in the
|
|
// dialog except "Cancel", then does the actual ChkDsk
|
|
//
|
|
// Arguments: [pIn] -- CHKDSKINFO structure pointer as a void *
|
|
//
|
|
// Returns: HRESULT thread exit code
|
|
//
|
|
DWORD WINAPI BeginChkDsk(void * pIn)
|
|
{
|
|
CHKDSKINFO *pChkDskInfo = (CHKDSKINFO *)pIn;
|
|
HRESULT hr;
|
|
|
|
// Save the CHKDSKINFO ptr for this thread, to be used in the ChkDsk
|
|
// callback function
|
|
hr = StuffChkDskInfoPtr(pChkDskInfo);
|
|
if (hr == S_OK)
|
|
{
|
|
WCHAR swzFileSystem[MAX_PATH];
|
|
|
|
// Get the filesystem in use on the device
|
|
if (GetVolumeInformationW(pChkDskInfo->wszDriveName,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
swzFileSystem,
|
|
MAX_PATH))
|
|
{
|
|
// Set the window title to indicate ChkDsk in proress...
|
|
SetDriveWindowTitle(pChkDskInfo->hDlg, pChkDskInfo->wszDriveName, IDS_CHKINPROGRESS);
|
|
|
|
pChkDskInfo->fNoFinalMsg = FALSE;
|
|
|
|
// Should we try data recovery?
|
|
pChkDskInfo->fRecovery = IsDlgButtonChecked(pChkDskInfo->hDlg, IDC_RECOVERY);
|
|
|
|
// Should we fix filesystem errors?
|
|
pChkDskInfo->fFixErrors = IsDlgButtonChecked(pChkDskInfo->hDlg, IDC_FIXERRORS);
|
|
|
|
// just do it!
|
|
DoChkDsk(pChkDskInfo, swzFileSystem);
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
// Release the TLS index
|
|
UnstuffChkDskInfoPtr();
|
|
}
|
|
|
|
PostMessage(pChkDskInfo->hDlg, (UINT) PWM_CHKDSKDONE, 0, 0);
|
|
ReleaseChkDskInfo(pChkDskInfo);
|
|
|
|
return (DWORD)hr;
|
|
}
|
|
|
|
//
|
|
// Synopsis: DLGPROC for the chkdsk dialog
|
|
//
|
|
// Arguments: [hDlg] -- Typical
|
|
// [wMsg] -- Typical
|
|
// [wParam] -- Typical
|
|
// [lParam] -- For WM_INIT, carries the CHKDSKINFO structure
|
|
// pointer passed to DialogBoxParam() when the
|
|
// dialog was created.
|
|
//
|
|
BOOL_PTR CALLBACK ChkDskDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int iID = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
// Grab our previously cached pointer to the CHKDSKINFO struct (see WM_INITDIALOG)
|
|
CHKDSKINFO *pChkDskInfo = (CHKDSKINFO *) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
switch (wMsg)
|
|
{
|
|
// done. Reset the window title and clear the progress meter
|
|
case PWM_CHKDSKDONE:
|
|
{
|
|
// chdsk is done. Reset the window title and clear the progress meter
|
|
SetDriveWindowTitle(pChkDskInfo->hDlg, pChkDskInfo->wszDriveName, IDS_CHKDISK);
|
|
|
|
SendMessage(GetDlgItem(pChkDskInfo->hDlg,
|
|
IDC_CHKDSKPROGRESS),
|
|
PBM_SETPOS,
|
|
0, // Reset Percent Complete
|
|
0);
|
|
EnableChkDskControls(pChkDskInfo);
|
|
|
|
if (pChkDskInfo->fCancelled)
|
|
{
|
|
ShellMessageBox(HINST_THISDLL,
|
|
pChkDskInfo->hDlg,
|
|
MAKEINTRESOURCE(IDS_CHKDSKCANCELLED),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
|
|
if (pChkDskInfo->hThread)
|
|
{
|
|
CloseHandle(pChkDskInfo->hThread);
|
|
pChkDskInfo->hThread = NULL;
|
|
}
|
|
|
|
EndDialog(hDlg, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
// Initialize the dialog and cache the CHKDSKINFO structure's pointer
|
|
// as our dialog's DWLP_USER data
|
|
pChkDskInfo = (CHKDSKINFO *) lParam;
|
|
pChkDskInfo->hDlg = hDlg;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
|
|
// Set the dialog title to indicate which drive we are dealing with
|
|
SetDriveWindowTitle(pChkDskInfo->hDlg, pChkDskInfo->wszDriveName, IDS_CHKDISK);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
if (pChkDskInfo && pChkDskInfo->hDlg)
|
|
{
|
|
pChkDskInfo->hDlg = NULL;
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
switch (iID)
|
|
{
|
|
case IDC_FIXERRORS:
|
|
pChkDskInfo->fFixErrors = Button_GetCheck((HWND)lParam);
|
|
break;
|
|
|
|
case IDC_RECOVERY:
|
|
pChkDskInfo->fRecovery = Button_GetCheck((HWND)lParam);
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
// Get user verification for chkdsk, break out on CANCEL
|
|
DisableChkDskControls(pChkDskInfo);
|
|
|
|
pChkDskInfo->fShouldCancel = FALSE;
|
|
pChkDskInfo->fCancelled = FALSE;
|
|
|
|
AddRefChkDskInfo(pChkDskInfo);
|
|
pChkDskInfo->hThread = CreateThread(NULL,
|
|
0,
|
|
BeginChkDsk,
|
|
(void *)pChkDskInfo,
|
|
0,
|
|
NULL);
|
|
if (!pChkDskInfo->hThread)
|
|
{
|
|
// ISSUE: we should probably do something here...
|
|
ReleaseChkDskInfo(pChkDskInfo);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
{
|
|
// If the chdsk thread is running, wait for it. If not,
|
|
// exit the dialog
|
|
pChkDskInfo->fCancelled = TRUE;
|
|
pChkDskInfo->fShouldCancel = TRUE;
|
|
|
|
if (pChkDskInfo->hThread)
|
|
{
|
|
DWORD dwWait;
|
|
|
|
do
|
|
{
|
|
dwWait = WaitForSingleObject(pChkDskInfo->hThread, 10000);
|
|
}
|
|
while ((WAIT_TIMEOUT == dwWait) &&
|
|
(IDRETRY == ShellMessageBox(HINST_THISDLL,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_CANTCANCELCHKDSK),
|
|
NULL,
|
|
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_RETRYCANCEL)));
|
|
|
|
// If the chkdsk doesn't admit to having been killed, it didn't
|
|
// give up peacefully. Just abandon it and let it clean up
|
|
// when it finally gets around to it, at which point we will
|
|
// enable the controls to let the user take another stab.
|
|
//
|
|
// Careful: The chkdsk may have cleaned up while the dialog box
|
|
// was up, so revalidate.
|
|
if (pChkDskInfo->hThread)
|
|
{
|
|
CloseHandle(pChkDskInfo->hThread);
|
|
pChkDskInfo->hThread = NULL;
|
|
pChkDskInfo->fCancelled = TRUE;
|
|
EnableChkDskControls(pChkDskInfo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EndDialog(hDlg, IDCANCEL);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_HELP:
|
|
WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (ULONG_PTR)(LPSTR)ChkaIds);
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(LPSTR)ChkaIds);
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#define GET_INTRESOURCE(r) (LOWORD((UINT_PTR)(r)))
|
|
|
|
static HDPA hpdaChkdskActive = NULL;
|
|
|
|
//
|
|
// Synopsis: Same as SHChkDskDrive but takes a path rather than a drive int ID
|
|
// Call this fct for both path and drive int ID to be protected
|
|
// against chkdsk'ing the same drive simultaneously
|
|
//
|
|
// Arguments: [hwnd] -- Parent window (Must NOT be NULL)
|
|
// [pszDrive] -- INTRESOURCE: string if mounted on folder, drive
|
|
// number if mounted on drive letter (0 based)
|
|
//
|
|
STDAPI_(DWORD) SHChkDskDriveEx(HWND hwnd, LPWSTR pszDrive)
|
|
{
|
|
HRESULT hr = SHFMT_ERROR;
|
|
WCHAR szUniqueID[50]; // 50: size of VolumeGUID, which can fit "A:\\" too
|
|
|
|
CHKDSKINFO *pChkDskInfo = (CHKDSKINFO *)LocalAlloc(LPTR, sizeof(*pChkDskInfo));
|
|
|
|
if (pChkDskInfo)
|
|
{
|
|
hr = S_OK;
|
|
|
|
// We use a last percentage-complete value of 101, to guarantee that the
|
|
// next one received will be less, indicating next (first) phase
|
|
pChkDskInfo->lastpercent = 101;
|
|
pChkDskInfo->cRef = 1;
|
|
|
|
lstrcpyn(pChkDskInfo->wszDriveName, pszDrive, ARRAYSIZE(pChkDskInfo->wszDriveName));
|
|
PathAddBackslash(pChkDskInfo->wszDriveName);
|
|
|
|
// Prevent multiple chkdsks of the same drive
|
|
GetVolumeNameForVolumeMountPoint(pChkDskInfo->wszDriveName, szUniqueID, ARRAYSIZE(szUniqueID));
|
|
|
|
// scoping ENTERCRITICAL's var definitions to make it cooperate with other ENTERCRITICAL
|
|
{
|
|
ENTERCRITICAL;
|
|
if (!hpdaChkdskActive)
|
|
{
|
|
hpdaChkdskActive = DPA_Create(1);
|
|
}
|
|
|
|
if (hpdaChkdskActive)
|
|
{
|
|
int i, n = DPA_GetPtrCount(hpdaChkdskActive);
|
|
|
|
// Go through the DPA of currently chkdsk'ed volumes, and check if we're already
|
|
// processing this volume
|
|
for (i = 0; i < n; ++i)
|
|
{
|
|
LPWSTR pszUniqueID = (LPWSTR)DPA_GetPtr(hpdaChkdskActive, i);
|
|
|
|
if (pszUniqueID)
|
|
{
|
|
if (!lstrcmpi(szUniqueID, pszUniqueID))
|
|
{
|
|
// we're already chkdsk'ing this drive
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Looks like we're currently not chkdsk'ing this volume, add it to the DPA of currently
|
|
// chkdsk'ed volumes
|
|
if (S_OK == hr)
|
|
{
|
|
LPWSTR pszUniqueID = StrDup(szUniqueID);
|
|
if (pszUniqueID)
|
|
{
|
|
if (-1 == DPA_AppendPtr(hpdaChkdskActive, pszUniqueID))
|
|
{
|
|
LocalFree((HLOCAL)pszUniqueID);
|
|
|
|
// if can't allocate room to store a pointer, pretty useless to go on
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// Load the FMIFS DLL and open the ChkDsk dialog
|
|
if (S_OK == hr)
|
|
{
|
|
if (S_OK == LoadFMIFS(&(pChkDskInfo->fmifs)))
|
|
{
|
|
INT_PTR ret;
|
|
INITCOMMONCONTROLSEX icc = {sizeof(icc), ICC_PROGRESS_CLASS};
|
|
InitCommonControlsEx(&icc);
|
|
|
|
ret = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_CHKDSK),
|
|
hwnd, ChkDskDlgProc, (LPARAM) pChkDskInfo);
|
|
if (-1 == ret)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
if (IDCANCEL == ret)
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0 && "Can't load FMIFS.DLL");
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
// We're finish for this volume, remove from the list of currently processed volumes
|
|
ENTERCRITICAL;
|
|
if (hpdaChkdskActive)
|
|
{
|
|
int i, n = DPA_GetPtrCount(hpdaChkdskActive);
|
|
|
|
for (i = 0; i < n; ++i)
|
|
{
|
|
LPWSTR pszUniqueID = (LPWSTR)DPA_GetPtr(hpdaChkdskActive, i);
|
|
if (pszUniqueID)
|
|
{
|
|
if (!lstrcmpi(szUniqueID, pszUniqueID))
|
|
{
|
|
LocalFree((HLOCAL)pszUniqueID);
|
|
|
|
DPA_DeletePtr(hpdaChkdskActive, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// If the DPA is empty delete it
|
|
ENTERCRITICAL;
|
|
if (hpdaChkdskActive && !DPA_GetPtrCount(hpdaChkdskActive))
|
|
{
|
|
DPA_Destroy(hpdaChkdskActive);
|
|
hpdaChkdskActive = NULL;
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
ReleaseChkDskInfo(pChkDskInfo);
|
|
}
|
|
|
|
return (DWORD) hr;
|
|
}
|
|
|
|
//****************************************************************************
|
|
//
|
|
// Special hook for Win9x app compat
|
|
//
|
|
// Some Win9x apps like to WinExec("DEFRAG") or WinExec("SCANDSKW")
|
|
// even though those apps don't exist on Windows NT. When such apps
|
|
// are found, we can shim them to come here instead.
|
|
BOOL ScanDskW_OnInitDialog(HWND hdlg)
|
|
{
|
|
HICON hico;
|
|
HWND hwndList;
|
|
SHFILEINFO sfi;
|
|
HIMAGELIST himlSys;
|
|
RECT rc;
|
|
LVCOLUMN lvc;
|
|
int iDrive;
|
|
TCHAR szDrive[4];
|
|
|
|
hico = (HICON)SendDlgItemMessage(hdlg, IDC_SCANDSKICON, STM_GETICON, 0, 0);
|
|
SendMessage(hdlg, WM_SETICON, ICON_BIG, (LPARAM)hico);
|
|
SendMessage(hdlg, WM_SETICON, ICON_SMALL, (LPARAM)hico);
|
|
|
|
hwndList = GetDlgItem(hdlg, IDC_SCANDSKLV);
|
|
|
|
if (Shell_GetImageLists(NULL, &himlSys))
|
|
{
|
|
ListView_SetImageList(hwndList, himlSys, LVSIL_SMALL);
|
|
}
|
|
|
|
GetClientRect(hwndList, &rc);
|
|
|
|
lvc.mask = LVCF_WIDTH;
|
|
lvc.cx = rc.right;
|
|
lvc.iSubItem = 0;
|
|
ListView_InsertColumn(hwndList, 0, &lvc);
|
|
|
|
for (iDrive = 0; iDrive < 26; iDrive++)
|
|
{
|
|
PathBuildRoot(szDrive, iDrive);
|
|
switch (GetDriveType(szDrive))
|
|
{
|
|
case DRIVE_UNKNOWN:
|
|
case DRIVE_NO_ROOT_DIR:
|
|
case DRIVE_REMOTE:
|
|
case DRIVE_CDROM:
|
|
break; // Can't scan these drives
|
|
|
|
default:
|
|
if (SHGetFileInfo(szDrive, FILE_ATTRIBUTE_DIRECTORY, &sfi, sizeof(sfi),
|
|
SHGFI_USEFILEATTRIBUTES |
|
|
SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_DISPLAYNAME))
|
|
{
|
|
LVITEM lvi;
|
|
lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
|
|
lvi.iItem = MAXLONG;
|
|
lvi.iSubItem = 0;
|
|
lvi.pszText = sfi.szDisplayName;
|
|
lvi.iImage = sfi.iIcon;
|
|
lvi.lParam = iDrive;
|
|
ListView_InsertItem(hwndList, &lvi);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void ScanDskW_OnOk(HWND hdlg)
|
|
{
|
|
HWND hwndList = GetDlgItem(hdlg, IDC_SCANDSKLV);
|
|
|
|
LVITEM lvi;
|
|
lvi.iItem = ListView_GetNextItem(hwndList, -1, LVNI_SELECTED);
|
|
if (lvi.iItem >= 0)
|
|
{
|
|
lvi.iSubItem = 0;
|
|
lvi.mask = LVIF_PARAM;
|
|
if (ListView_GetItem(hwndList, &lvi))
|
|
{
|
|
TCHAR szDrive[4];
|
|
PathBuildRoot(szDrive, (int)lvi.lParam);
|
|
SHChkDskDriveEx(hdlg, szDrive);
|
|
}
|
|
}
|
|
}
|
|
|
|
INT_PTR CALLBACK
|
|
ScanDskW_DlgProc(HWND hdlg, UINT wm, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (wm)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return ScanDskW_OnInitDialog(hdlg);
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDOK:
|
|
ScanDskW_OnOk(hdlg);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hdlg, 0);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
LPNMHDR pnm = (LPNMHDR)lParam;
|
|
if (pnm->code == LVN_ITEMCHANGED)
|
|
{
|
|
EnableWindow(GetDlgItem(hdlg, IDOK), ListView_GetSelectedCount(GetDlgItem(hdlg, IDC_SCANDSKLV)));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// Right now, we have only one app compat shim entry point (SCANDSKW)
|
|
// In the future we can add others to the command line.
|
|
|
|
STDAPI_(void) AppCompat_RunDLLW(HWND hwndStub, HINSTANCE hAppInstance, LPWSTR lpwszCmdLine, int nCmdShow)
|
|
{
|
|
TCHAR szCmd[MAX_PATH];
|
|
LPTSTR pszArgs;
|
|
|
|
lstrcpyn(szCmd, lpwszCmdLine, ARRAYSIZE(szCmd));
|
|
pszArgs = PathGetArgs(szCmd);
|
|
PathRemoveArgs(szCmd);
|
|
|
|
|
|
if (lstrcmpi(szCmd, L"SCANDSKW") == 0) {
|
|
DialogBoxParam(g_hinst, MAKEINTRESOURCE(IDD_SCANDSKW), NULL,
|
|
ScanDskW_DlgProc, (LPARAM)pszArgs);
|
|
}
|
|
}
|