column.c

一个类似windows

        {
            TaskManagerSettings.Column_NonPagedPool = TRUE;
            TaskManagerSettings.ColumnSizeArray[13] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_BASEPRI, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_BasePriority = TRUE;
            TaskManagerSettings.ColumnSizeArray[14] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_HANDLES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_HandleCount = TRUE;
            TaskManagerSettings.ColumnSizeArray[15] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_THREADS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_ThreadCount = TRUE;
            TaskManagerSettings.ColumnSizeArray[16] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_USERPBJECTS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_USERObjects = TRUE;
            TaskManagerSettings.ColumnSizeArray[17] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_GDIOBJECTS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_GDIObjects = TRUE;
            TaskManagerSettings.ColumnSizeArray[18] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOREADS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOReads = TRUE;
            TaskManagerSettings.ColumnSizeArray[19] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOWRITES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOWrites = TRUE;
            TaskManagerSettings.ColumnSizeArray[20] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOOTHER, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOOther = TRUE;
            TaskManagerSettings.ColumnSizeArray[21] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOREADBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOReadBytes = TRUE;
            TaskManagerSettings.ColumnSizeArray[22] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOWRITESBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOWriteBytes = TRUE;
            TaskManagerSettings.ColumnSizeArray[23] = hditem.cxy;
        }

        LoadString(hInst, IDS_TAB_IOOTHERBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
        {
            TaskManagerSettings.Column_IOOtherBytes = TRUE;
            TaskManagerSettings.ColumnSizeArray[24] = hditem.cxy;
        }
    }
}

void ProcessPage_OnViewSelectColumns(void)
{
    int        i;

    if (DialogBox(hInst, MAKEINTRESOURCE(IDD_COLUMNS_DIALOG), hMainWnd, ColumnsDialogWndProc) == IDOK)
    {
        for (i=Header_GetItemCount(hProcessPageHeaderCtrl)-1; i>=0; i--)
        {
            (void)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();
    }
}

INT_PTR 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);

        LoadString(hInst, IDS_TAB_IMAGENAME, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IMAGENAME;

        LoadString(hInst, IDS_TAB_PID, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_PID;

        LoadString(hInst, IDS_TAB_USERNAME, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_USERNAME;

        LoadString(hInst, IDS_TAB_SESSIONID, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_SESSIONID;

        LoadString(hInst, IDS_TAB_CPU, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_CPUUSAGE;

        LoadString(hInst, IDS_TAB_CPUTIME, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_CPUTIME;

        LoadString(hInst, IDS_TAB_MEMUSAGE, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_MEMORYUSAGE;

        LoadString(hInst, IDS_TAB_PEAKMEMUSAGE, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_PEAKMEMORYUSAGE;

        LoadString(hInst, IDS_TAB_MEMDELTA, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_MEMORYUSAGEDELTA;

        LoadString(hInst, IDS_TAB_PAGEFAULT, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_PAGEFAULTS;

        LoadString(hInst, IDS_TAB_PFDELTA, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_PAGEFAULTSDELTA;

        LoadString(hInst, IDS_TAB_VMSIZE, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_VIRTUALMEMORYSIZE;

        LoadString(hInst, IDS_TAB_PAGEDPOOL, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_PAGEDPOOL;

        LoadString(hInst, IDS_TAB_NPPOOL, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_NONPAGEDPOOL;

        LoadString(hInst, IDS_TAB_BASEPRI, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_BASEPRIORITY;

        LoadString(hInst, IDS_TAB_HANDLES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_HANDLECOUNT;

        LoadString(hInst, IDS_TAB_THREADS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_THREADCOUNT;

        LoadString(hInst, IDS_TAB_USERPBJECTS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_USEROBJECTS;

        LoadString(hInst, IDS_TAB_GDIOBJECTS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_GDIOBJECTS;

        LoadString(hInst, IDS_TAB_IOREADS, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOREADS;

        LoadString(hInst, IDS_TAB_IOWRITES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOWRITES;

        LoadString(hInst, IDS_TAB_IOOTHER, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOOTHER;

        LoadString(hInst, IDS_TAB_IOREADBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOREADBYTES;

        LoadString(hInst, IDS_TAB_IOWRITESBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOWRITEBYTES;

        LoadString(hInst, IDS_TAB_IOOTHERBYTES, szTemp, 256);
        if (_tcsicmp(text, szTemp) == 0)
            ColumnDataHints[Index] = COLUMN_IOOTHERBYTES;
    }
}