rosapps/taskmgr/taskmgr.c

   1 // TaskMgr.cpp : Defines the entry point for the application.
   2 //
   3
   4 #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
   5 #include <windows.h>
   6 #include <commctrl.h>
   7 #include <stdlib.h>
   8 #include <malloc.h>
   9 #include <memory.h>
  10 #include <tchar.h>
  11 #include <process.h>
  12 #include <stdio.h>
  13
  14 #include "resource.h"
  15 #include "taskmgr.h"
  16 #include "applpage.h"
  17 #include "procpage.h"
  18 #include "perfpage.h"
  19 #include "run.h"
  20 #include "perfdata.h"
  21 #include "optnmenu.h"
  22 #include "affinity.h"
  23 #include "priority.h"
  24 #include "debug.h"
  25 #include "endproc.h"
  26 #include "column.h"
  27 #include "about.h"
  28 #include "trayicon.h"
  29
  30 #define STATUS_WINDOW   2001
  31
  32 // Global Variables:
  33 HINSTANCE hInst;                 // current instance
  34
  35 HWND hMainWnd;                   // Main Window
  36 HWND hStatusWnd;                 // Status Bar Window
  37 HWND hTabWnd;                    // Tab Control Window
  38
  39 int  nMinimumWidth;              // Minimum width of the dialog (OnSize()'s cx)
  40 int  nMinimumHeight;             // Minimum height of the dialog (OnSize()'s cy)
  41
  42 int  nOldWidth;                  // Holds the previous client area width
  43 int  nOldHeight;                 // Holds the previous client area height
  44
  45 BOOL bInMenuLoop = FALSE;        // Tells us if we are in the menu loop
  46
  47 TASKMANAGER_SETTINGS TaskManagerSettings;
  48
  49
  50 int APIENTRY WinMain(HINSTANCE hInstance,
  51                      HINSTANCE hPrevInstance,
  52                      LPSTR     lpCmdLine,
  53                      int       nCmdShow)
  54 {
  55     HANDLE hProcess;
  56     HANDLE hToken;
  57     TOKEN_PRIVILEGES tkp;
  58
  59     // Initialize global variables
  60     hInst = hInstance;
  61
  62     // Change our priority class to HIGH
  63     hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
  64     SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS);
  65     CloseHandle(hProcess);
  66
  67     // Now lets get the SE_DEBUG_NAME priviledge
  68     // so that we can debug processes
  69
  70     // Get a token for this process.
  71     if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
  72         // Get the LUID for the debug privilege.
  73         LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tkp.Privileges[0].Luid);
  74
  75         tkp.PrivilegeCount = 1;  // one privilege to set
  76         tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  77
  78         // Get the debug privilege for this process.
  79         AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
  80     }
  81
  82     // Load our settings from the registry
  83     LoadSettings();
  84
  85     // Initialize perf data
  86     if (!PerfDataInitialize()) {
  87         return -1;
  88     }
  89
  90     DialogBox(hInst, (LPCTSTR)IDD_TASKMGR_DIALOG, NULL, (DLGPROC)TaskManagerWndProc);
  91
  92     // Save our settings to the registry
  93     SaveSettings();
  94     PerfDataUninitialize();
  95     return 0;
  96 }
  97
  98 #define _USE_CMD_MAP
  99
 100 #ifdef _USE_CMD_MAP
 101 //#define BEGIN_CMD_MAP(a) switch( ##a ) {
 102 #define BEGIN_CMD_MAP(a) switch( a ) {
 103 #define CMD_MAP_ENTRY(a, b) case a: b(); break;
 104 #define END_CMD_MAP(a) }
 105
 106 #endif
 107
 108 // Message handler for dialog box.
 109 LRESULT CALLBACK TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 110 {
 111     HDC             hdc;
 112     PAINTSTRUCT     ps;
 113     LPRECT          pRC;
 114     RECT            rc;
 115     int             idctrl;
 116     LPNMHDR         pnmh;
 117     WINDOWPLACEMENT wp;
 118
 119     switch (message) {
 120     case WM_INITDIALOG:
 121         hMainWnd = hDlg;
 122         return OnCreate(hDlg);
 123
 124     case WM_COMMAND:
 125         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
 126             EndDialog(hDlg, LOWORD(wParam));
 127             return TRUE;
 128         }
 129 #ifdef _USE_CMD_MAP
 130         BEGIN_CMD_MAP( LOWORD(wParam) )
 131             CMD_MAP_ENTRY(ID_FILE_NEW,                             TaskManager_OnFileNew)
 132             CMD_MAP_ENTRY(ID_OPTIONS_ALWAYSONTOP,                  TaskManager_OnOptionsAlwaysOnTop)
 133             CMD_MAP_ENTRY(ID_OPTIONS_MINIMIZEONUSE,                TaskManager_OnOptionsMinimizeOnUse)
 134             CMD_MAP_ENTRY(ID_OPTIONS_HIDEWHENMINIMIZED,            TaskManager_OnOptionsHideWhenMinimized)
 135             CMD_MAP_ENTRY(ID_OPTIONS_SHOW16BITTASKS,               TaskManager_OnOptionsShow16BitTasks)
 136             CMD_MAP_ENTRY(ID_VIEW_LARGE,                           ApplicationPage_OnViewLargeIcons)
 137             CMD_MAP_ENTRY(ID_VIEW_SMALL,                           ApplicationPage_OnViewSmallIcons)
 138             CMD_MAP_ENTRY(ID_VIEW_DETAILS,                         ApplicationPage_OnViewDetails)
 139             CMD_MAP_ENTRY(ID_VIEW_SHOWKERNELTIMES,                 PerformancePage_OnViewShowKernelTimes)
 140             CMD_MAP_ENTRY(ID_VIEW_CPUHISTORY_ONEGRAPHALL,          PerformancePage_OnViewCPUHistoryOneGraphAll)
 141             CMD_MAP_ENTRY(ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU,       PerformancePage_OnViewCPUHistoryOneGraphPerCPU)
 142             CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_HIGH,                TaskManager_OnViewUpdateSpeedHigh)
 143             CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_NORMAL,              TaskManager_OnViewUpdateSpeedNormal)
 144             CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_LOW,                 TaskManager_OnViewUpdateSpeedLow)
 145             CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_PAUSED,              TaskManager_OnViewUpdateSpeedPaused)
 146             CMD_MAP_ENTRY(ID_VIEW_SELECTCOLUMNS,                   ProcessPage_OnViewSelectColumns)
 147             CMD_MAP_ENTRY(ID_VIEW_REFRESH,                         TaskManager_OnViewRefresh)
 148             CMD_MAP_ENTRY(ID_WINDOWS_TILEHORIZONTALLY,             ApplicationPage_OnWindowsTileHorizontally)
 149             CMD_MAP_ENTRY(ID_WINDOWS_TILEVERTICALLY,               ApplicationPage_OnWindowsTileVertically)
 150             CMD_MAP_ENTRY(ID_WINDOWS_MINIMIZE,                     ApplicationPage_OnWindowsMinimize)
 151             CMD_MAP_ENTRY(ID_WINDOWS_MAXIMIZE,                     ApplicationPage_OnWindowsMaximize)
 152             CMD_MAP_ENTRY(ID_WINDOWS_CASCADE,                      ApplicationPage_OnWindowsCascade)
 153             CMD_MAP_ENTRY(ID_WINDOWS_BRINGTOFRONT,                 ApplicationPage_OnWindowsBringToFront)
 154             CMD_MAP_ENTRY(ID_APPLICATION_PAGE_SWITCHTO,            ApplicationPage_OnSwitchTo)
 155             CMD_MAP_ENTRY(ID_APPLICATION_PAGE_ENDTASK,             ApplicationPage_OnEndTask)
 156             CMD_MAP_ENTRY(ID_APPLICATION_PAGE_GOTOPROCESS,         ApplicationPage_OnGotoProcess)
 157             CMD_MAP_ENTRY(ID_PROCESS_PAGE_ENDPROCESS,              ProcessPage_OnEndProcess)
 158             CMD_MAP_ENTRY(ID_PROCESS_PAGE_ENDPROCESSTREE,          ProcessPage_OnEndProcessTree)
 159             CMD_MAP_ENTRY(ID_PROCESS_PAGE_DEBUG,                   ProcessPage_OnDebug)
 160             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETAFFINITY,             ProcessPage_OnSetAffinity)
 161             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_REALTIME,    ProcessPage_OnSetPriorityRealTime)
 162             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_HIGH,        ProcessPage_OnSetPriorityHigh)
 163             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL, ProcessPage_OnSetPriorityAboveNormal)
 164             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_NORMAL,      ProcessPage_OnSetPriorityNormal)
 165             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL, ProcessPage_OnSetPriorityBelowNormal)
 166             CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_LOW,         ProcessPage_OnSetPriorityLow)
 167             CMD_MAP_ENTRY(ID_HELP_ABOUT,                           OnAbout)
 168         END_CMD_MAP(0)
 169 #else
 170         // Process menu commands
 171         switch (LOWORD(wParam))
 172         {
 173         case ID_FILE_NEW:
 174             TaskManager_OnFileNew();
 175             break;
 176         case ID_OPTIONS_ALWAYSONTOP:
 177             TaskManager_OnOptionsAlwaysOnTop();
 178             break;
 179         case ID_OPTIONS_MINIMIZEONUSE:
 180             TaskManager_OnOptionsMinimizeOnUse();
 181             break;
 182         case ID_OPTIONS_HIDEWHENMINIMIZED:
 183             TaskManager_OnOptionsHideWhenMinimized();
 184             break;
 185         case ID_OPTIONS_SHOW16BITTASKS:
 186             TaskManager_OnOptionsShow16BitTasks();
 187             break;
 188         case ID_VIEW_LARGE:
 189             ApplicationPage_OnViewLargeIcons();
 190             break;
 191         case ID_VIEW_SMALL:
 192             ApplicationPage_OnViewSmallIcons();
 193             break;
 194         case ID_VIEW_DETAILS:
 195             ApplicationPage_OnViewDetails();
 196             break;
 197         case ID_VIEW_SHOWKERNELTIMES:
 198             PerformancePage_OnViewShowKernelTimes();
 199             break;
 200         case ID_VIEW_CPUHISTORY_ONEGRAPHALL:
 201             PerformancePage_OnViewCPUHistoryOneGraphAll();
 202             break;
 203         case ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU:
 204             PerformancePage_OnViewCPUHistoryOneGraphPerCPU();
 205             break;
 206         case ID_VIEW_UPDATESPEED_HIGH:
 207             TaskManager_OnViewUpdateSpeedHigh();
 208             break;
 209         case ID_VIEW_UPDATESPEED_NORMAL:
 210             TaskManager_OnViewUpdateSpeedNormal();
 211             break;
 212         case ID_VIEW_UPDATESPEED_LOW:
 213             TaskManager_OnViewUpdateSpeedLow();
 214             break;
 215         case ID_VIEW_UPDATESPEED_PAUSED:
 216             TaskManager_OnViewUpdateSpeedPaused();
 217             break;
 218         case ID_VIEW_SELECTCOLUMNS:
 219             ProcessPage_OnViewSelectColumns();
 220             break;
 221         case ID_VIEW_REFRESH:
 222             PostMessage(hDlg, WM_TIMER, 0, 0);
 223             break;
 224         case ID_WINDOWS_TILEHORIZONTALLY:
 225             ApplicationPage_OnWindowsTileHorizontally();
 226             break;
 227         case ID_WINDOWS_TILEVERTICALLY:
 228             ApplicationPage_OnWindowsTileVertically();
 229             break;
 230         case ID_WINDOWS_MINIMIZE:
 231             ApplicationPage_OnWindowsMinimize();
 232             break;
 233         case ID_WINDOWS_MAXIMIZE:
 234             ApplicationPage_OnWindowsMaximize();
 235             break;
 236         case ID_WINDOWS_CASCADE:
 237             ApplicationPage_OnWindowsCascade();
 238             break;
 239         case ID_WINDOWS_BRINGTOFRONT:
 240             ApplicationPage_OnWindowsBringToFront();
 241             break;
 242         case ID_APPLICATION_PAGE_SWITCHTO:
 243             ApplicationPage_OnSwitchTo();
 244             break;
 245         case ID_APPLICATION_PAGE_ENDTASK:
 246             ApplicationPage_OnEndTask();
 247             break;
 248         case ID_APPLICATION_PAGE_GOTOPROCESS:
 249             ApplicationPage_OnGotoProcess();
 250             break;
 251         case ID_PROCESS_PAGE_ENDPROCESS:
 252             ProcessPage_OnEndProcess();
 253             break;
 254         case ID_PROCESS_PAGE_ENDPROCESSTREE:
 255             ProcessPage_OnEndProcessTree();
 256             break;
 257         case ID_PROCESS_PAGE_DEBUG:
 258             ProcessPage_OnDebug();
 259             break;
 260         case ID_PROCESS_PAGE_SETAFFINITY:
 261             ProcessPage_OnSetAffinity();
 262             break;
 263         case ID_PROCESS_PAGE_SETPRIORITY_REALTIME:
 264             ProcessPage_OnSetPriorityRealTime();
 265             break;
 266         case ID_PROCESS_PAGE_SETPRIORITY_HIGH:
 267             ProcessPage_OnSetPriorityHigh();
 268             break;
 269         case ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL:
 270             ProcessPage_OnSetPriorityAboveNormal();
 271             break;
 272         case ID_PROCESS_PAGE_SETPRIORITY_NORMAL:
 273             ProcessPage_OnSetPriorityNormal();
 274             break;
 275         case ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL:
 276             ProcessPage_OnSetPriorityBelowNormal();
 277             break;
 278         case ID_PROCESS_PAGE_SETPRIORITY_LOW:
 279             ProcessPage_OnSetPriorityLow();
 280             break;
 281         case ID_HELP_ABOUT:
 282             OnAbout();
 283             break;
 284         }
 285 #endif
 286         break;
 287
 288     case WM_NOTIFY:
 289         idctrl = (int)wParam;
 290         pnmh = (LPNMHDR)lParam;
 291         if ((pnmh->hwndFrom == hTabWnd) &&
 292             (pnmh->idFrom == IDC_TAB) &&
 293             (pnmh->code == TCN_SELCHANGE))
 294         {
 295             TaskManager_OnTabWndSelChange();
 296         }
 297         break;
 298
 299     case WM_NCPAINT:
 300         hdc = GetDC(hDlg);
 301         GetClientRect(hDlg, &rc);
 302         Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
 303         ReleaseDC(hDlg, hdc);
 304         break;
 305
 306     case WM_PAINT:
 307         hdc = BeginPaint(hDlg, &ps);
 308         GetClientRect(hDlg, &rc);
 309         Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
 310         EndPaint(hDlg, &ps);
 311         break;
 312
 313     case WM_SIZING:
 314         // Make sure the user is sizing the dialog
 315         // in an acceptable range
 316         pRC = (LPRECT)lParam;
 317         if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT)) {
 318             // If the width is too small enlarge it to the minimum
 319             if (nMinimumWidth > (pRC->right - pRC->left))
 320                 pRC->left = pRC->right - nMinimumWidth;
 321         } else {
 322             // If the width is too small enlarge it to the minimum
 323             if (nMinimumWidth > (pRC->right - pRC->left))
 324                 pRC->right = pRC->left + nMinimumWidth;
 325         }
 326         if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT)) {
 327             // If the height is too small enlarge it to the minimum
 328             if (nMinimumHeight > (pRC->bottom - pRC->top))
 329                 pRC->top = pRC->bottom - nMinimumHeight;
 330         } else {
 331             // If the height is too small enlarge it to the minimum
 332             if (nMinimumHeight > (pRC->bottom - pRC->top))
 333                 pRC->bottom = pRC->top + nMinimumHeight;
 334         }
 335         return TRUE;
 336         break;
 337
 338     case WM_SIZE:
 339         // Handle the window sizing in it's own function
 340         OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
 341         break;
 342
 343     case WM_MOVE:
 344         // Handle the window moving in it's own function
 345         OnMove(wParam, LOWORD(lParam), HIWORD(lParam));
 346         break;
 347
 348     case WM_DESTROY:
 349         ShowWindow(hDlg, SW_HIDE);
 350         TrayIcon_ShellRemoveTrayIcon();
 351         wp.length = sizeof(WINDOWPLACEMENT);
 352         GetWindowPlacement(hDlg, &wp);
 353         TaskManagerSettings.Left = wp.rcNormalPosition.left;
 354         TaskManagerSettings.Top = wp.rcNormalPosition.top;
 355         TaskManagerSettings.Right = wp.rcNormalPosition.right;
 356         TaskManagerSettings.Bottom = wp.rcNormalPosition.bottom;
 357         if (IsZoomed(hDlg) || (wp.flags & WPF_RESTORETOMAXIMIZED))
 358             TaskManagerSettings.Maximized = TRUE;
 359         else
 360             TaskManagerSettings.Maximized = FALSE;
 361         return DefWindowProc(hDlg, message, wParam, lParam);
 362
 363     case WM_TIMER:
 364         // Refresh the performance data
 365         PerfDataRefresh();
 366         RefreshApplicationPage();
 367         RefreshProcessPage();
 368         RefreshPerformancePage();
 369         TrayIcon_ShellUpdateTrayIcon();
 370         break;
 371
 372     case WM_ENTERMENULOOP:
 373         TaskManager_OnEnterMenuLoop(hDlg);
 374         break;
 375     case WM_EXITMENULOOP:
 376         TaskManager_OnExitMenuLoop(hDlg);
 377         break;
 378     case WM_MENUSELECT:
 379         TaskManager_OnMenuSelect(hDlg, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
 380         break;
 381     }
 382
 383     return 0;
 384 }
 385
 386 void FillSolidRect(HDC hDC, LPCRECT lpRect, COLORREF clr)
 387 {
 388     SetBkColor(hDC, clr);
 389     ExtTextOut(hDC, 0, 0, ETO_OPAQUE, lpRect, NULL, 0, NULL);
 390 }
 391
 392 void FillSolidRect2(HDC hDC, int x, int y, int cx, int cy, COLORREF clr)
 393 {
 394     RECT rect;
 395
 396     SetBkColor(hDC, clr);
 397     rect.left = x;
 398     rect.top = y;
 399     rect.right = x + cx;
 400     rect.bottom = y + cy;
 401     ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
 402 }
 403
 404 void Draw3dRect(HDC hDC, int x, int y, int cx, int cy, COLORREF clrTopLeft, COLORREF clrBottomRight)
 405 {
 406     FillSolidRect2(hDC, x, y, cx - 1, 1, clrTopLeft);
 407     FillSolidRect2(hDC, x, y, 1, cy - 1, clrTopLeft);
 408     FillSolidRect2(hDC, x + cx, y, -1, cy, clrBottomRight);
 409     FillSolidRect2(hDC, x, y + cy, cx, -1, clrBottomRight);
 410 }
 411
 412 void Draw3dRect2(HDC hDC, LPRECT lpRect, COLORREF clrTopLeft, COLORREF clrBottomRight)
 413 {
 414     Draw3dRect(hDC, lpRect->left, lpRect->top, lpRect->right - lpRect->left,
 415         lpRect->bottom - lpRect->top, clrTopLeft, clrBottomRight);
 416 }
 417
 418 BOOL OnCreate(HWND hWnd)
 419 {
 420     HMENU   hMenu;
 421     HMENU   hEditMenu;
 422     HMENU   hViewMenu;
 423     HMENU   hUpdateSpeedMenu;
 424     HMENU   hCPUHistoryMenu;
 425     int     nActivePage;
 426     int     nParts[3];
 427     RECT    rc;
 428     TCHAR   szTemp[256];
 429     TCITEM  item;
 430
 431     SendMessage(hMainWnd, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(hInst, MAKEINTRESOURCE(IDI_TASKMANAGER)));
 432
 433     // Initialize the Windows Common Controls DLL
 434     InitCommonControls();
 435
 436     // Get the minimum window sizes
 437     GetWindowRect(hWnd, &rc);
 438     nMinimumWidth = (rc.right - rc.left);
 439     nMinimumHeight = (rc.bottom - rc.top);
 440
 441     // Create the status bar
 442     hStatusWnd = CreateStatusWindow(WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|SBT_NOBORDERS, _T(""), hWnd, STATUS_WINDOW);
 443     if(!hStatusWnd)
 444         return FALSE;
 445
 446     // Create the status bar panes
 447     nParts[0] = 100;
 448     nParts[1] = 210;
 449     nParts[2] = 400;
 450     SendMessage(hStatusWnd, SB_SETPARTS, 3, (long)nParts);
 451
 452     // Create tab pages
 453     hTabWnd = GetDlgItem(hWnd, IDC_TAB);
 454 #if 1
 455     hApplicationPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_APPLICATION_PAGE), hWnd, (DLGPROC)ApplicationPageWndProc);
 456     hProcessPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PROCESS_PAGE), hWnd, (DLGPROC)ProcessPageWndProc);
 457     hPerformancePage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PERFORMANCE_PAGE), hWnd, (DLGPROC)PerformancePageWndProc);
 458 #else
 459     hApplicationPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_APPLICATION_PAGE), hTabWnd, (DLGPROC)ApplicationPageWndProc);
 460     hProcessPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PROCESS_PAGE), hTabWnd, (DLGPROC)ProcessPageWndProc);
 461     hPerformancePage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PERFORMANCE_PAGE), hTabWnd, (DLGPROC)PerformancePageWndProc);
 462 #endif
 463     // Insert tabs
 464     _tcscpy(szTemp, _T("Applications"));
 465     memset(&item, 0, sizeof(TCITEM));
 466     item.mask = TCIF_TEXT;
 467     item.pszText = szTemp;
 468     TabCtrl_InsertItem(hTabWnd, 0, &item);
 469     _tcscpy(szTemp, _T("Processes"));
 470     memset(&item, 0, sizeof(TCITEM));
 471     item.mask = TCIF_TEXT;
 472     item.pszText = szTemp;
 473     TabCtrl_InsertItem(hTabWnd, 1, &item);
 474     _tcscpy(szTemp, _T("Performance"));
 475     memset(&item, 0, sizeof(TCITEM));
 476     item.mask = TCIF_TEXT;
 477     item.pszText = szTemp;
 478     TabCtrl_InsertItem(hTabWnd, 2, &item);
 479
 480     // Size everything correctly
 481     GetClientRect(hWnd, &rc);
 482     nOldWidth = rc.right;
 483     nOldHeight = rc.bottom;
 484     //nOldStartX = rc.left;
 485     //nOldStartY = rc.top;
 486
 487 #define PAGE_OFFSET_LEFT    17
 488 #define PAGE_OFFSET_TOP     72
 489 #define PAGE_OFFSET_WIDTH   (PAGE_OFFSET_LEFT*2)
 490 #define PAGE_OFFSET_HEIGHT  (PAGE_OFFSET_TOP+32)
 491
 492     if ((TaskManagerSettings.Left != 0) ||
 493         (TaskManagerSettings.Top != 0) ||
 494         (TaskManagerSettings.Right != 0) ||
 495         (TaskManagerSettings.Bottom != 0))
 496     {
 497         MoveWindow(hWnd, TaskManagerSettings.Left, TaskManagerSettings.Top, TaskManagerSettings.Right - TaskManagerSettings.Left, TaskManagerSettings.Bottom - TaskManagerSettings.Top, TRUE);
 498 #ifdef __GNUC__TEST__
 499         MoveWindow(hApplicationPage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 500         MoveWindow(hProcessPage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 501         MoveWindow(hPerformancePage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 502 #endif
 503     }
 504     if (TaskManagerSettings.Maximized)
 505         ShowWindow(hWnd, SW_MAXIMIZE);
 506
 507     // Set the always on top style
 508     hMenu = GetMenu(hWnd);
 509     hEditMenu = GetSubMenu(hMenu, 1);
 510     hViewMenu = GetSubMenu(hMenu, 2);
 511     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
 512     hCPUHistoryMenu = GetSubMenu(hViewMenu, 7);
 513
 514     // Check or uncheck the always on top menu item
 515     if (TaskManagerSettings.AlwaysOnTop) {
 516         CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_CHECKED);
 517         SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 518     } else {
 519         CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_UNCHECKED);
 520         SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 521     }
 522
 523     // Check or uncheck the minimize on use menu item
 524     if (TaskManagerSettings.MinimizeOnUse)
 525         CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_CHECKED);
 526     else
 527         CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_UNCHECKED);
 528
 529     // Check or uncheck the hide when minimized menu item
 530     if (TaskManagerSettings.HideWhenMinimized)
 531         CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_CHECKED);
 532     else
 533         CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_UNCHECKED);
 534
 535     // Check or uncheck the show 16-bit tasks menu item
 536     if (TaskManagerSettings.Show16BitTasks)
 537         CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
 538     else
 539         CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_UNCHECKED);
 540
 541     if (TaskManagerSettings.View_LargeIcons)
 542         CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
 543     else if (TaskManagerSettings.View_SmallIcons)
 544         CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
 545     else
 546         CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
 547
 548     if (TaskManagerSettings.ShowKernelTimes)
 549         CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
 550     else
 551         CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
 552
 553     if (TaskManagerSettings.UpdateSpeed == 1)
 554         CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_HIGH, MF_BYCOMMAND);
 555     else if (TaskManagerSettings.UpdateSpeed == 2)
 556         CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_NORMAL, MF_BYCOMMAND);
 557     else if (TaskManagerSettings.UpdateSpeed == 4)
 558         CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_LOW, MF_BYCOMMAND);
 559     else
 560         CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_PAUSED, MF_BYCOMMAND);
 561
 562     if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
 563         CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
 564     else
 565         CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
 566
 567     nActivePage = TaskManagerSettings.ActiveTabPage;
 568     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 0);
 569     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 1);
 570     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 2);
 571     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, nActivePage);
 572
 573     if (TaskManagerSettings.UpdateSpeed == 0)
 574         KillTimer(hWnd, 1);
 575     else if (TaskManagerSettings.UpdateSpeed == 1)
 576     {
 577         KillTimer(hWnd, 1);
 578         SetTimer(hWnd, 1, 1000, NULL);
 579     }
 580     else if (TaskManagerSettings.UpdateSpeed == 2)
 581     {
 582         KillTimer(hWnd, 1);
 583         SetTimer(hWnd, 1, 2000, NULL);
 584     }
 585     else if (TaskManagerSettings.UpdateSpeed == 4)
 586     {
 587         KillTimer(hWnd, 1);
 588         SetTimer(hWnd, 1, 4000, NULL);
 589     }
 590
 591     //
 592     // Refresh the performance data
 593     // Sample it twice so we can establish
 594     // the delta values & cpu usage
 595     //
 596     PerfDataRefresh();
 597     PerfDataRefresh();
 598
 599     RefreshApplicationPage();
 600     RefreshProcessPage();
 601     RefreshPerformancePage();
 602
 603     TrayIcon_ShellAddTrayIcon();
 604
 605     return TRUE;
 606 }
 607
 608 // OnMove()
 609 // This function handles all the moving events for the application
 610 // It moves every child window that needs moving
 611 void OnMove( UINT nType, int cx, int cy )
 612 {
 613 #ifdef __GNUC__TEST__
 614     MoveWindow(hApplicationPage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 615     MoveWindow(hProcessPage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 616     MoveWindow(hPerformancePage, TaskManagerSettings.Left + PAGE_OFFSET_LEFT, TaskManagerSettings.Top + PAGE_OFFSET_TOP, TaskManagerSettings.Right - TaskManagerSettings.Left - PAGE_OFFSET_WIDTH, TaskManagerSettings.Bottom - TaskManagerSettings.Top - PAGE_OFFSET_HEIGHT, FALSE);
 617 #endif
 618 }
 619
 620 // OnSize()
 621 // This function handles all the sizing events for the application
 622 // It re-sizes every window, and child window that needs re-sizing
 623 void OnSize( UINT nType, int cx, int cy )
 624 {
 625     int     nParts[3];
 626     int     nXDifference;
 627     int     nYDifference;
 628     RECT    rc;
 629
 630     if (nType == SIZE_MINIMIZED)
 631         return;
 632
 633     nXDifference = cx - nOldWidth;
 634     nYDifference = cy - nOldHeight;
 635     nOldWidth = cx;
 636     nOldHeight = cy;
 637
 638     // Update the status bar size
 639     GetWindowRect(hStatusWnd, &rc);
 640     SendMessage(hStatusWnd, WM_SIZE, nType, MAKELPARAM(cx, cy + (rc.bottom - rc.top)));
 641
 642     // Update the status bar pane sizes
 643     nParts[0] = bInMenuLoop ? -1 : 100;
 644     nParts[1] = 210;
 645     nParts[2] = cx;
 646     SendMessage(hStatusWnd, SB_SETPARTS, bInMenuLoop ? 1 : 3, (long)nParts);
 647
 648     // Resize the tab control
 649     GetWindowRect(hTabWnd, &rc);
 650     cx = (rc.right - rc.left) + nXDifference;
 651     cy = (rc.bottom - rc.top) + nYDifference;
 652     SetWindowPos(hTabWnd, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
 653
 654     // Resize the application page
 655     GetWindowRect(hApplicationPage, &rc);
 656     cx = (rc.right - rc.left) + nXDifference;
 657     cy = (rc.bottom - rc.top) + nYDifference;
 658     SetWindowPos(hApplicationPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
 659
 660     // Resize the process page
 661     GetWindowRect(hProcessPage, &rc);
 662     cx = (rc.right - rc.left) + nXDifference;
 663     cy = (rc.bottom - rc.top) + nYDifference;
 664     SetWindowPos(hProcessPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
 665
 666     // Resize the performance page
 667     GetWindowRect(hPerformancePage, &rc);
 668     cx = (rc.right - rc.left) + nXDifference;
 669     cy = (rc.bottom - rc.top) + nYDifference;
 670     SetWindowPos(hPerformancePage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
 671
 672 }
 673
 674 void LoadSettings(void)
 675 {
 676     HKEY    hKey;
 677     TCHAR   szSubKey[] = _T("Software\\ReactWare\\TaskManager");
 678     int     i;
 679     DWORD   dwSize;
 680
 681     // Window size & position settings
 682     TaskManagerSettings.Maximized = FALSE;
 683     TaskManagerSettings.Left = 0;
 684     TaskManagerSettings.Top = 0;
 685     TaskManagerSettings.Right = 0;
 686     TaskManagerSettings.Bottom = 0;
 687
 688     // Tab settings
 689     TaskManagerSettings.ActiveTabPage = 0;
 690
 691     // Options menu settings
 692     TaskManagerSettings.AlwaysOnTop = FALSE;
 693     TaskManagerSettings.MinimizeOnUse = TRUE;
 694     TaskManagerSettings.HideWhenMinimized = TRUE;
 695     TaskManagerSettings.Show16BitTasks = TRUE;
 696
 697     // Update speed settings
 698     TaskManagerSettings.UpdateSpeed = 2;
 699
 700     // Applications page settings
 701     TaskManagerSettings.View_LargeIcons = FALSE;
 702     TaskManagerSettings.View_SmallIcons = FALSE;
 703     TaskManagerSettings.View_Details = TRUE;
 704
 705     // Processes page settings
 706     TaskManagerSettings.ShowProcessesFromAllUsers = FALSE; // Server-only?
 707     TaskManagerSettings.Column_ImageName = TRUE;
 708     TaskManagerSettings.Column_PID = TRUE;
 709     TaskManagerSettings.Column_CPUUsage = TRUE;
 710     TaskManagerSettings.Column_CPUTime = TRUE;
 711     TaskManagerSettings.Column_MemoryUsage = TRUE;
 712     TaskManagerSettings.Column_MemoryUsageDelta = FALSE;
 713     TaskManagerSettings.Column_PeakMemoryUsage = FALSE;
 714     TaskManagerSettings.Column_PageFaults = FALSE;
 715     TaskManagerSettings.Column_USERObjects = FALSE;
 716     TaskManagerSettings.Column_IOReads = FALSE;
 717     TaskManagerSettings.Column_IOReadBytes = FALSE;
 718     TaskManagerSettings.Column_SessionID = FALSE; // Server-only?
 719     TaskManagerSettings.Column_UserName = FALSE; // Server-only?
 720     TaskManagerSettings.Column_PageFaultsDelta = FALSE;
 721     TaskManagerSettings.Column_VirtualMemorySize = FALSE;
 722     TaskManagerSettings.Column_PagedPool = FALSE;
 723     TaskManagerSettings.Column_NonPagedPool = FALSE;
 724     TaskManagerSettings.Column_BasePriority = FALSE;
 725     TaskManagerSettings.Column_HandleCount = FALSE;
 726     TaskManagerSettings.Column_ThreadCount = FALSE;
 727     TaskManagerSettings.Column_GDIObjects = FALSE;
 728     TaskManagerSettings.Column_IOWrites = FALSE;
 729     TaskManagerSettings.Column_IOWriteBytes = FALSE;
 730     TaskManagerSettings.Column_IOOther = FALSE;
 731     TaskManagerSettings.Column_IOOtherBytes = FALSE;
 732
 733     for (i = 0; i < 25; i++) {
 734         TaskManagerSettings.ColumnOrderArray[i] = i;
 735     }
 736     TaskManagerSettings.ColumnSizeArray[0] = 105;
 737     TaskManagerSettings.ColumnSizeArray[1] = 50;
 738     TaskManagerSettings.ColumnSizeArray[2] = 107;
 739     TaskManagerSettings.ColumnSizeArray[3] = 70;
 740     TaskManagerSettings.ColumnSizeArray[4] = 35;
 741     TaskManagerSettings.ColumnSizeArray[5] = 70;
 742     TaskManagerSettings.ColumnSizeArray[6] = 70;
 743     TaskManagerSettings.ColumnSizeArray[7] = 100;
 744     TaskManagerSettings.ColumnSizeArray[8] = 70;
 745     TaskManagerSettings.ColumnSizeArray[9] = 70;
 746     TaskManagerSettings.ColumnSizeArray[10] = 70;
 747     TaskManagerSettings.ColumnSizeArray[11] = 70;
 748     TaskManagerSettings.ColumnSizeArray[12] = 70;
 749     TaskManagerSettings.ColumnSizeArray[13] = 70;
 750     TaskManagerSettings.ColumnSizeArray[14] = 60;
 751     TaskManagerSettings.ColumnSizeArray[15] = 60;
 752     TaskManagerSettings.ColumnSizeArray[16] = 60;
 753     TaskManagerSettings.ColumnSizeArray[17] = 60;
 754     TaskManagerSettings.ColumnSizeArray[18] = 60;
 755     TaskManagerSettings.ColumnSizeArray[19] = 70;
 756     TaskManagerSettings.ColumnSizeArray[20] = 70;
 757     TaskManagerSettings.ColumnSizeArray[21] = 70;
 758     TaskManagerSettings.ColumnSizeArray[22] = 70;
 759     TaskManagerSettings.ColumnSizeArray[23] = 70;
 760     TaskManagerSettings.ColumnSizeArray[24] = 70;
 761
 762     TaskManagerSettings.SortColumn = 1;
 763     TaskManagerSettings.SortAscending = TRUE;
 764
 765     // Performance page settings
 766     TaskManagerSettings.CPUHistory_OneGraphPerCPU = TRUE;
 767     TaskManagerSettings.ShowKernelTimes = FALSE;
 768
 769     // Open the key
 770     if (RegOpenKeyEx(HKEY_CURRENT_USER, szSubKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
 771         return;
 772     // Read the settings
 773     dwSize = sizeof(TASKMANAGER_SETTINGS);
 774     RegQueryValueEx(hKey, _T("Preferences"), NULL, NULL, (LPBYTE)&TaskManagerSettings, &dwSize);
 775
 776     // Close the key
 777     RegCloseKey(hKey);
 778 }
 779
 780 void SaveSettings(void)
 781 {
 782     HKEY hKey;
 783     TCHAR szSubKey1[] = _T("Software");
 784     TCHAR szSubKey2[] = _T("Software\\ReactWare");
 785     TCHAR szSubKey3[] = _T("Software\\ReactWare\\TaskManager");
 786
 787     // Open (or create) the key
 788     hKey = NULL;
 789     RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey1, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
 790     RegCloseKey(hKey);
 791     hKey = NULL;
 792     RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey2, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
 793     RegCloseKey(hKey);
 794     hKey = NULL;
 795     if (RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey3, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
 796         return;
 797     // Save the settings
 798     RegSetValueEx(hKey, _T("Preferences"), 0, REG_BINARY, (LPBYTE)&TaskManagerSettings, sizeof(TASKMANAGER_SETTINGS));
 799     // Close the key
 800     RegCloseKey(hKey);
 801 }
 802
 803 void TaskManager_OnEnterMenuLoop(HWND hWnd)
 804 {
 805     int nParts;
 806
 807     // Update the status bar pane sizes
 808     nParts = -1;
 809     SendMessage(hStatusWnd, SB_SETPARTS, 1, (long)&nParts);
 810     bInMenuLoop = TRUE;
 811     SendMessage(hStatusWnd, SB_SETTEXT, (WPARAM)0, (LPARAM)_T(""));
 812 }
 813
 814 void TaskManager_OnExitMenuLoop(HWND hWnd)
 815 {
 816     RECT  rc;
 817     int   nParts[3];
 818     TCHAR text[260];
 819
 820     bInMenuLoop = FALSE;
 821     // Update the status bar pane sizes
 822     GetClientRect(hWnd, &rc);
 823     nParts[0] = 100;
 824     nParts[1] = 210;
 825     nParts[2] = rc.right;
 826     SendMessage(hStatusWnd, SB_SETPARTS, 3, (long)nParts);
 827     SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)_T(""));
 828     wsprintf(text, _T("CPU Usage: %3d%%"), PerfDataGetProcessorUsage());
 829     SendMessage(hStatusWnd, SB_SETTEXT, 1, (LPARAM)text);
 830     wsprintf(text, _T("Processes: %d"), PerfDataGetProcessCount());
 831     SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)text);
 832 }
 833
 834 void TaskManager_OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
 835 {
 836     TCHAR str[100];
 837
 838     _tcscpy(str, TEXT(""));
 839     if (LoadString(hInst, nItemID, str, 100)) {
 840         // load appropriate string
 841         LPTSTR lpsz = str;
 842         // first newline terminates actual string
 843         lpsz = _tcschr(lpsz, '\n');
 844         if (lpsz != NULL)
 845             *lpsz = '\0';
 846     }
 847     SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)str);
 848 }
 849
 850 void TaskManager_OnViewUpdateSpeedHigh(void)
 851 {
 852     HMENU hMenu;
 853     HMENU hViewMenu;
 854     HMENU hUpdateSpeedMenu;
 855
 856     hMenu = GetMenu(hMainWnd);
 857     hViewMenu = GetSubMenu(hMenu, 2);
 858     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
 859
 860     TaskManagerSettings.UpdateSpeed = 1;
 861     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_HIGH, MF_BYCOMMAND);
 862
 863     KillTimer(hMainWnd, 1);
 864     SetTimer(hMainWnd, 1, 1000, NULL);
 865 }
 866
 867 void TaskManager_OnViewUpdateSpeedNormal(void)
 868 {
 869     HMENU hMenu;
 870     HMENU hViewMenu;
 871     HMENU hUpdateSpeedMenu;
 872
 873     hMenu = GetMenu(hMainWnd);
 874     hViewMenu = GetSubMenu(hMenu, 2);
 875     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
 876
 877     TaskManagerSettings.UpdateSpeed = 2;
 878     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_NORMAL, MF_BYCOMMAND);
 879
 880     KillTimer(hMainWnd, 1);
 881     SetTimer(hMainWnd, 1, 2000, NULL);
 882 }
 883
 884 void TaskManager_OnViewUpdateSpeedLow(void)
 885 {
 886     HMENU hMenu;
 887     HMENU hViewMenu;
 888     HMENU hUpdateSpeedMenu;
 889
 890     hMenu = GetMenu(hMainWnd);
 891     hViewMenu = GetSubMenu(hMenu, 2);
 892     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
 893
 894     TaskManagerSettings.UpdateSpeed = 4;
 895     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_LOW, MF_BYCOMMAND);
 896
 897     KillTimer(hMainWnd, 1);
 898     SetTimer(hMainWnd, 1, 4000, NULL);
 899 }
 900
 901 void TaskManager_OnViewRefresh(void)
 902 {
 903     PostMessage(hMainWnd, WM_TIMER, 0, 0);
 904 }
 905
 906 void TaskManager_OnViewUpdateSpeedPaused(void)
 907 {
 908     HMENU hMenu;
 909     HMENU hViewMenu;
 910     HMENU hUpdateSpeedMenu;
 911
 912     hMenu = GetMenu(hMainWnd);
 913     hViewMenu = GetSubMenu(hMenu, 2);
 914     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
 915     TaskManagerSettings.UpdateSpeed = 0;
 916     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_PAUSED, MF_BYCOMMAND);
 917     KillTimer(hMainWnd, 1);
 918 }
 919
 920 void TaskManager_OnTabWndSelChange(void)
 921 {
 922     int   i;
 923     HMENU hMenu;
 924     HMENU hOptionsMenu;
 925     HMENU hViewMenu;
 926     HMENU hSubMenu;
 927
 928     hMenu = GetMenu(hMainWnd);
 929     hViewMenu = GetSubMenu(hMenu, 2);
 930     hOptionsMenu = GetSubMenu(hMenu, 1);
 931     TaskManagerSettings.ActiveTabPage = TabCtrl_GetCurSel(hTabWnd);
 932     for (i = GetMenuItemCount(hViewMenu) - 1; i > 2; i--) {
 933         hSubMenu = GetSubMenu(hViewMenu, i);
 934         if (hSubMenu)
 935             DestroyMenu(hSubMenu);
 936         RemoveMenu(hViewMenu, i, MF_BYPOSITION);
 937     }
 938     RemoveMenu(hOptionsMenu, 3, MF_BYPOSITION);
 939     switch (TaskManagerSettings.ActiveTabPage) {
 940     case 0:
 941         ShowWindow(hApplicationPage, SW_SHOW);
 942         ShowWindow(hProcessPage, SW_HIDE);
 943         ShowWindow(hPerformancePage, SW_HIDE);
 944         BringWindowToTop(hApplicationPage);
 945         AppendMenu(hViewMenu, MF_STRING, ID_VIEW_LARGE, _T("Lar&ge Icons"));
 946         AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SMALL, _T("S&mall Icons"));
 947         AppendMenu(hViewMenu, MF_STRING, ID_VIEW_DETAILS, _T("&Details"));
 948
 949         if (GetMenuItemCount(hMenu) <= 4) {
 950             hSubMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_WINDOWSMENU));
 951             InsertMenu(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT)hSubMenu, _T("&Windows"));
 952             DrawMenuBar(hMainWnd);
 953         }
 954         if (TaskManagerSettings.View_LargeIcons)
 955             CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
 956         else if (TaskManagerSettings.View_SmallIcons)
 957             CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
 958         else
 959             CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
 960         //
 961         // Give the application list control focus
 962         //
 963         SetFocus(hApplicationPageListCtrl);
 964         break;
 965
 966     case 1:
 967         ShowWindow(hApplicationPage, SW_HIDE);
 968         ShowWindow(hProcessPage, SW_SHOW);
 969         ShowWindow(hPerformancePage, SW_HIDE);
 970         BringWindowToTop(hProcessPage);
 971         AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SELECTCOLUMNS, _T("&Select Columns..."));
 972         AppendMenu(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, _T("&Show 16-bit tasks"));
 973         if (TaskManagerSettings.Show16BitTasks)
 974             CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
 975         if (GetMenuItemCount(hMenu) > 4)
 976         {
 977             RemoveMenu(hMenu, 3, MF_BYPOSITION);
 978             DrawMenuBar(hMainWnd);
 979         }
 980         //
 981         // Give the process list control focus
 982         //
 983         SetFocus(hProcessPageListCtrl);
 984         break;
 985
 986     case 2:
 987         ShowWindow(hApplicationPage, SW_HIDE);
 988         ShowWindow(hProcessPage, SW_HIDE);
 989         ShowWindow(hPerformancePage, SW_SHOW);
 990         BringWindowToTop(hPerformancePage);
 991         if (GetMenuItemCount(hMenu) > 4) {
 992             RemoveMenu(hMenu, 3, MF_BYPOSITION);
 993             DrawMenuBar(hMainWnd);
 994         }
 995         hSubMenu = CreatePopupMenu();
 996         AppendMenu(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHALL, _T("&One Graph, All CPUs"));
 997         AppendMenu(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, _T("One Graph &Per CPU"));
 998         AppendMenu(hViewMenu, MF_STRING|MF_POPUP, (UINT)hSubMenu, _T("&CPU History"));
 999         AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, _T("&Show Kernel Times"));
1000         if (TaskManagerSettings.ShowKernelTimes)
1001             CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
1002         else
1003             CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
1004         if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
1005             CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
1006         else
1007             CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
1008         //
1009         // Give the tab control focus
1010         //
1011         SetFocus(hTabWnd);
1012         break;
1013     }
1014 }
1015
1016 LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize)
1017 {
1018     DWORD  dwRet;
1019     LPTSTR lpszTemp = NULL;
1020
1021     dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
1022                            NULL,
1023                            GetLastError(),
1024                            LANG_NEUTRAL,
1025                            (LPTSTR)&lpszTemp,
1026                            0,
1027                            NULL );
1028
1029     // supplied buffer is not long enough
1030     if (!dwRet || ( (long)dwSize < (long)dwRet+14)) {
1031         lpszBuf[0] = TEXT('\0');
1032     } else {
1033         lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0');  //remove cr and newline character
1034         _stprintf(lpszBuf, TEXT("%s (0x%x)"), lpszTemp, (int)GetLastError());
1035     }
1036     if (lpszTemp) {
1037         LocalFree((HLOCAL)lpszTemp);
1038     }
1039     return lpszBuf;
1040 }