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