programs/taskmgr/graph.c

   1 /*
   2  *  ReactOS Task Manager
   3  *
   4  *  graph.c
   5  *
   6  *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
   7  *  Copyright (C) 2008  Vladimir Pankratov
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include <windows.h>
  28 #include <commctrl.h>
  29 #include <shlwapi.h>
  30 #include <winnt.h>
  31
  32 #include "taskmgr.h"
  33 #include "perfdata.h"
  34
  35 #define BRIGHT_GREEN    RGB(0, 255, 0)
  36 #define DARK_GREEN      RGB(0, 130, 0)
  37 #define RED             RGB(255, 0, 0)
  38
  39
  40 WNDPROC             OldGraphWndProc;
  41
  42 static void Graph_DrawCpuUsageGraph(HDC hDC, HWND hWnd)
  43 {
  44     RECT            rcClient;
  45     RECT            rcBarLeft;
  46     RECT            rcBarRight;
  47     RECT            rcText;
  48     WCHAR            Text[256];
  49     ULONG            CpuUsage;
  50     ULONG            CpuKernelUsage;
  51     int                nBars;
  52     int                nBarsUsed;
  53 /* Bottom bars that are "used", i.e. are bright green, representing used cpu time */
  54     int                nBarsUsedKernel;
  55 /* Bottom bars that are "used", i.e. are bright green, representing used cpu kernel time */
  56     int                nBarsFree;
  57 /* Top bars that are "unused", i.e. are dark green, representing free cpu time */
  58     int                i;
  59
  60     static const WCHAR    wszFormatI[] = {'%','d','%','%',0};
  61     static const WCHAR    wszFormatII[] = {' ',' ','%','d','%','%',0};
  62     static const WCHAR    wszFormatIII[] = {' ','%','d','%','%',0};
  63
  64     /*
  65      * Get the client area rectangle
  66      */
  67     GetClientRect(hWnd, &rcClient);
  68
  69     /*
  70      * Fill it with blackness
  71      */
  72     FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
  73
  74     /*
  75      * Get the CPU usage
  76      */
  77     CpuUsage = PerfDataGetProcessorUsage();
  78     CpuKernelUsage = PerfDataGetProcessorSystemUsage();
  79
  80     /*
  81      * Check and see how many digits it will take
  82      * so we get the indentation right every time.
  83      */
  84     if (CpuUsage == 100)
  85     {
  86         swprintf(Text, ARRAY_SIZE(Text), wszFormatI, (int)CpuUsage);
  87     }
  88     else if (CpuUsage < 10)
  89     {
  90         swprintf(Text, ARRAY_SIZE(Text), wszFormatII, (int)CpuUsage);
  91     }
  92     else
  93     {
  94         swprintf(Text, ARRAY_SIZE(Text), wszFormatIII, (int)CpuUsage);
  95     }
  96
  97     /*
  98      * Draw the font text onto the graph
  99      * The bottom 20 pixels are reserved for the text
 100      */
 101     CopyRect(&rcText, &rcClient);
 102     rcText.top = rcText.bottom - 19;
 103
 104     SetTextColor(hDC, BRIGHT_GREEN);
 105     DrawTextW(hDC, Text, -1, &rcText, DT_CENTER);
 106
 107     /*
 108      * Now we have to draw the graph
 109      * So first find out how many bars we can fit
 110      */
 111     nBars = ((rcClient.bottom - rcClient.top) - 25) / 3;
 112     nBarsUsed = (nBars * CpuUsage) / 100;
 113     if ((CpuUsage) && (nBarsUsed == 0))
 114     {
 115         nBarsUsed = 1;
 116     }
 117     nBarsFree = nBars - nBarsUsed;
 118     if (TaskManagerSettings.ShowKernelTimes)
 119     {
 120         nBarsUsedKernel = ((nBars * 2) * CpuKernelUsage) / 100;
 121         nBarsUsed -= (nBarsUsedKernel / 2);
 122     }
 123     else
 124     {
 125         nBarsUsedKernel = 0;
 126     }
 127
 128     /*
 129      * Now draw the bar graph
 130      */
 131     rcBarLeft.left =  ((rcClient.right - rcClient.left) - 33) / 2;
 132     rcBarLeft.right =  rcBarLeft.left + 16;
 133     rcBarRight.left = rcBarLeft.left + 17;
 134     rcBarRight.right = rcBarLeft.right + 17;
 135     rcBarLeft.top = rcBarRight.top = 5;
 136     rcBarLeft.bottom = rcBarRight.bottom = 7;
 137
 138     if (nBarsUsed < 0)     nBarsUsed = 0;
 139     if (nBarsUsed > nBars) nBarsUsed = nBars;
 140
 141     if (nBarsFree < 0)     nBarsFree = 0;
 142     if (nBarsFree > nBars) nBarsFree = nBars;
 143
 144     if (nBarsUsedKernel < 0)     nBarsUsedKernel = 0;
 145     if (nBarsUsedKernel > nBars) nBarsUsedKernel = nBars;
 146
 147     /*
 148      * Draw the "free" bars
 149      */
 150     for (i=0; i<nBarsFree; i++)
 151     {
 152         FillSolidRect(hDC, &rcBarLeft, DARK_GREEN);
 153         FillSolidRect(hDC, &rcBarRight, DARK_GREEN);
 154
 155         rcBarLeft.top += 3;
 156         rcBarLeft.bottom += 3;
 157
 158         rcBarRight.top += 3;
 159         rcBarRight.bottom += 3;
 160     }
 161
 162     /*
 163      * Draw the "used" bars
 164      */
 165     for (i=0; i<nBarsUsed; i++)
 166     {
 167         if (nBarsUsed > 5000) nBarsUsed = 5000;
 168
 169         FillSolidRect(hDC, &rcBarLeft, BRIGHT_GREEN);
 170         FillSolidRect(hDC, &rcBarRight, BRIGHT_GREEN);
 171
 172         rcBarLeft.top += 3;
 173         rcBarLeft.bottom += 3;
 174
 175         rcBarRight.top += 3;
 176         rcBarRight.bottom += 3;
 177     }
 178
 179     /*
 180      * Draw the "used" kernel bars
 181      */
 182     rcBarLeft.bottom--;
 183     rcBarRight.bottom--;
 184     if (nBarsUsedKernel && nBarsUsedKernel % 2)
 185     {
 186         rcBarLeft.top -= 2;
 187         rcBarLeft.bottom -= 2;
 188
 189         rcBarRight.top -= 2;
 190         rcBarRight.bottom -= 2;
 191
 192         FillSolidRect(hDC, &rcBarLeft, RED);
 193         FillSolidRect(hDC, &rcBarRight, RED);
 194
 195         rcBarLeft.top += 2;
 196         rcBarLeft.bottom += 2;
 197
 198         rcBarRight.top += 2;
 199         rcBarRight.bottom += 2;
 200
 201         nBarsUsedKernel--;
 202     }
 203     for (i=0; i<nBarsUsedKernel; i++)
 204     {
 205         if (nBarsUsedKernel > 5000) nBarsUsedKernel = 5000;
 206
 207         FillSolidRect(hDC, &rcBarLeft, RED);
 208         FillSolidRect(hDC, &rcBarRight, RED);
 209
 210         rcBarLeft.top++;
 211         rcBarLeft.bottom++;
 212
 213         rcBarRight.top++;
 214         rcBarRight.bottom++;
 215
 216         if (i % 2)
 217         {
 218             rcBarLeft.top++;
 219             rcBarLeft.bottom++;
 220
 221             rcBarRight.top++;
 222             rcBarRight.bottom++;
 223         }
 224     }
 225 }
 226
 227 static void Graph_DrawMemUsageGraph(HDC hDC, HWND hWnd)
 228 {
 229     RECT            rcClient;
 230     RECT            rcBarLeft;
 231     RECT            rcBarRight;
 232     RECT            rcText;
 233     WCHAR            Text[256];
 234     ULONGLONG        CommitChargeTotal;
 235     ULONGLONG        CommitChargeLimit;
 236     int                nBars;
 237     int                nBarsUsed = 0;
 238 /* Bottom bars that are "used", i.e. are bright green, representing used memory */
 239     int                nBarsFree;
 240 /* Top bars that are "unused", i.e. are dark green, representing free memory */
 241     int                i;
 242
 243     /*
 244      * Get the client area rectangle
 245      */
 246     GetClientRect(hWnd, &rcClient);
 247
 248     /*
 249      * Fill it with blackness
 250      */
 251     FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
 252
 253     /*
 254      * Get the memory usage
 255      */
 256     CommitChargeTotal = (ULONGLONG)PerfDataGetCommitChargeTotalK();
 257     CommitChargeLimit = (ULONGLONG)PerfDataGetCommitChargeLimitK();
 258
 259     if (CommitChargeTotal < 1024)
 260         StrFormatKBSizeW(CommitChargeTotal, Text, ARRAY_SIZE(Text));
 261     else
 262         StrFormatByteSizeW(CommitChargeTotal, Text, ARRAY_SIZE(Text));
 263
 264     /*
 265      * Draw the font text onto the graph
 266      * The bottom 20 pixels are reserved for the text
 267      */
 268     CopyRect(&rcText, &rcClient);
 269     rcText.top = rcText.bottom - 19;
 270
 271     SetTextColor(hDC, BRIGHT_GREEN);
 272     DrawTextW(hDC, Text, -1, &rcText, DT_CENTER);
 273
 274     /*
 275      * Now we have to draw the graph
 276      * So first find out how many bars we can fit
 277      */
 278     nBars = ((rcClient.bottom - rcClient.top) - 25) / 3;
 279     if (CommitChargeLimit)
 280         nBarsUsed = (nBars * (int)((CommitChargeTotal * 100) / CommitChargeLimit)) / 100;
 281     nBarsFree = nBars - nBarsUsed;
 282
 283     if (nBarsUsed < 0)     nBarsUsed = 0;
 284     if (nBarsUsed > nBars) nBarsUsed = nBars;
 285
 286     if (nBarsFree < 0)     nBarsFree = 0;
 287     if (nBarsFree > nBars) nBarsFree = nBars;
 288
 289     /*
 290      * Now draw the bar graph
 291      */
 292     rcBarLeft.left =  ((rcClient.right - rcClient.left) - 33) / 2;
 293     rcBarLeft.right =  rcBarLeft.left + 16;
 294     rcBarRight.left = rcBarLeft.left + 17;
 295     rcBarRight.right = rcBarLeft.right + 17;
 296     rcBarLeft.top = rcBarRight.top = 5;
 297     rcBarLeft.bottom = rcBarRight.bottom = 7;
 298
 299     /*
 300      * Draw the "free" bars
 301      */
 302     for (i=0; i<nBarsFree; i++)
 303     {
 304         FillSolidRect(hDC, &rcBarLeft, DARK_GREEN);
 305         FillSolidRect(hDC, &rcBarRight, DARK_GREEN);
 306
 307         rcBarLeft.top += 3;
 308         rcBarLeft.bottom += 3;
 309
 310         rcBarRight.top += 3;
 311         rcBarRight.bottom += 3;
 312     }
 313
 314     /*
 315      * Draw the "used" bars
 316      */
 317     for (i=0; i<nBarsUsed; i++)
 318     {
 319         FillSolidRect(hDC, &rcBarLeft, BRIGHT_GREEN);
 320         FillSolidRect(hDC, &rcBarRight, BRIGHT_GREEN);
 321
 322         rcBarLeft.top += 3;
 323         rcBarLeft.bottom += 3;
 324
 325         rcBarRight.top += 3;
 326         rcBarRight.bottom += 3;
 327     }
 328 }
 329
 330 static void Graph_DrawMemUsageHistoryGraph(HDC hDC, HWND hWnd)
 331 {
 332     RECT            rcClient;
 333     int                i;
 334     static int        offset = 0;
 335
 336     if (offset++ >= 10)
 337         offset = 0;
 338
 339     /*
 340      * Get the client area rectangle
 341      */
 342     GetClientRect(hWnd, &rcClient);
 343
 344     /*
 345      * Fill it with blackness
 346      */
 347     FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
 348
 349     /*
 350      * Draw the graph background
 351      *
 352      * Draw the horizontal bars
 353      */
 354     for (i=0; i<rcClient.bottom; i++)
 355     {
 356         if ((i % 11) == 0)
 357         {
 358             /* FillSolidRect2(hDC, 0, i, rcClient.right, 1, DARK_GREEN);  */
 359         }
 360     }
 361     /*
 362      * Draw the vertical bars
 363      */
 364     for (i=11; i<rcClient.right + offset; i++)
 365     {
 366         if ((i % 11) == 0)
 367         {
 368             /* FillSolidRect2(hDC, i - offset, 0, 1, rcClient.bottom, DARK_GREEN);  */
 369         }
 370     }
 371
 372     /*
 373      * Draw the memory usage
 374      */
 375     for (i=rcClient.right; i>=0; i--)
 376     {
 377     }
 378 }
 379
 380 INT_PTR CALLBACK
 381 Graph_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 382 {
 383     HDC                hdc;
 384     PAINTSTRUCT        ps;
 385     LONG            WindowId;
 386
 387     switch (message)
 388     {
 389     case WM_ERASEBKGND:
 390         return TRUE;
 391
 392     /*
 393      * Filter out mouse  & keyboard messages
 394      */
 395     /* case WM_APPCOMMAND: */
 396     case WM_CAPTURECHANGED:
 397     case WM_LBUTTONDBLCLK:
 398     case WM_LBUTTONDOWN:
 399     case WM_LBUTTONUP:
 400     case WM_MBUTTONDBLCLK:
 401     case WM_MBUTTONDOWN:
 402     case WM_MBUTTONUP:
 403     case WM_MOUSEACTIVATE:
 404     case WM_MOUSEHOVER:
 405     case WM_MOUSELEAVE:
 406     case WM_MOUSEMOVE:
 407     /* case WM_MOUSEWHEEL: */
 408     case WM_NCHITTEST:
 409     case WM_NCLBUTTONDBLCLK:
 410     case WM_NCLBUTTONDOWN:
 411     case WM_NCLBUTTONUP:
 412     case WM_NCMBUTTONDBLCLK:
 413     case WM_NCMBUTTONDOWN:
 414     case WM_NCMBUTTONUP:
 415     /* case WM_NCMOUSEHOVER: */
 416     /* case WM_NCMOUSELEAVE: */
 417     case WM_NCMOUSEMOVE:
 418     case WM_NCRBUTTONDBLCLK:
 419     case WM_NCRBUTTONDOWN:
 420     case WM_NCRBUTTONUP:
 421     /* case WM_NCXBUTTONDBLCLK: */
 422     /* case WM_NCXBUTTONDOWN: */
 423     /* case WM_NCXBUTTONUP: */
 424     case WM_RBUTTONDBLCLK:
 425     case WM_RBUTTONDOWN:
 426     case WM_RBUTTONUP:
 427     /* case WM_XBUTTONDBLCLK: */
 428     /* case WM_XBUTTONDOWN: */
 429     /* case WM_XBUTTONUP: */
 430     case WM_ACTIVATE:
 431     case WM_CHAR:
 432     case WM_DEADCHAR:
 433     case WM_GETHOTKEY:
 434     case WM_HOTKEY:
 435     case WM_KEYDOWN:
 436     case WM_KEYUP:
 437     case WM_KILLFOCUS:
 438     case WM_SETFOCUS:
 439     case WM_SETHOTKEY:
 440     case WM_SYSCHAR:
 441     case WM_SYSDEADCHAR:
 442     case WM_SYSKEYDOWN:
 443     case WM_SYSKEYUP:
 444
 445     case WM_NCCALCSIZE:
 446         return 0;
 447
 448     case WM_PAINT:
 449
 450         hdc = BeginPaint(hWnd, &ps);
 451
 452         WindowId = GetWindowLongPtrW(hWnd, GWLP_ID);
 453
 454         switch (WindowId)
 455         {
 456         case IDC_CPU_USAGE_GRAPH:
 457             Graph_DrawCpuUsageGraph(hdc, hWnd);
 458             break;
 459         case IDC_MEM_USAGE_GRAPH:
 460             Graph_DrawMemUsageGraph(hdc, hWnd);
 461             break;
 462         case IDC_MEM_USAGE_HISTORY_GRAPH:
 463             Graph_DrawMemUsageHistoryGraph(hdc, hWnd);
 464             break;
 465         }
 466
 467         EndPaint(hWnd, &ps);
 468
 469         return 0;
 470
 471     }
 472
 473     /*
 474      * We pass on all non-handled messages
 475      */
 476     return CallWindowProcW(OldGraphWndProc, hWnd, message, wParam, lParam);
 477 }