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