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