pviewdat.c

<Win2k系统编程>源码.次数为国人自编,内容丰富,还是不错的.

                                                PX_PROCESS_IMAGE_EXE_READONLY,
                                                PX_PROCESS_IMAGE_EXE_READWRITE,
                                                PX_PROCESS_IMAGE_EXE_WRITECOPY);
}

//*********************************************************************
//
//      PaintMemDlgVMData
//
//  Paint the memory dialog Virtual Memory data.
//
void    PaintMemDlgVMData  (HWND            hMemDlg,
                            PPERF_INSTANCE  pInst,
                            PPERF_OBJECT    pObj)
{

    PutCounterDWKB (hMemDlg, MEMORY_WS,           pInst, pObj, PX_PROCESS_WORKING_SET);
    PutCounterDWKB (hMemDlg, MEMORY_PEAK_WS,      pInst, pObj, PX_PROCESS_PEAK_WS);
    PutCounterDWKB (hMemDlg, MEMORY_PRIVATE_PAGE, pInst, pObj, PX_PROCESS_PRIVATE_PAGE);
    PutCounterDWKB (hMemDlg, MEMORY_VSIZE,        pInst, pObj, PX_PROCESS_VIRTUAL_SIZE);
    PutCounterDWKB (hMemDlg, MEMORY_PEAK_VSIZE,   pInst, pObj, PX_PROCESS_PEAK_VS);
    PutCounterDWKB (hMemDlg, MEMORY_PFCOUNT,      pInst, pObj, PX_PROCESS_FAULT_COUNT);
}

//*********************************************************************
//
//      PaintPviewDlgMemoryData
//
//  Paint the memory data for pview dialog.
//
void    PaintPviewDlgMemoryData    (HWND            hPviewDlg,
                                    PPERF_INSTANCE  pInst,
                                    PPERF_OBJECT    pObj)
{
	PPERF_COUNTER   pCounter;
	TCHAR           str[20];
	DWORD           *pdwData;
	DWORD           dwData = 0;
	BOOL            bCounter = FALSE;

    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_NOACCESS))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READONLY))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_READWRITE))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_WRITECOPY))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXECUTABLE))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READONLY))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_READWRITE))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (pCounter = FindCounter (pObj, PX_PROCESS_PRIVATE_EXE_WRITECOPY))
	{
        pdwData = (DWORD *) CounterData (pInst, pCounter);
        dwData += *pdwData;
        bCounter = TRUE;
	}
    if (bCounter)
	{
        wsprintf (str, TEXT("%ld KB"), dwData/1024);
        SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, str);
	}
    else
        SetDlgItemText (hPviewDlg, PVIEW_TOTALPRIVATE_COMMIT, NODATA);

}

//*********************************************************************
//
//      RefreshMemoryDlg
//
//  Refresh the memory detail dialog.
//
BOOL    RefreshMemoryDlg   (HWND            hMemDlg,
                            PPERF_INSTANCE  pProcessInstance,
                            PPERF_OBJECT    pProcessObject,
                            PPERF_OBJECT    pAddressObject,
                            PPERF_OBJECT    pImageObject)
{
	DWORD           *pProcessID1;
	DWORD           *pProcessID2;
	PPERF_COUNTER   pCounter1;
	PPERF_COUNTER   pCounter2;
	PPERF_INSTANCE  pAddressInstance;
	HWND            hImageList;
	TCHAR           szTemp[40];
	BOOL            bStat = FALSE;
	INT             InstIndex = 0;

    if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) &&
        (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID)))
	{
        pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1);
        wsprintf (szTemp, TEXT("%s (%#x)"), InstanceName (pProcessInstance), *pProcessID1);
        SetDlgItemText (hMemDlg, MEMORY_PROCESS_ID, szTemp);
        pAddressInstance = FirstInstance (pAddressObject);
        while (pAddressInstance && InstIndex < pAddressObject->NumInstances)
		{
            pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2);
            if (*pProcessID1 == *pProcessID2)
			{
                PaintMemDlgAddrData (hMemDlg, pAddressInstance, pAddressObject);
                PaintMemDlgVMData (hMemDlg, pProcessInstance, pProcessObject);
                hImageList = GetDlgItem (hMemDlg, MEMORY_IMAGE);
                RefreshMemoryDlgImageList (hImageList, InstIndex, pImageObject);
                bStat = TRUE;
                break;
			}
             pAddressInstance = NextInstance (pAddressInstance);
            InstIndex++;
		}
	}
    return bStat;
}

//*********************************************************************
//
//      RefreshMemoryDlgImageList
//
//  Refresh the image list for memory dialog.
//
void    RefreshMemoryDlgImageList  (HWND            hImageList,
                                    DWORD           ParentIndex,
                                    PPERF_OBJECT    pImageObj)
{
	PPERF_INSTANCE  pImageInst;
	INT             ListIndex;
	INT             InstIndex = 0;

    ListIndex = SendMessage (hImageList, CB_ADDSTRING, 0, (DWORD)TEXT(" Total Commit"));
    SendMessage (hImageList, CB_SETITEMDATA, ListIndex, 0xFFFFFFFF);
    if (pImageObj)
	{
        pImageInst = FirstInstance (pImageObj);
        while (pImageInst && InstIndex < pImageObj->NumInstances)
		{
            if (ParentIndex == pImageInst->ParentObjectInstance)
			{
                ListIndex = SendMessage (hImageList,
                                         CB_ADDSTRING,
                                         0,
                                         (DWORD)InstanceName(pImageInst));
                SendMessage (hImageList, CB_SETITEMDATA, ListIndex, InstIndex);
			}
            pImageInst = NextInstance (pImageInst);
            InstIndex++;
		}
	}
}

//*********************************************************************
//
//      RefreshMemoryDlgImage
//
//
void RefreshMemoryDlgImage (HWND            hMemDlg,
                            DWORD           dwIndex,
                            PPERF_OBJECT    pImageObject)
{
	PPERF_INSTANCE  pInst;
    if (pInst = FindInstanceN (pImageObject, dwIndex))
        PaintAddressSpace (hMemDlg, pInst, pImageObject,
                           MEMORY_TOTALIMAGE_COMMIT,
                           MEMORY_IMAGE_NOACCESS,   PX_IMAGE_NOACCESS,
                           MEMORY_IMAGE_READONLY,   PX_IMAGE_READONLY,
                           MEMORY_IMAGE_READWRITE,  PX_IMAGE_READWRITE,
                           MEMORY_IMAGE_WRITECOPY,  PX_IMAGE_WRITECOPY,
                           MEMORY_IMAGE_EXECUTE,    PX_IMAGE_EXECUTABLE,
                           PX_IMAGE_EXE_READONLY,   PX_IMAGE_EXE_READWRITE,
                           PX_IMAGE_EXE_WRITECOPY);
}

//*********************************************************************
//
//      RefreshPviewDlgMemoryData
//
//  Update the memory data for pview dialog.  This should be done
//  after the ghCostlyData is collected and is not refreshing.
//
void RefreshPviewDlgMemoryData (HWND            hPviewDlg,
                                PPERF_INSTANCE  pProcessInstance,
                                PPERF_OBJECT    pProcessObject,
                                PPERF_OBJECT    pAddressObject)
{
	DWORD           *pProcessID1;
	DWORD           *pProcessID2;
	PPERF_COUNTER   pCounter1;
	PPERF_COUNTER   pCounter2;
	PPERF_INSTANCE  pAddressInstance;
	INT             i = 0;
    if ((pCounter1 = FindCounter (pProcessObject, PX_PROCESS_ID)) &&
        (pCounter2 = FindCounter (pAddressObject, PX_PROCESS_ID)))
	{
        pProcessID1 = (DWORD *) CounterData (pProcessInstance, pCounter1);
        pAddressInstance = FirstInstance (pAddressObject);
        while (pAddressInstance && i < pAddressObject->NumInstances)
		{
            pProcessID2 = (DWORD *) CounterData (pAddressInstance, pCounter2);
            if (*pProcessID1 == *pProcessID2)
			{
                PaintPviewDlgMemoryData (hPviewDlg, pAddressInstance, pAddressObject);
                break;
			}
            pAddressInstance = NextInstance (pAddressInstance);
            i++;
		}
	}
}

//*********************************************************************
//
//      RefreshPviewDlgThreadPC
//
//  Update the thread PC value.  This should be done after the ghCostlyData
//  is collected and is no refreshing.
//
void RefreshPviewDlgThreadPC   (HWND            hPviewDlg,
                                LPTSTR          szProcessName,
                                LPTSTR          szThreadName,
                                PPERF_OBJECT    pThreadDetailsObject,
                                PPERF_DATA      pCostlyData)
{
	PPERF_COUNTER   pCounter;
	PPERF_INSTANCE  pInstance;
	PPERF_INSTANCE  pParent;
	LPTSTR          szInstanceName;
	LPTSTR          szParentName;
	TCHAR           str[20];
	DWORD           *pdwData;
	INT             i = 0;
    if (pCounter = FindCounter (pThreadDetailsObject, PX_THREAD_PC))
	{
        pInstance = FirstInstance (pThreadDetailsObject);
        while (pInstance && i < pThreadDetailsObject->NumInstances)
		{
            if (!(szInstanceName = InstanceName (pInstance)))
                // can't find name
                ;
            else if (lstrcmp (szThreadName, szInstanceName))
                // the thread name is different
                ;
            else if (!(pParent = FindInstanceParent (pInstance, pCostlyData)))
                // can't find parent
                ;
            else if (!(szParentName = InstanceName (pParent)))
                // can't find parent's name
                ;
            else if (!lstrcmp (szProcessName, szParentName))
			{
                // Parent's name matches, this is the right one.
                //
                pdwData = CounterData (pInstance, pCounter);
                wsprintf (str, TEXT("0x%08x"), *pdwData);
                SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, str);
                return;
			}
            pInstance = NextInstance (pInstance);
            i++;
		}
	}
    // We are here only because we can't find the data to display.
    //
    SetDlgItemText (hPviewDlg, PVIEW_THREAD_PC, NODATA);
}

//*********************************************************************
//
//      ProcessPriority
//
//  Returns the process priority dialog item id.
//
WORD    ProcessPriority    (PPERF_OBJECT    pObject,
                            PPERF_INSTANCE  pInstance)
{
	PPERF_COUNTER   pCounter;
	DWORD           *pdwData;
    if (pCounter = FindCounter (pObject, PX_PROCESS_PRIO))
	{
        pdwData = (DWORD *) CounterData (pInstance, pCounter);
        if (*pdwData < 7)
            return PVIEW_PRIORITY_IDL;
        else if (*pdwData < 10)
            return PVIEW_PRIORITY_NORMAL;
        else
            return PVIEW_PRIORITY_HIGH;