Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-09-30 22:47:28 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/base/applications/taskmgr/perfpage.c
Joachim Henze 7215b32c40 [0.4.11][TASKMGR] Mainly Graph-stuff backports 2023-10-31 
This backports the following commits:
0.4.15-dev-6770-g ddd1d19b3f [TASKMGR] Get rid of cplusplus extern c (#5808)
partially 0.4.15-dev-6120-g 6e77747b30 [TASKMGR] Simplify tray icon code
0.4.15-dev-6114-g 9a6c85f68a [TASKMGR] Fix PerfDataDeallocCommandLineCache, part of CORE-18014 (unresolved still)
0.4.15-dev-6113-g 7989e3f26c [TASKMGR] GraphCtrl_Dispose: Delete hdcGraph first, part of CORE-18014 (unresolved still)
0.4.15-dev-6112-g dc14a9f6e0 [TASKMGR] GraphCtrl: Use DeleteDC instead of DeleteObject to delete inst->hdcGraph, part of CORE-18014 (unresolved still)
partially 0.4.15-dev-4994-g 15a0f7adb0 picked a tiny part from PR4657 (I picked only the refactoring to switch-statement, no functional changes. Especially NOT the formatting changes which would require the additional winnls.h-include)
0.4.15-dev-3737-g f8faa0b660 [TASKMGR] Fix a heap corruption bug (#4311), just an addendum to PR4141 which is picked with this backport as well. Older branches were never affected.
partially 0.4.15-dev-3514-g 1c82bf0324 [TASKMGR] Avoid freezing in getting icons, from (PR4180) CORE17894. I picked only the 1000ms->100ms part and the stripping of WM_QUERYDRAGICON call. Therefore I don't consider CORE17894 as fully covered.
0.4.15-dev-3486-g 545e1190f2 [TASKMGR] Avoid hangs as much as possible (#4166) CORE17894
partially 0.4.15-dev-3483-g 403222dd4f [TASKMGR] Preserve graphs history on resizes (#4141). I left aside the structs type renaming and OOM-Handling upon graph creation. Picked all the logical changes though.
0.4.15-dev-3269-g 0ed04e3640 [TASKMGR] Make performance graph grid scroll (#3581)
0.4.15-dev-3268-g a4ab9a1e19 [TASKMGR] Formatting only (#3581). Covers the last bits of that PR.

Main motivation was getting the toggling of ShowKernelTimes in the Performance tab
switch on and off in realtime without introducing gaps in the graph.
It also makes the grid scroll together with the data, like on Windows.

Most other parts I picked solely for their binary-shrinking effect.
I decided to strip the ID_HELP_TOPICS from the rc files, as this was not implemented,
and I would never port that back later. So it is one less non-functional-button in the older branches.
I favored memset() over Zeromemory() in this usermode-app everywhere, and favoref for (;;) over while(1).

Binary size shrinks slightly on all branches:

master taskmgr.exe RosBEWin2.2.2 GCC8.4.0dbg             696.832 (0.4.15-dev-6820-gb3194e3)
0.4.14 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  549.888 -> 548.864
0.4.13 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  542.720 -> 542.208
0.4.12 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  545.792 -> 543.232
0.4.11 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  545.792 -> 543.232
0.4.10 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  532.480 -> 530.432
0.4. 9 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  532.480 -> 530.432
0.4. 8 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  532.480 -> 530.432
0.4. 7 taskmgr.exe RosBEWin2.1.6 GCC4.7.2dbg  531.456 -> 529.408

       taskmgr.exe MS XPSP3 german                                           140.800 Bytes
0.4.14 taskmgr.exe RosBEWin2.1.6 MSVC2010SP1rls I18N=de-DE  110.080 Bytes -> 109.056 Bytes (my current taskmgr of choice)
0.4. 8 taskmgr.exe RosBEWin2.1.6 MSVC2010SP1rls I18N=en-US  108.032 Bytes -> 105.984 Bytes
0.4. 7 taskmgr.exe RosBEWin2.1.6 MSVC2010SP1rls I18N=en-US  107.520 Bytes -> 105.472 Bytes
2023-10-31 20:43:44 +01:00

444 lines
17 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS Task Manager
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* COPYRIGHT: 1999-2001 Brian Palmer <brianp@reactos.org>
*/
#include "precomp.h"
#include <shlwapi.h>
TGraphCtrl PerformancePageCpuUsageHistoryGraph;
TGraphCtrl PerformancePageMemUsageHistoryGraph;
HWND hPerformancePage;
HWND hCpuUsageGraph;
HWND hMemUsageGraph;
HWND hPerformancePageCpuUsageHistoryGraph;
HWND hPerformancePageMemUsageHistoryGraph;
HWND hTotalsFrame;
HWND hCommitChargeFrame;
HWND hKernelMemoryFrame;
HWND hPhysicalMemoryFrame;
HWND hCpuUsageFrame;
HWND hMemUsageFrame;
HWND hCpuUsageHistoryFrame;
HWND hMemUsageHistoryFrame;
HWND hCommitChargeTotalEdit;
HWND hCommitChargeLimitEdit;
HWND hCommitChargePeakEdit;
HWND hKernelMemoryTotalEdit;
HWND hKernelMemoryPagedEdit;
HWND hKernelMemoryNonPagedEdit;
HWND hPhysicalMemoryTotalEdit;
HWND hPhysicalMemoryAvailableEdit;
HWND hPhysicalMemorySystemCacheEdit;
HWND hTotalsHandleCountEdit;
HWND hTotalsProcessCountEdit;
HWND hTotalsThreadCountEdit;
#ifdef RUN_PERF_PAGE
static HANDLE hPerformanceThread = NULL;
static DWORD dwPerformanceThread;
#endif
static int nPerformancePageWidth;
static int nPerformancePageHeight;
static int lastX, lastY;
DWORD WINAPI PerformancePageRefreshThread(PVOID Parameter);
void AdjustFrameSize(HWND hCntrl, HWND hDlg, int nXDifference, int nYDifference, int pos)
{
RECT rc;
int cx, cy, sx, sy;
GetClientRect(hCntrl, &rc);
MapWindowPoints(hCntrl, hDlg, (LPPOINT)(PRECT)(&rc), sizeof(RECT)/sizeof(POINT));
if (pos) {
cx = rc.left;
cy = rc.top;
sx = rc.right - rc.left;
switch (pos) {
case 1:
break;
case 2:
cy += nYDifference / 2;
break;
case 3:
sx += nXDifference;
break;
case 4:
cy += nYDifference / 2;
sx += nXDifference;
break;
}
sy = rc.bottom - rc.top + nYDifference / 2;
SetWindowPos(hCntrl, NULL, cx, cy, sx, sy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOZORDER);
} else {
cx = rc.left + nXDifference;
cy = rc.top + nYDifference;
SetWindowPos(hCntrl, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
}
InvalidateRect(hCntrl, NULL, TRUE);
}
static void AdjustCntrlPos(int ctrl_id, HWND hDlg, int nXDifference, int nYDifference)
{
AdjustFrameSize(GetDlgItem(hDlg, ctrl_id), hDlg, nXDifference, nYDifference, 0);
}
INT_PTR CALLBACK
PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
RECT rc;
int nXDifference;
int nYDifference;
switch (message) {
case WM_DESTROY:
GraphCtrl_Dispose(&PerformancePageCpuUsageHistoryGraph);
GraphCtrl_Dispose(&PerformancePageMemUsageHistoryGraph);
#ifdef RUN_PERF_PAGE
EndLocalThread(&hPerformanceThread, dwPerformanceThread);
#endif
break;
case WM_INITDIALOG:
{
TFormat fmt;
// Save the width and height
GetClientRect(hDlg, &rc);
nPerformancePageWidth = rc.right;
nPerformancePageHeight = rc.bottom;
// Update window position
SetWindowPos(hDlg, NULL, 15, 30, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
// Get handles to all the controls
hTotalsFrame = GetDlgItem(hDlg, IDC_TOTALS_FRAME);
hCommitChargeFrame = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_FRAME);
hKernelMemoryFrame = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_FRAME);
hPhysicalMemoryFrame = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_FRAME);
hCpuUsageFrame = GetDlgItem(hDlg, IDC_CPU_USAGE_FRAME);
hMemUsageFrame = GetDlgItem(hDlg, IDC_MEM_USAGE_FRAME);
hCpuUsageHistoryFrame = GetDlgItem(hDlg, IDC_CPU_USAGE_HISTORY_FRAME);
hMemUsageHistoryFrame = GetDlgItem(hDlg, IDC_MEMORY_USAGE_HISTORY_FRAME);
hCommitChargeTotalEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_TOTAL);
hCommitChargeLimitEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_LIMIT);
hCommitChargePeakEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_PEAK);
hKernelMemoryTotalEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_TOTAL);
hKernelMemoryPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_PAGED);
hKernelMemoryNonPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_NONPAGED);
hPhysicalMemoryTotalEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_TOTAL);
hPhysicalMemoryAvailableEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_AVAILABLE);
hPhysicalMemorySystemCacheEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_SYSTEM_CACHE);
hTotalsHandleCountEdit = GetDlgItem(hDlg, IDC_TOTALS_HANDLE_COUNT);
hTotalsProcessCountEdit = GetDlgItem(hDlg, IDC_TOTALS_PROCESS_COUNT);
hTotalsThreadCountEdit = GetDlgItem(hDlg, IDC_TOTALS_THREAD_COUNT);
hCpuUsageGraph = GetDlgItem(hDlg, IDC_CPU_USAGE_GRAPH);
hMemUsageGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_GRAPH);
hPerformancePageMemUsageHistoryGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_HISTORY_GRAPH);
hPerformancePageCpuUsageHistoryGraph = GetDlgItem(hDlg, IDC_CPU_USAGE_HISTORY_GRAPH);
// Create the controls
fmt.clrBack = RGB(0, 0, 0);
fmt.clrGrid = RGB(0, 128, 64);
fmt.clrPlot0 = RGB(0, 255, 0);
fmt.clrPlot1 = RGB(255, 0, 0);
fmt.GridCellWidth = fmt.GridCellHeight = 12;
fmt.DrawSecondaryPlot = TaskManagerSettings.ShowKernelTimes;
GraphCtrl_Create(&PerformancePageCpuUsageHistoryGraph, hPerformancePageCpuUsageHistoryGraph, hDlg, &fmt);
fmt.clrPlot0 = RGB(255, 255, 0);
fmt.clrPlot1 = RGB(100, 255, 255);
fmt.DrawSecondaryPlot = TRUE;
GraphCtrl_Create(&PerformancePageMemUsageHistoryGraph, hPerformancePageMemUsageHistoryGraph, hDlg, &fmt);
#ifdef RUN_PERF_PAGE
hPerformanceThread = CreateThread(NULL, 0, PerformancePageRefreshThread, NULL, 0, &dwPerformanceThread);
#endif
// Subclass graph buttons
OldGraphWndProc = (WNDPROC)SetWindowLongPtrW(hCpuUsageGraph, GWLP_WNDPROC, (LONG_PTR)Graph_WndProc);
SetWindowLongPtrW(hMemUsageGraph, GWLP_WNDPROC, (LONG_PTR)Graph_WndProc);
OldGraphCtrlWndProc = (WNDPROC)SetWindowLongPtrW(hPerformancePageMemUsageHistoryGraph, GWLP_WNDPROC, (LONG_PTR)GraphCtrl_WndProc);
SetWindowLongPtrW(hPerformancePageCpuUsageHistoryGraph, GWLP_WNDPROC, (LONG_PTR)GraphCtrl_WndProc);
return TRUE;
}
case WM_COMMAND:
break;
case WM_SIZE:
do {
int cx, cy;
if (wParam == SIZE_MINIMIZED)
return 0;
cx = LOWORD(lParam);
cy = HIWORD(lParam);
nXDifference = cx - nPerformancePageWidth;
nYDifference = cy - nPerformancePageHeight;
nPerformancePageWidth = cx;
nPerformancePageHeight = cy;
} while (0);
// Reposition the performance page's controls
AdjustFrameSize(hTotalsFrame, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hCommitChargeFrame, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hKernelMemoryFrame, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hPhysicalMemoryFrame, hDlg, 0, nYDifference, 0);
AdjustCntrlPos(IDS_COMMIT_CHARGE_TOTAL, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_COMMIT_CHARGE_LIMIT, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_COMMIT_CHARGE_PEAK, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_KERNEL_MEMORY_TOTAL, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_KERNEL_MEMORY_PAGED, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_KERNEL_MEMORY_NONPAGED, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_PHYSICAL_MEMORY_TOTAL, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_PHYSICAL_MEMORY_AVAILABLE, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_PHYSICAL_MEMORY_SYSTEM_CACHE, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_TOTALS_HANDLE_COUNT, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_TOTALS_PROCESS_COUNT, hDlg, 0, nYDifference);
AdjustCntrlPos(IDS_TOTALS_THREAD_COUNT, hDlg, 0, nYDifference);
AdjustFrameSize(hCommitChargeTotalEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hCommitChargeLimitEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hCommitChargePeakEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hKernelMemoryTotalEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hKernelMemoryPagedEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hKernelMemoryNonPagedEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hPhysicalMemoryTotalEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hPhysicalMemoryAvailableEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hPhysicalMemorySystemCacheEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hTotalsHandleCountEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hTotalsProcessCountEdit, hDlg, 0, nYDifference, 0);
AdjustFrameSize(hTotalsThreadCountEdit, hDlg, 0, nYDifference, 0);
nXDifference += lastX;
nYDifference += lastY;
lastX = lastY = 0;
if (nXDifference % 2) {
if (nXDifference > 0) {
nXDifference--;
lastX++;
} else {
nXDifference++;
lastX--;
}
}
if (nYDifference % 2) {
if (nYDifference > 0) {
nYDifference--;
lastY++;
} else {
nYDifference++;
lastY--;
}
}
AdjustFrameSize(hCpuUsageFrame, hDlg, nXDifference, nYDifference, 1);
AdjustFrameSize(hMemUsageFrame, hDlg, nXDifference, nYDifference, 2);
AdjustFrameSize(hCpuUsageHistoryFrame, hDlg, nXDifference, nYDifference, 3);
AdjustFrameSize(hMemUsageHistoryFrame, hDlg, nXDifference, nYDifference, 4);
AdjustFrameSize(hCpuUsageGraph, hDlg, nXDifference, nYDifference, 1);
AdjustFrameSize(hMemUsageGraph, hDlg, nXDifference, nYDifference, 2);
AdjustFrameSize(hPerformancePageCpuUsageHistoryGraph, hDlg, nXDifference, nYDifference, 3);
AdjustFrameSize(hPerformancePageMemUsageHistoryGraph, hDlg, nXDifference, nYDifference, 4);
break;
}
return 0;
}
void RefreshPerformancePage(void)
{
#ifdef RUN_PERF_PAGE
// Signal the event so that our refresh thread
// will wake up and refresh the performance page
PostThreadMessage(dwPerformanceThread, WM_TIMER, 0, 0);
#endif
}
DWORD WINAPI PerformancePageRefreshThread(PVOID Parameter)
{
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;
MSG msg;
WCHAR Text[260];
WCHAR szMemUsage[256], szCpuUsage[256], szProcesses[256];
LoadStringW(hInst, IDS_STATUS_CPUUSAGE, szCpuUsage, 256);
LoadStringW(hInst, IDS_STATUS_MEMUSAGE, szMemUsage, 256);
LoadStringW(hInst, IDS_STATUS_PROCESSES, szProcesses, 256);
for (;;)
{
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(hCommitChargeTotalEdit, Text);
_ultow(CommitChargeLimit, Text, 10);
SetWindowTextW(hCommitChargeLimitEdit, Text);
_ultow(CommitChargePeak, Text, 10);
SetWindowTextW(hCommitChargePeakEdit, Text);
StrFormatByteSizeW(CommitChargeTotal * 1024,
szChargeTotalFormat,
_countof(szChargeTotalFormat));
StrFormatByteSizeW(CommitChargeLimit * 1024,
szChargeLimitFormat,
_countof(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(hKernelMemoryTotalEdit, Text);
_ultow(KernelMemoryPaged, Text, 10);
SetWindowTextW(hKernelMemoryPagedEdit, Text);
_ultow(KernelMemoryNonPaged, Text, 10);
SetWindowTextW(hKernelMemoryNonPagedEdit, Text);
// Update the physical memory info
PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK();
PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK();
PhysicalMemorySystemCache = PerfDataGetPhysicalMemorySystemCacheK();
_ultow(PhysicalMemoryTotal, Text, 10);
SetWindowTextW(hPhysicalMemoryTotalEdit, Text);
_ultow(PhysicalMemoryAvailable, Text, 10);
SetWindowTextW(hPhysicalMemoryAvailableEdit, Text);
_ultow(PhysicalMemorySystemCache, Text, 10);
SetWindowTextW(hPhysicalMemorySystemCacheEdit, Text);
// Update the totals info
TotalHandles = PerfDataGetSystemHandleCount();
TotalThreads = PerfDataGetTotalThreadCount();
TotalProcesses = PerfDataGetProcessCount();
_ultow(TotalHandles, Text, 10);
SetWindowTextW(hTotalsHandleCountEdit, Text);
_ultow(TotalThreads, Text, 10);
SetWindowTextW(hTotalsThreadCountEdit, Text);
_ultow(TotalProcesses, Text, 10);
SetWindowTextW(hTotalsProcessCountEdit, Text);
wsprintfW(Text, szProcesses, TotalProcesses);
SendMessageW(hStatusWnd, SB_SETTEXT, 0, (LPARAM)Text);
// Redraw the graphs
InvalidateRect(hCpuUsageGraph, NULL, FALSE);
InvalidateRect(hMemUsageGraph, NULL, FALSE);
// Get the CPU usage
CpuUsage = PerfDataGetProcessorUsage();
CpuKernelUsage = PerfDataGetProcessorSystemUsage();
wsprintfW(Text, szCpuUsage, CpuUsage);
SendMessageW(hStatusWnd, SB_SETTEXT, 1, (LPARAM)Text);
// 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_AddPoint(&PerformancePageCpuUsageHistoryGraph, CpuUsage, CpuKernelUsage);
GraphCtrl_AddPoint(&PerformancePageMemUsageHistoryGraph, nBarsUsed1, nBarsUsed2);
InvalidateRect(hPerformancePageMemUsageHistoryGraph, NULL, FALSE);
InvalidateRect(hPerformancePageCpuUsageHistoryGraph, NULL, FALSE);
}
}
return 0;
}
void PerformancePage_OnViewShowKernelTimes(void)
{
HMENU hMenu;
HMENU hViewMenu;
hMenu = GetMenu(hMainWnd);
hViewMenu = GetSubMenu(hMenu, 2);
if (GetMenuState(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND) & MF_CHECKED)
{
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
TaskManagerSettings.ShowKernelTimes = FALSE;
PerformancePageCpuUsageHistoryGraph.DrawSecondaryPlot = FALSE;
}
else
{
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
TaskManagerSettings.ShowKernelTimes = TRUE;
PerformancePageCpuUsageHistoryGraph.DrawSecondaryPlot = TRUE;
}
GraphCtrl_RedrawBitmap(&PerformancePageCpuUsageHistoryGraph, PerformancePageCpuUsageHistoryGraph.BitmapHeight);
RefreshPerformancePage();
}
void PerformancePage_OnViewCPUHistoryOneGraphAll(void)
{
HMENU hMenu;
HMENU hViewMenu;
HMENU hCPUHistoryMenu;
hMenu = GetMenu(hMainWnd);
hViewMenu = GetSubMenu(hMenu, 2);
hCPUHistoryMenu = GetSubMenu(hViewMenu, 3);
TaskManagerSettings.CPUHistory_OneGraphPerCPU = FALSE;
CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
}
void PerformancePage_OnViewCPUHistoryOneGraphPerCPU(void)
{
HMENU hMenu;
HMENU hViewMenu;
HMENU hCPUHistoryMenu;
hMenu = GetMenu(hMainWnd);
hViewMenu = GetSubMenu(hMenu, 2);
hCPUHistoryMenu = GetSubMenu(hViewMenu, 3);
TaskManagerSettings.CPUHistory_OneGraphPerCPU = TRUE;
CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
}
Reference in a new issue View git blame Copy permalink