mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 22:28:36 +00:00
1040 lines
40 KiB
C
1040 lines
40 KiB
C
// TaskMgr.cpp : Defines the entry point for the application.
|
|
//
|
|
|
|
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
|
|
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <stdlib.h>
|
|
#include <malloc.h>
|
|
#include <memory.h>
|
|
#include <tchar.h>
|
|
#include <process.h>
|
|
#include <stdio.h>
|
|
|
|
#include "resource.h"
|
|
#include "taskmgr.h"
|
|
#include "applpage.h"
|
|
#include "procpage.h"
|
|
#include "perfpage.h"
|
|
#include "run.h"
|
|
#include "perfdata.h"
|
|
#include "optnmenu.h"
|
|
#include "affinity.h"
|
|
#include "priority.h"
|
|
#include "debug.h"
|
|
#include "endproc.h"
|
|
#include "column.h"
|
|
#include "about.h"
|
|
#include "trayicon.h"
|
|
|
|
#define STATUS_WINDOW 2001
|
|
|
|
// Global Variables:
|
|
HINSTANCE hInst; // current instance
|
|
|
|
HWND hMainWnd; // Main Window
|
|
HWND hStatusWnd; // Status Bar Window
|
|
HWND hTabWnd; // Tab Control Window
|
|
|
|
int nMinimumWidth; // Minimum width of the dialog (OnSize()'s cx)
|
|
int nMinimumHeight; // Minimum height of the dialog (OnSize()'s cy)
|
|
|
|
int nOldWidth; // Holds the previous client area width
|
|
int nOldHeight; // Holds the previous client area height
|
|
|
|
BOOL bInMenuLoop = FALSE; // Tells us if we are in the menu loop
|
|
|
|
TASKMANAGER_SETTINGS TaskManagerSettings;
|
|
|
|
|
|
int APIENTRY WinMain(HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine,
|
|
int nCmdShow)
|
|
{
|
|
HANDLE hProcess;
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tkp;
|
|
|
|
// Initialize global variables
|
|
hInst = hInstance;
|
|
|
|
// Change our priority class to HIGH
|
|
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
|
|
SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS);
|
|
CloseHandle(hProcess);
|
|
|
|
// Now lets get the SE_DEBUG_NAME priviledge
|
|
// so that we can debug processes
|
|
|
|
// Get a token for this process.
|
|
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
|
|
// Get the LUID for the debug privilege.
|
|
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tkp.Privileges[0].Luid);
|
|
|
|
tkp.PrivilegeCount = 1; // one privilege to set
|
|
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
// Get the debug privilege for this process.
|
|
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
|
|
}
|
|
|
|
// Load our settings from the registry
|
|
LoadSettings();
|
|
|
|
// Initialize perf data
|
|
if (!PerfDataInitialize()) {
|
|
return -1;
|
|
}
|
|
|
|
DialogBox(hInst, (LPCTSTR)IDD_TASKMGR_DIALOG, NULL, (DLGPROC)TaskManagerWndProc);
|
|
|
|
// Save our settings to the registry
|
|
SaveSettings();
|
|
PerfDataUninitialize();
|
|
return 0;
|
|
}
|
|
|
|
#define _USE_CMD_MAP
|
|
|
|
#ifdef _USE_CMD_MAP
|
|
#define BEGIN_CMD_MAP(a) switch( ##a ) {
|
|
#define CMD_MAP_ENTRY(a, b) case a: b(); break;
|
|
#define END_CMD_MAP(a) }
|
|
|
|
#endif
|
|
|
|
// Message handler for dialog box.
|
|
LRESULT CALLBACK TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
LPRECT pRC;
|
|
RECT rc;
|
|
int idctrl;
|
|
LPNMHDR pnmh;
|
|
WINDOWPLACEMENT wp;
|
|
|
|
switch (message) {
|
|
case WM_INITDIALOG:
|
|
hMainWnd = hDlg;
|
|
return OnCreate(hDlg);
|
|
|
|
case WM_COMMAND:
|
|
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
return TRUE;
|
|
}
|
|
#ifdef _USE_CMD_MAP
|
|
BEGIN_CMD_MAP( LOWORD(wParam) )
|
|
CMD_MAP_ENTRY(ID_FILE_NEW, TaskManager_OnFileNew)
|
|
CMD_MAP_ENTRY(ID_OPTIONS_ALWAYSONTOP, TaskManager_OnOptionsAlwaysOnTop)
|
|
CMD_MAP_ENTRY(ID_OPTIONS_MINIMIZEONUSE, TaskManager_OnOptionsMinimizeOnUse)
|
|
CMD_MAP_ENTRY(ID_OPTIONS_HIDEWHENMINIMIZED, TaskManager_OnOptionsHideWhenMinimized)
|
|
CMD_MAP_ENTRY(ID_OPTIONS_SHOW16BITTASKS, TaskManager_OnOptionsShow16BitTasks)
|
|
CMD_MAP_ENTRY(ID_VIEW_LARGE, ApplicationPage_OnViewLargeIcons)
|
|
CMD_MAP_ENTRY(ID_VIEW_SMALL, ApplicationPage_OnViewSmallIcons)
|
|
CMD_MAP_ENTRY(ID_VIEW_DETAILS, ApplicationPage_OnViewDetails)
|
|
CMD_MAP_ENTRY(ID_VIEW_SHOWKERNELTIMES, PerformancePage_OnViewShowKernelTimes)
|
|
CMD_MAP_ENTRY(ID_VIEW_CPUHISTORY_ONEGRAPHALL, PerformancePage_OnViewCPUHistoryOneGraphAll)
|
|
CMD_MAP_ENTRY(ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, PerformancePage_OnViewCPUHistoryOneGraphPerCPU)
|
|
CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_HIGH, TaskManager_OnViewUpdateSpeedHigh)
|
|
CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_NORMAL, TaskManager_OnViewUpdateSpeedNormal)
|
|
CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_LOW, TaskManager_OnViewUpdateSpeedLow)
|
|
CMD_MAP_ENTRY(ID_VIEW_UPDATESPEED_PAUSED, TaskManager_OnViewUpdateSpeedPaused)
|
|
CMD_MAP_ENTRY(ID_VIEW_SELECTCOLUMNS, ProcessPage_OnViewSelectColumns)
|
|
CMD_MAP_ENTRY(ID_VIEW_REFRESH, TaskManager_OnViewRefresh)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_TILEHORIZONTALLY, ApplicationPage_OnWindowsTileHorizontally)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_TILEVERTICALLY, ApplicationPage_OnWindowsTileVertically)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_MINIMIZE, ApplicationPage_OnWindowsMinimize)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_MAXIMIZE, ApplicationPage_OnWindowsMaximize)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_CASCADE, ApplicationPage_OnWindowsCascade)
|
|
CMD_MAP_ENTRY(ID_WINDOWS_BRINGTOFRONT, ApplicationPage_OnWindowsBringToFront)
|
|
CMD_MAP_ENTRY(ID_APPLICATION_PAGE_SWITCHTO, ApplicationPage_OnSwitchTo)
|
|
CMD_MAP_ENTRY(ID_APPLICATION_PAGE_ENDTASK, ApplicationPage_OnEndTask)
|
|
CMD_MAP_ENTRY(ID_APPLICATION_PAGE_GOTOPROCESS, ApplicationPage_OnGotoProcess)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_ENDPROCESS, ProcessPage_OnEndProcess)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_ENDPROCESSTREE, ProcessPage_OnEndProcessTree)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_DEBUG, ProcessPage_OnDebug)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETAFFINITY, ProcessPage_OnSetAffinity)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ProcessPage_OnSetPriorityRealTime)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_HIGH, ProcessPage_OnSetPriorityHigh)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL, ProcessPage_OnSetPriorityAboveNormal)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_NORMAL, ProcessPage_OnSetPriorityNormal)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL, ProcessPage_OnSetPriorityBelowNormal)
|
|
CMD_MAP_ENTRY(ID_PROCESS_PAGE_SETPRIORITY_LOW, ProcessPage_OnSetPriorityLow)
|
|
CMD_MAP_ENTRY(ID_HELP_ABOUT, OnAbout)
|
|
END_CMD_MAP(0)
|
|
#else
|
|
// Process menu commands
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case ID_FILE_NEW:
|
|
TaskManager_OnFileNew();
|
|
break;
|
|
case ID_OPTIONS_ALWAYSONTOP:
|
|
TaskManager_OnOptionsAlwaysOnTop();
|
|
break;
|
|
case ID_OPTIONS_MINIMIZEONUSE:
|
|
TaskManager_OnOptionsMinimizeOnUse();
|
|
break;
|
|
case ID_OPTIONS_HIDEWHENMINIMIZED:
|
|
TaskManager_OnOptionsHideWhenMinimized();
|
|
break;
|
|
case ID_OPTIONS_SHOW16BITTASKS:
|
|
TaskManager_OnOptionsShow16BitTasks();
|
|
break;
|
|
case ID_VIEW_LARGE:
|
|
ApplicationPage_OnViewLargeIcons();
|
|
break;
|
|
case ID_VIEW_SMALL:
|
|
ApplicationPage_OnViewSmallIcons();
|
|
break;
|
|
case ID_VIEW_DETAILS:
|
|
ApplicationPage_OnViewDetails();
|
|
break;
|
|
case ID_VIEW_SHOWKERNELTIMES:
|
|
PerformancePage_OnViewShowKernelTimes();
|
|
break;
|
|
case ID_VIEW_CPUHISTORY_ONEGRAPHALL:
|
|
PerformancePage_OnViewCPUHistoryOneGraphAll();
|
|
break;
|
|
case ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU:
|
|
PerformancePage_OnViewCPUHistoryOneGraphPerCPU();
|
|
break;
|
|
case ID_VIEW_UPDATESPEED_HIGH:
|
|
TaskManager_OnViewUpdateSpeedHigh();
|
|
break;
|
|
case ID_VIEW_UPDATESPEED_NORMAL:
|
|
TaskManager_OnViewUpdateSpeedNormal();
|
|
break;
|
|
case ID_VIEW_UPDATESPEED_LOW:
|
|
TaskManager_OnViewUpdateSpeedLow();
|
|
break;
|
|
case ID_VIEW_UPDATESPEED_PAUSED:
|
|
TaskManager_OnViewUpdateSpeedPaused();
|
|
break;
|
|
case ID_VIEW_SELECTCOLUMNS:
|
|
ProcessPage_OnViewSelectColumns();
|
|
break;
|
|
case ID_VIEW_REFRESH:
|
|
PostMessage(hDlg, WM_TIMER, 0, 0);
|
|
break;
|
|
case ID_WINDOWS_TILEHORIZONTALLY:
|
|
ApplicationPage_OnWindowsTileHorizontally();
|
|
break;
|
|
case ID_WINDOWS_TILEVERTICALLY:
|
|
ApplicationPage_OnWindowsTileVertically();
|
|
break;
|
|
case ID_WINDOWS_MINIMIZE:
|
|
ApplicationPage_OnWindowsMinimize();
|
|
break;
|
|
case ID_WINDOWS_MAXIMIZE:
|
|
ApplicationPage_OnWindowsMaximize();
|
|
break;
|
|
case ID_WINDOWS_CASCADE:
|
|
ApplicationPage_OnWindowsCascade();
|
|
break;
|
|
case ID_WINDOWS_BRINGTOFRONT:
|
|
ApplicationPage_OnWindowsBringToFront();
|
|
break;
|
|
case ID_APPLICATION_PAGE_SWITCHTO:
|
|
ApplicationPage_OnSwitchTo();
|
|
break;
|
|
case ID_APPLICATION_PAGE_ENDTASK:
|
|
ApplicationPage_OnEndTask();
|
|
break;
|
|
case ID_APPLICATION_PAGE_GOTOPROCESS:
|
|
ApplicationPage_OnGotoProcess();
|
|
break;
|
|
case ID_PROCESS_PAGE_ENDPROCESS:
|
|
ProcessPage_OnEndProcess();
|
|
break;
|
|
case ID_PROCESS_PAGE_ENDPROCESSTREE:
|
|
ProcessPage_OnEndProcessTree();
|
|
break;
|
|
case ID_PROCESS_PAGE_DEBUG:
|
|
ProcessPage_OnDebug();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETAFFINITY:
|
|
ProcessPage_OnSetAffinity();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_REALTIME:
|
|
ProcessPage_OnSetPriorityRealTime();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_HIGH:
|
|
ProcessPage_OnSetPriorityHigh();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL:
|
|
ProcessPage_OnSetPriorityAboveNormal();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_NORMAL:
|
|
ProcessPage_OnSetPriorityNormal();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL:
|
|
ProcessPage_OnSetPriorityBelowNormal();
|
|
break;
|
|
case ID_PROCESS_PAGE_SETPRIORITY_LOW:
|
|
ProcessPage_OnSetPriorityLow();
|
|
break;
|
|
case ID_HELP_ABOUT:
|
|
OnAbout();
|
|
break;
|
|
}
|
|
#endif
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
idctrl = (int)wParam;
|
|
pnmh = (LPNMHDR)lParam;
|
|
if ((pnmh->hwndFrom == hTabWnd) &&
|
|
(pnmh->idFrom == IDC_TAB) &&
|
|
(pnmh->code == TCN_SELCHANGE))
|
|
{
|
|
TaskManager_OnTabWndSelChange();
|
|
}
|
|
break;
|
|
|
|
case WM_NCPAINT:
|
|
hdc = GetDC(hDlg);
|
|
GetClientRect(hDlg, &rc);
|
|
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
|
|
ReleaseDC(hDlg, hdc);
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
hdc = BeginPaint(hDlg, &ps);
|
|
GetClientRect(hDlg, &rc);
|
|
Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT));
|
|
EndPaint(hDlg, &ps);
|
|
break;
|
|
|
|
case WM_SIZING:
|
|
// Make sure the user is sizing the dialog
|
|
// in an acceptable range
|
|
pRC = (LPRECT)lParam;
|
|
if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT)) {
|
|
// If the width is too small enlarge it to the minimum
|
|
if (nMinimumWidth > (pRC->right - pRC->left))
|
|
pRC->left = pRC->right - nMinimumWidth;
|
|
} else {
|
|
// If the width is too small enlarge it to the minimum
|
|
if (nMinimumWidth > (pRC->right - pRC->left))
|
|
pRC->right = pRC->left + nMinimumWidth;
|
|
}
|
|
if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT)) {
|
|
// If the height is too small enlarge it to the minimum
|
|
if (nMinimumHeight > (pRC->bottom - pRC->top))
|
|
pRC->top = pRC->bottom - nMinimumHeight;
|
|
} else {
|
|
// If the height is too small enlarge it to the minimum
|
|
if (nMinimumHeight > (pRC->bottom - pRC->top))
|
|
pRC->bottom = pRC->top + nMinimumHeight;
|
|
}
|
|
return TRUE;
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
// Handle the window sizing in it's own function
|
|
OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_MOVE:
|
|
// Handle the window moving in it's own function
|
|
OnMove(wParam, LOWORD(lParam), HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
ShowWindow(hDlg, SW_HIDE);
|
|
TrayIcon_ShellRemoveTrayIcon();
|
|
wp.length = sizeof(WINDOWPLACEMENT);
|
|
GetWindowPlacement(hDlg, &wp);
|
|
TaskManagerSettings.Left = wp.rcNormalPosition.left;
|
|
TaskManagerSettings.Top = wp.rcNormalPosition.top;
|
|
TaskManagerSettings.Right = wp.rcNormalPosition.right;
|
|
TaskManagerSettings.Bottom = wp.rcNormalPosition.bottom;
|
|
if (IsZoomed(hDlg) || (wp.flags & WPF_RESTORETOMAXIMIZED))
|
|
TaskManagerSettings.Maximized = TRUE;
|
|
else
|
|
TaskManagerSettings.Maximized = FALSE;
|
|
return DefWindowProc(hDlg, message, wParam, lParam);
|
|
|
|
case WM_TIMER:
|
|
// Refresh the performance data
|
|
PerfDataRefresh();
|
|
RefreshApplicationPage();
|
|
RefreshProcessPage();
|
|
RefreshPerformancePage();
|
|
TrayIcon_ShellUpdateTrayIcon();
|
|
break;
|
|
|
|
case WM_ENTERMENULOOP:
|
|
TaskManager_OnEnterMenuLoop(hDlg);
|
|
break;
|
|
case WM_EXITMENULOOP:
|
|
TaskManager_OnExitMenuLoop(hDlg);
|
|
break;
|
|
case WM_MENUSELECT:
|
|
TaskManager_OnMenuSelect(hDlg, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void FillSolidRect(HDC hDC, LPCRECT lpRect, COLORREF clr)
|
|
{
|
|
SetBkColor(hDC, clr);
|
|
ExtTextOut(hDC, 0, 0, ETO_OPAQUE, lpRect, NULL, 0, NULL);
|
|
}
|
|
|
|
void FillSolidRect2(HDC hDC, int x, int y, int cx, int cy, COLORREF clr)
|
|
{
|
|
RECT rect;
|
|
|
|
SetBkColor(hDC, clr);
|
|
rect.left = x;
|
|
rect.top = y;
|
|
rect.right = x + cx;
|
|
rect.bottom = y + cy;
|
|
ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
|
|
}
|
|
|
|
void Draw3dRect(HDC hDC, int x, int y, int cx, int cy, COLORREF clrTopLeft, COLORREF clrBottomRight)
|
|
{
|
|
FillSolidRect2(hDC, x, y, cx - 1, 1, clrTopLeft);
|
|
FillSolidRect2(hDC, x, y, 1, cy - 1, clrTopLeft);
|
|
FillSolidRect2(hDC, x + cx, y, -1, cy, clrBottomRight);
|
|
FillSolidRect2(hDC, x, y + cy, cx, -1, clrBottomRight);
|
|
}
|
|
|
|
void Draw3dRect2(HDC hDC, LPRECT lpRect, COLORREF clrTopLeft, COLORREF clrBottomRight)
|
|
{
|
|
Draw3dRect(hDC, lpRect->left, lpRect->top, lpRect->right - lpRect->left,
|
|
lpRect->bottom - lpRect->top, clrTopLeft, clrBottomRight);
|
|
}
|
|
|
|
BOOL OnCreate(HWND hWnd)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hEditMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hUpdateSpeedMenu;
|
|
HMENU hCPUHistoryMenu;
|
|
int nActivePage;
|
|
int nParts[3];
|
|
RECT rc;
|
|
TCHAR szTemp[256];
|
|
TCITEM item;
|
|
|
|
SendMessage(hMainWnd, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(hInst, MAKEINTRESOURCE(IDI_TASKMANAGER)));
|
|
|
|
// Initialize the Windows Common Controls DLL
|
|
InitCommonControls();
|
|
|
|
// Get the minimum window sizes
|
|
GetWindowRect(hWnd, &rc);
|
|
nMinimumWidth = (rc.right - rc.left);
|
|
nMinimumHeight = (rc.bottom - rc.top);
|
|
|
|
// Create the status bar
|
|
hStatusWnd = CreateStatusWindow(WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|SBT_NOBORDERS, _T(""), hWnd, STATUS_WINDOW);
|
|
if(!hStatusWnd)
|
|
return FALSE;
|
|
|
|
// Create the status bar panes
|
|
nParts[0] = 100;
|
|
nParts[1] = 210;
|
|
nParts[2] = 400;
|
|
SendMessage(hStatusWnd, SB_SETPARTS, 3, (long)nParts);
|
|
|
|
// Create tab pages
|
|
hTabWnd = GetDlgItem(hWnd, IDC_TAB);
|
|
#if 1
|
|
hApplicationPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_APPLICATION_PAGE), hWnd, (DLGPROC)ApplicationPageWndProc);
|
|
hProcessPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PROCESS_PAGE), hWnd, (DLGPROC)ProcessPageWndProc);
|
|
hPerformancePage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PERFORMANCE_PAGE), hWnd, (DLGPROC)PerformancePageWndProc);
|
|
#else
|
|
hApplicationPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_APPLICATION_PAGE), hTabWnd, (DLGPROC)ApplicationPageWndProc);
|
|
hProcessPage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PROCESS_PAGE), hTabWnd, (DLGPROC)ProcessPageWndProc);
|
|
hPerformancePage = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PERFORMANCE_PAGE), hTabWnd, (DLGPROC)PerformancePageWndProc);
|
|
#endif
|
|
// Insert tabs
|
|
_tcscpy(szTemp, _T("Applications"));
|
|
memset(&item, 0, sizeof(TCITEM));
|
|
item.mask = TCIF_TEXT;
|
|
item.pszText = szTemp;
|
|
TabCtrl_InsertItem(hTabWnd, 0, &item);
|
|
_tcscpy(szTemp, _T("Processes"));
|
|
memset(&item, 0, sizeof(TCITEM));
|
|
item.mask = TCIF_TEXT;
|
|
item.pszText = szTemp;
|
|
TabCtrl_InsertItem(hTabWnd, 1, &item);
|
|
_tcscpy(szTemp, _T("Performance"));
|
|
memset(&item, 0, sizeof(TCITEM));
|
|
item.mask = TCIF_TEXT;
|
|
item.pszText = szTemp;
|
|
TabCtrl_InsertItem(hTabWnd, 2, &item);
|
|
|
|
// Size everything correctly
|
|
GetClientRect(hWnd, &rc);
|
|
nOldWidth = rc.right;
|
|
nOldHeight = rc.bottom;
|
|
//nOldStartX = rc.left;
|
|
//nOldStartY = rc.top;
|
|
|
|
#define PAGE_OFFSET_LEFT 17
|
|
#define PAGE_OFFSET_TOP 72
|
|
#define PAGE_OFFSET_WIDTH (PAGE_OFFSET_LEFT*2)
|
|
#define PAGE_OFFSET_HEIGHT (PAGE_OFFSET_TOP+32)
|
|
|
|
if ((TaskManagerSettings.Left != 0) ||
|
|
(TaskManagerSettings.Top != 0) ||
|
|
(TaskManagerSettings.Right != 0) ||
|
|
(TaskManagerSettings.Bottom != 0))
|
|
{
|
|
MoveWindow(hWnd, TaskManagerSettings.Left, TaskManagerSettings.Top, TaskManagerSettings.Right - TaskManagerSettings.Left, TaskManagerSettings.Bottom - TaskManagerSettings.Top, TRUE);
|
|
#ifdef __GNUC__TEST__
|
|
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);
|
|
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);
|
|
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);
|
|
#endif
|
|
}
|
|
if (TaskManagerSettings.Maximized)
|
|
ShowWindow(hWnd, SW_MAXIMIZE);
|
|
|
|
// Set the always on top style
|
|
hMenu = GetMenu(hWnd);
|
|
hEditMenu = GetSubMenu(hMenu, 1);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
|
|
hCPUHistoryMenu = GetSubMenu(hViewMenu, 7);
|
|
|
|
// Check or uncheck the always on top menu item
|
|
if (TaskManagerSettings.AlwaysOnTop) {
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_CHECKED);
|
|
SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
} else {
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_UNCHECKED);
|
|
SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
}
|
|
|
|
// Check or uncheck the minimize on use menu item
|
|
if (TaskManagerSettings.MinimizeOnUse)
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_CHECKED);
|
|
else
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_UNCHECKED);
|
|
|
|
// Check or uncheck the hide when minimized menu item
|
|
if (TaskManagerSettings.HideWhenMinimized)
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_CHECKED);
|
|
else
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_UNCHECKED);
|
|
|
|
// Check or uncheck the show 16-bit tasks menu item
|
|
if (TaskManagerSettings.Show16BitTasks)
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
|
|
else
|
|
CheckMenuItem(hEditMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_UNCHECKED);
|
|
|
|
if (TaskManagerSettings.View_LargeIcons)
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
|
|
else if (TaskManagerSettings.View_SmallIcons)
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
|
|
else
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
|
|
|
|
if (TaskManagerSettings.ShowKernelTimes)
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
|
|
else
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
|
|
|
|
if (TaskManagerSettings.UpdateSpeed == 1)
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_HIGH, MF_BYCOMMAND);
|
|
else if (TaskManagerSettings.UpdateSpeed == 2)
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_NORMAL, MF_BYCOMMAND);
|
|
else if (TaskManagerSettings.UpdateSpeed == 4)
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_LOW, MF_BYCOMMAND);
|
|
else
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_PAUSED, MF_BYCOMMAND);
|
|
|
|
if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
|
|
CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
|
|
else
|
|
CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
|
|
|
|
nActivePage = TaskManagerSettings.ActiveTabPage;
|
|
TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 0);
|
|
TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 1);
|
|
TabCtrl_SetCurFocus/*Sel*/(hTabWnd, 2);
|
|
TabCtrl_SetCurFocus/*Sel*/(hTabWnd, nActivePage);
|
|
|
|
if (TaskManagerSettings.UpdateSpeed == 0)
|
|
KillTimer(hWnd, 1);
|
|
else if (TaskManagerSettings.UpdateSpeed == 1)
|
|
{
|
|
KillTimer(hWnd, 1);
|
|
SetTimer(hWnd, 1, 1000, NULL);
|
|
}
|
|
else if (TaskManagerSettings.UpdateSpeed == 2)
|
|
{
|
|
KillTimer(hWnd, 1);
|
|
SetTimer(hWnd, 1, 2000, NULL);
|
|
}
|
|
else if (TaskManagerSettings.UpdateSpeed == 4)
|
|
{
|
|
KillTimer(hWnd, 1);
|
|
SetTimer(hWnd, 1, 4000, NULL);
|
|
}
|
|
|
|
//
|
|
// Refresh the performance data
|
|
// Sample it twice so we can establish
|
|
// the delta values & cpu usage
|
|
//
|
|
PerfDataRefresh();
|
|
PerfDataRefresh();
|
|
|
|
RefreshApplicationPage();
|
|
RefreshProcessPage();
|
|
RefreshPerformancePage();
|
|
|
|
TrayIcon_ShellAddTrayIcon();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// OnMove()
|
|
// This function handles all the moving events for the application
|
|
// It moves every child window that needs moving
|
|
void OnMove( UINT nType, int cx, int cy )
|
|
{
|
|
#ifdef __GNUC__TEST__
|
|
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);
|
|
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);
|
|
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);
|
|
#endif
|
|
}
|
|
|
|
// OnSize()
|
|
// This function handles all the sizing events for the application
|
|
// It re-sizes every window, and child window that needs re-sizing
|
|
void OnSize( UINT nType, int cx, int cy )
|
|
{
|
|
int nParts[3];
|
|
int nXDifference;
|
|
int nYDifference;
|
|
RECT rc;
|
|
|
|
if (nType == SIZE_MINIMIZED)
|
|
return;
|
|
|
|
nXDifference = cx - nOldWidth;
|
|
nYDifference = cy - nOldHeight;
|
|
nOldWidth = cx;
|
|
nOldHeight = cy;
|
|
|
|
// Update the status bar size
|
|
GetWindowRect(hStatusWnd, &rc);
|
|
SendMessage(hStatusWnd, WM_SIZE, nType, MAKELPARAM(cx, cy + (rc.bottom - rc.top)));
|
|
|
|
// Update the status bar pane sizes
|
|
nParts[0] = bInMenuLoop ? -1 : 100;
|
|
nParts[1] = 210;
|
|
nParts[2] = cx;
|
|
SendMessage(hStatusWnd, SB_SETPARTS, bInMenuLoop ? 1 : 3, (long)nParts);
|
|
|
|
// Resize the tab control
|
|
GetWindowRect(hTabWnd, &rc);
|
|
cx = (rc.right - rc.left) + nXDifference;
|
|
cy = (rc.bottom - rc.top) + nYDifference;
|
|
SetWindowPos(hTabWnd, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
|
|
|
|
// Resize the application page
|
|
GetWindowRect(hApplicationPage, &rc);
|
|
cx = (rc.right - rc.left) + nXDifference;
|
|
cy = (rc.bottom - rc.top) + nYDifference;
|
|
SetWindowPos(hApplicationPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
|
|
|
|
// Resize the process page
|
|
GetWindowRect(hProcessPage, &rc);
|
|
cx = (rc.right - rc.left) + nXDifference;
|
|
cy = (rc.bottom - rc.top) + nYDifference;
|
|
SetWindowPos(hProcessPage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
|
|
|
|
// Resize the performance page
|
|
GetWindowRect(hPerformancePage, &rc);
|
|
cx = (rc.right - rc.left) + nXDifference;
|
|
cy = (rc.bottom - rc.top) + nYDifference;
|
|
SetWindowPos(hPerformancePage, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
|
|
|
|
}
|
|
|
|
void LoadSettings(void)
|
|
{
|
|
HKEY hKey;
|
|
TCHAR szSubKey[] = _T("Software\\ReactWare\\TaskManager");
|
|
int i;
|
|
DWORD dwSize;
|
|
|
|
// Window size & position settings
|
|
TaskManagerSettings.Maximized = FALSE;
|
|
TaskManagerSettings.Left = 0;
|
|
TaskManagerSettings.Top = 0;
|
|
TaskManagerSettings.Right = 0;
|
|
TaskManagerSettings.Bottom = 0;
|
|
|
|
// Tab settings
|
|
TaskManagerSettings.ActiveTabPage = 0;
|
|
|
|
// Options menu settings
|
|
TaskManagerSettings.AlwaysOnTop = FALSE;
|
|
TaskManagerSettings.MinimizeOnUse = TRUE;
|
|
TaskManagerSettings.HideWhenMinimized = TRUE;
|
|
TaskManagerSettings.Show16BitTasks = TRUE;
|
|
|
|
// Update speed settings
|
|
TaskManagerSettings.UpdateSpeed = 2;
|
|
|
|
// Applications page settings
|
|
TaskManagerSettings.View_LargeIcons = FALSE;
|
|
TaskManagerSettings.View_SmallIcons = FALSE;
|
|
TaskManagerSettings.View_Details = TRUE;
|
|
|
|
// Processes page settings
|
|
TaskManagerSettings.ShowProcessesFromAllUsers = FALSE; // Server-only?
|
|
TaskManagerSettings.Column_ImageName = TRUE;
|
|
TaskManagerSettings.Column_PID = TRUE;
|
|
TaskManagerSettings.Column_CPUUsage = TRUE;
|
|
TaskManagerSettings.Column_CPUTime = TRUE;
|
|
TaskManagerSettings.Column_MemoryUsage = TRUE;
|
|
TaskManagerSettings.Column_MemoryUsageDelta = FALSE;
|
|
TaskManagerSettings.Column_PeakMemoryUsage = FALSE;
|
|
TaskManagerSettings.Column_PageFaults = FALSE;
|
|
TaskManagerSettings.Column_USERObjects = FALSE;
|
|
TaskManagerSettings.Column_IOReads = FALSE;
|
|
TaskManagerSettings.Column_IOReadBytes = FALSE;
|
|
TaskManagerSettings.Column_SessionID = FALSE; // Server-only?
|
|
TaskManagerSettings.Column_UserName = FALSE; // Server-only?
|
|
TaskManagerSettings.Column_PageFaultsDelta = FALSE;
|
|
TaskManagerSettings.Column_VirtualMemorySize = FALSE;
|
|
TaskManagerSettings.Column_PagedPool = FALSE;
|
|
TaskManagerSettings.Column_NonPagedPool = FALSE;
|
|
TaskManagerSettings.Column_BasePriority = FALSE;
|
|
TaskManagerSettings.Column_HandleCount = FALSE;
|
|
TaskManagerSettings.Column_ThreadCount = FALSE;
|
|
TaskManagerSettings.Column_GDIObjects = FALSE;
|
|
TaskManagerSettings.Column_IOWrites = FALSE;
|
|
TaskManagerSettings.Column_IOWriteBytes = FALSE;
|
|
TaskManagerSettings.Column_IOOther = FALSE;
|
|
TaskManagerSettings.Column_IOOtherBytes = FALSE;
|
|
|
|
for (i = 0; i < 25; i++) {
|
|
TaskManagerSettings.ColumnOrderArray[i] = i;
|
|
}
|
|
TaskManagerSettings.ColumnSizeArray[0] = 105;
|
|
TaskManagerSettings.ColumnSizeArray[1] = 50;
|
|
TaskManagerSettings.ColumnSizeArray[2] = 107;
|
|
TaskManagerSettings.ColumnSizeArray[3] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[4] = 35;
|
|
TaskManagerSettings.ColumnSizeArray[5] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[6] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[7] = 100;
|
|
TaskManagerSettings.ColumnSizeArray[8] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[9] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[10] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[11] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[12] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[13] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[14] = 60;
|
|
TaskManagerSettings.ColumnSizeArray[15] = 60;
|
|
TaskManagerSettings.ColumnSizeArray[16] = 60;
|
|
TaskManagerSettings.ColumnSizeArray[17] = 60;
|
|
TaskManagerSettings.ColumnSizeArray[18] = 60;
|
|
TaskManagerSettings.ColumnSizeArray[19] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[20] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[21] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[22] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[23] = 70;
|
|
TaskManagerSettings.ColumnSizeArray[24] = 70;
|
|
|
|
TaskManagerSettings.SortColumn = 1;
|
|
TaskManagerSettings.SortAscending = TRUE;
|
|
|
|
// Performance page settings
|
|
TaskManagerSettings.CPUHistory_OneGraphPerCPU = TRUE;
|
|
TaskManagerSettings.ShowKernelTimes = FALSE;
|
|
|
|
// Open the key
|
|
if (RegOpenKeyEx(HKEY_CURRENT_USER, szSubKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
|
|
return;
|
|
// Read the settings
|
|
dwSize = sizeof(TASKMANAGER_SETTINGS);
|
|
RegQueryValueEx(hKey, _T("Preferences"), NULL, NULL, (LPBYTE)&TaskManagerSettings, &dwSize);
|
|
|
|
// Close the key
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
void SaveSettings(void)
|
|
{
|
|
HKEY hKey;
|
|
TCHAR szSubKey1[] = _T("Software");
|
|
TCHAR szSubKey2[] = _T("Software\\ReactWare");
|
|
TCHAR szSubKey3[] = _T("Software\\ReactWare\\TaskManager");
|
|
|
|
// Open (or create) the key
|
|
hKey = NULL;
|
|
RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey1, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
|
|
RegCloseKey(hKey);
|
|
hKey = NULL;
|
|
RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey2, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
|
|
RegCloseKey(hKey);
|
|
hKey = NULL;
|
|
if (RegCreateKeyEx(HKEY_CURRENT_USER, szSubKey3, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
|
|
return;
|
|
// Save the settings
|
|
RegSetValueEx(hKey, _T("Preferences"), 0, REG_BINARY, (LPBYTE)&TaskManagerSettings, sizeof(TASKMANAGER_SETTINGS));
|
|
// Close the key
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
void TaskManager_OnEnterMenuLoop(HWND hWnd)
|
|
{
|
|
int nParts;
|
|
|
|
// Update the status bar pane sizes
|
|
nParts = -1;
|
|
SendMessage(hStatusWnd, SB_SETPARTS, 1, (long)&nParts);
|
|
bInMenuLoop = TRUE;
|
|
SendMessage(hStatusWnd, SB_SETTEXT, (WPARAM)0, (LPARAM)_T(""));
|
|
}
|
|
|
|
void TaskManager_OnExitMenuLoop(HWND hWnd)
|
|
{
|
|
RECT rc;
|
|
int nParts[3];
|
|
TCHAR text[260];
|
|
|
|
bInMenuLoop = FALSE;
|
|
// Update the status bar pane sizes
|
|
GetClientRect(hWnd, &rc);
|
|
nParts[0] = 100;
|
|
nParts[1] = 210;
|
|
nParts[2] = rc.right;
|
|
SendMessage(hStatusWnd, SB_SETPARTS, 3, (long)nParts);
|
|
SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)_T(""));
|
|
wsprintf(text, _T("CPU Usage: %3d%%"), PerfDataGetProcessorUsage());
|
|
SendMessage(hStatusWnd, SB_SETTEXT, 1, (LPARAM)text);
|
|
wsprintf(text, _T("Processes: %d"), PerfDataGetProcessCount());
|
|
SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)text);
|
|
}
|
|
|
|
void TaskManager_OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
|
|
{
|
|
TCHAR str[100];
|
|
|
|
_tcscpy(str, TEXT(""));
|
|
if (LoadString(hInst, nItemID, str, 100)) {
|
|
// load appropriate string
|
|
LPTSTR lpsz = str;
|
|
// first newline terminates actual string
|
|
lpsz = _tcschr(lpsz, '\n');
|
|
if (lpsz != NULL)
|
|
*lpsz = '\0';
|
|
}
|
|
SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)str);
|
|
}
|
|
|
|
void TaskManager_OnViewUpdateSpeedHigh(void)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hUpdateSpeedMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
|
|
|
|
TaskManagerSettings.UpdateSpeed = 1;
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_HIGH, MF_BYCOMMAND);
|
|
|
|
KillTimer(hMainWnd, 1);
|
|
SetTimer(hMainWnd, 1, 1000, NULL);
|
|
}
|
|
|
|
void TaskManager_OnViewUpdateSpeedNormal(void)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hUpdateSpeedMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
|
|
|
|
TaskManagerSettings.UpdateSpeed = 2;
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_NORMAL, MF_BYCOMMAND);
|
|
|
|
KillTimer(hMainWnd, 1);
|
|
SetTimer(hMainWnd, 1, 2000, NULL);
|
|
}
|
|
|
|
void TaskManager_OnViewUpdateSpeedLow(void)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hUpdateSpeedMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
|
|
|
|
TaskManagerSettings.UpdateSpeed = 4;
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_LOW, MF_BYCOMMAND);
|
|
|
|
KillTimer(hMainWnd, 1);
|
|
SetTimer(hMainWnd, 1, 4000, NULL);
|
|
}
|
|
|
|
void TaskManager_OnViewRefresh(void)
|
|
{
|
|
PostMessage(hMainWnd, WM_TIMER, 0, 0);
|
|
}
|
|
|
|
void TaskManager_OnViewUpdateSpeedPaused(void)
|
|
{
|
|
HMENU hMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hUpdateSpeedMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hUpdateSpeedMenu = GetSubMenu(hViewMenu, 1);
|
|
TaskManagerSettings.UpdateSpeed = 0;
|
|
CheckMenuRadioItem(hUpdateSpeedMenu, ID_VIEW_UPDATESPEED_HIGH, ID_VIEW_UPDATESPEED_PAUSED, ID_VIEW_UPDATESPEED_PAUSED, MF_BYCOMMAND);
|
|
KillTimer(hMainWnd, 1);
|
|
}
|
|
|
|
void TaskManager_OnTabWndSelChange(void)
|
|
{
|
|
int i;
|
|
HMENU hMenu;
|
|
HMENU hOptionsMenu;
|
|
HMENU hViewMenu;
|
|
HMENU hSubMenu;
|
|
|
|
hMenu = GetMenu(hMainWnd);
|
|
hViewMenu = GetSubMenu(hMenu, 2);
|
|
hOptionsMenu = GetSubMenu(hMenu, 1);
|
|
TaskManagerSettings.ActiveTabPage = TabCtrl_GetCurSel(hTabWnd);
|
|
for (i = GetMenuItemCount(hViewMenu) - 1; i > 2; i--) {
|
|
hSubMenu = GetSubMenu(hViewMenu, i);
|
|
if (hSubMenu)
|
|
DestroyMenu(hSubMenu);
|
|
RemoveMenu(hViewMenu, i, MF_BYPOSITION);
|
|
}
|
|
RemoveMenu(hOptionsMenu, 3, MF_BYPOSITION);
|
|
switch (TaskManagerSettings.ActiveTabPage) {
|
|
case 0:
|
|
ShowWindow(hApplicationPage, SW_SHOW);
|
|
ShowWindow(hProcessPage, SW_HIDE);
|
|
ShowWindow(hPerformancePage, SW_HIDE);
|
|
BringWindowToTop(hApplicationPage);
|
|
AppendMenu(hViewMenu, MF_STRING, ID_VIEW_LARGE, _T("Lar&ge Icons"));
|
|
AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SMALL, _T("S&mall Icons"));
|
|
AppendMenu(hViewMenu, MF_STRING, ID_VIEW_DETAILS, _T("&Details"));
|
|
|
|
if (GetMenuItemCount(hMenu) <= 4) {
|
|
hSubMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_WINDOWSMENU));
|
|
InsertMenu(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT)hSubMenu, _T("&Windows"));
|
|
DrawMenuBar(hMainWnd);
|
|
}
|
|
if (TaskManagerSettings.View_LargeIcons)
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
|
|
else if (TaskManagerSettings.View_SmallIcons)
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
|
|
else
|
|
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
|
|
//
|
|
// Give the application list control focus
|
|
//
|
|
SetFocus(hApplicationPageListCtrl);
|
|
break;
|
|
|
|
case 1:
|
|
ShowWindow(hApplicationPage, SW_HIDE);
|
|
ShowWindow(hProcessPage, SW_SHOW);
|
|
ShowWindow(hPerformancePage, SW_HIDE);
|
|
BringWindowToTop(hProcessPage);
|
|
AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SELECTCOLUMNS, _T("&Select Columns..."));
|
|
AppendMenu(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, _T("&Show 16-bit tasks"));
|
|
if (TaskManagerSettings.Show16BitTasks)
|
|
CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
|
|
if (GetMenuItemCount(hMenu) > 4)
|
|
{
|
|
RemoveMenu(hMenu, 3, MF_BYPOSITION);
|
|
DrawMenuBar(hMainWnd);
|
|
}
|
|
//
|
|
// Give the process list control focus
|
|
//
|
|
SetFocus(hProcessPageListCtrl);
|
|
break;
|
|
|
|
case 2:
|
|
ShowWindow(hApplicationPage, SW_HIDE);
|
|
ShowWindow(hProcessPage, SW_HIDE);
|
|
ShowWindow(hPerformancePage, SW_SHOW);
|
|
BringWindowToTop(hPerformancePage);
|
|
if (GetMenuItemCount(hMenu) > 4) {
|
|
RemoveMenu(hMenu, 3, MF_BYPOSITION);
|
|
DrawMenuBar(hMainWnd);
|
|
}
|
|
hSubMenu = CreatePopupMenu();
|
|
AppendMenu(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHALL, _T("&One Graph, All CPUs"));
|
|
AppendMenu(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, _T("One Graph &Per CPU"));
|
|
AppendMenu(hViewMenu, MF_STRING|MF_POPUP, (UINT)hSubMenu, _T("&CPU History"));
|
|
AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, _T("&Show Kernel Times"));
|
|
if (TaskManagerSettings.ShowKernelTimes)
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
|
|
else
|
|
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
|
|
if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
|
|
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
|
|
else
|
|
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
|
|
//
|
|
// Give the tab control focus
|
|
//
|
|
SetFocus(hTabWnd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize)
|
|
{
|
|
DWORD dwRet;
|
|
LPTSTR lpszTemp = NULL;
|
|
|
|
dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
NULL,
|
|
GetLastError(),
|
|
LANG_NEUTRAL,
|
|
(LPTSTR)&lpszTemp,
|
|
0,
|
|
NULL );
|
|
|
|
// supplied buffer is not long enough
|
|
if (!dwRet || ( (long)dwSize < (long)dwRet+14)) {
|
|
lpszBuf[0] = TEXT('\0');
|
|
} else {
|
|
lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0'); //remove cr and newline character
|
|
_stprintf(lpszBuf, TEXT("%s (0x%x)"), lpszTemp, (int)GetLastError());
|
|
}
|
|
if (lpszTemp) {
|
|
LocalFree((HLOCAL)lpszTemp);
|
|
}
|
|
return lpszBuf;
|
|
}
|