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