reactos/base/applications/taskmgr/taskmgr.c

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