mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-31 08:49:15 +00:00
503 lines
21 KiB
C
503 lines
21 KiB
C
/*
|
|
* ReactOS Task Manager
|
|
*
|
|
* perfpage.c
|
|
*
|
|
* Copyright (C) 1999 - 2001 Brian Palmer <brianp@reactos.org>
|
|
* Copyright (C) 2008 Vladimir Pankratov
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */
|
|
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <stdlib.h>
|
|
#include <memory.h>
|
|
#include <stdio.h>
|
|
#include <winnt.h>
|
|
|
|
#include "wine/unicode.h"
|
|
#include "taskmgr.h"
|
|
#include "perfdata.h"
|
|
#include "graphctl.h"
|
|
|
|
TGraphCtrl PerformancePageCpuUsageHistoryGraph;
|
|
TGraphCtrl PerformancePageMemUsageHistoryGraph;
|
|
|
|
HWND hPerformancePage; /* Performance Property Page */
|
|
HWND hPerformancePageCpuUsageGraph; /* CPU Usage Graph */
|
|
HWND hPerformancePageMemUsageGraph; /* MEM Usage Graph */
|
|
HWND hPerformancePageCpuUsageHistoryGraph; /* CPU Usage History Graph */
|
|
HWND hPerformancePageMemUsageHistoryGraph; /* Memory Usage History Graph */
|
|
HWND hPerformancePageTotalsFrame; /* Totals Frame */
|
|
HWND hPerformancePageCommitChargeFrame; /* Commit Charge Frame */
|
|
HWND hPerformancePageKernelMemoryFrame; /* Kernel Memory Frame */
|
|
HWND hPerformancePagePhysicalMemoryFrame; /* Physical Memory Frame */
|
|
HWND hPerformancePageCpuUsageFrame;
|
|
HWND hPerformancePageMemUsageFrame;
|
|
HWND hPerformancePageCpuUsageHistoryFrame;
|
|
HWND hPerformancePageMemUsageHistoryFrame;
|
|
HWND hPerformancePageCommitChargeTotalEdit; /* Commit Charge Total Edit Control */
|
|
HWND hPerformancePageCommitChargeLimitEdit; /* Commit Charge Limit Edit Control */
|
|
HWND hPerformancePageCommitChargePeakEdit; /* Commit Charge Peak Edit Control */
|
|
HWND hPerformancePageKernelMemoryTotalEdit; /* Kernel Memory Total Edit Control */
|
|
HWND hPerformancePageKernelMemoryPagedEdit; /* Kernel Memory Paged Edit Control */
|
|
HWND hPerformancePageKernelMemoryNonPagedEdit; /* Kernel Memory NonPaged Edit Control */
|
|
HWND hPerformancePagePhysicalMemoryTotalEdit; /* Physical Memory Total Edit Control */
|
|
HWND hPerformancePagePhysicalMemoryAvailableEdit; /* Physical Memory Available Edit Control */
|
|
HWND hPerformancePagePhysicalMemorySystemCacheEdit; /* Physical Memory System Cache Edit Control */
|
|
HWND hPerformancePageTotalsHandleCountEdit; /* Total Handles Edit Control */
|
|
HWND hPerformancePageTotalsProcessCountEdit; /* Total Processes Edit Control */
|
|
HWND hPerformancePageTotalsThreadCountEdit; /* Total Threads Edit Control */
|
|
|
|
|
|
static int nPerformancePageWidth;
|
|
static int nPerformancePageHeight;
|
|
static HANDLE hPerformancePageEvent = NULL; /* When this event becomes signaled then we refresh the performance page */
|
|
|
|
static 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)(&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;
|
|
sx = sy = 0;
|
|
SetWindowPos(hCntrl, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
|
|
}
|
|
InvalidateRect(hCntrl, NULL, TRUE);
|
|
}
|
|
|
|
static void AdjustControlPostion(HWND hCntrl, HWND hDlg, int nXDifference, int nYDifference)
|
|
{
|
|
AdjustFrameSize(hCntrl, hDlg, nXDifference, nYDifference, 0);
|
|
}
|
|
|
|
static void AdjustCntrlPos(int ctrl_id, HWND hDlg, int nXDifference, int nYDifference)
|
|
{
|
|
AdjustFrameSize(GetDlgItem(hDlg, ctrl_id), hDlg, nXDifference, nYDifference, 0);
|
|
}
|
|
void RefreshPerformancePage(void)
|
|
{
|
|
/* Signal the event so that our refresh thread */
|
|
/* will wake up and refresh the performance page */
|
|
SetEvent(hPerformancePageEvent);
|
|
}
|
|
|
|
static DWORD WINAPI PerformancePageRefreshThread(void *lpParameter)
|
|
{
|
|
ULONG CommitChargeTotal;
|
|
ULONG CommitChargeLimit;
|
|
ULONG CommitChargePeak;
|
|
|
|
ULONG KernelMemoryTotal;
|
|
ULONG KernelMemoryPaged;
|
|
ULONG KernelMemoryNonPaged;
|
|
|
|
ULONG PhysicalMemoryTotal;
|
|
ULONG PhysicalMemoryAvailable;
|
|
ULONG PhysicalMemorySystemCache;
|
|
|
|
ULONG TotalHandles;
|
|
ULONG TotalThreads;
|
|
ULONG TotalProcesses;
|
|
|
|
WCHAR Text[256];
|
|
|
|
static const WCHAR wszFormatDigit[] = {'%','d',0};
|
|
static const WCHAR wszMemUsage[] = {'M','e','m',' ','U','s','a','g','e',':',' ',
|
|
'%','d','K',' ','/',' ','%','d','K',0};
|
|
|
|
/* Create the event */
|
|
hPerformancePageEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
|
|
|
|
/* If we couldn't create the event then exit the thread */
|
|
if (!hPerformancePageEvent)
|
|
return 0;
|
|
|
|
while (1)
|
|
{
|
|
DWORD dwWaitVal;
|
|
|
|
/* Wait on the event */
|
|
dwWaitVal = WaitForSingleObject(hPerformancePageEvent, INFINITE);
|
|
|
|
/* If the wait failed then the event object must have been */
|
|
/* closed and the task manager is exiting so exit this thread */
|
|
if (dwWaitVal == WAIT_FAILED)
|
|
return 0;
|
|
|
|
if (dwWaitVal == WAIT_OBJECT_0)
|
|
{
|
|
ULONG CpuUsage;
|
|
ULONG CpuKernelUsage;
|
|
int nBarsUsed1;
|
|
int nBarsUsed2;
|
|
|
|
/* Reset our event */
|
|
ResetEvent(hPerformancePageEvent);
|
|
|
|
/*
|
|
* Update the commit charge info
|
|
*/
|
|
CommitChargeTotal = PerfDataGetCommitChargeTotalK();
|
|
CommitChargeLimit = PerfDataGetCommitChargeLimitK();
|
|
CommitChargePeak = PerfDataGetCommitChargePeakK();
|
|
wsprintfW(Text, wszFormatDigit, CommitChargeTotal);
|
|
SetWindowTextW(hPerformancePageCommitChargeTotalEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, CommitChargeLimit);
|
|
SetWindowTextW(hPerformancePageCommitChargeLimitEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, CommitChargePeak);
|
|
SetWindowTextW(hPerformancePageCommitChargePeakEdit, Text);
|
|
wsprintfW(Text, wszMemUsage, CommitChargeTotal, CommitChargeLimit);
|
|
SendMessageW(hStatusWnd, SB_SETTEXTW, 2, (LPARAM)Text);
|
|
|
|
/*
|
|
* Update the kernel memory info
|
|
*/
|
|
KernelMemoryTotal = PerfDataGetKernelMemoryTotalK();
|
|
KernelMemoryPaged = PerfDataGetKernelMemoryPagedK();
|
|
KernelMemoryNonPaged = PerfDataGetKernelMemoryNonPagedK();
|
|
wsprintfW(Text, wszFormatDigit, KernelMemoryTotal);
|
|
SetWindowTextW(hPerformancePageKernelMemoryTotalEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, KernelMemoryPaged);
|
|
SetWindowTextW(hPerformancePageKernelMemoryPagedEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, KernelMemoryNonPaged);
|
|
SetWindowTextW(hPerformancePageKernelMemoryNonPagedEdit, Text);
|
|
|
|
/*
|
|
* Update the physical memory info
|
|
*/
|
|
PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK();
|
|
PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK();
|
|
PhysicalMemorySystemCache = PerfDataGetPhysicalMemorySystemCacheK();
|
|
wsprintfW(Text, wszFormatDigit, PhysicalMemoryTotal);
|
|
SetWindowTextW(hPerformancePagePhysicalMemoryTotalEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, PhysicalMemoryAvailable);
|
|
SetWindowTextW(hPerformancePagePhysicalMemoryAvailableEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, PhysicalMemorySystemCache);
|
|
SetWindowTextW(hPerformancePagePhysicalMemorySystemCacheEdit, Text);
|
|
|
|
/*
|
|
* Update the totals info
|
|
*/
|
|
TotalHandles = PerfDataGetSystemHandleCount();
|
|
TotalThreads = PerfDataGetTotalThreadCount();
|
|
TotalProcesses = PerfDataGetProcessCount();
|
|
wsprintfW(Text, wszFormatDigit, TotalHandles);
|
|
SetWindowTextW(hPerformancePageTotalsHandleCountEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, TotalThreads);
|
|
SetWindowTextW(hPerformancePageTotalsThreadCountEdit, Text);
|
|
wsprintfW(Text, wszFormatDigit, TotalProcesses);
|
|
SetWindowTextW(hPerformancePageTotalsProcessCountEdit, Text);
|
|
|
|
/*
|
|
* Redraw the graphs
|
|
*/
|
|
InvalidateRect(hPerformancePageCpuUsageGraph, NULL, FALSE);
|
|
InvalidateRect(hPerformancePageMemUsageGraph, NULL, FALSE);
|
|
|
|
/*
|
|
* Get the CPU usage
|
|
*/
|
|
CpuUsage = PerfDataGetProcessorUsage();
|
|
CpuKernelUsage = PerfDataGetProcessorSystemUsage();
|
|
|
|
/*
|
|
* Get the memory usage
|
|
*/
|
|
CommitChargeTotal = (ULONGLONG)PerfDataGetCommitChargeTotalK();
|
|
CommitChargeLimit = (ULONGLONG)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;
|
|
}
|
|
|
|
INT_PTR CALLBACK
|
|
PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
RECT rc;
|
|
int nXDifference;
|
|
int nYDifference;
|
|
|
|
/* HDC hdc; */
|
|
/* PAINTSTRUCT ps; */
|
|
|
|
switch (message) {
|
|
case WM_INITDIALOG:
|
|
|
|
/* 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
|
|
*/
|
|
hPerformancePageTotalsFrame = GetDlgItem(hDlg, IDC_TOTALS_FRAME);
|
|
hPerformancePageCommitChargeFrame = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_FRAME);
|
|
hPerformancePageKernelMemoryFrame = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_FRAME);
|
|
hPerformancePagePhysicalMemoryFrame = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_FRAME);
|
|
|
|
hPerformancePageCpuUsageFrame = GetDlgItem(hDlg, IDC_CPU_USAGE_FRAME);
|
|
hPerformancePageMemUsageFrame = GetDlgItem(hDlg, IDC_MEM_USAGE_FRAME);
|
|
hPerformancePageCpuUsageHistoryFrame = GetDlgItem(hDlg, IDC_CPU_USAGE_HISTORY_FRAME);
|
|
hPerformancePageMemUsageHistoryFrame = GetDlgItem(hDlg, IDC_MEMORY_USAGE_HISTORY_FRAME);
|
|
|
|
hPerformancePageCommitChargeTotalEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_TOTAL);
|
|
hPerformancePageCommitChargeLimitEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_LIMIT);
|
|
hPerformancePageCommitChargePeakEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_PEAK);
|
|
hPerformancePageKernelMemoryTotalEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_TOTAL);
|
|
hPerformancePageKernelMemoryPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_PAGED);
|
|
hPerformancePageKernelMemoryNonPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_NONPAGED);
|
|
hPerformancePagePhysicalMemoryTotalEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_TOTAL);
|
|
hPerformancePagePhysicalMemoryAvailableEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_AVAILABLE);
|
|
hPerformancePagePhysicalMemorySystemCacheEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_SYSTEM_CACHE);
|
|
hPerformancePageTotalsHandleCountEdit = GetDlgItem(hDlg, IDC_TOTALS_HANDLE_COUNT);
|
|
hPerformancePageTotalsProcessCountEdit = GetDlgItem(hDlg, IDC_TOTALS_PROCESS_COUNT);
|
|
hPerformancePageTotalsThreadCountEdit = GetDlgItem(hDlg, IDC_TOTALS_THREAD_COUNT);
|
|
|
|
hPerformancePageCpuUsageGraph = GetDlgItem(hDlg, IDC_CPU_USAGE_GRAPH);
|
|
hPerformancePageMemUsageGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_GRAPH);
|
|
hPerformancePageMemUsageHistoryGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_HISTORY_GRAPH);
|
|
hPerformancePageCpuUsageHistoryGraph = GetDlgItem(hDlg, IDC_CPU_USAGE_HISTORY_GRAPH);
|
|
|
|
GetClientRect(hPerformancePageCpuUsageHistoryGraph, &rc);
|
|
/* create the control */
|
|
/* PerformancePageCpuUsageHistoryGraph.Create(0, rc, hDlg, IDC_CPU_USAGE_HISTORY_GRAPH); */
|
|
GraphCtrl_Create(&PerformancePageCpuUsageHistoryGraph, hPerformancePageCpuUsageHistoryGraph, hDlg, IDC_CPU_USAGE_HISTORY_GRAPH);
|
|
/* customize the control */
|
|
GraphCtrl_SetRange(&PerformancePageCpuUsageHistoryGraph, 0.0, 100.0, 10);
|
|
/* PerformancePageCpuUsageHistoryGraph.SetYUnits("Current") ; */
|
|
/* PerformancePageCpuUsageHistoryGraph.SetXUnits("Samples (Windows Timer: 100 msec)") ; */
|
|
/* PerformancePageCpuUsageHistoryGraph.SetBackgroundColor(RGB(0, 0, 64)) ; */
|
|
/* PerformancePageCpuUsageHistoryGraph.SetGridColor(RGB(192, 192, 255)) ; */
|
|
/* PerformancePageCpuUsageHistoryGraph.SetPlotColor(RGB(255, 255, 255)) ; */
|
|
GraphCtrl_SetBackgroundColor(&PerformancePageCpuUsageHistoryGraph, RGB(0, 0, 0)) ;
|
|
GraphCtrl_SetGridColor(&PerformancePageCpuUsageHistoryGraph, RGB(152, 205, 152)) ;
|
|
GraphCtrl_SetPlotColor(&PerformancePageCpuUsageHistoryGraph, 0, RGB(255, 0, 0)) ;
|
|
GraphCtrl_SetPlotColor(&PerformancePageCpuUsageHistoryGraph, 1, RGB(0, 255, 0)) ;
|
|
|
|
GetClientRect(hPerformancePageMemUsageHistoryGraph, &rc);
|
|
GraphCtrl_Create(&PerformancePageMemUsageHistoryGraph, hPerformancePageMemUsageHistoryGraph, hDlg, IDC_MEM_USAGE_HISTORY_GRAPH);
|
|
GraphCtrl_SetRange(&PerformancePageMemUsageHistoryGraph, 0.0, 100.0, 10) ;
|
|
GraphCtrl_SetBackgroundColor(&PerformancePageMemUsageHistoryGraph, RGB(0, 0, 0)) ;
|
|
GraphCtrl_SetGridColor(&PerformancePageMemUsageHistoryGraph, RGB(152, 215, 152)) ;
|
|
GraphCtrl_SetPlotColor(&PerformancePageMemUsageHistoryGraph, 0, RGB(255, 255, 0)) ;
|
|
/* Start our refresh thread */
|
|
#ifdef RUN_PERF_PAGE
|
|
CreateThread(NULL, 0, PerformancePageRefreshThread, NULL, 0, NULL);
|
|
#endif
|
|
|
|
/*
|
|
* Subclass graph buttons
|
|
*/
|
|
OldGraphWndProc = (WNDPROC)SetWindowLongPtr(hPerformancePageCpuUsageGraph, GWLP_WNDPROC, (LONG_PTR)Graph_WndProc);
|
|
SetWindowLongPtr(hPerformancePageMemUsageGraph, GWLP_WNDPROC, (LONG_PTR)Graph_WndProc);
|
|
OldGraphCtrlWndProc = (WNDPROC)SetWindowLongPtr(hPerformancePageMemUsageHistoryGraph, GWLP_WNDPROC, (LONG_PTR)GraphCtrl_WndProc);
|
|
SetWindowLongPtr(hPerformancePageCpuUsageHistoryGraph, GWLP_WNDPROC, (LONG_PTR)GraphCtrl_WndProc);
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
break;
|
|
#if 0
|
|
case WM_NCPAINT:
|
|
hdc = GetDC(hDlg);
|
|
GetClientRect(hDlg, &rc);
|
|
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
|
|
ReleaseDC(hDlg, hdc);
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
hdc = BeginPaint(hDlg, &ps);
|
|
GetClientRect(hDlg, &rc);
|
|
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
|
|
EndPaint(hDlg, &ps);
|
|
break;
|
|
#endif
|
|
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(hPerformancePageTotalsFrame, hDlg, 0, nYDifference, 0);
|
|
AdjustFrameSize(hPerformancePageCommitChargeFrame, hDlg, 0, nYDifference, 0);
|
|
AdjustFrameSize(hPerformancePageKernelMemoryFrame, hDlg, 0, nYDifference, 0);
|
|
AdjustFrameSize(hPerformancePagePhysicalMemoryFrame, 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);
|
|
|
|
AdjustControlPostion(hPerformancePageCommitChargeTotalEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageCommitChargeLimitEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageCommitChargePeakEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageKernelMemoryTotalEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageKernelMemoryPagedEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageKernelMemoryNonPagedEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePagePhysicalMemoryTotalEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePagePhysicalMemoryAvailableEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePagePhysicalMemorySystemCacheEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageTotalsHandleCountEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageTotalsProcessCountEdit, hDlg, 0, nYDifference);
|
|
AdjustControlPostion(hPerformancePageTotalsThreadCountEdit, hDlg, 0, nYDifference);
|
|
|
|
{
|
|
static int lastX, lastY;
|
|
|
|
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(hPerformancePageCpuUsageFrame, hDlg, nXDifference, nYDifference, 1);
|
|
AdjustFrameSize(hPerformancePageMemUsageFrame, hDlg, nXDifference, nYDifference, 2);
|
|
AdjustFrameSize(hPerformancePageCpuUsageHistoryFrame, hDlg, nXDifference, nYDifference, 3);
|
|
AdjustFrameSize(hPerformancePageMemUsageHistoryFrame, hDlg, nXDifference, nYDifference, 4);
|
|
AdjustFrameSize(hPerformancePageCpuUsageGraph, hDlg, nXDifference, nYDifference, 1);
|
|
AdjustFrameSize(hPerformancePageMemUsageGraph, hDlg, nXDifference, nYDifference, 2);
|
|
AdjustFrameSize(hPerformancePageCpuUsageHistoryGraph, hDlg, nXDifference, nYDifference, 3);
|
|
AdjustFrameSize(hPerformancePageMemUsageHistoryGraph, hDlg, nXDifference, nYDifference, 4);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void PerformancePage_OnViewShowKernelTimes(void)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hViewMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
|
|
/* Check or uncheck the show 16-bit tasks menu item */
|
|
if (GetMenuState(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND) & MF_CHECKED)
|
|
{
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
|
|
TaskManagerSettings.ShowKernelTimes = FALSE;
|
|
}
|
|
else
|
|
{
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
|
|
TaskManagerSettings.ShowKernelTimes = TRUE;
|
|
}
|
|
|
|
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);
|
|
}
|