1809 lines
49 KiB
C++
1809 lines
49 KiB
C++
// TaskMan - NT TaskManager
|
|
// Copyright (C) Microsoft
|
|
|
|
// File: perfpage.cpp
|
|
|
|
// History: Nov-10-95 DavePl Created
|
|
|
|
#include "precomp.h"
|
|
|
|
// Size macros for the bitmap we use to draw LED digits
|
|
|
|
#define DIGITS_STRIP_WIDTH 96
|
|
#define DIGITS_STRIP_HEIGHT 11
|
|
#define DIGIT_WIDTH 8
|
|
#define DIGIT_HEIGHT (DIGITS_STRIP_HEIGHT)
|
|
#define PERCENT_SIGN_INDEX 10 // Index into bitmap strip where % sign lives
|
|
#define K_INDEX 11 // Index into bitmap strip where "K" lives
|
|
#define BLANK_INDEX 12 // Index into bitmap where blank digit lives
|
|
|
|
#define GRAPH_BRUSH BLACK_BRUSH
|
|
#define GRAPH_LINE_COLOR RGB(0, 128, 64)
|
|
|
|
#define STRIP_HEIGHT 75
|
|
#define STRIP_WIDTH 33
|
|
|
|
LARGE_INTEGER PreviousCPUIdleTime[MAX_PROCESSOR] = {0 ,0};
|
|
LARGE_INTEGER PreviousCPUTotalTime[MAX_PROCESSOR] = {0 ,0};
|
|
LARGE_INTEGER PreviousCPUKernelTime[MAX_PROCESSOR] = {0 ,0};
|
|
|
|
LPBYTE g_pCPUHistory[MAX_PROCESSOR] = { NULL };
|
|
LPBYTE g_pKernelHistory[MAX_PROCESSOR] = { NULL };
|
|
LPBYTE g_pMEMHistory = NULL;
|
|
|
|
BYTE g_CPUUsage = 0;
|
|
BYTE g_KernelUsage = 0;
|
|
DWORD g_MEMUsage = 0;
|
|
DWORD g_MEMMax = 0;
|
|
|
|
DWORD g_PageSize;
|
|
|
|
|
|
/*++ CPerfPage::SizePerfPage
|
|
|
|
Routine Description:
|
|
Sizes its children based on the size of the
|
|
tab control on which it appears. Welcome to
|
|
sizing hell.
|
|
|
|
Revision History:
|
|
Nov-12-95 Davepl Created
|
|
--*/
|
|
|
|
static const INT aPerfControls[] =
|
|
{
|
|
IDC_STATIC1,
|
|
IDC_STATIC2,
|
|
IDC_STATIC3,
|
|
IDC_STATIC4,
|
|
IDC_STATIC5,
|
|
IDC_STATIC6,
|
|
IDC_STATIC8,
|
|
IDC_STATIC9,
|
|
IDC_STATIC10,
|
|
IDC_STATIC11,
|
|
IDC_STATIC12,
|
|
IDC_STATIC13,
|
|
IDC_STATIC14,
|
|
IDC_STATIC15,
|
|
IDC_STATIC16,
|
|
IDC_STATIC17,
|
|
IDC_TOTAL_PHYSICAL,
|
|
IDC_AVAIL_PHYSICAL,
|
|
IDC_FILE_CACHE,
|
|
IDC_COMMIT_TOTAL,
|
|
IDC_COMMIT_LIMIT,
|
|
IDC_COMMIT_PEAK,
|
|
IDC_KERNEL_TOTAL,
|
|
IDC_KERNEL_PAGED,
|
|
IDC_KERNEL_NONPAGED,
|
|
IDC_TOTAL_HANDLES,
|
|
IDC_TOTAL_THREADS,
|
|
IDC_TOTAL_PROCESSES,
|
|
};
|
|
|
|
// Amount of spacing down from the top of a group box to the
|
|
// control it contains
|
|
|
|
void CPerfPage::SizePerfPage()
|
|
{
|
|
// Get the coords of the tab control
|
|
|
|
RECT rcParent;
|
|
|
|
if (g_Options.m_fNoTitle)
|
|
{
|
|
GetClientRect(g_hMainWnd, &rcParent);
|
|
}
|
|
else
|
|
{
|
|
GetClientRect(m_hwndTabs, &rcParent);
|
|
MapWindowPoints(m_hwndTabs, m_hPage, (LPPOINT) &rcParent, 2);
|
|
TabCtrl_AdjustRect(m_hwndTabs, FALSE, &rcParent);
|
|
}
|
|
|
|
HDWP hdwp = BeginDeferWindowPos(10);
|
|
|
|
// Calc the deltas in the x and y positions that we need to
|
|
// move each of the child controls
|
|
|
|
RECT rcMaster;
|
|
HWND hwndMaster = GetDlgItem(m_hPage, IDC_STATIC5);
|
|
GetWindowRect(hwndMaster, &rcMaster);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcMaster, 2);
|
|
|
|
INT dy = ((rcParent.bottom - g_DefSpacing * 2) - rcMaster.bottom);
|
|
|
|
// Move each of the child controls by the above delta
|
|
|
|
for (int i = 0; i < ARRAYSIZE(aPerfControls); i++)
|
|
{
|
|
HWND hwndCtrl = GetDlgItem(m_hPage, aPerfControls[i]);
|
|
RECT rcCtrl;
|
|
GetWindowRect(hwndCtrl, &rcCtrl);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcCtrl, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndCtrl, NULL,
|
|
rcCtrl.left,
|
|
rcCtrl.top + dy,
|
|
0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
HWND hwndTopFrame = GetDlgItem(m_hPage, IDC_STATIC13);
|
|
RECT rcTopFrame;
|
|
GetWindowRect(hwndTopFrame, &rcTopFrame);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcTopFrame, 2);
|
|
INT yTop = rcTopFrame.top + dy;
|
|
|
|
INT yHist;
|
|
if (g_Options.m_fNoTitle)
|
|
{
|
|
yHist = rcParent.bottom - rcParent.top - g_DefSpacing * 2;
|
|
}
|
|
else
|
|
{
|
|
yHist = (yTop - g_DefSpacing * 3) / 2;
|
|
}
|
|
|
|
// Size the CPU history frame
|
|
|
|
RECT rcFrame;
|
|
HWND hwndFrame = GetDlgItem(m_hPage, IDC_CPUFRAME);
|
|
GetWindowRect(hwndFrame, &rcFrame);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcFrame, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndFrame, NULL, 0, 0,
|
|
(rcParent.right - rcFrame.left) - g_DefSpacing * 2,
|
|
yHist,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
// Size the CPU bar graph frame
|
|
|
|
|
|
RECT rcCPUFrame;
|
|
HWND hwndCPUFrame = GetDlgItem(m_hPage, IDC_STATIC);
|
|
GetWindowRect(hwndCPUFrame, &rcCPUFrame);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcCPUFrame, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndCPUFrame, NULL, 0, 0,
|
|
(rcCPUFrame.right - rcCPUFrame.left),
|
|
yHist,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
RECT rcCPUBAR;
|
|
HWND hwndCPUBAR = GetDlgItem(m_hPage, IDC_CPUMETER);
|
|
GetWindowRect(hwndCPUBAR, &rcCPUBAR);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcCPUBAR, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndCPUBAR, NULL, rcCPUFrame.left + g_InnerSpacing * 2, rcCPUFrame.top + g_TopSpacing,
|
|
(rcCPUBAR.right - rcCPUBAR.left),
|
|
yHist - g_TopSpacing - g_InnerSpacing * 2 ,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
// Size the mem bar graph frame
|
|
|
|
|
|
RECT rcMEMFrame;
|
|
HWND hwndMEMFrame = GetDlgItem(m_hPage, IDC_MEMBARFRAME);
|
|
GetWindowRect(hwndMEMFrame, &rcMEMFrame);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcMEMFrame, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndMEMFrame, NULL, rcMEMFrame.left, yHist + g_DefSpacing * 2,
|
|
(rcMEMFrame.right - rcMEMFrame.left),
|
|
yHist,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
RECT rcMEMBAR;
|
|
HWND hwndMEMBAR = GetDlgItem(m_hPage, IDC_MEMMETER);
|
|
GetWindowRect(hwndMEMBAR, &rcMEMBAR);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcMEMBAR, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndMEMBAR, NULL, rcMEMBAR.left, yHist + g_DefSpacing * 2 + g_TopSpacing,
|
|
(rcMEMBAR.right - rcMEMBAR.left),
|
|
yHist - g_InnerSpacing * 2 - g_TopSpacing,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
// Size the Memory history frame
|
|
|
|
RECT rcMemFrame;
|
|
HWND hwndMemFrame = GetDlgItem(m_hPage, IDC_MEMFRAME);
|
|
GetWindowRect(hwndMemFrame, &rcMemFrame);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcMemFrame, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndMemFrame, NULL, rcMemFrame.left, yHist + g_DefSpacing * 2,
|
|
(rcParent.right - rcMemFrame.left) - g_DefSpacing * 2,
|
|
yHist,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
|
|
// We have N panes, where N is 1 or g_cProcessors depending on what mode the
|
|
// cpu meter is currently in
|
|
|
|
INT cPanes = (CM_PANES == g_Options.m_cmHistMode) ? g_cProcessors : 1;
|
|
|
|
// Total amount of room available for all of the panes
|
|
|
|
INT Width = (rcParent.right - rcParent.left) - (rcFrame.left - rcParent.left) - g_DefSpacing * 2
|
|
- g_InnerSpacing * 3;
|
|
|
|
// Use this width to size the memory graph
|
|
|
|
HWND hwndButton = GetDlgItem(m_hPage, IDC_MEMGRAPH);
|
|
RECT rcButton;
|
|
GetWindowRect(hwndButton, &rcButton);
|
|
MapWindowPoints(NULL, m_hPage, (LPPOINT) &rcButton, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndButton, NULL, rcFrame.left + g_InnerSpacing * 2,
|
|
yHist + g_DefSpacing * 2 + g_TopSpacing,
|
|
Width - g_InnerSpacing,
|
|
yHist - g_InnerSpacing * 2 - g_TopSpacing,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
// Total amount of room available for each CPU pane
|
|
|
|
Width -= cPanes * g_InnerSpacing;
|
|
Width /= cPanes;
|
|
Width = Width >= 0 ? Width : 0;
|
|
|
|
for (i = 0; i < cPanes; i++)
|
|
{
|
|
HWND hwndButton = GetDlgItem(m_hPage, IDC_CPUGRAPH + i);
|
|
|
|
INT left = rcFrame.left + g_InnerSpacing * (i + 2) + Width * i;
|
|
|
|
DeferWindowPos(hdwp,
|
|
hwndButton,
|
|
NULL,
|
|
left, rcFrame.top + g_TopSpacing,
|
|
Width,
|
|
yHist - g_InnerSpacing * 2 -g_TopSpacing,
|
|
#if 0
|
|
/* the following code doesn't make any sense... Either way, 0 is passed in */
|
|
SWP_NOZORDER | SWP_NOACTIVATE | i == 0 ? 0 : 0); // Don't move first button
|
|
#else
|
|
0 ); // Don't move first button
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
// Create new bitmaps to be used in the history windows
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
|
|
GetClientRect(hwndButton, &rcButton);
|
|
FreeMemoryBitmaps(); // Free any old ones
|
|
CreateMemoryBitmaps(rcButton.right - rcButton.left, rcButton.bottom - rcButton.top);
|
|
|
|
}
|
|
|
|
/*++ CPerfPage::CreatePens
|
|
|
|
Routine Description:
|
|
|
|
Creates 8 different colors pens, saves them in
|
|
the pen array
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
static const COLORREF aColors[] =
|
|
{
|
|
RGB(000, 255, 000),
|
|
RGB(255, 000, 000),
|
|
RGB(255, 000, 255),
|
|
RGB(000, 000, 255),
|
|
RGB(000, 255, 255),
|
|
RGB(255, 128, 000),
|
|
RGB(255, 000, 255),
|
|
RGB(000, 128, 255),
|
|
|
|
// End of CPU pens
|
|
|
|
#define MEM_PEN 8
|
|
|
|
RGB(255, 255, 0),
|
|
|
|
};
|
|
|
|
void CPerfPage::CreatePens()
|
|
{
|
|
for (int i = 0; i < ARRAYSIZE(aColors); i++)
|
|
{
|
|
// Create then pen. If a failure occurs, just substitute
|
|
// the white pen
|
|
|
|
m_hPens[i] = CreatePen(PS_SOLID, 1, aColors[i]);
|
|
if (NULL == m_hPens[i])
|
|
{
|
|
m_hPens[i] = (HPEN) GetStockObject(WHITE_PEN);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPerfPage::ReleasePens()
|
|
{
|
|
for (int i = 0; i < NUM_PENS; i++)
|
|
{
|
|
if (m_hPens[i])
|
|
{
|
|
DeleteObject(m_hPens[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*++ CPerfPage::DrawGraphPaper
|
|
|
|
Routine Description:
|
|
|
|
Draws a graph-paper-like grid into a memory bitmap
|
|
|
|
Arguments:
|
|
|
|
hdcGraph - HDC to draw into
|
|
prcGraph - RECT describing area to draw
|
|
Width - Amount, on right side, to actually draw
|
|
|
|
Revision History:
|
|
|
|
Jan-17-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
static int g_Scrollamount = 0;
|
|
|
|
void DrawGraphPaper(HDC hdcGraph, RECT * prcGraph, int Width)
|
|
{
|
|
#define GRAPHPAPERSIZE 12
|
|
|
|
int Leftside = prcGraph->right - Width;
|
|
|
|
// Only one of the many graphs needs to ask us to scroll
|
|
|
|
HPEN hPen = CreatePen(PS_SOLID, 1, GRAPH_LINE_COLOR);
|
|
|
|
HGDIOBJ hOld = SelectObject(hdcGraph, hPen);
|
|
|
|
for (int i = GRAPHPAPERSIZE - 1; i < prcGraph->bottom - prcGraph->top; i+= GRAPHPAPERSIZE)
|
|
{
|
|
MoveToEx(hdcGraph,
|
|
Leftside,
|
|
i + prcGraph->top,
|
|
(LPPOINT) NULL);
|
|
|
|
LineTo(hdcGraph,
|
|
prcGraph->right,
|
|
i + prcGraph->top);
|
|
}
|
|
|
|
for (i = prcGraph->right - g_Scrollamount; i > Leftside; i -= GRAPHPAPERSIZE)
|
|
{
|
|
MoveToEx(hdcGraph,
|
|
i,
|
|
prcGraph->top,
|
|
(LPPOINT) NULL);
|
|
|
|
LineTo(hdcGraph,
|
|
i,
|
|
prcGraph->bottom);
|
|
}
|
|
|
|
if (hOld)
|
|
{
|
|
SelectObject(hdcGraph, hOld);
|
|
}
|
|
|
|
DeleteObject(hPen);
|
|
}
|
|
|
|
/*++ CPerfPage::TextToLegend
|
|
|
|
Routine Description:
|
|
|
|
Given the DC, an X, a Y, and a string, writes that string out
|
|
to the legend and returns the new X.
|
|
|
|
Return Value:
|
|
|
|
New X pos in the legend
|
|
|
|
Revision History:
|
|
|
|
Jan-18-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
int CPerfPage::TextToLegend(HDC hDC, int xPos, int yPos, LPCTSTR szCPUName)
|
|
{
|
|
int cchText = lstrlen(szCPUName);
|
|
TextOut(hDC, xPos, yPos, szCPUName, cchText);
|
|
|
|
SIZE size;
|
|
GetTextExtentPoint32(hDC, szCPUName, cchText, &size);
|
|
|
|
return xPos + size.cx;
|
|
}
|
|
|
|
|
|
/*++ CPerfPage::DrawCPUGraph
|
|
|
|
Routine Description:
|
|
|
|
Draws the CPU graph (which is an ownerdraw control)
|
|
|
|
Arguments:
|
|
|
|
lpdi - LPDRAWITEMSTRUCT describing area we need to paint
|
|
iPane - Pane number to be drawn (ie: which CPU)
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
void CPerfPage::DrawCPUGraph(LPDRAWITEMSTRUCT lpdi, UINT iPane)
|
|
{
|
|
#define THISCPU 0
|
|
|
|
if (NULL == m_hdcGraph)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FillRect(m_hdcGraph, &m_rcGraph, (HBRUSH) GetStockObject(GRAPH_BRUSH));
|
|
|
|
int Width = lpdi->rcItem.right - lpdi->rcItem.left;
|
|
int Scale = (Width - 1) / HIST_SIZE;
|
|
if (0 == Scale)
|
|
{
|
|
Scale = 2;
|
|
}
|
|
|
|
// Draw the CPU history graph
|
|
|
|
DrawGraphPaper(m_hdcGraph, &m_rcGraph, Width);
|
|
|
|
int GraphHeight = m_rcGraph.bottom - m_rcGraph.top - 1;
|
|
int GraphWidth = m_rcGraph.right - m_rcGraph.left + 1;
|
|
|
|
|
|
if (g_Options.m_cmHistMode == CM_PANES)
|
|
{
|
|
// Draw the kernel times
|
|
|
|
if (g_Options.m_fKernelTimes)
|
|
{
|
|
HGDIOBJ hOld = SelectObject(m_hdcGraph, m_hPens[1]);
|
|
|
|
MoveToEx(m_hdcGraph,
|
|
m_rcGraph.right,
|
|
m_rcGraph.bottom - (g_pKernelHistory[iPane][0] * GraphHeight) / 100,
|
|
(LPPOINT) NULL);
|
|
|
|
for (int i = 0; i < HIST_SIZE && i * Scale < Width; i++)
|
|
{
|
|
LineTo(m_hdcGraph,
|
|
m_rcGraph.right - Scale * i,
|
|
m_rcGraph.bottom - (g_pKernelHistory[iPane][i] * GraphHeight) / 100);
|
|
}
|
|
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, hOld);
|
|
}
|
|
|
|
// Draw a particular CPU in its pane
|
|
|
|
HGDIOBJ hOld = SelectObject(m_hdcGraph, m_hPens[0]);
|
|
|
|
MoveToEx(m_hdcGraph,
|
|
m_rcGraph.right,
|
|
m_rcGraph.bottom - (g_pCPUHistory[iPane][0] * GraphHeight) / 100,
|
|
(LPPOINT) NULL);
|
|
|
|
for (int i = 0; i < HIST_SIZE && i * Scale < Width; i++)
|
|
{
|
|
LineTo(m_hdcGraph,
|
|
m_rcGraph.right - Scale * i,
|
|
m_rcGraph.bottom - (g_pCPUHistory[iPane][i] * GraphHeight) / 100);
|
|
}
|
|
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, hOld);
|
|
|
|
}
|
|
else
|
|
{
|
|
ASSERT(iPane == 0);
|
|
|
|
// Draw the kernel times
|
|
|
|
if (g_Options.m_fKernelTimes)
|
|
{
|
|
HGDIOBJ hOld = SelectObject(m_hdcGraph, m_hPens[1]);
|
|
|
|
DWORD dwSum = 0;
|
|
|
|
for (int iCPU = 0; iCPU < g_cProcessors; iCPU++)
|
|
{
|
|
dwSum += g_pKernelHistory[iCPU][0];
|
|
}
|
|
dwSum /= g_cProcessors;
|
|
|
|
MoveToEx(m_hdcGraph, m_rcGraph.right, m_rcGraph.bottom - (dwSum * GraphHeight) / 100, (LPPOINT) NULL);
|
|
|
|
for (int i = 0; i < HIST_SIZE && i * Scale < Width; i++)
|
|
{
|
|
dwSum = 0;
|
|
|
|
for (iCPU = 0; iCPU < g_cProcessors; iCPU++)
|
|
{
|
|
dwSum += g_pKernelHistory[iCPU][i];
|
|
}
|
|
|
|
dwSum /= g_cProcessors;
|
|
|
|
LineTo(m_hdcGraph, m_rcGraph.right - Scale * i, m_rcGraph.bottom - (dwSum * GraphHeight) / 100);
|
|
}
|
|
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, hOld);
|
|
}
|
|
|
|
// Draw History as a sum of all CPUs
|
|
|
|
HGDIOBJ hOld = SelectObject(m_hdcGraph, m_hPens[0]);
|
|
|
|
DWORD dwSum = 0;
|
|
|
|
for (int iCPU = 0; iCPU < g_cProcessors; iCPU++)
|
|
{
|
|
dwSum += g_pCPUHistory[iCPU][0];
|
|
}
|
|
dwSum /= g_cProcessors;
|
|
|
|
MoveToEx(m_hdcGraph, m_rcGraph.right, m_rcGraph.bottom - (dwSum * GraphHeight) / 100, (LPPOINT) NULL);
|
|
|
|
for (int i = 0; i < HIST_SIZE && i * Scale < Width; i++)
|
|
{
|
|
dwSum = 0;
|
|
|
|
for (iCPU = 0; iCPU < g_cProcessors; iCPU++)
|
|
{
|
|
dwSum += g_pCPUHistory[iCPU][i];
|
|
}
|
|
|
|
dwSum /= g_cProcessors;
|
|
|
|
LineTo(m_hdcGraph, m_rcGraph.right - Scale * i, m_rcGraph.bottom - (dwSum * GraphHeight) / 100);
|
|
}
|
|
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, hOld);
|
|
}
|
|
|
|
// Memory bitmap could be wider than the target control, so find a delta
|
|
|
|
INT xDiff = (m_rcGraph.right - m_rcGraph.left) - (lpdi->rcItem.right - lpdi->rcItem.left);
|
|
|
|
BitBlt( lpdi->hDC,
|
|
lpdi->rcItem.left,
|
|
lpdi->rcItem.top,
|
|
lpdi->rcItem.right - lpdi->rcItem.left,
|
|
lpdi->rcItem.bottom - lpdi->rcItem.top,
|
|
m_hdcGraph,
|
|
xDiff,
|
|
0,
|
|
SRCCOPY);
|
|
}
|
|
|
|
|
|
/*++ CPerfPage::DrawMEMGraph
|
|
|
|
Routine Description:
|
|
Draws the Memory history graph (which is an ownerdraw control)
|
|
|
|
Arguments:
|
|
lpdi - LPDRAWITEMSTRUCT describing area we need to paint
|
|
|
|
Revision History:
|
|
Nov-12-95 Davepl Created
|
|
--*/
|
|
void CPerfPage::DrawMEMGraph(LPDRAWITEMSTRUCT lpdi)
|
|
{
|
|
#define THISCPU 0
|
|
|
|
if (NULL == m_hdcGraph)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FillRect(m_hdcGraph, &m_rcGraph, (HBRUSH) GetStockObject(GRAPH_BRUSH));
|
|
|
|
int Width = lpdi->rcItem.right - lpdi->rcItem.left;
|
|
|
|
DrawGraphPaper(m_hdcGraph, &m_rcGraph, Width);
|
|
|
|
int Scale = (Width - 1) / HIST_SIZE;
|
|
if (0 == Scale)
|
|
{
|
|
Scale = 2;
|
|
}
|
|
|
|
int GraphHeight = m_rcGraph.bottom - m_rcGraph.top - 1;
|
|
|
|
HGDIOBJ hOld = SelectObject(m_hdcGraph, m_hPens[MEM_PEN]);
|
|
|
|
MoveToEx(m_hdcGraph,
|
|
m_rcGraph.right,
|
|
m_rcGraph.bottom - (g_pMEMHistory[0] * GraphHeight) / 100,
|
|
(LPPOINT) NULL);
|
|
|
|
for (int i = 0; i < HIST_SIZE && i * Scale < Width - 1; i++)
|
|
{
|
|
if (0 == g_pMEMHistory[i])
|
|
{
|
|
break; // End of Data
|
|
}
|
|
|
|
LineTo(m_hdcGraph,
|
|
m_rcGraph.right - Scale * i,
|
|
m_rcGraph.bottom - (g_pMEMHistory[i] * GraphHeight) / 100);
|
|
}
|
|
|
|
BitBlt( lpdi->hDC,
|
|
lpdi->rcItem.left,
|
|
lpdi->rcItem.top,
|
|
lpdi->rcItem.right - lpdi->rcItem.left,
|
|
lpdi->rcItem.bottom - lpdi->rcItem.top,
|
|
m_hdcGraph,
|
|
0,
|
|
0,
|
|
SRCCOPY);
|
|
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, hOld);
|
|
|
|
}
|
|
|
|
/*++ CPerfPage::UpdateGraphs
|
|
|
|
Routine Description:
|
|
|
|
Adds and removed CPU panes as required
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Revision History:
|
|
|
|
Dec-16-96 Davepl Create
|
|
|
|
***/
|
|
|
|
// WARNING: CPU pane IDs must be contiguous in resource.h
|
|
|
|
#define ID_FIRSTPANE IDC_CPUGRAPH
|
|
#define ID_LASTPANE IDC_CPUGRAPH32
|
|
#define NUMPANES 32
|
|
|
|
void CPerfPage::UpdateGraphs()
|
|
{
|
|
// WARNING: CPU pane IDs must be contiguous in resource.h
|
|
|
|
ASSERT(ID_LASTPANE - ID_FIRSTPANE == (NUMPANES - 1));
|
|
|
|
// Turn the extra windows on or off as required
|
|
|
|
for (UINT i = 1; i < g_cProcessors && i < NUMPANES; i++)
|
|
{
|
|
ShowWindow(GetDlgItem(m_hPage, ID_FIRSTPANE + i),
|
|
CM_PANES == g_Options.m_cmHistMode ? SW_SHOW : SW_HIDE);
|
|
}
|
|
|
|
// Hide/show everything but the CPU meters when we're in notitle/title mode
|
|
|
|
for (i = 0; i < ARRAYSIZE(aPerfControls); i++)
|
|
{
|
|
ShowWindow(GetDlgItem(m_hPage, aPerfControls[i]), g_Options.m_fNoTitle ? SW_HIDE : SW_SHOW);
|
|
}
|
|
|
|
ShowWindow(GetDlgItem(m_hPage, IDC_MEMGRAPH), g_Options.m_fNoTitle ? SW_HIDE : SW_SHOW);
|
|
ShowWindow(GetDlgItem(m_hPage, IDC_MEMFRAME), g_Options.m_fNoTitle ? SW_HIDE : SW_SHOW);
|
|
ShowWindow(GetDlgItem(m_hPage, IDC_MEMBARFRAME), g_Options.m_fNoTitle ? SW_HIDE : SW_SHOW);
|
|
ShowWindow(GetDlgItem(m_hPage, IDC_MEMMETER), g_Options.m_fNoTitle ? SW_HIDE : SW_SHOW);
|
|
|
|
SizePerfPage();
|
|
}
|
|
|
|
/*++ CPerfPage::DrawCPUDigits
|
|
|
|
Routine Description:
|
|
|
|
Draws the CPU meter and digits
|
|
|
|
Arguments:
|
|
|
|
lpdi - LPDRAWITEMSTRUCT describing area we need to paint
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
void CPerfPage::DrawCPUDigits(LPDRAWITEMSTRUCT lpdi)
|
|
{
|
|
int cDigits = 3;
|
|
HBRUSH hBlack = (HBRUSH) GetStockObject(BLACK_BRUSH);
|
|
HGDIOBJ hOld = SelectObject(lpdi->hDC, hBlack);
|
|
Rectangle(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top, lpdi->rcItem.right, lpdi->rcItem.bottom);
|
|
|
|
// Draw the digits into the ownder draw control
|
|
|
|
INT xOffset = ((lpdi->rcItem.right - lpdi->rcItem.left) - 4 * DIGIT_WIDTH) / 2 - 2;
|
|
INT yOffset = (lpdi->rcItem.bottom - DIGIT_HEIGHT - g_DefSpacing);
|
|
INT xBarOffset = ((lpdi->rcItem.right - lpdi->rcItem.left) - STRIP_WIDTH) / 2;
|
|
|
|
RECT rcBar;
|
|
GetWindowRect(GetDlgItem(m_hPage, IDC_MEMMETER), &rcBar);
|
|
INT cBarHeight = lpdi->rcItem.bottom - lpdi->rcItem.top - (DIGIT_HEIGHT + g_DefSpacing * 3);
|
|
if (cBarHeight <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
INT ctmpBarLitPixels = (g_CPUUsage * cBarHeight) / 100;
|
|
INT ctmpBarRedPixels = g_Options.m_fKernelTimes ? ctmpBarRedPixels = (g_KernelUsage * cBarHeight) / 100 : 0;
|
|
|
|
INT cBarUnLitPixels = cBarHeight - ctmpBarLitPixels;
|
|
cBarUnLitPixels = (cBarUnLitPixels / 3) * 3;
|
|
|
|
INT cBarLitPixels = cBarHeight - cBarUnLitPixels;
|
|
INT cBarRedPixels = ctmpBarRedPixels;
|
|
|
|
HDC hdcMem = CreateCompatibleDC(lpdi->hDC);
|
|
if (hdcMem)
|
|
{
|
|
HBITMAP hOldbmp = (HBITMAP) SelectObject(hdcMem, m_hDigits);
|
|
if (hOldbmp)
|
|
{
|
|
int Place = 100;
|
|
int Value = g_CPUUsage;
|
|
BOOL fDrawnYet = FALSE;
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
// Don't zero-pad
|
|
|
|
if (Value / Place == 0 && fDrawnYet == FALSE && Place != 1)
|
|
{
|
|
BitBlt(lpdi->hDC, xOffset + DIGIT_WIDTH * i, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
BLANK_INDEX * DIGIT_WIDTH, 0,
|
|
SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
BitBlt(lpdi->hDC, xOffset + DIGIT_WIDTH * i, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
(Value / Place) * DIGIT_WIDTH, 0,
|
|
SRCCOPY);
|
|
if (Value / Place)
|
|
{
|
|
fDrawnYet = TRUE;
|
|
}
|
|
}
|
|
Value %= Place;
|
|
Place /= 10;
|
|
|
|
};
|
|
|
|
// Percent sign
|
|
|
|
BitBlt(lpdi->hDC, xOffset + cDigits * DIGIT_WIDTH, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
PERCENT_SIGN_INDEX * DIGIT_WIDTH, 0, SRCCOPY);
|
|
|
|
// Draw the CPU meter
|
|
|
|
// Draw unlit portion
|
|
|
|
if (cBarHeight != cBarLitPixels)
|
|
{
|
|
INT cUnlit = cBarHeight - cBarLitPixels;
|
|
INT cOffset = 0;
|
|
SelectObject(hdcMem, m_hStripUnlit);
|
|
|
|
while (cUnlit > 0)
|
|
{
|
|
BitBlt(lpdi->hDC, xBarOffset, g_DefSpacing + cOffset,
|
|
STRIP_WIDTH, min(cUnlit, STRIP_HEIGHT),
|
|
hdcMem,
|
|
0, 0, SRCCOPY);
|
|
cOffset += min(cUnlit, STRIP_HEIGHT);
|
|
cUnlit -= min(cUnlit, STRIP_HEIGHT);
|
|
}
|
|
};
|
|
|
|
// Draw lit portion
|
|
|
|
if (0 != cBarLitPixels)
|
|
{
|
|
SelectObject(hdcMem, m_hStripLit);
|
|
INT cOffset = 0;
|
|
INT cLit = cBarLitPixels - cBarRedPixels;
|
|
|
|
while (cLit > 0)
|
|
{
|
|
BitBlt(lpdi->hDC, xBarOffset, g_DefSpacing + (cBarHeight - cBarLitPixels) + cOffset,
|
|
STRIP_WIDTH, min(STRIP_HEIGHT, cLit),
|
|
hdcMem,
|
|
0, 0, SRCCOPY);
|
|
cOffset += min(cLit, STRIP_HEIGHT);
|
|
cLit -= min(cLit, STRIP_HEIGHT);
|
|
}
|
|
|
|
}
|
|
|
|
if (0 != cBarRedPixels)
|
|
{
|
|
SelectObject(hdcMem, m_hStripLitRed);
|
|
INT cOffset = 0;
|
|
INT cRed = cBarRedPixels;
|
|
|
|
while (cRed > 0)
|
|
{
|
|
BitBlt(lpdi->hDC, xBarOffset, g_DefSpacing + (cBarHeight - cBarRedPixels) + cOffset,
|
|
STRIP_WIDTH, min(cRed, STRIP_HEIGHT),
|
|
hdcMem,
|
|
0, 0, SRCCOPY);
|
|
cOffset += min(cRed, STRIP_HEIGHT);
|
|
cRed -= min(cRed, STRIP_HEIGHT);
|
|
}
|
|
}
|
|
|
|
SelectObject(hdcMem, hOldbmp);
|
|
}
|
|
DeleteDC(hdcMem);
|
|
}
|
|
SelectObject(lpdi->hDC, hOld);
|
|
}
|
|
|
|
// CPerfPage::DrawMEMMeter
|
|
|
|
// Draws the memory meter
|
|
|
|
void CPerfPage::DrawMEMMeter(LPDRAWITEMSTRUCT lpdi)
|
|
{
|
|
int cDigits = 6;
|
|
int Place = 100000;
|
|
|
|
BOOL fNoSymbol = FALSE;
|
|
|
|
// For systems with >1G of memory, we add another digit and
|
|
// skip the K symbol to make room for it.
|
|
|
|
if (g_MEMMax > 1000000)
|
|
{
|
|
cDigits = 7;
|
|
Place = 1000000;
|
|
fNoSymbol = TRUE;
|
|
}
|
|
|
|
HBRUSH hBlack = (HBRUSH) GetStockObject(BLACK_BRUSH);
|
|
HGDIOBJ hOld = SelectObject(lpdi->hDC, hBlack);
|
|
Rectangle(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top, lpdi->rcItem.right, lpdi->rcItem.bottom);
|
|
|
|
// Draw the digits into the ownder draw control
|
|
|
|
INT xOffset = ((lpdi->rcItem.right - lpdi->rcItem.left) -
|
|
((fNoSymbol ? (cDigits) : (cDigits + 1)) * DIGIT_WIDTH)) / 2 ;
|
|
INT yOffset = (lpdi->rcItem.bottom - DIGIT_HEIGHT - g_DefSpacing);
|
|
INT xBarOffset = ((lpdi->rcItem.right - lpdi->rcItem.left) - STRIP_WIDTH) / 2;
|
|
|
|
HDC hdcMem = CreateCompatibleDC(lpdi->hDC);
|
|
if (hdcMem)
|
|
{
|
|
HBITMAP hOldbmp = (HBITMAP) SelectObject(hdcMem, m_hDigits);
|
|
if (hOldbmp)
|
|
{
|
|
int Value = g_MEMUsage;
|
|
BOOL fDrawnYet = FALSE;
|
|
|
|
for (int i = 0; i < cDigits; i++)
|
|
{
|
|
// Don't zero-pad
|
|
|
|
if (Value / Place == 0 && fDrawnYet == FALSE)
|
|
{
|
|
BitBlt(lpdi->hDC, xOffset + DIGIT_WIDTH * i, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
BLANK_INDEX * DIGIT_WIDTH, 0,
|
|
SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
BitBlt(lpdi->hDC, xOffset + DIGIT_WIDTH * i, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
(Value / Place) * DIGIT_WIDTH, 0,
|
|
SRCCOPY);
|
|
if (Value / Place)
|
|
{
|
|
fDrawnYet = TRUE;
|
|
}
|
|
}
|
|
Value %= Place;
|
|
Place /= 10;
|
|
|
|
};
|
|
|
|
if (FALSE == fNoSymbol)
|
|
{
|
|
// K
|
|
|
|
BitBlt(lpdi->hDC, xOffset + cDigits * DIGIT_WIDTH, yOffset,
|
|
DIGIT_WIDTH, DIGIT_HEIGHT,
|
|
hdcMem,
|
|
K_INDEX * DIGIT_WIDTH, 0, SRCCOPY);
|
|
}
|
|
|
|
// Draw the CPU meter
|
|
|
|
// Draw unlit portion
|
|
|
|
INT cBarHeight = lpdi->rcItem.bottom - lpdi->rcItem.top - (DIGIT_HEIGHT + g_DefSpacing * 3);
|
|
|
|
if (cBarHeight > 0)
|
|
{
|
|
INT cBarLitPixels = (g_MEMUsage * cBarHeight) / g_MEMMax;
|
|
cBarLitPixels = (cBarLitPixels / 3) * 3;
|
|
INT cBarUnlitPixels = cBarHeight - cBarLitPixels;
|
|
|
|
if (cBarHeight != cBarLitPixels)
|
|
{
|
|
SelectObject(hdcMem, m_hStripUnlit);
|
|
INT cUnlit = cBarHeight - cBarLitPixels;
|
|
INT cOffset = 0;
|
|
|
|
while (cUnlit > 0)
|
|
{
|
|
BitBlt(lpdi->hDC, xBarOffset, g_DefSpacing + cOffset,
|
|
STRIP_WIDTH, min(cUnlit, STRIP_HEIGHT),
|
|
hdcMem,
|
|
0, 0, SRCCOPY);
|
|
cOffset += min(cUnlit, STRIP_HEIGHT);
|
|
cUnlit -= min(cUnlit, STRIP_HEIGHT);
|
|
}
|
|
};
|
|
|
|
// Draw lit portion
|
|
|
|
if (0 != cBarLitPixels)
|
|
{
|
|
SelectObject(hdcMem, m_hStripLit);
|
|
INT cOffset = 0;
|
|
INT cLit = cBarLitPixels;
|
|
|
|
while (cLit > 0)
|
|
{
|
|
BitBlt(lpdi->hDC, xBarOffset, g_DefSpacing + (cBarHeight - cBarLitPixels) + cOffset,
|
|
STRIP_WIDTH, min(STRIP_HEIGHT, cLit),
|
|
hdcMem,
|
|
0, 0, SRCCOPY);
|
|
cOffset += min(cLit, STRIP_HEIGHT);
|
|
cLit -= min(cLit, STRIP_HEIGHT);
|
|
}
|
|
}
|
|
}
|
|
|
|
SelectObject(hdcMem, hOldbmp);
|
|
}
|
|
DeleteDC(hdcMem);
|
|
}
|
|
SelectObject(lpdi->hDC, hOld);
|
|
}
|
|
|
|
/*++ CPerfPage::TimerEvent
|
|
|
|
Routine Description:
|
|
|
|
Called by main app when the update time fires
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
void CPerfPage::TimerEvent()
|
|
{
|
|
CalcCpuTime(TRUE);
|
|
|
|
g_Scrollamount+=2;
|
|
g_Scrollamount %= GRAPHPAPERSIZE;
|
|
|
|
// Force the displays to update
|
|
|
|
if (FALSE == IsIconic(g_hMainWnd))
|
|
{
|
|
InvalidateRect(GetDlgItem(m_hPage, IDC_CPUMETER), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(m_hPage, IDC_CPUMETER));
|
|
InvalidateRect(GetDlgItem(m_hPage, IDC_MEMMETER), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(m_hPage, IDC_MEMMETER));
|
|
|
|
for (UINT i = 0; i < g_cProcessors; i++)
|
|
{
|
|
InvalidateRect(GetDlgItem(m_hPage, ID_FIRSTPANE + i), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(m_hPage, ID_FIRSTPANE + i));
|
|
if (CM_PANES != g_Options.m_cmHistMode)
|
|
{
|
|
// If we're not in multipane mode, we can stop after the first graph
|
|
break;
|
|
}
|
|
}
|
|
|
|
InvalidateRect(GetDlgItem(m_hPage, IDC_MEMGRAPH), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(m_hPage, IDC_MEMGRAPH));
|
|
}
|
|
}
|
|
|
|
/*++ PerfPageProc
|
|
|
|
Routine Description:
|
|
|
|
Dialogproc for the performance page.
|
|
|
|
Arguments:
|
|
|
|
hwnd - handle to dialog box
|
|
uMsg - message
|
|
wParam - first message parameter
|
|
lParam - second message parameter
|
|
|
|
Return Value:
|
|
|
|
For WM_INITDIALOG, TRUE == success
|
|
For others, TRUE == this proc handles the message
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
INT_PTR CALLBACK PerfPageProc(
|
|
HWND hwnd, // handle to dialog box
|
|
UINT uMsg, // message
|
|
WPARAM wParam, // first message parameter
|
|
LPARAM lParam // second message parameter
|
|
)
|
|
{
|
|
CPerfPage * thispage = (CPerfPage *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
// See if the parent wants this message
|
|
|
|
if (TRUE == CheckParentDeferrals(uMsg, wParam, lParam))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);
|
|
CPerfPage * thispage = (CPerfPage *) lParam;
|
|
|
|
DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
|
|
dwStyle |= WS_CLIPCHILDREN;
|
|
SetWindowLong(hwnd, GWL_STYLE, dwStyle);
|
|
|
|
if (IS_WINDOW_RTL_MIRRORED(hwnd))
|
|
{
|
|
HWND hItem;
|
|
LONG lExtStyle;
|
|
|
|
hItem = GetDlgItem(hwnd,IDC_CPUMETER);
|
|
lExtStyle = GetWindowLong(hItem,GWL_EXSTYLE);
|
|
SetWindowLong(hItem,GWL_EXSTYLE, lExtStyle & ~(RTL_MIRRORED_WINDOW | RTL_NOINHERITLAYOUT));
|
|
hItem = GetDlgItem(hwnd,IDC_MEMMETER);
|
|
lExtStyle = GetWindowLong(hItem,GWL_EXSTYLE);
|
|
SetWindowLong(hItem,GWL_EXSTYLE, lExtStyle & ~(dwExStyleRTLMirrorWnd | dwExStyleNoInheritLayout));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// We need to fake client mouse clicks in this child to appear as nonclient
|
|
// (caption) clicks in the parent so that the user can drag the entire app
|
|
// when the title bar is hidden by dragging the client area of this child
|
|
|
|
case WM_LBUTTONUP:
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
if (g_Options.m_fNoTitle)
|
|
{
|
|
SendMessage(g_hMainWnd,
|
|
uMsg == WM_LBUTTONUP ? WM_NCLBUTTONUP : WM_NCLBUTTONDOWN,
|
|
HTCAPTION,
|
|
lParam);
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
case WM_NCLBUTTONDBLCLK:
|
|
case WM_LBUTTONDBLCLK:
|
|
{
|
|
SendMessage(g_hMainWnd, uMsg, wParam, lParam);
|
|
break;
|
|
}
|
|
|
|
case WM_CTLCOLORBTN:
|
|
{
|
|
// When windows tries to redraw our owner draw controls, tell
|
|
// it to do so with a black background
|
|
|
|
if (lParam >= ID_FIRSTPANE && lParam <= ID_LASTPANE)
|
|
{
|
|
// Trivial case: its a CPU graph
|
|
|
|
return (INT_PTR) GetStockObject(GRAPH_BRUSH);
|
|
}
|
|
else
|
|
{
|
|
// Not a CPU graph, maybe its one of the other graphs
|
|
|
|
const static int rgGraphs[] =
|
|
{
|
|
IDC_MEMGRAPH,
|
|
IDC_MEMMETER,
|
|
IDC_CPUMETER
|
|
};
|
|
|
|
for (int i = 0; i < ARRAYSIZE(rgGraphs); i++)
|
|
{
|
|
if (lParam == (LPARAM) GetDlgItem(hwnd, rgGraphs[i]))
|
|
{
|
|
return (INT_PTR) GetStockObject(GRAPH_BRUSH);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Size our kids
|
|
|
|
case WM_SIZE:
|
|
thispage->SizePerfPage();
|
|
return FALSE;
|
|
|
|
// Draw one of our owner draw controls
|
|
|
|
case WM_DRAWITEM:
|
|
{
|
|
if (wParam >= ID_FIRSTPANE && wParam <= ID_LASTPANE)
|
|
{
|
|
thispage->DrawCPUGraph( (LPDRAWITEMSTRUCT) lParam, (UINT)wParam - ID_FIRSTPANE);
|
|
return TRUE;
|
|
}
|
|
else if (IDC_CPUMETER == wParam)
|
|
{
|
|
thispage->DrawCPUDigits( (LPDRAWITEMSTRUCT) lParam);
|
|
return TRUE;
|
|
}
|
|
else if (IDC_MEMMETER == wParam)
|
|
{
|
|
thispage->DrawMEMMeter( (LPDRAWITEMSTRUCT) lParam);
|
|
return TRUE;
|
|
}
|
|
else if (IDC_MEMGRAPH == wParam)
|
|
{
|
|
thispage->DrawMEMGraph( (LPDRAWITEMSTRUCT) lParam);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*++ CPerfPage::GetTitle
|
|
|
|
Routine Description:
|
|
|
|
Copies the title of this page to the caller-supplied buffer
|
|
|
|
Arguments:
|
|
|
|
pszText - the buffer to copy to
|
|
bufsize - size of buffer, in characters
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
void CPerfPage::GetTitle(LPTSTR pszText, size_t bufsize)
|
|
{
|
|
LoadString(g_hInstance, IDS_PERFPAGETITLE, pszText, bufsize);
|
|
}
|
|
|
|
/*++ CPerfPage::Activate
|
|
|
|
Routine Description:
|
|
|
|
Brings this page to the front, sets its initial position,
|
|
and shows it
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
HRESULT (S_OK on success)
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
HRESULT CPerfPage::Activate()
|
|
{
|
|
// Adjust the size and position of our dialog relative
|
|
// to the tab control which "owns" us
|
|
|
|
RECT rcParent;
|
|
GetClientRect(m_hwndTabs, &rcParent);
|
|
MapWindowPoints(m_hwndTabs, g_hMainWnd, (LPPOINT) &rcParent, 2);
|
|
TabCtrl_AdjustRect(m_hwndTabs, FALSE, &rcParent);
|
|
|
|
SetWindowPos(m_hPage,
|
|
HWND_TOP,
|
|
rcParent.left, rcParent.top,
|
|
rcParent.right - rcParent.left, rcParent.bottom - rcParent.top,
|
|
0);
|
|
|
|
// Make this page visible
|
|
|
|
ShowWindow(m_hPage, SW_SHOW);
|
|
|
|
// Make the CPU graphs visible or invisible depending on its current mode
|
|
|
|
UpdateGraphs();
|
|
|
|
// Newly created dialogs seem to steal the focus, so give it back to the
|
|
// tab control (which must have had it if we got here in the first place)
|
|
|
|
SetFocus(m_hwndTabs);
|
|
|
|
// Change the menu bar to be the menu for this page
|
|
|
|
HMENU hMenuOld = GetMenu(g_hMainWnd);
|
|
HMENU hMenuNew = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDR_MAINMENU_PERF));
|
|
|
|
if (hMenuNew && SHRestricted(REST_NORUN))
|
|
{
|
|
DeleteMenu(hMenuNew, IDM_RUN, MF_BYCOMMAND);
|
|
}
|
|
|
|
g_hMenu = hMenuNew;
|
|
if (g_Options.m_fNoTitle == FALSE)
|
|
{
|
|
SetMenu(g_hMainWnd, hMenuNew);
|
|
}
|
|
|
|
if (hMenuOld)
|
|
{
|
|
DestroyMenu(hMenuOld);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*++ CPerfPage::Initialize
|
|
|
|
Routine Description:
|
|
|
|
Loads the resources we need for this page, creates the inmemory DCs
|
|
and bitmaps for the charts, and creates the actual window (a dialog)
|
|
that represents this page
|
|
|
|
Arguments:
|
|
|
|
hwndParent - Parent on which to base sizing on: not used for creation,
|
|
since the main app window is always used as the parent in
|
|
order to keep tab order correct
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
HRESULT CPerfPage::Initialize(HWND hwndParent)
|
|
{
|
|
// Our pseudo-parent is the tab contrl, and is what we base our
|
|
// sizing on. However, in order to keep tab order right among
|
|
// the controls, we actually create ourselves with the main
|
|
// window as the parent
|
|
|
|
m_hwndTabs = hwndParent;
|
|
|
|
// Create the color pens
|
|
|
|
CreatePens();
|
|
|
|
|
|
// Load the LED digits bitmap, etc.
|
|
|
|
|
|
m_hDigits = (HBITMAP) LoadImage(g_hInstance, MAKEINTRESOURCE(LED_NUMBERS),
|
|
IMAGE_BITMAP,
|
|
0, 0,
|
|
LR_DEFAULTCOLOR);
|
|
|
|
m_hStripLit = (HBITMAP) LoadImage(g_hInstance, MAKEINTRESOURCE(LED_STRIP_LIT),
|
|
IMAGE_BITMAP,
|
|
0, 0,
|
|
LR_DEFAULTCOLOR);
|
|
|
|
m_hStripLitRed = (HBITMAP) LoadImage(g_hInstance, MAKEINTRESOURCE(LED_STRIP_LIT_RED),
|
|
IMAGE_BITMAP,
|
|
0, 0,
|
|
LR_DEFAULTCOLOR);
|
|
|
|
m_hStripUnlit = (HBITMAP) LoadImage(g_hInstance, MAKEINTRESOURCE(LED_STRIP_UNLIT),
|
|
IMAGE_BITMAP,
|
|
0, 0,
|
|
LR_DEFAULTCOLOR);
|
|
|
|
if (NULL == m_hDigits)
|
|
{
|
|
return GetLastHRESULT();
|
|
}
|
|
|
|
|
|
// Create the dialog which represents the body of this page
|
|
|
|
|
|
m_hPage = CreateDialogParam(
|
|
g_hInstance, // handle to application instance
|
|
MAKEINTRESOURCE(IDD_PERFPAGE), // identifies dialog box template name
|
|
g_hMainWnd, // handle to owner window
|
|
PerfPageProc, // pointer to dialog box procedure
|
|
(LPARAM) this ); // User data (our this pointer)
|
|
|
|
if (NULL == m_hPage)
|
|
{
|
|
return GetLastHRESULT();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*++ CPerfPage::CreateMemoryBitmaps
|
|
|
|
Routine Description:
|
|
|
|
Creates the inmemory bitmaps used to draw the history graphics
|
|
|
|
Arguments:
|
|
|
|
x, y - size of bitmap to create
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
static HGDIOBJ hOld;
|
|
|
|
HRESULT CPerfPage::CreateMemoryBitmaps(int x, int y)
|
|
{
|
|
|
|
// Create the inmemory bitmaps and DCs that we will use
|
|
|
|
|
|
HDC hdcPage = GetDC(m_hPage);
|
|
m_hdcGraph = CreateCompatibleDC(hdcPage);
|
|
|
|
if (NULL == m_hdcGraph)
|
|
{
|
|
ReleaseDC(m_hPage, hdcPage);
|
|
return GetLastHRESULT();
|
|
}
|
|
|
|
m_rcGraph.left = 0;
|
|
m_rcGraph.top = 0;
|
|
m_rcGraph.right = x;
|
|
m_rcGraph.bottom = y;
|
|
|
|
m_hbmpGraph = CreateCompatibleBitmap(hdcPage, x, y);
|
|
ReleaseDC(m_hPage, hdcPage);
|
|
if (NULL == m_hbmpGraph)
|
|
{
|
|
HRESULT hr = GetLastHRESULT();
|
|
DeleteDC(m_hdcGraph);
|
|
m_hdcGraph = NULL;
|
|
return hr;
|
|
}
|
|
|
|
// Select the bitmap into the DC
|
|
|
|
hOld = SelectObject(m_hdcGraph, m_hbmpGraph);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*++ CPerfPage::FreeMemoryBitmaps
|
|
|
|
Routine Description:
|
|
|
|
Frees the inmemory bitmaps used to drag the history graphs
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-12-95 Davepl Created
|
|
|
|
--*/
|
|
|
|
void CPerfPage::FreeMemoryBitmaps()
|
|
{
|
|
|
|
if (m_hdcGraph)
|
|
{
|
|
if (hOld)
|
|
SelectObject(m_hdcGraph, m_hbmpGraph);
|
|
DeleteDC(m_hdcGraph);
|
|
}
|
|
|
|
if (m_hbmpGraph)
|
|
{
|
|
DeleteObject(m_hbmpGraph);
|
|
}
|
|
|
|
}
|
|
|
|
/*++ CPerfPage::Deactivate
|
|
|
|
Routine Description:
|
|
Called when this page is losing its place up front
|
|
|
|
Revision History:
|
|
Nov-16-95 Davepl Created
|
|
--*/
|
|
void CPerfPage::Deactivate()
|
|
{
|
|
if (m_hPage)
|
|
{
|
|
ShowWindow(m_hPage, SW_HIDE);
|
|
}
|
|
}
|
|
|
|
/*++ CPerfPage::Destroy
|
|
|
|
Routine Description:
|
|
Frees whatever has been allocated by the Initialize call
|
|
|
|
Revision History:
|
|
Nov-12-95 Davepl Created
|
|
--*/
|
|
HRESULT CPerfPage::Destroy()
|
|
{
|
|
// When we are being destroyed, kill off our dialog
|
|
|
|
ReleasePens();
|
|
|
|
if (m_hPage)
|
|
{
|
|
DestroyWindow(m_hPage);
|
|
m_hPage = NULL;
|
|
}
|
|
|
|
if (m_hDigits)
|
|
{
|
|
DeleteObject(m_hDigits);
|
|
m_hDigits = NULL;
|
|
}
|
|
|
|
if (m_hStripLit)
|
|
{
|
|
DeleteObject(m_hStripLit);
|
|
m_hStripLit = NULL;
|
|
}
|
|
|
|
if (m_hStripUnlit)
|
|
{
|
|
DeleteObject(m_hStripUnlit);
|
|
m_hStripUnlit = NULL;
|
|
}
|
|
|
|
if (m_hStripLitRed)
|
|
{
|
|
DeleteObject(m_hStripLitRed);
|
|
m_hStripLitRed = NULL;
|
|
}
|
|
|
|
if (m_hbmpGraph)
|
|
{
|
|
DeleteObject(m_hbmpGraph);
|
|
m_hbmpGraph = NULL;
|
|
}
|
|
|
|
if (m_hdcGraph)
|
|
{
|
|
DeleteDC(m_hdcGraph);
|
|
m_hdcGraph = NULL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*++
|
|
Routine Description:
|
|
Initialize data for perf measurements
|
|
Arguments:
|
|
None
|
|
Return Value:
|
|
Number of system processors (0 if error)
|
|
Revision History:
|
|
10-13-95 Modified from WPERF
|
|
--*/
|
|
BYTE InitPerfInfo()
|
|
{
|
|
SYSTEM_BASIC_INFORMATION BasicInfo;
|
|
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION PPerfInfo;
|
|
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION ProcessorInfo[MAX_PROCESSOR];
|
|
int i;
|
|
|
|
NTSTATUS Status = NtQuerySystemInformation(SystemBasicInformation, &BasicInfo, sizeof(BasicInfo), NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
g_PageSize = BasicInfo.PageSize;
|
|
g_cProcessors = BasicInfo.NumberOfProcessors;
|
|
|
|
if (g_cProcessors > MAX_PROCESSOR) {
|
|
return(0);
|
|
}
|
|
|
|
for (i = 0; i < g_cProcessors; i++)
|
|
{
|
|
g_pCPUHistory[i] = (LPBYTE) LocalAlloc(LPTR, HIST_SIZE * sizeof(LPBYTE));
|
|
if (NULL == g_pCPUHistory[i])
|
|
{
|
|
return 0;
|
|
}
|
|
g_pKernelHistory[i] = (LPBYTE) LocalAlloc(LPTR, HIST_SIZE * sizeof(LPBYTE));
|
|
if (NULL == g_pKernelHistory[i])
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
g_pMEMHistory = (LPBYTE) LocalAlloc(LPTR, HIST_SIZE * sizeof(LPBYTE));
|
|
if (NULL == g_pMEMHistory)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Status = NtQuerySystemInformation(SystemProcessorPerformanceInformation, ProcessorInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * MAX_PROCESSOR, NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
PPerfInfo = ProcessorInfo;
|
|
|
|
|
|
for (i=0; i < g_cProcessors; i++)
|
|
{
|
|
PreviousCPUIdleTime[i] = PPerfInfo->IdleTime;
|
|
PreviousCPUTotalTime[i].QuadPart = PPerfInfo->UserTime.QuadPart +
|
|
PPerfInfo->KernelTime.QuadPart;
|
|
PreviousCPUKernelTime[i].QuadPart = PPerfInfo->KernelTime.QuadPart +
|
|
PPerfInfo->IdleTime.QuadPart;
|
|
|
|
// PPerfInfo->IdleTime.QuadPart;
|
|
PPerfInfo++;
|
|
}
|
|
|
|
|
|
// Get the maximum commit limit
|
|
|
|
|
|
SYSTEM_PERFORMANCE_INFORMATION PerfInfo;
|
|
|
|
Status = NtQuerySystemInformation(SystemPerformanceInformation, &PerfInfo, sizeof(PerfInfo), NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
g_MEMMax = PerfInfo.CommitLimit * ( g_PageSize / 1024 );
|
|
|
|
return(g_cProcessors);
|
|
}
|
|
|
|
/*++ ReleasePerfInfo
|
|
|
|
Routine Description:
|
|
|
|
Frees the history buffers
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-13-95 DavePl Created
|
|
|
|
--*/
|
|
|
|
void ReleasePerfInfo()
|
|
{
|
|
for (int i = 0; i < g_cProcessors; i++)
|
|
{
|
|
if (g_pCPUHistory[i])
|
|
{
|
|
LocalFree(g_pCPUHistory[i]);
|
|
g_pCPUHistory[i] = NULL;
|
|
}
|
|
if (g_pKernelHistory[i])
|
|
{
|
|
LocalFree(g_pKernelHistory[i]);
|
|
g_pKernelHistory[i] = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
if (g_pMEMHistory)
|
|
{
|
|
LocalFree(g_pMEMHistory);
|
|
}
|
|
}
|
|
|
|
|
|
void CalcCpuTime(BOOL fUpdateHistory)
|
|
/*++
|
|
Routine Description:
|
|
calculate and return %cpu time and time periods
|
|
Revision History:
|
|
Nov-13-95 DavePl Created
|
|
--*/
|
|
{
|
|
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION ProcessorInfo[MAX_PROCESSOR];
|
|
LARGE_INTEGER CPUIdleTime[MAX_PROCESSOR];
|
|
LARGE_INTEGER CPUTotalTime[MAX_PROCESSOR];
|
|
LARGE_INTEGER CPUKernelTime[MAX_PROCESSOR];
|
|
LARGE_INTEGER SumIdleTime = { 0 ,0 };
|
|
LARGE_INTEGER SumTotalTime = { 0, 0 };
|
|
LARGE_INTEGER SumKernelTime = { 0, 0 };
|
|
NTSTATUS Status;
|
|
|
|
Status = NtQuerySystemInformation(SystemProcessorPerformanceInformation, ProcessorInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * MAX_PROCESSOR, NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Walk through the info for each CPU, and compile
|
|
|
|
// - Amount of time each CPU has spent idle (since last check)
|
|
// - Amount of time each CPU has spent entirely (since last check)
|
|
|
|
// In addition to keeping per-CPU stats, compile a sum for
|
|
|
|
// - Amount of time system has spent idle (since last check)
|
|
// - Amount of time that has elapsed, in total (since last check)
|
|
|
|
for (int ListIndex = 0; ListIndex < g_cProcessors; ListIndex++)
|
|
{
|
|
LARGE_INTEGER DeltaCPUIdleTime;
|
|
LARGE_INTEGER DeltaCPUTotalTime;
|
|
LARGE_INTEGER DeltaCPUKernelTime;
|
|
|
|
CPUIdleTime[ListIndex].QuadPart = ProcessorInfo[ListIndex].IdleTime.QuadPart;
|
|
CPUKernelTime[ListIndex].QuadPart= ProcessorInfo[ListIndex].KernelTime.QuadPart-ProcessorInfo[ListIndex].IdleTime.QuadPart;
|
|
CPUTotalTime[ListIndex].QuadPart = ProcessorInfo[ListIndex].KernelTime.QuadPart + ProcessorInfo[ListIndex].UserTime.QuadPart;// +
|
|
//ProcessorInfo[ListIndex].IdleTime.QuadPart;
|
|
|
|
DeltaCPUIdleTime.QuadPart = CPUIdleTime[ListIndex].QuadPart - PreviousCPUIdleTime[ListIndex].QuadPart;
|
|
DeltaCPUKernelTime.QuadPart = CPUKernelTime[ListIndex].QuadPart - PreviousCPUKernelTime[ListIndex].QuadPart;
|
|
DeltaCPUTotalTime.QuadPart = CPUTotalTime[ListIndex].QuadPart - PreviousCPUTotalTime[ListIndex].QuadPart;
|
|
|
|
SumIdleTime.QuadPart += DeltaCPUIdleTime.QuadPart;
|
|
SumTotalTime.QuadPart += DeltaCPUTotalTime.QuadPart;
|
|
SumKernelTime.QuadPart += DeltaCPUKernelTime.QuadPart;
|
|
|
|
// Calc CPU Usage % for this processor, scroll the history buffer, and store
|
|
// the newly calced value at the head of the history buffer
|
|
|
|
BYTE ThisCPU = DeltaCPUTotalTime.QuadPart ? (BYTE) (100 - ((DeltaCPUIdleTime.QuadPart * 100) / DeltaCPUTotalTime.QuadPart)) : 0;
|
|
|
|
BYTE * pbHistory = g_pCPUHistory[ListIndex];
|
|
MoveMemory((LPVOID) (pbHistory + 1), (LPVOID) (pbHistory), sizeof(BYTE) * (HIST_SIZE - 1) );
|
|
pbHistory[0] = ThisCPU;
|
|
|
|
BYTE ThisKernel = DeltaCPUTotalTime.QuadPart ? (BYTE) (((DeltaCPUKernelTime.QuadPart * 100) / DeltaCPUTotalTime.QuadPart)) : 0;
|
|
|
|
pbHistory = g_pKernelHistory[ListIndex];
|
|
MoveMemory((LPVOID) (pbHistory + 1), (LPVOID) (pbHistory), sizeof(BYTE) * (HIST_SIZE - 1) );
|
|
pbHistory[0] = ThisKernel;
|
|
|
|
PreviousCPUTotalTime[ListIndex].QuadPart = CPUTotalTime[ListIndex].QuadPart;
|
|
PreviousCPUIdleTime[ListIndex].QuadPart = CPUIdleTime[ListIndex].QuadPart;
|
|
PreviousCPUKernelTime[ListIndex].QuadPart = CPUKernelTime[ListIndex].QuadPart;
|
|
}
|
|
|
|
g_CPUUsage = SumTotalTime.QuadPart ? (BYTE) (100 - ((SumIdleTime.QuadPart * 100) / SumTotalTime.QuadPart)) : 0;
|
|
|
|
if (fUpdateHistory)
|
|
{
|
|
g_KernelUsage = SumTotalTime.QuadPart ? (BYTE) ((SumKernelTime.QuadPart * 100) / SumTotalTime.QuadPart) : 0;
|
|
|
|
// Get the commit size
|
|
|
|
SYSTEM_PERFORMANCE_INFORMATION PerfInfo;
|
|
|
|
Status = NtQuerySystemInformation(SystemPerformanceInformation, &PerfInfo, sizeof(PerfInfo), NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_MEMUsage = PerfInfo.CommittedPages * (g_PageSize / 1024);
|
|
MoveMemory((LPVOID) (g_pMEMHistory + 1), (LPVOID) (g_pMEMHistory), sizeof(BYTE) * (HIST_SIZE - 1) );
|
|
g_pMEMHistory[0] = (BYTE) ((g_MEMUsage * 100) / g_MEMMax);
|
|
}
|
|
} |