rosapps/taskmgr/column.c

   1 /*
   2  *  ReactOS Task Manager
   3  *
   4  *  column.cpp
   5  *
   6  *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
  24 #include <windows.h>
  25 #include <commctrl.h>
  26 #include <stdlib.h>
  27 #include <malloc.h>
  28 #include <memory.h>
  29 #include <tchar.h>
  30 #include <process.h>
  31 #include <stdio.h>
  32
  33 #include "taskmgr.h"
  34 #include "column.h"
  35 #include "procpage.h"
  36
  37 UINT    ColumnDataHints[25];
  38
  39 int                                     InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem);
  40 LRESULT CALLBACK        ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  41
  42 void AddColumns(void)
  43 {
  44         int             size;
  45
  46         if (TaskManagerSettings.Column_ImageName)
  47                 InsertColumn(0, _T("Image Name"), LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[0], -1);
  48         if (TaskManagerSettings.Column_PID)
  49                 InsertColumn(1, _T("PID"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[1], -1);
  50         if (TaskManagerSettings.Column_UserName)
  51                 InsertColumn(2, _T("Username"), LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[2], -1);
  52         if (TaskManagerSettings.Column_SessionID)
  53                 InsertColumn(3, _T("Session ID"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[3], -1);
  54         if (TaskManagerSettings.Column_CPUUsage)
  55                 InsertColumn(4, _T("CPU"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[4], -1);
  56         if (TaskManagerSettings.Column_CPUTime)
  57                 InsertColumn(5, _T("CPU Time"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[5], -1);
  58         if (TaskManagerSettings.Column_MemoryUsage)
  59                 InsertColumn(6, _T("Mem Usage"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[6], -1);
  60         if (TaskManagerSettings.Column_PeakMemoryUsage)
  61                 InsertColumn(7, _T("Peak Mem Usage"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[7], -1);
  62         if (TaskManagerSettings.Column_MemoryUsageDelta)
  63                 InsertColumn(8, _T("Mem Delta"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[8], -1);
  64         if (TaskManagerSettings.Column_PageFaults)
  65                 InsertColumn(9, _T("Page Faults"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[9], -1);
  66         if (TaskManagerSettings.Column_PageFaultsDelta)
  67                 InsertColumn(10, _T("PF Delta"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[10], -1);
  68         if (TaskManagerSettings.Column_VirtualMemorySize)
  69                 InsertColumn(11, _T("VM Size"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[11], -1);
  70         if (TaskManagerSettings.Column_PagedPool)
  71                 InsertColumn(12, _T("Paged Pool"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[12], -1);
  72         if (TaskManagerSettings.Column_NonPagedPool)
  73                 InsertColumn(13, _T("NP Pool"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[13], -1);
  74         if (TaskManagerSettings.Column_BasePriority)
  75                 InsertColumn(14, _T("Base Pri"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[14], -1);
  76         if (TaskManagerSettings.Column_HandleCount)
  77                 InsertColumn(15, _T("Handles"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[15], -1);
  78         if (TaskManagerSettings.Column_ThreadCount)
  79                 InsertColumn(16, _T("Threads"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[16], -1);
  80         if (TaskManagerSettings.Column_USERObjects)
  81                 InsertColumn(17, _T("USER Objects"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[17], -1);
  82         if (TaskManagerSettings.Column_GDIObjects)
  83                 InsertColumn(18, _T("GDI Objects"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[18], -1);
  84         if (TaskManagerSettings.Column_IOReads)
  85                 InsertColumn(19, _T("I/O Reads"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[19], -1);
  86         if (TaskManagerSettings.Column_IOWrites)
  87                 InsertColumn(20, _T("I/O Writes"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[20], -1);
  88         if (TaskManagerSettings.Column_IOOther)
  89                 InsertColumn(21, _T("I/O Other"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[21], -1);
  90         if (TaskManagerSettings.Column_IOReadBytes)
  91                 InsertColumn(22, _T("I/O Read Bytes"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[22], -1);
  92         if (TaskManagerSettings.Column_IOWriteBytes)
  93                 InsertColumn(23, _T("I/O Write Bytes"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[23], -1);
  94         if (TaskManagerSettings.Column_IOOtherBytes)
  95                 InsertColumn(24, _T("I/O Other Bytes"), LVCFMT_RIGHT, TaskManagerSettings.ColumnSizeArray[24], -1);
  96
  97         size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
  98         SendMessage(hProcessPageHeaderCtrl, HDM_SETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
  99
 100         UpdateColumnDataHints();
 101 }
 102
 103 int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem)
 104 {
 105         LVCOLUMN        column;
 106
 107         column.mask = LVCF_TEXT|LVCF_FMT;
 108         column.pszText = (LPTSTR)lpszColumnHeading;
 109         column.fmt = nFormat;
 110
 111         if (nWidth != -1)
 112         {
 113                 column.mask |= LVCF_WIDTH;
 114                 column.cx = nWidth;
 115         }
 116
 117         if (nSubItem != -1)
 118         {
 119                 column.mask |= LVCF_SUBITEM;
 120                 column.iSubItem = nSubItem;
 121         }
 122
 123         return ListView_InsertColumn(hProcessPageListCtrl, nCol, &column);
 124 }
 125
 126 void SaveColumnSettings(void)
 127 {
 128         HDITEM  hditem;
 129         int             i;
 130         TCHAR   text[260];
 131         int             size;
 132
 133         // Reset column data
 134         for (i=0; i<25; i++)
 135                 TaskManagerSettings.ColumnOrderArray[i] = i;
 136
 137         TaskManagerSettings.Column_ImageName = FALSE;
 138         TaskManagerSettings.Column_PID = FALSE;
 139         TaskManagerSettings.Column_CPUUsage = FALSE;
 140         TaskManagerSettings.Column_CPUTime = FALSE;
 141         TaskManagerSettings.Column_MemoryUsage = FALSE;
 142         TaskManagerSettings.Column_MemoryUsageDelta = FALSE;
 143         TaskManagerSettings.Column_PeakMemoryUsage = FALSE;
 144         TaskManagerSettings.Column_PageFaults = FALSE;
 145         TaskManagerSettings.Column_USERObjects = FALSE;
 146         TaskManagerSettings.Column_IOReads = FALSE;
 147         TaskManagerSettings.Column_IOReadBytes = FALSE;
 148         TaskManagerSettings.Column_SessionID = FALSE;
 149         TaskManagerSettings.Column_UserName = FALSE;
 150         TaskManagerSettings.Column_PageFaultsDelta = FALSE;
 151         TaskManagerSettings.Column_VirtualMemorySize = FALSE;
 152         TaskManagerSettings.Column_PagedPool = FALSE;
 153         TaskManagerSettings.Column_NonPagedPool = FALSE;
 154         TaskManagerSettings.Column_BasePriority = FALSE;
 155         TaskManagerSettings.Column_HandleCount = FALSE;
 156         TaskManagerSettings.Column_ThreadCount = FALSE;
 157         TaskManagerSettings.Column_GDIObjects = FALSE;
 158         TaskManagerSettings.Column_IOWrites = FALSE;
 159         TaskManagerSettings.Column_IOWriteBytes = FALSE;
 160         TaskManagerSettings.Column_IOOther = FALSE;
 161         TaskManagerSettings.Column_IOOtherBytes = FALSE;
 162         TaskManagerSettings.ColumnSizeArray[0] = 105;
 163         TaskManagerSettings.ColumnSizeArray[1] = 50;
 164         TaskManagerSettings.ColumnSizeArray[2] = 107;
 165         TaskManagerSettings.ColumnSizeArray[3] = 70;
 166         TaskManagerSettings.ColumnSizeArray[4] = 35;
 167         TaskManagerSettings.ColumnSizeArray[5] = 70;
 168         TaskManagerSettings.ColumnSizeArray[6] = 70;
 169         TaskManagerSettings.ColumnSizeArray[7] = 100;
 170         TaskManagerSettings.ColumnSizeArray[8] = 70;
 171         TaskManagerSettings.ColumnSizeArray[9] = 70;
 172         TaskManagerSettings.ColumnSizeArray[10] = 70;
 173         TaskManagerSettings.ColumnSizeArray[11] = 70;
 174         TaskManagerSettings.ColumnSizeArray[12] = 70;
 175         TaskManagerSettings.ColumnSizeArray[13] = 70;
 176         TaskManagerSettings.ColumnSizeArray[14] = 60;
 177         TaskManagerSettings.ColumnSizeArray[15] = 60;
 178         TaskManagerSettings.ColumnSizeArray[16] = 60;
 179         TaskManagerSettings.ColumnSizeArray[17] = 60;
 180         TaskManagerSettings.ColumnSizeArray[18] = 60;
 181         TaskManagerSettings.ColumnSizeArray[19] = 70;
 182         TaskManagerSettings.ColumnSizeArray[20] = 70;
 183         TaskManagerSettings.ColumnSizeArray[21] = 70;
 184         TaskManagerSettings.ColumnSizeArray[22] = 70;
 185         TaskManagerSettings.ColumnSizeArray[23] = 70;
 186         TaskManagerSettings.ColumnSizeArray[24] = 70;
 187
 188         // Get header order
 189         size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
 190         SendMessage(hProcessPageHeaderCtrl, HDM_GETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
 191
 192         // Get visible columns
 193         for (i=0; i<SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); i++) {
 194                 memset(&hditem, 0, sizeof(HDITEM));
 195
 196                 hditem.mask = HDI_TEXT|HDI_WIDTH;
 197                 hditem.pszText = text;
 198                 hditem.cchTextMax = 260;
 199
 200                 SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, i, (LPARAM) &hditem);
 201
 202                 if (_tcsicmp(text, _T("Image Name")) == 0)
 203                 {
 204                         TaskManagerSettings.Column_ImageName = TRUE;
 205                         TaskManagerSettings.ColumnSizeArray[0] = hditem.cxy;
 206                 }
 207                 if (_tcsicmp(text, _T("PID")) == 0)
 208                 {
 209                         TaskManagerSettings.Column_PID = TRUE;
 210                         TaskManagerSettings.ColumnSizeArray[1] = hditem.cxy;
 211                 }
 212                 if (_tcsicmp(text, _T("Username")) == 0)
 213                 {
 214                         TaskManagerSettings.Column_UserName = TRUE;
 215                         TaskManagerSettings.ColumnSizeArray[2] = hditem.cxy;
 216                 }
 217                 if (_tcsicmp(text, _T("Session ID")) == 0)
 218                 {
 219                         TaskManagerSettings.Column_SessionID = TRUE;
 220                         TaskManagerSettings.ColumnSizeArray[3] = hditem.cxy;
 221                 }
 222                 if (_tcsicmp(text, _T("CPU")) == 0)
 223                 {
 224                         TaskManagerSettings.Column_CPUUsage = TRUE;
 225                         TaskManagerSettings.ColumnSizeArray[4] = hditem.cxy;
 226                 }
 227                 if (_tcsicmp(text, _T("CPU Time")) == 0)
 228                 {
 229                         TaskManagerSettings.Column_CPUTime = TRUE;
 230                         TaskManagerSettings.ColumnSizeArray[5] = hditem.cxy;
 231                 }
 232                 if (_tcsicmp(text, _T("Mem Usage")) == 0)
 233                 {
 234                         TaskManagerSettings.Column_MemoryUsage = TRUE;
 235                         TaskManagerSettings.ColumnSizeArray[6] = hditem.cxy;
 236                 }
 237                 if (_tcsicmp(text, _T("Peak Mem Usage")) == 0)
 238                 {
 239                         TaskManagerSettings.Column_PeakMemoryUsage = TRUE;
 240                         TaskManagerSettings.ColumnSizeArray[7] = hditem.cxy;
 241                 }
 242                 if (_tcsicmp(text, _T("Mem Delta")) == 0)
 243                 {
 244                         TaskManagerSettings.Column_MemoryUsageDelta = TRUE;
 245                         TaskManagerSettings.ColumnSizeArray[8] = hditem.cxy;
 246                 }
 247                 if (_tcsicmp(text, _T("Page Faults")) == 0)
 248                 {
 249                         TaskManagerSettings.Column_PageFaults = TRUE;
 250                         TaskManagerSettings.ColumnSizeArray[9] = hditem.cxy;
 251                 }
 252                 if (_tcsicmp(text, _T("PF Delta")) == 0)
 253                 {
 254                         TaskManagerSettings.Column_PageFaultsDelta = TRUE;
 255                         TaskManagerSettings.ColumnSizeArray[10] = hditem.cxy;
 256                 }
 257                 if (_tcsicmp(text, _T("VM Size")) == 0)
 258                 {
 259                         TaskManagerSettings.Column_VirtualMemorySize = TRUE;
 260                         TaskManagerSettings.ColumnSizeArray[11] = hditem.cxy;
 261                 }
 262                 if (_tcsicmp(text, _T("Paged Pool")) == 0)
 263                 {
 264                         TaskManagerSettings.Column_PagedPool = TRUE;
 265                         TaskManagerSettings.ColumnSizeArray[12] = hditem.cxy;
 266                 }
 267                 if (_tcsicmp(text, _T("NP Pool")) == 0)
 268                 {
 269                         TaskManagerSettings.Column_NonPagedPool = TRUE;
 270                         TaskManagerSettings.ColumnSizeArray[13] = hditem.cxy;
 271                 }
 272                 if (_tcsicmp(text, _T("Base Pri")) == 0)
 273                 {
 274                         TaskManagerSettings.Column_BasePriority = TRUE;
 275                         TaskManagerSettings.ColumnSizeArray[14] = hditem.cxy;
 276                 }
 277                 if (_tcsicmp(text, _T("Handles")) == 0)
 278                 {
 279                         TaskManagerSettings.Column_HandleCount = TRUE;
 280                         TaskManagerSettings.ColumnSizeArray[15] = hditem.cxy;
 281                 }
 282                 if (_tcsicmp(text, _T("Threads")) == 0)
 283                 {
 284                         TaskManagerSettings.Column_ThreadCount = TRUE;
 285                         TaskManagerSettings.ColumnSizeArray[16] = hditem.cxy;
 286                 }
 287                 if (_tcsicmp(text, _T("USER Objects")) == 0)
 288                 {
 289                         TaskManagerSettings.Column_USERObjects = TRUE;
 290                         TaskManagerSettings.ColumnSizeArray[17] = hditem.cxy;
 291                 }
 292                 if (_tcsicmp(text, _T("GDI Objects")) == 0)
 293                 {
 294                         TaskManagerSettings.Column_GDIObjects = TRUE;
 295                         TaskManagerSettings.ColumnSizeArray[18] = hditem.cxy;
 296                 }
 297                 if (_tcsicmp(text, _T("I/O Reads")) == 0)
 298                 {
 299                         TaskManagerSettings.Column_IOReads = TRUE;
 300                         TaskManagerSettings.ColumnSizeArray[19] = hditem.cxy;
 301                 }
 302                 if (_tcsicmp(text, _T("I/O Writes")) == 0)
 303                 {
 304                         TaskManagerSettings.Column_IOWrites = TRUE;
 305                         TaskManagerSettings.ColumnSizeArray[20] = hditem.cxy;
 306                 }
 307                 if (_tcsicmp(text, _T("I/O Other")) == 0)
 308                 {
 309                         TaskManagerSettings.Column_IOOther = TRUE;
 310                         TaskManagerSettings.ColumnSizeArray[21] = hditem.cxy;
 311                 }
 312                 if (_tcsicmp(text, _T("I/O Read Bytes")) == 0)
 313                 {
 314                         TaskManagerSettings.Column_IOReadBytes = TRUE;
 315                         TaskManagerSettings.ColumnSizeArray[22] = hditem.cxy;
 316                 }
 317                 if (_tcsicmp(text, _T("I/O Write Bytes")) == 0)
 318                 {
 319                         TaskManagerSettings.Column_IOWriteBytes = TRUE;
 320                         TaskManagerSettings.ColumnSizeArray[23] = hditem.cxy;
 321                 }
 322                 if (_tcsicmp(text, _T("I/O Other Bytes")) == 0)
 323                 {
 324                         TaskManagerSettings.Column_IOOtherBytes = TRUE;
 325                         TaskManagerSettings.ColumnSizeArray[24] = hditem.cxy;
 326                 }
 327         }
 328 }
 329
 330 void ProcessPage_OnViewSelectColumns(void)
 331 {
 332         int             i;
 333
 334         if (DialogBox(hInst, MAKEINTRESOURCE(IDD_COLUMNS_DIALOG), hMainWnd, (DLGPROC)ColumnsDialogWndProc) == IDOK)
 335         {
 336                 for (i=Header_GetItemCount(hProcessPageHeaderCtrl)-1; i>=0; i--)
 337                 {
 338                         ListView_DeleteColumn(hProcessPageListCtrl, i);
 339                 }
 340
 341                 for (i=0; i<25; i++)
 342                         TaskManagerSettings.ColumnOrderArray[i] = i;
 343
 344                 TaskManagerSettings.ColumnSizeArray[0] = 105;
 345                 TaskManagerSettings.ColumnSizeArray[1] = 50;
 346                 TaskManagerSettings.ColumnSizeArray[2] = 107;
 347                 TaskManagerSettings.ColumnSizeArray[3] = 70;
 348                 TaskManagerSettings.ColumnSizeArray[4] = 35;
 349                 TaskManagerSettings.ColumnSizeArray[5] = 70;
 350                 TaskManagerSettings.ColumnSizeArray[6] = 70;
 351                 TaskManagerSettings.ColumnSizeArray[7] = 100;
 352                 TaskManagerSettings.ColumnSizeArray[8] = 70;
 353                 TaskManagerSettings.ColumnSizeArray[9] = 70;
 354                 TaskManagerSettings.ColumnSizeArray[10] = 70;
 355                 TaskManagerSettings.ColumnSizeArray[11] = 70;
 356                 TaskManagerSettings.ColumnSizeArray[12] = 70;
 357                 TaskManagerSettings.ColumnSizeArray[13] = 70;
 358                 TaskManagerSettings.ColumnSizeArray[14] = 60;
 359                 TaskManagerSettings.ColumnSizeArray[15] = 60;
 360                 TaskManagerSettings.ColumnSizeArray[16] = 60;
 361                 TaskManagerSettings.ColumnSizeArray[17] = 60;
 362                 TaskManagerSettings.ColumnSizeArray[18] = 60;
 363                 TaskManagerSettings.ColumnSizeArray[19] = 70;
 364                 TaskManagerSettings.ColumnSizeArray[20] = 70;
 365                 TaskManagerSettings.ColumnSizeArray[21] = 70;
 366                 TaskManagerSettings.ColumnSizeArray[22] = 70;
 367                 TaskManagerSettings.ColumnSizeArray[23] = 70;
 368                 TaskManagerSettings.ColumnSizeArray[24] = 70;
 369
 370                 AddColumns();
 371         }
 372 }
 373
 374 LRESULT CALLBACK ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 375 {
 376
 377         switch (message)
 378         {
 379         case WM_INITDIALOG:
 380
 381                 if (TaskManagerSettings.Column_ImageName)
 382                         SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_SETCHECK, BST_CHECKED, 0);
 383                 if (TaskManagerSettings.Column_PID)
 384                         SendMessage(GetDlgItem(hDlg, IDC_PID), BM_SETCHECK, BST_CHECKED, 0);
 385                 if (TaskManagerSettings.Column_UserName)
 386                         SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_SETCHECK, BST_CHECKED, 0);
 387                 if (TaskManagerSettings.Column_SessionID)
 388                         SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_SETCHECK, BST_CHECKED, 0);
 389                 if (TaskManagerSettings.Column_CPUUsage)
 390                         SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 391                 if (TaskManagerSettings.Column_CPUTime)
 392                         SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_SETCHECK, BST_CHECKED, 0);
 393                 if (TaskManagerSettings.Column_MemoryUsage)
 394                         SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 395                 if (TaskManagerSettings.Column_PeakMemoryUsage)
 396                         SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 397                 if (TaskManagerSettings.Column_MemoryUsageDelta)
 398                         SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_SETCHECK, BST_CHECKED, 0);
 399                 if (TaskManagerSettings.Column_PageFaults)
 400                         SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_SETCHECK, BST_CHECKED, 0);
 401                 if (TaskManagerSettings.Column_PageFaultsDelta)
 402                         SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_SETCHECK, BST_CHECKED, 0);
 403                 if (TaskManagerSettings.Column_VirtualMemorySize)
 404                         SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_SETCHECK, BST_CHECKED, 0);
 405                 if (TaskManagerSettings.Column_PagedPool)
 406                         SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
 407                 if (TaskManagerSettings.Column_NonPagedPool)
 408                         SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
 409                 if (TaskManagerSettings.Column_BasePriority)
 410                         SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_SETCHECK, BST_CHECKED, 0);
 411                 if (TaskManagerSettings.Column_HandleCount)
 412                         SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_SETCHECK, BST_CHECKED, 0);
 413                 if (TaskManagerSettings.Column_ThreadCount)
 414                         SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_SETCHECK, BST_CHECKED, 0);
 415                 if (TaskManagerSettings.Column_USERObjects)
 416                         SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_SETCHECK, BST_CHECKED, 0);
 417                 if (TaskManagerSettings.Column_GDIObjects)
 418                         SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_SETCHECK, BST_CHECKED, 0);
 419                 if (TaskManagerSettings.Column_IOReads)
 420                         SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_SETCHECK, BST_CHECKED, 0);
 421                 if (TaskManagerSettings.Column_IOWrites)
 422                         SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_SETCHECK, BST_CHECKED, 0);
 423                 if (TaskManagerSettings.Column_IOOther)
 424                         SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_SETCHECK, BST_CHECKED, 0);
 425                 if (TaskManagerSettings.Column_IOReadBytes)
 426                         SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_SETCHECK, BST_CHECKED, 0);
 427                 if (TaskManagerSettings.Column_IOWriteBytes)
 428                         SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_SETCHECK, BST_CHECKED, 0);
 429                 if (TaskManagerSettings.Column_IOOtherBytes)
 430                         SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_SETCHECK, BST_CHECKED, 0);
 431
 432                 return TRUE;
 433
 434         case WM_COMMAND:
 435
 436                 if (LOWORD(wParam) == IDCANCEL)
 437                 {
 438                         EndDialog(hDlg, LOWORD(wParam));
 439                         return TRUE;
 440                 }
 441
 442                 if (LOWORD(wParam) == IDOK)
 443                 {
 444                         TaskManagerSettings.Column_ImageName = SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_GETCHECK, 0, 0);
 445                         TaskManagerSettings.Column_PID = SendMessage(GetDlgItem(hDlg, IDC_PID), BM_GETCHECK, 0, 0);
 446                         TaskManagerSettings.Column_UserName = SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_GETCHECK, 0, 0);
 447                         TaskManagerSettings.Column_SessionID = SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_GETCHECK, 0, 0);
 448                         TaskManagerSettings.Column_CPUUsage = SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_GETCHECK, 0, 0);
 449                         TaskManagerSettings.Column_CPUTime = SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_GETCHECK, 0, 0);
 450                         TaskManagerSettings.Column_MemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_GETCHECK, 0, 0);
 451                         TaskManagerSettings.Column_PeakMemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_GETCHECK, 0, 0);
 452                         TaskManagerSettings.Column_MemoryUsageDelta = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_GETCHECK, 0, 0);
 453                         TaskManagerSettings.Column_PageFaults = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_GETCHECK, 0, 0);
 454                         TaskManagerSettings.Column_PageFaultsDelta = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_GETCHECK, 0, 0);
 455                         TaskManagerSettings.Column_VirtualMemorySize = SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_GETCHECK, 0, 0);
 456                         TaskManagerSettings.Column_PagedPool = SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_GETCHECK, 0, 0);
 457                         TaskManagerSettings.Column_NonPagedPool = SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_GETCHECK, 0, 0);
 458                         TaskManagerSettings.Column_BasePriority = SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_GETCHECK, 0, 0);
 459                         TaskManagerSettings.Column_HandleCount = SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_GETCHECK, 0, 0);
 460                         TaskManagerSettings.Column_ThreadCount = SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_GETCHECK, 0, 0);
 461                         TaskManagerSettings.Column_USERObjects = SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_GETCHECK, 0, 0);
 462                         TaskManagerSettings.Column_GDIObjects = SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_GETCHECK, 0, 0);
 463                         TaskManagerSettings.Column_IOReads = SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_GETCHECK, 0, 0);
 464                         TaskManagerSettings.Column_IOWrites = SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_GETCHECK, 0, 0);
 465                         TaskManagerSettings.Column_IOOther = SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_GETCHECK, 0, 0);
 466                         TaskManagerSettings.Column_IOReadBytes = SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_GETCHECK, 0, 0);
 467                         TaskManagerSettings.Column_IOWriteBytes = SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_GETCHECK, 0, 0);
 468                         TaskManagerSettings.Column_IOOtherBytes = SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_GETCHECK, 0, 0);
 469
 470                         EndDialog(hDlg, LOWORD(wParam));
 471                         return TRUE;
 472                 }
 473
 474                 break;
 475         }
 476
 477     return 0;
 478 }
 479
 480 void UpdateColumnDataHints(void)
 481 {
 482         HDITEM                  hditem;
 483         TCHAR                   text[260];
 484         ULONG                   Index;
 485
 486         for (Index=0; Index<(ULONG)SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); Index++)
 487         {
 488                 memset(&hditem, 0, sizeof(HDITEM));
 489
 490                 hditem.mask = HDI_TEXT;
 491                 hditem.pszText = text;
 492                 hditem.cchTextMax = 260;
 493
 494                 SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, Index, (LPARAM) &hditem);
 495
 496                 if (_tcsicmp(text, _T("Image Name")) == 0)
 497                         ColumnDataHints[Index] = COLUMN_IMAGENAME;
 498                 if (_tcsicmp(text, _T("PID")) == 0)
 499                         ColumnDataHints[Index] = COLUMN_PID;
 500                 if (_tcsicmp(text, _T("Username")) == 0)
 501                         ColumnDataHints[Index] = COLUMN_USERNAME;
 502                 if (_tcsicmp(text, _T("Session ID")) == 0)
 503                         ColumnDataHints[Index] = COLUMN_SESSIONID;
 504                 if (_tcsicmp(text, _T("CPU")) == 0)
 505                         ColumnDataHints[Index] = COLUMN_CPUUSAGE;
 506                 if (_tcsicmp(text, _T("CPU Time")) == 0)
 507                         ColumnDataHints[Index] = COLUMN_CPUTIME;
 508                 if (_tcsicmp(text, _T("Mem Usage")) == 0)
 509                         ColumnDataHints[Index] = COLUMN_MEMORYUSAGE;
 510                 if (_tcsicmp(text, _T("Peak Mem Usage")) == 0)
 511                         ColumnDataHints[Index] = COLUMN_PEAKMEMORYUSAGE;
 512                 if (_tcsicmp(text, _T("Mem Delta")) == 0)
 513                         ColumnDataHints[Index] = COLUMN_MEMORYUSAGEDELTA;
 514                 if (_tcsicmp(text, _T("Page Faults")) == 0)
 515                         ColumnDataHints[Index] = COLUMN_PAGEFAULTS;
 516                 if (_tcsicmp(text, _T("PF Delta")) == 0)
 517                         ColumnDataHints[Index] = COLUMN_PAGEFAULTSDELTA;
 518                 if (_tcsicmp(text, _T("VM Size")) == 0)
 519                         ColumnDataHints[Index] = COLUMN_VIRTUALMEMORYSIZE;
 520                 if (_tcsicmp(text, _T("Paged Pool")) == 0)
 521                         ColumnDataHints[Index] = COLUMN_PAGEDPOOL;
 522                 if (_tcsicmp(text, _T("NP Pool")) == 0)
 523                         ColumnDataHints[Index] = COLUMN_NONPAGEDPOOL;
 524                 if (_tcsicmp(text, _T("Base Pri")) == 0)
 525                         ColumnDataHints[Index] = COLUMN_BASEPRIORITY;
 526                 if (_tcsicmp(text, _T("Handles")) == 0)
 527                         ColumnDataHints[Index] = COLUMN_HANDLECOUNT;
 528                 if (_tcsicmp(text, _T("Threads")) == 0)
 529                         ColumnDataHints[Index] = COLUMN_THREADCOUNT;
 530                 if (_tcsicmp(text, _T("USER Objects")) == 0)
 531                         ColumnDataHints[Index] = COLUMN_USEROBJECTS;
 532                 if (_tcsicmp(text, _T("GDI Objects")) == 0)
 533                         ColumnDataHints[Index] = COLUMN_GDIOBJECTS;
 534                 if (_tcsicmp(text, _T("I/O Reads")) == 0)
 535                         ColumnDataHints[Index] = COLUMN_IOREADS;
 536                 if (_tcsicmp(text, _T("I/O Writes")) == 0)
 537                         ColumnDataHints[Index] = COLUMN_IOWRITES;
 538                 if (_tcsicmp(text, _T("I/O Other")) == 0)
 539                         ColumnDataHints[Index] = COLUMN_IOOTHER;
 540                 if (_tcsicmp(text, _T("I/O Read Bytes")) == 0)
 541                         ColumnDataHints[Index] = COLUMN_IOREADBYTES;
 542                 if (_tcsicmp(text, _T("I/O Write Bytes")) == 0)
 543                         ColumnDataHints[Index] = COLUMN_IOWRITEBYTES;
 544                 if (_tcsicmp(text, _T("I/O Other Bytes")) == 0)
 545                         ColumnDataHints[Index] = COLUMN_IOOTHERBYTES;
 546         }
 547 }