1364 lines
40 KiB
C++
1364 lines
40 KiB
C++
// exctrdlg.cpp : implementation file
|
|
//
|
|
|
|
#ifndef UNICODE
|
|
#define UNICODE 1
|
|
#endif
|
|
#ifndef _UNICODE
|
|
#define _UNICODE 1
|
|
#endif
|
|
|
|
#include "stdafx.h"
|
|
#include "exctrlst.h"
|
|
#include "exctrdlg.h"
|
|
#include "tchar.h"
|
|
|
|
// string constants
|
|
// displayed strings
|
|
const TCHAR cszNotFound[] = {TEXT("Not Found")};
|
|
const TCHAR cszNA[] = {TEXT("N/A")};
|
|
|
|
// strings that are not displayed
|
|
|
|
const WCHAR cszServiceKeyName[] = L"SYSTEM\\CurrentControlSet\\Services";
|
|
const WCHAR cszNamesKey[] = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib";
|
|
|
|
// Performance subkey registry value names
|
|
const WCHAR cszDisablePerformanceCounters[] = {L"Disable Performance Counters"};
|
|
const TCHAR cszDoubleBackslash[] = {TEXT("\\\\")};
|
|
const TCHAR cszSpace[] = {TEXT(" ")};
|
|
const TCHAR cszSplat[] = {TEXT("*")};
|
|
const TCHAR cszServIdFmt[] = {TEXT("%d %s")};
|
|
const TCHAR cszOpen[] = {TEXT("Open")};
|
|
const TCHAR cszCollect[] = {TEXT("Collect")};
|
|
const TCHAR cszClose[] = {TEXT("Close")};
|
|
const TCHAR cszIdFmt[] = {TEXT("0x%8.8x (%d) %s")};
|
|
const TCHAR cszSortIdFmt[] = {TEXT("0x%8.8x\t%s")};
|
|
const TCHAR cszTab[] = {TEXT("\t")};
|
|
const TCHAR cszFirstCounter[] = {TEXT("First Counter")};
|
|
const TCHAR cszLastCounter[] = {TEXT("Last Counter")};
|
|
const TCHAR cszFirstHelp[] = {TEXT("First Help")};
|
|
const TCHAR cszLastHelp[] = {TEXT("Last Help")};
|
|
const TCHAR cszLibrary[] = {TEXT("Library")};
|
|
const TCHAR cszPerformance[] = {TEXT("\\Performance")};
|
|
const TCHAR cszSlash[] = {TEXT("\\")};
|
|
const WCHAR cszVersionName[] = {L"Version"};
|
|
const WCHAR cszCounterName[] = {L"Counter "};
|
|
const WCHAR cszHelpName[] = {L"Explain "};
|
|
const WCHAR cszCounters[] = {L"Counters"};
|
|
const TCHAR cszHelp[] = {TEXT("Help")};
|
|
|
|
// Perflib registry values
|
|
const WCHAR cszDefaultLangId[] = L"009";
|
|
const WCHAR cszConfigurationFlags[] = L"Configuration Flags";
|
|
const WCHAR cszEventLogLevel[] = L"EventLogLevel";
|
|
const WCHAR cszExtCounterTestLevel[] = L"ExtCounterTestLevel";
|
|
const WCHAR cszFailureLimit[] = L"Error Count Limit";
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
BOOL CExctrlstDlg::IndexHasString (
|
|
DWORD dwIndex
|
|
)
|
|
{
|
|
if ((dwIndex <= dwLastElement) && (pNameTable != NULL)) {
|
|
if (pNameTable[dwIndex] != NULL) {
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
LPWSTR
|
|
*BuildNameTable(
|
|
LPCWSTR szMachineName,
|
|
LPCWSTR lpszLangIdArg, // unicode value of Language subkey
|
|
PDWORD pdwLastItem, // size of array in elements
|
|
PDWORD pdwIdArray // array for index ID's
|
|
)
|
|
/*++
|
|
|
|
BuildNameTable
|
|
|
|
Arguments:
|
|
|
|
hKeyRegistry
|
|
Handle to an open registry (this can be local or remote.) and
|
|
is the value returned by RegConnectRegistry or a default key.
|
|
|
|
lpszLangId
|
|
The unicode id of the language to look up. (default is 409)
|
|
|
|
Return Value:
|
|
|
|
pointer to an allocated table. (the caller must MemoryFree it when finished!)
|
|
the table is an array of pointers to zero terminated strings. NULL is
|
|
returned if an error occured.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKeyRegistry; // handle to registry db with counter names
|
|
|
|
LPWSTR *lpReturnValue;
|
|
LPCWSTR lpszLangId;
|
|
|
|
LPWSTR *lpCounterId;
|
|
LPWSTR lpCounterNames;
|
|
LPWSTR lpHelpText;
|
|
|
|
LPWSTR lpThisName;
|
|
|
|
LONG lWin32Status;
|
|
DWORD dwLastError;
|
|
DWORD dwValueType;
|
|
DWORD dwArraySize;
|
|
DWORD dwBufferSize;
|
|
DWORD dwCounterSize;
|
|
DWORD dwHelpSize;
|
|
DWORD dwThisCounter;
|
|
|
|
DWORD dwSystemVersion;
|
|
DWORD dwLastId;
|
|
DWORD dwLastHelpId;
|
|
|
|
DWORD dwLastCounterIdUsed;
|
|
DWORD dwLastHelpIdUsed;
|
|
|
|
HKEY hKeyValue;
|
|
HKEY hKeyNames;
|
|
|
|
LPWSTR lpValueNameString;
|
|
WCHAR CounterNameBuffer [50];
|
|
WCHAR HelpNameBuffer [50];
|
|
|
|
|
|
hKeyRegistry = NULL;
|
|
if (szMachineName != NULL) {
|
|
lWin32Status = RegConnectRegistryW (szMachineName,
|
|
HKEY_LOCAL_MACHINE,
|
|
&hKeyRegistry);
|
|
} else {
|
|
lWin32Status = ERROR_SUCCESS;
|
|
hKeyRegistry = HKEY_LOCAL_MACHINE;
|
|
}
|
|
|
|
lpValueNameString = NULL; //initialize to NULL
|
|
lpReturnValue = NULL;
|
|
hKeyValue = NULL;
|
|
hKeyNames = NULL;
|
|
|
|
// check for null arguments and insert defaults if necessary
|
|
|
|
if (!lpszLangIdArg) {
|
|
lpszLangId = cszDefaultLangId;
|
|
} else {
|
|
lpszLangId = lpszLangIdArg;
|
|
}
|
|
|
|
// open registry to get number of items for computing array size
|
|
|
|
if (lWin32Status == ERROR_SUCCESS) {
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
cszNamesKey,
|
|
RESERVED,
|
|
KEY_READ,
|
|
&hKeyValue);
|
|
}
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastHelpId);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
cszLastHelp,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwLastHelpId,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
pdwIdArray[2] = dwLastHelpId;
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastId);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
cszLastCounter,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwLastId,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
pdwIdArray[0] = dwLastId;
|
|
|
|
if (dwLastId < dwLastHelpId)
|
|
dwLastId = dwLastHelpId;
|
|
|
|
dwArraySize = dwLastId * sizeof(LPWSTR);
|
|
|
|
// get Perflib system version
|
|
dwBufferSize = sizeof (dwSystemVersion);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
cszVersionName,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwSystemVersion,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
dwSystemVersion = OLD_VERSION;
|
|
// reset the error status
|
|
lWin32Status = ERROR_SUCCESS;
|
|
}
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// get names from registry
|
|
lpValueNameString = (LPWSTR)HeapAlloc (GetProcessHeap(), 0,
|
|
lstrlen(cszNamesKey) * sizeof (WCHAR) +
|
|
lstrlen(cszSlash) * sizeof (WCHAR) +
|
|
lstrlen(lpszLangId) * sizeof (WCHAR) +
|
|
sizeof (UNICODE_NULL));
|
|
|
|
if (!lpValueNameString) goto BNT_BAILOUT;
|
|
|
|
lstrcpy (lpValueNameString, cszNamesKey);
|
|
lstrcat (lpValueNameString, cszSlash);
|
|
lstrcat (lpValueNameString, lpszLangId);
|
|
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
lpValueNameString,
|
|
RESERVED,
|
|
KEY_READ,
|
|
&hKeyNames);
|
|
} else {
|
|
if (szMachineName[0] == 0) {
|
|
hKeyNames = HKEY_PERFORMANCE_DATA;
|
|
} else {
|
|
lWin32Status = RegConnectRegistry (szMachineName,
|
|
HKEY_PERFORMANCE_DATA,
|
|
&hKeyNames);
|
|
}
|
|
lstrcpy (CounterNameBuffer, cszCounterName);
|
|
lstrcat (CounterNameBuffer, lpszLangId);
|
|
|
|
lstrcpy (HelpNameBuffer, cszHelpName);
|
|
lstrcat (HelpNameBuffer, lpszLangId);
|
|
}
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == (DWORD)OLD_VERSION ? cszCounters : CounterNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwBufferSize);
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwCounterSize = dwBufferSize;
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == (DWORD)OLD_VERSION ? cszHelp : HelpNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwBufferSize);
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwHelpSize = dwBufferSize;
|
|
|
|
lpReturnValue = (LPWSTR *)HeapAlloc (GetProcessHeap(), 0,dwArraySize + dwCounterSize + dwHelpSize);
|
|
|
|
if (!lpReturnValue) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
// initialize pointers into buffer
|
|
|
|
lpCounterId = lpReturnValue;
|
|
lpCounterNames = (LPWSTR)((LPBYTE)lpCounterId + dwArraySize);
|
|
lpHelpText = (LPWSTR)((LPBYTE)lpCounterNames + dwCounterSize);
|
|
|
|
// read counters into memory
|
|
|
|
dwBufferSize = dwCounterSize;
|
|
lWin32Status = RegQueryValueExW (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? cszCounters : CounterNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)lpCounterNames,
|
|
&dwBufferSize);
|
|
|
|
if (!lpReturnValue) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwBufferSize = dwHelpSize;
|
|
lWin32Status = RegQueryValueExW (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? cszHelp : HelpNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)lpHelpText,
|
|
&dwBufferSize);
|
|
|
|
if (!lpReturnValue) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwLastCounterIdUsed = 0;
|
|
dwLastHelpIdUsed = 0;
|
|
|
|
// load counter array items
|
|
|
|
for (lpThisName = lpCounterNames;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if (dwThisCounter == 0) {
|
|
goto BNT_BAILOUT; // bad entry
|
|
}
|
|
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
if (dwThisCounter > dwLastCounterIdUsed) dwLastCounterIdUsed = dwThisCounter;
|
|
|
|
}
|
|
|
|
pdwIdArray[1] = dwLastCounterIdUsed;
|
|
|
|
for (lpThisName = lpHelpText;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if (dwThisCounter == 0) {
|
|
goto BNT_BAILOUT; // bad entry
|
|
}
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
if (dwThisCounter > dwLastHelpIdUsed) dwLastHelpIdUsed= dwThisCounter;
|
|
}
|
|
|
|
pdwIdArray[3] = dwLastHelpIdUsed;
|
|
|
|
dwLastId = dwLastHelpIdUsed;
|
|
if (dwLastId < dwLastCounterIdUsed) dwLastId = dwLastCounterIdUsed;
|
|
|
|
if (pdwLastItem) *pdwLastItem = dwLastId;
|
|
|
|
HeapFree (GetProcessHeap(), 0, (LPVOID)lpValueNameString);
|
|
RegCloseKey (hKeyValue);
|
|
// if (dwSystemVersion == OLD_VERSION)
|
|
RegCloseKey (hKeyNames);
|
|
|
|
if ((hKeyRegistry != HKEY_LOCAL_MACHINE) &&
|
|
(hKeyRegistry != NULL)) {
|
|
RegCloseKey(hKeyRegistry);
|
|
}
|
|
return lpReturnValue;
|
|
|
|
BNT_BAILOUT:
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
dwLastError = GetLastError();
|
|
}
|
|
|
|
if (lpValueNameString) {
|
|
HeapFree (GetProcessHeap(), 0, (LPVOID)lpValueNameString);
|
|
}
|
|
|
|
if (lpReturnValue) {
|
|
HeapFree (GetProcessHeap(), 0, (LPVOID)lpReturnValue);
|
|
}
|
|
|
|
if ((hKeyValue != NULL) && (hKeyValue != INVALID_HANDLE_VALUE)) {
|
|
RegCloseKey (hKeyValue);
|
|
}
|
|
|
|
// if (dwSystemVersion == OLD_VERSION &&
|
|
// hKeyNames)
|
|
if ((hKeyNames != NULL) && (hKeyNames != INVALID_HANDLE_VALUE)) {
|
|
RegCloseKey (hKeyNames);
|
|
}
|
|
|
|
if ((hKeyRegistry != HKEY_LOCAL_MACHINE) &&
|
|
(hKeyRegistry != NULL)) {
|
|
RegCloseKey(hKeyRegistry);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
IsMsObject(CString *pLibraryName)
|
|
{
|
|
CString LocalLibraryName;
|
|
|
|
LocalLibraryName = *pLibraryName;
|
|
LocalLibraryName.MakeLower();
|
|
|
|
// for now this just compares known DLL names. valid as of
|
|
// NT v4.0
|
|
if (LocalLibraryName.Find((LPCWSTR)L"perfctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"ftpctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"rasctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"winsctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"sfmctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"atkctrs.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"bhmon.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"tapictrs.dll") >= 0) return TRUE;
|
|
// NT v5.0
|
|
if (LocalLibraryName.Find((LPCWSTR)L"perfdisk.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"perfos.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"perfproc.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"perfnet.dll") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"winspool.drv") >= 0) return TRUE;
|
|
if (LocalLibraryName.Find((LPCWSTR)L"tapiperf.dll") >= 0) return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CExctrlstDlg dialog
|
|
|
|
CExctrlstDlg::CExctrlstDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CExctrlstDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CExctrlstDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
|
|
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
hKeyServices = NULL;
|
|
dwSortOrder = SORT_ORDER_SERVICE;
|
|
bReadWriteAccess = TRUE;
|
|
dwRegAccessMask = KEY_READ | KEY_WRITE;
|
|
pNameTable = NULL;
|
|
dwLastElement = 0;
|
|
dwListBoxHorizExtent = 0;
|
|
dwTabStopCount = 1;
|
|
dwTabStopArray[0] = 85;
|
|
memset (&dwIdArray[0], 0, sizeof(dwIdArray));
|
|
}
|
|
|
|
CExctrlstDlg::~CExctrlstDlg()
|
|
{
|
|
if (hKeyServices != NULL && hKeyServices != INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(hKeyServices);
|
|
}
|
|
if (hKeyMachine != NULL && hKeyMachine != INVALID_HANDLE_VALUE
|
|
&& hKeyMachine != HKEY_LOCAL_MACHINE) {
|
|
RegCloseKey(hKeyMachine);
|
|
}
|
|
if (pNameTable != NULL) {
|
|
HeapFree (GetProcessHeap(), 0, pNameTable);
|
|
pNameTable = NULL;
|
|
dwLastElement = 0;
|
|
}
|
|
}
|
|
|
|
void CExctrlstDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CExctrlstDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CExctrlstDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CExctrlstDlg)
|
|
ON_WM_PAINT()
|
|
ON_WM_QUERYDRAGICON()
|
|
ON_LBN_SELCHANGE(IDC_EXT_LIST, OnSelchangeExtList)
|
|
ON_WM_DESTROY()
|
|
ON_BN_CLICKED(IDC_REFRESH, OnRefresh)
|
|
ON_BN_CLICKED(IDC_ABOUT, OnAbout)
|
|
ON_EN_KILLFOCUS(IDC_MACHINE_NAME, OnKillfocusMachineName)
|
|
ON_BN_CLICKED(IDC_SORT_LIBRARY, OnSortButton)
|
|
ON_BN_CLICKED(IDC_SORT_SERVICE, OnSortButton)
|
|
ON_BN_CLICKED(IDC_SORT_ID, OnSortButton)
|
|
ON_BN_CLICKED(IDC_ENABLED_BTN, OnEnablePerf)
|
|
ON_WM_SYSCOMMAND()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
DWORD CExctrlstDlg::EnablePerfCounters (HKEY hKeyItem, DWORD dwNewValue)
|
|
{
|
|
DWORD dwStatus;
|
|
DWORD dwType;
|
|
DWORD dwValue;
|
|
DWORD dwSize;
|
|
DWORD dwReturn;
|
|
|
|
switch (dwNewValue) {
|
|
case ENABLE_PERF_CTR_QUERY:
|
|
dwType = 0;
|
|
dwSize = sizeof (dwValue);
|
|
dwValue = 0;
|
|
dwStatus = RegQueryValueExW (
|
|
hKeyItem,
|
|
cszDisablePerformanceCounters,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwSize);
|
|
|
|
if ((dwStatus == ERROR_SUCCESS) && (dwType == REG_DWORD)) {
|
|
switch (dwValue) {
|
|
case 0: dwReturn = ENABLE_PERF_CTR_ENABLE; break;
|
|
case 1: dwReturn = ENABLE_PERF_CTR_DISABLE; break;
|
|
default: dwReturn = 0; break;
|
|
}
|
|
} else {
|
|
// if the value is not present, or not = 1, then the perfctrs
|
|
// are enabled
|
|
dwReturn = ENABLE_PERF_CTR_ENABLE;
|
|
}
|
|
break;
|
|
|
|
case ENABLE_PERF_CTR_ENABLE:
|
|
dwType = REG_DWORD;
|
|
dwSize = sizeof (dwValue);
|
|
dwValue = 0;
|
|
dwStatus = RegSetValueExW (
|
|
hKeyItem,
|
|
cszDisablePerformanceCounters,
|
|
0L,
|
|
dwType,
|
|
(LPBYTE)&dwValue,
|
|
dwSize);
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
dwReturn = ENABLE_PERF_CTR_ENABLE;
|
|
} else {
|
|
dwReturn = 0;
|
|
}
|
|
break;
|
|
|
|
case ENABLE_PERF_CTR_DISABLE:
|
|
dwType = REG_DWORD;
|
|
dwSize = sizeof (dwValue);
|
|
dwValue = 1;
|
|
dwStatus = RegSetValueExW (
|
|
hKeyItem,
|
|
cszDisablePerformanceCounters,
|
|
0L,
|
|
dwType,
|
|
(LPBYTE)&dwValue,
|
|
dwSize);
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
dwReturn = ENABLE_PERF_CTR_DISABLE;
|
|
} else {
|
|
dwReturn = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
dwReturn = 0;
|
|
}
|
|
return dwReturn;
|
|
}
|
|
|
|
void CExctrlstDlg::ScanForExtensibleCounters ()
|
|
{
|
|
LONG lStatus = ERROR_SUCCESS;
|
|
LONG lEnumStatus = ERROR_SUCCESS;
|
|
DWORD dwServiceIndex;
|
|
TCHAR szServiceSubKeyName[MAX_PATH];
|
|
TCHAR szPerfSubKeyName[MAX_PATH+20];
|
|
TCHAR szItemText[MAX_PATH];
|
|
TCHAR szListText[MAX_PATH*2];
|
|
DWORD dwNameSize;
|
|
HKEY hKeyPerformance;
|
|
UINT_PTR nListBoxEntry;
|
|
DWORD dwItemSize, dwType, dwValue;
|
|
HCURSOR hOldCursor;
|
|
DWORD dwThisExtent;
|
|
HDC hDcListBox;
|
|
CWnd *pCWndListBox;
|
|
|
|
hOldCursor = ::SetCursor (LoadCursor(NULL, IDC_WAIT));
|
|
|
|
ResetListBox();
|
|
|
|
if (hKeyServices == NULL) {
|
|
// try read/write access
|
|
lStatus = RegOpenKeyEx (hKeyMachine,
|
|
cszServiceKeyName,
|
|
0L,
|
|
dwRegAccessMask,
|
|
&hKeyServices);
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// try read-only then
|
|
dwRegAccessMask = KEY_READ;
|
|
bReadWriteAccess = FALSE;
|
|
lStatus = RegOpenKeyEx (hKeyMachine,
|
|
cszServiceKeyName,
|
|
0L,
|
|
dwRegAccessMask,
|
|
&hKeyServices);
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// display Read Only message
|
|
AfxMessageBox (IDS_READ_ONLY);
|
|
} else {
|
|
// fall through with error code
|
|
// display no access message
|
|
AfxMessageBox (IDS_NO_ACCESS);
|
|
}
|
|
}
|
|
} else {
|
|
lStatus = ERROR_SUCCESS;
|
|
}
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
pCWndListBox = GetDlgItem (IDC_EXT_LIST);
|
|
hDcListBox = ::GetDC (pCWndListBox->m_hWnd);
|
|
if (hDcListBox == NULL) {
|
|
return;
|
|
}
|
|
dwServiceIndex = 0;
|
|
dwNameSize = MAX_PATH;
|
|
while ((lEnumStatus = RegEnumKeyEx (
|
|
hKeyServices,
|
|
dwServiceIndex,
|
|
szServiceSubKeyName,
|
|
&dwNameSize,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL)) == ERROR_SUCCESS) {
|
|
|
|
//try to open the perfkey under this key.
|
|
lstrcpy (szPerfSubKeyName, szServiceSubKeyName);
|
|
lstrcat (szPerfSubKeyName, cszPerformance);
|
|
|
|
lStatus = RegOpenKeyEx (
|
|
hKeyServices,
|
|
szPerfSubKeyName,
|
|
0L,
|
|
dwRegAccessMask,
|
|
&hKeyPerformance);
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
// look up the library name
|
|
|
|
dwItemSize = MAX_PATH * sizeof(TCHAR);
|
|
dwType = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyPerformance,
|
|
cszLibrary,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&szItemText[0],
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) ||
|
|
((dwType != REG_SZ) && dwType != REG_EXPAND_SZ)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
}
|
|
|
|
dwItemSize = sizeof(DWORD);
|
|
dwType = 0;
|
|
dwValue = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyPerformance,
|
|
cszFirstCounter,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) || (dwType != REG_DWORD)) {
|
|
dwValue = 0;
|
|
}
|
|
|
|
// make the string for the list box here depending
|
|
// on the selected sort order.
|
|
|
|
if (dwSortOrder == SORT_ORDER_LIBRARY) {
|
|
lstrcpy(szListText, szItemText);
|
|
lstrcat(szListText, cszTab);
|
|
lstrcat(szListText, szServiceSubKeyName);
|
|
} else if (dwSortOrder == SORT_ORDER_ID) {
|
|
_stprintf (szListText, cszSortIdFmt,
|
|
dwValue, szServiceSubKeyName);
|
|
} else { // default is sort by service
|
|
lstrcpy(szListText, szServiceSubKeyName);
|
|
lstrcat(szListText, cszTab);
|
|
lstrcat(szListText, szItemText);
|
|
}
|
|
|
|
// add this name to the list box
|
|
nListBoxEntry = SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_ADDSTRING, 0, (LPARAM)&szListText[0]);
|
|
|
|
if (nListBoxEntry != LB_ERR) {
|
|
dwThisExtent = GetTabbedTextExtent (
|
|
hDcListBox,
|
|
szListText,
|
|
lstrlen(szListText),
|
|
(int)dwTabStopCount,
|
|
(int *)&dwTabStopArray[0]);
|
|
|
|
if (dwThisExtent > dwListBoxHorizExtent) {
|
|
dwListBoxHorizExtent = dwThisExtent;
|
|
SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_SETHORIZONTALEXTENT,
|
|
(WPARAM)LOWORD(dwListBoxHorizExtent), (LPARAM)0);
|
|
}
|
|
// save key to this entry in the registry
|
|
SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_SETITEMDATA, (WPARAM)nListBoxEntry,
|
|
(LPARAM)hKeyPerformance);
|
|
|
|
// Ignore PREFIX complains of handle leak for hKeyPerformance.
|
|
//
|
|
// local variable hKeyPerformance (registry key for "<service>\Performace") is
|
|
// put in persistent data storage so that later EXCTRLST can retrieve its value in
|
|
// CExctrlstDlg::UpdateDllInfo() and CExctrlstDlg::OnEnablePerf() and uses it as
|
|
// a parameter in RegQueryValueEx() calls.
|
|
// These registry keys will be released in CExctrlstDlg::ResetListBox().
|
|
}
|
|
else {
|
|
// close the key since there's no point in
|
|
// keeping it open
|
|
RegCloseKey(hKeyPerformance);
|
|
SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_SETITEMDATA, (WPARAM) nListBoxEntry,
|
|
(LPARAM) NULL);
|
|
}
|
|
}
|
|
// reset for next loop
|
|
dwServiceIndex++;
|
|
dwNameSize = MAX_PATH;
|
|
}
|
|
::ReleaseDC (pCWndListBox->m_hWnd, hDcListBox);
|
|
}
|
|
nListBoxEntry = SendDlgItemMessage (IDC_EXT_LIST, LB_GETCOUNT);
|
|
if (nListBoxEntry > 0) {
|
|
SendDlgItemMessage (IDC_EXT_LIST, LB_SETCURSEL, 0, 0);
|
|
}
|
|
::SetCursor (hOldCursor);
|
|
|
|
}
|
|
|
|
void CExctrlstDlg::UpdateSystemInfo () {
|
|
TCHAR szItemText[MAX_PATH];
|
|
|
|
_stprintf (szItemText, cszIdFmt,
|
|
dwIdArray[0], dwIdArray[0], cszSpace);
|
|
SetDlgItemText (IDC_LAST_COUNTER_VALUE, szItemText);
|
|
|
|
_stprintf (szItemText, cszIdFmt,
|
|
dwIdArray[1], dwIdArray[1],
|
|
dwIdArray[1] != dwIdArray[0] ? cszSplat : cszSpace);
|
|
SetDlgItemText (IDC_LAST_TEXT_COUNTER_VALUE, szItemText);
|
|
|
|
_stprintf (szItemText, cszIdFmt,
|
|
dwIdArray[2], dwIdArray[2], cszSpace);
|
|
SetDlgItemText (IDC_LAST_HELP_VALUE, szItemText);
|
|
|
|
_stprintf (szItemText, cszIdFmt,
|
|
dwIdArray[3], dwIdArray[3],
|
|
dwIdArray[3] != dwIdArray[2] ? cszSplat : cszSpace);
|
|
SetDlgItemText (IDC_LAST_TEXT_HELP_VALUE, szItemText);
|
|
|
|
}
|
|
|
|
void CExctrlstDlg::UpdateDllInfo () {
|
|
HKEY hKeyItem;
|
|
TCHAR szItemText[MAX_PATH];
|
|
UINT_PTR nSelectedItem;
|
|
LONG lStatus;
|
|
DWORD dwType;
|
|
DWORD dwValue;
|
|
DWORD dwItemSize;
|
|
BOOL bNoIndexValues = FALSE;
|
|
DWORD dwEnabled;
|
|
|
|
CString OpenProcName;
|
|
CString LibraryName;
|
|
|
|
HCURSOR hOldCursor;
|
|
|
|
hOldCursor = ::SetCursor (LoadCursor(NULL, IDC_WAIT));
|
|
|
|
OpenProcName.Empty();
|
|
LibraryName.Empty();
|
|
// update the performance counter information
|
|
|
|
nSelectedItem = SendDlgItemMessage (IDC_EXT_LIST, LB_GETCURSEL);
|
|
|
|
if (nSelectedItem != LB_ERR) {
|
|
// get registry key for the selected item
|
|
hKeyItem = (HKEY)SendDlgItemMessage(IDC_EXT_LIST, LB_GETITEMDATA,
|
|
(WPARAM)nSelectedItem, 0);
|
|
|
|
if (hKeyItem == NULL) {
|
|
lStatus = ERROR_INVALID_HANDLE;
|
|
}
|
|
else {
|
|
dwItemSize = MAX_PATH * sizeof(TCHAR);
|
|
dwType = 0;
|
|
lStatus = RegQueryValueEx(
|
|
hKeyItem,
|
|
cszLibrary,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & szItemText[0],
|
|
& dwItemSize);
|
|
}
|
|
|
|
if ((lStatus != ERROR_SUCCESS) ||
|
|
((dwType != REG_SZ) && dwType != REG_EXPAND_SZ)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
} else {
|
|
LibraryName = szItemText;
|
|
}
|
|
SetDlgItemText (IDC_DLL_NAME, szItemText);
|
|
|
|
dwItemSize = MAX_PATH * sizeof(TCHAR);
|
|
dwType = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszOpen,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&szItemText[0],
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) ||
|
|
((dwType != REG_SZ) && dwType != REG_EXPAND_SZ)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
} else {
|
|
OpenProcName = szItemText;
|
|
}
|
|
SetDlgItemText (IDC_OPEN_PROC, szItemText);
|
|
|
|
dwItemSize = MAX_PATH * sizeof(TCHAR);
|
|
dwType = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszCollect,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&szItemText[0],
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) ||
|
|
((dwType != REG_SZ) && dwType != REG_EXPAND_SZ)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
}
|
|
SetDlgItemText (IDC_COLLECT_PROC, szItemText);
|
|
|
|
dwItemSize = MAX_PATH * sizeof(TCHAR);
|
|
dwType = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszClose,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&szItemText[0],
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) ||
|
|
((dwType != REG_SZ) && dwType != REG_EXPAND_SZ)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
}
|
|
SetDlgItemText (IDC_CLOSE_PROC, szItemText);
|
|
|
|
dwItemSize = sizeof(DWORD);
|
|
dwType = 0;
|
|
dwValue = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszFirstCounter,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) || (dwType != REG_DWORD)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
bNoIndexValues = TRUE;
|
|
} else {
|
|
_stprintf (szItemText, cszServIdFmt, dwValue, IndexHasString (dwValue) ? cszSpace : cszSplat);
|
|
}
|
|
SetDlgItemText (IDC_FIRST_CTR_ID, szItemText);
|
|
|
|
dwItemSize = sizeof(DWORD);
|
|
dwType = 0;
|
|
dwValue = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszLastCounter,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) || (dwType != REG_DWORD)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
} else {
|
|
_stprintf (szItemText, cszServIdFmt, dwValue, IndexHasString (dwValue) ? cszSpace : cszSplat);
|
|
}
|
|
SetDlgItemText (IDC_LAST_CTR_ID, szItemText);
|
|
|
|
dwItemSize = sizeof(DWORD);
|
|
dwType = 0;
|
|
dwValue = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszFirstHelp,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) || (dwType != REG_DWORD)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
bNoIndexValues = TRUE;
|
|
} else {
|
|
_stprintf (szItemText, cszServIdFmt, dwValue, IndexHasString (dwValue) ? cszSpace : cszSplat);
|
|
}
|
|
SetDlgItemText (IDC_FIRST_HELP_ID, szItemText);
|
|
|
|
dwItemSize = sizeof(DWORD);
|
|
dwType = 0;
|
|
dwValue = 0;
|
|
lStatus = RegQueryValueEx (
|
|
hKeyItem,
|
|
cszLastHelp,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwValue,
|
|
&dwItemSize);
|
|
|
|
if ((lStatus != ERROR_SUCCESS) || (dwType != REG_DWORD)) {
|
|
lstrcpy (szItemText, cszNotFound);
|
|
} else {
|
|
_stprintf (szItemText, cszServIdFmt, dwValue, IndexHasString (dwValue) ? cszSpace : cszSplat);
|
|
}
|
|
SetDlgItemText (IDC_LAST_HELP_ID, szItemText);
|
|
|
|
if (bNoIndexValues) {
|
|
// test to see if this is a "standard" i.e. Microsoft provided
|
|
// extensible counter or simply one that hasn't been completely
|
|
// installed
|
|
if (IsMsObject(&LibraryName)) {
|
|
SetDlgItemText (IDC_FIRST_HELP_ID, cszNA);
|
|
SetDlgItemText (IDC_LAST_HELP_ID, cszNA);
|
|
SetDlgItemText (IDC_FIRST_CTR_ID, cszNA);
|
|
SetDlgItemText (IDC_LAST_CTR_ID, cszNA);
|
|
}
|
|
}
|
|
|
|
GetDlgItem(IDC_ENABLED_BTN)->ShowWindow (bReadWriteAccess ? SW_SHOW : SW_HIDE);
|
|
GetDlgItem(IDC_ENABLED_BTN)->EnableWindow (bReadWriteAccess);
|
|
|
|
dwEnabled = EnablePerfCounters (hKeyItem, ENABLE_PERF_CTR_QUERY);
|
|
|
|
if (bReadWriteAccess) {
|
|
// then set the check box
|
|
CheckDlgButton (IDC_ENABLED_BTN, dwEnabled == ENABLE_PERF_CTR_ENABLE ? 1 : 0);
|
|
GetDlgItem(IDC_DISABLED_TEXT)->ShowWindow (SW_HIDE);
|
|
} else {
|
|
// update the text message
|
|
GetDlgItem(IDC_DISABLED_TEXT)->ShowWindow (
|
|
(!(dwEnabled == ENABLE_PERF_CTR_ENABLE)) ?
|
|
SW_SHOW : SW_HIDE);
|
|
GetDlgItem(IDC_DISABLED_TEXT)->EnableWindow (TRUE);
|
|
}
|
|
|
|
|
|
}
|
|
::SetCursor (hOldCursor);
|
|
}
|
|
|
|
void CExctrlstDlg::ResetListBox ()
|
|
{
|
|
INT_PTR nItemCount;
|
|
INT nThisItem;
|
|
HKEY hKeyItem;
|
|
|
|
nItemCount = SendDlgItemMessage (IDC_EXT_LIST, LB_GETCOUNT);
|
|
nThisItem = 0;
|
|
while (nThisItem > nItemCount) {
|
|
hKeyItem = (HKEY) SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_GETITEMDATA, (WPARAM)nThisItem);
|
|
if (hKeyItem != NULL) RegCloseKey(hKeyItem);
|
|
nThisItem++;
|
|
}
|
|
SendDlgItemMessage (IDC_EXT_LIST, LB_RESETCONTENT);
|
|
dwListBoxHorizExtent = 0;
|
|
SendDlgItemMessage(IDC_EXT_LIST,
|
|
LB_SETHORIZONTALEXTENT,
|
|
(WPARAM)LOWORD(dwListBoxHorizExtent), (LPARAM)0);
|
|
}
|
|
|
|
void CExctrlstDlg::SetSortButtons()
|
|
{
|
|
DWORD dwBtn;
|
|
|
|
switch (dwSortOrder) {
|
|
case SORT_ORDER_LIBRARY: dwBtn = IDC_SORT_LIBRARY; break;
|
|
case SORT_ORDER_SERVICE: dwBtn = IDC_SORT_SERVICE; break;
|
|
case SORT_ORDER_ID: dwBtn = IDC_SORT_ID; break;
|
|
default: dwBtn = IDC_SORT_SERVICE; break;
|
|
}
|
|
|
|
CheckRadioButton (
|
|
IDC_SORT_LIBRARY,
|
|
IDC_SORT_ID,
|
|
dwBtn);
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CExctrlstDlg message handlers
|
|
|
|
BOOL CExctrlstDlg::OnInitDialog()
|
|
{
|
|
HCURSOR hOldCursor;
|
|
DWORD dwLength;
|
|
|
|
hOldCursor = ::SetCursor (::LoadCursor (NULL, IDC_WAIT));
|
|
|
|
CDialog::OnInitDialog();
|
|
CenterWindow();
|
|
|
|
lstrcpy (szThisComputerName, cszDoubleBackslash);
|
|
dwLength = MAX_COMPUTERNAME_LENGTH+1;
|
|
GetComputerName (&szThisComputerName[2], &dwLength);
|
|
|
|
lstrcpy (szComputerName, szThisComputerName);
|
|
|
|
SetDlgItemText (IDC_MACHINE_NAME, szComputerName);
|
|
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
|
|
pNameTable = BuildNameTable (
|
|
szComputerName,
|
|
cszDefaultLangId,
|
|
&dwLastElement, // size of array in elements
|
|
&dwIdArray[0]);
|
|
|
|
SendDlgItemMessage (IDC_MACHINE_NAME, EM_LIMITTEXT,
|
|
(WPARAM)MAX_COMPUTERNAME_LENGTH+2, 0); // include 2 leading backslash
|
|
|
|
SendDlgItemMessage (IDC_EXT_LIST, LB_SETTABSTOPS,
|
|
(WPARAM)dwTabStopCount, (LPARAM)&dwTabStopArray[0]);
|
|
|
|
SetSortButtons();
|
|
|
|
ScanForExtensibleCounters(); //.checks for access to the registry
|
|
|
|
UpdateSystemInfo();
|
|
|
|
// set the check box to the appropriate state
|
|
|
|
UpdateDllInfo ();
|
|
|
|
::SetCursor(hOldCursor);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
}
|
|
|
|
// If you add a minimize button to your dialog, you will need the code below
|
|
// to draw the icon. For MFC applications using the document/view model,
|
|
// this is automatically done for you by the framework.
|
|
|
|
void CExctrlstDlg::OnPaint()
|
|
{
|
|
if (IsIconic())
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
|
|
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
|
|
|
|
// Center icon in client rectangle
|
|
int cxIcon = GetSystemMetrics(SM_CXICON);
|
|
int cyIcon = GetSystemMetrics(SM_CYICON);
|
|
CRect rect;
|
|
GetClientRect(&rect);
|
|
int x = (rect.Width() - cxIcon + 1) / 2;
|
|
int y = (rect.Height() - cyIcon + 1) / 2;
|
|
|
|
// Draw the icon
|
|
dc.DrawIcon(x, y, m_hIcon);
|
|
}
|
|
else
|
|
{
|
|
CDialog::OnPaint();
|
|
}
|
|
}
|
|
|
|
// The system calls this to obtain the cursor to display while the user drags
|
|
// the minimized window.
|
|
HCURSOR CExctrlstDlg::OnQueryDragIcon()
|
|
{
|
|
return (HCURSOR) m_hIcon;
|
|
}
|
|
|
|
void CExctrlstDlg::OnSelchangeExtList()
|
|
{
|
|
UpdateDllInfo ();
|
|
}
|
|
|
|
void CExctrlstDlg::OnDestroy()
|
|
{
|
|
ResetListBox();
|
|
CDialog::OnDestroy();
|
|
}
|
|
|
|
void CExctrlstDlg::OnAbout()
|
|
{
|
|
CAbout dlg;
|
|
dlg.DoModal();
|
|
}
|
|
|
|
void CExctrlstDlg::OnRefresh()
|
|
{
|
|
HCURSOR hOldCursor;
|
|
|
|
hOldCursor = ::SetCursor (::LoadCursor (NULL, IDC_WAIT));
|
|
|
|
ScanForExtensibleCounters();
|
|
if (pNameTable != NULL) {
|
|
HeapFree (GetProcessHeap(), 0, pNameTable);
|
|
pNameTable = NULL;
|
|
dwLastElement = 0;
|
|
}
|
|
|
|
pNameTable = BuildNameTable (
|
|
szComputerName,
|
|
cszDefaultLangId,
|
|
&dwLastElement, // size of array in elements
|
|
&dwIdArray[0]);
|
|
|
|
UpdateSystemInfo();
|
|
|
|
UpdateDllInfo ();
|
|
::SetCursor(hOldCursor);
|
|
}
|
|
|
|
void CExctrlstDlg::OnKillfocusMachineName()
|
|
{
|
|
TCHAR szNewMachineName[MAX_PATH];
|
|
HKEY hKeyNewMachine;
|
|
LONG lStatus;
|
|
HCURSOR hOldCursor;
|
|
|
|
hOldCursor = ::SetCursor (::LoadCursor (NULL, IDC_WAIT));
|
|
|
|
GetDlgItemText (IDC_MACHINE_NAME, szNewMachineName, MAX_PATH);
|
|
|
|
if (lstrcmpi(szComputerName, szNewMachineName) != 0) {
|
|
// a new computer has been entered so try to connect to it
|
|
lStatus = RegConnectRegistry (szNewMachineName,
|
|
HKEY_LOCAL_MACHINE, &hKeyNewMachine);
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
RegCloseKey (hKeyServices); // close the old key
|
|
hKeyServices = NULL; // clear it
|
|
bReadWriteAccess = TRUE; // reset the access variables
|
|
dwRegAccessMask = KEY_READ | KEY_WRITE;
|
|
if (hKeyMachine != NULL && hKeyMachine != INVALID_HANDLE_VALUE
|
|
&& hKeyMachine != HKEY_LOCAL_MACHINE) {
|
|
RegCloseKey(hKeyMachine); // close the old machine
|
|
}
|
|
hKeyMachine = hKeyNewMachine; // update to the new machine
|
|
lstrcpy (szComputerName, szNewMachineName); // update the name
|
|
OnRefresh(); // get new counters
|
|
} else {
|
|
SetDlgItemText (IDC_MACHINE_NAME, szComputerName);
|
|
}
|
|
} else {
|
|
// the machine name has not changed
|
|
}
|
|
::SetCursor (hOldCursor);
|
|
}
|
|
|
|
void CExctrlstDlg::OnSortButton()
|
|
{
|
|
if (IsDlgButtonChecked(IDC_SORT_LIBRARY)) {
|
|
dwSortOrder = SORT_ORDER_LIBRARY;
|
|
} else if (IsDlgButtonChecked(IDC_SORT_SERVICE)) {
|
|
dwSortOrder = SORT_ORDER_SERVICE;
|
|
} else if (IsDlgButtonChecked(IDC_SORT_ID)) {
|
|
dwSortOrder = SORT_ORDER_ID;
|
|
}
|
|
ScanForExtensibleCounters();
|
|
UpdateDllInfo ();
|
|
}
|
|
|
|
void CExctrlstDlg::OnEnablePerf()
|
|
{
|
|
HKEY hKeyItem;
|
|
UINT_PTR nSelectedItem;
|
|
DWORD dwNewValue;
|
|
|
|
nSelectedItem = SendDlgItemMessage (IDC_EXT_LIST, LB_GETCURSEL);
|
|
|
|
if (nSelectedItem != LB_ERR) {
|
|
// get registry key for the selected item
|
|
hKeyItem = (HKEY)SendDlgItemMessage (IDC_EXT_LIST, LB_GETITEMDATA,
|
|
(WPARAM)nSelectedItem, 0);
|
|
|
|
if (hKeyItem != NULL) {
|
|
// get selected perf item and the corre
|
|
dwNewValue = IsDlgButtonChecked(IDC_ENABLED_BTN) ?
|
|
ENABLE_PERF_CTR_ENABLE :
|
|
ENABLE_PERF_CTR_DISABLE;
|
|
|
|
if (EnablePerfCounters (hKeyItem, dwNewValue) == 0) {
|
|
MessageBeep(0xFFFFFFFF);
|
|
// then it failed so reset to the curent value
|
|
dwNewValue = EnablePerfCounters (hKeyItem, ENABLE_PERF_CTR_QUERY);
|
|
CheckDlgButton (IDC_ENABLED_BTN, dwNewValue == ENABLE_PERF_CTR_ENABLE ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CExctrlstDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
switch (nID) {
|
|
case SC_CLOSE:
|
|
EndDialog(IDOK);
|
|
break;
|
|
|
|
default:
|
|
CDialog::OnSysCommand (nID, lParam);
|
|
break;
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAbout dialog
|
|
|
|
|
|
CAbout::CAbout(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CAbout::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CAbout)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CAbout::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAbout)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
BOOL CAbout::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
TCHAR buffer[512];
|
|
TCHAR strProgram[1024];
|
|
DWORD dw;
|
|
BYTE* pVersionInfo;
|
|
LPTSTR pVersion = NULL;
|
|
LPTSTR pProduct = NULL;
|
|
LPTSTR pCopyRight = NULL;
|
|
|
|
dw = GetModuleFileName(NULL, strProgram, 1024);
|
|
|
|
if( dw>0 ){
|
|
|
|
dw = GetFileVersionInfoSize( strProgram, &dw );
|
|
if( dw > 0 ){
|
|
|
|
pVersionInfo = (BYTE*)malloc(dw);
|
|
if( NULL != pVersionInfo ){
|
|
if(GetFileVersionInfo( strProgram, 0, dw, pVersionInfo )){
|
|
LPDWORD lptr = NULL;
|
|
VerQueryValue( pVersionInfo, _T("\\VarFileInfo\\Translation"), (void**)&lptr, (UINT*)&dw );
|
|
if( lptr != NULL ){
|
|
_stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("ProductVersion") );
|
|
VerQueryValue( pVersionInfo, buffer, (void**)&pVersion, (UINT*)&dw );
|
|
_stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("OriginalFilename") );
|
|
VerQueryValue( pVersionInfo, buffer, (void**)&pProduct, (UINT*)&dw );
|
|
_stprintf( buffer, _T("\\StringFileInfo\\%04x%04x\\%s"), LOWORD(*lptr), HIWORD(*lptr), _T("LegalCopyright") );
|
|
VerQueryValue( pVersionInfo, buffer, (void**)&pCopyRight, (UINT*)&dw );
|
|
}
|
|
|
|
if( pProduct != NULL && pVersion != NULL && pCopyRight != NULL ){
|
|
GetDlgItem(IDC_COPYRIGHT)->SetWindowText( pCopyRight );
|
|
GetDlgItem(IDC_VERSION)->SetWindowText( pVersion );
|
|
}
|
|
}
|
|
free( pVersionInfo );
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CAbout, CDialog)
|
|
//{{AFX_MSG_MAP(CAbout)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAbout message handlers
|