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); }