Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-26 17:14:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rosapps/taskmgr/graphctl.cpp
Steven Edwards 09a23ffea3 Compleated the update of the license headers and converted most 
of the rest of the C++ style comments to C.

svn path=/trunk/; revision=7502
2004-01-07 18:57:22 +00:00

723 lines
23 KiB
C++
Raw Blame History

/*
* ReactOS Task Manager
*
* GraphCtrl.cpp
*
* Copyright (C) 2002 Robert Dickenson <robd@reactos.org>
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <process.h>
#include <stdio.h>
#include "math.h"
#include "graphctl.h"
#include "taskmgr.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
LONG OldGraphCtrlWndProc;
TGraphCtrl::TGraphCtrl() :
m_hWnd(0),
m_hParentWnd(0),
m_dcGrid(0),
m_dcPlot(0),
m_bitmapOldGrid(0),
m_bitmapOldPlot(0),
m_bitmapGrid(0),
m_bitmapPlot(0),
m_brushBack(0)
{
//RECT m_rectClient;
//RECT m_rectPlot;
m_penPlot[0] = 0;
m_penPlot[1] = 0;
m_penPlot[2] = 0;
m_penPlot[3] = 0;
/* since plotting is based on a LineTo for each new point
* we need a starting point (i.e. a "previous" point)
* use 0.0 as the default first point.
* these are public member variables, and can be changed outside
* (after construction). Therefore m_perviousPosition could be set to
* a more appropriate value prior to the first call to SetPosition.
*/
m_dPreviousPosition[0] = 0.0;
m_dPreviousPosition[1] = 0.0;
m_dPreviousPosition[2] = 0.0;
m_dPreviousPosition[3] = 0.0;
/* public variable for the number of decimal places on the y axis */
m_nYDecimals = 3;
/* set some initial values for the scaling until "SetRange" is called.
* these are protected varaibles and must be set with SetRange
* in order to ensure that m_dRange is updated accordingly
*/
// m_dLowerLimit = -10.0;
// m_dUpperLimit = 10.0;
m_dLowerLimit = 0.0;
m_dUpperLimit = 100.0;
m_dRange = m_dUpperLimit - m_dLowerLimit; // protected member variable
// m_nShiftPixels determines how much the plot shifts (in terms of pixels)
// with the addition of a new data point
m_nShiftPixels = 4;
m_nHalfShiftPixels = m_nShiftPixels/2; // protected
m_nPlotShiftPixels = m_nShiftPixels + m_nHalfShiftPixels; // protected
// background, grid and data colors
// these are public variables and can be set directly
m_crBackColor = RGB( 0, 0, 0); // see also SetBackgroundColor
m_crGridColor = RGB( 0, 255, 255); // see also SetGridColor
m_crPlotColor[0] = RGB(255, 255, 255); // see also SetPlotColor
m_crPlotColor[1] = RGB(100, 255, 255); // see also SetPlotColor
m_crPlotColor[2] = RGB(255, 100, 255); // see also SetPlotColor
m_crPlotColor[3] = RGB(255, 255, 100); // see also SetPlotColor
/* protected variables */
int i;
for (i = 0; i < MAX_PLOTS; i++) {
m_penPlot[i] = CreatePen(PS_SOLID, 0, m_crPlotColor[i]);
}
m_brushBack = CreateSolidBrush(m_crBackColor);
/* public member variables, can be set directly */
strcpy(m_strXUnitsString, "Samples"); // can also be set with SetXUnits
strcpy(m_strYUnitsString, "Y units"); // can also be set with SetYUnits
// protected bitmaps to restore the memory DC's
m_bitmapOldGrid = NULL;
m_bitmapOldPlot = NULL;
#if 0
for (i = 0; i < MAX_CTRLS; i++) {
if (pCtrlArray[i] == 0) {
pCtrlArray[i] = this;
}
}
#endif
}
/////////////////////////////////////////////////////////////////////////////
TGraphCtrl::~TGraphCtrl()
{
// just to be picky restore the bitmaps for the two memory dc's
// (these dc's are being destroyed so there shouldn't be any leaks)
if (m_bitmapOldGrid != NULL) SelectObject(m_dcGrid, m_bitmapOldGrid);
if (m_bitmapOldPlot != NULL) SelectObject(m_dcPlot, m_bitmapOldPlot);
if (m_bitmapGrid != NULL) DeleteObject(m_bitmapGrid);
if (m_bitmapPlot != NULL) DeleteObject(m_bitmapPlot);
if (m_dcGrid != NULL) DeleteDC(m_dcGrid);
if (m_dcPlot != NULL) DeleteDC(m_dcPlot);
if (m_brushBack != NULL) DeleteObject(m_brushBack);
#if 0
for (int i = 0; i < MAX_CTRLS; i++) {
if (pCtrlArray[i] == this) {
pCtrlArray[i] = 0;
}
}
#endif
}
/////////////////////////////////////////////////////////////////////////////
BOOL TGraphCtrl::Create(HWND hWnd, HWND hParentWnd, UINT nID)
{
BOOL result = 0;
m_hParentWnd = hParentWnd;
m_hWnd = hWnd;
Resize();
if (result != 0)
InvalidateCtrl();
return result;
}
/*
BOOL TGraphCtrl::Create(DWORD dwStyle, const RECT& rect,
HWND hParentWnd, UINT nID)
{
BOOL result = 0;
m_hParentWnd = hParentWnd;
// GetClientRect(m_hParentWnd, &m_rectClient);
// set some member variables to avoid multiple function calls
m_nClientHeight = rect.bottom - rect.top;//rect.Height();
m_nClientWidth = rect.right - rect.left;//rect.Width();
// m_nClientHeight = cx;
// m_nClientWidth = cy;
// the "left" coordinate and "width" will be modified in
// InvalidateCtrl to be based on the width of the y axis scaling
#if 0
m_rectPlot.left = 20;
m_rectPlot.top = 10;
m_rectPlot.right = rect.right-10;
m_rectPlot.bottom = rect.bottom-25;
#else
m_rectPlot.left = -1;
m_rectPlot.top = -1;
m_rectPlot.right = rect.right-0;
m_rectPlot.bottom = rect.bottom-0;
#endif
// set some member variables to avoid multiple function calls
m_nPlotHeight = m_rectPlot.bottom - m_rectPlot.top;//m_rectPlot.Height();
m_nPlotWidth = m_rectPlot.right - m_rectPlot.left;//m_rectPlot.Width();
// set the scaling factor for now, this can be adjusted
// in the SetRange functions
m_dVerticalFactor = (double)m_nPlotHeight / m_dRange;
if (result != 0)
InvalidateCtrl();
return result;
}
*/
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetRange(double dLower, double dUpper, int nDecimalPlaces)
{
//ASSERT(dUpper > dLower);
m_dLowerLimit = dLower;
m_dUpperLimit = dUpper;
m_nYDecimals = nDecimalPlaces;
m_dRange = m_dUpperLimit - m_dLowerLimit;
m_dVerticalFactor = (double)m_nPlotHeight / m_dRange;
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetXUnits(const char* string)
{
strncpy(m_strXUnitsString, string, sizeof(m_strXUnitsString) - 1);
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetYUnits(const char* string)
{
strncpy(m_strYUnitsString, string, sizeof(m_strYUnitsString) - 1);
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetGridColor(COLORREF color)
{
m_crGridColor = color;
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetPlotColor(int plot, COLORREF color)
{
m_crPlotColor[plot] = color;
DeleteObject(m_penPlot[plot]);
m_penPlot[plot] = CreatePen(PS_SOLID, 0, m_crPlotColor[plot]);
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::SetBackgroundColor(COLORREF color)
{
m_crBackColor = color;
DeleteObject(m_brushBack);
m_brushBack = CreateSolidBrush(m_crBackColor);
// clear out the existing garbage, re-start with a clean plot
InvalidateCtrl();
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::InvalidateCtrl()
{
// There is a lot of drawing going on here - particularly in terms of
// drawing the grid. Don't panic, this is all being drawn (only once)
// to a bitmap. The result is then BitBlt'd to the control whenever needed.
int i, j;
int nCharacters;
int nTopGridPix, nMidGridPix, nBottomGridPix;
HPEN oldPen;
HPEN solidPen = CreatePen(PS_SOLID, 0, m_crGridColor);
//HFONT axisFont, yUnitFont, oldFont;
//char strTemp[50];
// in case we haven't established the memory dc's
//CClientDC dc(this);
HDC dc = GetDC(m_hParentWnd);
// if we don't have one yet, set up a memory dc for the grid
if (m_dcGrid == NULL) {
m_dcGrid = CreateCompatibleDC(dc);
m_bitmapGrid = CreateCompatibleBitmap(dc, m_nClientWidth, m_nClientHeight);
m_bitmapOldGrid = (HBITMAP)SelectObject(m_dcGrid, m_bitmapGrid);
}
SetBkColor(m_dcGrid, m_crBackColor);
// fill the grid background
FillRect(m_dcGrid, &m_rectClient, m_brushBack);
// draw the plot rectangle:
// determine how wide the y axis scaling values are
nCharacters = abs((int)log10(fabs(m_dUpperLimit)));
nCharacters = max(nCharacters, abs((int)log10(fabs(m_dLowerLimit))));
// add the units digit, decimal point and a minus sign, and an extra space
// as well as the number of decimal places to display
nCharacters = nCharacters + 4 + m_nYDecimals;
// adjust the plot rectangle dimensions
// assume 6 pixels per character (this may need to be adjusted)
// m_rectPlot.left = m_rectClient.left + 6*(nCharacters);
m_rectPlot.left = m_rectClient.left;
m_nPlotWidth = m_rectPlot.right - m_rectPlot.left;//m_rectPlot.Width();
// draw the plot rectangle
oldPen = (HPEN)SelectObject(m_dcGrid, solidPen);
MoveToEx(m_dcGrid, m_rectPlot.left, m_rectPlot.top, NULL);
LineTo(m_dcGrid, m_rectPlot.right+1, m_rectPlot.top);
LineTo(m_dcGrid, m_rectPlot.right+1, m_rectPlot.bottom+1);
LineTo(m_dcGrid, m_rectPlot.left, m_rectPlot.bottom+1);
// LineTo(m_dcGrid, m_rectPlot.left, m_rectPlot.top);
SelectObject(m_dcGrid, oldPen);
DeleteObject(solidPen);
// draw the dotted lines,
// use SetPixel instead of a dotted pen - this allows for a
// finer dotted line and a more "technical" look
nMidGridPix = (m_rectPlot.top + m_rectPlot.bottom)/2;
nTopGridPix = nMidGridPix - m_nPlotHeight/4;
nBottomGridPix = nMidGridPix + m_nPlotHeight/4;
for (i=m_rectPlot.left; i<m_rectPlot.right; i+=2) {
SetPixel(m_dcGrid, i, nTopGridPix, m_crGridColor);
SetPixel(m_dcGrid, i, nMidGridPix, m_crGridColor);
SetPixel(m_dcGrid, i, nBottomGridPix, m_crGridColor);
}
for (i=m_rectPlot.left; i<m_rectPlot.right; i+=10) {
for (j=m_rectPlot.top; j<m_rectPlot.bottom; j+=2) {
SetPixel(m_dcGrid, i, j, m_crGridColor);
// SetPixel(m_dcGrid, i, j, m_crGridColor);
// SetPixel(m_dcGrid, i, j, m_crGridColor);
}
}
#if 0
// create some fonts (horizontal and vertical)
// use a height of 14 pixels and 300 weight
// (these may need to be adjusted depending on the display)
axisFont = CreateFont (14, 0, 0, 0, 300,
FALSE, FALSE, 0, ANSI_CHARSET,
OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY,
DEFAULT_PITCH|FF_SWISS, "Arial");
yUnitFont = CreateFont (14, 0, 900, 0, 300,
FALSE, FALSE, 0, ANSI_CHARSET,
OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY,
DEFAULT_PITCH|FF_SWISS, "Arial");
// grab the horizontal font
oldFont = (HFONT)SelectObject(m_dcGrid, axisFont);
// y max
SetTextColor(m_dcGrid, m_crGridColor);
SetTextAlign(m_dcGrid, TA_RIGHT|TA_TOP);
sprintf(strTemp, "%.*lf", m_nYDecimals, m_dUpperLimit);
TextOut(m_dcGrid, m_rectPlot.left-4, m_rectPlot.top, strTemp, _tcslen(strTemp));
// y min
SetTextAlign(m_dcGrid, TA_RIGHT|TA_BASELINE);
sprintf(strTemp, "%.*lf", m_nYDecimals, m_dLowerLimit);
TextOut(m_dcGrid, m_rectPlot.left-4, m_rectPlot.bottom, strTemp, _tcslen(strTemp));
// x min
SetTextAlign(m_dcGrid, TA_LEFT|TA_TOP);
TextOut(m_dcGrid, m_rectPlot.left, m_rectPlot.bottom+4, "0", 1);
// x max
SetTextAlign(m_dcGrid, TA_RIGHT|TA_TOP);
sprintf(strTemp, "%d", m_nPlotWidth/m_nShiftPixels);
TextOut(m_dcGrid, m_rectPlot.right, m_rectPlot.bottom+4, strTemp, _tcslen(strTemp));
// x units
SetTextAlign(m_dcGrid, TA_CENTER|TA_TOP);
TextOut(m_dcGrid, (m_rectPlot.left+m_rectPlot.right)/2,
m_rectPlot.bottom+4, m_strXUnitsString, _tcslen(m_strXUnitsString));
// restore the font
SelectObject(m_dcGrid, oldFont);
// y units
oldFont = (HFONT)SelectObject(m_dcGrid, yUnitFont);
SetTextAlign(m_dcGrid, TA_CENTER|TA_BASELINE);
TextOut(m_dcGrid, (m_rectClient.left+m_rectPlot.left)/2,
(m_rectPlot.bottom+m_rectPlot.top)/2, m_strYUnitsString, _tcslen(m_strYUnitsString));
SelectObject(m_dcGrid, oldFont);
#endif
// at this point we are done filling the the grid bitmap,
// no more drawing to this bitmap is needed until the setting are changed
// if we don't have one yet, set up a memory dc for the plot
if (m_dcPlot == NULL) {
m_dcPlot = CreateCompatibleDC(dc);
m_bitmapPlot = CreateCompatibleBitmap(dc, m_nClientWidth, m_nClientHeight);
m_bitmapOldPlot = (HBITMAP)SelectObject(m_dcPlot, m_bitmapPlot);
}
// make sure the plot bitmap is cleared
SetBkColor(m_dcPlot, m_crBackColor);
FillRect(m_dcPlot, &m_rectClient, m_brushBack);
// finally, force the plot area to redraw
InvalidateRect(m_hParentWnd, &m_rectClient, TRUE);
ReleaseDC(m_hParentWnd, dc);
}
/////////////////////////////////////////////////////////////////////////////
double TGraphCtrl::AppendPoint(double dNewPoint0, double dNewPoint1,
double dNewPoint2, double dNewPoint3)
{
// append a data point to the plot & return the previous point
double dPrevious;
dPrevious = m_dCurrentPosition[0];
m_dCurrentPosition[0] = dNewPoint0;
m_dCurrentPosition[1] = dNewPoint1;
m_dCurrentPosition[2] = dNewPoint2;
m_dCurrentPosition[3] = dNewPoint3;
DrawPoint();
//Invalidate();
return dPrevious;
}
////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::Paint(HWND hWnd, HDC dc)
{
HDC memDC;
HBITMAP memBitmap;
HBITMAP oldBitmap; // bitmap originally found in CMemDC
// RECT rcClient;
// GetClientRect(hWnd, &rcClient);
// FillSolidRect(dc, &rcClient, RGB(255, 0, 255));
// m_nClientWidth = rcClient.right - rcClient.left;
// m_nClientHeight = rcClient.bottom - rcClient.top;
// no real plotting work is performed here,
// just putting the existing bitmaps on the client
// to avoid flicker, establish a memory dc, draw to it
// and then BitBlt it to the client
memDC = CreateCompatibleDC(dc);
memBitmap = (HBITMAP)CreateCompatibleBitmap(dc, m_nClientWidth, m_nClientHeight);
oldBitmap = (HBITMAP)SelectObject(memDC, memBitmap);
if (memDC != NULL) {
// first drop the grid on the memory dc
BitBlt(memDC, 0, 0, m_nClientWidth, m_nClientHeight, m_dcGrid, 0, 0, SRCCOPY);
// now add the plot on top as a "pattern" via SRCPAINT.
// works well with dark background and a light plot
BitBlt(memDC, 0, 0, m_nClientWidth, m_nClientHeight, m_dcPlot, 0, 0, SRCPAINT); //SRCPAINT
// finally send the result to the display
BitBlt(dc, 0, 0, m_nClientWidth, m_nClientHeight, memDC, 0, 0, SRCCOPY);
}
SelectObject(memDC, oldBitmap);
DeleteObject(memBitmap);
DeleteDC(memDC);
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::DrawPoint()
{
// this does the work of "scrolling" the plot to the left
// and appending a new data point all of the plotting is
// directed to the memory based bitmap associated with m_dcPlot
// the will subsequently be BitBlt'd to the client in Paint
int currX, prevX, currY, prevY;
HPEN oldPen;
RECT rectCleanUp;
if (m_dcPlot != NULL) {
// shift the plot by BitBlt'ing it to itself
// note: the m_dcPlot covers the entire client
// but we only shift bitmap that is the size
// of the plot rectangle
// grab the right side of the plot (exluding m_nShiftPixels on the left)
// move this grabbed bitmap to the left by m_nShiftPixels
BitBlt(m_dcPlot, m_rectPlot.left, m_rectPlot.top+1,
m_nPlotWidth, m_nPlotHeight, m_dcPlot,
m_rectPlot.left+m_nShiftPixels, m_rectPlot.top+1,
SRCCOPY);
// establish a rectangle over the right side of plot
// which now needs to be cleaned up proir to adding the new point
rectCleanUp = m_rectPlot;
rectCleanUp.left = rectCleanUp.right - m_nShiftPixels;
// fill the cleanup area with the background
FillRect(m_dcPlot, &rectCleanUp, m_brushBack);
// draw the next line segement
for (int i = 0; i < MAX_PLOTS; i++) {
// grab the plotting pen
oldPen = (HPEN)SelectObject(m_dcPlot, m_penPlot[i]);
// move to the previous point
prevX = m_rectPlot.right-m_nPlotShiftPixels;
prevY = m_rectPlot.bottom -
(long)((m_dPreviousPosition[i] - m_dLowerLimit) * m_dVerticalFactor);
MoveToEx(m_dcPlot, prevX, prevY, NULL);
// draw to the current point
currX = m_rectPlot.right-m_nHalfShiftPixels;
currY = m_rectPlot.bottom -
(long)((m_dCurrentPosition[i] - m_dLowerLimit) * m_dVerticalFactor);
LineTo(m_dcPlot, currX, currY);
// restore the pen
SelectObject(m_dcPlot, oldPen);
// if the data leaks over the upper or lower plot boundaries
// fill the upper and lower leakage with the background
// this will facilitate clipping on an as needed basis
// as opposed to always calling IntersectClipRect
if ((prevY <= m_rectPlot.top) || (currY <= m_rectPlot.top)) {
RECT rc;
rc.bottom = m_rectPlot.top+1;
rc.left = prevX;
rc.right = currX+1;
rc.top = m_rectClient.top;
FillRect(m_dcPlot, &rc, m_brushBack);
}
if ((prevY >= m_rectPlot.bottom) || (currY >= m_rectPlot.bottom)) {
RECT rc;
rc.bottom = m_rectClient.bottom+1;
rc.left = prevX;
rc.right = currX+1;
rc.top = m_rectPlot.bottom+1;
//RECT rc(prevX, m_rectPlot.bottom+1, currX+1, m_rectClient.bottom+1);
FillRect(m_dcPlot, &rc, m_brushBack);
}
// store the current point for connection to the next point
m_dPreviousPosition[i] = m_dCurrentPosition[i];
}
}
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::Resize(void)
{
// NOTE: Resize automatically gets called during the setup of the control
GetClientRect(m_hWnd, &m_rectClient);
// set some member variables to avoid multiple function calls
m_nClientHeight = m_rectClient.bottom - m_rectClient.top;//m_rectClient.Height();
m_nClientWidth = m_rectClient.right - m_rectClient.left;//m_rectClient.Width();
// the "left" coordinate and "width" will be modified in
// InvalidateCtrl to be based on the width of the y axis scaling
#if 0
m_rectPlot.left = 20;
m_rectPlot.top = 10;
m_rectPlot.right = m_rectClient.right-10;
m_rectPlot.bottom = m_rectClient.bottom-25;
#else
m_rectPlot.left = 0;
m_rectPlot.top = -1;
m_rectPlot.right = m_rectClient.right-0;
m_rectPlot.bottom = m_rectClient.bottom-0;
#endif
// set some member variables to avoid multiple function calls
m_nPlotHeight = m_rectPlot.bottom - m_rectPlot.top;//m_rectPlot.Height();
m_nPlotWidth = m_rectPlot.right - m_rectPlot.left;//m_rectPlot.Width();
// set the scaling factor for now, this can be adjusted
// in the SetRange functions
m_dVerticalFactor = (double)m_nPlotHeight / m_dRange;
}
/////////////////////////////////////////////////////////////////////////////
void TGraphCtrl::Reset()
{
// to clear the existing data (in the form of a bitmap)
// simply invalidate the entire control
InvalidateCtrl();
}
extern TGraphCtrl PerformancePageCpuUsageHistoryGraph;
extern TGraphCtrl PerformancePageMemUsageHistoryGraph;
extern HWND hPerformancePageCpuUsageHistoryGraph;
extern HWND hPerformancePageMemUsageHistoryGraph;
LRESULT CALLBACK GraphCtrl_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
RECT rcClient;
HDC hdc;
PAINTSTRUCT ps;
//LONG WindowId;
//TGraphCtrl* pGraphCtrl;
switch (message) {
case WM_ERASEBKGND:
return TRUE;
//
// Filter out mouse & keyboard messages
//
//case WM_APPCOMMAND:
case WM_CAPTURECHANGED:
case WM_LBUTTONDBLCLK:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDBLCLK:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_MOUSEACTIVATE:
case WM_MOUSEHOVER:
case WM_MOUSELEAVE:
case WM_MOUSEMOVE:
//case WM_MOUSEWHEEL:
case WM_NCHITTEST:
case WM_NCLBUTTONDBLCLK:
case WM_NCLBUTTONDOWN:
case WM_NCLBUTTONUP:
case WM_NCMBUTTONDBLCLK:
case WM_NCMBUTTONDOWN:
case WM_NCMBUTTONUP:
//case WM_NCMOUSEHOVER:
//case WM_NCMOUSELEAVE:
case WM_NCMOUSEMOVE:
case WM_NCRBUTTONDBLCLK:
case WM_NCRBUTTONDOWN:
case WM_NCRBUTTONUP:
//case WM_NCXBUTTONDBLCLK:
//case WM_NCXBUTTONDOWN:
//case WM_NCXBUTTONUP:
case WM_RBUTTONDBLCLK:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
//case WM_XBUTTONDBLCLK:
//case WM_XBUTTONDOWN:
//case WM_XBUTTONUP:
case WM_ACTIVATE:
case WM_CHAR:
case WM_DEADCHAR:
case WM_GETHOTKEY:
case WM_HOTKEY:
case WM_KEYDOWN:
case WM_KEYUP:
case WM_KILLFOCUS:
case WM_SETFOCUS:
case WM_SETHOTKEY:
case WM_SYSCHAR:
case WM_SYSDEADCHAR:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
return 0;
case WM_NCCALCSIZE:
return 0;
case WM_SIZE:
// pGraphCtrl = TGraphCtrl::LookupGraphCtrl(hWnd);
// if (pGraphCtrl) pGraphCtrl->Resize(wParam, HIWORD(lParam), LOWORD(lParam));
if (hWnd == hPerformancePageMemUsageHistoryGraph) {
PerformancePageMemUsageHistoryGraph.Resize();
PerformancePageMemUsageHistoryGraph.InvalidateCtrl();
}
if (hWnd == hPerformancePageCpuUsageHistoryGraph) {
PerformancePageCpuUsageHistoryGraph.Resize();
PerformancePageCpuUsageHistoryGraph.InvalidateCtrl();
}
return 0;
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// pGraphCtrl = TGraphCtrl::LookupGraphCtrl(hWnd);
// if (pGraphCtrl) pGraphCtrl->Paint(hdc);
GetClientRect(hWnd, &rcClient);
if (hWnd == hPerformancePageMemUsageHistoryGraph) {
PerformancePageMemUsageHistoryGraph.Paint(hWnd, hdc);
}
if (hWnd == hPerformancePageCpuUsageHistoryGraph) {
PerformancePageCpuUsageHistoryGraph.Paint(hWnd, hdc);
}
EndPaint(hWnd, &ps);
return 0;
}
//
// We pass on all non-handled messages
//
return CallWindowProc((WNDPROC)OldGraphCtrlWndProc, hWnd, message, wParam, lParam);
}
#if 0
#include "GraphCtrl.h"
TGraphCtrl* TGraphCtrl::pCtrlArray[] = { 0, 0, 0, 0 };
int TGraphCtrl::CtrlCount = 0;
TGraphCtrl* TGraphCtrl::LookupGraphCtrl(HWND hWnd)
{
for (int i = 0; i < MAX_CTRLS; i++) {
if (pCtrlArray[i] != 0) {
if (pCtrlArray[i]->m_hParentWnd == hWnd) {
return pCtrlArray[i];
}
}
}
return NULL;
}
#endif
Reference in a new issue View git blame Copy permalink