LPWSTR
SH_FormatFileSizeWithBytes(const PULARGE_INTEGER lpQwSize, LPWSTR pwszResult, UINT cchResultMax)
{
/* Format bytes in KBs, MBs etc */
if (StrFormatByteSizeW(lpQwSize->QuadPart, pwszResult, cchResultMax) == NULL)
return NULL;
/* If there is less bytes than 1KB, we have nothing to do */
if (lpQwSize->QuadPart < 1024)
return pwszResult;
/* Concate " (" */
UINT cchWritten = wcslen(pwszResult);
LPWSTR pwszEnd = pwszResult + cchWritten;
size_t cchRemaining = cchResultMax - cchWritten;
StringCchCopyExW(pwszEnd, cchRemaining, L" (", &pwszEnd, &cchRemaining, 0);
/* Write formated bytes count */
cchWritten = SH_FormatByteSize(lpQwSize->QuadPart, pwszEnd, cchRemaining);
pwszEnd += cchWritten;
cchRemaining -= cchWritten;
/* Copy ")" to the buffer */
StringCchCopyW(pwszEnd, cchRemaining, L")");
return pwszResult;
}
VOID
UpdateLanStatusUiDlg(
HWND hwndDlg,
MIB_IFROW *IfEntry,
LANSTATUSUI_CONTEXT *pContext)
{
WCHAR szFormat[MAX_PATH] = {0};
WCHAR szBuffer[MAX_PATH] = {0};
SYSTEMTIME TimeConnected;
DWORD DurationSeconds;
WCHAR Buffer[100];
WCHAR DayBuffer[30];
WCHAR LocBuffer[50];
#if 0
ULONGLONG Ticks;
#else
DWORD Ticks;
#endif
if (IfEntry->dwSpeed < 1000)
{
if (LoadStringW(netshell_hInstance, IDS_FORMAT_BIT, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
{
swprintf(szBuffer, szFormat, IfEntry->dwSpeed);
SendDlgItemMessageW(hwndDlg, IDC_SPEED, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
}
else if (IfEntry->dwSpeed < 1000000)
{
if (LoadStringW(netshell_hInstance, IDS_FORMAT_KBIT, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
{
swprintf(szBuffer, szFormat, IfEntry->dwSpeed/1000);
SendDlgItemMessageW(hwndDlg, IDC_SPEED, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
}
else if (IfEntry->dwSpeed < 1000000000)
{
if (LoadStringW(netshell_hInstance, IDS_FORMAT_MBIT, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
{
swprintf(szBuffer, szFormat, IfEntry->dwSpeed/1000000);
SendDlgItemMessageW(hwndDlg, IDC_SPEED, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
}
else
{
if (LoadStringW(netshell_hInstance, IDS_FORMAT_GBIT, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
{
swprintf(szBuffer, szFormat, IfEntry->dwSpeed/1000000000);
SendDlgItemMessageW(hwndDlg, IDC_SPEED, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
}
if (StrFormatByteSizeW(IfEntry->dwInOctets, szBuffer, sizeof(szFormat)/sizeof(WCHAR)))
{
SendDlgItemMessageW(hwndDlg, IDC_RECEIVED, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
if (StrFormatByteSizeW(IfEntry->dwOutOctets, szBuffer, sizeof(szFormat)/sizeof(WCHAR)))
{
SendDlgItemMessageW(hwndDlg, IDC_SEND, WM_SETTEXT, 0, (LPARAM)szBuffer);
}
#if 0
Ticks = GetTickCount64();
#else
Ticks = GetTickCount();
#endif
DurationSeconds = Ticks / 1000;
TimeConnected.wSecond = (DurationSeconds % 60);
TimeConnected.wMinute = (DurationSeconds / 60) % 60;
TimeConnected.wHour = (DurationSeconds / (60 * 60)) % 24;
TimeConnected.wDay = DurationSeconds / (60 * 60 * 24);
if (!GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &TimeConnected, L"HH':'mm':'ss", LocBuffer, sizeof(LocBuffer) / sizeof(LocBuffer[0])))
return;
if (!TimeConnected.wDay)
{
SendDlgItemMessageW(hwndDlg, IDC_DURATION, WM_SETTEXT, 0, (LPARAM)LocBuffer);
}
else
{
if (TimeConnected.wDay == 1)
{
if (!LoadStringW(netshell_hInstance, IDS_DURATION_DAY, DayBuffer, sizeof(DayBuffer) / sizeof(DayBuffer[0])))
DayBuffer[0] = L'\0';
}
else
{
if (!LoadStringW(netshell_hInstance, IDS_DURATION_DAYS, DayBuffer, sizeof(DayBuffer) / sizeof(DayBuffer[0])))
DayBuffer[0] = L'\0';
}
swprintf(Buffer, DayBuffer, TimeConnected.wDay, LocBuffer);
SendDlgItemMessageW(hwndDlg, IDC_DURATION, WM_SETTEXT, 0, (LPARAM)Buffer);
}
}
// FillList() populates the list control.
void CShellViewImpl::FillList()
{
CComPtr<IEnumIDList> pEnum;
LPITEMIDLIST pidl = NULL;
HRESULT hr;
// Get an enumerator object for the folder's contents. Since this simple
// extension doesn't deal with subfolders, we request only non-folder
// objects.
hr = m_psfContainingFolder->EnumObjects ( m_hWnd, SHCONTF_NONFOLDERS,
&pEnum );
if ( FAILED(hr) )
return;
// Stop redrawing to avoid flickering
m_wndList.SetRedraw ( FALSE );
// Add items.
DWORD dwFetched;
while ( pEnum->Next(1, &pidl, &dwFetched) == S_OK )
{
LVITEM lvi = {0};
TCHAR szText[MAX_PATH];
ATLASSERT(1 == dwFetched); // sanity check
lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
lvi.iItem = m_wndList.GetItemCount();
lvi.iImage = 0;
// Store PIDL to the drive letter, using the lParam member for each item
TCHAR chDrive = m_PidlMgr.GetData ( pidl );
lvi.lParam = (LPARAM) m_PidlMgr.Create ( chDrive );
// Column 1: Drive letter
m_PidlMgr.GetPidlDescription ( pidl, szText );
lvi.pszText = szText;
m_wndList.InsertItem ( &lvi );
if ( m_wndList.GetStyle() & LVS_REPORT )
{
// Column 2: volume label
TCHAR szDriveRoot[] = _T("?:\\");
ULARGE_INTEGER uliFreeSpace, uliTotalSpace;
*szDriveRoot = chDrive;
if ( GetVolumeInformation ( szDriveRoot, szText, countof(szText),
NULL, NULL, NULL, NULL, 0 ))
{
m_wndList.SetItemText ( lvi.iItem, 1, szText );
}
// Columns 3/4: free/total space
if ( GetDiskFreeSpaceEx ( szDriveRoot, &uliFreeSpace, &uliTotalSpace, NULL ))
{
WCHAR szSize[MAX_PATH];
USES_CONVERSION;
// Note we use the Unicode API here, since the ANSI one only
// uses a 32-bit number (max 4 GB) for the size.
// If you don't mind a dependence on IE 5, use
// StrFormatByteSize64() instead.
StrFormatByteSizeW ( uliFreeSpace.QuadPart, szSize, countof(szSize) );
m_wndList.SetItemText ( lvi.iItem, 2, W2CT(szSize) );
StrFormatByteSizeW ( uliTotalSpace.QuadPart, szSize, countof(szSize) );
m_wndList.SetItemText ( lvi.iItem, 3, W2CT(szSize) );
/*
If you don't want the dependency on shlwapi.dll, use the
following code, which just shows the numbers unformatted.
Also take out the '#pragma comment' at the top of this file.
_stprintf ( szText, _T("%I64u"), uliFreeSpace.QuadPart );
m_wndList.SetItemText ( lvi.iItem, 2, szText);
_stprintf ( szText, _T("%I64u"), uliTotalSpace.QuadPart );
m_wndList.SetItemText ( lvi.iItem, 3, szText );
*/
}
}
}
// Sort the items by drive letter initially.
CListSortInfo sort = { m_psfContainingFolder, SIMPNS_SORT_DRIVELETTER, true };
m_wndList.SortItems ( CompareItems, (LPARAM) &sort );
if ( m_wndList.GetStyle() & LVS_REPORT )
{
m_wndList.SetColumnWidth ( 0, LVSCW_AUTOSIZE_USEHEADER );
m_wndList.SetColumnWidth ( 1, LVSCW_AUTOSIZE_USEHEADER );
m_wndList.SetColumnWidth ( 2, LVSCW_AUTOSIZE_USEHEADER );
m_wndList.SetColumnWidth ( 3, LVSCW_AUTOSIZE_USEHEADER );
}
// Redraw the list view.
m_wndList.SetRedraw ( TRUE );
m_wndList.Invalidate();
m_wndList.UpdateWindow();
}
DWORD WINAPI PerformancePageRefreshThread(void *lpParameter)
{
ULONGLONG CommitChargeTotal;
ULONGLONG CommitChargeLimit;
ULONGLONG CommitChargePeak;
ULONG CpuUsage;
ULONG CpuKernelUsage;
ULONGLONG KernelMemoryTotal;
ULONGLONG KernelMemoryPaged;
ULONGLONG KernelMemoryNonPaged;
ULONGLONG PhysicalMemoryTotal;
ULONGLONG PhysicalMemoryAvailable;
ULONGLONG PhysicalMemorySystemCache;
ULONG TotalHandles;
ULONG TotalThreads;
ULONG TotalProcesses;
WCHAR Text[260];
WCHAR szMemUsage[256];
MSG msg;
LoadStringW(hInst, IDS_STATUS_MEMUSAGE, szMemUsage, 256);
while (1)
{
int nBarsUsed1;
int nBarsUsed2;
WCHAR szChargeTotalFormat[256];
WCHAR szChargeLimitFormat[256];
/* Wait for an the event or application close */
if (GetMessage(&msg, NULL, 0, 0) <= 0)
return 0;
if (msg.message == WM_TIMER)
{
/*
* Update the commit charge info
*/
CommitChargeTotal = PerfDataGetCommitChargeTotalK();
CommitChargeLimit = PerfDataGetCommitChargeLimitK();
CommitChargePeak = PerfDataGetCommitChargePeakK();
_ultow(CommitChargeTotal, Text, 10);
SetWindowTextW(hPerformancePageCommitChargeTotalEdit, Text);
_ultow(CommitChargeLimit, Text, 10);
SetWindowTextW(hPerformancePageCommitChargeLimitEdit, Text);
_ultow(CommitChargePeak, Text, 10);
SetWindowTextW(hPerformancePageCommitChargePeakEdit, Text);
StrFormatByteSizeW(CommitChargeTotal * 1024,
szChargeTotalFormat,
sizeof(szChargeTotalFormat));
StrFormatByteSizeW(CommitChargeLimit * 1024,
szChargeLimitFormat,
sizeof(szChargeLimitFormat));
wsprintfW(Text, szMemUsage, szChargeTotalFormat, szChargeLimitFormat,
(CommitChargeLimit ? ((CommitChargeTotal * 100) / CommitChargeLimit) : 0));
SendMessageW(hStatusWnd, SB_SETTEXT, 2, (LPARAM)Text);
/*
* Update the kernel memory info
*/
KernelMemoryTotal = PerfDataGetKernelMemoryTotalK();
KernelMemoryPaged = PerfDataGetKernelMemoryPagedK();
KernelMemoryNonPaged = PerfDataGetKernelMemoryNonPagedK();
_ultow(KernelMemoryTotal, Text, 10);
SetWindowTextW(hPerformancePageKernelMemoryTotalEdit, Text);
_ultow(KernelMemoryPaged, Text, 10);
SetWindowTextW(hPerformancePageKernelMemoryPagedEdit, Text);
_ultow(KernelMemoryNonPaged, Text, 10);
SetWindowTextW(hPerformancePageKernelMemoryNonPagedEdit, Text);
/*
* Update the physical memory info
*/
PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK();
PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK();
PhysicalMemorySystemCache = PerfDataGetPhysicalMemorySystemCacheK();
_ultow(PhysicalMemoryTotal, Text, 10);
SetWindowTextW(hPerformancePagePhysicalMemoryTotalEdit, Text);
_ultow(PhysicalMemoryAvailable, Text, 10);
SetWindowTextW(hPerformancePagePhysicalMemoryAvailableEdit, Text);
_ultow(PhysicalMemorySystemCache, Text, 10);
SetWindowTextW(hPerformancePagePhysicalMemorySystemCacheEdit, Text);
/*
* Update the totals info
*/
TotalHandles = PerfDataGetSystemHandleCount();
TotalThreads = PerfDataGetTotalThreadCount();
TotalProcesses = PerfDataGetProcessCount();
_ultow(TotalHandles, Text, 10);
SetWindowTextW(hPerformancePageTotalsHandleCountEdit, Text);
_ultow(TotalThreads, Text, 10);
SetWindowTextW(hPerformancePageTotalsThreadCountEdit, Text);
_ultow(TotalProcesses, Text, 10);
SetWindowTextW(hPerformancePageTotalsProcessCountEdit, Text);
/*
* Redraw the graphs
*/
InvalidateRect(hPerformancePageCpuUsageGraph, NULL, FALSE);
InvalidateRect(hPerformancePageMemUsageGraph, NULL, FALSE);
/*
* Get the CPU usage
*/
CpuUsage = PerfDataGetProcessorUsage();
if (CpuUsage <= 0 ) CpuUsage = 0;
if (CpuUsage > 100) CpuUsage = 100;
if (TaskManagerSettings.ShowKernelTimes)
{
CpuKernelUsage = PerfDataGetProcessorSystemUsage();
if (CpuKernelUsage <= 0) CpuKernelUsage = 0;
if (CpuKernelUsage > 100) CpuKernelUsage = 100;
}
else
{
CpuKernelUsage = 0;
}
/*
* Get the memory usage
*/
CommitChargeTotal = PerfDataGetCommitChargeTotalK();
CommitChargeLimit = PerfDataGetCommitChargeLimitK();
nBarsUsed1 = CommitChargeLimit ? ((CommitChargeTotal * 100) / CommitChargeLimit) : 0;
PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK();
PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK();
nBarsUsed2 = PhysicalMemoryTotal ? ((PhysicalMemoryAvailable * 100) / PhysicalMemoryTotal) : 0;
GraphCtrl_AppendPoint(&PerformancePageCpuUsageHistoryGraph, CpuUsage, CpuKernelUsage, 0.0, 0.0);
GraphCtrl_AppendPoint(&PerformancePageMemUsageHistoryGraph, nBarsUsed1, nBarsUsed2, 0.0, 0.0);
/* PerformancePageMemUsageHistoryGraph.SetRange(0.0, 100.0, 10) ; */
InvalidateRect(hPerformancePageMemUsageHistoryGraph, NULL, FALSE);
InvalidateRect(hPerformancePageCpuUsageHistoryGraph, NULL, FALSE);
}
}
return 0;
}
HRESULT WINAPI CFontsFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
{
WCHAR buffer[MAX_PATH] = {0};
HRESULT hr = E_FAIL;
PIDLFontStruct * pfont;
HANDLE hFile;
LARGE_INTEGER FileSize;
SHFILEINFOW fi;
TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, psd);
if (iColumn >= FontsSHELLVIEWCOLUMNS)
return E_FAIL;
psd->fmt = FontsSFHeader[iColumn].fmt;
psd->cxChar = FontsSFHeader[iColumn].cxChar;
if (pidl == NULL)
{
psd->str.uType = STRRET_WSTR;
if (LoadStringW(shell32_hInstance, FontsSFHeader[iColumn].colnameid, buffer, MAX_PATH))
hr = SHStrDupW(buffer, &psd->str.pOleStr);
return hr;
}
if (iColumn == COLUMN_NAME)
{
psd->str.uType = STRRET_WSTR;
return GetDisplayNameOf(pidl, SHGDN_NORMAL, &psd->str);
}
psd->str.uType = STRRET_CSTR;
psd->str.cStr[0] = '\0';
switch(iColumn)
{
case COLUMN_TYPE:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
if (SHGetFileInfoW(pfont->szName + pfont->offsFile, 0, &fi, sizeof(fi), SHGFI_TYPENAME))
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(fi.szTypeName) + 1) * sizeof(WCHAR));
if (!psd->str.pOleStr)
return E_OUTOFMEMORY;
wcscpy(psd->str.pOleStr, fi.szTypeName);
psd->str.uType = STRRET_WSTR;
return S_OK;
}
}
break;
case COLUMN_SIZE:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
hFile = CreateFileW(pfont->szName + pfont->offsFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
if (GetFileSizeEx(hFile, &FileSize))
{
if (StrFormatByteSizeW(FileSize.QuadPart, buffer, sizeof(buffer) / sizeof(WCHAR)))
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc(wcslen(buffer) + 1);
if (!psd->str.pOleStr)
{
CloseHandle(hFile);
return E_OUTOFMEMORY;
}
wcscpy(psd->str.pOleStr, buffer);
psd->str.uType = STRRET_WSTR;
CloseHandle(hFile);
return S_OK;
}
}
CloseHandle(hFile);
}
}
break;
case COLUMN_FILENAME:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(pfont->szName + pfont->offsFile) + 1) * sizeof(WCHAR));
if (psd->str.pOleStr)
{
psd->str.uType = STRRET_WSTR;
wcscpy(psd->str.pOleStr, pfont->szName + pfont->offsFile);
return S_OK;
}
else
return E_OUTOFMEMORY;
}
break;
}
return E_FAIL;
}
VOID
InitializeFormatDriveDlg(HWND hwndDlg, PFORMAT_DRIVE_CONTEXT pContext)
{
WCHAR szText[120];
WCHAR szDrive[4] = { L'C', ':', '\\', 0 };
WCHAR szFs[30] = {0};
INT Length, TempLength;
DWORD dwSerial, dwMaxComp, dwFileSys;
ULARGE_INTEGER FreeBytesAvailableUser, TotalNumberOfBytes;
DWORD dwIndex, dwDefault;
UCHAR uMinor, uMajor;
BOOLEAN Latest;
HWND hDlgCtrl;
Length = GetWindowTextW(hwndDlg, szText, sizeof(szText)/sizeof(WCHAR));
if (Length < 0)
Length = 0;
szDrive[0] = pContext->Drive + L'A';
if (GetVolumeInformationW(szDrive, &szText[Length+1], (sizeof(szText)/sizeof(WCHAR))- Length - 2, &dwSerial, &dwMaxComp, &dwFileSys, szFs, sizeof(szFs)/sizeof(WCHAR)))
{
szText[Length] = L' ';
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
TempLength = wcslen(&szText[Length+1]);
if (!TempLength)
{
/* load default volume label */
TempLength = LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, &szText[Length+1], (sizeof(szText)/sizeof(WCHAR))- Length - 2);
}
else
{
/* set volume label */
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, 28679, WM_SETTEXT, 0, (LPARAM)&szText[Length+1]);
}
Length += TempLength + 1;
}
if (Length + 4 < (sizeof(szText)/sizeof(WCHAR)))
{
szText[Length] = L' ';
szText[Length+1] = L'(';
szText[Length+2] = szDrive[0];
szText[Length+3] = L')';
Length +=4;
}
if (Length < (sizeof(szText)/sizeof(WCHAR)))
szText[Length] = L'\0';
else
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
/* set window text */
SetWindowTextW(hwndDlg, szText);
if (GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailableUser, &TotalNumberOfBytes, NULL))
{
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szText, sizeof(szText)/sizeof(WCHAR)))
{
/* add drive capacity */
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, 28673, CB_ADDSTRING, 0, (LPARAM)szText);
SendDlgItemMessageW(hwndDlg, 28673, CB_SETCURSEL, 0, (LPARAM)0);
}
}
if (pContext->Options & SHFMT_OPT_FULL)
{
/* check quick format button */
SendDlgItemMessageW(hwndDlg, 28674, BM_SETCHECK, BST_CHECKED, 0);
}
/* enumerate all available filesystems */
dwIndex = 0;
dwDefault = 0;
hDlgCtrl = GetDlgItem(hwndDlg, 28677);
while(pContext->QueryAvailableFileSystemFormat(dwIndex, szText, &uMajor, &uMinor, &Latest))
{
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
if (!wcsicmp(szText, szFs))
dwDefault = dwIndex;
SendMessageW(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szText);
dwIndex++;
}
if (!dwIndex)
{
ERR("no filesystem providers\n");
return;
}
/* select default filesys */
SendMessageW(hDlgCtrl, CB_SETCURSEL, dwDefault, 0);
/* setup cluster combo */
InsertDefaultClusterSizeForFs(hwndDlg, pContext);
/* hide progress control */
ShowWindow(GetDlgItem(hwndDlg, 28678), SW_HIDE);
}
VOID
InsertDefaultClusterSizeForFs(HWND hwndDlg, PFORMAT_DRIVE_CONTEXT pContext)
{
WCHAR szFs[100] = {0};
WCHAR szDrive[4] = { L'C', ':', '\\', 0 };
INT iSelIndex;
ULARGE_INTEGER FreeBytesAvailableUser, TotalNumberOfBytes;
DWORD ClusterSize;
LRESULT lIndex;
HWND hDlgCtrl;
hDlgCtrl = GetDlgItem(hwndDlg, 28677);
iSelIndex = SendMessage(hDlgCtrl, CB_GETCURSEL, 0, 0);
if (iSelIndex == CB_ERR)
return;
if (SendMessageW(hDlgCtrl, CB_GETLBTEXT, iSelIndex, (LPARAM)szFs) == CB_ERR)
return;
szFs[(sizeof(szFs)/sizeof(WCHAR))-1] = L'\0';
szDrive[0] = pContext->Drive + 'A';
if (!GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailableUser, &TotalNumberOfBytes, NULL))
return;
if (!wcsicmp(szFs, L"FAT16") ||
!wcsicmp(szFs, L"FAT")) //ODYSSEY HACK
{
if (!GetDefaultClusterSize(szFs, &ClusterSize, &TotalNumberOfBytes))
{
TRACE("FAT16 is not supported on hdd larger than 4G current %lu\n", TotalNumberOfBytes.QuadPart);
SendMessageW(hDlgCtrl, CB_DELETESTRING, iSelIndex, 0);
return;
}
if (LoadStringW(shell32_hInstance, IDS_DEFAULT_CLUSTER_SIZE, szFs, sizeof(szFs)/sizeof(WCHAR)))
{
hDlgCtrl = GetDlgItem(hwndDlg, 28680);
szFs[(sizeof(szFs)/sizeof(WCHAR))-1] = L'\0';
SendMessageW(hDlgCtrl, CB_RESETCONTENT, 0, 0);
lIndex = SendMessageW(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szFs);
if (lIndex != CB_ERR)
SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize);
SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0);
}
}
else if (!wcsicmp(szFs, L"FAT32"))
{
if (!GetDefaultClusterSize(szFs, &ClusterSize, &TotalNumberOfBytes))
{
TRACE("FAT32 is not supported on hdd larger than 32G current %lu\n", TotalNumberOfBytes.QuadPart);
SendMessageW(hDlgCtrl, CB_DELETESTRING, iSelIndex, 0);
return;
}
if (LoadStringW(shell32_hInstance, IDS_DEFAULT_CLUSTER_SIZE, szFs, sizeof(szFs)/sizeof(WCHAR)))
{
hDlgCtrl = GetDlgItem(hwndDlg, 28680);
szFs[(sizeof(szFs)/sizeof(WCHAR))-1] = L'\0';
SendMessageW(hDlgCtrl, CB_RESETCONTENT, 0, 0);
lIndex = SendMessageW(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szFs);
if (lIndex != CB_ERR)
SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize);
SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0);
}
}
else if (!wcsicmp(szFs, L"NTFS"))
{
if (!GetDefaultClusterSize(szFs, &ClusterSize, &TotalNumberOfBytes))
{
TRACE("NTFS is not supported on hdd larger than 2TB current %lu\n", TotalNumberOfBytes.QuadPart);
SendMessageW(hDlgCtrl, CB_DELETESTRING, iSelIndex, 0);
return;
}
hDlgCtrl = GetDlgItem(hwndDlg, 28680);
if (LoadStringW(shell32_hInstance, IDS_DEFAULT_CLUSTER_SIZE, szFs, sizeof(szFs)/sizeof(WCHAR)))
{
szFs[(sizeof(szFs)/sizeof(WCHAR))-1] = L'\0';
SendMessageW(hDlgCtrl, CB_RESETCONTENT, 0, 0);
lIndex = SendMessageW(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szFs);
if (lIndex != CB_ERR)
SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize);
SendMessageW(hDlgCtrl, CB_SETCURSEL, 0, 0);
}
ClusterSize = 512;
for (lIndex = 0; lIndex < 4; lIndex++)
{
TotalNumberOfBytes.QuadPart = ClusterSize;
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szFs, sizeof(szFs)/sizeof(WCHAR)))
{
lIndex = SendMessageW(hDlgCtrl, CB_ADDSTRING, 0, (LPARAM)szFs);
if (lIndex != CB_ERR)
SendMessageW(hDlgCtrl, CB_SETITEMDATA, lIndex, (LPARAM)ClusterSize);
}
ClusterSize *= 2;
}
}
else
{
FIXME("unknown fs\n");
SendDlgItemMessageW(hwndDlg, 28680, CB_RESETCONTENT, iSelIndex, 0);
return;
}
}
static
void
InitializeGeneralDriveDialog(HWND hwndDlg, WCHAR * szDrive)
{
WCHAR szVolumeName[MAX_PATH+1] = {0};
DWORD MaxComponentLength = 0;
DWORD FileSystemFlags = 0;
WCHAR FileSystemName[MAX_PATH+1] = {0};
WCHAR szFormat[50];
WCHAR szBuffer[128];
BOOL ret;
UINT DriveType;
ULARGE_INTEGER FreeBytesAvailable;
LARGE_INTEGER TotalNumberOfFreeBytes;
LARGE_INTEGER TotalNumberOfBytes;
ret = GetVolumeInformationW(szDrive, szVolumeName, MAX_PATH+1, NULL, &MaxComponentLength, &FileSystemFlags, FileSystemName, MAX_PATH+1);
if (ret)
{
/* set volume label */
SendDlgItemMessageW(hwndDlg, 14000, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szVolumeName);
/* set filesystem type */
SendDlgItemMessageW(hwndDlg, 14002, WM_SETTEXT, (WPARAM)NULL, (LPARAM)FileSystemName);
}
DriveType = GetDriveTypeW(szDrive);
if (DriveType == DRIVE_FIXED || DriveType == DRIVE_CDROM)
{
if(GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable, (PULARGE_INTEGER)&TotalNumberOfBytes, (PULARGE_INTEGER)&TotalNumberOfFreeBytes))
{
WCHAR szResult[128];
LONGLONG Result;
HANDLE hVolume;
DWORD BytesReturned = 0;
swprintf(szResult, L"\\\\.\\%c:", towupper(szDrive[0]));
hVolume = CreateFileW(szResult, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hVolume != INVALID_HANDLE_VALUE)
{
ret = DeviceIoControl(hVolume, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, (LPVOID)&TotalNumberOfBytes, sizeof(ULARGE_INTEGER), &BytesReturned, NULL);
if (ret && StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
CloseHandle(hVolume);
}
TRACE("szResult %s hVOlume %p ret %d LengthInformation %ul Bytesreturned %d\n", debugstr_w(szResult), hVolume, ret, TotalNumberOfBytes.QuadPart, BytesReturned);
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14003, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
Result = GetFreeBytesShare(TotalNumberOfFreeBytes.QuadPart, TotalNumberOfBytes.QuadPart);
/* set free bytes percentage */
swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
/* store used share amount */
Result = 100 - Result;
swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
if (DriveType == DRIVE_FIXED)
{
if (LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);
}
else /* DriveType == DRIVE_CDROM) */
{
if (LoadStringW(shell32_hInstance, IDS_DRIVE_CDROM, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);
}
}
}
/* set drive description */
SendDlgItemMessageW(hwndDlg, 14009, WM_GETTEXT, (WPARAM)50, (LPARAM)szFormat);
swprintf(szBuffer, szFormat, szDrive);
SendDlgItemMessageW(hwndDlg, 14009, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szBuffer);
}
virtual HRESULT STDMETHODCALLTYPE OnProgress(
ULONG ulProgress,
ULONG ulProgressMax,
ULONG ulStatusCode,
LPCWSTR szStatusText)
{
HWND Item;
LONG r;
Item = GetDlgItem(m_hDialog, IDC_DOWNLOAD_PROGRESS);
if (Item && ulProgressMax)
{
WCHAR szProgress[100];
WCHAR szProgressMax[100];
UINT uiPercentage = ((ULONGLONG)ulProgress * 100) / ulProgressMax;
/* send the current progress to the progress bar */
SendMessageW(Item, PBM_SETPOS, uiPercentage, 0);
/* format the bits and bytes into pretty and accesible units... */
StrFormatByteSizeW(ulProgress, szProgress, _countof(szProgress));
StrFormatByteSizeW(ulProgressMax, szProgressMax, _countof(szProgressMax));
/* ...and post all of it to our subclassed progress bar text subroutine */
StringCbPrintfW(m_ProgressText,
sizeof(m_ProgressText),
L"%u%% \x2014 %ls / %ls",
uiPercentage,
szProgress,
szProgressMax);
SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)m_ProgressText);
}
Item = GetDlgItem(m_hDialog, IDC_DOWNLOAD_STATUS);
if (Item && szStatusText && wcslen(szStatusText) > 0 && m_UrlHasBeenCopied == FALSE)
{
DWORD len = wcslen(szStatusText) + 1;
PWSTR buf = (PWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR));
if (buf)
{
/* beautify our url for display purposes */
InternetCanonicalizeUrl(szStatusText, buf, &len, ICU_DECODE | ICU_NO_ENCODE);
}
else
{
/* just use the original */
buf = (PWSTR)szStatusText;
}
/* paste it into our dialog and don't do it again in this instance */
SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)buf);
m_UrlHasBeenCopied = TRUE;
if (buf != szStatusText)
{
HeapFree(GetProcessHeap(), 0, buf);
}
}
SetLastError(0);
r = GetWindowLongPtrW(m_hDialog, GWLP_USERDATA);
if (0 != r || 0 != GetLastError())
{
*m_pbCancelled = TRUE;
return E_ABORT;
}
return S_OK;
}
VOID
CDrvDefExt::InitGeneralPage(HWND hwndDlg)
{
WCHAR wszVolumeName[MAX_PATH+1] = {0};
WCHAR wszFileSystem[MAX_PATH+1] = {0};
WCHAR wszBuf[128];
BOOL bRet;
bRet = GetVolumeInformationW(m_wszDrive, wszVolumeName, _countof(wszVolumeName), NULL, NULL, NULL, wszFileSystem, _countof(wszFileSystem));
if (bRet)
{
/* Set volume label and filesystem */
SetDlgItemTextW(hwndDlg, 14000, wszVolumeName);
SetDlgItemTextW(hwndDlg, 14002, wszFileSystem);
}
/* Set drive type and icon */
UINT DriveType = GetDriveTypeW(m_wszDrive);
UINT IconId, TypeStrId = 0;
switch (DriveType)
{
case DRIVE_CDROM: IconId = IDI_SHELL_CDROM; TypeStrId = IDS_DRIVE_CDROM; break;
case DRIVE_REMOVABLE: IconId = IDI_SHELL_FLOPPY; break;
case DRIVE_RAMDISK: IconId = IDI_SHELL_RAMDISK; break;
default: IconId = IDI_SHELL_DRIVE; TypeStrId = IDS_DRIVE_FIXED;
}
HICON hIcon = (HICON)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IconId), IMAGE_ICON, 32, 32, LR_SHARED);
if (hIcon)
SendDlgItemMessageW(hwndDlg, 14016, STM_SETICON, (WPARAM)hIcon, 0);
if (TypeStrId && LoadStringW(shell32_hInstance, TypeStrId, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14001, wszBuf);
ULARGE_INTEGER FreeBytesAvailable, TotalNumberOfBytes;
if(GetDiskFreeSpaceExW(m_wszDrive, &FreeBytesAvailable, &TotalNumberOfBytes, NULL))
{
/* Init free space percentage used for drawing piechart */
m_FreeSpacePerc = (UINT)(FreeBytesAvailable.QuadPart * 100ull / TotalNumberOfBytes.QuadPart);
/* Used space */
if (SH_FormatByteSize(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14003, wszBuf);
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14004, wszBuf);
/* Free space */
if (SH_FormatByteSize(FreeBytesAvailable.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14005, wszBuf);
if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14006, wszBuf);
/* Total space */
if (SH_FormatByteSize(TotalNumberOfBytes.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14007, wszBuf);
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, wszBuf, _countof(wszBuf)))
SetDlgItemTextW(hwndDlg, 14008, wszBuf);
}
/* Set drive description */
WCHAR wszFormat[50];
GetDlgItemTextW(hwndDlg, 14009, wszFormat, _countof(wszFormat));
swprintf(wszBuf, wszFormat, m_wszDrive[0]);
SetDlgItemTextW(hwndDlg, 14009, wszBuf);
}
