diff --git a/rosapps/taskmgr/ApplicationPage.cpp b/rosapps/taskmgr/ApplicationPage.cpp
new file mode 100644
index 00000000000..467022a9920
--- /dev/null
+++ b/rosapps/taskmgr/ApplicationPage.cpp
@@ -0,0 +1,1016 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  applicationpage.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "TASKMGR.h"
+#include "ApplicationPage.h"
+#include "ProcessPage.h"
+
+typedef struct
+{
+	HWND	hWnd;
+	char	szTitle[260];
+	HICON	hIcon;
+	BOOL	bHung;
+} APPLICATION_PAGE_LIST_ITEM, *LPAPPLICATION_PAGE_LIST_ITEM;
+
+HWND			hApplicationPage;				// Application List Property Page
+
+HWND			hApplicationPageListCtrl;		// Application ListCtrl Window
+HWND			hApplicationPageEndTaskButton;	// Application End Task button
+HWND			hApplicationPageSwitchToButton;	// Application Switch To button
+HWND			hApplicationPageNewTaskButton;	// Application New Task button
+
+static int		nApplicationPageWidth;
+static int		nApplicationPageHeight;
+
+static HANDLE	hApplicationPageEvent = NULL;	// When this event becomes signaled then we refresh the app list
+
+static BOOL		bSortAscending = TRUE;
+
+void			ApplicationPageRefreshThread(void *lpParameter);
+BOOL CALLBACK	EnumWindowsProc(HWND hWnd, LPARAM lParam);
+void			AddOrUpdateHwnd(HWND hWnd, char *szTitle, HICON hIcon, BOOL bHung);
+void			ApplicationPageUpdate(void);
+void			ApplicationPageOnNotify(WPARAM wParam, LPARAM lParam);
+void			ApplicationPageShowContextMenu1(void);
+void			ApplicationPageShowContextMenu2(void);
+int	CALLBACK	ApplicationPageCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
+
+void SwitchToThisWindow (
+HWND hWnd,   // Handle to the window that should be activated
+BOOL bRestore // Restore the window if it is minimized
+);
+
+LRESULT CALLBACK ApplicationPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	RECT		rc;
+	int			nXDifference;
+	int			nYDifference;
+	LV_COLUMN	column;
+	char		szTemp[256];
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		// Save the width and height
+		GetClientRect(hDlg, &rc);
+		nApplicationPageWidth = rc.right;
+		nApplicationPageHeight = rc.bottom;
+
+		// Update window position
+		SetWindowPos(hDlg, NULL, 15, 30, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+
+		// Get handles to the controls
+		hApplicationPageListCtrl = GetDlgItem(hDlg, IDC_APPLIST);
+		hApplicationPageEndTaskButton = GetDlgItem(hDlg, IDC_ENDTASK);
+		hApplicationPageSwitchToButton = GetDlgItem(hDlg, IDC_SWITCHTO);
+		hApplicationPageNewTaskButton = GetDlgItem(hDlg, IDC_NEWTASK);
+
+		SetWindowText(hApplicationPageListCtrl, "Tasks");
+
+		// Initialize the application page's controls
+		column.mask = LVCF_TEXT|LVCF_WIDTH;
+		strcpy(szTemp, "Task");
+		column.pszText = szTemp;
+		column.cx = 250;
+		ListView_InsertColumn(hApplicationPageListCtrl, 0, &column);	// Add the "Task" column
+		column.mask = LVCF_TEXT|LVCF_WIDTH;
+		strcpy(szTemp, "Status");
+		column.pszText = szTemp;
+		column.cx = 95;
+		ListView_InsertColumn(hApplicationPageListCtrl, 1, &column);	// Add the "Status" column
+
+		ListView_SetImageList(hApplicationPageListCtrl, ImageList_Create(16, 16, ILC_COLOR8|ILC_MASK, 0, 1), LVSIL_SMALL);
+		ListView_SetImageList(hApplicationPageListCtrl, ImageList_Create(32, 32, ILC_COLOR8|ILC_MASK, 0, 1), LVSIL_NORMAL);
+
+		UpdateApplicationListControlViewSetting();
+
+		// Start our refresh thread
+		_beginthread(ApplicationPageRefreshThread, 0, NULL);
+
+		return TRUE;
+
+	case WM_DESTROY:
+		// Close the event handle, this will make the
+		// refresh thread exit when the wait fails
+		CloseHandle(hApplicationPageEvent);
+		break;
+
+	case WM_COMMAND:
+
+		// Handle the button clicks
+		switch (LOWORD(wParam))
+		{
+		case IDC_ENDTASK:
+			ApplicationPage_OnEndTask();
+			break;
+		case IDC_SWITCHTO:
+			ApplicationPage_OnSwitchTo();
+			break;
+		case IDC_NEWTASK:
+			SendMessage(hMainWnd, WM_COMMAND, MAKEWPARAM(ID_FILE_NEW, 0), NULL);
+			break;
+		}
+
+		break;
+
+	case WM_SIZE:
+		int		cx, cy;
+
+		if (wParam == SIZE_MINIMIZED)
+			return 0;
+
+		cx = LOWORD(lParam);
+		cy = HIWORD(lParam);
+		nXDifference = cx - nApplicationPageWidth;
+		nYDifference = cy - nApplicationPageHeight;
+		nApplicationPageWidth = cx;
+		nApplicationPageHeight = cy;
+
+		// Reposition the application page's controls
+		GetWindowRect(hApplicationPageListCtrl, &rc);
+		cx = (rc.right - rc.left) + nXDifference;
+		cy = (rc.bottom - rc.top) + nYDifference;
+		SetWindowPos(hApplicationPageListCtrl, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageListCtrl, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageEndTaskButton, &rc);
+		MapWindowPoints(hApplicationPageEndTaskButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageEndTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageEndTaskButton, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageSwitchToButton, &rc);
+		MapWindowPoints(hApplicationPageSwitchToButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageSwitchToButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageSwitchToButton, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageNewTaskButton, &rc);
+		MapWindowPoints(hApplicationPageNewTaskButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageNewTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageNewTaskButton, NULL, TRUE);
+
+		break;
+
+	case WM_NOTIFY:
+
+		ApplicationPageOnNotify(wParam, lParam);
+		break;
+	}
+
+    return 0;
+}
+
+void RefreshApplicationPage(void)
+{
+	// Signal the event so that our refresh thread
+	// will wake up and refresh the application page
+	SetEvent(hApplicationPageEvent);
+}
+
+void UpdateApplicationListControlViewSetting(void)
+{
+	DWORD	dwStyle = GetWindowLong(hApplicationPageListCtrl, GWL_STYLE);
+
+	dwStyle &= ~LVS_REPORT;
+	dwStyle &= ~LVS_ICON;
+	dwStyle &= ~LVS_LIST;
+	dwStyle &= ~LVS_SMALLICON;
+
+	if (TaskManagerSettings.View_LargeIcons)
+		dwStyle |= LVS_ICON;
+	else if (TaskManagerSettings.View_SmallIcons)
+		dwStyle |= LVS_SMALLICON;
+	else
+		dwStyle |= LVS_REPORT;
+
+	SetWindowLong(hApplicationPageListCtrl, GWL_STYLE, dwStyle);
+
+	RefreshApplicationPage();
+}
+
+void ApplicationPageRefreshThread(void *lpParameter)
+{
+	// Create the event
+	hApplicationPageEvent = CreateEvent(NULL, TRUE, TRUE, "Application Page Event");
+
+	// If we couldn't create the event then exit the thread
+	if (!hApplicationPageEvent)
+		return;
+
+	while (1)
+	{
+		DWORD	dwWaitVal;
+
+		// Wait on the event
+		dwWaitVal = WaitForSingleObject(hApplicationPageEvent, INFINITE);
+
+		// If the wait failed then the event object must have been
+		// closed and the task manager is exiting so exit this thread
+		if (dwWaitVal == WAIT_FAILED)
+			return;
+
+		if (dwWaitVal == WAIT_OBJECT_0)
+		{
+			// Reset our event
+			ResetEvent(hApplicationPageEvent);
+
+			/*
+			 * FIXME:
+			 *
+			 * Should this be EnumDesktopWindows() instead?
+			 */
+			EnumWindows(EnumWindowsProc, NULL);
+		}
+	}
+}
+
+BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam)
+{
+	HICON		hIcon;
+	char		szText[260];
+	BOOL		bLargeIcon;
+
+	// Skip our window
+	if (hWnd == hMainWnd)
+		return TRUE;
+
+	bLargeIcon = TaskManagerSettings.View_LargeIcons ? TRUE : FALSE;
+
+	GetWindowText(hWnd, szText, 260); // Get the window text
+
+	// Get the icon for this window
+	hIcon = NULL;
+	SendMessageTimeout(hWnd, WM_GETICON, bLargeIcon ? ICON_BIG /*1*/ : ICON_SMALL /*0*/, 0, 0, 1000, (unsigned long*)&hIcon);
+
+	if (!hIcon)
+	{
+		hIcon = (HICON)GetClassLong(hWnd, bLargeIcon ? GCL_HICON : GCL_HICONSM);
+		if (!hIcon)	hIcon = (HICON)GetClassLong(hWnd, bLargeIcon ? GCL_HICONSM : GCL_HICON);
+		if (!hIcon)	SendMessageTimeout(hWnd, WM_QUERYDRAGICON, 0, 0, 0, 1000, (unsigned long*)&hIcon);
+		if (!hIcon)	SendMessageTimeout(hWnd, WM_GETICON, bLargeIcon ? ICON_SMALL /*0*/ : ICON_BIG /*1*/, 0, 0, 1000, (unsigned long*)&hIcon);
+	}
+
+	if (!hIcon)
+		hIcon = LoadIcon(hInst, bLargeIcon ? MAKEINTRESOURCE(IDI_WINDOW) : MAKEINTRESOURCE(IDI_WINDOWSM));
+
+	// Check and see if this is a top-level app window
+	if ((strlen(szText) <= 0) ||
+		!IsWindowVisible(hWnd) ||
+		(GetParent(hWnd) != NULL) ||
+		(GetWindow(hWnd, GW_OWNER) != NULL) ||
+		(GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW))
+	{
+		return TRUE; // Skip this window
+	}
+
+	BOOL	bHung = FALSE;
+
+	typedef int (FAR __stdcall *IsHungAppWindowProc)(HWND);
+	IsHungAppWindowProc IsHungAppWindow;
+
+	IsHungAppWindow = (IsHungAppWindowProc)(FARPROC)GetProcAddress(GetModuleHandle("USER32.DLL"), "IsHungAppWindow");
+
+	if (IsHungAppWindow)
+		bHung = IsHungAppWindow(hWnd);
+
+	AddOrUpdateHwnd(hWnd, szText, hIcon, bHung);
+
+	return TRUE;
+}
+
+void AddOrUpdateHwnd(HWND hWnd, char *szTitle, HICON hIcon, BOOL bHung)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	HIMAGELIST						hImageListLarge;
+	HIMAGELIST						hImageListSmall;
+	LV_ITEM							item;
+	int								i;
+	BOOL							bAlreadyInList = FALSE;
+	BOOL							bItemRemoved = FALSE;
+
+	memset(&item, 0, sizeof(LV_ITEM));
+
+	// Get the image lists
+	hImageListLarge = ListView_GetImageList(hApplicationPageListCtrl, LVSIL_NORMAL);
+	hImageListSmall = ListView_GetImageList(hApplicationPageListCtrl, LVSIL_SMALL);
+
+	// Check to see if it's already in our list
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_IMAGE|LVIF_PARAM;
+		item.iItem = i;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+		if (pAPLI->hWnd == hWnd)
+		{
+			bAlreadyInList = TRUE;
+			break;
+		}
+	}
+
+	// If it is already in the list then update it if necessary
+	if (bAlreadyInList)
+	{
+		// Check to see if anything needs updating
+		if ((pAPLI->hIcon != hIcon) ||
+			(stricmp(pAPLI->szTitle, szTitle) != 0) ||
+			(pAPLI->bHung != bHung))
+		{
+			// Update the structure
+			pAPLI->hIcon = hIcon;
+			pAPLI->bHung = bHung;
+			strcpy(pAPLI->szTitle, szTitle);
+
+			// Update the image list
+			ImageList_ReplaceIcon(hImageListLarge, item.iItem, hIcon);
+			ImageList_ReplaceIcon(hImageListSmall, item.iItem, hIcon);
+
+			// Update the list view
+			ListView_RedrawItems(hApplicationPageListCtrl, 0, ListView_GetItemCount(hApplicationPageListCtrl));
+			UpdateWindow(hApplicationPageListCtrl);
+		}
+	}
+	// It is not already in the list so add it
+	else
+	{
+		pAPLI = new APPLICATION_PAGE_LIST_ITEM;
+
+		pAPLI->hWnd = hWnd;
+		pAPLI->hIcon = hIcon;
+		pAPLI->bHung = bHung;
+		strcpy(pAPLI->szTitle, szTitle);
+
+		// Add the item to the list
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
+		ImageList_AddIcon(hImageListLarge, hIcon);
+		item.iImage = ImageList_AddIcon(hImageListSmall, hIcon);
+		item.pszText = LPSTR_TEXTCALLBACK;
+		item.iItem = ListView_GetItemCount(hApplicationPageListCtrl);
+		item.lParam = (LPARAM)pAPLI;
+		ListView_InsertItem(hApplicationPageListCtrl, &item);
+	}
+
+
+	// Check to see if we need to remove any items from the list
+	for (i=ListView_GetItemCount(hApplicationPageListCtrl)-1; i>=0; i--)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_IMAGE|LVIF_PARAM;
+		item.iItem = i;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+		if (!IsWindow(pAPLI->hWnd)||
+			(strlen(pAPLI->szTitle) <= 0) ||
+			!IsWindowVisible(pAPLI->hWnd) ||
+			(GetParent(pAPLI->hWnd) != NULL) ||
+			(GetWindow(pAPLI->hWnd, GW_OWNER) != NULL) ||
+			(GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW))
+		{
+			ImageList_Remove(hImageListLarge, item.iItem);
+			ImageList_Remove(hImageListSmall, item.iItem);
+
+			ListView_DeleteItem(hApplicationPageListCtrl, item.iItem);
+			delete pAPLI;
+			bItemRemoved = TRUE;
+		}
+	}
+
+	//
+	// If an item was removed from the list then
+	// we need to resync all the items with the
+	// image list
+	//
+	if (bItemRemoved)
+	{
+		for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+		{
+			memset(&item, 0, sizeof(LV_ITEM));
+			item.mask = LVIF_IMAGE;
+			item.iItem = i;
+			item.iImage = i;
+			ListView_SetItem(hApplicationPageListCtrl, &item);
+		}
+	}
+
+	ApplicationPageUpdate();
+}
+
+void ApplicationPageUpdate(void)
+{
+	// Enable or disable the "End Task" & "Switch To" buttons
+	if (ListView_GetSelectedCount(hApplicationPageListCtrl))
+	{
+		EnableWindow(hApplicationPageEndTaskButton, TRUE);
+		EnableWindow(hApplicationPageSwitchToButton, TRUE);
+	}
+	else
+	{
+		EnableWindow(hApplicationPageEndTaskButton, FALSE);
+		EnableWindow(hApplicationPageSwitchToButton, FALSE);
+	}
+
+	// If we are on the applications tab the the windows menu will
+	// be present on the menu bar so enable & disable the menu items
+	if (TabCtrl_GetCurSel(hTabWnd) == 0)
+	{
+		HMENU	hMenu;
+		HMENU	hWindowsMenu;
+
+		hMenu = GetMenu(hMainWnd);
+		hWindowsMenu = GetSubMenu(hMenu, 3);
+
+		// Only one item selected
+		if (ListView_GetSelectedCount(hApplicationPageListCtrl) == 1)
+		{
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_ENABLED);
+		}
+		// More than one item selected
+		else if (ListView_GetSelectedCount(hApplicationPageListCtrl) > 1)
+		{
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_ENABLED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		}
+		// No items selected
+		else
+		{
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+			EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		}
+	}
+}
+
+void ApplicationPageOnNotify(WPARAM wParam, LPARAM lParam)
+{
+	int				idctrl;
+	LPNMHDR			pnmh;
+	LPNM_LISTVIEW	pnmv;
+	LV_DISPINFO*	pnmdi;
+
+	idctrl = (int) wParam;
+	pnmh = (LPNMHDR) lParam;
+	pnmv = (LPNM_LISTVIEW) lParam;
+	pnmdi = (LV_DISPINFO*) lParam;
+
+	if (pnmh->hwndFrom == hApplicationPageListCtrl)
+	{
+		switch (pnmh->code)
+		{
+		case LVN_ITEMCHANGED:
+			ApplicationPageUpdate();
+			break;
+			
+		case LVN_GETDISPINFO:
+			LPAPPLICATION_PAGE_LIST_ITEM	pAPLI;
+
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)pnmdi->item.lParam;
+
+			// Update the item text
+			if (pnmdi->item.iSubItem == 0)
+			{
+				strncpy(pnmdi->item.pszText, pAPLI->szTitle, pnmdi->item.cchTextMax);
+			}
+
+			// Update the item status
+			else if (pnmdi->item.iSubItem == 1)
+			{
+				if (pAPLI->bHung)
+					strncpy(pnmdi->item.pszText, "Not Responding", pnmdi->item.cchTextMax);
+				else
+					strncpy(pnmdi->item.pszText, "Running", pnmdi->item.cchTextMax);
+			}
+
+			break;
+
+		case NM_RCLICK:
+
+			if (ListView_GetSelectedCount(hApplicationPageListCtrl) < 1)
+			{
+				ApplicationPageShowContextMenu1();
+			}
+			else
+			{
+				ApplicationPageShowContextMenu2();
+			}
+
+			break;
+
+		case NM_DBLCLK:
+
+			ApplicationPage_OnSwitchTo();
+
+			break;
+		}
+	}
+	else if (pnmh->hwndFrom == ListView_GetHeader(hApplicationPageListCtrl))
+	{
+		switch (pnmh->code)
+		{
+		case NM_RCLICK:
+
+			if (ListView_GetSelectedCount(hApplicationPageListCtrl) < 1)
+			{
+				ApplicationPageShowContextMenu1();
+			}
+			else
+			{
+				ApplicationPageShowContextMenu2();
+			}
+
+			break;
+
+		case HDN_ITEMCLICK:
+
+			ListView_SortItems(hApplicationPageListCtrl, ApplicationPageCompareFunc, NULL);
+			bSortAscending = !bSortAscending;
+
+			break;
+		}
+	}
+
+}
+
+void ApplicationPageShowContextMenu1(void)
+{
+	HMENU	hMenu;
+	HMENU	hSubMenu;
+	POINT	pt;
+
+	GetCursorPos(&pt);
+
+	hMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_APPLICATION_PAGE_CONTEXT1));
+	hSubMenu = GetSubMenu(hMenu, 0);
+
+	if (TaskManagerSettings.View_LargeIcons)
+		CheckMenuRadioItem(hSubMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
+	else if (TaskManagerSettings.View_SmallIcons)
+		CheckMenuRadioItem(hSubMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
+	else
+		CheckMenuRadioItem(hSubMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
+
+	TrackPopupMenu(hSubMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_LEFTBUTTON, pt.x, pt.y, 0, hMainWnd, NULL);
+
+	DestroyMenu(hMenu);
+}
+
+void ApplicationPageShowContextMenu2(void)
+{
+	HMENU	hMenu;
+	HMENU	hSubMenu;
+	POINT	pt;
+
+	GetCursorPos(&pt);
+
+	hMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_APPLICATION_PAGE_CONTEXT2));
+	hSubMenu = GetSubMenu(hMenu, 0);
+
+	if (ListView_GetSelectedCount(hApplicationPageListCtrl) == 1)
+	{
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_ENABLED);
+	}
+	else if (ListView_GetSelectedCount(hApplicationPageListCtrl) > 1)
+	{
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_ENABLED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+	}
+	else
+	{
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		EnableMenuItem(hSubMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+	}
+
+	SetMenuDefaultItem(hSubMenu, ID_APPLICATION_PAGE_SWITCHTO, MF_BYCOMMAND);
+
+	TrackPopupMenu(hSubMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_LEFTBUTTON, pt.x, pt.y, 0, hMainWnd, NULL);
+
+	DestroyMenu(hMenu);
+}
+
+void ApplicationPage_OnViewLargeIcons(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+
+	TaskManagerSettings.View_LargeIcons = TRUE;
+	TaskManagerSettings.View_SmallIcons = FALSE;
+	TaskManagerSettings.View_Details = FALSE;
+	CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
+
+	UpdateApplicationListControlViewSetting();
+}
+
+void ApplicationPage_OnViewSmallIcons(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+
+	TaskManagerSettings.View_LargeIcons = FALSE;
+	TaskManagerSettings.View_SmallIcons = TRUE;
+	TaskManagerSettings.View_Details = FALSE;
+	CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
+
+	UpdateApplicationListControlViewSetting();
+}
+
+void ApplicationPage_OnViewDetails(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+
+	TaskManagerSettings.View_LargeIcons = FALSE;
+	TaskManagerSettings.View_SmallIcons = FALSE;
+	TaskManagerSettings.View_Details = TRUE;
+	CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
+
+	UpdateApplicationListControlViewSetting();
+}
+
+void ApplicationPage_OnWindowsTileHorizontally(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+	HWND*							hWndArray;
+	int								nWndCount;
+
+	hWndArray = new HWND[ListView_GetItemCount(hApplicationPageListCtrl)];
+	nWndCount = 0;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				hWndArray[nWndCount] = pAPLI->hWnd;
+				nWndCount++;
+			}
+		}
+	}
+
+	TileWindows(NULL, MDITILE_HORIZONTAL, NULL, nWndCount, hWndArray);
+
+	delete[] hWndArray;
+}
+
+void ApplicationPage_OnWindowsTileVertically(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+	HWND*							hWndArray;
+	int								nWndCount;
+
+	hWndArray = new HWND[ListView_GetItemCount(hApplicationPageListCtrl)];
+	nWndCount = 0;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				hWndArray[nWndCount] = pAPLI->hWnd;
+				nWndCount++;
+			}
+		}
+	}
+
+	TileWindows(NULL, MDITILE_VERTICAL, NULL, nWndCount, hWndArray);
+
+	delete[] hWndArray;
+}
+
+void ApplicationPage_OnWindowsMinimize(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				ShowWindow(pAPLI->hWnd, SW_MINIMIZE);
+			}
+		}
+	}
+}
+
+void ApplicationPage_OnWindowsMaximize(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				ShowWindow(pAPLI->hWnd, SW_MAXIMIZE);
+			}
+		}
+	}
+}
+
+void ApplicationPage_OnWindowsCascade(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+	HWND*							hWndArray;
+	int								nWndCount;
+
+	hWndArray = new HWND[ListView_GetItemCount(hApplicationPageListCtrl)];
+	nWndCount = 0;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				hWndArray[nWndCount] = pAPLI->hWnd;
+				nWndCount++;
+			}
+		}
+	}
+
+	CascadeWindows(NULL, 0, NULL, nWndCount, hWndArray);
+
+	delete[] hWndArray;
+}
+
+void ApplicationPage_OnWindowsBringToFront(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+			break;
+		}
+	}
+
+	if (pAPLI)
+	{
+		if (IsIconic(pAPLI->hWnd))
+			ShowWindow(pAPLI->hWnd, SW_RESTORE);
+
+		BringWindowToTop(pAPLI->hWnd);
+	}
+}
+
+void ApplicationPage_OnSwitchTo(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+			break;
+		}
+	}
+
+	if (pAPLI)
+	{
+		typedef void (WINAPI *PROCSWITCHTOTHISWINDOW) (HWND, BOOL);
+		PROCSWITCHTOTHISWINDOW SwitchToThisWindow;
+
+		HMODULE hUser32 = GetModuleHandle("user32");
+
+		SwitchToThisWindow = (PROCSWITCHTOTHISWINDOW)GetProcAddress(hUser32, "SwitchToThisWindow");
+
+
+		if (SwitchToThisWindow)
+			SwitchToThisWindow(pAPLI->hWnd, TRUE);
+		else
+		{
+			if (IsIconic(pAPLI->hWnd))
+				ShowWindow(pAPLI->hWnd, SW_RESTORE);
+
+			BringWindowToTop(pAPLI->hWnd);
+			SetForegroundWindow(pAPLI->hWnd);
+		}
+
+		if (TaskManagerSettings.MinimizeOnUse)
+			ShowWindow(hMainWnd, SW_MINIMIZE);
+	}
+}
+
+void ApplicationPage_OnEndTask(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+
+			if (pAPLI)
+			{
+				PostMessage(pAPLI->hWnd, WM_CLOSE, 0, 0);
+			}
+		}
+	}
+}
+
+void ApplicationPage_OnGotoProcess(void)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	pAPLI = NULL;
+	LV_ITEM							item;
+	int								i;
+	NMHDR							nmhdr;
+
+	for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++)
+	{
+		memset(&item, 0, sizeof(LV_ITEM));
+		item.mask = LVIF_STATE|LVIF_PARAM;
+		item.iItem = i;
+		item.stateMask = (UINT)-1;
+		ListView_GetItem(hApplicationPageListCtrl, &item);
+
+		if (item.state & LVIS_SELECTED)
+		{
+			pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)item.lParam;
+			break;
+		}
+	}
+
+	if (pAPLI)
+	{
+		DWORD	dwProcessId;
+
+		GetWindowThreadProcessId(pAPLI->hWnd, &dwProcessId);
+
+		//
+		// Switch to the process tab
+		//
+		TabCtrl_SetCurFocus(hTabWnd, 1);
+
+		//
+		// FIXME: Select the process item in the list
+		//
+		for (i=0; i<ListView_GetItemCount(hProcessPage); i++)
+		{
+
+		}
+	}
+}
+
+int CALLBACK ApplicationPageCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+{
+	LPAPPLICATION_PAGE_LIST_ITEM	Param1;
+	LPAPPLICATION_PAGE_LIST_ITEM	Param2;
+
+	if (bSortAscending)
+	{
+		Param1 = (LPAPPLICATION_PAGE_LIST_ITEM)lParam1;
+		Param2 = (LPAPPLICATION_PAGE_LIST_ITEM)lParam2;
+	}
+	else
+	{
+		Param1 = (LPAPPLICATION_PAGE_LIST_ITEM)lParam2;
+		Param2 = (LPAPPLICATION_PAGE_LIST_ITEM)lParam1;
+	}
+
+	return strcmp(Param1->szTitle, Param2->szTitle);
+}
diff --git a/rosapps/taskmgr/ApplicationPage.h b/rosapps/taskmgr/ApplicationPage.h
new file mode 100644
index 00000000000..554e516e4fb
--- /dev/null
+++ b/rosapps/taskmgr/ApplicationPage.h
@@ -0,0 +1,50 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  applicationpage.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __APPLICATIONPAGE_H
+#define __APPLICATIONPAGE_H
+
+extern	HWND		hApplicationPage;				// Application List Property Page
+
+extern	HWND		hApplicationPageListCtrl;		// Application ListCtrl Window
+extern	HWND		hApplicationPageEndTaskButton;	// Application End Task button
+extern	HWND		hApplicationPageSwitchToButton;	// Application Switch To button
+extern	HWND		hApplicationPageNewTaskButton;	// Application New Task button
+
+LRESULT CALLBACK	ApplicationPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+void				RefreshApplicationPage(void);
+void				UpdateApplicationListControlViewSetting(void);
+
+void				ApplicationPage_OnViewLargeIcons(void);
+void				ApplicationPage_OnViewSmallIcons(void);
+void				ApplicationPage_OnViewDetails(void);
+void				ApplicationPage_OnWindowsTileHorizontally(void);
+void				ApplicationPage_OnWindowsTileVertically(void);
+void				ApplicationPage_OnWindowsMinimize(void);
+void				ApplicationPage_OnWindowsMaximize(void);
+void				ApplicationPage_OnWindowsCascade(void);
+void				ApplicationPage_OnWindowsBringToFront(void);
+void				ApplicationPage_OnSwitchTo(void);
+void				ApplicationPage_OnEndTask(void);
+void				ApplicationPage_OnGotoProcess(void);
+
+#endif // defined __APPLICATIONPAGE_H
diff --git a/rosapps/taskmgr/PerformancePage.cpp b/rosapps/taskmgr/PerformancePage.cpp
new file mode 100644
index 00000000000..e96b9e5bc4a
--- /dev/null
+++ b/rosapps/taskmgr/PerformancePage.cpp
@@ -0,0 +1,331 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  performancepage.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "TASKMGR.h"
+#include "PerformancePage.h"
+#include "perfdata.h"
+#include "graph.h"
+
+HWND		hPerformancePage;								// Performance Property Page
+
+HWND		hPerformancePageCpuUsageGraph;					// CPU Usage Graph
+HWND		hPerformancePageMemUsageGraph;					// MEM Usage Graph
+HWND		hPerformancePageMemUsageHistoryGraph;			// Memory Usage History Graph
+
+HWND		hPerformancePageTotalsFrame;					// Totals Frame
+HWND		hPerformancePageCommitChargeFrame;				// Commit Charge Frame
+HWND		hPerformancePageKernelMemoryFrame;				// Kernel Memory Frame
+HWND		hPerformancePagePhysicalMemoryFrame;			// Physical Memory Frame
+
+HWND		hPerformancePageCommitChargeTotalEdit;			// Commit Charge Total Edit Control
+HWND		hPerformancePageCommitChargeLimitEdit;			// Commit Charge Limit Edit Control
+HWND		hPerformancePageCommitChargePeakEdit;			// Commit Charge Peak Edit Control
+
+HWND		hPerformancePageKernelMemoryTotalEdit;			// Kernel Memory Total Edit Control
+HWND		hPerformancePageKernelMemoryPagedEdit;			// Kernel Memory Paged Edit Control
+HWND		hPerformancePageKernelMemoryNonPagedEdit;		// Kernel Memory NonPaged Edit Control
+
+HWND		hPerformancePagePhysicalMemoryTotalEdit;		// Physical Memory Total Edit Control
+HWND		hPerformancePagePhysicalMemoryAvailableEdit;	// Physical Memory Available Edit Control
+HWND		hPerformancePagePhysicalMemorySystemCacheEdit;	// Physical Memory System Cache Edit Control
+
+HWND		hPerformancePageTotalsHandleCountEdit;			// Total Handles Edit Control
+HWND		hPerformancePageTotalsProcessCountEdit;			// Total Processes Edit Control
+HWND		hPerformancePageTotalsThreadCountEdit;			// Total Threads Edit Control
+
+static int	nPerformancePageWidth;
+static int	nPerformancePageHeight;
+
+static HANDLE	hPerformancePageEvent = NULL;	// When this event becomes signaled then we refresh the performance page
+
+void		PerformancePageRefreshThread(void *lpParameter);
+
+LRESULT CALLBACK PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	RECT	rc;
+	int		nXDifference;
+	int		nYDifference;
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+		
+		// Save the width and height
+		GetClientRect(hDlg, &rc);
+		nPerformancePageWidth = rc.right;
+		nPerformancePageHeight = rc.bottom;
+
+		// Update window position
+		SetWindowPos(hDlg, NULL, 15, 30, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+
+		//
+		// Get handles to all the controls
+		//
+		hPerformancePageTotalsFrame = GetDlgItem(hDlg, IDC_TOTALS_FRAME);
+		hPerformancePageCommitChargeFrame = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_FRAME);
+		hPerformancePageKernelMemoryFrame = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_FRAME);
+		hPerformancePagePhysicalMemoryFrame = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_FRAME);
+		hPerformancePageCommitChargeTotalEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_TOTAL);
+		hPerformancePageCommitChargeLimitEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_LIMIT);
+		hPerformancePageCommitChargePeakEdit = GetDlgItem(hDlg, IDC_COMMIT_CHARGE_PEAK);
+		hPerformancePageKernelMemoryTotalEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_TOTAL);
+		hPerformancePageKernelMemoryPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_PAGED);
+		hPerformancePageKernelMemoryNonPagedEdit = GetDlgItem(hDlg, IDC_KERNEL_MEMORY_NONPAGED);
+		hPerformancePagePhysicalMemoryTotalEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_TOTAL);
+		hPerformancePagePhysicalMemoryAvailableEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_AVAILABLE);
+		hPerformancePagePhysicalMemorySystemCacheEdit = GetDlgItem(hDlg, IDC_PHYSICAL_MEMORY_SYSTEM_CACHE);
+		hPerformancePageTotalsHandleCountEdit = GetDlgItem(hDlg, IDC_TOTALS_HANDLE_COUNT);
+		hPerformancePageTotalsProcessCountEdit = GetDlgItem(hDlg, IDC_TOTALS_PROCESS_COUNT);
+		hPerformancePageTotalsThreadCountEdit = GetDlgItem(hDlg, IDC_TOTALS_THREAD_COUNT);
+		hPerformancePageCpuUsageGraph = GetDlgItem(hDlg, IDC_CPU_USAGE_GRAPH);
+		hPerformancePageMemUsageGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_GRAPH);
+		hPerformancePageMemUsageHistoryGraph = GetDlgItem(hDlg, IDC_MEM_USAGE_HISTORY_GRAPH);
+		
+		// Start our refresh thread
+		_beginthread(PerformancePageRefreshThread, 0, NULL);
+
+		//
+		// Subclass graph buttons
+		//
+		OldGraphWndProc = SetWindowLong(hPerformancePageCpuUsageGraph, GWL_WNDPROC, (LONG)Graph_WndProc);
+		SetWindowLong(hPerformancePageMemUsageGraph, GWL_WNDPROC, (LONG)Graph_WndProc);
+		SetWindowLong(hPerformancePageMemUsageHistoryGraph, GWL_WNDPROC, (LONG)Graph_WndProc);
+		
+		return TRUE;
+
+	case WM_COMMAND:
+		break;
+
+	case WM_SIZE:
+		int		cx, cy;
+
+		if (wParam == SIZE_MINIMIZED)
+			return 0;
+
+		cx = LOWORD(lParam);
+		cy = HIWORD(lParam);
+		nXDifference = cx - nPerformancePageWidth;
+		nYDifference = cy - nPerformancePageHeight;
+		nPerformancePageWidth = cx;
+		nPerformancePageHeight = cy;
+
+		// Reposition the performance page's controls
+		/*GetWindowRect(hApplicationPageListCtrl, &rc);
+		cx = (rc.right - rc.left) + nXDifference;
+		cy = (rc.bottom - rc.top) + nYDifference;
+		SetWindowPos(hApplicationPageListCtrl, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageListCtrl, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageEndTaskButton, &rc);
+		MapWindowPoints(hApplicationPageEndTaskButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageEndTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageEndTaskButton, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageSwitchToButton, &rc);
+		MapWindowPoints(hApplicationPageSwitchToButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageSwitchToButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageSwitchToButton, NULL, TRUE);
+		
+		GetClientRect(hApplicationPageNewTaskButton, &rc);
+		MapWindowPoints(hApplicationPageNewTaskButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hApplicationPageNewTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hApplicationPageNewTaskButton, NULL, TRUE);*/
+
+		break;
+	}
+
+    return 0;
+}
+
+void RefreshPerformancePage(void)
+{
+	// Signal the event so that our refresh thread
+	// will wake up and refresh the performance page
+	SetEvent(hPerformancePageEvent);
+}
+
+void PerformancePageRefreshThread(void *lpParameter)
+{
+	ULONG	CommitChargeTotal;
+	ULONG	CommitChargeLimit;
+	ULONG	CommitChargePeak;
+
+	ULONG	KernelMemoryTotal;
+	ULONG	KernelMemoryPaged;
+	ULONG	KernelMemoryNonPaged;
+
+	ULONG	PhysicalMemoryTotal;
+	ULONG	PhysicalMemoryAvailable;
+	ULONG	PhysicalMemorySystemCache;
+
+	ULONG	TotalHandles;
+	ULONG	TotalThreads;
+	ULONG	TotalProcesses;
+
+	TCHAR	Text[260];
+
+	// Create the event
+	hPerformancePageEvent = CreateEvent(NULL, TRUE, TRUE, "Performance Page Event");
+
+	// If we couldn't create the event then exit the thread
+	if (!hPerformancePageEvent)
+		return;
+
+	while (1)
+	{
+		DWORD	dwWaitVal;
+
+		// Wait on the event
+		dwWaitVal = WaitForSingleObject(hPerformancePageEvent, INFINITE);
+
+		// If the wait failed then the event object must have been
+		// closed and the task manager is exiting so exit this thread
+		if (dwWaitVal == WAIT_FAILED)
+			return;
+
+		if (dwWaitVal == WAIT_OBJECT_0)
+		{
+			// Reset our event
+			ResetEvent(hPerformancePageEvent);
+
+			//
+			// Update the commit charge info
+			//
+			CommitChargeTotal = PerfDataGetCommitChargeTotalK();
+			CommitChargeLimit = PerfDataGetCommitChargeLimitK();
+			CommitChargePeak = PerfDataGetCommitChargePeakK();
+			_ultot(CommitChargeTotal, Text, 10);
+			SetWindowText(hPerformancePageCommitChargeTotalEdit, Text);
+			_ultot(CommitChargeLimit, Text, 10);
+			SetWindowText(hPerformancePageCommitChargeLimitEdit, Text);
+			_ultot(CommitChargePeak, Text, 10);
+			SetWindowText(hPerformancePageCommitChargePeakEdit, Text);
+			wsprintf(Text, _T("Mem Usage: %dK / %dK"), CommitChargeTotal, CommitChargeLimit);
+			SendMessage(hStatusWnd, SB_SETTEXT, 2, (LPARAM)Text);
+
+			//
+			// Update the kernel memory info
+			//
+			KernelMemoryTotal = PerfDataGetKernelMemoryTotalK();
+			KernelMemoryPaged = PerfDataGetKernelMemoryPagedK();
+			KernelMemoryNonPaged = PerfDataGetKernelMemoryNonPagedK();
+			_ultot(KernelMemoryTotal, Text, 10);
+			SetWindowText(hPerformancePageKernelMemoryTotalEdit, Text);
+			_ultot(KernelMemoryPaged, Text, 10);
+			SetWindowText(hPerformancePageKernelMemoryPagedEdit, Text);
+			_ultot(KernelMemoryNonPaged, Text, 10);
+			SetWindowText(hPerformancePageKernelMemoryNonPagedEdit, Text);
+
+			//
+			// Update the physical memory info
+			//
+			PhysicalMemoryTotal = PerfDataGetPhysicalMemoryTotalK();
+			PhysicalMemoryAvailable = PerfDataGetPhysicalMemoryAvailableK();
+			PhysicalMemorySystemCache = PerfDataGetPhysicalMemorySystemCacheK();
+			_ultot(PhysicalMemoryTotal, Text, 10);
+			SetWindowText(hPerformancePagePhysicalMemoryTotalEdit, Text);
+			_ultot(PhysicalMemoryAvailable, Text, 10);
+			SetWindowText(hPerformancePagePhysicalMemoryAvailableEdit, Text);
+			_ultot(PhysicalMemorySystemCache, Text, 10);
+			SetWindowText(hPerformancePagePhysicalMemorySystemCacheEdit, Text);
+
+			//
+			// Update the totals info
+			//
+			TotalHandles = PerfDataGetSystemHandleCount();
+			TotalThreads = PerfDataGetTotalThreadCount();
+			TotalProcesses = PerfDataGetProcessCount();
+			_ultot(TotalHandles, Text, 10);
+			SetWindowText(hPerformancePageTotalsHandleCountEdit, Text);
+			_ultot(TotalThreads, Text, 10);
+			SetWindowText(hPerformancePageTotalsThreadCountEdit, Text);
+			_ultot(TotalProcesses, Text, 10);
+			SetWindowText(hPerformancePageTotalsProcessCountEdit, Text);
+
+			//
+			// Redraw the graphs
+			//
+			InvalidateRect(hPerformancePageCpuUsageGraph, NULL, FALSE);
+			InvalidateRect(hPerformancePageMemUsageGraph, NULL, FALSE);
+			InvalidateRect(hPerformancePageMemUsageHistoryGraph, NULL, FALSE);
+		}
+	}
+}
+
+void PerformancePage_OnViewShowKernelTimes(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+
+	// Check or uncheck the show 16-bit tasks menu item
+	if (GetMenuState(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND) & MF_CHECKED)
+	{
+		CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
+		TaskManagerSettings.ShowKernelTimes = FALSE;
+	}
+	else
+	{
+		CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
+		TaskManagerSettings.ShowKernelTimes = TRUE;
+	}
+
+	RefreshPerformancePage();
+}
+
+void PerformancePage_OnViewCPUHistoryOneGraphAll(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+	HMENU	hCPUHistoryMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+	hCPUHistoryMenu = GetSubMenu(hViewMenu, 3);
+
+	TaskManagerSettings.CPUHistory_OneGraphPerCPU = FALSE;
+	CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
+}
+
+void PerformancePage_OnViewCPUHistoryOneGraphPerCPU(void)
+{
+	HMENU	hMenu;
+	HMENU	hViewMenu;
+	HMENU	hCPUHistoryMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hViewMenu = GetSubMenu(hMenu, 2);
+	hCPUHistoryMenu = GetSubMenu(hViewMenu, 3);
+
+	TaskManagerSettings.CPUHistory_OneGraphPerCPU = TRUE;
+	CheckMenuRadioItem(hCPUHistoryMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
+}
+
diff --git a/rosapps/taskmgr/PerformancePage.h b/rosapps/taskmgr/PerformancePage.h
new file mode 100644
index 00000000000..3e5789f3798
--- /dev/null
+++ b/rosapps/taskmgr/PerformancePage.h
@@ -0,0 +1,35 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  performancepage.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __PERFORMANCEPAGE_H
+#define __PERFORMANCEPAGE_H
+
+extern	HWND		hPerformancePage;				// Performance Property Page
+
+LRESULT CALLBACK	PerformancePageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+void				RefreshPerformancePage(void);
+
+void				PerformancePage_OnViewShowKernelTimes(void);
+void				PerformancePage_OnViewCPUHistoryOneGraphAll(void);
+void				PerformancePage_OnViewCPUHistoryOneGraphPerCPU(void);
+
+#endif // defined __PERFORMANCEPAGE_H
diff --git a/rosapps/taskmgr/ProcessPage.cpp b/rosapps/taskmgr/ProcessPage.cpp
new file mode 100644
index 00000000000..36eac142d19
--- /dev/null
+++ b/rosapps/taskmgr/ProcessPage.cpp
@@ -0,0 +1,531 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  processpage.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "TASKMGR.h"
+#include "ProcessPage.h"
+#include "perfdata.h"
+#include "column.h"
+#include "proclist.h"
+
+HWND		hProcessPage;						// Process List Property Page
+
+HWND		hProcessPageListCtrl;				// Process ListCtrl Window
+HWND		hProcessPageHeaderCtrl;				// Process Header Control
+HWND		hProcessPageEndProcessButton;		// Process End Process button
+HWND		hProcessPageShowAllProcessesButton;	// Process Show All Processes checkbox
+
+static int	nProcessPageWidth;
+static int	nProcessPageHeight;
+
+static HANDLE	hProcessPageEvent = NULL;	// When this event becomes signaled then we refresh the process list
+
+void				ProcessPageOnNotify(WPARAM wParam, LPARAM lParam);
+void				CommaSeparateNumberString(LPTSTR strNumber, int nMaxCount);
+void				ProcessPageShowContextMenu(DWORD dwProcessId);
+void				ProcessPageRefreshThread(void *lpParameter);
+
+LRESULT CALLBACK ProcessPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	RECT	rc;
+	int		nXDifference;
+	int		nYDifference;
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		//
+		// Save the width and height
+		//
+		GetClientRect(hDlg, &rc);
+		nProcessPageWidth = rc.right;
+		nProcessPageHeight = rc.bottom;
+
+		// Update window position
+		SetWindowPos(hDlg, NULL, 15, 30, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+
+		//
+		// Get handles to the controls
+		//
+		hProcessPageListCtrl = GetDlgItem(hDlg, IDC_PROCESSLIST);
+		hProcessPageHeaderCtrl = ListView_GetHeader(hProcessPageListCtrl);
+		hProcessPageEndProcessButton = GetDlgItem(hDlg, IDC_ENDPROCESS);
+		hProcessPageShowAllProcessesButton = GetDlgItem(hDlg, IDC_SHOWALLPROCESSES);
+
+		//
+		// Set the font, title, and extended window styles for the list control
+		//
+		SendMessage(hProcessPageListCtrl, WM_SETFONT, SendMessage(hProcessPage, WM_GETFONT, 0, 0), TRUE);
+		SetWindowText(hProcessPageListCtrl, "Processes");
+		ListView_SetExtendedListViewStyle(hProcessPageListCtrl, ListView_GetExtendedListViewStyle(hProcessPageListCtrl) | LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP);
+
+		AddColumns();
+
+		//
+		// Subclass the process list control so we can intercept WM_ERASEBKGND
+		//
+		OldProcessListWndProc = SetWindowLong(hProcessPageListCtrl, GWL_WNDPROC, (LONG)ProcessListWndProc);
+
+		// Start our refresh thread
+		_beginthread(ProcessPageRefreshThread, 0, NULL);
+
+		return TRUE;
+
+	case WM_DESTROY:
+		// Close the event handle, this will make the
+		// refresh thread exit when the wait fails
+		CloseHandle(hProcessPageEvent);
+
+		SaveColumnSettings();
+
+		break;
+
+	case WM_COMMAND:
+		break;
+
+	case WM_SIZE:
+		int		cx, cy;
+
+		if (wParam == SIZE_MINIMIZED)
+			return 0;
+
+		cx = LOWORD(lParam);
+		cy = HIWORD(lParam);
+		nXDifference = cx - nProcessPageWidth;
+		nYDifference = cy - nProcessPageHeight;
+		nProcessPageWidth = cx;
+		nProcessPageHeight = cy;
+
+		// Reposition the application page's controls
+		GetWindowRect(hProcessPageListCtrl, &rc);
+		cx = (rc.right - rc.left) + nXDifference;
+		cy = (rc.bottom - rc.top) + nYDifference;
+		SetWindowPos(hProcessPageListCtrl, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
+		InvalidateRect(hProcessPageListCtrl, NULL, TRUE);
+		
+		GetClientRect(hProcessPageEndProcessButton, &rc);
+		MapWindowPoints(hProcessPageEndProcessButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left + nXDifference;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hProcessPageEndProcessButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hProcessPageEndProcessButton, NULL, TRUE);
+		
+		GetClientRect(hProcessPageShowAllProcessesButton, &rc);
+		MapWindowPoints(hProcessPageShowAllProcessesButton, hDlg, (LPPOINT)(&rc), (sizeof(RECT)/sizeof(POINT)) );
+   		cx = rc.left;
+		cy = rc.top + nYDifference;
+		SetWindowPos(hProcessPageShowAllProcessesButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
+		InvalidateRect(hProcessPageShowAllProcessesButton, NULL, TRUE);
+
+		break;
+
+	case WM_NOTIFY:
+
+		ProcessPageOnNotify(wParam, lParam);
+		break;
+	}
+
+    return 0;
+}
+
+void ProcessPageOnNotify(WPARAM wParam, LPARAM lParam)
+{
+	int				idctrl;
+	LPNMHDR			pnmh;
+	LPNMLISTVIEW	pnmv;
+	NMLVDISPINFO*	pnmdi;
+	LPNMHEADER		pnmhdr;
+	LVITEM			lvitem;
+	ULONG			Index;
+	ULONG			ColumnIndex;
+	IO_COUNTERS		iocounters;
+	TIME			time;
+
+	idctrl = (int) wParam;
+	pnmh = (LPNMHDR) lParam;
+	pnmv = (LPNMLISTVIEW) lParam;
+	pnmdi = (NMLVDISPINFO*) lParam;
+	pnmhdr = (LPNMHEADER) lParam;
+
+	if (pnmh->hwndFrom == hProcessPageListCtrl)
+	{
+		switch (pnmh->code)
+		{
+		/*case LVN_ITEMCHANGED:
+			ProcessPageUpdate();
+			break;*/
+			
+		case LVN_GETDISPINFO:
+
+			if (!(pnmdi->item.mask & LVIF_TEXT))
+				break;
+			
+			ColumnIndex = pnmdi->item.iSubItem;
+			Index = pnmdi->item.iItem;
+
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IMAGENAME)
+				PerfDataGetImageName(Index, pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			if (ColumnDataHints[ColumnIndex] == COLUMN_PID)
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetProcessId(Index));
+			if (ColumnDataHints[ColumnIndex] == COLUMN_USERNAME)
+				PerfDataGetUserName(Index, pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			if (ColumnDataHints[ColumnIndex] == COLUMN_SESSIONID)
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetSessionId(Index));
+			if (ColumnDataHints[ColumnIndex] == COLUMN_CPUUSAGE)
+				wsprintf(pnmdi->item.pszText, _T("%02d"), PerfDataGetCPUUsage(Index));
+			if (ColumnDataHints[ColumnIndex] == COLUMN_CPUTIME)
+			{
+				time = PerfDataGetCPUTime(Index);
+
+				DWORD	dwHours = (DWORD)(time.QuadPart / 36000000000);
+				DWORD	dwMinutes = (DWORD)((time.QuadPart % 36000000000) / 600000000);
+				DWORD	dwSeconds = (DWORD)(((time.QuadPart % 36000000000) % 600000000) / 10000000);
+
+				wsprintf(pnmdi->item.pszText, _T("%d:%02d:%02d"), dwHours, dwMinutes, dwSeconds);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_MEMORYUSAGE)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetWorkingSetSizeBytes(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_PEAKMEMORYUSAGE)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetPeakWorkingSetSizeBytes(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_MEMORYUSAGEDELTA)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetWorkingSetSizeDelta(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_PAGEFAULTS)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetPageFaultCount(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_PAGEFAULTSDELTA)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetPageFaultCountDelta(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_VIRTUALMEMORYSIZE)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetVirtualMemorySizeBytes(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_PAGEDPOOL)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetPagedPoolUsagePages(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_NONPAGEDPOOL)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetNonPagedPoolUsagePages(Index) / 1024);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+				_tcscat(pnmdi->item.pszText, _T(" K"));
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_BASEPRIORITY)
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetBasePriority(Index));
+			if (ColumnDataHints[ColumnIndex] == COLUMN_HANDLECOUNT)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetHandleCount(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_THREADCOUNT)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetThreadCount(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_USEROBJECTS)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetUSERObjectCount(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_GDIOBJECTS)
+			{
+				wsprintf(pnmdi->item.pszText, _T("%d"), PerfDataGetGDIObjectCount(Index));
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOREADS)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.ReadOperationCount);
+				_ui64toa(iocounters.ReadOperationCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOWRITES)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.WriteOperationCount);
+				_ui64toa(iocounters.WriteOperationCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOOTHER)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.OtherOperationCount);
+				_ui64toa(iocounters.OtherOperationCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOREADBYTES)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.ReadTransferCount);
+				_ui64toa(iocounters.ReadTransferCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOWRITEBYTES)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.WriteTransferCount);
+				_ui64toa(iocounters.WriteTransferCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+			if (ColumnDataHints[ColumnIndex] == COLUMN_IOOTHERBYTES)
+			{
+				PerfDataGetIOCounters(Index, &iocounters);
+				//wsprintf(pnmdi->item.pszText, _T("%d"), iocounters.OtherTransferCount);
+				_ui64toa(iocounters.OtherTransferCount, pnmdi->item.pszText, 10);
+				CommaSeparateNumberString(pnmdi->item.pszText, pnmdi->item.cchTextMax);
+			}
+
+			break;
+
+		case NM_RCLICK:
+
+			for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+			{
+				memset(&lvitem, 0, sizeof(LVITEM));
+
+				lvitem.mask = LVIF_STATE;
+				lvitem.stateMask = LVIS_SELECTED;
+				lvitem.iItem = Index;
+
+				ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+				if (lvitem.state & LVIS_SELECTED)
+					break;
+			}
+
+			if ((ListView_GetSelectedCount(hProcessPageListCtrl) == 1) &&
+				(PerfDataGetProcessId(Index) != 0))
+			{
+				ProcessPageShowContextMenu(PerfDataGetProcessId(Index));
+			}
+
+			break;
+
+		}
+	}
+	else if (pnmh->hwndFrom == hProcessPageHeaderCtrl)
+	{
+		switch (pnmh->code)
+		{
+		case HDN_ITEMCLICK:
+
+			//
+			// FIXME: Fix the column sorting
+			//
+			//ListView_SortItems(hApplicationPageListCtrl, ApplicationPageCompareFunc, NULL);
+			//bSortAscending = !bSortAscending;
+
+			break;
+
+		case HDN_ITEMCHANGED:
+
+			UpdateColumnDataHints();
+
+			break;
+
+		case HDN_ENDDRAG:
+
+			UpdateColumnDataHints();
+
+			break;
+
+		}
+	}
+
+}
+
+void CommaSeparateNumberString(LPTSTR strNumber, int nMaxCount)
+{
+	TCHAR	temp[260];
+	UINT	i, j, k;
+
+	for (i=0,j=0; i<(_tcslen(strNumber) % 3); i++, j++)
+		temp[j] = strNumber[i];
+
+	for (k=0; i<_tcslen(strNumber); i++,j++,k++)
+	{
+		if ((k % 3 == 0) && (j > 0))
+			temp[j++] = _T(',');
+
+		temp[j] = strNumber[i];
+	}
+
+	temp[j] = _T('\0');
+
+	_tcsncpy(strNumber, temp, nMaxCount);
+}
+
+void ProcessPageShowContextMenu(DWORD dwProcessId)
+{
+	HMENU		hMenu;
+	HMENU		hSubMenu;
+	HMENU		hPriorityMenu;
+	POINT		pt;
+	SYSTEM_INFO	si;
+	HANDLE		hProcess;
+	DWORD		dwProcessPriorityClass;
+	TCHAR		strDebugger[260];
+	DWORD		dwDebuggerSize;
+	HKEY		hKey;
+	UINT		Idx;
+
+	memset(&si, 0, sizeof(SYSTEM_INFO));
+
+	GetCursorPos(&pt);
+	GetSystemInfo(&si);
+
+	hMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_PROCESS_PAGE_CONTEXT));
+	hSubMenu = GetSubMenu(hMenu, 0);
+	hPriorityMenu = GetSubMenu(hSubMenu, 4);
+
+	hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessId);
+	dwProcessPriorityClass = GetPriorityClass(hProcess);
+	CloseHandle(hProcess);
+
+	if (si.dwNumberOfProcessors < 2)
+		RemoveMenu(hSubMenu, ID_PROCESS_PAGE_SETAFFINITY, MF_BYCOMMAND);
+
+	switch (dwProcessPriorityClass)
+	{
+	case REALTIME_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, MF_BYCOMMAND);
+		break;
+	case HIGH_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_HIGH, MF_BYCOMMAND);
+		break;
+	case ABOVE_NORMAL_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL, MF_BYCOMMAND);
+		break;
+	case NORMAL_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_NORMAL, MF_BYCOMMAND);
+		break;
+	case BELOW_NORMAL_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL, MF_BYCOMMAND);
+		break;
+	case IDLE_PRIORITY_CLASS:
+		CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_LOW, MF_BYCOMMAND);
+		break;
+	}
+
+	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
+	{
+		dwDebuggerSize = 260;
+		if (RegQueryValueEx(hKey, "Debugger", NULL, NULL, (LPBYTE)strDebugger, &dwDebuggerSize) == ERROR_SUCCESS)
+		{
+			for (Idx=0; Idx<strlen(strDebugger); Idx++)
+				strDebugger[Idx] = (char) toupper(strDebugger[Idx]);
+
+			if (strstr(strDebugger, "DRWTSN32"))
+				EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+		}
+		else
+			EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+
+		RegCloseKey(hKey);
+	}
+	else
+		EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
+
+	TrackPopupMenu(hSubMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_LEFTBUTTON, pt.x, pt.y, 0, hMainWnd, NULL);
+
+	DestroyMenu(hMenu);
+}
+
+void RefreshProcessPage(void)
+{
+	// Signal the event so that our refresh thread
+	// will wake up and refresh the process page
+	SetEvent(hProcessPageEvent);
+}
+
+void ProcessPageRefreshThread(void *lpParameter)
+{
+	ULONG	OldProcessorUsage = 0;
+	ULONG	OldProcessCount = 0;
+
+	// Create the event
+	hProcessPageEvent = CreateEvent(NULL, TRUE, TRUE, "Process Page Event");
+
+	// If we couldn't create the event then exit the thread
+	if (!hProcessPageEvent)
+		return;
+
+	while (1)
+	{
+		DWORD	dwWaitVal;
+
+		// Wait on the event
+		dwWaitVal = WaitForSingleObject(hProcessPageEvent, INFINITE);
+
+		// If the wait failed then the event object must have been
+		// closed and the task manager is exiting so exit this thread
+		if (dwWaitVal == WAIT_FAILED)
+			return;
+
+		if (dwWaitVal == WAIT_OBJECT_0)
+		{
+			// Reset our event
+			ResetEvent(hProcessPageEvent);
+
+			if ((ULONG)SendMessage(hProcessPageListCtrl, LVM_GETITEMCOUNT, 0, 0) != PerfDataGetProcessCount())
+				SendMessage(hProcessPageListCtrl, LVM_SETITEMCOUNT, PerfDataGetProcessCount(), /*LVSICF_NOINVALIDATEALL|*/LVSICF_NOSCROLL);
+
+			if (IsWindowVisible(hProcessPage))
+				InvalidateRect(hProcessPageListCtrl, NULL, FALSE);
+
+			TCHAR	text[260];
+
+			if (OldProcessorUsage != PerfDataGetProcessorUsage())
+			{
+				OldProcessorUsage = PerfDataGetProcessorUsage();
+				wsprintf(text, _T("CPU Usage: %3d%%"), OldProcessorUsage);
+				SendMessage(hStatusWnd, SB_SETTEXT, 1, (LPARAM)text);
+			}
+			if (OldProcessCount != PerfDataGetProcessCount())
+			{
+				OldProcessCount = PerfDataGetProcessCount();
+				wsprintf(text, _T("Processes: %d"), OldProcessCount);
+				SendMessage(hStatusWnd, SB_SETTEXT, 0, (LPARAM)text);
+			}
+		}
+	}
+}
diff --git a/rosapps/taskmgr/ProcessPage.h b/rosapps/taskmgr/ProcessPage.h
new file mode 100644
index 00000000000..092da9ad67a
--- /dev/null
+++ b/rosapps/taskmgr/ProcessPage.h
@@ -0,0 +1,35 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  processpage.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __PROCESSPAGE_H
+#define __PROCESSPAGE_H
+
+extern	HWND		hProcessPage;						// Process List Property Page
+extern	HWND		hProcessPageListCtrl;				// Process ListCtrl Window
+extern	HWND		hProcessPageHeaderCtrl;				// Process Header Control
+extern	HWND		hProcessPageEndProcessButton;		// Process End Process button
+extern	HWND		hProcessPageShowAllProcessesButton;	// Process Show All Processes checkbox
+
+LRESULT CALLBACK	ProcessPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+void				RefreshProcessPage(void);
+
+#endif // defined __PROCESSPAGE_H
diff --git a/rosapps/taskmgr/StdAfx.cpp b/rosapps/taskmgr/StdAfx.cpp
new file mode 100644
index 00000000000..ab004ec4f58
--- /dev/null
+++ b/rosapps/taskmgr/StdAfx.cpp
@@ -0,0 +1,30 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  stdafx.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+// stdafx.cpp : source file that includes just the standard includes
+//	TASKMGR.pch will be the pre-compiled header
+//	stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file
diff --git a/rosapps/taskmgr/StdAfx.h b/rosapps/taskmgr/StdAfx.h
new file mode 100644
index 00000000000..3f0a9e1f271
--- /dev/null
+++ b/rosapps/taskmgr/StdAfx.h
@@ -0,0 +1,57 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  stdafx.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+// stdafx.h : include file for standard system include files,
+//  or project specific include files that are used frequently, but
+//      are changed infrequently
+//
+
+#if !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_)
+#define AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
+
+// Windows Header Files:
+#include <windows.h>
+#include <commctrl.h>
+//#include <vdmdbg.h>
+
+// C RunTime Header Files
+#include <stdlib.h>
+#include <malloc.h>
+#include <memory.h>
+#include <tchar.h>
+#include <process.h>
+#include <stdio.h>
+
+// Local Header Files
+
+// TODO: reference additional headers your program requires here
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_STDAFX_H__A9DB83DB_A9FD_11D0_BFD1_444553540000__INCLUDED_)
diff --git a/rosapps/taskmgr/TASKMGR.cpp b/rosapps/taskmgr/TASKMGR.cpp
new file mode 100644
index 00000000000..775df9a0d59
--- /dev/null
+++ b/rosapps/taskmgr/TASKMGR.cpp
@@ -0,0 +1,1011 @@
+// TASKMGR.cpp : Defines the entry point for the application.
+//
+
+#include "stdafx.h"
+#include "resource.h"
+#include "TASKMGR.h"
+#include "ApplicationPage.h"
+#include "ProcessPage.h"
+#include "PerformancePage.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)
+{
+	// Initialize global variables
+	hInst = hInstance;
+
+	// Change our priority class to HIGH
+	HANDLE	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
+	HANDLE hToken; 
+	TOKEN_PRIVILEGES tkp; 
+
+	// 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;
+}
+
+// Message handler for dialog box.
+LRESULT CALLBACK TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HDC				hdc;
+	PAINTSTRUCT		ps;
+	LPRECT			pRC;
+	RECT			rc;
+
+
+	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;
+		}
+
+		// 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;
+		}
+
+		break;
+
+	case WM_NOTIFY:
+		int		idctrl;
+		LPNMHDR	pnmh;
+
+		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_DESTROY:
+		WINDOWPLACEMENT	wp;
+
+		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 FillSolidRect(HDC hDC, int x, int y, int cx, int cy, COLORREF clr)
+{
+
+	SetBkColor(hDC, clr);
+	RECT rect;
+	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)
+{
+	FillSolidRect(hDC, x, y, cx - 1, 1, clrTopLeft);
+	FillSolidRect(hDC, x, y, 1, cy - 1, clrTopLeft);
+	FillSolidRect(hDC, x + cx, y, -1, cy, clrBottomRight);
+	FillSolidRect(hDC, x, y + cy, cx, -1, clrBottomRight);
+}
+
+void Draw3dRect(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)
+{
+	int				nParts[3];
+	RECT			rc;
+	char			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, "", 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);
+	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);
+
+	// Insert tabs
+	strcpy(szTemp, "Applications");
+	memset(&item, 0, sizeof(TCITEM));
+	item.mask = TCIF_TEXT;
+	item.pszText = szTemp;
+	TabCtrl_InsertItem(hTabWnd, 0, &item);
+	strcpy(szTemp, "Processes");
+	memset(&item, 0, sizeof(TCITEM));
+	item.mask = TCIF_TEXT;
+	item.pszText = szTemp;
+	TabCtrl_InsertItem(hTabWnd, 1, &item);
+	strcpy(szTemp, "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;
+
+	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);
+	}
+	if (TaskManagerSettings.Maximized)
+		ShowWindow(hWnd, SW_MAXIMIZE);
+
+	// Set the always on top style
+	HMENU	hMenu;
+	HMENU	hEditMenu;
+	HMENU	hViewMenu;
+	HMENU	hUpdateSpeedMenu;
+	HMENU	hCPUHistoryMenu;
+
+	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);
+
+	int		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, 500, 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;
+}
+
+// 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;
+	char	szSubKey[] = "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, "Preferences", NULL, NULL, (LPBYTE)&TaskManagerSettings, &dwSize);
+
+	// Close the key
+	RegCloseKey(hKey);
+}
+
+void SaveSettings(void)
+{
+	HKEY	hKey;
+	char	szSubKey1[] = "Software";
+	char	szSubKey2[] = "Software\\ReactWare";
+	char	szSubKey3[] = "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, "Preferences", NULL, 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];
+
+	strcpy(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, 500, 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_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, "Lar&ge Icons");
+		AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SMALL, "S&mall Icons");
+		AppendMenu(hViewMenu, MF_STRING, ID_VIEW_DETAILS, "&Details");
+
+		if (GetMenuItemCount(hMenu) <= 4)
+		{
+			hSubMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_WINDOWSMENU));
+			InsertMenu(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT)hSubMenu, "&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, "&Select Columns...");
+		AppendMenu(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, "&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, "&One Graph, All CPUs");
+		AppendMenu(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, "One Graph &Per CPU");
+		AppendMenu(hViewMenu, MF_STRING|MF_POPUP, (UINT)hSubMenu, "&CPU History");
+		AppendMenu(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, "&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, GetLastError() );
+    }
+
+    if ( lpszTemp )
+        LocalFree((HLOCAL) lpszTemp );
+
+    return lpszBuf;
+}
diff --git a/rosapps/taskmgr/about.cpp b/rosapps/taskmgr/about.cpp
new file mode 100644
index 00000000000..b0118f07011
--- /dev/null
+++ b/rosapps/taskmgr/about.cpp
@@ -0,0 +1,66 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  about.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "about.h"
+
+
+LRESULT CALLBACK AboutDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+
+void OnAbout(void)
+{
+
+	DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hMainWnd, (DLGPROC)AboutDialogWndProc);
+
+}
+
+LRESULT CALLBACK AboutDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HWND	hLicenseEditWnd;
+	TCHAR	strLicense[0x1000];
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		hLicenseEditWnd = GetDlgItem(hDlg, IDC_LICENSE_EDIT);
+
+		LoadString(hInst, IDS_LICENSE, strLicense, 0x1000);
+
+		SetWindowText(hLicenseEditWnd, strLicense);
+
+		return TRUE;
+
+	case WM_COMMAND:
+
+		if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+
+		break;
+	}
+
+    return 0;
+}
diff --git a/rosapps/taskmgr/about.h b/rosapps/taskmgr/about.h
new file mode 100644
index 00000000000..b7212535f44
--- /dev/null
+++ b/rosapps/taskmgr/about.h
@@ -0,0 +1,28 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  about.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __ABOUT_H
+#define __ABOUT_H
+
+void	OnAbout(void);
+
+#endif // defined __ABOUT_H
diff --git a/rosapps/taskmgr/affinity.cpp b/rosapps/taskmgr/affinity.cpp
new file mode 100644
index 00000000000..3375d36f050
--- /dev/null
+++ b/rosapps/taskmgr/affinity.cpp
@@ -0,0 +1,355 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  affinity.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "ProcessPage.h"
+#include "affinity.h"
+#include "perfdata.h"
+
+HANDLE		hProcessAffinityHandle;
+
+LRESULT CALLBACK AffinityDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+
+void ProcessPage_OnSetAffinity(void)
+{
+	LV_ITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LV_ITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	hProcessAffinityHandle = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcessAffinityHandle)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Access or Set Process Affinity", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	DialogBox(hInst, MAKEINTRESOURCE(IDD_AFFINITY_DIALOG), hMainWnd, (DLGPROC)AffinityDialogWndProc);
+
+	if (hProcessAffinityHandle)
+	{
+		CloseHandle(hProcessAffinityHandle);
+		hProcessAffinityHandle = NULL;
+	}
+}
+
+LRESULT CALLBACK AffinityDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	DWORD	dwProcessAffinityMask = 0;
+	DWORD	dwSystemAffinityMask = 0;
+	TCHAR	strErrorText[260];
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		//
+		// Get the current affinity mask for the process and
+		// the number of CPUs present in the system
+		//
+		if (!GetProcessAffinityMask(hProcessAffinityHandle, &dwProcessAffinityMask, &dwSystemAffinityMask))
+		{
+			GetLastErrorText(strErrorText, 260);
+			EndDialog(hDlg, 0);
+			MessageBox(hMainWnd, strErrorText, "Unable to Access or Set Process Affinity", MB_OK|MB_ICONSTOP);
+		}
+
+		//
+		// Enable a checkbox for each processor present in the system
+		//
+		if (dwSystemAffinityMask & 0x00000001)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU0), TRUE);
+		if (dwSystemAffinityMask & 0x00000002)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU1), TRUE);
+		if (dwSystemAffinityMask & 0x00000004)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU2), TRUE);
+		if (dwSystemAffinityMask & 0x00000008)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU3), TRUE);
+		if (dwSystemAffinityMask & 0x00000010)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU4), TRUE);
+		if (dwSystemAffinityMask & 0x00000020)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU5), TRUE);
+		if (dwSystemAffinityMask & 0x00000040)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU6), TRUE);
+		if (dwSystemAffinityMask & 0x00000080)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU7), TRUE);
+		if (dwSystemAffinityMask & 0x00000100)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU8), TRUE);
+		if (dwSystemAffinityMask & 0x00000200)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU9), TRUE);
+		if (dwSystemAffinityMask & 0x00000400)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU10), TRUE);
+		if (dwSystemAffinityMask & 0x00000800)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU11), TRUE);
+		if (dwSystemAffinityMask & 0x00001000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU12), TRUE);
+		if (dwSystemAffinityMask & 0x00002000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU13), TRUE);
+		if (dwSystemAffinityMask & 0x00004000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU14), TRUE);
+		if (dwSystemAffinityMask & 0x00008000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU15), TRUE);
+		if (dwSystemAffinityMask & 0x00010000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU16), TRUE);
+		if (dwSystemAffinityMask & 0x00020000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU17), TRUE);
+		if (dwSystemAffinityMask & 0x00040000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU18), TRUE);
+		if (dwSystemAffinityMask & 0x00080000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU19), TRUE);
+		if (dwSystemAffinityMask & 0x00100000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU20), TRUE);
+		if (dwSystemAffinityMask & 0x00200000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU21), TRUE);
+		if (dwSystemAffinityMask & 0x00400000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU22), TRUE);
+		if (dwSystemAffinityMask & 0x00800000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU23), TRUE);
+		if (dwSystemAffinityMask & 0x01000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU24), TRUE);
+		if (dwSystemAffinityMask & 0x02000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU25), TRUE);
+		if (dwSystemAffinityMask & 0x04000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU26), TRUE);
+		if (dwSystemAffinityMask & 0x08000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU27), TRUE);
+		if (dwSystemAffinityMask & 0x10000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU28), TRUE);
+		if (dwSystemAffinityMask & 0x20000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU29), TRUE);
+		if (dwSystemAffinityMask & 0x40000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU30), TRUE);
+		if (dwSystemAffinityMask & 0x80000000)
+			EnableWindow(GetDlgItem(hDlg, IDC_CPU31), TRUE);
+
+
+		//
+		// Check each checkbox that the current process
+		// has affinity with
+		//
+		if (dwProcessAffinityMask & 0x00000001)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU0), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000002)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU1), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000004)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU2), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000008)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU3), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000010)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU4), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000020)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU5), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000040)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU6), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000080)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU7), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000100)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU8), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000200)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU9), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000400)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU10), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00000800)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU11), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00001000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU12), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00002000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU13), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00004000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU14), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00008000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU15), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00010000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU16), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00020000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU17), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00040000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU18), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00080000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU19), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00100000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU20), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00200000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU21), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00400000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU22), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x00800000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU23), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x01000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU24), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x02000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU25), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x04000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU26), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x08000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU27), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x10000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU28), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x20000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU29), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x40000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU30), BM_SETCHECK, BST_CHECKED, 0);
+		if (dwProcessAffinityMask & 0x80000000)
+			SendMessage(GetDlgItem(hDlg, IDC_CPU31), BM_SETCHECK, BST_CHECKED, 0);
+
+		return TRUE;
+
+	case WM_COMMAND:
+
+		//
+		// If the user has cancelled the dialog box
+		// then just close it
+		//
+		if (LOWORD(wParam) == IDCANCEL)
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+
+		//
+		// The user has clicked OK -- so now we have
+		// to adjust the process affinity mask
+		//
+		if (LOWORD(wParam) == IDOK)
+		{
+			//
+			// First we have to create a mask out of each
+			// checkbox that the user checked.
+			//
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU0), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000001;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU1), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000002;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU2), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000004;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU3), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000008;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU4), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000010;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU5), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000020;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU6), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000040;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU7), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000080;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU8), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000100;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU9), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000200;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU10), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000400;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU11), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00000800;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU12), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00001000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU13), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00002000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU14), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00004000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU15), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00008000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU16), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00010000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU17), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00020000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU18), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00040000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU19), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00080000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU20), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00100000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU21), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00200000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU22), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00400000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU23), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x00800000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU24), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x01000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU25), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x02000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU26), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x04000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU27), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x08000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU28), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x10000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU29), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x20000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU30), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x40000000;
+			if (SendMessage(GetDlgItem(hDlg, IDC_CPU31), BM_GETCHECK, 0, 0))
+				dwProcessAffinityMask |= 0x80000000;
+
+			//
+			// Make sure they are giving the process affinity
+			// with at least one processor. I'd hate to see a
+			// process that is not in a wait state get deprived
+			// of it's cpu time.
+			//
+			if (!dwProcessAffinityMask)
+			{
+				MessageBox(hDlg, "The process must have affinity with at least one processor.", "Invalid Option", MB_OK|MB_ICONSTOP);
+				return TRUE;
+			}
+
+			//
+			// Try to set the process affinity
+			//
+			if (!SetProcessAffinityMask(hProcessAffinityHandle, dwProcessAffinityMask))
+			{
+				GetLastErrorText(strErrorText, 260);
+				EndDialog(hDlg, LOWORD(wParam));
+				MessageBox(hMainWnd, strErrorText, "Unable to Access or Set Process Affinity", MB_OK|MB_ICONSTOP);
+			}
+
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+
+		break;
+	}
+
+    return 0;
+}
diff --git a/rosapps/taskmgr/affinity.h b/rosapps/taskmgr/affinity.h
new file mode 100644
index 00000000000..e0b76451109
--- /dev/null
+++ b/rosapps/taskmgr/affinity.h
@@ -0,0 +1,28 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  affinity.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __AFFINITY_H
+#define __AFFINITY_H
+
+void ProcessPage_OnSetAffinity(void);
+
+#endif // __AFFINITY_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/column.cpp b/rosapps/taskmgr/column.cpp
new file mode 100644
index 00000000000..0afac9949d9
--- /dev/null
+++ b/rosapps/taskmgr/column.cpp
@@ -0,0 +1,539 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  column.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "column.h"
+#include "ProcessPage.h"
+
+UINT	ColumnDataHints[25];
+
+int					InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem);
+LRESULT CALLBACK	ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
+
+void AddColumns(void)
+{
+	int		size;
+
+	if (TaskManagerSettings.Column_ImageName)
+		InsertColumn(0, "Image Name", LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[0], -1);
+	if (TaskManagerSettings.Column_PID)
+		InsertColumn(1, "PID", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[1], -1);
+	if (TaskManagerSettings.Column_UserName)
+		InsertColumn(2, "Username", LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[2], -1);
+	if (TaskManagerSettings.Column_SessionID)
+		InsertColumn(3, "Session ID", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[3], -1);
+	if (TaskManagerSettings.Column_CPUUsage)
+		InsertColumn(4, "CPU", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[4], -1);
+	if (TaskManagerSettings.Column_CPUTime)
+		InsertColumn(5, "CPU Time", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[5], -1);
+	if (TaskManagerSettings.Column_MemoryUsage)
+		InsertColumn(6, "Mem Usage", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[6], -1);
+	if (TaskManagerSettings.Column_PeakMemoryUsage)
+		InsertColumn(7, "Peak Mem Usage", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[7], -1);
+	if (TaskManagerSettings.Column_MemoryUsageDelta)
+		InsertColumn(8, "Mem Delta", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[8], -1);
+	if (TaskManagerSettings.Column_PageFaults)
+		InsertColumn(9, "Page Faults", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[9], -1);
+	if (TaskManagerSettings.Column_PageFaultsDelta)
+		InsertColumn(10, "PF Delta", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[10], -1);
+	if (TaskManagerSettings.Column_VirtualMemorySize)
+		InsertColumn(11, "VM Size", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[11], -1);
+	if (TaskManagerSettings.Column_PagedPool)
+		InsertColumn(12, "Paged Pool", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[12], -1);
+	if (TaskManagerSettings.Column_NonPagedPool)
+		InsertColumn(13, "NP Pool", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[13], -1);
+	if (TaskManagerSettings.Column_BasePriority)
+		InsertColumn(14, "Base Pri", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[14], -1);
+	if (TaskManagerSettings.Column_HandleCount)
+		InsertColumn(15, "Handles", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[15], -1);
+	if (TaskManagerSettings.Column_ThreadCount)
+		InsertColumn(16, "Threads", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[16], -1);
+	if (TaskManagerSettings.Column_USERObjects)
+		InsertColumn(17, "USER Objects", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[17], -1);
+	if (TaskManagerSettings.Column_GDIObjects)
+		InsertColumn(18, "GDI Objects", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[18], -1);
+	if (TaskManagerSettings.Column_IOReads)
+		InsertColumn(19, "I/O Reads", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[19], -1);
+	if (TaskManagerSettings.Column_IOWrites)
+		InsertColumn(20, "I/O Writes", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[20], -1);
+	if (TaskManagerSettings.Column_IOOther)
+		InsertColumn(21, "I/O Other", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[21], -1);
+	if (TaskManagerSettings.Column_IOReadBytes)
+		InsertColumn(22, "I/O Read Bytes", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[22], -1);
+	if (TaskManagerSettings.Column_IOWriteBytes)
+		InsertColumn(23, "I/O Write Bytes", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[23], -1);
+	if (TaskManagerSettings.Column_IOOtherBytes)
+		InsertColumn(24, "I/O Other Bytes", LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[24], -1);
+
+	size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
+	SendMessage(hProcessPageHeaderCtrl, HDM_SETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
+
+	UpdateColumnDataHints();
+}
+
+int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem)
+{
+	LVCOLUMN	column;
+
+	column.mask = LVCF_TEXT|LVCF_FMT;
+	column.pszText = (LPTSTR)lpszColumnHeading;
+	column.fmt = nFormat;
+
+	if (nWidth != -1)
+	{
+		column.mask |= LVCF_WIDTH;
+		column.cx = nWidth;
+	}
+
+	if (nSubItem != -1)
+	{
+		column.mask |= LVCF_SUBITEM;
+		column.iSubItem = nSubItem;
+	}
+
+	return ListView_InsertColumn(hProcessPageListCtrl, nCol, &column);
+}
+
+void SaveColumnSettings(void)
+{
+	HDITEM	hditem;
+	int		i;
+	char	text[260];
+	int		size;
+
+	// Reset column data
+	for (i=0; i<25; i++)
+		TaskManagerSettings.ColumnOrderArray[i] = i;
+
+	TaskManagerSettings.Column_ImageName = FALSE;
+	TaskManagerSettings.Column_PID = FALSE;
+	TaskManagerSettings.Column_CPUUsage = FALSE;
+	TaskManagerSettings.Column_CPUTime = FALSE;
+	TaskManagerSettings.Column_MemoryUsage = FALSE;
+	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;
+	TaskManagerSettings.Column_UserName = FALSE;
+	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;
+	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;
+
+	// Get header order
+	size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
+	SendMessage(hProcessPageHeaderCtrl, HDM_GETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
+
+	// Get visible columns
+	for (i=0; i<SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); i++)
+	{
+		memset(&hditem, 0, sizeof(HDITEM));
+
+		hditem.mask = HDI_TEXT|HDI_WIDTH;
+		hditem.pszText = text;
+		hditem.cchTextMax = 260;
+
+		SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, i, (LPARAM) &hditem);
+
+		if (stricmp(text, "Image Name") == 0)
+		{
+			TaskManagerSettings.Column_ImageName = TRUE;
+			TaskManagerSettings.ColumnSizeArray[0] = hditem.cxy;
+		}
+		if (stricmp(text, "PID") == 0)
+		{
+			TaskManagerSettings.Column_PID = TRUE;
+			TaskManagerSettings.ColumnSizeArray[1] = hditem.cxy;
+		}
+		if (stricmp(text, "Username") == 0)
+		{
+			TaskManagerSettings.Column_UserName = TRUE;
+			TaskManagerSettings.ColumnSizeArray[2] = hditem.cxy;
+		}
+		if (stricmp(text, "Session ID") == 0)
+		{
+			TaskManagerSettings.Column_SessionID = TRUE;
+			TaskManagerSettings.ColumnSizeArray[3] = hditem.cxy;
+		}
+		if (stricmp(text, "CPU") == 0)
+		{
+			TaskManagerSettings.Column_CPUUsage = TRUE;
+			TaskManagerSettings.ColumnSizeArray[4] = hditem.cxy;
+		}
+		if (stricmp(text, "CPU Time") == 0)
+		{
+			TaskManagerSettings.Column_CPUTime = TRUE;
+			TaskManagerSettings.ColumnSizeArray[5] = hditem.cxy;
+		}
+		if (stricmp(text, "Mem Usage") == 0)
+		{
+			TaskManagerSettings.Column_MemoryUsage = TRUE;
+			TaskManagerSettings.ColumnSizeArray[6] = hditem.cxy;
+		}
+		if (stricmp(text, "Peak Mem Usage") == 0)
+		{
+			TaskManagerSettings.Column_PeakMemoryUsage = TRUE;
+			TaskManagerSettings.ColumnSizeArray[7] = hditem.cxy;
+		}
+		if (stricmp(text, "Mem Delta") == 0)
+		{
+			TaskManagerSettings.Column_MemoryUsageDelta = TRUE;
+			TaskManagerSettings.ColumnSizeArray[8] = hditem.cxy;
+		}
+		if (stricmp(text, "Page Faults") == 0)
+		{
+			TaskManagerSettings.Column_PageFaults = TRUE;
+			TaskManagerSettings.ColumnSizeArray[9] = hditem.cxy;
+		}
+		if (stricmp(text, "PF Delta") == 0)
+		{
+			TaskManagerSettings.Column_PageFaultsDelta = TRUE;
+			TaskManagerSettings.ColumnSizeArray[10] = hditem.cxy;
+		}
+		if (stricmp(text, "VM Size") == 0)
+		{
+			TaskManagerSettings.Column_VirtualMemorySize = TRUE;
+			TaskManagerSettings.ColumnSizeArray[11] = hditem.cxy;
+		}
+		if (stricmp(text, "Paged Pool") == 0)
+		{
+			TaskManagerSettings.Column_PagedPool = TRUE;
+			TaskManagerSettings.ColumnSizeArray[12] = hditem.cxy;
+		}
+		if (stricmp(text, "NP Pool") == 0)
+		{
+			TaskManagerSettings.Column_NonPagedPool = TRUE;
+			TaskManagerSettings.ColumnSizeArray[13] = hditem.cxy;
+		}
+		if (stricmp(text, "Base Pri") == 0)
+		{
+			TaskManagerSettings.Column_BasePriority = TRUE;
+			TaskManagerSettings.ColumnSizeArray[14] = hditem.cxy;
+		}
+		if (stricmp(text, "Handles") == 0)
+		{
+			TaskManagerSettings.Column_HandleCount = TRUE;
+			TaskManagerSettings.ColumnSizeArray[15] = hditem.cxy;
+		}
+		if (stricmp(text, "Threads") == 0)
+		{
+			TaskManagerSettings.Column_ThreadCount = TRUE;
+			TaskManagerSettings.ColumnSizeArray[16] = hditem.cxy;
+		}
+		if (stricmp(text, "USER Objects") == 0)
+		{
+			TaskManagerSettings.Column_USERObjects = TRUE;
+			TaskManagerSettings.ColumnSizeArray[17] = hditem.cxy;
+		}
+		if (stricmp(text, "GDI Objects") == 0)
+		{
+			TaskManagerSettings.Column_GDIObjects = TRUE;
+			TaskManagerSettings.ColumnSizeArray[18] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Reads") == 0)
+		{
+			TaskManagerSettings.Column_IOReads = TRUE;
+			TaskManagerSettings.ColumnSizeArray[19] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Writes") == 0)
+		{
+			TaskManagerSettings.Column_IOWrites = TRUE;
+			TaskManagerSettings.ColumnSizeArray[20] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Other") == 0)
+		{
+			TaskManagerSettings.Column_IOOther = TRUE;
+			TaskManagerSettings.ColumnSizeArray[21] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Read Bytes") == 0)
+		{
+			TaskManagerSettings.Column_IOReadBytes = TRUE;
+			TaskManagerSettings.ColumnSizeArray[22] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Write Bytes") == 0)
+		{
+			TaskManagerSettings.Column_IOWriteBytes = TRUE;
+			TaskManagerSettings.ColumnSizeArray[23] = hditem.cxy;
+		}
+		if (stricmp(text, "I/O Other Bytes") == 0)
+		{
+			TaskManagerSettings.Column_IOOtherBytes = TRUE;
+			TaskManagerSettings.ColumnSizeArray[24] = hditem.cxy;
+		}
+	}
+}
+
+void ProcessPage_OnViewSelectColumns(void)
+{
+	int		i;
+
+	if (DialogBox(hInst, MAKEINTRESOURCE(IDD_COLUMNS_DIALOG), hMainWnd, (DLGPROC)ColumnsDialogWndProc) == IDOK)
+	{
+		for (i=Header_GetItemCount(hProcessPageHeaderCtrl)-1; i>=0; i--)
+		{
+			ListView_DeleteColumn(hProcessPageListCtrl, i);
+		}
+
+		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;
+
+		AddColumns();
+	}
+}
+
+LRESULT CALLBACK ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+
+	switch (message)
+	{
+	case WM_INITDIALOG:
+
+		if (TaskManagerSettings.Column_ImageName)
+			SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_PID)
+			SendMessage(GetDlgItem(hDlg, IDC_PID), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_UserName)
+			SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_SessionID)
+			SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_CPUUsage)
+			SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_CPUTime)
+			SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_MemoryUsage)
+			SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_PeakMemoryUsage)
+			SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_MemoryUsageDelta)
+			SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_PageFaults)
+			SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_PageFaultsDelta)
+			SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_VirtualMemorySize)
+			SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_PagedPool)
+			SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_NonPagedPool)
+			SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_BasePriority)
+			SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_HandleCount)
+			SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_ThreadCount)
+			SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_USERObjects)
+			SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_GDIObjects)
+			SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOReads)
+			SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOWrites)
+			SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOOther)
+			SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOReadBytes)
+			SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOWriteBytes)
+			SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_SETCHECK, BST_CHECKED, 0);
+		if (TaskManagerSettings.Column_IOOtherBytes)
+			SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_SETCHECK, BST_CHECKED, 0);
+
+		return TRUE;
+
+	case WM_COMMAND:
+
+		if (LOWORD(wParam) == IDCANCEL)
+		{
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+
+		if (LOWORD(wParam) == IDOK)
+		{
+			TaskManagerSettings.Column_ImageName = SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_PID = SendMessage(GetDlgItem(hDlg, IDC_PID), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_UserName = SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_SessionID = SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_CPUUsage = SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_CPUTime = SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_MemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_PeakMemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_MemoryUsageDelta = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_PageFaults = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_PageFaultsDelta = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_VirtualMemorySize = SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_PagedPool = SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_NonPagedPool = SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_BasePriority = SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_HandleCount = SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_ThreadCount = SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_USERObjects = SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_GDIObjects = SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOReads = SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOWrites = SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOOther = SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOReadBytes = SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOWriteBytes = SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_GETCHECK, 0, 0);
+			TaskManagerSettings.Column_IOOtherBytes = SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_GETCHECK, 0, 0);
+
+			EndDialog(hDlg, LOWORD(wParam));
+			return TRUE;
+		}
+
+		break;
+	}
+
+    return 0;
+}
+
+void UpdateColumnDataHints(void)
+{
+	HDITEM			hditem;
+	TCHAR			text[260];
+	ULONG			Index;
+
+	for (Index=0; Index<(ULONG)SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); Index++)
+	{
+		memset(&hditem, 0, sizeof(HDITEM));
+
+		hditem.mask = HDI_TEXT;
+		hditem.pszText = text;
+		hditem.cchTextMax = 260;
+
+		SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, Index, (LPARAM) &hditem);
+
+		if (stricmp(text, "Image Name") == 0)
+			ColumnDataHints[Index] = COLUMN_IMAGENAME;
+		if (stricmp(text, "PID") == 0)
+			ColumnDataHints[Index] = COLUMN_PID;
+		if (stricmp(text, "Username") == 0)
+			ColumnDataHints[Index] = COLUMN_USERNAME;
+		if (stricmp(text, "Session ID") == 0)
+			ColumnDataHints[Index] = COLUMN_SESSIONID;
+		if (stricmp(text, "CPU") == 0)
+			ColumnDataHints[Index] = COLUMN_CPUUSAGE;
+		if (stricmp(text, "CPU Time") == 0)
+			ColumnDataHints[Index] = COLUMN_CPUTIME;
+		if (stricmp(text, "Mem Usage") == 0)
+			ColumnDataHints[Index] = COLUMN_MEMORYUSAGE;
+		if (stricmp(text, "Peak Mem Usage") == 0)
+			ColumnDataHints[Index] = COLUMN_PEAKMEMORYUSAGE;
+		if (stricmp(text, "Mem Delta") == 0)
+			ColumnDataHints[Index] = COLUMN_MEMORYUSAGEDELTA;
+		if (stricmp(text, "Page Faults") == 0)
+			ColumnDataHints[Index] = COLUMN_PAGEFAULTS;
+		if (stricmp(text, "PF Delta") == 0)
+			ColumnDataHints[Index] = COLUMN_PAGEFAULTSDELTA;
+		if (stricmp(text, "VM Size") == 0)
+			ColumnDataHints[Index] = COLUMN_VIRTUALMEMORYSIZE;
+		if (stricmp(text, "Paged Pool") == 0)
+			ColumnDataHints[Index] = COLUMN_PAGEDPOOL;
+		if (stricmp(text, "NP Pool") == 0)
+			ColumnDataHints[Index] = COLUMN_NONPAGEDPOOL;
+		if (stricmp(text, "Base Pri") == 0)
+			ColumnDataHints[Index] = COLUMN_BASEPRIORITY;
+		if (stricmp(text, "Handles") == 0)
+			ColumnDataHints[Index] = COLUMN_HANDLECOUNT;
+		if (stricmp(text, "Threads") == 0)
+			ColumnDataHints[Index] = COLUMN_THREADCOUNT;
+		if (stricmp(text, "USER Objects") == 0)
+			ColumnDataHints[Index] = COLUMN_USEROBJECTS;
+		if (stricmp(text, "GDI Objects") == 0)
+			ColumnDataHints[Index] = COLUMN_GDIOBJECTS;
+		if (stricmp(text, "I/O Reads") == 0)
+			ColumnDataHints[Index] = COLUMN_IOREADS;
+		if (stricmp(text, "I/O Writes") == 0)
+			ColumnDataHints[Index] = COLUMN_IOWRITES;
+		if (stricmp(text, "I/O Other") == 0)
+			ColumnDataHints[Index] = COLUMN_IOOTHER;
+		if (stricmp(text, "I/O Read Bytes") == 0)
+			ColumnDataHints[Index] = COLUMN_IOREADBYTES;
+		if (stricmp(text, "I/O Write Bytes") == 0)
+			ColumnDataHints[Index] = COLUMN_IOWRITEBYTES;
+		if (stricmp(text, "I/O Other Bytes") == 0)
+			ColumnDataHints[Index] = COLUMN_IOOTHERBYTES;
+	}
+}
diff --git a/rosapps/taskmgr/column.h b/rosapps/taskmgr/column.h
new file mode 100644
index 00000000000..4c414cd6310
--- /dev/null
+++ b/rosapps/taskmgr/column.h
@@ -0,0 +1,59 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  column.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __COLUMN_H
+#define __COLUMN_H
+
+#define COLUMN_IMAGENAME			0
+#define COLUMN_PID					1
+#define COLUMN_USERNAME				2
+#define COLUMN_SESSIONID			3
+#define COLUMN_CPUUSAGE				4
+#define COLUMN_CPUTIME				5
+#define COLUMN_MEMORYUSAGE			6
+#define COLUMN_PEAKMEMORYUSAGE		7
+#define COLUMN_MEMORYUSAGEDELTA		8
+#define COLUMN_PAGEFAULTS			9
+#define COLUMN_PAGEFAULTSDELTA		10
+#define COLUMN_VIRTUALMEMORYSIZE	11
+#define COLUMN_PAGEDPOOL			12
+#define COLUMN_NONPAGEDPOOL			13
+#define COLUMN_BASEPRIORITY			14
+#define COLUMN_HANDLECOUNT			15
+#define COLUMN_THREADCOUNT			16
+#define COLUMN_USEROBJECTS			17
+#define COLUMN_GDIOBJECTS			18
+#define COLUMN_IOREADS				19
+#define COLUMN_IOWRITES				20
+#define COLUMN_IOOTHER				21
+#define COLUMN_IOREADBYTES			22
+#define COLUMN_IOWRITEBYTES			23
+#define COLUMN_IOOTHERBYTES			24
+
+extern	UINT	ColumnDataHints[25];
+
+void ProcessPage_OnViewSelectColumns(void);
+void AddColumns(void);
+void SaveColumnSettings(void);
+void UpdateColumnDataHints(void);
+
+#endif // __COlUMN_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/debug.cpp b/rosapps/taskmgr/debug.cpp
new file mode 100644
index 00000000000..a7c44e7ae26
--- /dev/null
+++ b/rosapps/taskmgr/debug.cpp
@@ -0,0 +1,107 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  debug.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "debug.h"
+#include "ProcessPage.h"
+#include "perfdata.h"
+
+void ProcessPage_OnDebug(void)
+{
+	LVITEM				lvitem;
+	ULONG				Index;
+	DWORD				dwProcessId;
+	TCHAR				strErrorText[260];
+	HKEY				hKey;
+	TCHAR				strDebugPath[260];
+	TCHAR				strDebugger[260];
+	DWORD				dwDebuggerSize;
+	PROCESS_INFORMATION	pi;
+	STARTUPINFO			si;
+	HANDLE				hDebugEvent;
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Debugging this process may result in loss of data.\nAre you sure you wish to attach the debugger?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Debug Process", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Debug Process", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	dwDebuggerSize = 260;
+	if (RegQueryValueEx(hKey, "Debugger", NULL, NULL, (LPBYTE)strDebugger, &dwDebuggerSize) != ERROR_SUCCESS)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Debug Process", MB_OK|MB_ICONSTOP);
+		RegCloseKey(hKey);
+		return;
+	}
+
+	RegCloseKey(hKey);
+
+	hDebugEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+	if (!hDebugEvent)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Debug Process", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	wsprintf(strDebugPath, strDebugger, dwProcessId, hDebugEvent);
+
+	memset(&pi, 0, sizeof(PROCESS_INFORMATION));
+	memset(&si, 0, sizeof(STARTUPINFO));
+	si.cb = sizeof(STARTUPINFO);
+	if (!CreateProcess(NULL, strDebugPath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Debug Process", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hDebugEvent);
+}
diff --git a/rosapps/taskmgr/debug.h b/rosapps/taskmgr/debug.h
new file mode 100644
index 00000000000..35669d11e92
--- /dev/null
+++ b/rosapps/taskmgr/debug.h
@@ -0,0 +1,28 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  debug.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+void ProcessPage_OnDebug(void);
+
+#endif // __DEBUG_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/endproc.cpp b/rosapps/taskmgr/endproc.cpp
new file mode 100644
index 00000000000..87d52de2b09
--- /dev/null
+++ b/rosapps/taskmgr/endproc.cpp
@@ -0,0 +1,123 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  endproc.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "endproc.h"
+#include "ProcessPage.h"
+#include "perfdata.h"
+
+void ProcessPage_OnEndProcess(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Terminating a process can cause undesired\nresults including loss of data and system instability. The\nprocess will not be given the chance to save its state or\ndata before it is terminated. Are you sure you want to\nterminate the process?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Terminate Process", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!TerminateProcess(hProcess, 0))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Terminate Process", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnEndProcessTree(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Terminating a process can cause undesired\nresults including loss of data and system instability. The\nprocess will not be given the chance to save its state or\ndata before it is terminated. Are you sure you want to\nterminate the process?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Terminate Process", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!TerminateProcess(hProcess, 0))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Terminate Process", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
diff --git a/rosapps/taskmgr/endproc.h b/rosapps/taskmgr/endproc.h
new file mode 100644
index 00000000000..931c0877c25
--- /dev/null
+++ b/rosapps/taskmgr/endproc.h
@@ -0,0 +1,29 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  endproc.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __ENDPROC_H
+#define __ENDPROC_H
+
+void ProcessPage_OnEndProcess(void);
+void ProcessPage_OnEndProcessTree(void);
+
+#endif // __ENDPROC_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/font.bmp b/rosapps/taskmgr/font.bmp
new file mode 100644
index 00000000000..7de02b6613a
Binary files /dev/null and b/rosapps/taskmgr/font.bmp differ
diff --git a/rosapps/taskmgr/font.cpp b/rosapps/taskmgr/font.cpp
new file mode 100644
index 00000000000..1e7816232c6
--- /dev/null
+++ b/rosapps/taskmgr/font.cpp
@@ -0,0 +1,60 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  font.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "font.h"
+
+void Font_DrawText(HDC hDC, LPCTSTR lpszText, int x, int y)
+{
+	HDC		hFontDC;
+	HBITMAP	hFontBitmap;
+	HBITMAP	hOldBitmap;
+	int		i;
+	
+	hFontDC = CreateCompatibleDC(hDC);
+
+	hFontBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_FONT));
+	
+	hOldBitmap = (HBITMAP)SelectObject(hFontDC, hFontBitmap);
+	
+	for (i=0; i< (int) _tcslen(lpszText); i++)
+	{
+		if ((lpszText[i] >= '0') && (lpszText[i] <= '9'))
+		{
+			BitBlt(hDC, x + (i * 8), y, 8, 11, hFontDC, (lpszText[i] - '0') * 8, 0, SRCCOPY);
+		}
+		else if (lpszText[i] == 'K')
+		{
+			BitBlt(hDC, x + (i * 8), y, 8, 11, hFontDC, 80, 0, SRCCOPY);
+		}
+		else if (lpszText[i] == '%')
+		{
+			BitBlt(hDC, x + (i * 8), y, 8, 11, hFontDC, 88, 0, SRCCOPY);
+		}
+	}
+
+	SelectObject(hFontDC, hOldBitmap);
+	DeleteObject(hFontBitmap);
+	DeleteDC(hFontDC);
+}
+
diff --git a/rosapps/taskmgr/font.h b/rosapps/taskmgr/font.h
new file mode 100644
index 00000000000..c41dd4973b0
--- /dev/null
+++ b/rosapps/taskmgr/font.h
@@ -0,0 +1,28 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  font.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __FONT_H
+#define __FONT_H
+
+void	Font_DrawText(HDC hDC, LPCTSTR lpszText, int x, int y);
+
+#endif // __FONT_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/graph.cpp b/rosapps/taskmgr/graph.cpp
new file mode 100644
index 00000000000..06bba82fb2d
--- /dev/null
+++ b/rosapps/taskmgr/graph.cpp
@@ -0,0 +1,434 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  graph.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "graph.h"
+#include "font.h"
+#include "perfdata.h"
+
+
+LONG				OldGraphWndProc;
+
+void				Graph_DrawCpuUsageGraph(HDC hDC, HWND hWnd);
+void				Graph_DrawMemUsageGraph(HDC hDC, HWND hWnd);
+void				Graph_DrawMemUsageHistoryGraph(HDC hDC, HWND hWnd);
+
+LRESULT CALLBACK Graph_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HDC				hdc;
+	PAINTSTRUCT		ps;
+	LONG			WindowId;
+	
+	switch (message)
+	{
+	case WM_ERASEBKGND:
+
+		return TRUE;
+
+	//
+	// Filter out mouse  & keyboard messages
+	//
+	//case WM_APPCOMMAND:
+	case WM_CAPTURECHANGED:
+	case WM_LBUTTONDBLCLK:
+	case WM_LBUTTONDOWN:
+	case WM_LBUTTONUP:
+	case WM_MBUTTONDBLCLK:
+	case WM_MBUTTONDOWN:
+	case WM_MBUTTONUP:
+	case WM_MOUSEACTIVATE:
+	case WM_MOUSEHOVER:
+	case WM_MOUSELEAVE:
+	case WM_MOUSEMOVE:
+	//case WM_MOUSEWHEEL:
+	case WM_NCHITTEST:
+	case WM_NCLBUTTONDBLCLK:
+	case WM_NCLBUTTONDOWN:
+	case WM_NCLBUTTONUP:
+	case WM_NCMBUTTONDBLCLK:
+	case WM_NCMBUTTONDOWN:
+	case WM_NCMBUTTONUP:
+	//case WM_NCMOUSEHOVER:
+	//case WM_NCMOUSELEAVE:
+	case WM_NCMOUSEMOVE:
+	case WM_NCRBUTTONDBLCLK:
+	case WM_NCRBUTTONDOWN:
+	case WM_NCRBUTTONUP:
+	//case WM_NCXBUTTONDBLCLK:
+	//case WM_NCXBUTTONDOWN:
+	//case WM_NCXBUTTONUP:
+	case WM_RBUTTONDBLCLK:
+	case WM_RBUTTONDOWN:
+	case WM_RBUTTONUP:
+	//case WM_XBUTTONDBLCLK:
+	//case WM_XBUTTONDOWN:
+	//case WM_XBUTTONUP:
+	case WM_ACTIVATE:
+	case WM_CHAR:
+	case WM_DEADCHAR:
+	case WM_GETHOTKEY:
+	case WM_HOTKEY:
+	case WM_KEYDOWN:
+	case WM_KEYUP:
+	case WM_KILLFOCUS:
+	case WM_SETFOCUS:
+	case WM_SETHOTKEY:
+	case WM_SYSCHAR:
+	case WM_SYSDEADCHAR:
+	case WM_SYSKEYDOWN:
+	case WM_SYSKEYUP:
+			
+		return 0;
+
+	case WM_PAINT:
+		
+		hdc = BeginPaint(hWnd, &ps);
+
+		WindowId = GetWindowLong(hWnd, GWL_ID);
+
+		switch (WindowId)
+		{
+		case IDC_CPU_USAGE_GRAPH:
+			Graph_DrawCpuUsageGraph(hdc, hWnd);
+			break;
+		case IDC_MEM_USAGE_GRAPH:
+			Graph_DrawMemUsageGraph(hdc, hWnd);
+			break;
+		case IDC_MEM_USAGE_HISTORY_GRAPH:
+			Graph_DrawMemUsageHistoryGraph(hdc, hWnd);
+			break;
+		}
+		
+		EndPaint(hWnd, &ps);
+		
+		return 0;
+		
+	}
+	
+	//
+	// We pass on all non-handled messages
+	//
+	return CallWindowProc((WNDPROC)OldGraphWndProc, hWnd, message, wParam, lParam);
+}
+
+void Graph_DrawCpuUsageGraph(HDC hDC, HWND hWnd)
+{
+	RECT			rcClient;
+	RECT			rcBarLeft;
+	RECT			rcBarRight;
+	TCHAR			Text[260];
+	ULONG			CpuUsage;
+	ULONG			CpuKernelUsage;
+	int				nBars;
+	int				nBarsUsed; // Bottom bars that are "used", i.e. are bright green, representing used cpu time
+	int				nBarsUsedKernel; // Bottom bars that are "used", i.e. are bright green, representing used cpu kernel time
+	int				nBarsFree; // Top bars that are "unused", i.e. are dark green, representing free cpu time
+	int				i;
+	
+	//
+	// Get the client area rectangle
+	//
+	GetClientRect(hWnd, &rcClient);
+	
+	//
+	// Fill it with blackness
+	//
+	FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
+	
+	//
+	// Get the CPU usage
+	//
+	CpuUsage = PerfDataGetProcessorUsage();
+	CpuKernelUsage = PerfDataGetProcessorSystemUsage();
+	
+	//
+	// Check and see how many digits it will take
+	// so we get the indentation right every time.
+	//
+	if (CpuUsage == 100)
+	{
+		sprintf(Text, "%d%%", CpuUsage);
+	}
+	else if (CpuUsage < 10)
+	{
+		sprintf(Text, "  %d%%", CpuUsage);
+	}
+	else
+	{
+		sprintf(Text, " %d%%", CpuUsage);
+	}
+	
+	//
+	// Draw the font text onto the graph
+	// The bottom 20 pixels are reserved for the text
+	//
+	Font_DrawText(hDC, Text, ((rcClient.right - rcClient.left) - 32) / 2, rcClient.bottom - 11 - 5);
+
+	//
+	// Now we have to draw the graph
+	// So first find out how many bars we can fit
+	//
+	nBars = ((rcClient.bottom - rcClient.top) - 25) / 3;
+	nBarsUsed = (nBars * CpuUsage) / 100;
+	if ((CpuUsage) && (nBarsUsed == 0))
+	{
+		nBarsUsed = 1;
+	}
+	nBarsFree = nBars - nBarsUsed;
+	if (TaskManagerSettings.ShowKernelTimes)
+	{
+		nBarsUsedKernel = ((nBars * 2) * CpuKernelUsage) / 100;
+		nBarsUsed -= (nBarsUsedKernel / 2);
+	}
+	else
+	{
+		nBarsUsedKernel = 0;
+	}
+
+	//
+	// Now draw the bar graph
+	//
+	rcBarLeft.left =  ((rcClient.right - rcClient.left) - 33) / 2;
+	rcBarLeft.right =  rcBarLeft.left + 16;
+	rcBarRight.left = rcBarLeft.left + 17;
+	rcBarRight.right = rcBarLeft.right + 17;
+	rcBarLeft.top = rcBarRight.top = 5;
+	rcBarLeft.bottom = rcBarRight.bottom = 7;
+	
+	//
+	// Draw the "free" bars
+	//
+	for (i=0; i<nBarsFree; i++)
+	{
+		FillSolidRect(hDC, &rcBarLeft, DARK_GREEN);
+		FillSolidRect(hDC, &rcBarRight, DARK_GREEN);
+		
+		rcBarLeft.top += 3;
+		rcBarLeft.bottom += 3;
+		
+		rcBarRight.top += 3;
+		rcBarRight.bottom += 3;
+	}
+	
+	//
+	// Draw the "used" bars
+	//
+	for (i=0; i<nBarsUsed; i++)
+	{
+		FillSolidRect(hDC, &rcBarLeft, BRIGHT_GREEN);
+		FillSolidRect(hDC, &rcBarRight, BRIGHT_GREEN);
+		
+		rcBarLeft.top += 3;
+		rcBarLeft.bottom += 3;
+		
+		rcBarRight.top += 3;
+		rcBarRight.bottom += 3;
+	}
+	
+	//
+	// Draw the "used" kernel bars
+	//
+	rcBarLeft.bottom--;
+	rcBarRight.bottom--;
+	if (nBarsUsedKernel % 2)
+	{
+		rcBarLeft.top -= 2;
+		rcBarLeft.bottom -= 2;
+		
+		rcBarRight.top -= 2;
+		rcBarRight.bottom -= 2;
+
+		FillSolidRect(hDC, &rcBarLeft, RED);
+		FillSolidRect(hDC, &rcBarRight, RED);
+		
+		rcBarLeft.top += 2;
+		rcBarLeft.bottom += 2;
+		
+		rcBarRight.top += 2;
+		rcBarRight.bottom += 2;
+
+		nBarsUsedKernel--;
+	}
+	for (i=0; i<nBarsUsedKernel; i++)
+	{
+		FillSolidRect(hDC, &rcBarLeft, RED);
+		FillSolidRect(hDC, &rcBarRight, RED);
+		
+		rcBarLeft.top++;
+		rcBarLeft.bottom++;
+		
+		rcBarRight.top++;
+		rcBarRight.bottom++;
+
+		if (i % 2)
+		{
+			rcBarLeft.top++;
+			rcBarLeft.bottom++;
+			
+			rcBarRight.top++;
+			rcBarRight.bottom++;
+		}
+	}
+}
+
+void Graph_DrawMemUsageGraph(HDC hDC, HWND hWnd)
+{
+	RECT			rcClient;
+	RECT			rcBarLeft;
+	RECT			rcBarRight;
+	TCHAR			Text[260];
+	ULONGLONG		CommitChargeTotal;
+	ULONGLONG		CommitChargeLimit;
+	int				nBars;
+	int				nBarsUsed; // Bottom bars that are "used", i.e. are bright green, representing used memory
+	int				nBarsFree; // Top bars that are "unused", i.e. are dark green, representing free memory
+	int				i;
+	
+	//
+	// Get the client area rectangle
+	//
+	GetClientRect(hWnd, &rcClient);
+	
+	//
+	// Fill it with blackness
+	//
+	FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
+	
+	//
+	// Get the memory usage
+	//
+	CommitChargeTotal = (ULONGLONG)PerfDataGetCommitChargeTotalK();
+	CommitChargeLimit = (ULONGLONG)PerfDataGetCommitChargeLimitK();
+
+	sprintf(Text, "%dK", CommitChargeTotal);
+	
+	//
+	// Draw the font text onto the graph
+	// The bottom 20 pixels are reserved for the text
+	//
+	Font_DrawText(hDC, Text, ((rcClient.right - rcClient.left) - (strlen(Text) * 8)) / 2, rcClient.bottom - 11 - 5);
+
+	//
+	// Now we have to draw the graph
+	// So first find out how many bars we can fit
+	//
+	nBars = ((rcClient.bottom - rcClient.top) - 25) / 3;
+	nBarsUsed = (nBars * (int)((CommitChargeTotal * 100) / CommitChargeLimit)) / 100;
+	nBarsFree = nBars - nBarsUsed;
+
+	//
+	// Now draw the bar graph
+	//
+	rcBarLeft.left =  ((rcClient.right - rcClient.left) - 33) / 2;
+	rcBarLeft.right =  rcBarLeft.left + 16;
+	rcBarRight.left = rcBarLeft.left + 17;
+	rcBarRight.right = rcBarLeft.right + 17;
+	rcBarLeft.top = rcBarRight.top = 5;
+	rcBarLeft.bottom = rcBarRight.bottom = 7;
+	
+	//
+	// Draw the "free" bars
+	//
+	for (i=0; i<nBarsFree; i++)
+	{
+		FillSolidRect(hDC, &rcBarLeft, DARK_GREEN);
+		FillSolidRect(hDC, &rcBarRight, DARK_GREEN);
+		
+		rcBarLeft.top += 3;
+		rcBarLeft.bottom += 3;
+		
+		rcBarRight.top += 3;
+		rcBarRight.bottom += 3;
+	}
+	
+	//
+	// Draw the "used" bars
+	//
+	for (i=0; i<nBarsUsed; i++)
+	{
+		FillSolidRect(hDC, &rcBarLeft, BRIGHT_GREEN);
+		FillSolidRect(hDC, &rcBarRight, BRIGHT_GREEN);
+		
+		rcBarLeft.top += 3;
+		rcBarLeft.bottom += 3;
+		
+		rcBarRight.top += 3;
+		rcBarRight.bottom += 3;
+	}
+}
+
+void Graph_DrawMemUsageHistoryGraph(HDC hDC, HWND hWnd)
+{
+	RECT			rcClient;
+	ULONGLONG		CommitChargeLimit;
+	int				i;
+	static int		offset = 0;
+	
+	if (offset++ >= 10)
+		offset = 0;
+	
+	//
+	// Get the client area rectangle
+	//
+	GetClientRect(hWnd, &rcClient);
+	
+	//
+	// Fill it with blackness
+	//
+	FillSolidRect(hDC, &rcClient, RGB(0, 0, 0));
+	
+	//
+	// Get the memory usage
+	//
+	CommitChargeLimit = (ULONGLONG)PerfDataGetCommitChargeLimitK();
+
+	//
+	// Draw the graph background
+	//
+	// Draw the horizontal bars
+	//
+	for (i=0; i<rcClient.bottom; i++)
+	{
+		if ((i % 11) == 0)
+		{
+			FillSolidRect(hDC, 0, i, rcClient.right, 1, DARK_GREEN);
+		}
+	}
+	//
+	// Draw the vertical bars
+	//
+	for (i=11; i<rcClient.right + offset; i++)
+	{
+		if ((i % 11) == 0)
+		{
+			FillSolidRect(hDC, i - offset, 0, 1, rcClient.bottom, DARK_GREEN);
+		}
+	}
+
+	//
+	// Draw the memory usage
+	//
+	for (i=rcClient.right; i>=0; i--)
+	{
+	}
+}
\ No newline at end of file
diff --git a/rosapps/taskmgr/graph.h b/rosapps/taskmgr/graph.h
new file mode 100644
index 00000000000..0dfdf0a35f7
--- /dev/null
+++ b/rosapps/taskmgr/graph.h
@@ -0,0 +1,35 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  graph.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __GRAPH_H
+#define __GRAPH_H
+
+
+#define BRIGHT_GREEN	RGB(0, 255, 0)
+#define DARK_GREEN		RGB(0, 130, 0)
+#define RED				RGB(255, 0, 0)
+
+extern	LONG				OldGraphWndProc;
+
+LRESULT CALLBACK	Graph_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+#endif // __GRAPH_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/optnmenu.cpp b/rosapps/taskmgr/optnmenu.cpp
new file mode 100644
index 00000000000..d44876e0932
--- /dev/null
+++ b/rosapps/taskmgr/optnmenu.cpp
@@ -0,0 +1,141 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  optnmenu.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+//
+// options.c
+//
+// Menu item handlers for the options menu.
+//
+
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "optnmenu.h"
+#include "ProcessPage.h"
+
+#define OPTIONS_MENU_INDEX	1
+
+void TaskManager_OnOptionsAlwaysOnTop(void)
+{
+	HMENU	hMenu;
+	HMENU	hOptionsMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hOptionsMenu = GetSubMenu(hMenu, OPTIONS_MENU_INDEX);
+
+	//
+	// Check or uncheck the always on top menu item
+	// and update main window.
+	//
+	if (GetMenuState(hOptionsMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND) & MF_CHECKED)
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_UNCHECKED);
+		TaskManagerSettings.AlwaysOnTop = FALSE;
+		SetWindowPos(hMainWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+	}
+	else
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND|MF_CHECKED);
+		TaskManagerSettings.AlwaysOnTop = TRUE;
+		SetWindowPos(hMainWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+	}
+}
+
+void TaskManager_OnOptionsMinimizeOnUse(void)
+{
+	HMENU	hMenu;
+	HMENU	hOptionsMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hOptionsMenu = GetSubMenu(hMenu, OPTIONS_MENU_INDEX);
+
+	//
+	// Check or uncheck the minimize on use menu item.
+	//
+	if (GetMenuState(hOptionsMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND) & MF_CHECKED)
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_UNCHECKED);
+		TaskManagerSettings.MinimizeOnUse = FALSE;
+	}
+	else
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_MINIMIZEONUSE, MF_BYCOMMAND|MF_CHECKED);
+		TaskManagerSettings.MinimizeOnUse = TRUE;
+	}
+}
+
+void TaskManager_OnOptionsHideWhenMinimized(void)
+{
+	HMENU	hMenu;
+	HMENU	hOptionsMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hOptionsMenu = GetSubMenu(hMenu, OPTIONS_MENU_INDEX);
+
+	//
+	// Check or uncheck the hide when minimized menu item.
+	//
+	if (GetMenuState(hOptionsMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND) & MF_CHECKED)
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_UNCHECKED);
+		TaskManagerSettings.HideWhenMinimized = FALSE;
+	}
+	else
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_HIDEWHENMINIMIZED, MF_BYCOMMAND|MF_CHECKED);
+		TaskManagerSettings.HideWhenMinimized = TRUE;
+	}
+}
+
+void TaskManager_OnOptionsShow16BitTasks(void)
+{
+	HMENU	hMenu;
+	HMENU	hOptionsMenu;
+
+	hMenu = GetMenu(hMainWnd);
+	hOptionsMenu = GetSubMenu(hMenu, OPTIONS_MENU_INDEX);
+
+	//
+	// FIXME: Currently this is useless because the
+	// current implemetation doesn't list the 16-bit
+	// processes. I believe that would require querying
+	// each ntvdm.exe process for it's children.
+	//
+
+	//
+	// Check or uncheck the show 16-bit tasks menu item
+	//
+	if (GetMenuState(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND) & MF_CHECKED)
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_UNCHECKED);
+		TaskManagerSettings.Show16BitTasks = FALSE;
+	}
+	else
+	{
+		CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
+		TaskManagerSettings.Show16BitTasks = TRUE;
+	}
+
+	//
+	// Refresh the list of processes.
+	//
+	RefreshProcessPage();
+}
diff --git a/rosapps/taskmgr/optnmenu.h b/rosapps/taskmgr/optnmenu.h
new file mode 100644
index 00000000000..a50bdc28a57
--- /dev/null
+++ b/rosapps/taskmgr/optnmenu.h
@@ -0,0 +1,37 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  optnmenu.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+//
+// options.h
+//
+// Menu item handlers for the options menu.
+//
+
+#ifndef __OPTIONS_H
+#define __OPTIONS_H
+
+void TaskManager_OnOptionsAlwaysOnTop(void);
+void TaskManager_OnOptionsMinimizeOnUse(void);
+void TaskManager_OnOptionsHideWhenMinimized(void);
+void TaskManager_OnOptionsShow16BitTasks(void);
+
+#endif // __OPTIONS_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/perfdata.cpp b/rosapps/taskmgr/perfdata.cpp
new file mode 100644
index 00000000000..a6954ea4b6a
--- /dev/null
+++ b/rosapps/taskmgr/perfdata.cpp
@@ -0,0 +1,865 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  perfdata.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "TASKMGR.h"
+#include "perfdata.h"
+
+PROCNTQSI						NtQuerySystemInformation = NULL;
+PROCGGR							GetGuiResources = NULL;
+PROCGPIC						GetProcessIoCounters = NULL;
+CRITICAL_SECTION				PerfDataCriticalSection;
+PPERFDATA						pPerfDataOld = NULL;	// Older perf data (saved to establish delta values)
+PPERFDATA						pPerfData = NULL;		// Most recent copy of perf data
+ULONG							ProcessCountOld = 0;
+ULONG							ProcessCount = 0;
+double							dbIdleTime;
+double							dbKernelTime;
+double							dbSystemTime;
+LARGE_INTEGER					liOldIdleTime = {0,0};
+double							OldKernelTime = 0;
+LARGE_INTEGER					liOldSystemTime = {0,0};
+SYSTEM_PERFORMANCE_INFORMATION	SystemPerfInfo;
+SYSTEM_BASIC_INFORMATION		SystemBasicInfo;
+SYSTEM_CACHE_INFORMATION		SystemCacheInfo;
+SYSTEM_HANDLE_INFORMATION		SystemHandleInfo;
+PSYSTEM_PROCESSORTIME_INFO		SystemProcessorTimeInfo = NULL;
+
+BOOL PerfDataInitialize(void)
+{
+	LONG	status;
+
+	NtQuerySystemInformation = (PROCNTQSI)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtQuerySystemInformation");
+	GetGuiResources = (PROCGGR)GetProcAddress(GetModuleHandle("user32.dll"), "GetGuiResources");
+	GetProcessIoCounters = (PROCGPIC)GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProcessIoCounters");
+	
+	InitializeCriticalSection(&PerfDataCriticalSection);
+	
+	if (!NtQuerySystemInformation)
+		return FALSE;
+	
+	//
+	// Get number of processors in the system
+	//
+	status = NtQuerySystemInformation(SystemBasicInformation, &SystemBasicInfo, sizeof(SystemBasicInfo), NULL);
+	if (status != NO_ERROR)
+		return FALSE;
+	
+	return TRUE;
+}
+
+void PerfDataUninitialize(void)
+{
+	NtQuerySystemInformation = NULL;
+
+	DeleteCriticalSection(&PerfDataCriticalSection);
+}
+
+void PerfDataRefresh(void)
+{
+	ULONG							ulSize;
+	LONG							status;
+	LPBYTE							pBuffer;
+	ULONG							BufferSize;
+	PSYSTEM_PROCESS_INFORMATION		pSPI;
+	PPERFDATA						pPDOld;
+	ULONG							Idx, Idx2;
+	HANDLE							hProcess;
+	HANDLE							hProcessToken;
+	TCHAR							szTemp[MAX_PATH];
+	DWORD							dwSize;
+	SYSTEM_PERFORMANCE_INFORMATION	SysPerfInfo;
+	SYSTEM_TIME_INFORMATION			SysTimeInfo;
+	SYSTEM_CACHE_INFORMATION		SysCacheInfo;
+	LPBYTE							SysHandleInfoData;
+	PSYSTEM_PROCESSORTIME_INFO		SysProcessorTimeInfo;
+	double							CurrentKernelTime;
+	
+
+	if (!NtQuerySystemInformation)
+		return;
+
+	// Get new system time
+	status = NtQuerySystemInformation(SystemTimeInformation, &SysTimeInfo, sizeof(SysTimeInfo), 0);
+	if (status != NO_ERROR)
+		return;
+
+	// Get new CPU's idle time
+	status = NtQuerySystemInformation(SystemPerformanceInformation, &SysPerfInfo, sizeof(SysPerfInfo), NULL);
+	if (status != NO_ERROR)
+		return;
+
+	// Get system cache information
+	status = NtQuerySystemInformation(SystemCacheInformation, &SysCacheInfo, sizeof(SysCacheInfo), NULL);
+	if (status != NO_ERROR)
+		return;
+	
+	// Get processor time information
+	SysProcessorTimeInfo = new SYSTEM_PROCESSORTIME_INFO[SystemBasicInfo.bKeNumberProcessors];
+	status = NtQuerySystemInformation(SystemProcessorTimeInformation, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSORTIME_INFO) * SystemBasicInfo.bKeNumberProcessors, &ulSize);
+	if (status != NO_ERROR)
+		return;
+	
+	// Get handle information
+	// We don't know how much data there is so just keep
+	// increasing the buffer size until the call succeeds
+	BufferSize = 0;
+	do
+	{
+		BufferSize += 0x10000;
+		SysHandleInfoData = new BYTE[BufferSize];
+		
+		status = NtQuerySystemInformation(SystemHandleInformation, SysHandleInfoData, BufferSize, &ulSize);
+		
+		if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/)
+			delete[] SysHandleInfoData;
+		
+	} while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
+
+	// Get process information
+	// We don't know how much data there is so just keep
+	// increasing the buffer size until the call succeeds
+	BufferSize = 0;
+	do
+	{
+		BufferSize += 0x10000;
+		pBuffer = new BYTE[BufferSize];
+
+		status = NtQuerySystemInformation(SystemProcessInformation, pBuffer, BufferSize, &ulSize);
+
+		if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/)
+			delete[] pBuffer;
+
+	} while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	//
+	// Save system performance info
+	//
+	memcpy(&SystemPerfInfo, &SysPerfInfo, sizeof(SYSTEM_PERFORMANCE_INFORMATION));
+
+	//
+	// Save system cache info
+	//
+	memcpy(&SystemCacheInfo, &SysCacheInfo, sizeof(SYSTEM_CACHE_INFORMATION));
+	
+	//
+	// Save system processor time info
+	//
+	if (SystemProcessorTimeInfo)
+	{
+		delete[] SystemProcessorTimeInfo;
+	}
+	SystemProcessorTimeInfo = SysProcessorTimeInfo;
+	
+	//
+	// Save system handle info
+	//
+	memcpy(&SystemHandleInfo, SysHandleInfoData, sizeof(SYSTEM_HANDLE_INFORMATION));
+	delete[] SysHandleInfoData;
+	
+	for (CurrentKernelTime=0, Idx=0; Idx<SystemBasicInfo.bKeNumberProcessors; Idx++)
+	{
+		CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].KernelTime);
+		CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].DpcTime);
+		CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].InterruptTime);
+	}
+
+	// If it's a first call - skip idle time calcs
+	if (liOldIdleTime.QuadPart != 0)
+	{
+		// CurrentValue = NewValue - OldValue
+		dbIdleTime = Li2Double(SysPerfInfo.liIdleTime) - Li2Double(liOldIdleTime);
+		dbKernelTime = CurrentKernelTime - OldKernelTime;
+		dbSystemTime = Li2Double(SysTimeInfo.liKeSystemTime) - Li2Double(liOldSystemTime);
+
+		// CurrentCpuIdle = IdleTime / SystemTime
+		dbIdleTime = dbIdleTime / dbSystemTime;
+		dbKernelTime = dbKernelTime / dbSystemTime;
+		
+		// CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors
+		dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors;// + 0.5;
+		dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors;// + 0.5;
+	}
+
+	// Store new CPU's idle and system time
+	liOldIdleTime = SysPerfInfo.liIdleTime;
+	liOldSystemTime = SysTimeInfo.liKeSystemTime;
+	OldKernelTime = CurrentKernelTime;
+
+	// Determine the process count
+	// We loop through the data we got from NtQuerySystemInformation
+	// and count how many structures there are (until RelativeOffset is 0)
+	ProcessCountOld = ProcessCount;
+	ProcessCount = 0;
+	pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
+	while (pSPI)
+	{
+		ProcessCount++;
+
+		if (pSPI->RelativeOffset == 0)
+			break;
+
+		pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->RelativeOffset);
+	}
+
+	// Now alloc a new PERFDATA array and fill in the data
+	if (pPerfDataOld)
+		delete[] pPerfDataOld;
+	pPerfDataOld = pPerfData;
+	pPerfData = new PERFDATA[ProcessCount];
+	pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
+	for (Idx=0; Idx<ProcessCount; Idx++)
+	{
+		// Get the old perf data for this process (if any)
+		// so that we can establish delta values
+		pPDOld = NULL;
+		for (Idx2=0; Idx2<ProcessCountOld; Idx2++)
+		{
+			if (pPerfDataOld[Idx2].ProcessId == pSPI->ProcessId)
+			{
+				pPDOld = &pPerfDataOld[Idx2];
+				break;
+			}
+		}
+
+		// Clear out process perf data structure
+		memset(&pPerfData[Idx], 0, sizeof(PERFDATA));
+
+		if (pSPI->Name.Buffer)
+			wcscpy(pPerfData[Idx].ImageName, pSPI->Name.Buffer);
+		else
+			wcscpy(pPerfData[Idx].ImageName, L"System Idle Process");
+
+		pPerfData[Idx].ProcessId = pSPI->ProcessId;
+
+		if (pPDOld)
+		{
+			double	CurTime = Li2Double(pSPI->KernelTime) + Li2Double(pSPI->UserTime);
+			double	OldTime = Li2Double(pPDOld->KernelTime) + Li2Double(pPDOld->UserTime);
+
+			double	CpuTime = (CurTime - OldTime) / dbSystemTime;
+
+			CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors;// + 0.5;
+
+			pPerfData[Idx].CPUUsage = (ULONG)CpuTime;
+		}
+		pPerfData[Idx].CPUTime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;
+		pPerfData[Idx].WorkingSetSizeBytes = pSPI->TotalWorkingSetSizeBytes;
+		pPerfData[Idx].PeakWorkingSetSizeBytes = pSPI->PeakWorkingSetSizeBytes;
+		if (pPDOld)
+			pPerfData[Idx].WorkingSetSizeDelta = labs((LONG)pSPI->TotalWorkingSetSizeBytes - (LONG)pPDOld->WorkingSetSizeBytes);
+		else
+			pPerfData[Idx].WorkingSetSizeDelta = 0;
+		pPerfData[Idx].PageFaultCount = pSPI->PageFaultCount;
+		if (pPDOld)
+			pPerfData[Idx].PageFaultCountDelta = labs((LONG)pSPI->PageFaultCount - (LONG)pPDOld->PageFaultCount);
+		else
+			pPerfData[Idx].PageFaultCountDelta = 0;
+		pPerfData[Idx].VirtualMemorySizeBytes = pSPI->TotalVirtualSizeBytes;
+		pPerfData[Idx].PagedPoolUsagePages = pSPI->TotalPagedPoolUsagePages;
+		pPerfData[Idx].NonPagedPoolUsagePages = pSPI->TotalNonPagedPoolUsagePages;
+		pPerfData[Idx].BasePriority = pSPI->BasePriority;
+		pPerfData[Idx].HandleCount = pSPI->HandleCount;
+		pPerfData[Idx].ThreadCount = pSPI->ThreadCount;
+
+		pPerfData[Idx].SessionId = pSPI->SessionId;
+		
+		hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pSPI->ProcessId);
+		if (hProcess)
+		{
+			if (OpenProcessToken(hProcess, TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_IMPERSONATE, &hProcessToken))
+			{
+				ImpersonateLoggedOnUser(hProcessToken);
+				memset(szTemp, 0, sizeof(TCHAR[MAX_PATH]));
+				dwSize = MAX_PATH;
+				GetUserName(szTemp, &dwSize);
+				MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szTemp, -1, pPerfData[Idx].UserName, MAX_PATH);
+				RevertToSelf();
+				
+				CloseHandle(hProcessToken);
+			}
+			
+			if (GetGuiResources)
+			{
+				pPerfData[Idx].USERObjectCount = GetGuiResources(hProcess, GR_USEROBJECTS);
+				pPerfData[Idx].GDIObjectCount = GetGuiResources(hProcess, GR_GDIOBJECTS);
+			}
+			if (GetProcessIoCounters)
+				GetProcessIoCounters(hProcess, &pPerfData[Idx].IOCounters);
+			
+			CloseHandle(hProcess);
+		}
+		
+		pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
+		pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
+		
+		pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->RelativeOffset);
+	}
+
+	delete[] pBuffer;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+}
+
+ULONG PerfDataGetProcessCount(void)
+{
+	return ProcessCount;
+}
+
+ULONG PerfDataGetProcessorUsage(void)
+{
+	return (ULONG)dbIdleTime;
+}
+
+ULONG PerfDataGetProcessorSystemUsage(void)
+{
+	return (ULONG)dbKernelTime;
+}
+
+BOOL PerfDataGetImageName(ULONG Index, LPTSTR lpImageName, int nMaxCount)
+{
+	BOOL	bSuccessful;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+	{
+		#ifdef _UNICODE
+			wcsncpy(lpImageName, pPerfData[Index].ImageName, nMaxCount);
+		#else
+			WideCharToMultiByte(CP_ACP, 0, pPerfData[Index].ImageName, -1, lpImageName, nMaxCount, NULL, NULL);
+		#endif
+
+		bSuccessful = TRUE;
+	}
+	else
+		bSuccessful = FALSE;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return bSuccessful;
+}
+
+ULONG PerfDataGetProcessId(ULONG Index)
+{
+	ULONG	ProcessId;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		ProcessId = pPerfData[Index].ProcessId;
+	else
+		ProcessId = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return ProcessId;
+}
+
+BOOL PerfDataGetUserName(ULONG Index, LPTSTR lpUserName, int nMaxCount)
+{
+	BOOL	bSuccessful;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+	{
+		#ifdef _UNICODE
+			wcsncpy(lpUserName, pPerfData[Index].UserName, nMaxCount);
+		#else
+			WideCharToMultiByte(CP_ACP, 0, pPerfData[Index].UserName, -1, lpUserName, nMaxCount, NULL, NULL);
+		#endif
+
+		bSuccessful = TRUE;
+	}
+	else
+		bSuccessful = FALSE;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return bSuccessful;
+}
+
+ULONG PerfDataGetSessionId(ULONG Index)
+{
+	ULONG	SessionId;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		SessionId = pPerfData[Index].SessionId;
+	else
+		SessionId = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return SessionId;
+}
+
+ULONG PerfDataGetCPUUsage(ULONG Index)
+{
+	ULONG	CpuUsage;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		CpuUsage = pPerfData[Index].CPUUsage;
+	else
+		CpuUsage = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return CpuUsage;
+}
+
+TIME PerfDataGetCPUTime(ULONG Index)
+{
+	TIME	CpuTime = {0,0};
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		CpuTime = pPerfData[Index].CPUTime;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return CpuTime;
+}
+
+ULONG PerfDataGetWorkingSetSizeBytes(ULONG Index)
+{
+	ULONG	WorkingSetSizeBytes;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		WorkingSetSizeBytes = pPerfData[Index].WorkingSetSizeBytes;
+	else
+		WorkingSetSizeBytes = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return WorkingSetSizeBytes;
+}
+
+ULONG PerfDataGetPeakWorkingSetSizeBytes(ULONG Index)
+{
+	ULONG	PeakWorkingSetSizeBytes;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		PeakWorkingSetSizeBytes = pPerfData[Index].PeakWorkingSetSizeBytes;
+	else
+		PeakWorkingSetSizeBytes = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return PeakWorkingSetSizeBytes;
+}
+
+ULONG PerfDataGetWorkingSetSizeDelta(ULONG Index)
+{
+	ULONG	WorkingSetSizeDelta;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		WorkingSetSizeDelta = pPerfData[Index].WorkingSetSizeDelta;
+	else
+		WorkingSetSizeDelta = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return WorkingSetSizeDelta;
+}
+
+ULONG PerfDataGetPageFaultCount(ULONG Index)
+{
+	ULONG	PageFaultCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		PageFaultCount = pPerfData[Index].PageFaultCount;
+	else
+		PageFaultCount = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return PageFaultCount;
+}
+
+ULONG PerfDataGetPageFaultCountDelta(ULONG Index)
+{
+	ULONG	PageFaultCountDelta;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		PageFaultCountDelta = pPerfData[Index].PageFaultCountDelta;
+	else
+		PageFaultCountDelta = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return PageFaultCountDelta;
+}
+
+ULONG PerfDataGetVirtualMemorySizeBytes(ULONG Index)
+{
+	ULONG	VirtualMemorySizeBytes;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		VirtualMemorySizeBytes = pPerfData[Index].VirtualMemorySizeBytes;
+	else
+		VirtualMemorySizeBytes = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return VirtualMemorySizeBytes;
+}
+
+ULONG PerfDataGetPagedPoolUsagePages(ULONG Index)
+{
+	ULONG	PagedPoolUsagePages;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		PagedPoolUsagePages = pPerfData[Index].PagedPoolUsagePages;
+	else
+		PagedPoolUsagePages = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return PagedPoolUsagePages;
+}
+
+ULONG PerfDataGetNonPagedPoolUsagePages(ULONG Index)
+{
+	ULONG	NonPagedPoolUsagePages;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		NonPagedPoolUsagePages = pPerfData[Index].NonPagedPoolUsagePages;
+	else
+		NonPagedPoolUsagePages = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return NonPagedPoolUsagePages;
+}
+
+ULONG PerfDataGetBasePriority(ULONG Index)
+{
+	ULONG	BasePriority;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		BasePriority = pPerfData[Index].BasePriority;
+	else
+		BasePriority = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return BasePriority;
+}
+
+ULONG PerfDataGetHandleCount(ULONG Index)
+{
+	ULONG	HandleCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		HandleCount = pPerfData[Index].HandleCount;
+	else
+		HandleCount = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return HandleCount;
+}
+
+ULONG PerfDataGetThreadCount(ULONG Index)
+{
+	ULONG	ThreadCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		ThreadCount = pPerfData[Index].ThreadCount;
+	else
+		ThreadCount = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return ThreadCount;
+}
+
+ULONG PerfDataGetUSERObjectCount(ULONG Index)
+{
+	ULONG	USERObjectCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		USERObjectCount = pPerfData[Index].USERObjectCount;
+	else
+		USERObjectCount = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return USERObjectCount;
+}
+
+ULONG PerfDataGetGDIObjectCount(ULONG Index)
+{
+	ULONG	GDIObjectCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+		GDIObjectCount = pPerfData[Index].GDIObjectCount;
+	else
+		GDIObjectCount = 0;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return GDIObjectCount;
+}
+
+BOOL PerfDataGetIOCounters(ULONG Index, PIO_COUNTERS pIoCounters)
+{
+	BOOL	bSuccessful;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	if (Index < ProcessCount)
+	{
+		memcpy(pIoCounters, &pPerfData[Index].IOCounters, sizeof(IO_COUNTERS));
+		bSuccessful = TRUE;
+	}
+	else
+		bSuccessful = FALSE;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return bSuccessful;
+}
+
+ULONG PerfDataGetCommitChargeTotalK(void)
+{
+	ULONG	Total;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Total = SystemPerfInfo.MmTotalCommitedPages;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Total = Total * (PageSize / 1024);
+
+	return Total;
+}
+
+ULONG PerfDataGetCommitChargeLimitK(void)
+{
+	ULONG	Limit;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Limit = SystemPerfInfo.MmTotalCommitLimit;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Limit = Limit * (PageSize / 1024);
+
+	return Limit;
+}
+
+ULONG PerfDataGetCommitChargePeakK(void)
+{
+	ULONG	Peak;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Peak = SystemPerfInfo.MmPeakLimit;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Peak = Peak * (PageSize / 1024);
+
+	return Peak;
+}
+
+ULONG PerfDataGetKernelMemoryTotalK(void)
+{
+	ULONG	Total;
+	ULONG	Paged;
+	ULONG	NonPaged;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Paged = SystemPerfInfo.PoolPagedBytes;
+	NonPaged = SystemPerfInfo.PoolNonPagedBytes;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Paged = Paged * (PageSize / 1024);
+	NonPaged = NonPaged * (PageSize / 1024);
+
+	Total = Paged + NonPaged;
+
+	return Total;
+}
+
+ULONG PerfDataGetKernelMemoryPagedK(void)
+{
+	ULONG	Paged;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Paged = SystemPerfInfo.PoolPagedBytes;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Paged = Paged * (PageSize / 1024);
+
+	return Paged;
+}
+
+ULONG PerfDataGetKernelMemoryNonPagedK(void)
+{
+	ULONG	NonPaged;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	NonPaged = SystemPerfInfo.PoolNonPagedBytes;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	NonPaged = NonPaged * (PageSize / 1024);
+
+	return NonPaged;
+}
+
+ULONG PerfDataGetPhysicalMemoryTotalK(void)
+{
+	ULONG	Total;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Total = SystemBasicInfo.uMmNumberOfPhysicalPages;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Total = Total * (PageSize / 1024);
+
+	return Total;
+}
+
+ULONG PerfDataGetPhysicalMemoryAvailableK(void)
+{
+	ULONG	Available;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	Available = SystemPerfInfo.MmAvailablePages;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	Available = Available * (PageSize / 1024);
+
+	return Available;
+}
+
+ULONG PerfDataGetPhysicalMemorySystemCacheK(void)
+{
+	ULONG	SystemCache;
+	ULONG	PageSize;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	SystemCache = SystemCacheInfo.CurrentSize;
+	PageSize = SystemBasicInfo.uPageSize;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	//SystemCache = SystemCache * (PageSize / 1024);
+	SystemCache = SystemCache / 1024;
+
+	return SystemCache;
+}
+
+ULONG PerfDataGetSystemHandleCount(void)
+{
+	ULONG	HandleCount;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	HandleCount = SystemHandleInfo.Count;
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return HandleCount;
+}
+
+ULONG PerfDataGetTotalThreadCount(void)
+{
+	ULONG	ThreadCount = 0;
+	ULONG	i;
+
+	EnterCriticalSection(&PerfDataCriticalSection);
+
+	for (i=0; i<ProcessCount; i++)
+	{
+		ThreadCount += pPerfData[i].ThreadCount;
+	}
+
+	LeaveCriticalSection(&PerfDataCriticalSection);
+
+	return ThreadCount;
+}
diff --git a/rosapps/taskmgr/perfdata.h b/rosapps/taskmgr/perfdata.h
new file mode 100644
index 00000000000..b70fa39364e
--- /dev/null
+++ b/rosapps/taskmgr/perfdata.h
@@ -0,0 +1,423 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  perfdata.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __PERFDATA_H
+#define __PERFDATA_H
+
+#if 0
+typedef struct _TIME {
+	DWORD LowPart;
+	LONG HighPart;
+} TIME, *PTIME;
+#endif
+
+typedef ULARGE_INTEGER	TIME, *PTIME;
+
+//typedef WCHAR			UNICODE_STRING;
+typedef struct _UNICODE_STRING {
+    USHORT	Length;
+    USHORT	MaximumLength;
+    PWSTR	Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+typedef struct _IO_COUNTERS {
+    ULONGLONG	ReadOperationCount;
+    ULONGLONG	WriteOperationCount;
+    ULONGLONG	OtherOperationCount;
+    ULONGLONG	ReadTransferCount;
+    ULONGLONG	WriteTransferCount;
+    ULONGLONG	OtherTransferCount;
+} IO_COUNTERS;
+
+typedef IO_COUNTERS *PIO_COUNTERS;
+
+typedef struct _PERFDATA
+{
+	WCHAR				ImageName[MAX_PATH];
+	ULONG				ProcessId;
+	WCHAR				UserName[MAX_PATH];
+	ULONG				SessionId;
+	ULONG				CPUUsage;
+	TIME				CPUTime;
+	ULONG				WorkingSetSizeBytes;
+	ULONG				PeakWorkingSetSizeBytes;
+	ULONG				WorkingSetSizeDelta;
+	ULONG				PageFaultCount;
+	ULONG				PageFaultCountDelta;
+	ULONG				VirtualMemorySizeBytes;
+	ULONG				PagedPoolUsagePages;
+	ULONG				NonPagedPoolUsagePages;
+	ULONG				BasePriority;
+	ULONG				HandleCount;
+	ULONG				ThreadCount;
+	ULONG				USERObjectCount;
+	ULONG				GDIObjectCount;
+	IO_COUNTERS			IOCounters;
+
+	TIME				UserTime;
+	TIME				KernelTime;
+} PERFDATA, *PPERFDATA;
+
+typedef struct _CLIENT_ID
+{
+    HANDLE UniqueProcess;
+    HANDLE UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
+
+typedef enum _KWAIT_REASON
+{
+   Executive,
+   FreePage,
+   PageIn,
+   PoolAllocation,
+   DelayExecution,
+   Suspended,
+   UserRequest,
+   WrExecutive,
+   WrFreePage,
+   WrPageIn,
+   WrDelayExecution,
+   WrSuspended,
+   WrUserRequest,
+   WrQueue,
+   WrLpcReceive,
+   WrLpcReply,
+   WrVirtualMemory,
+   WrPageOut,
+   WrRendezvous,
+   Spare2,
+   Spare3,
+   Spare4,
+   Spare5,
+   Spare6,
+   WrKernel,
+   MaximumWaitReason,
+} KWAIT_REASON;
+
+// SystemProcessThreadInfo (5)
+typedef struct _SYSTEM_THREAD_INFORMATION
+{
+	TIME		KernelTime;
+	TIME		UserTime;
+	TIME		CreateTime;
+	ULONG		TickCount;
+	ULONG		StartEIP;
+	CLIENT_ID	ClientId;
+	ULONG		DynamicPriority;
+	ULONG		BasePriority;
+	ULONG		nSwitches;
+	DWORD		State;
+	KWAIT_REASON	WaitReason;
+	
+} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
+
+typedef struct SYSTEM_PROCESS_INFORMATION
+{
+	ULONG				RelativeOffset;
+	ULONG				ThreadCount;
+	ULONG				Unused1 [6];
+	TIME				CreateTime;
+	TIME				UserTime;
+	TIME				KernelTime;
+	UNICODE_STRING		Name;
+	ULONG				BasePriority;
+	ULONG				ProcessId;
+	ULONG				ParentProcessId;
+	ULONG				HandleCount;
+	ULONG				SessionId;
+	ULONG				Unused2;
+	ULONG				PeakVirtualSizeBytes;
+	ULONG				TotalVirtualSizeBytes;
+	ULONG				PageFaultCount;
+	ULONG				PeakWorkingSetSizeBytes;
+	ULONG				TotalWorkingSetSizeBytes;
+	ULONG				PeakPagedPoolUsagePages;
+	ULONG				TotalPagedPoolUsagePages;
+	ULONG				PeakNonPagedPoolUsagePages;
+	ULONG				TotalNonPagedPoolUsagePages;
+	ULONG				TotalPageFileUsageBytes;
+	ULONG				PeakPageFileUsageBytes;
+	ULONG				TotalPrivateBytes;
+	SYSTEM_THREAD_INFORMATION	ThreadSysInfo [1];
+	
+} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
+
+typedef struct
+{
+	DWORD	dwUnknown1;
+	ULONG	uKeMaximumIncrement;
+	ULONG	uPageSize;
+	ULONG	uMmNumberOfPhysicalPages;
+	ULONG	uMmLowestPhysicalPage;
+	ULONG	uMmHighestPhysicalPage;
+	ULONG	uAllocationGranularity;
+	PVOID	pLowestUserAddress;
+	PVOID	pMmHighestUserAddress;
+	ULONG	uKeActiveProcessors;
+	BYTE	bKeNumberProcessors;
+	BYTE	bUnknown2;
+	WORD	wUnknown3;
+} SYSTEM_BASIC_INFORMATION;
+
+// SystemPerformanceInfo (2)
+typedef struct _SYSTEM_PERFORMANCE_INFORMATION
+{
+	LARGE_INTEGER	/*TotalProcessorTime*/liIdleTime;
+	LARGE_INTEGER	IoReadTransferCount;
+	LARGE_INTEGER	IoWriteTransferCount;
+	LARGE_INTEGER	IoOtherTransferCount;
+	ULONG		IoReadOperationCount;
+	ULONG		IoWriteOperationCount;
+	ULONG		IoOtherOperationCount;
+	ULONG		MmAvailablePages;
+	ULONG		MmTotalCommitedPages;
+	ULONG		MmTotalCommitLimit;
+	ULONG		MmPeakLimit;
+	ULONG		PageFaults;
+	ULONG		WriteCopies;
+	ULONG		TransitionFaults;
+	ULONG		Unknown1;
+	ULONG		DemandZeroFaults;
+	ULONG		PagesInput;
+	ULONG		PagesRead;
+	ULONG		Unknown2;
+	ULONG		Unknown3;
+	ULONG		PagesOutput;
+	ULONG		PageWrites;
+	ULONG		Unknown4;
+	ULONG		Unknown5;
+	ULONG		PoolPagedBytes;
+	ULONG		PoolNonPagedBytes;
+	ULONG		Unknown6;
+	ULONG		Unknown7;
+	ULONG		Unknown8;
+	ULONG		Unknown9;
+	ULONG		MmTotalSystemFreePtes;
+	ULONG		MmSystemCodepage;
+	ULONG		MmTotalSystemDriverPages;
+	ULONG		MmTotalSystemCodePages;
+	ULONG		Unknown10;
+	ULONG		Unknown11;
+	ULONG		Unknown12;
+	ULONG		MmSystemCachePage;
+	ULONG		MmPagedPoolPage;
+	ULONG		MmSystemDriverPage;
+	ULONG		CcFastReadNoWait;
+	ULONG		CcFastReadWait;
+	ULONG		CcFastReadResourceMiss;
+	ULONG		CcFastReadNotPossible;
+	ULONG		CcFastMdlReadNoWait;
+	ULONG		CcFastMdlReadWait;
+	ULONG		CcFastMdlReadResourceMiss;
+	ULONG		CcFastMdlReadNotPossible;
+	ULONG		CcMapDataNoWait;
+	ULONG		CcMapDataWait;
+	ULONG		CcMapDataNoWaitMiss;
+	ULONG		CcMapDataWaitMiss;
+	ULONG		CcPinMappedDataCount;
+	ULONG		CcPinReadNoWait;
+	ULONG		CcPinReadWait;
+	ULONG		CcPinReadNoWaitMiss;
+	ULONG		CcPinReadWaitMiss;
+	ULONG		CcCopyReadNoWait;
+	ULONG		CcCopyReadWait;
+	ULONG		CcCopyReadNoWaitMiss;
+	ULONG		CcCopyReadWaitMiss;
+	ULONG		CcMdlReadNoWait;
+	ULONG		CcMdlReadWait;
+	ULONG		CcMdlReadNoWaitMiss;
+	ULONG		CcMdlReadWaitMiss;
+	ULONG		CcReadaheadIos;
+	ULONG		CcLazyWriteIos;
+	ULONG		CcLazyWritePages;
+	ULONG		CcDataFlushes;
+	ULONG		CcDataPages;
+	ULONG		ContextSwitches;
+	ULONG		Unknown13;
+	ULONG		Unknown14;
+	ULONG		SystemCalls;
+
+} SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
+
+typedef struct
+{
+	LARGE_INTEGER	liKeBootTime;
+	LARGE_INTEGER	liKeSystemTime;
+	LARGE_INTEGER	liExpTimeZoneBias;
+	ULONG			uCurrentTimeZoneId;
+	DWORD			dwReserved;
+} SYSTEM_TIME_INFORMATION;
+
+// SystemCacheInformation (21)
+typedef struct _SYSTEM_CACHE_INFORMATION
+{
+	ULONG	CurrentSize;
+	ULONG	PeakSize;
+	ULONG	PageFaultCount;
+	ULONG	MinimumWorkingSet;
+	ULONG	MaximumWorkingSet;
+	ULONG	Unused[4];
+
+} SYSTEM_CACHE_INFORMATION;
+
+// SystemPageFileInformation (18)
+typedef
+struct _SYSTEM_PAGEFILE_INFORMATION
+{
+	ULONG		RelativeOffset;
+	ULONG		CurrentSizePages;
+	ULONG		TotalUsedPages;
+	ULONG		PeakUsedPages;
+	UNICODE_STRING	PagefileFileName;
+	
+} SYSTEM_PAGEFILE_INFORMATION, *PSYSTEM_PAGEFILE_INFORMATION;
+
+// SystemHandleInformation (16)
+// (see ontypes.h)
+typedef
+struct _SYSTEM_HANDLE_ENTRY
+{
+	ULONG	OwnerPid;
+	BYTE	ObjectType;
+	BYTE	HandleFlags;
+	USHORT	HandleValue;
+	PVOID	ObjectPointer;
+	ULONG	AccessMask;
+	
+} SYSTEM_HANDLE_ENTRY, *PSYSTEM_HANDLE_ENTRY;
+
+typedef
+struct _SYSTEM_HANDLE_INFORMATION
+{
+	ULONG			Count;
+	SYSTEM_HANDLE_ENTRY	Handle [1];
+	
+} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
+
+// SystemProcessorPerformanceInformation (8)
+typedef
+struct _SYSTEM_PROCESSORTIME_INFO
+{
+	LARGE_INTEGER	IdleTime;
+	LARGE_INTEGER	KernelTime;
+	LARGE_INTEGER	UserTime;
+	LARGE_INTEGER	DpcTime;
+	LARGE_INTEGER	InterruptTime;
+	ULONG			InterruptCount;
+	ULONG			Unused;
+	
+} SYSTEM_PROCESSORTIME_INFO, *PSYSTEM_PROCESSORTIME_INFO;
+
+#define SystemBasicInformation			0
+#define SystemPerformanceInformation	2
+#define SystemTimeInformation			3
+#define	SystemProcessInformation		5
+#define SystemProcessorTimeInformation	8
+#define SystemHandleInformation			16
+#define SystemPageFileInformation		18
+#define SystemCacheInformation			21
+
+#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))
+
+#define BELOW_NORMAL_PRIORITY_CLASS 0x00004000
+#define ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
+
+#define GR_GDIOBJECTS     0       /* Count of GDI objects */
+#define GR_USEROBJECTS    1       /* Count of USER objects */
+
+// ntdll!NtQuerySystemInformation (NT specific!) 
+// 
+// The function copies the system information of the 
+// specified type into a buffer 
+// 
+// NTSYSAPI 
+// NTSTATUS 
+// NTAPI 
+// NtQuerySystemInformation( 
+// IN UINT SystemInformationClass, // information type 
+// OUT PVOID SystemInformation, // pointer to buffer 
+// IN ULONG SystemInformationLength, // buffer size in bytes 
+// OUT PULONG ReturnLength OPTIONAL // pointer to a 32-bit 
+// // variable that receives 
+// // the number of bytes 
+// // written to the buffer 
+// ); 
+typedef LONG (WINAPI *PROCNTQSI)(UINT,PVOID,ULONG,PULONG); 
+
+//DWORD GetGuiResources (
+//  HANDLE hProcess,  // handle to process
+//  DWORD uiFlags     // GUI object type
+//);
+typedef DWORD (WINAPI *PROCGGR)(HANDLE,DWORD);
+
+//BOOL GetProcessIoCounters(
+//  HANDLE hProcess,           // handle to process
+//  PIO_COUNTERS lpIoCounters  // I/O accouting information
+//);
+typedef BOOL (WINAPI *PROCGPIC)(HANDLE,PIO_COUNTERS);
+
+BOOL	PerfDataInitialize(void);
+void	PerfDataUninitialize(void);
+void	PerfDataRefresh(void);
+
+ULONG	PerfDataGetProcessCount(void);
+ULONG	PerfDataGetProcessorUsage(void);
+ULONG	PerfDataGetProcessorSystemUsage(void);
+
+BOOL	PerfDataGetImageName(ULONG Index, LPTSTR lpImageName, int nMaxCount);
+ULONG	PerfDataGetProcessId(ULONG Index);
+BOOL	PerfDataGetUserName(ULONG Index, LPTSTR lpUserName, int nMaxCount);
+ULONG	PerfDataGetSessionId(ULONG Index);
+ULONG	PerfDataGetCPUUsage(ULONG Index);
+TIME	PerfDataGetCPUTime(ULONG Index);
+ULONG	PerfDataGetWorkingSetSizeBytes(ULONG Index);
+ULONG	PerfDataGetPeakWorkingSetSizeBytes(ULONG Index);
+ULONG	PerfDataGetWorkingSetSizeDelta(ULONG Index);
+ULONG	PerfDataGetPageFaultCount(ULONG Index);
+ULONG	PerfDataGetPageFaultCountDelta(ULONG Index);
+ULONG	PerfDataGetVirtualMemorySizeBytes(ULONG Index);
+ULONG	PerfDataGetPagedPoolUsagePages(ULONG Index);
+ULONG	PerfDataGetNonPagedPoolUsagePages(ULONG Index);
+ULONG	PerfDataGetBasePriority(ULONG Index);
+ULONG	PerfDataGetHandleCount(ULONG Index);
+ULONG	PerfDataGetThreadCount(ULONG Index);
+ULONG	PerfDataGetUSERObjectCount(ULONG Index);
+ULONG	PerfDataGetGDIObjectCount(ULONG Index);
+BOOL	PerfDataGetIOCounters(ULONG Index, PIO_COUNTERS pIoCounters);
+
+ULONG	PerfDataGetCommitChargeTotalK(void);
+ULONG	PerfDataGetCommitChargeLimitK(void);
+ULONG	PerfDataGetCommitChargePeakK(void);
+
+ULONG	PerfDataGetKernelMemoryTotalK(void);
+ULONG	PerfDataGetKernelMemoryPagedK(void);
+ULONG	PerfDataGetKernelMemoryNonPagedK(void);
+
+ULONG	PerfDataGetPhysicalMemoryTotalK(void);
+ULONG	PerfDataGetPhysicalMemoryAvailableK(void);
+ULONG	PerfDataGetPhysicalMemorySystemCacheK(void);
+
+ULONG	PerfDataGetSystemHandleCount(void);
+
+ULONG	PerfDataGetTotalThreadCount(void);
+
+#endif // defined __PERFDATA_H
diff --git a/rosapps/taskmgr/priority.cpp b/rosapps/taskmgr/priority.cpp
new file mode 100644
index 00000000000..b9eed6636e2
--- /dev/null
+++ b/rosapps/taskmgr/priority.cpp
@@ -0,0 +1,315 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  priority.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "priority.h"
+#include "ProcessPage.h"
+#include "perfdata.h"
+
+void ProcessPage_OnSetPriorityRealTime(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnSetPriorityHigh(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnSetPriorityAboveNormal(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, ABOVE_NORMAL_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnSetPriorityNormal(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, NORMAL_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnSetPriorityBelowNormal(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, BELOW_NORMAL_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
+
+void ProcessPage_OnSetPriorityLow(void)
+{
+	LVITEM			lvitem;
+	ULONG			Index;
+	DWORD			dwProcessId;
+	HANDLE			hProcess;
+	TCHAR			strErrorText[260];
+
+	for (Index=0; Index<(ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
+	{
+		memset(&lvitem, 0, sizeof(LVITEM));
+
+		lvitem.mask = LVIF_STATE;
+		lvitem.stateMask = LVIS_SELECTED;
+		lvitem.iItem = Index;
+
+		ListView_GetItem(hProcessPageListCtrl, &lvitem);
+
+		if (lvitem.state & LVIS_SELECTED)
+			break;
+	}
+
+	dwProcessId = PerfDataGetProcessId(Index);
+
+	if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
+		return;
+
+	if (MessageBox(hMainWnd, "WARNING: Changing the priority class of this process may\ncause undesired results including system instability. Are you\nsure you want to change the priority class?", "Task Manager Warning", MB_YESNO|MB_ICONWARNING) != IDYES)
+		return;
+
+	hProcess = OpenProcess(PROCESS_SET_INFORMATION, FALSE, dwProcessId);
+
+	if (!hProcess)
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	if (!SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS))
+	{
+		GetLastErrorText(strErrorText, 260);
+		MessageBox(hMainWnd, strErrorText, "Unable to Change Priority", MB_OK|MB_ICONSTOP);
+	}
+
+	CloseHandle(hProcess);
+}
diff --git a/rosapps/taskmgr/priority.h b/rosapps/taskmgr/priority.h
new file mode 100644
index 00000000000..c0431f6ae62
--- /dev/null
+++ b/rosapps/taskmgr/priority.h
@@ -0,0 +1,33 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  priority.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __PRIORITY_H
+#define __PRIORITY_H
+
+void ProcessPage_OnSetPriorityRealTime(void);
+void ProcessPage_OnSetPriorityHigh(void);
+void ProcessPage_OnSetPriorityAboveNormal(void);
+void ProcessPage_OnSetPriorityNormal(void);
+void ProcessPage_OnSetPriorityBelowNormal(void);
+void ProcessPage_OnSetPriorityLow(void);
+
+#endif // __PRIORITY_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/proclist.cpp b/rosapps/taskmgr/proclist.cpp
new file mode 100644
index 00000000000..b5faff96a72
--- /dev/null
+++ b/rosapps/taskmgr/proclist.cpp
@@ -0,0 +1,113 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  proclist.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "ProcessPage.h"
+#include "proclist.h"
+#include "perfdata.h"
+
+
+LRESULT CALLBACK	ProcessListWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+LONG				OldProcessListWndProc;
+
+
+LRESULT CALLBACK ProcessListWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HBRUSH	hbrBackground;
+	RECT	rcItem;
+	RECT	rcClip;
+	HDC		hDC;
+	int		DcSave;
+
+	switch (message)
+	{
+	case WM_ERASEBKGND:
+
+		//
+		// The list control produces a nasty flicker
+		// when the user is resizing the window because
+		// it erases the background to white, then
+		// paints the list items over it.
+		//
+		// We will clip the drawing so that it only
+		// erases the parts of the list control that
+		// show only the background.
+		//
+
+		//
+		// Get the device context and save it's state
+		// to be restored after we're done
+		//
+		hDC = (HDC) wParam;
+		DcSave = SaveDC(hDC);
+
+		//
+		// Get the background brush
+		//
+		hbrBackground = (HBRUSH) GetClassLong(hWnd, GCL_HBRBACKGROUND);
+
+		//
+		// Calculate the clip rect by getting the RECT
+		// of the first and last items and adding them up.
+		//
+		// We also have to get the item's icon RECT and
+		// subtract it from our clip rect because we don't
+		// use icons in this list control.
+		//
+		ListView_GetItemRect(hWnd, 0, &rcClip, LVIR_BOUNDS);
+		ListView_GetItemRect(hWnd, ListView_GetItemCount(hWnd) - 1, &rcItem, LVIR_BOUNDS);
+		rcClip.bottom = rcItem.bottom;
+		ListView_GetItemRect(hWnd, 0, &rcItem, LVIR_ICON);
+		rcClip.left = rcItem.right;
+
+		//
+		// Now exclude the clip rect
+		//
+		ExcludeClipRect(hDC, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom);
+
+		//
+		// Now erase the background
+		//
+		//
+		// FIXME: Should I erase it myself or
+		// pass down the updated HDC and let
+		// the default handler do it?
+		//
+		GetClientRect(hWnd, &rcItem);
+		FillRect(hDC, &rcItem, hbrBackground);
+
+		//
+		// Now restore the DC state that we
+		// saved earlier
+		//
+		RestoreDC(hDC, DcSave);
+		
+		return TRUE;
+	}
+
+	//
+	// We pass on all messages except WM_ERASEBKGND
+	//
+	return CallWindowProc((WNDPROC)OldProcessListWndProc, hWnd, message, wParam, lParam);
+}
\ No newline at end of file
diff --git a/rosapps/taskmgr/proclist.h b/rosapps/taskmgr/proclist.h
new file mode 100644
index 00000000000..0abe87c8387
--- /dev/null
+++ b/rosapps/taskmgr/proclist.h
@@ -0,0 +1,30 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  proclist.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __PROCLIST_H
+#define __PROCLIST_H
+
+LRESULT CALLBACK	ProcessListWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+extern	LONG		OldProcessListWndProc;
+
+#endif // __PROCLIST_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/resource.h b/rosapps/taskmgr/resource.h
new file mode 100644
index 00000000000..0260e7bb813
--- /dev/null
+++ b/rosapps/taskmgr/resource.h
@@ -0,0 +1,175 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by TASKMGR.rc
+//
+#define IDD_TASKMGR_DIALOG              102
+#define IDD_ABOUTBOX                    103
+#define IDS_APP_TITLE                   103
+#define IDM_ABOUT                       104
+#define IDM_EXIT                        105
+#define IDD_APPLICATION_PAGE            106
+#define IDI_TASKMGR                     107
+#define IDI_SMALL                       108
+#define IDC_TASKMGR                     109
+#define IDR_MAINFRAME                   128
+#define IDR_TASKMANAGER                 130
+#define IDD_PROCESS_PAGE                133
+#define IDD_PERFORMANCE_PAGE            134
+#define IDR_WINDOWSMENU                 135
+#define IDI_TASKMANAGER                 136
+#define IDI_WINDOW                      137
+#define IDI_WINDOWSM                    138
+#define IDR_APPLICATION_PAGE_CONTEXT1   139
+#define IDR_APPLICATION_PAGE_CONTEXT2   140
+#define IDR_TRAY_POPUP                  141
+#define IDD_AFFINITY_DIALOG             142
+#define IDD_COLUMNS_DIALOG              143
+#define IDR_PROCESS_PAGE_CONTEXT        144
+#define IDB_TRAYMASK                    150
+#define IDB_TRAYICON                    153
+#define IDB_FONT                        154
+#define IDC_ENDTASK                     1012
+#define IDC_SWITCHTO                    1013
+#define IDC_NEWTASK                     1014
+#define IDC_TAB                         1015
+#define IDC_APPLIST                     1016
+#define IDC_ENDPROCESS                  1017
+#define IDC_PROCESSLIST                 1018
+#define IDC_CPU0                        1019
+#define IDC_CPU1                        1020
+#define IDC_CPU2                        1021
+#define IDC_SHOWALLPROCESSES            1021
+#define IDC_CPU3                        1022
+#define IDC_IMAGENAME                   1022
+#define IDC_CPU4                        1023
+#define IDC_PID                         1023
+#define IDC_CPU5                        1024
+#define IDC_CPUUSAGE                    1024
+#define IDC_TOTALS_HANDLE_COUNT         1024
+#define IDC_CPU6                        1025
+#define IDC_CPUTIME                     1025
+#define IDC_CPU7                        1026
+#define IDC_MEMORYUSAGE                 1026
+#define IDC_TOTALS_THREAD_COUNT         1026
+#define IDC_CPU8                        1027
+#define IDC_MEMORYUSAGEDELTA            1027
+#define IDC_TOTALS_PROCESS_COUNT        1027
+#define IDC_CPU9                        1028
+#define IDC_PEAKMEMORYUSAGE             1028
+#define IDC_COMMIT_CHARGE_TOTAL         1028
+#define IDC_CPU10                       1029
+#define IDC_PAGEFAULTS                  1029
+#define IDC_COMMIT_CHARGE_LIMIT         1029
+#define IDC_LICENSE_EDIT                1029
+#define IDC_CPU11                       1030
+#define IDC_USEROBJECTS                 1030
+#define IDC_COMMIT_CHARGE_PEAK          1030
+#define IDC_CPU12                       1031
+#define IDC_IOREADS                     1031
+#define IDC_PHYSICAL_MEMORY_TOTAL       1031
+#define IDC_CPU13                       1032
+#define IDC_IOREADBYTES                 1032
+#define IDC_PHYSICAL_MEMORY_AVAILABLE   1032
+#define IDC_CPU14                       1033
+#define IDC_SESSIONID                   1033
+#define IDC_PHYSICAL_MEMORY_SYSTEM_CACHE 1033
+#define IDC_CPU15                       1034
+#define IDC_USERNAME                    1034
+#define IDC_KERNEL_MEMORY_TOTAL         1034
+#define IDC_CPU16                       1035
+#define IDC_PAGEFAULTSDELTA             1035
+#define IDC_KERNEL_MEMORY_PAGED         1035
+#define IDC_CPU17                       1036
+#define IDC_VIRTUALMEMORYSIZE           1036
+#define IDC_KERNEL_MEMORY_NONPAGED      1036
+#define IDC_CPU18                       1037
+#define IDC_PAGEDPOOL                   1037
+#define IDC_TOTALS_FRAME                1037
+#define IDC_CPU19                       1038
+#define IDC_NONPAGEDPOOL                1038
+#define IDC_COMMIT_CHARGE_FRAME         1038
+#define IDC_CPU20                       1039
+#define IDC_BASEPRIORITY                1039
+#define IDC_KERNEL_MEMORY_FRAME         1039
+#define IDC_CPU21                       1040
+#define IDC_HANDLECOUNT                 1040
+#define IDC_PHYSICAL_MEMORY_FRAME       1040
+#define IDC_CPU22                       1041
+#define IDC_THREADCOUNT                 1041
+#define IDC_CPU23                       1042
+#define IDC_CPU24                       1043
+#define IDC_GDIOBJECTS                  1043
+#define IDC_CPU_USAGE_FRAME             1043
+#define IDC_CPU25                       1044
+#define IDC_IOWRITES                    1044
+#define IDC_MEM_USAGE_FRAME             1044
+#define IDC_CPU26                       1045
+#define IDC_IOWRITEBYTES                1045
+#define IDC_CPU_USAGE_HISTORY_FRAME     1045
+#define IDC_CPU27                       1046
+#define IDC_IOOTHER                     1046
+#define IDC_MEMORY_USAGE_HISTORY_FRAME  1046
+#define IDC_CPU28                       1047
+#define IDC_IOOTHERBYTES                1047
+#define IDC_CPU_USAGE_GRAPH             1047
+#define IDC_CPU29                       1048
+#define IDC_MEM_USAGE_GRAPH2            1048
+#define IDC_MEM_USAGE_GRAPH             1048
+#define IDC_CPU30                       1049
+#define IDC_MEM_USAGE_HISTORY_GRAPH     1049
+#define IDC_CPU31                       1050
+#define ID_FILE_NEW                     32771
+#define ID_OPTIONS_ALWAYSONTOP          32773
+#define ID_OPTIONS_MINIMIZEONUSE        32774
+#define ID_OPTIONS_HIDEWHENMINIMIZED    32775
+#define ID_VIEW_REFRESH                 32776
+#define ID_VIEW_LARGE                   32778
+#define ID_VIEW_SMALL                   32779
+#define ID_VIEW_DETAILS                 32780
+#define ID_VIEW_UPDATESPEED_HIGH        32781
+#define ID_VIEW_UPDATESPEED_NORMAL      32782
+#define ID_VIEW_UPDATESPEED_LOW         32783
+#define ID_VIEW_UPDATESPEED_PAUSED      32784
+#define ID_WINDOWS_TILEHORIZONTALLY     32785
+#define ID_WINDOWS_TILEVERTICALLY       32786
+#define ID_WINDOWS_MINIMIZE             32787
+#define ID_WINDOWS_MAXIMIZE             32788
+#define ID_WINDOWS_CASCADE              32789
+#define ID_WINDOWS_BRINGTOFRONT         32790
+#define ID_HELP_TOPICS                  32791
+#define ID_HELP_ABOUT                   32792
+#define ID_FILE_EXIT                    32793
+#define ID_OPTIONS_SHOW16BITTASKS       32794
+#define ID_VIEW_SELECTCOLUMNS           32795
+#define ID_VIEW_SHOWKERNELTIMES         32796
+#define ID_VIEW_CPUHISTORY_ONEGRAPHALL  32797
+#define ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU 32798
+#define ID_APPLICATION_PAGE_SWITCHTO    32799
+#define ID_ENDTASK                      32800
+#define ID_GOTOPROCESS                  32801
+#define ID_RESTORE                      32802
+#define ID_APPLICATION_PAGE_ENDTASK     32803
+#define ID_APPLICATION_PAGE_GOTOPROCESS 32804
+#define ID_PROCESS_PAGE_ENDPROCESS      32805
+#define ID_PROCESS_PAGE_ENDPROCESSTREE  32806
+#define ID_PROCESS_PAGE_DEBUG           32807
+#define ID_PROCESS_PAGE_SETAFFINITY     32808
+#define ID_PROCESS_PAGE_SETPRIORITY_REALTIME 32809
+#define ID_PROCESS_PAGE_SETPRIORITY_HIGH 32810
+#define ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL 32811
+#define ID_PROCESS_PAGE_SETPRIORITY_NORMAL 32812
+#define ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL 32813
+#define ID_PROCESS_PAGE_SETPRIORITY_LOW 32814
+#define IDS_LICENSE                     32815
+#define IDC_STATIC                      -1
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        155
+#define _APS_NEXT_COMMAND_VALUE         32815
+#define _APS_NEXT_CONTROL_VALUE         1048
+#define _APS_NEXT_SYMED_VALUE           110
+#endif
+#endif
diff --git a/rosapps/taskmgr/run.cpp b/rosapps/taskmgr/run.cpp
new file mode 100644
index 00000000000..ca6f00e8692
--- /dev/null
+++ b/rosapps/taskmgr/run.cpp
@@ -0,0 +1,57 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  run.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "run.h"
+
+void TaskManager_OnFileNew(void)
+{
+	HMODULE			hShell32;
+	RUNFILEDLG		RunFileDlg;
+	OSVERSIONINFO	versionInfo;
+	WCHAR			wTitle[40];
+	WCHAR			wText[256];
+	char			szTitle[40] = "Create New Task";
+	char			szText[256] = "Type the name of a program, folder, document, or Internet resource, and Task Manager will open it for you.";
+
+	hShell32 = LoadLibrary("SHELL32.DLL");
+	RunFileDlg = (RUNFILEDLG)(FARPROC)GetProcAddress(hShell32, (char*)((long)0x3D));
+
+	// Show "Run..." dialog
+	if (RunFileDlg)
+	{
+		versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+		GetVersionEx(&versionInfo);
+
+		if (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
+		{
+			MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szTitle, -1, wTitle, 40);
+			MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szText, -1, wText, 256);
+			RunFileDlg(hMainWnd, 0, NULL, (LPCSTR)wTitle, (LPCSTR)wText, RFF_CALCDIRECTORY);
+		}
+		else
+			RunFileDlg(hMainWnd, 0, NULL, szTitle, szText, RFF_CALCDIRECTORY);
+	}
+
+	FreeLibrary(hShell32);
+}
diff --git a/rosapps/taskmgr/run.h b/rosapps/taskmgr/run.h
new file mode 100644
index 00000000000..335ba228cbb
--- /dev/null
+++ b/rosapps/taskmgr/run.h
@@ -0,0 +1,54 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  run.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+// run.h - definitions necessary to use Microsoft's "Run" dialog
+// Undocumented Windows call
+// use the type below to declare a function pointer
+
+// Information taken from http://www.geocities.com/SiliconValley/4942/
+// Copyright © 1998-1999 James Holderness. All Rights Reserved.
+// jholderness@geocities.com
+
+#ifndef __RUN_H
+#define __RUN_H
+
+void TaskManager_OnFileNew(void);
+
+typedef	void (WINAPI *RUNFILEDLG)(
+						HWND    hwndOwner, 
+						HICON   hIcon, 
+						LPCSTR  lpstrDirectory, 
+						LPCSTR  lpstrTitle, 
+						LPCSTR  lpstrDescription,
+						UINT    uFlags); 
+
+//
+// Flags for RunFileDlg
+//
+
+#define	RFF_NOBROWSE		0x01	// Removes the browse button. 
+#define	RFF_NODEFAULT		0x02	// No default item selected. 
+#define	RFF_CALCDIRECTORY	0x04	// Calculates the working directory from the file name.
+#define	RFF_NOLABEL			0x08	// Removes the edit box label. 
+#define	RFF_NOSEPARATEMEM	0x20	// Removes the Separate Memory Space check box (Windows NT only).
+
+#endif // __RUN_H
diff --git a/rosapps/taskmgr/taskmgr.ico b/rosapps/taskmgr/taskmgr.ico
new file mode 100644
index 00000000000..727ad7be44d
Binary files /dev/null and b/rosapps/taskmgr/taskmgr.ico differ
diff --git a/rosapps/taskmgr/trayicon.bmp b/rosapps/taskmgr/trayicon.bmp
new file mode 100644
index 00000000000..d0572453c3e
Binary files /dev/null and b/rosapps/taskmgr/trayicon.bmp differ
diff --git a/rosapps/taskmgr/trayicon.cpp b/rosapps/taskmgr/trayicon.cpp
new file mode 100644
index 00000000000..dcbc66fedfc
--- /dev/null
+++ b/rosapps/taskmgr/trayicon.cpp
@@ -0,0 +1,204 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  trayicon.cpp
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#include "stdafx.h"
+#include "taskmgr.h"
+#include "trayicon.h"
+#include "perfdata.h"
+#include "shellapi.h"
+
+HICON TrayIcon_GetProcessorUsageIcon(void)
+{
+	HICON		hTrayIcon = NULL;
+	HDC			hScreenDC = NULL;
+	HDC			hDC = NULL;
+	HBITMAP		hBitmap = NULL;
+	HBITMAP		hOldBitmap = NULL;
+	HBITMAP		hBitmapMask = NULL;
+	ICONINFO	iconInfo;
+	ULONG		ProcessorUsage;
+	int			nLinesToDraw;
+	HBRUSH		hBitmapBrush = NULL;
+	RECT		rc;
+
+	//
+	// Get a handle to the screen DC
+	//
+	hScreenDC = GetDC(NULL);
+	if (!hScreenDC)
+		goto done;
+	
+	//
+	// Create our own DC from it
+	//
+	hDC = CreateCompatibleDC(hScreenDC);
+	if (!hDC)
+		goto done;
+
+	//
+	// Load the bitmaps
+	//
+	hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_TRAYICON));
+	hBitmapMask = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_TRAYMASK));
+	if (!hBitmap || !hBitmapMask)
+		goto done;
+
+	hBitmapBrush = CreateSolidBrush(RGB(0, 255, 0));
+	if (!hBitmapBrush)
+		goto done;
+	
+	//
+	// Select the bitmap into our device context
+	// so we can draw on it.
+	//
+	hOldBitmap = (HBITMAP) SelectObject(hDC, hBitmap);
+
+	//
+	// Get the cpu usage
+	//
+	ProcessorUsage = PerfDataGetProcessorUsage();
+
+	//
+	// Calculate how many lines to draw
+	// since we have 11 rows of space
+	// to draw the cpu usage instead of
+	// just having 10.
+	//
+	nLinesToDraw = (ProcessorUsage + (ProcessorUsage / 10)) / 11;
+	rc.left = 3;
+	rc.top = 12 - nLinesToDraw;
+	rc.right = 13;
+	rc.bottom = 13;
+
+	//
+	// Now draw the cpu usage
+	//
+	if (nLinesToDraw)
+		FillRect(hDC, &rc, hBitmapBrush);
+
+	//
+	// Now that we are done drawing put the
+	// old bitmap back.
+	//
+	SelectObject(hDC, hOldBitmap);
+	hOldBitmap = NULL;
+	
+	iconInfo.fIcon = TRUE;
+	iconInfo.xHotspot = 0;
+	iconInfo.yHotspot = 0;
+	iconInfo.hbmMask = hBitmapMask;
+	iconInfo.hbmColor = hBitmap;
+
+	hTrayIcon = CreateIconIndirect(&iconInfo);
+
+done:
+	//
+	// Cleanup
+	//
+	if (hScreenDC)
+		ReleaseDC(NULL, hScreenDC);
+	if (hOldBitmap)
+		SelectObject(hDC, hOldBitmap);
+	if (hDC)
+		DeleteDC(hDC);
+	if (hBitmapBrush)
+		DeleteObject(hBitmapBrush);
+	if (hBitmap)
+		DeleteObject(hBitmap);
+	if (hBitmapMask)
+		DeleteObject(hBitmapMask);
+	
+	//
+	// Return the newly created tray icon (if successful)
+	//
+	return hTrayIcon;
+}
+
+BOOL TrayIcon_ShellAddTrayIcon(void)
+{
+	NOTIFYICONDATA	nid;
+	HICON			hIcon = NULL;
+	BOOL			bRetVal;
+
+	memset(&nid, 0, sizeof(NOTIFYICONDATA));
+
+	hIcon = TrayIcon_GetProcessorUsageIcon();
+
+	nid.cbSize = sizeof(NOTIFYICONDATA);
+	nid.hWnd = hMainWnd;
+	nid.uID = 0;
+	nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+	//nid.uCallbackMessage = ??;
+	nid.hIcon = hIcon;
+	sprintf(nid.szTip, "CPU Usage: %d%%", PerfDataGetProcessorUsage());
+
+	bRetVal = Shell_NotifyIcon(NIM_ADD, &nid);
+
+	if (hIcon)
+		DeleteObject(hIcon);
+
+	return bRetVal;
+}
+
+BOOL TrayIcon_ShellRemoveTrayIcon(void)
+{
+	NOTIFYICONDATA	nid;
+	BOOL			bRetVal;
+	
+	memset(&nid, 0, sizeof(NOTIFYICONDATA));
+	
+	nid.cbSize = sizeof(NOTIFYICONDATA);
+	nid.hWnd = hMainWnd;
+	nid.uID = 0;
+	nid.uFlags = 0;
+	//nid.uCallbackMessage = ??;
+	
+	bRetVal = Shell_NotifyIcon(NIM_DELETE, &nid);
+	
+	return bRetVal;
+}
+
+BOOL TrayIcon_ShellUpdateTrayIcon(void)
+{
+	NOTIFYICONDATA	nid;
+	HICON			hIcon = NULL;
+	BOOL			bRetVal;
+	
+	memset(&nid, 0, sizeof(NOTIFYICONDATA));
+	
+	hIcon = TrayIcon_GetProcessorUsageIcon();
+	
+	nid.cbSize = sizeof(NOTIFYICONDATA);
+	nid.hWnd = hMainWnd;
+	nid.uID = 0;
+	nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+	//nid.uCallbackMessage = ??;
+	nid.hIcon = hIcon;
+	sprintf(nid.szTip, "CPU Usage: %d%%", PerfDataGetProcessorUsage());
+	
+	bRetVal = Shell_NotifyIcon(NIM_MODIFY, &nid);
+	
+	if (hIcon)
+		DeleteObject(hIcon);
+	
+	return bRetVal;
+}
diff --git a/rosapps/taskmgr/trayicon.h b/rosapps/taskmgr/trayicon.h
new file mode 100644
index 00000000000..d013858f920
--- /dev/null
+++ b/rosapps/taskmgr/trayicon.h
@@ -0,0 +1,31 @@
+/*
+ *  ReactOS Task Manager
+ *
+ *  trayicon.h
+ *
+ *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+	
+#ifndef __TRAYICON_H
+#define __TRAYICON_H
+
+HICON	TrayIcon_GetProcessorUsageIcon(void);
+BOOL	TrayIcon_ShellAddTrayIcon(void);
+BOOL	TrayIcon_ShellRemoveTrayIcon(void);
+BOOL	TrayIcon_ShellUpdateTrayIcon(void);
+
+#endif // __TRAYICON_H
\ No newline at end of file
diff --git a/rosapps/taskmgr/traymask.bmp b/rosapps/taskmgr/traymask.bmp
new file mode 100644
index 00000000000..73379b1928c
Binary files /dev/null and b/rosapps/taskmgr/traymask.bmp differ
diff --git a/rosapps/taskmgr/window.ico b/rosapps/taskmgr/window.ico
new file mode 100644
index 00000000000..1b9d3ad85a4
Binary files /dev/null and b/rosapps/taskmgr/window.ico differ
diff --git a/rosapps/taskmgr/windowsm.ico b/rosapps/taskmgr/windowsm.ico
new file mode 100644
index 00000000000..9d4b2cff3bd
Binary files /dev/null and b/rosapps/taskmgr/windowsm.ico differ