From 17a20222006a859aafecea2b2c9f179cb1be777a Mon Sep 17 00:00:00 2001 From: Steven Edwards Date: Fri, 9 Jan 2004 22:28:32 +0000 Subject: [PATCH] Convert the last of Task Manager from C++ to C. Patch by Eric Pouech. svn path=/trunk/; revision=7535 --- rosapps/taskmgr/graphctl.c | 649 +++++++++++++++++ rosapps/taskmgr/graphctl.cpp | 723 ------------------- rosapps/taskmgr/graphctl.h | 58 +- rosapps/taskmgr/{perfpage.cpp => perfpage.c} | 77 +- 4 files changed, 714 insertions(+), 793 deletions(-) create mode 100644 rosapps/taskmgr/graphctl.c delete mode 100644 rosapps/taskmgr/graphctl.cpp rename rosapps/taskmgr/{perfpage.cpp => perfpage.c} (87%) diff --git a/rosapps/taskmgr/graphctl.c b/rosapps/taskmgr/graphctl.c new file mode 100644 index 00000000000..5f3377b94af --- /dev/null +++ b/rosapps/taskmgr/graphctl.c @@ -0,0 +1,649 @@ +/* + * ReactOS Task Manager + * + * GraphCtrl.cpp + * + * Copyright (C) 2002 Robert Dickenson + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */ +#include +#include +#include +#include +#include +#include +#include + +#include +#include "graphctl.h" +#include "taskmgr.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +LONG OldGraphCtrlWndProc; + +static void GraphCtrl_Init(TGraphCtrl* this) +{ + int i; + + this->m_hWnd = 0; + this->m_hParentWnd = 0; + this->m_dcGrid = 0; + this->m_dcPlot = 0; + this->m_bitmapOldGrid = 0; + this->m_bitmapOldPlot = 0; + this->m_bitmapGrid = 0; + this->m_bitmapPlot = 0; + this->m_brushBack = 0; + + this->m_penPlot[0] = 0; + this->m_penPlot[1] = 0; + this->m_penPlot[2] = 0; + this->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. + */ + this->m_dPreviousPosition[0] = 0.0; + this->m_dPreviousPosition[1] = 0.0; + this->m_dPreviousPosition[2] = 0.0; + this->m_dPreviousPosition[3] = 0.0; + + // public variable for the number of decimal places on the y axis + this->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; + this->m_dLowerLimit = 0.0; + this->m_dUpperLimit = 100.0; + this->m_dRange = this->m_dUpperLimit - this->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 + this->m_nShiftPixels = 4; + this->m_nHalfShiftPixels = this->m_nShiftPixels/2; // protected + this->m_nPlotShiftPixels = this->m_nShiftPixels + this->m_nHalfShiftPixels; // protected + + // background, grid and data colors + // these are public variables and can be set directly + this->m_crBackColor = RGB( 0, 0, 0); // see also SetBackgroundColor + this->m_crGridColor = RGB( 0, 255, 255); // see also SetGridColor + this->m_crPlotColor[0] = RGB(255, 255, 255); // see also SetPlotColor + this->m_crPlotColor[1] = RGB(100, 255, 255); // see also SetPlotColor + this->m_crPlotColor[2] = RGB(255, 100, 255); // see also SetPlotColor + this->m_crPlotColor[3] = RGB(255, 255, 100); // see also SetPlotColor + + // protected variables + for (i = 0; i < MAX_PLOTS; i++) + { + this->m_penPlot[i] = CreatePen(PS_SOLID, 0, this->m_crPlotColor[i]); + } + this->m_brushBack = CreateSolidBrush(this->m_crBackColor); + + // public member variables, can be set directly + strcpy(this->m_strXUnitsString, "Samples"); // can also be set with SetXUnits + strcpy(this->m_strYUnitsString, "Y units"); // can also be set with SetYUnits + + // protected bitmaps to restore the memory DC's + this->m_bitmapOldGrid = NULL; + this->m_bitmapOldPlot = NULL; +} + +#if 0 +///////////////////////////////////////////////////////////////////////////// +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); +} +#endif + +///////////////////////////////////////////////////////////////////////////// +BOOL GraphCtrl_Create(TGraphCtrl* this, HWND hWnd, HWND hParentWnd, UINT nID) +{ + BOOL result = 0; + + GraphCtrl_Init(this); + this->m_hParentWnd = hParentWnd; + this->m_hWnd = hWnd; + GraphCtrl_Resize(this); + if (result != 0) + GraphCtrl_InvalidateCtrl(this); + return result; +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_SetRange(TGraphCtrl* this, double dLower, double dUpper, int nDecimalPlaces) +{ + //ASSERT(dUpper > dLower); + this->m_dLowerLimit = dLower; + this->m_dUpperLimit = dUpper; + this->m_nYDecimals = nDecimalPlaces; + this->m_dRange = this->m_dUpperLimit - this->m_dLowerLimit; + this->m_dVerticalFactor = (double)this->m_nPlotHeight / this->m_dRange; + // clear out the existing garbage, re-start with a clean plot + GraphCtrl_InvalidateCtrl(this); +} + +#if 0 +///////////////////////////////////////////////////////////////////////////// +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(); +} +#endif + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_SetGridColor(TGraphCtrl* this, COLORREF color) +{ + this->m_crGridColor = color; + // clear out the existing garbage, re-start with a clean plot + GraphCtrl_InvalidateCtrl(this); +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_SetPlotColor(TGraphCtrl* this, int plot, COLORREF color) +{ + this->m_crPlotColor[plot] = color; + DeleteObject(this->m_penPlot[plot]); + this->m_penPlot[plot] = CreatePen(PS_SOLID, 0, this->m_crPlotColor[plot]); + // clear out the existing garbage, re-start with a clean plot + GraphCtrl_InvalidateCtrl(this); +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_SetBackgroundColor(TGraphCtrl* this, COLORREF color) +{ + this->m_crBackColor = color; + DeleteObject(this->m_brushBack); + this->m_brushBack = CreateSolidBrush(this->m_crBackColor); + // clear out the existing garbage, re-start with a clean plot + GraphCtrl_InvalidateCtrl(this); +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_InvalidateCtrl(TGraphCtrl* this) +{ + // 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, this->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(this->m_hParentWnd); + + // if we don't have one yet, set up a memory dc for the grid + if (this->m_dcGrid == NULL) + { + this->m_dcGrid = CreateCompatibleDC(dc); + this->m_bitmapGrid = CreateCompatibleBitmap(dc, this->m_nClientWidth, this->m_nClientHeight); + this->m_bitmapOldGrid = (HBITMAP)SelectObject(this->m_dcGrid, this->m_bitmapGrid); + } + + SetBkColor(this->m_dcGrid, this->m_crBackColor); + + // fill the grid background + FillRect(this->m_dcGrid, &this->m_rectClient, this->m_brushBack); + + // draw the plot rectangle: + // determine how wide the y axis scaling values are + nCharacters = abs((int)log10(fabs(this->m_dUpperLimit))); + nCharacters = max(nCharacters, abs((int)log10(fabs(this->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 + this->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); + this->m_rectPlot.left = this->m_rectClient.left; + this->m_nPlotWidth = this->m_rectPlot.right - this->m_rectPlot.left;//m_rectPlot.Width(); + + // draw the plot rectangle + oldPen = (HPEN)SelectObject(this->m_dcGrid, solidPen); + MoveToEx(this->m_dcGrid, this->m_rectPlot.left, this->m_rectPlot.top, NULL); + LineTo(this->m_dcGrid, this->m_rectPlot.right+1, this->m_rectPlot.top); + LineTo(this->m_dcGrid, this->m_rectPlot.right+1, this->m_rectPlot.bottom+1); + LineTo(this->m_dcGrid, this->m_rectPlot.left, this->m_rectPlot.bottom+1); + // LineTo(m_dcGrid, m_rectPlot.left, m_rectPlot.top); + SelectObject(this->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 = (this->m_rectPlot.top + this->m_rectPlot.bottom)/2; + nTopGridPix = nMidGridPix - this->m_nPlotHeight/4; + nBottomGridPix = nMidGridPix + this->m_nPlotHeight/4; + + for (i=this->m_rectPlot.left; im_rectPlot.right; i+=2) + { + SetPixel(this->m_dcGrid, i, nTopGridPix, this->m_crGridColor); + SetPixel(this->m_dcGrid, i, nMidGridPix, this->m_crGridColor); + SetPixel(this->m_dcGrid, i, nBottomGridPix, this->m_crGridColor); + } + + for (i=this->m_rectPlot.left; im_rectPlot.right; i+=10) + { + for (j=this->m_rectPlot.top; jm_rectPlot.bottom; j+=2) + { + SetPixel(this->m_dcGrid, i, j, this->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 (this->m_dcPlot == NULL) + { + this->m_dcPlot = CreateCompatibleDC(dc); + this->m_bitmapPlot = CreateCompatibleBitmap(dc, this->m_nClientWidth, this->m_nClientHeight); + this->m_bitmapOldPlot = (HBITMAP)SelectObject(this->m_dcPlot, this->m_bitmapPlot); + } + + // make sure the plot bitmap is cleared + SetBkColor(this->m_dcPlot, this->m_crBackColor); + FillRect(this->m_dcPlot, &this->m_rectClient, this->m_brushBack); + + // finally, force the plot area to redraw + InvalidateRect(this->m_hParentWnd, &this->m_rectClient, TRUE); + ReleaseDC(this->m_hParentWnd, dc); +} + +///////////////////////////////////////////////////////////////////////////// +double GraphCtrl_AppendPoint(TGraphCtrl* this, + double dNewPoint0, double dNewPoint1, + double dNewPoint2, double dNewPoint3) +{ + // append a data point to the plot & return the previous point + double dPrevious; + + dPrevious = this->m_dCurrentPosition[0]; + this->m_dCurrentPosition[0] = dNewPoint0; + this->m_dCurrentPosition[1] = dNewPoint1; + this->m_dCurrentPosition[2] = dNewPoint2; + this->m_dCurrentPosition[3] = dNewPoint3; + GraphCtrl_DrawPoint(this); + //Invalidate(); + return dPrevious; +} + +//////////////////////////////////////////////////////////////////////////// +void GraphCtrl_Paint(TGraphCtrl* this, 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, this->m_nClientWidth, this->m_nClientHeight); + oldBitmap = (HBITMAP)SelectObject(memDC, memBitmap); + + if (memDC != NULL) + { + // first drop the grid on the memory dc + BitBlt(memDC, 0, 0, this->m_nClientWidth, this->m_nClientHeight, this->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, this->m_nClientWidth, this->m_nClientHeight, this->m_dcPlot, 0, 0, SRCPAINT); //SRCPAINT + // finally send the result to the display + BitBlt(dc, 0, 0, this->m_nClientWidth, this->m_nClientHeight, memDC, 0, 0, SRCCOPY); + } + SelectObject(memDC, oldBitmap); + DeleteObject(memBitmap); + DeleteDC(memDC); +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_DrawPoint(TGraphCtrl* this) +{ + // 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; + int i; + + if (this->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(this->m_dcPlot, this->m_rectPlot.left, this->m_rectPlot.top+1, + this->m_nPlotWidth, this->m_nPlotHeight, this->m_dcPlot, + this->m_rectPlot.left+this->m_nShiftPixels, this->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 = this->m_rectPlot; + rectCleanUp.left = rectCleanUp.right - this->m_nShiftPixels; + + // fill the cleanup area with the background + FillRect(this->m_dcPlot, &rectCleanUp, this->m_brushBack); + + // draw the next line segement + for (i = 0; i < MAX_PLOTS; i++) + { + // grab the plotting pen + oldPen = (HPEN)SelectObject(this->m_dcPlot, this->m_penPlot[i]); + + // move to the previous point + prevX = this->m_rectPlot.right-this->m_nPlotShiftPixels; + prevY = this->m_rectPlot.bottom - + (long)((this->m_dPreviousPosition[i] - this->m_dLowerLimit) * this->m_dVerticalFactor); + MoveToEx(this->m_dcPlot, prevX, prevY, NULL); + + // draw to the current point + currX = this->m_rectPlot.right-this->m_nHalfShiftPixels; + currY = this->m_rectPlot.bottom - + (long)((this->m_dCurrentPosition[i] - this->m_dLowerLimit) * this->m_dVerticalFactor); + LineTo(this->m_dcPlot, currX, currY); + + // Restore the pen + SelectObject(this->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 <= this->m_rectPlot.top) || (currY <= this->m_rectPlot.top)) + { + RECT rc; + rc.bottom = this->m_rectPlot.top+1; + rc.left = prevX; + rc.right = currX+1; + rc.top = this->m_rectClient.top; + FillRect(this->m_dcPlot, &rc, this->m_brushBack); + } + if ((prevY >= this->m_rectPlot.bottom) || (currY >= this->m_rectPlot.bottom)) + { + RECT rc; + rc.bottom = this->m_rectClient.bottom+1; + rc.left = prevX; + rc.right = currX+1; + rc.top = this->m_rectPlot.bottom+1; + //RECT rc(prevX, m_rectPlot.bottom+1, currX+1, m_rectClient.bottom+1); + FillRect(this->m_dcPlot, &rc, this->m_brushBack); + } + + // store the current point for connection to the next point + this->m_dPreviousPosition[i] = this->m_dCurrentPosition[i]; + } + } +} + +///////////////////////////////////////////////////////////////////////////// +void GraphCtrl_Resize(TGraphCtrl* this) +{ + // NOTE: Resize automatically gets called during the setup of the control + GetClientRect(this->m_hWnd, &this->m_rectClient); + + // set some member variables to avoid multiple function calls + this->m_nClientHeight = this->m_rectClient.bottom - this->m_rectClient.top;//m_rectClient.Height(); + this->m_nClientWidth = this->m_rectClient.right - this->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 + this->m_rectPlot.left = 20; + this->m_rectPlot.top = 10; + this->m_rectPlot.right = this->m_rectClient.right-10; + this->m_rectPlot.bottom = this->m_rectClient.bottom-25; +#else + this->m_rectPlot.left = 0; + this->m_rectPlot.top = -1; + this->m_rectPlot.right = this->m_rectClient.right-0; + this->m_rectPlot.bottom = this->m_rectClient.bottom-0; +#endif + + // set some member variables to avoid multiple function calls + this->m_nPlotHeight = this->m_rectPlot.bottom - this->m_rectPlot.top;//m_rectPlot.Height(); + this->m_nPlotWidth = this->m_rectPlot.right - this->m_rectPlot.left;//m_rectPlot.Width(); + + // set the scaling factor for now, this can be adjusted + // in the SetRange functions + this->m_dVerticalFactor = (double)this->m_nPlotHeight / this->m_dRange; +} + +#if 0 +///////////////////////////////////////////////////////////////////////////// +void TGraphCtrl::Reset() +{ + // to clear the existing data (in the form of a bitmap) + // simply invalidate the entire control + InvalidateCtrl(); +} +#endif + +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; + + 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: + if (hWnd == hPerformancePageMemUsageHistoryGraph) + { + GraphCtrl_Resize(&PerformancePageMemUsageHistoryGraph); + GraphCtrl_InvalidateCtrl(&PerformancePageMemUsageHistoryGraph); + } + if (hWnd == hPerformancePageCpuUsageHistoryGraph) + { + GraphCtrl_Resize(&PerformancePageCpuUsageHistoryGraph); + GraphCtrl_InvalidateCtrl(&PerformancePageCpuUsageHistoryGraph); + } + return 0; + + case WM_PAINT: + hdc = BeginPaint(hWnd, &ps); + GetClientRect(hWnd, &rcClient); + if (hWnd == hPerformancePageMemUsageHistoryGraph) + GraphCtrl_Paint(&PerformancePageMemUsageHistoryGraph, hWnd, hdc); + if (hWnd == hPerformancePageCpuUsageHistoryGraph) + GraphCtrl_Paint(&PerformancePageCpuUsageHistoryGraph, hWnd, hdc); + EndPaint(hWnd, &ps); + return 0; + } + + // + // We pass on all non-handled messages + // + return CallWindowProc((WNDPROC)OldGraphCtrlWndProc, hWnd, message, wParam, lParam); +} diff --git a/rosapps/taskmgr/graphctl.cpp b/rosapps/taskmgr/graphctl.cpp deleted file mode 100644 index 213b47d4462..00000000000 --- a/rosapps/taskmgr/graphctl.cpp +++ /dev/null @@ -1,723 +0,0 @@ -/* - * ReactOS Task Manager - * - * GraphCtrl.cpp - * - * Copyright (C) 2002 Robert Dickenson - * - * 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 -#include -#include -#include -#include -#include -#include -#include - -#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.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 - diff --git a/rosapps/taskmgr/graphctl.h b/rosapps/taskmgr/graphctl.h index d68bb2c1286..589500b341c 100644 --- a/rosapps/taskmgr/graphctl.h +++ b/rosapps/taskmgr/graphctl.h @@ -26,41 +26,25 @@ #define MAX_PLOTS 4 #define MAX_CTRLS 4 - #ifdef __cplusplus +extern "C" { +#endif +#if 0 -class TGraphCtrl -{ /* Attributes */ public: - double AppendPoint(double dNewPoint0, double dNewPoint1 = 0.0, - double dNewPoint2 = 0.0, double dNewPoint3 = 0.0); - void SetRange(double dLower, double dUpper, int nDecimalPlaces=1); void SetXUnits(const char* string); void SetYUnits(const char* string); - void SetGridColor(COLORREF color); - void SetPlotColor(int plot, COLORREF color); - void SetBackgroundColor(COLORREF color); - void InvalidateCtrl(); - void DrawPoint(); - void Reset(); /* Operations */ public: BOOL Create(DWORD dwStyle, const RECT& rect, HWND hParentWnd, UINT nID=NULL); - BOOL Create(HWND hWnd, HWND hParentWnd, UINT nID=NULL); - void Paint(HWND hWnd, HDC dc); - void Resize(void); -#if 0 - static TGraphCtrl* LookupGraphCtrl(HWND hWnd); - static TGraphCtrl* pCtrlArray[MAX_CTRLS]; - static int CtrlCount; #endif -/* Implementation */ -public: +typedef struct +{ int m_nShiftPixels; /* amount to shift with each new point */ int m_nYDecimals; @@ -74,12 +58,7 @@ public: double m_dCurrentPosition[MAX_PLOTS]; /* current position */ double m_dPreviousPosition[MAX_PLOTS]; /* previous position */ -/* Construction */ -public: - TGraphCtrl(); - virtual ~TGraphCtrl(); - -protected: +/* those were protected fields */ int m_nHalfShiftPixels; int m_nPlotShiftPixels; int m_nClientHeight; @@ -104,18 +83,31 @@ protected: HPEN m_penPlot[MAX_PLOTS]; RECT m_rectClient; RECT m_rectPlot; -}; - -extern "C" { -#endif +} TGraphCtrl; extern LONG OldGraphCtrlWndProc; +double GraphCtrl_AppendPoint(TGraphCtrl* this, + double dNewPoint0, double dNewPoint1, + double dNewPoint2, double dNewPoint3); +BOOL GraphCtrl_Create(TGraphCtrl* this, HWND hWnd, HWND hParentWnd, +UINT nID); +void GraphCtrl_DrawPoint(TGraphCtrl* this); +void GraphCtrl_InvalidateCtrl(TGraphCtrl* this); +void GraphCtrl_Paint(TGraphCtrl* this, HWND hWnd, HDC dc); +void GraphCtrl_Reset(TGraphCtrl* this); +void GraphCtrl_Resize(TGraphCtrl* this); +void GraphCtrl_SetBackgroundColor(TGraphCtrl* this, COLORREF +color); +void GraphCtrl_SetGridColor(TGraphCtrl* this, COLORREF color); +void GraphCtrl_SetPlotColor(TGraphCtrl* this, int plot, COLORREF +color); +void GraphCtrl_SetRange(TGraphCtrl* this, double dLower, double +dUpper, int nDecimalPlaces); LRESULT CALLBACK GraphCtrl_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam); #ifdef __cplusplus -}; +} #endif - #endif /* __GRAPH_CTRL_H__ */ diff --git a/rosapps/taskmgr/perfpage.cpp b/rosapps/taskmgr/perfpage.c similarity index 87% rename from rosapps/taskmgr/perfpage.cpp rename to rosapps/taskmgr/perfpage.c index ce4c429d881..16d816a4abe 100644 --- a/rosapps/taskmgr/perfpage.cpp +++ b/rosapps/taskmgr/perfpage.c @@ -5,30 +5,30 @@ * * Copyright (C) 1999 - 2001 Brian Palmer * - * 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 program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 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. + * This program 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 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 + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ - -#define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */ + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers #include #include #include #include #include #include -#include #include +#include #include "taskmgr.h" #include "perfpage.h" @@ -40,7 +40,7 @@ TGraphCtrl PerformancePageCpuUsageHistoryGraph; TGraphCtrl PerformancePageMemUsageHistoryGraph; -HWND hPerformancePage; /* Performance Property Page */ +HWND hPerformancePage; // Performance Property Page HWND hPerformancePageCpuUsageGraph; // CPU Usage Graph HWND hPerformancePageMemUsageGraph; // MEM Usage Graph @@ -79,7 +79,7 @@ static int nPerformancePageHeight; static HANDLE hPerformancePageEvent = NULL; // When this event becomes signaled then we refresh the performance page -void PerformancePageRefreshThread(void *lpParameter); +DWORD WINAPI PerformancePageRefreshThread(void *lpParameter); void AdjustFrameSize(HWND hCntrl, HWND hDlg, int nXDifference, int nYDifference, int pos) { @@ -181,30 +181,30 @@ LRESULT CALLBACK PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, GetClientRect(hPerformancePageCpuUsageHistoryGraph, &rc); // create the control //PerformancePageCpuUsageHistoryGraph.Create(0, rc, hDlg, IDC_CPU_USAGE_HISTORY_GRAPH); - PerformancePageCpuUsageHistoryGraph.Create(hPerformancePageCpuUsageHistoryGraph, hDlg, IDC_CPU_USAGE_HISTORY_GRAPH); + GraphCtrl_Create(&PerformancePageCpuUsageHistoryGraph, hPerformancePageCpuUsageHistoryGraph, hDlg, IDC_CPU_USAGE_HISTORY_GRAPH); // customize the control - PerformancePageCpuUsageHistoryGraph.SetRange(0.0, 100.0, 10) ; + 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)) ; - PerformancePageCpuUsageHistoryGraph.SetBackgroundColor(RGB(0, 0, 0)) ; - PerformancePageCpuUsageHistoryGraph.SetGridColor(RGB(152, 205, 152)) ; - PerformancePageCpuUsageHistoryGraph.SetPlotColor(0, RGB(255, 0, 0)) ; - PerformancePageCpuUsageHistoryGraph.SetPlotColor(1, RGB(0, 255, 0)) ; - - GetClientRect(hPerformancePageMemUsageHistoryGraph, &rc); - PerformancePageMemUsageHistoryGraph.Create(hPerformancePageMemUsageHistoryGraph, hDlg, IDC_MEM_USAGE_HISTORY_GRAPH); - PerformancePageMemUsageHistoryGraph.SetRange(0.0, 100.0, 10) ; - PerformancePageMemUsageHistoryGraph.SetBackgroundColor(RGB(0, 0, 0)) ; - PerformancePageMemUsageHistoryGraph.SetGridColor(RGB(152, 215, 152)) ; - PerformancePageMemUsageHistoryGraph.SetPlotColor(0, RGB(255, 255, 0)) ; + 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 - _beginthread(PerformancePageRefreshThread, 0, NULL); + CreateThread(NULL, 0, PerformancePageRefreshThread, NULL, 0, NULL); #endif + // // Subclass graph buttons // @@ -232,6 +232,7 @@ LRESULT CALLBACK PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, break; #endif case WM_SIZE: + do { int cx, cy; if (wParam == SIZE_MINIMIZED) @@ -243,6 +244,7 @@ LRESULT CALLBACK PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, nYDifference = cy - nPerformancePageHeight; nPerformancePageWidth = cx; nPerformancePageHeight = cy; + } while (0); // Reposition the performance page's controls AdjustFrameSize(hPerformancePageTotalsFrame, hDlg, 0, nYDifference, 0); @@ -318,7 +320,7 @@ void RefreshPerformancePage(void) SetEvent(hPerformancePageEvent); } -void PerformancePageRefreshThread(void *lpParameter) +DWORD WINAPI PerformancePageRefreshThread(void *lpParameter) { ULONG CommitChargeTotal; ULONG CommitChargeLimit; @@ -343,7 +345,7 @@ void PerformancePageRefreshThread(void *lpParameter) // If we couldn't create the event then exit the thread if (!hPerformancePageEvent) - return; + return 0; while (1) { @@ -355,7 +357,7 @@ void PerformancePageRefreshThread(void *lpParameter) // 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; + return 0; if (dwWaitVal == WAIT_OBJECT_0) { @@ -448,20 +450,21 @@ void PerformancePageRefreshThread(void *lpParameter) // CommitChargeTotal = (ULONGLONG)PerfDataGetCommitChargeTotalK(); CommitChargeLimit = (ULONGLONG)PerfDataGetCommitChargeLimitK(); - nBarsUsed1 = ((CommitChargeTotal * 100) / CommitChargeLimit); + nBarsUsed1 = CommitChargeLimit ? ((CommitChargeTotal * 100) / CommitChargeLimit) : 0; PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK(); PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK(); - nBarsUsed2 = ((PhysicalMemoryAvailable * 100) / PhysicalMemoryTotal); + nBarsUsed2 = PhysicalMemoryTotal ? ((PhysicalMemoryAvailable * 100) / PhysicalMemoryTotal) : 0; - PerformancePageCpuUsageHistoryGraph.AppendPoint(CpuUsage, CpuKernelUsage); - PerformancePageMemUsageHistoryGraph.AppendPoint(nBarsUsed1, nBarsUsed2); + 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; } void PerformancePage_OnViewShowKernelTimes(void)