reactos/subsys/system/taskmgr/column.c

   1 /*
   2  *  ReactOS Task Manager
   3  *
   4  *  column.cpp
   5  *
   6  *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
   7  *                2005         Klemens Friedl <frik85@reactos.at>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include <precomp.h>
  25
  26 UINT    ColumnDataHints[25];
  27 TCHAR       szTemp[256];
  28
  29 int                 InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem);
  30 INT_PTR CALLBACK    ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  31
  32 void AddColumns(void)
  33 {
  34     int        size;
  35
  36     if (TaskManagerSettings.Column_ImageName) {
  37         LoadString(hInst, IDS_TAB_IMAGENAME, szTemp, 256);
  38         InsertColumn(0, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[0], -1);
  39     }
  40     if (TaskManagerSettings.Column_PID) {
  41         LoadString(hInst, IDS_TAB_PID, szTemp, 256);
  42         InsertColumn(1, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[1], -1);
  43     }
  44     if (TaskManagerSettings.Column_UserName) {
  45         LoadString(hInst, IDS_TAB_USERNAME, szTemp, 256);
  46         InsertColumn(2, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[2], -1);
  47     }
  48     if (TaskManagerSettings.Column_SessionID) {
  49         LoadString(hInst, IDS_TAB_SESSIONID, szTemp, 256);
  50         InsertColumn(3, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[3], -1);
  51     }
  52     if (TaskManagerSettings.Column_CPUUsage) {
  53         LoadString(hInst, IDS_TAB_CPU, szTemp, 256);
  54         InsertColumn(4, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[4], -1);
  55     }
  56
  57     if (TaskManagerSettings.Column_CPUTime) {
  58         LoadString(hInst, IDS_TAB_CPUTIME, szTemp, 256);
  59         InsertColumn(5, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[5], -1);
  60     }
  61
  62     if (TaskManagerSettings.Column_MemoryUsage) {
  63         LoadString(hInst, IDS_TAB_MEMUSAGE, szTemp, 256);
  64         InsertColumn(6, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[6], -1);
  65     }
  66
  67     if (TaskManagerSettings.Column_PeakMemoryUsage) {
  68         LoadString(hInst, IDS_TAB_PEAKMEMUSAGE, szTemp, 256);
  69         InsertColumn(7, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[7], -1);
  70     }
  71
  72     if (TaskManagerSettings.Column_MemoryUsageDelta) {
  73         LoadString(hInst, IDS_TAB_MEMDELTA, szTemp, 256);
  74         InsertColumn(8, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[8], -1);
  75     }
  76
  77     if (TaskManagerSettings.Column_PageFaults) {
  78         LoadString(hInst, IDS_TAB_PAGEFAULT, szTemp, 256);
  79         InsertColumn(9, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[9], -1);
  80     }
  81
  82     if (TaskManagerSettings.Column_PageFaultsDelta) {
  83         LoadString(hInst, IDS_TAB_PFDELTA, szTemp, 256);
  84         InsertColumn(10, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[10], -1);
  85     }
  86
  87     if (TaskManagerSettings.Column_VirtualMemorySize) {
  88         LoadString(hInst, IDS_TAB_VMSIZE, szTemp, 256);
  89         InsertColumn(11, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[11], -1);
  90     }
  91
  92     if (TaskManagerSettings.Column_PagedPool) {
  93         LoadString(hInst, IDS_TAB_PAGEDPOOL, szTemp, 256);
  94         InsertColumn(12, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[12], -1);
  95     }
  96
  97     if (TaskManagerSettings.Column_NonPagedPool) {
  98         LoadString(hInst, IDS_TAB_NPPOOL, szTemp, 256);
  99         InsertColumn(13, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[13], -1);
 100     }
 101
 102     if (TaskManagerSettings.Column_BasePriority) {
 103         LoadString(hInst, IDS_TAB_BASEPRI, szTemp, 256);
 104         InsertColumn(14, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[14], -1);
 105     }
 106
 107     if (TaskManagerSettings.Column_HandleCount) {
 108         LoadString(hInst, IDS_TAB_HANDLES, szTemp, 256);
 109         InsertColumn(15, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[15], -1);
 110     }
 111
 112     if (TaskManagerSettings.Column_ThreadCount) {
 113         LoadString(hInst, IDS_TAB_THREADS, szTemp, 256);
 114         InsertColumn(16, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[16], -1);
 115     }
 116
 117     if (TaskManagerSettings.Column_USERObjects) {
 118         LoadString(hInst, IDS_TAB_USERPBJECTS, szTemp, 256);
 119         InsertColumn(17, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[17], -1);
 120     }
 121
 122     if (TaskManagerSettings.Column_GDIObjects) {
 123         LoadString(hInst, IDS_TAB_GDIOBJECTS, szTemp, 256);
 124         InsertColumn(18, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[18], -1);
 125     }
 126
 127     if (TaskManagerSettings.Column_IOReads) {
 128         LoadString(hInst, IDS_TAB_IOREADS, szTemp, 256);
 129         InsertColumn(19, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[19], -1);
 130     }
 131
 132     if (TaskManagerSettings.Column_IOWrites) {
 133         LoadString(hInst, IDS_TAB_IOWRITES, szTemp, 256);
 134         InsertColumn(20, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[20], -1);
 135     }
 136
 137     if (TaskManagerSettings.Column_IOOther) {
 138         LoadString(hInst, IDS_TAB_IOOTHER, szTemp, 256);
 139         InsertColumn(21, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[21], -1);
 140     }
 141
 142     if (TaskManagerSettings.Column_IOReadBytes) {
 143         LoadString(hInst, IDS_TAB_IOREADBYTES, szTemp, 256);
 144         InsertColumn(22, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[22], -1);
 145     }
 146
 147     if (TaskManagerSettings.Column_IOWriteBytes) {
 148         LoadString(hInst, IDS_TAB_IOWRITESBYTES, szTemp, 256);
 149         InsertColumn(23, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[23], -1);
 150     }
 151
 152     if (TaskManagerSettings.Column_IOOtherBytes) {
 153         LoadString(hInst, IDS_TAB_IOOTHERBYTES, szTemp, 256);
 154         InsertColumn(24, szTemp, LVCFMT_LEFT, TaskManagerSettings.ColumnSizeArray[24], -1);
 155     }
 156
 157     size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
 158     SendMessage(hProcessPageHeaderCtrl, HDM_SETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
 159
 160     UpdateColumnDataHints();
 161 }
 162
 163 int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem)
 164 {
 165     LVCOLUMN    column;
 166
 167     column.mask = LVCF_TEXT|LVCF_FMT;
 168     column.pszText = (LPTSTR)lpszColumnHeading;
 169     column.fmt = nFormat;
 170
 171     if (nWidth != -1)
 172     {
 173         column.mask |= LVCF_WIDTH;
 174         column.cx = nWidth;
 175     }
 176
 177     if (nSubItem != -1)
 178     {
 179         column.mask |= LVCF_SUBITEM;
 180         column.iSubItem = nSubItem;
 181     }
 182
 183     return ListView_InsertColumn(hProcessPageListCtrl, nCol, &column);
 184 }
 185
 186 void SaveColumnSettings(void)
 187 {
 188     HDITEM    hditem;
 189     int        i;
 190     TCHAR    text[260];
 191     int        size;
 192
 193     /* Reset column data */
 194     for (i=0; i<25; i++)
 195         TaskManagerSettings.ColumnOrderArray[i] = i;
 196
 197     TaskManagerSettings.Column_ImageName = FALSE;
 198     TaskManagerSettings.Column_PID = FALSE;
 199     TaskManagerSettings.Column_CPUUsage = FALSE;
 200     TaskManagerSettings.Column_CPUTime = FALSE;
 201     TaskManagerSettings.Column_MemoryUsage = FALSE;
 202     TaskManagerSettings.Column_MemoryUsageDelta = FALSE;
 203     TaskManagerSettings.Column_PeakMemoryUsage = FALSE;
 204     TaskManagerSettings.Column_PageFaults = FALSE;
 205     TaskManagerSettings.Column_USERObjects = FALSE;
 206     TaskManagerSettings.Column_IOReads = FALSE;
 207     TaskManagerSettings.Column_IOReadBytes = FALSE;
 208     TaskManagerSettings.Column_SessionID = FALSE;
 209     TaskManagerSettings.Column_UserName = FALSE;
 210     TaskManagerSettings.Column_PageFaultsDelta = FALSE;
 211     TaskManagerSettings.Column_VirtualMemorySize = FALSE;
 212     TaskManagerSettings.Column_PagedPool = FALSE;
 213     TaskManagerSettings.Column_NonPagedPool = FALSE;
 214     TaskManagerSettings.Column_BasePriority = FALSE;
 215     TaskManagerSettings.Column_HandleCount = FALSE;
 216     TaskManagerSettings.Column_ThreadCount = FALSE;
 217     TaskManagerSettings.Column_GDIObjects = FALSE;
 218     TaskManagerSettings.Column_IOWrites = FALSE;
 219     TaskManagerSettings.Column_IOWriteBytes = FALSE;
 220     TaskManagerSettings.Column_IOOther = FALSE;
 221     TaskManagerSettings.Column_IOOtherBytes = FALSE;
 222     TaskManagerSettings.ColumnSizeArray[0] = 105;
 223     TaskManagerSettings.ColumnSizeArray[1] = 50;
 224     TaskManagerSettings.ColumnSizeArray[2] = 107;
 225     TaskManagerSettings.ColumnSizeArray[3] = 70;
 226     TaskManagerSettings.ColumnSizeArray[4] = 35;
 227     TaskManagerSettings.ColumnSizeArray[5] = 70;
 228     TaskManagerSettings.ColumnSizeArray[6] = 70;
 229     TaskManagerSettings.ColumnSizeArray[7] = 100;
 230     TaskManagerSettings.ColumnSizeArray[8] = 70;
 231     TaskManagerSettings.ColumnSizeArray[9] = 70;
 232     TaskManagerSettings.ColumnSizeArray[10] = 70;
 233     TaskManagerSettings.ColumnSizeArray[11] = 70;
 234     TaskManagerSettings.ColumnSizeArray[12] = 70;
 235     TaskManagerSettings.ColumnSizeArray[13] = 70;
 236     TaskManagerSettings.ColumnSizeArray[14] = 60;
 237     TaskManagerSettings.ColumnSizeArray[15] = 60;
 238     TaskManagerSettings.ColumnSizeArray[16] = 60;
 239     TaskManagerSettings.ColumnSizeArray[17] = 60;
 240     TaskManagerSettings.ColumnSizeArray[18] = 60;
 241     TaskManagerSettings.ColumnSizeArray[19] = 70;
 242     TaskManagerSettings.ColumnSizeArray[20] = 70;
 243     TaskManagerSettings.ColumnSizeArray[21] = 70;
 244     TaskManagerSettings.ColumnSizeArray[22] = 70;
 245     TaskManagerSettings.ColumnSizeArray[23] = 70;
 246     TaskManagerSettings.ColumnSizeArray[24] = 70;
 247
 248     /* Get header order */
 249     size = SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0);
 250     SendMessage(hProcessPageHeaderCtrl, HDM_GETORDERARRAY, (WPARAM) size, (LPARAM) &TaskManagerSettings.ColumnOrderArray);
 251
 252     /* Get visible columns */
 253     for (i=0; i<SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); i++) {
 254         memset(&hditem, 0, sizeof(HDITEM));
 255
 256         hditem.mask = HDI_TEXT|HDI_WIDTH;
 257         hditem.pszText = text;
 258         hditem.cchTextMax = 260;
 259
 260         SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, i, (LPARAM) &hditem);
 261
 262         LoadString(hInst, IDS_TAB_IMAGENAME, szTemp, 256);
 263         if (_tcsicmp(text, szTemp) == 0)
 264         {
 265             TaskManagerSettings.Column_ImageName = TRUE;
 266             TaskManagerSettings.ColumnSizeArray[0] = hditem.cxy;
 267         }
 268
 269         LoadString(hInst, IDS_TAB_PID, szTemp, 256);
 270         if (_tcsicmp(text, szTemp) == 0)
 271         {
 272             TaskManagerSettings.Column_PID = TRUE;
 273             TaskManagerSettings.ColumnSizeArray[1] = hditem.cxy;
 274         }
 275
 276         LoadString(hInst, IDS_TAB_USERNAME, szTemp, 256);
 277         if (_tcsicmp(text, szTemp) == 0)
 278         {
 279             TaskManagerSettings.Column_UserName = TRUE;
 280             TaskManagerSettings.ColumnSizeArray[2] = hditem.cxy;
 281         }
 282
 283         LoadString(hInst, IDS_TAB_SESSIONID, szTemp, 256);
 284         if (_tcsicmp(text, szTemp) == 0)
 285         {
 286             TaskManagerSettings.Column_SessionID = TRUE;
 287             TaskManagerSettings.ColumnSizeArray[3] = hditem.cxy;
 288         }
 289
 290         LoadString(hInst, IDS_TAB_CPU, szTemp, 256);
 291         if (_tcsicmp(text, szTemp) == 0)
 292         {
 293             TaskManagerSettings.Column_CPUUsage = TRUE;
 294             TaskManagerSettings.ColumnSizeArray[4] = hditem.cxy;
 295         }
 296
 297         LoadString(hInst, IDS_TAB_CPUTIME, szTemp, 256);
 298         if (_tcsicmp(text, szTemp) == 0)
 299         {
 300             TaskManagerSettings.Column_CPUTime = TRUE;
 301             TaskManagerSettings.ColumnSizeArray[5] = hditem.cxy;
 302         }
 303
 304         LoadString(hInst, IDS_TAB_MEMUSAGE, szTemp, 256);
 305         if (_tcsicmp(text, szTemp) == 0)
 306         {
 307             TaskManagerSettings.Column_MemoryUsage = TRUE;
 308             TaskManagerSettings.ColumnSizeArray[6] = hditem.cxy;
 309         }
 310
 311         LoadString(hInst, IDS_TAB_PEAKMEMUSAGE, szTemp, 256);
 312         if (_tcsicmp(text, szTemp) == 0)
 313         {
 314             TaskManagerSettings.Column_PeakMemoryUsage = TRUE;
 315             TaskManagerSettings.ColumnSizeArray[7] = hditem.cxy;
 316         }
 317
 318         LoadString(hInst, IDS_TAB_MEMDELTA, szTemp, 256);
 319         if (_tcsicmp(text, szTemp) == 0)
 320         {
 321             TaskManagerSettings.Column_MemoryUsageDelta = TRUE;
 322             TaskManagerSettings.ColumnSizeArray[8] = hditem.cxy;
 323         }
 324
 325         LoadString(hInst, IDS_TAB_PAGEFAULT, szTemp, 256);
 326         if (_tcsicmp(text, szTemp) == 0)
 327         {
 328             TaskManagerSettings.Column_PageFaults = TRUE;
 329             TaskManagerSettings.ColumnSizeArray[9] = hditem.cxy;
 330         }
 331
 332         LoadString(hInst, IDS_TAB_PFDELTA, szTemp, 256);
 333         if (_tcsicmp(text, szTemp) == 0)
 334         {
 335             TaskManagerSettings.Column_PageFaultsDelta = TRUE;
 336             TaskManagerSettings.ColumnSizeArray[10] = hditem.cxy;
 337         }
 338
 339         LoadString(hInst, IDS_TAB_VMSIZE, szTemp, 256);
 340         if (_tcsicmp(text, szTemp) == 0)
 341         {
 342             TaskManagerSettings.Column_VirtualMemorySize = TRUE;
 343             TaskManagerSettings.ColumnSizeArray[11] = hditem.cxy;
 344         }
 345
 346         LoadString(hInst, IDS_TAB_PAGEDPOOL, szTemp, 256);
 347         if (_tcsicmp(text, szTemp) == 0)
 348         {
 349             TaskManagerSettings.Column_PagedPool = TRUE;
 350             TaskManagerSettings.ColumnSizeArray[12] = hditem.cxy;
 351         }
 352
 353         LoadString(hInst, IDS_TAB_NPPOOL, szTemp, 256);
 354         if (_tcsicmp(text, szTemp) == 0)
 355         {
 356             TaskManagerSettings.Column_NonPagedPool = TRUE;
 357             TaskManagerSettings.ColumnSizeArray[13] = hditem.cxy;
 358         }
 359
 360         LoadString(hInst, IDS_TAB_BASEPRI, szTemp, 256);
 361         if (_tcsicmp(text, szTemp) == 0)
 362         {
 363             TaskManagerSettings.Column_BasePriority = TRUE;
 364             TaskManagerSettings.ColumnSizeArray[14] = hditem.cxy;
 365         }
 366
 367         LoadString(hInst, IDS_TAB_HANDLES, szTemp, 256);
 368         if (_tcsicmp(text, szTemp) == 0)
 369         {
 370             TaskManagerSettings.Column_HandleCount = TRUE;
 371             TaskManagerSettings.ColumnSizeArray[15] = hditem.cxy;
 372         }
 373
 374         LoadString(hInst, IDS_TAB_THREADS, szTemp, 256);
 375         if (_tcsicmp(text, szTemp) == 0)
 376         {
 377             TaskManagerSettings.Column_ThreadCount = TRUE;
 378             TaskManagerSettings.ColumnSizeArray[16] = hditem.cxy;
 379         }
 380
 381         LoadString(hInst, IDS_TAB_USERPBJECTS, szTemp, 256);
 382         if (_tcsicmp(text, szTemp) == 0)
 383         {
 384             TaskManagerSettings.Column_USERObjects = TRUE;
 385             TaskManagerSettings.ColumnSizeArray[17] = hditem.cxy;
 386         }
 387
 388         LoadString(hInst, IDS_TAB_GDIOBJECTS, szTemp, 256);
 389         if (_tcsicmp(text, szTemp) == 0)
 390         {
 391             TaskManagerSettings.Column_GDIObjects = TRUE;
 392             TaskManagerSettings.ColumnSizeArray[18] = hditem.cxy;
 393         }
 394
 395         LoadString(hInst, IDS_TAB_IOREADS, szTemp, 256);
 396         if (_tcsicmp(text, szTemp) == 0)
 397         {
 398             TaskManagerSettings.Column_IOReads = TRUE;
 399             TaskManagerSettings.ColumnSizeArray[19] = hditem.cxy;
 400         }
 401
 402         LoadString(hInst, IDS_TAB_IOWRITES, szTemp, 256);
 403         if (_tcsicmp(text, szTemp) == 0)
 404         {
 405             TaskManagerSettings.Column_IOWrites = TRUE;
 406             TaskManagerSettings.ColumnSizeArray[20] = hditem.cxy;
 407         }
 408
 409         LoadString(hInst, IDS_TAB_IOOTHER, szTemp, 256);
 410         if (_tcsicmp(text, szTemp) == 0)
 411         {
 412             TaskManagerSettings.Column_IOOther = TRUE;
 413             TaskManagerSettings.ColumnSizeArray[21] = hditem.cxy;
 414         }
 415
 416         LoadString(hInst, IDS_TAB_IOREADBYTES, szTemp, 256);
 417         if (_tcsicmp(text, szTemp) == 0)
 418         {
 419             TaskManagerSettings.Column_IOReadBytes = TRUE;
 420             TaskManagerSettings.ColumnSizeArray[22] = hditem.cxy;
 421         }
 422
 423         LoadString(hInst, IDS_TAB_IOWRITESBYTES, szTemp, 256);
 424         if (_tcsicmp(text, szTemp) == 0)
 425         {
 426             TaskManagerSettings.Column_IOWriteBytes = TRUE;
 427             TaskManagerSettings.ColumnSizeArray[23] = hditem.cxy;
 428         }
 429
 430         LoadString(hInst, IDS_TAB_IOOTHERBYTES, szTemp, 256);
 431         if (_tcsicmp(text, szTemp) == 0)
 432         {
 433             TaskManagerSettings.Column_IOOtherBytes = TRUE;
 434             TaskManagerSettings.ColumnSizeArray[24] = hditem.cxy;
 435         }
 436     }
 437 }
 438
 439 void ProcessPage_OnViewSelectColumns(void)
 440 {
 441     int        i;
 442
 443     if (DialogBox(hInst, MAKEINTRESOURCE(IDD_COLUMNS_DIALOG), hMainWnd, ColumnsDialogWndProc) == IDOK)
 444     {
 445         for (i=Header_GetItemCount(hProcessPageHeaderCtrl)-1; i>=0; i--)
 446         {
 447             ListView_DeleteColumn(hProcessPageListCtrl, i);
 448         }
 449
 450         for (i=0; i<25; i++)
 451             TaskManagerSettings.ColumnOrderArray[i] = i;
 452
 453         TaskManagerSettings.ColumnSizeArray[0] = 105;
 454         TaskManagerSettings.ColumnSizeArray[1] = 50;
 455         TaskManagerSettings.ColumnSizeArray[2] = 107;
 456         TaskManagerSettings.ColumnSizeArray[3] = 70;
 457         TaskManagerSettings.ColumnSizeArray[4] = 35;
 458         TaskManagerSettings.ColumnSizeArray[5] = 70;
 459         TaskManagerSettings.ColumnSizeArray[6] = 70;
 460         TaskManagerSettings.ColumnSizeArray[7] = 100;
 461         TaskManagerSettings.ColumnSizeArray[8] = 70;
 462         TaskManagerSettings.ColumnSizeArray[9] = 70;
 463         TaskManagerSettings.ColumnSizeArray[10] = 70;
 464         TaskManagerSettings.ColumnSizeArray[11] = 70;
 465         TaskManagerSettings.ColumnSizeArray[12] = 70;
 466         TaskManagerSettings.ColumnSizeArray[13] = 70;
 467         TaskManagerSettings.ColumnSizeArray[14] = 60;
 468         TaskManagerSettings.ColumnSizeArray[15] = 60;
 469         TaskManagerSettings.ColumnSizeArray[16] = 60;
 470         TaskManagerSettings.ColumnSizeArray[17] = 60;
 471         TaskManagerSettings.ColumnSizeArray[18] = 60;
 472         TaskManagerSettings.ColumnSizeArray[19] = 70;
 473         TaskManagerSettings.ColumnSizeArray[20] = 70;
 474         TaskManagerSettings.ColumnSizeArray[21] = 70;
 475         TaskManagerSettings.ColumnSizeArray[22] = 70;
 476         TaskManagerSettings.ColumnSizeArray[23] = 70;
 477         TaskManagerSettings.ColumnSizeArray[24] = 70;
 478
 479         AddColumns();
 480     }
 481 }
 482
 483 INT_PTR CALLBACK
 484 ColumnsDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 485 {
 486
 487     switch (message)
 488     {
 489     case WM_INITDIALOG:
 490
 491         if (TaskManagerSettings.Column_ImageName)
 492             SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_SETCHECK, BST_CHECKED, 0);
 493         if (TaskManagerSettings.Column_PID)
 494             SendMessage(GetDlgItem(hDlg, IDC_PID), BM_SETCHECK, BST_CHECKED, 0);
 495         if (TaskManagerSettings.Column_UserName)
 496             SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_SETCHECK, BST_CHECKED, 0);
 497         if (TaskManagerSettings.Column_SessionID)
 498             SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_SETCHECK, BST_CHECKED, 0);
 499         if (TaskManagerSettings.Column_CPUUsage)
 500             SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 501         if (TaskManagerSettings.Column_CPUTime)
 502             SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_SETCHECK, BST_CHECKED, 0);
 503         if (TaskManagerSettings.Column_MemoryUsage)
 504             SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 505         if (TaskManagerSettings.Column_PeakMemoryUsage)
 506             SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_SETCHECK, BST_CHECKED, 0);
 507         if (TaskManagerSettings.Column_MemoryUsageDelta)
 508             SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_SETCHECK, BST_CHECKED, 0);
 509         if (TaskManagerSettings.Column_PageFaults)
 510             SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_SETCHECK, BST_CHECKED, 0);
 511         if (TaskManagerSettings.Column_PageFaultsDelta)
 512             SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_SETCHECK, BST_CHECKED, 0);
 513         if (TaskManagerSettings.Column_VirtualMemorySize)
 514             SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_SETCHECK, BST_CHECKED, 0);
 515         if (TaskManagerSettings.Column_PagedPool)
 516             SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
 517         if (TaskManagerSettings.Column_NonPagedPool)
 518             SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_SETCHECK, BST_CHECKED, 0);
 519         if (TaskManagerSettings.Column_BasePriority)
 520             SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_SETCHECK, BST_CHECKED, 0);
 521         if (TaskManagerSettings.Column_HandleCount)
 522             SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_SETCHECK, BST_CHECKED, 0);
 523         if (TaskManagerSettings.Column_ThreadCount)
 524             SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_SETCHECK, BST_CHECKED, 0);
 525         if (TaskManagerSettings.Column_USERObjects)
 526             SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_SETCHECK, BST_CHECKED, 0);
 527         if (TaskManagerSettings.Column_GDIObjects)
 528             SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_SETCHECK, BST_CHECKED, 0);
 529         if (TaskManagerSettings.Column_IOReads)
 530             SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_SETCHECK, BST_CHECKED, 0);
 531         if (TaskManagerSettings.Column_IOWrites)
 532             SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_SETCHECK, BST_CHECKED, 0);
 533         if (TaskManagerSettings.Column_IOOther)
 534             SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_SETCHECK, BST_CHECKED, 0);
 535         if (TaskManagerSettings.Column_IOReadBytes)
 536             SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_SETCHECK, BST_CHECKED, 0);
 537         if (TaskManagerSettings.Column_IOWriteBytes)
 538             SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_SETCHECK, BST_CHECKED, 0);
 539         if (TaskManagerSettings.Column_IOOtherBytes)
 540             SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_SETCHECK, BST_CHECKED, 0);
 541
 542         return TRUE;
 543
 544     case WM_COMMAND:
 545
 546         if (LOWORD(wParam) == IDCANCEL)
 547         {
 548             EndDialog(hDlg, LOWORD(wParam));
 549             return TRUE;
 550         }
 551
 552         if (LOWORD(wParam) == IDOK)
 553         {
 554             TaskManagerSettings.Column_ImageName = SendMessage(GetDlgItem(hDlg, IDC_IMAGENAME), BM_GETCHECK, 0, 0);
 555             TaskManagerSettings.Column_PID = SendMessage(GetDlgItem(hDlg, IDC_PID), BM_GETCHECK, 0, 0);
 556             TaskManagerSettings.Column_UserName = SendMessage(GetDlgItem(hDlg, IDC_USERNAME), BM_GETCHECK, 0, 0);
 557             TaskManagerSettings.Column_SessionID = SendMessage(GetDlgItem(hDlg, IDC_SESSIONID), BM_GETCHECK, 0, 0);
 558             TaskManagerSettings.Column_CPUUsage = SendMessage(GetDlgItem(hDlg, IDC_CPUUSAGE), BM_GETCHECK, 0, 0);
 559             TaskManagerSettings.Column_CPUTime = SendMessage(GetDlgItem(hDlg, IDC_CPUTIME), BM_GETCHECK, 0, 0);
 560             TaskManagerSettings.Column_MemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGE), BM_GETCHECK, 0, 0);
 561             TaskManagerSettings.Column_PeakMemoryUsage = SendMessage(GetDlgItem(hDlg, IDC_PEAKMEMORYUSAGE), BM_GETCHECK, 0, 0);
 562             TaskManagerSettings.Column_MemoryUsageDelta = SendMessage(GetDlgItem(hDlg, IDC_MEMORYUSAGEDELTA), BM_GETCHECK, 0, 0);
 563             TaskManagerSettings.Column_PageFaults = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTS), BM_GETCHECK, 0, 0);
 564             TaskManagerSettings.Column_PageFaultsDelta = SendMessage(GetDlgItem(hDlg, IDC_PAGEFAULTSDELTA), BM_GETCHECK, 0, 0);
 565             TaskManagerSettings.Column_VirtualMemorySize = SendMessage(GetDlgItem(hDlg, IDC_VIRTUALMEMORYSIZE), BM_GETCHECK, 0, 0);
 566             TaskManagerSettings.Column_PagedPool = SendMessage(GetDlgItem(hDlg, IDC_PAGEDPOOL), BM_GETCHECK, 0, 0);
 567             TaskManagerSettings.Column_NonPagedPool = SendMessage(GetDlgItem(hDlg, IDC_NONPAGEDPOOL), BM_GETCHECK, 0, 0);
 568             TaskManagerSettings.Column_BasePriority = SendMessage(GetDlgItem(hDlg, IDC_BASEPRIORITY), BM_GETCHECK, 0, 0);
 569             TaskManagerSettings.Column_HandleCount = SendMessage(GetDlgItem(hDlg, IDC_HANDLECOUNT), BM_GETCHECK, 0, 0);
 570             TaskManagerSettings.Column_ThreadCount = SendMessage(GetDlgItem(hDlg, IDC_THREADCOUNT), BM_GETCHECK, 0, 0);
 571             TaskManagerSettings.Column_USERObjects = SendMessage(GetDlgItem(hDlg, IDC_USEROBJECTS), BM_GETCHECK, 0, 0);
 572             TaskManagerSettings.Column_GDIObjects = SendMessage(GetDlgItem(hDlg, IDC_GDIOBJECTS), BM_GETCHECK, 0, 0);
 573             TaskManagerSettings.Column_IOReads = SendMessage(GetDlgItem(hDlg, IDC_IOREADS), BM_GETCHECK, 0, 0);
 574             TaskManagerSettings.Column_IOWrites = SendMessage(GetDlgItem(hDlg, IDC_IOWRITES), BM_GETCHECK, 0, 0);
 575             TaskManagerSettings.Column_IOOther = SendMessage(GetDlgItem(hDlg, IDC_IOOTHER), BM_GETCHECK, 0, 0);
 576             TaskManagerSettings.Column_IOReadBytes = SendMessage(GetDlgItem(hDlg, IDC_IOREADBYTES), BM_GETCHECK, 0, 0);
 577             TaskManagerSettings.Column_IOWriteBytes = SendMessage(GetDlgItem(hDlg, IDC_IOWRITEBYTES), BM_GETCHECK, 0, 0);
 578             TaskManagerSettings.Column_IOOtherBytes = SendMessage(GetDlgItem(hDlg, IDC_IOOTHERBYTES), BM_GETCHECK, 0, 0);
 579
 580             EndDialog(hDlg, LOWORD(wParam));
 581             return TRUE;
 582         }
 583
 584         break;
 585     }
 586
 587     return 0;
 588 }
 589
 590 void UpdateColumnDataHints(void)
 591 {
 592     HDITEM            hditem;
 593     TCHAR            text[260];
 594     ULONG            Index;
 595
 596     for (Index=0; Index<(ULONG)SendMessage(hProcessPageHeaderCtrl, HDM_GETITEMCOUNT, 0, 0); Index++)
 597     {
 598         memset(&hditem, 0, sizeof(HDITEM));
 599
 600         hditem.mask = HDI_TEXT;
 601         hditem.pszText = text;
 602         hditem.cchTextMax = 260;
 603
 604         SendMessage(hProcessPageHeaderCtrl, HDM_GETITEM, Index, (LPARAM) &hditem);
 605
 606         LoadString(hInst, IDS_TAB_IMAGENAME, szTemp, 256);
 607         if (_tcsicmp(text, szTemp) == 0)
 608             ColumnDataHints[Index] = COLUMN_IMAGENAME;
 609
 610         LoadString(hInst, IDS_TAB_PID, szTemp, 256);
 611         if (_tcsicmp(text, szTemp) == 0)
 612             ColumnDataHints[Index] = COLUMN_PID;
 613
 614         LoadString(hInst, IDS_TAB_USERNAME, szTemp, 256);
 615         if (_tcsicmp(text, szTemp) == 0)
 616             ColumnDataHints[Index] = COLUMN_USERNAME;
 617
 618         LoadString(hInst, IDS_TAB_SESSIONID, szTemp, 256);
 619         if (_tcsicmp(text, szTemp) == 0)
 620             ColumnDataHints[Index] = COLUMN_SESSIONID;
 621
 622         LoadString(hInst, IDS_TAB_CPU, szTemp, 256);
 623         if (_tcsicmp(text, szTemp) == 0)
 624             ColumnDataHints[Index] = COLUMN_CPUUSAGE;
 625
 626         LoadString(hInst, IDS_TAB_CPUTIME, szTemp, 256);
 627         if (_tcsicmp(text, szTemp) == 0)
 628             ColumnDataHints[Index] = COLUMN_CPUTIME;
 629
 630         LoadString(hInst, IDS_TAB_MEMUSAGE, szTemp, 256);
 631         if (_tcsicmp(text, szTemp) == 0)
 632             ColumnDataHints[Index] = COLUMN_MEMORYUSAGE;
 633
 634         LoadString(hInst, IDS_TAB_PEAKMEMUSAGE, szTemp, 256);
 635         if (_tcsicmp(text, szTemp) == 0)
 636             ColumnDataHints[Index] = COLUMN_PEAKMEMORYUSAGE;
 637
 638         LoadString(hInst, IDS_TAB_MEMDELTA, szTemp, 256);
 639         if (_tcsicmp(text, szTemp) == 0)
 640             ColumnDataHints[Index] = COLUMN_MEMORYUSAGEDELTA;
 641
 642         LoadString(hInst, IDS_TAB_PAGEFAULT, szTemp, 256);
 643         if (_tcsicmp(text, szTemp) == 0)
 644             ColumnDataHints[Index] = COLUMN_PAGEFAULTS;
 645
 646         LoadString(hInst, IDS_TAB_PFDELTA, szTemp, 256);
 647         if (_tcsicmp(text, szTemp) == 0)
 648             ColumnDataHints[Index] = COLUMN_PAGEFAULTSDELTA;
 649
 650         LoadString(hInst, IDS_TAB_VMSIZE, szTemp, 256);
 651         if (_tcsicmp(text, szTemp) == 0)
 652             ColumnDataHints[Index] = COLUMN_VIRTUALMEMORYSIZE;
 653
 654         LoadString(hInst, IDS_TAB_PAGEDPOOL, szTemp, 256);
 655         if (_tcsicmp(text, szTemp) == 0)
 656             ColumnDataHints[Index] = COLUMN_PAGEDPOOL;
 657
 658         LoadString(hInst, IDS_TAB_NPPOOL, szTemp, 256);
 659         if (_tcsicmp(text, szTemp) == 0)
 660             ColumnDataHints[Index] = COLUMN_NONPAGEDPOOL;
 661
 662         LoadString(hInst, IDS_TAB_BASEPRI, szTemp, 256);
 663         if (_tcsicmp(text, szTemp) == 0)
 664             ColumnDataHints[Index] = COLUMN_BASEPRIORITY;
 665
 666         LoadString(hInst, IDS_TAB_HANDLES, szTemp, 256);
 667         if (_tcsicmp(text, szTemp) == 0)
 668             ColumnDataHints[Index] = COLUMN_HANDLECOUNT;
 669
 670         LoadString(hInst, IDS_TAB_THREADS, szTemp, 256);
 671         if (_tcsicmp(text, szTemp) == 0)
 672             ColumnDataHints[Index] = COLUMN_THREADCOUNT;
 673
 674         LoadString(hInst, IDS_TAB_USERPBJECTS, szTemp, 256);
 675         if (_tcsicmp(text, szTemp) == 0)
 676             ColumnDataHints[Index] = COLUMN_USEROBJECTS;
 677
 678         LoadString(hInst, IDS_TAB_GDIOBJECTS, szTemp, 256);
 679         if (_tcsicmp(text, szTemp) == 0)
 680             ColumnDataHints[Index] = COLUMN_GDIOBJECTS;
 681
 682         LoadString(hInst, IDS_TAB_IOREADS, szTemp, 256);
 683         if (_tcsicmp(text, szTemp) == 0)
 684             ColumnDataHints[Index] = COLUMN_IOREADS;
 685
 686         LoadString(hInst, IDS_TAB_IOWRITES, szTemp, 256);
 687         if (_tcsicmp(text, szTemp) == 0)
 688             ColumnDataHints[Index] = COLUMN_IOWRITES;
 689
 690         LoadString(hInst, IDS_TAB_IOOTHER, szTemp, 256);
 691         if (_tcsicmp(text, szTemp) == 0)
 692             ColumnDataHints[Index] = COLUMN_IOOTHER;
 693
 694         LoadString(hInst, IDS_TAB_IOREADBYTES, szTemp, 256);
 695         if (_tcsicmp(text, szTemp) == 0)
 696             ColumnDataHints[Index] = COLUMN_IOREADBYTES;
 697
 698         LoadString(hInst, IDS_TAB_IOWRITESBYTES, szTemp, 256);
 699         if (_tcsicmp(text, szTemp) == 0)
 700             ColumnDataHints[Index] = COLUMN_IOWRITEBYTES;
 701
 702         LoadString(hInst, IDS_TAB_IOOTHERBYTES, szTemp, 256);
 703         if (_tcsicmp(text, szTemp) == 0)
 704             ColumnDataHints[Index] = COLUMN_IOOTHERBYTES;
 705     }
 706 }