ReactOS Development > Doxygen

00001 /*
00002  *  ReactOS Task Manager
00003  *
00004  * taskmgr.c : Defines the entry point for the application.
00005  *
00006  *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
00007  *                2005         Klemens Friedl <frik85@reactos.at>
00008  *
00009  * This library is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free Software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  *
00014  * This library is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with this library; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00022  */
00023 
00024 #include <precomp.h>
00025 
00026 #define STATUS_WINDOW   2001
00027 
00028 /* Global Variables: */
00029 HINSTANCE hInst;                 /* current instance */
00030 
00031 HWND hMainWnd;                   /* Main Window */
00032 HWND hStatusWnd;                 /* Status Bar Window */
00033 HWND hTabWnd;                    /* Tab Control Window */
00034 
00035 int  nMinimumWidth;              /* Minimum width of the dialog (OnSize()'s cx) */
00036 int  nMinimumHeight;             /* Minimum height of the dialog (OnSize()'s cy) */
00037 
00038 int  nOldWidth;                  /* Holds the previous client area width */
00039 int  nOldHeight;                 /* Holds the previous client area height */
00040 
00041 BOOL bInMenuLoop = FALSE;        /* Tells us if we are in the menu loop */
00042 
00043 TASKMANAGER_SETTINGS TaskManagerSettings;
00044 
00045 
00046 int APIENTRY wWinMain(HINSTANCE hInstance,
00047                       HINSTANCE hPrevInstance,
00048                       LPWSTR    lpCmdLine,
00049                       int       nCmdShow)
00050 {
00051     HANDLE hProcess;
00052     HANDLE hToken;
00053     TOKEN_PRIVILEGES tkp;
00054     HANDLE hMutex;
00055 
00056     /* check wether we're already running or not */
00057     hMutex = CreateMutexW(NULL, TRUE, L"taskmgrros");
00058     if (hMutex && GetLastError() == ERROR_ALREADY_EXISTS)
00059     {
00060         /* Restore existing taskmanager and bring window to front */
00061         /* Relies on the fact that the application title string and window title are the same */
00062         HWND hTaskMgr;
00063         TCHAR szTaskmgr[128];
00064 
00065         LoadString(hInst, IDS_APP_TITLE, szTaskmgr, sizeof(szTaskmgr)/sizeof(TCHAR));
00066         hTaskMgr = FindWindow(NULL, szTaskmgr);
00067 
00068         if (hTaskMgr != NULL)
00069         {
00070             SendMessage(hTaskMgr, WM_SYSCOMMAND, SC_RESTORE, 0);
00071             SetForegroundWindow(hTaskMgr);
00072         }
00073         return 0;
00074     }
00075     else if (!hMutex)
00076     {
00077         return 1;
00078     }
00079 
00080     /* Initialize global variables */
00081     hInst = hInstance;
00082 
00083     /* Change our priority class to HIGH */
00084     hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
00085     SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS);
00086     CloseHandle(hProcess);
00087 
00088     /* Now lets get the SE_DEBUG_NAME privilege
00089      * so that we can debug processes
00090      */
00091 
00092     /* Get a token for this process.  */
00093     if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
00094         /* Get the LUID for the debug privilege.  */
00095         LookupPrivilegeValueW(NULL, SE_DEBUG_NAME, &tkp.Privileges[0].Luid);
00096 
00097         tkp.PrivilegeCount = 1;  /* one privilege to set */
00098         tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
00099 
00100         /* Get the debug privilege for this process. */
00101         AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
00102         CloseHandle(hToken);
00103     }
00104 
00105     /* Load our settings from the registry */
00106     LoadSettings();
00107 
00108     /* Initialize perf data */
00109     if (!PerfDataInitialize()) {
00110         return -1;
00111     }
00112 
00113     DialogBoxW(hInst, (LPCWSTR)IDD_TASKMGR_DIALOG, NULL, TaskManagerWndProc);
00114 
00115     /* Save our settings to the registry */
00116     SaveSettings();
00117     PerfDataUninitialize();
00118     return 0;
00119 }
00120 
00121 /* Message handler for dialog box. */
00122 INT_PTR CALLBACK
00123 TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
00124 {
00125 #if 0
00126     HDC              hdc;
00127     PAINTSTRUCT      ps;
00128     RECT             rc;
00129 #endif
00130     LPRECT           pRC;
00131     LPNMHDR          pnmh;
00132     WINDOWPLACEMENT  wp;
00133 
00134     switch (message) {
00135     case WM_INITDIALOG:
00136         hMainWnd = hDlg;
00137         return OnCreate(hDlg);
00138 
00139     case WM_COMMAND:
00140         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
00141             EndDialog(hDlg, LOWORD(wParam));
00142             return TRUE;
00143         }
00144         /* Process menu commands */
00145         switch (LOWORD(wParam))
00146         {
00147         case ID_FILE_NEW:
00148             TaskManager_OnFileNew();
00149             break;
00150         case ID_OPTIONS_ALWAYSONTOP:
00151             TaskManager_OnOptionsAlwaysOnTop();
00152             break;
00153         case ID_OPTIONS_MINIMIZEONUSE:
00154             TaskManager_OnOptionsMinimizeOnUse();
00155             break;
00156         case ID_OPTIONS_HIDEWHENMINIMIZED:
00157             TaskManager_OnOptionsHideWhenMinimized();
00158             break;
00159         case ID_OPTIONS_SHOW16BITTASKS:
00160             TaskManager_OnOptionsShow16BitTasks();
00161             break;
00162         case ID_RESTORE:
00163             TaskManager_OnRestoreMainWindow();
00164             break;
00165         case ID_VIEW_LARGE:
00166         case ID_VIEW_SMALL:
00167         case ID_VIEW_DETAILS:
00168             ApplicationPage_OnView(LOWORD(wParam));
00169             break;
00170         case ID_VIEW_SHOWKERNELTIMES:
00171             PerformancePage_OnViewShowKernelTimes();
00172             break;
00173         case ID_VIEW_CPUHISTORY_ONEGRAPHALL:
00174             PerformancePage_OnViewCPUHistoryOneGraphAll();
00175             break;
00176         case ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU:
00177             PerformancePage_OnViewCPUHistoryOneGraphPerCPU();
00178             break;
00179         case ID_VIEW_UPDATESPEED_HIGH:
00180         case ID_VIEW_UPDATESPEED_NORMAL:
00181         case ID_VIEW_UPDATESPEED_LOW:
00182         case ID_VIEW_UPDATESPEED_PAUSED:
00183             TaskManager_OnViewUpdateSpeed(LOWORD(wParam));
00184             break;
00185         case ID_VIEW_SELECTCOLUMNS:
00186             ProcessPage_OnViewSelectColumns();
00187             break;
00188         case ID_VIEW_REFRESH:
00189             PostMessageW(hDlg, WM_TIMER, 0, 0);
00190             break;
00191         case ID_WINDOWS_TILEHORIZONTALLY:
00192             ApplicationPage_OnWindowsTile(MDITILE_HORIZONTAL);
00193             break;
00194         case ID_WINDOWS_TILEVERTICALLY:
00195             ApplicationPage_OnWindowsTile(MDITILE_VERTICAL);
00196             break;
00197         case ID_WINDOWS_MINIMIZE:
00198             ApplicationPage_OnWindowsMinimize();
00199             break;
00200         case ID_WINDOWS_MAXIMIZE:
00201             ApplicationPage_OnWindowsMaximize();
00202             break;
00203         case ID_WINDOWS_CASCADE:
00204             ApplicationPage_OnWindowsCascade();
00205             break;
00206         case ID_WINDOWS_BRINGTOFRONT:
00207             ApplicationPage_OnWindowsBringToFront();
00208             break;
00209         case ID_APPLICATION_PAGE_SWITCHTO:
00210             ApplicationPage_OnSwitchTo();
00211             break;
00212         case ID_APPLICATION_PAGE_ENDTASK:
00213             ApplicationPage_OnEndTask();
00214             break;
00215         case ID_APPLICATION_PAGE_GOTOPROCESS:
00216             ApplicationPage_OnGotoProcess();
00217             break;
00218         case ID_PROCESS_PAGE_ENDPROCESS:
00219             ProcessPage_OnEndProcess();
00220             break;
00221         case ID_PROCESS_PAGE_ENDPROCESSTREE:
00222             ProcessPage_OnEndProcessTree();
00223             break;
00224         case ID_PROCESS_PAGE_DEBUG:
00225             ProcessPage_OnDebug();
00226             break;
00227         case ID_PROCESS_PAGE_SETAFFINITY:
00228             ProcessPage_OnSetAffinity();
00229             break;
00230         case ID_PROCESS_PAGE_SETPRIORITY_REALTIME:
00231             DoSetPriority(REALTIME_PRIORITY_CLASS);
00232             break;
00233         case ID_PROCESS_PAGE_SETPRIORITY_HIGH:
00234             DoSetPriority(HIGH_PRIORITY_CLASS);
00235             break;
00236         case ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL:
00237             DoSetPriority(ABOVE_NORMAL_PRIORITY_CLASS);
00238             break;
00239         case ID_PROCESS_PAGE_SETPRIORITY_NORMAL:
00240             DoSetPriority(NORMAL_PRIORITY_CLASS);
00241             break;
00242         case ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL:
00243             DoSetPriority(BELOW_NORMAL_PRIORITY_CLASS);
00244             break;
00245         case ID_PROCESS_PAGE_SETPRIORITY_LOW:
00246             DoSetPriority(IDLE_PRIORITY_CLASS);
00247             break;
00248         case ID_PROCESS_PAGE_DEBUGCHANNELS:
00249             ProcessPage_OnDebugChannels();
00250             break;
00251         case ID_HELP_ABOUT:
00252             OnAbout();
00253             break;
00254         case ID_FILE_EXIT:
00255             EndDialog(hDlg, IDOK);
00256             break;
00257         }
00258         break;
00259 
00260     case WM_ONTRAYICON:
00261         switch(lParam)
00262         {
00263         case WM_RBUTTONDOWN:
00264             {
00265             POINT pt;
00266             BOOL OnTop;
00267             HMENU hMenu, hPopupMenu;
00268 
00269             GetCursorPos(&pt);
00270 
00271             OnTop = ((GetWindowLongPtrW(hMainWnd, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0);
00272 
00273             hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_TRAY_POPUP));
00274             hPopupMenu = GetSubMenu(hMenu, 0);
00275 
00276             if(IsWindowVisible(hMainWnd))
00277             {
00278               DeleteMenu(hPopupMenu, ID_RESTORE, MF_BYCOMMAND);
00279             }
00280             else
00281             {
00282               SetMenuDefaultItem(hPopupMenu, ID_RESTORE, FALSE);
00283             }
00284 
00285             if(OnTop)
00286             {
00287               CheckMenuItem(hPopupMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND | MF_CHECKED);
00288             } else
00289             {
00290               CheckMenuItem(hPopupMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND | MF_UNCHECKED);
00291             }
00292 
00293             SetForegroundWindow(hMainWnd);
00294             TrackPopupMenuEx(hPopupMenu, 0, pt.x, pt.y, hMainWnd, NULL);
00295 
00296             DestroyMenu(hMenu);
00297             break;
00298             }
00299         case WM_LBUTTONDBLCLK:
00300             TaskManager_OnRestoreMainWindow();
00301             break;
00302         }
00303         break;
00304 
00305     case WM_NOTIFY:
00306         pnmh = (LPNMHDR)lParam;
00307         if ((pnmh->hwndFrom == hTabWnd) &&
00308             (pnmh->idFrom == IDC_TAB) &&
00309             (pnmh->code == TCN_SELCHANGE))
00310         {
00311             TaskManager_OnTabWndSelChange();
00312         }
00313         break;
00314 #if 0
00315     case WM_NCPAINT:
00316         hdc = GetDC(hDlg);
00317         GetClientRect(hDlg, &rc);
00318         Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
00319         ReleaseDC(hDlg, hdc);
00320         break;
00321 
00322     case WM_PAINT:
00323         hdc = BeginPaint(hDlg, &ps);
00324         GetClientRect(hDlg, &rc);
00325         Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
00326         EndPaint(hDlg, &ps);
00327         break;
00328 #endif
00329     case WM_SIZING:
00330         /* Make sure the user is sizing the dialog */
00331         /* in an acceptable range */
00332         pRC = (LPRECT)lParam;
00333         if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT)) {
00334             /* If the width is too small enlarge it to the minimum */
00335             if (nMinimumWidth > (pRC->right - pRC->left))
00336                 pRC->left = pRC->right - nMinimumWidth;
00337         } else {
00338             /* If the width is too small enlarge it to the minimum */
00339             if (nMinimumWidth > (pRC->right - pRC->left))
00340                 pRC->right = pRC->left + nMinimumWidth;
00341         }
00342         if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT)) {
00343             /* If the height is too small enlarge it to the minimum */
00344             if (nMinimumHeight > (pRC->bottom - pRC->top))
00345                 pRC->top = pRC->bottom - nMinimumHeight;
00346         } else {
00347             /* If the height is too small enlarge it to the minimum */
00348             if (nMinimumHeight > (pRC->bottom - pRC->top))
00349                 pRC->bottom = pRC->top + nMinimumHeight;
00350         }
00351         return TRUE;
00352         break;
00353 
00354     case WM_SIZE:
00355         /* Handle the window sizing in it's own function */
00356         OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
00357         break;
00358 
00359     case WM_MOVE:
00360         /* Handle the window moving in it's own function */
00361         OnMove(wParam, LOWORD(lParam), HIWORD(lParam));
00362         break;
00363 
00364     case WM_DESTROY:
00365         ShowWindow(hDlg, SW_HIDE);
00366         TrayIcon_ShellRemoveTrayIcon();
00367         wp.length = sizeof(WINDOWPLACEMENT);
00368         GetWindowPlacement(hDlg, &wp);
00369         TaskManagerSettings.Left = wp.rcNormalPosition.left;
00370         TaskManagerSettings.Top = wp.rcNormalPosition.top;
00371         TaskManagerSettings.Right = wp.rcNormalPosition.right;
00372         TaskManagerSettings.Bottom = wp.rcNormalPosition.bottom;
00373         if (IsZoomed(hDlg) || (wp.flags & WPF_RESTORETOMAXIMIZED))
00374             TaskManagerSettings.Maximized = TRUE;
00375         else
00376             TaskManagerSettings.Maximized = FALSE;
00377         return DefWindowProcW(hDlg, message, wParam, lParam);
00378 
00379     case WM_TIMER:
00380         /* Refresh the performance data */
00381         PerfDataRefresh();
00382         RefreshApplicationPage();
00383         RefreshProcessPage();
00384         RefreshPerformancePage();
00385         TrayIcon_ShellUpdateTrayIcon();
00386         break;
00387 
00388     case WM_ENTERMENULOOP:
00389         TaskManager_OnEnterMenuLoop(hDlg);
00390         break;
00391     case WM_EXITMENULOOP:
00392         TaskManager_OnExitMenuLoop(hDlg);
00393         break;
00394     case WM_MENUSELECT:
00395         TaskManager_OnMenuSelect(hDlg, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
00396         break;
00397     case WM_SYSCOLORCHANGE:
00398         /* Forward WM_SYSCOLORCHANGE to common controls */
00399         SendMessage(hApplicationPageListCtrl, WM_SYSCOLORCHANGE, 0, 0);
00400         SendMessage(hProcessPageListCtrl, WM_SYSCOLORCHANGE, 0, 0);
00401         SendMessage(hProcessPageHeaderCtrl, WM_SYSCOLORCHANGE, 0, 0);
00402         break;
00403     }
00404 
00405     return 0;
00406 }
00407 
00408 void FillSolidRect(HDC hDC, LPCRECT lpRect, COLORREF clr)
00409 {
00410     SetBkColor(hDC, clr);
00411     ExtTextOutW(hDC, 0, 0, ETO_OPAQUE, lpRect, NULL, 0, NULL);
00412 }
00413 
00414 void FillSolidRect2(HDC hDC, int x, int y, int cx, int cy, COLORREF clr)
00415 {
00416     RECT rect;
00417 
00418     SetBkColor(hDC, clr);
00419     rect.left = x;
00420     rect.top = y;
00421     rect.right = x + cx;
00422     rect.bottom = y + cy;
00423     ExtTextOutW(hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
00424 }
00425 
00426 void Draw3dRect(HDC hDC, int x, int y, int cx, int cy, COLORREF clrTopLeft, COLORREF clrBottomRight)
00427 {
00428     FillSolidRect2(hDC, x, y, cx - 1, 1, clrTopLeft);
00429     FillSolidRect2(hDC, x, y, 1, cy - 1, clrTopLeft);
00430     FillSolidRect2(hDC, x + cx, y, -1, cy, clrBottomRight);
00431     FillSolidRect2(hDC, x, y + cy, cx, -1, clrBottomRight);
00432 }
00433 
00434 void Draw3dRect2(HDC hDC, LPRECT lpRect, COLORREF clrTopLeft, COLORREF clrBottomRight)
00435 {
00436     Draw3dRect(hDC, lpRect->left, lpRect->top, lpRect->right - lpRect->left,
00437         lpRect->bottom - lpRect->top, clrTopLeft, clrBottomRight);
00438 }
00439 
00440 static void SetUpdateSpeed(HWND hWnd)
00441 {
00442     /* Setup update speed (pause=fall down) */
00443     switch (TaskManagerSettings.UpdateSpeed) {
00444     case ID_VIEW_UPDATESPEED_HIGH:
00445         SetTimer(hWnd, 1, 1000, NULL);
00446         break;
00447     case ID_VIEW_UPDATESPEED_NORMAL:
00448         SetTimer(hWnd, 1, 2000, NULL);
00449         break;
00450     case ID_VIEW_UPDATESPEED_LOW:
00451         SetTimer(hWnd, 1, 4000, NULL);
00452         break;
00453     }
00454 }
00455 
00456 BOOL OnCreate(HWND hWnd)
00457 {
00458     HMENU   hMenu;
00459     HMENU   hEditMenu;
00460     HMENU   hViewMenu;
00461     HMENU   hUpdateSpeedMenu;
00462     HMENU   hCPUHistoryMenu;
00463     int     nActivePage;
00464     int     nParts[3];
00465     RECT    rc;
00466     WCHAR   szTemp[256];
00467     TCITEM  item;
00468 
00469     SendMessageW(hMainWnd, WM_SETICON, ICON_BIG, (LPARAM)LoadIconW(hInst, MAKEINTRESOURCEW(IDI_TASKMANAGER)));
00470 
00471     /* Initialize the Windows Common Controls DLL */
00472     InitCommonControls();
00473 
00474     /* Get the minimum window sizes */
00475     GetWindowRect(hWnd, &rc);
00476     nMinimumWidth = (rc.right - rc.left);
00477     nMinimumHeight = (rc.bottom - rc.top);
00478 
00479     /* Create the status bar */
00480     hStatusWnd = CreateStatusWindow(WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|SBT_NOBORDERS, L"", hWnd, STATUS_WINDOW);
00481     if(!hStatusWnd)
00482         return FALSE;
00483 
00484     /* Create the status bar panes */
00485     nParts[0] = STATUS_SIZE1;
00486     nParts[1] = STATUS_SIZE2;
00487     nParts[2] = STATUS_SIZE3;
00488     SendMessageW(hStatusWnd, SB_SETPARTS, 3, (LPARAM) (LPINT) nParts);
00489 
00490     /* Create tab pages */
00491     hTabWnd = GetDlgItem(hWnd, IDC_TAB);
00492 #if 1
00493     hApplicationPage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_APPLICATION_PAGE), hWnd, ApplicationPageWndProc);
00494     hProcessPage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_PROCESS_PAGE), hWnd, ProcessPageWndProc);
00495     hPerformancePage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_PERFORMANCE_PAGE), hWnd, PerformancePageWndProc);
00496 #else
00497     hApplicationPage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_APPLICATION_PAGE), hTabWnd, ApplicationPageWndProc);
00498     hProcessPage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_PROCESS_PAGE), hTabWnd, ProcessPageWndProc);
00499     hPerformancePage = CreateDialogW(hInst, MAKEINTRESOURCEW(IDD_PERFORMANCE_PAGE), hTabWnd, PerformancePageWndProc);
00500 #endif
00501 
00502     /* Insert tabs */
00503     LoadStringW(hInst, IDS_TAB_APPS, szTemp, 256);
00504     memset(&item, 0, sizeof(TCITEM));
00505     item.mask = TCIF_TEXT;
00506     item.pszText = szTemp;
00507     (void)TabCtrl_InsertItem(hTabWnd, 0, &item);
00508     LoadStringW(hInst, IDS_TAB_PROCESSES, szTemp, 256);
00509     memset(&item, 0, sizeof(TCITEM));
00510     item.mask = TCIF_TEXT;
00511     item.pszText = szTemp;
00512     (void)TabCtrl_InsertItem(hTabWnd, 1, &item);
00513     LoadStringW(hInst, IDS_TAB_PERFORMANCE, szTemp, 256);
00514     memset(&item, 0, sizeof(TCITEM));
00515     item.mask = TCIF_TEXT;
00516     item.pszText = szTemp;
00517     (void)TabCtrl_InsertItem(hTabWnd, 2, &item);
00518 
00519     /* Size everything correctly */
00520     GetClientRect(hWnd, &rc);
00521     nOldWidth = rc.right;
00522     nOldHeight = rc.bottom;
00523     /* nOldStartX = rc.left; */
00524     /*nOldStartY = rc.top;  */
00525 
00526 #define PAGE_OFFSET_LEFT    17
00527 #define PAGE_OFFSET_TOP     72
00528 #define PAGE_OFFSET_WIDTH   (PAGE_OFFSET_LEFT*2)
00529 #define PAGE_OFFSET_HEIGHT  (PAGE_OFFSET_TOP+32)
00530 
00531     if ((TaskManagerSettings.Left != 0) ||
00532         (TaskManagerSettings.Top != 0) ||
00533         (TaskManagerSettings.Right != 0) ||
00534         (TaskManagerSettings.Bottom != 0))
00535     {
00536         MoveWindow(hWnd, TaskManagerSettings.Left, TaskManagerSettings.Top, TaskManagerSettings.Right - TaskManagerSettings.Left, TaskManagerSettings.Bottom - TaskManagerSettings.Top, TRUE);
00537 #ifdef __GNUC__TEST__
00538         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);
00539         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);
00540         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);
00541 #endif
00542     }
00543     if (TaskManagerSettings.Maximized)
00544         ShowWindow(hWnd, SW_MAXIMIZE);
00545 
00546     /* Set the always on top style */
00547     hMenu = GetMenu(hWnd);
00548     hEditMenu = GetSubMenu(hMenu, 1);
00549     hViewMenu = GetSubMenu(hMenu, 2);
00550     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
00551     hCPUHistoryMenu = GetSubMenu(hViewMenu, 7);
00552 
00553     /* Check or uncheck the always on top menu item */
00554     if (TaskManagerSettings.AlwaysOnTop) {
00555         CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_CHECKED);
00556         SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
00557     } else {
00558         CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_UNCHECKED);
00559         SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
00560     }
00561 
00562     /* Check or uncheck the minimize on use menu item */
00563     if (TaskManagerSettings.MinimizeOnUse)
00564         CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_CHECKED);
00565     else
00566         CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_UNCHECKED);
00567 
00568     /* Check or uncheck the hide when minimized menu item */
00569     if (TaskManagerSettings.HideWhenMinimized)
00570         CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_CHECKED);
00571     else
00572         CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_UNCHECKED);
00573 
00574     /* Check or uncheck the show 16-bit tasks menu item */
00575     if (TaskManagerSettings.Show16BitTasks)
00576         CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
00577     else
00578         CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_UNCHECKED);
00579 
00580     /* Set the view mode */
00581     CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, TaskManagerSettings.ViewMode, MF_BYCOMMAND);
00582 
00583     if (TaskManagerSettings.ShowKernelTimes)
00584         CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
00585     else
00586         CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
00587 
00588     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, TaskManagerSettings.UpdateSpeed, MF_BYCOMMAND);
00589 
00590     if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
00591         CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
00592     else
00593         CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
00594 
00595     nActivePage = TaskManagerSettings.ActiveTabPage;
00596     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 0);
00597     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 1);
00598     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 2);
00599     TabCtrl_SetCurFocus/*Sel*/(hTabWnd, nActivePage);
00600 
00601     /* Setup update speed */
00602     SetUpdateSpeed(hWnd);
00603 
00604     /*
00605      * Refresh the performance data
00606      * Sample it twice so we can establish
00607      * the delta values & cpu usage
00608      */
00609     PerfDataRefresh();
00610     PerfDataRefresh();
00611 
00612     RefreshApplicationPage();
00613     RefreshProcessPage();
00614     RefreshPerformancePage();
00615 
00616     TrayIcon_ShellAddTrayIcon();
00617 
00618     return TRUE;
00619 }
00620 
00621 /* OnMove()
00622  * This function handles all the moving events for the application
00623  * It moves every child window that needs moving
00624  */
00625 void OnMove( WPARAM nType, int cx, int cy )
00626 {
00627 #ifdef __GNUC__TEST__
00628     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);
00629     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);
00630     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);
00631 #endif
00632 }
00633 
00634 /* OnSize()
00635  * This function handles all the sizing events for the application
00636  * It re-sizes every window, and child window that needs re-sizing
00637  */
00638 void OnSize( WPARAM nType, int cx, int cy )
00639 {
00640     int   nParts[3];
00641     int   nXDifference;
00642     int   nYDifference;
00643     RECT  rc;
00644 
00645     if (nType == SIZE_MINIMIZED)
00646     {
00647         if(TaskManagerSettings.HideWhenMinimized)
00648         {
00649           ShowWindow(hMainWnd, SW_HIDE);
00650         }
00651         return;
00652     }
00653 
00654     nXDifference = cx - nOldWidth;
00655     nYDifference = cy - nOldHeight;
00656     nOldWidth = cx;
00657     nOldHeight = cy;
00658 
00659     /* Update the status bar size */
00660     GetWindowRect(hStatusWnd, &rc);
00661     SendMessageW(hStatusWnd, WM_SIZE, nType, MAKELPARAM(cx,rc.bottom - rc.top));
00662 
00663     /* Update the status bar pane sizes */
00664     nParts[0] = bInMenuLoop ? -1 : STATUS_SIZE1;
00665     nParts[1] = STATUS_SIZE2;
00666     nParts[2] = cx;
00667     SendMessageW(hStatusWnd, SB_SETPARTS, bInMenuLoop ? 1 : 3, (LPARAM) (LPINT) nParts);
00668 
00669     /* Resize the tab control */
00670     GetWindowRect(hTabWnd, &rc);
00671     cx = (rc.right - rc.left) + nXDifference;
00672     cy = (rc.bottom - rc.top) + nYDifference;
00673     SetWindowPos(hTabWnd, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
00674 
00675     /* Resize the application page */
00676     GetWindowRect(hApplicationPage, &rc);
00677     cx = (rc.right - rc.left) + nXDifference;
00678     cy = (rc.bottom - rc.top) + nYDifference;
00679     SetWindowPos(hApplicationPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
00680 
00681     /* Resize the process page */
00682     GetWindowRect(hProcessPage, &rc);
00683     cx = (rc.right - rc.left) + nXDifference;
00684     cy = (rc.bottom - rc.top) + nYDifference;
00685     SetWindowPos(hProcessPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
00686 
00687     /* Resize the performance page */
00688     GetWindowRect(hPerformancePage, &rc);
00689     cx = (rc.right - rc.left) + nXDifference;
00690     cy = (rc.bottom - rc.top) + nYDifference;
00691     SetWindowPos(hPerformancePage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
00692 }
00693 
00694 void LoadSettings(void)
00695 {
00696     HKEY   hKey;
00697     WCHAR  szSubKey[] = L"Software\\ReactOS\\TaskManager";
00698     int    i;
00699     DWORD  dwSize;
00700 
00701     /* Window size & position settings */
00702     TaskManagerSettings.Maximized = FALSE;
00703     TaskManagerSettings.Left = 0;
00704     TaskManagerSettings.Top = 0;
00705     TaskManagerSettings.Right = 0;
00706     TaskManagerSettings.Bottom = 0;
00707 
00708     /* Tab settings */
00709     TaskManagerSettings.ActiveTabPage = 0;
00710 
00711     /* Options menu settings */
00712     TaskManagerSettings.AlwaysOnTop = FALSE;
00713     TaskManagerSettings.MinimizeOnUse = TRUE;
00714     TaskManagerSettings.HideWhenMinimized = TRUE;
00715     TaskManagerSettings.Show16BitTasks = TRUE;
00716 
00717     /* Update speed settings */
00718     TaskManagerSettings.UpdateSpeed = ID_VIEW_UPDATESPEED_NORMAL;
00719 
00720     /* Applications page settings */
00721     TaskManagerSettings.ViewMode = ID_VIEW_DETAILS;
00722 
00723     /* Processes page settings */
00724     TaskManagerSettings.ShowProcessesFromAllUsers = FALSE; /* Server-only? */
00725 
00726     for (i = 0; i < COLUMN_NMAX; i++) {
00727         TaskManagerSettings.Columns[i] = ColumnPresets[i].bDefaults;
00728         TaskManagerSettings.ColumnOrderArray[i] = i;
00729         TaskManagerSettings.ColumnSizeArray[i] = ColumnPresets[i].size;
00730     }
00731 
00732     TaskManagerSettings.SortColumn = COLUMN_IMAGENAME;
00733     TaskManagerSettings.SortAscending = TRUE;
00734 
00735     /* Performance page settings */
00736     TaskManagerSettings.CPUHistory_OneGraphPerCPU = TRUE;
00737     TaskManagerSettings.ShowKernelTimes = FALSE;
00738 
00739     /* Open the key */
00740     if (RegOpenKeyExW(HKEY_CURRENT_USER, szSubKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
00741         return;
00742     /* Read the settings */
00743     dwSize = sizeof(TASKMANAGER_SETTINGS);
00744     RegQueryValueExW(hKey, L"Preferences", NULL, NULL, (LPBYTE)&TaskManagerSettings, &dwSize);
00745 
00746     /*
00747      * ATM, the 'ImageName' column is always visible
00748      * (and grayed in configuration dialog)
00749      * This will avoid troubles if the registry gets corrupted.
00750      */
00751     TaskManagerSettings.Column_ImageName = TRUE;
00752 
00753     /* Close the key */
00754     RegCloseKey(hKey);
00755 }
00756 
00757 void SaveSettings(void)
00758 {
00759     HKEY hKey;
00760     WCHAR szSubKey[] = L"Software\\ReactOS\\TaskManager";
00761 
00762     /* Open (or create) the key */
00763     if (RegCreateKeyExW(HKEY_CURRENT_USER, szSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
00764         return;
00765     /* Save the settings */
00766     RegSetValueExW(hKey, L"Preferences", 0, REG_BINARY, (LPBYTE)&TaskManagerSettings, sizeof(TASKMANAGER_SETTINGS));
00767     /* Close the key */
00768     RegCloseKey(hKey);
00769 }
00770 
00771 void TaskManager_OnRestoreMainWindow(void)
00772 {
00773     //HMENU hMenu, hOptionsMenu;
00774     BOOL OnTop;
00775 
00776     //hMenu = GetMenu(hMainWnd);
00777     //hOptionsMenu = GetSubMenu(hMenu, OPTIONS_MENU_INDEX);
00778     OnTop = ((GetWindowLongPtrW(hMainWnd, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0);
00779 
00780     OpenIcon(hMainWnd);
00781     SetForegroundWindow(hMainWnd);
00782     SetWindowPos(hMainWnd, (OnTop ? HWND_TOPMOST : HWND_TOP), 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
00783 }
00784 
00785 void TaskManager_OnEnterMenuLoop(HWND hWnd)
00786 {
00787     int nParts;
00788 
00789     /* Update the status bar pane sizes */
00790     nParts = -1;
00791     SendMessageW(hStatusWnd, SB_SETPARTS, 1, (LPARAM) (LPINT)&nParts);
00792     bInMenuLoop = TRUE;
00793     SendMessageW(hStatusWnd, SB_SETTEXT, (WPARAM)0, (LPARAM)L"");
00794 }
00795 
00796 void TaskManager_OnExitMenuLoop(HWND hWnd)
00797 {
00798     RECT   rc;
00799     int    nParts[3];
00800     WCHAR  text[260];
00801     WCHAR  szCpuUsage[256], szProcesses[256];
00802 
00803     LoadStringW(hInst, IDS_STATUS_CPUUSAGE, szCpuUsage, 256);
00804     LoadStringW(hInst, IDS_STATUS_PROCESSES, szProcesses, 256);
00805 
00806     bInMenuLoop = FALSE;
00807     /* Update the status bar pane sizes */
00808     GetClientRect(hWnd, &rc);
00809     nParts[0] = STATUS_SIZE1;
00810     nParts[1] = STATUS_SIZE2;
00811     nParts[2] = rc.right;
00812     SendMessageW(hStatusWnd, SB_SETPARTS, 3, (LPARAM) (LPINT) nParts);
00813     SendMessageW(hStatusWnd, SB_SETTEXT, 0, (LPARAM)L"");
00814     wsprintfW(text, szCpuUsage, PerfDataGetProcessorUsage());
00815     SendMessageW(hStatusWnd, SB_SETTEXT, 1, (LPARAM)text);
00816     wsprintfW(text, szProcesses, PerfDataGetProcessCount());
00817     SendMessageW(hStatusWnd, SB_SETTEXT, 0, (LPARAM)text);
00818 }
00819 
00820 void TaskManager_OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
00821 {
00822     WCHAR  str[100];
00823 
00824     wcscpy(str, L"");
00825     if (LoadStringW(hInst, nItemID, str, 100)) {
00826         /* load appropriate string */
00827         LPWSTR lpsz = str;
00828         /* first newline terminates actual string */
00829         lpsz = wcschr(lpsz, '\n');
00830         if (lpsz != NULL)
00831             *lpsz = '\0';
00832     }
00833     SendMessageW(hStatusWnd, SB_SETTEXT, 0, (LPARAM)str);
00834 }
00835 
00836 void TaskManager_OnViewUpdateSpeed(DWORD dwSpeed)
00837 {
00838     HMENU  hMenu;
00839     HMENU  hViewMenu;
00840     HMENU  hUpdateSpeedMenu;
00841 
00842     hMenu = GetMenu(hMainWnd);
00843     hViewMenu = GetSubMenu(hMenu, 2);
00844     hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
00845 
00846     TaskManagerSettings.UpdateSpeed = dwSpeed;
00847     CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, dwSpeed, MF_BYCOMMAND);
00848 
00849     KillTimer(hMainWnd, 1);
00850 
00851     SetUpdateSpeed(hMainWnd);
00852 }
00853 
00854 void TaskManager_OnTabWndSelChange(void)
00855 {
00856     int    i;
00857     HMENU  hMenu;
00858     HMENU  hOptionsMenu;
00859     HMENU  hViewMenu;
00860     HMENU  hSubMenu;
00861     WCHAR  szTemp[256];
00862     SYSTEM_INFO sysInfo;
00863 
00864     hMenu = GetMenu(hMainWnd);
00865     hViewMenu = GetSubMenu(hMenu, 2);
00866     hOptionsMenu = GetSubMenu(hMenu, 1);
00867     TaskManagerSettings.ActiveTabPage = TabCtrl_GetCurSel(hTabWnd);
00868     for (i = GetMenuItemCount(hViewMenu) - 1; i > 2; i--) {
00869         hSubMenu = GetSubMenu(hViewMenu, i);
00870         if (hSubMenu)
00871             DestroyMenu(hSubMenu);
00872         RemoveMenu(hViewMenu, i, MF_BYPOSITION);
00873     }
00874     RemoveMenu(hOptionsMenu, 3, MF_BYPOSITION);
00875     switch (TaskManagerSettings.ActiveTabPage) {
00876     case 0:
00877         ShowWindow(hApplicationPage, SW_SHOW);
00878         ShowWindow(hProcessPage, SW_HIDE);
00879         ShowWindow(hPerformancePage, SW_HIDE);
00880         BringWindowToTop(hApplicationPage);
00881 
00882         LoadStringW(hInst, IDS_MENU_LARGEICONS, szTemp, 256);
00883         AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_LARGE, szTemp);
00884 
00885         LoadStringW(hInst, IDS_MENU_SMALLICONS, szTemp, 256);
00886         AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SMALL, szTemp);
00887 
00888         LoadStringW(hInst, IDS_MENU_DETAILS, szTemp, 256);
00889         AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_DETAILS, szTemp);
00890 
00891         if (GetMenuItemCount(hMenu) <= 4) {
00892             hSubMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_WINDOWSMENU));
00893 
00894             LoadStringW(hInst, IDS_MENU_WINDOWS, szTemp, 256);
00895             InsertMenuW(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT_PTR) hSubMenu, szTemp);
00896 
00897             DrawMenuBar(hMainWnd);
00898         }
00899         CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, TaskManagerSettings.ViewMode, MF_BYCOMMAND);
00900 
00901         /*
00902          * Give the application list control focus
00903          */
00904         SetFocus(hApplicationPageListCtrl);
00905         break;
00906 
00907     case 1:
00908         ShowWindow(hApplicationPage, SW_HIDE);
00909         ShowWindow(hProcessPage, SW_SHOW);
00910         ShowWindow(hPerformancePage, SW_HIDE);
00911         BringWindowToTop(hProcessPage);
00912 
00913         LoadStringW(hInst, IDS_MENU_SELECTCOLUMNS, szTemp, 256);
00914         AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SELECTCOLUMNS, szTemp);
00915 
00916         LoadStringW(hInst, IDS_MENU_16BITTASK, szTemp, 256);
00917         AppendMenuW(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, szTemp);
00918 
00919         if (TaskManagerSettings.Show16BitTasks)
00920             CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
00921         if (GetMenuItemCount(hMenu) > 4)
00922         {
00923             DeleteMenu(hMenu, 3, MF_BYPOSITION);
00924             DrawMenuBar(hMainWnd);
00925         }
00926         /*
00927          * Give the process list control focus
00928          */
00929         SetFocus(hProcessPageListCtrl);
00930         break;
00931 
00932     case 2:
00933         ShowWindow(hApplicationPage, SW_HIDE);
00934         ShowWindow(hProcessPage, SW_HIDE);
00935         ShowWindow(hPerformancePage, SW_SHOW);
00936         BringWindowToTop(hPerformancePage);
00937         if (GetMenuItemCount(hMenu) > 4) {
00938             DeleteMenu(hMenu, 3, MF_BYPOSITION);
00939             DrawMenuBar(hMainWnd);
00940         }
00941 
00942         GetSystemInfo(&sysInfo);
00943 
00944         /* Hide CPU graph options on single CPU systems */
00945         if (sysInfo.dwNumberOfProcessors > 1)
00946         {
00947             hSubMenu = CreatePopupMenu();
00948 
00949             LoadStringW(hInst, IDS_MENU_ONEGRAPHALLCPUS, szTemp, 256);
00950             AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHALL, szTemp);
00951 
00952             LoadStringW(hInst, IDS_MENU_ONEGRAPHPERCPU, szTemp, 256);
00953             AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, szTemp);
00954 
00955             LoadStringW(hInst, IDS_MENU_CPUHISTORY, szTemp, 256);
00956             AppendMenuW(hViewMenu, MF_STRING|MF_POPUP, (UINT_PTR) hSubMenu, szTemp);
00957 
00958             if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
00959                 CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
00960             else
00961                 CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
00962         }
00963 
00964         LoadStringW(hInst, IDS_MENU_SHOWKERNELTIMES, szTemp, 256);
00965         AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, szTemp);
00966 
00967         if (TaskManagerSettings.ShowKernelTimes)
00968             CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
00969         else
00970             CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
00971 
00972         /*
00973          * Give the tab control focus
00974          */
00975         SetFocus(hTabWnd);
00976         break;
00977     }
00978 }
00979 
00980 LPWSTR GetLastErrorText(LPWSTR lpszBuf, DWORD dwSize)
00981 {
00982     DWORD  dwRet;
00983     LPWSTR lpszTemp = NULL;
00984 
00985     dwRet = FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
00986                            NULL,
00987                            GetLastError(),
00988                            LANG_NEUTRAL,
00989                            (LPWSTR)&lpszTemp,
00990                            0,
00991                            NULL );
00992 
00993     /* supplied buffer is not long enough */
00994     if (!dwRet || ( (long)dwSize < (long)dwRet+14)) {
00995         lpszBuf[0] = L'\0';
00996     } else {
00997         lpszTemp[lstrlenW(lpszTemp)-2] = L'\0';  /*remove cr and newline character */
00998         wsprintfW(lpszBuf, L"%s (0x%x)", lpszTemp, (int)GetLastError());
00999     }
01000     if (lpszTemp) {
01001         LocalFree((HLOCAL)lpszTemp);
01002     }
01003     return lpszBuf;
01004 }
01005 
01006 DWORD EndLocalThread(HANDLE *hThread, DWORD dwThread)
01007 {
01008     DWORD dwExitCodeThread = 0;
01009 
01010     if (*hThread != NULL) {
01011         PostThreadMessage(dwThread,WM_QUIT,0,0);
01012         for (;;) {
01013             MSG msg;
01014 
01015             if (WAIT_OBJECT_0 == WaitForSingleObject(*hThread, 500))
01016                 break;
01017             while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
01018                 TranslateMessage(&msg);
01019                 DispatchMessage(&msg);
01020             }
01021         }
01022         GetExitCodeThread(*hThread, &dwExitCodeThread);
01023         CloseHandle(*hThread);
01024         *hThread = NULL;
01025     }
01026     return dwExitCodeThread;
01027 }
01028
Generated on Sun May 27 2012 04:17:47 for ReactOS by
1.7.6.1