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