3834 lines
125 KiB
C
3834 lines
125 KiB
C
/*++
|
||
|
||
Copyright (C) 1995-1999 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
browsdlg.c
|
||
|
||
Abstract:
|
||
|
||
counter name browsing dialog box functions
|
||
|
||
Revision History
|
||
|
||
Bob Watson (a-robw) Oct-95 Created
|
||
|
||
--*/
|
||
#include <windows.h>
|
||
#include <winperf.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include <tchar.h>
|
||
#include "mbctype.h"
|
||
#include "pdhidef.h"
|
||
#include "pdhdlgs.h"
|
||
#include "pdh.h"
|
||
#include "browsdlg.h"
|
||
#include "resource.h"
|
||
#include "expldlg.h"
|
||
#include "pdhui.h"
|
||
|
||
#pragma warning ( disable : 4213)
|
||
|
||
//
|
||
// Constants used in this module
|
||
//
|
||
#define MACHINE_LIST_SIZE 1024
|
||
#define OBJECT_LIST_SIZE 4096
|
||
#define COUNTER_LIST_SIZE 8192
|
||
#define INSTANCE_LIST_SIZE 8192
|
||
|
||
// global data strings to load into combo box to select counter filtering level
|
||
|
||
ULONG
|
||
PdhiBrowseraulControlIdToHelpIdMap[] =
|
||
{
|
||
IDC_USE_LOCAL_MACHINE, IDH_USE_LOCAL_MACHINE,
|
||
IDC_SELECT_MACHINE, IDH_SELECT_MACHINE,
|
||
IDC_MACHINE_COMBO, IDH_MACHINE_COMBO,
|
||
IDC_COUNTER_DETAIL_COMBO, IDH_COUNTER_DETAIL_COMBO,
|
||
IDC_OBJECT_COMBO, IDH_OBJECT_COMBO,
|
||
IDC_ALL_COUNTERS, IDH_ALL_COUNTERS,
|
||
IDC_USE_COUNTER_LIST, IDH_USE_COUNTER_LIST,
|
||
IDC_COUNTER_LIST, IDH_COUNTER_LIST,
|
||
IDC_ALL_INSTANCES, IDH_ALL_INSTANCES,
|
||
IDC_USE_INSTANCE_LIST, IDH_USE_INSTANCE_LIST,
|
||
IDC_INSTANCE_LIST, IDH_INSTANCE_LIST,
|
||
IDC_EXPLAIN_BTN, IDH_EXPLAIN_BTN,
|
||
IDC_OBJECT_LIST, IDH_OBJECT_LIST,
|
||
0,0
|
||
};
|
||
|
||
PDHI_DETAIL_INFO PdhiDetailInfo[] = {
|
||
{PERF_DETAIL_NOVICE, IDS_DETAIL_NOVICE},
|
||
{PERF_DETAIL_ADVANCED, IDS_DETAIL_ADVANCED},
|
||
{PERF_DETAIL_EXPERT, IDS_DETAIL_EXPERT},
|
||
{PERF_DETAIL_WIZARD, IDS_DETAIL_WIZARD},
|
||
{0,0}
|
||
};
|
||
|
||
static HWND hExplainDlg = NULL;
|
||
|
||
static DWORD dwCounterListSize;
|
||
static DWORD dwInstanceListSize;
|
||
|
||
//
|
||
// Function references
|
||
//
|
||
STATIC_BOOL
|
||
PdhiLoadMachineObjects (
|
||
IN HWND hDlg,
|
||
IN BOOL bRefresh
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadCountersAndInstances (
|
||
IN HWND hDlg
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_MACHINE_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadNewMachine (
|
||
IN HWND hDlg,
|
||
IN LPCWSTR szNewMachineName
|
||
);
|
||
|
||
STATIC_DWORD
|
||
PdhiLoadDetailLevelCombo (
|
||
IN HWND hDlg,
|
||
IN DWORD dwInitialLevel
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiSelectItemsInPath (
|
||
IN HWND hDlg
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadKnownMachines (
|
||
IN HWND hDlg
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersT (
|
||
IN HWND hDlg,
|
||
IN LPVOID pUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength,
|
||
IN BOOL bUnicode
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersW (
|
||
IN HWND hDlg,
|
||
IN LPWSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersA (
|
||
IN HWND hDlg,
|
||
IN LPSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsT (
|
||
IN HWND hDlg,
|
||
IN LPVOID pUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength,
|
||
IN BOOL bUnicode
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsW (
|
||
IN HWND hDlg,
|
||
IN LPWSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
);
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsA (
|
||
IN HWND hDlg,
|
||
IN LPSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_MACHINE_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OBJECT_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_COUNTER_LIST (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OBJECT_LIST (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_DETAIL_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_INSTANCE_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_COUNTER_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OK (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_CANCEL (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_EXPLAIN_BTN (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_HELP_BTN (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_INITDIALOG (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_COMPAREITEM (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_COMMAND (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_SYSCOMMAND (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_CLOSE (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_DESTROY (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
);
|
||
|
||
__inline
|
||
PDH_STATUS
|
||
PdhiCopyString(
|
||
LPBYTE * pszNextString,
|
||
LPWSTR szWorkBuffer,
|
||
LPDWORD pdwRemaining,
|
||
BOOL bUnicode
|
||
)
|
||
{
|
||
PDH_STATUS pdhStatus = ERROR_SUCCESS;
|
||
DWORD dwSize = 0;
|
||
DWORD dwRemaining = * pdwRemaining;
|
||
LPBYTE szNextString = * pszNextString;
|
||
|
||
if (bUnicode) {
|
||
dwSize = lstrlenW(szWorkBuffer);
|
||
if (dwSize < dwRemaining) {
|
||
lstrcpyW ((LPWSTR) szNextString, szWorkBuffer);
|
||
szNextString += dwSize * sizeof(WCHAR);
|
||
* ((LPWSTR) szNextString) = L'\0';
|
||
szNextString += sizeof(WCHAR);
|
||
} else {
|
||
pdhStatus = PDH_MORE_DATA;
|
||
}
|
||
dwSize ++;
|
||
}
|
||
else {
|
||
dwSize = dwRemaining;
|
||
pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
|
||
szWorkBuffer,
|
||
(LPSTR) szNextString,
|
||
& dwSize);
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
szNextString = szNextString
|
||
+ sizeof(CHAR) * (lstrlenA((LPSTR) szNextString) + 1);
|
||
}
|
||
}
|
||
|
||
if (dwRemaining >= dwSize) {
|
||
dwRemaining -= dwSize;
|
||
} else {
|
||
dwRemaining = 0;
|
||
pdhStatus = PDH_MORE_DATA;
|
||
}
|
||
|
||
* pdwRemaining = dwRemaining;
|
||
* pszNextString = szNextString;
|
||
return pdhStatus;
|
||
}
|
||
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadNewMachine (
|
||
IN HWND hDlg,
|
||
IN LPCWSTR szNewMachineName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Connects to a new machine and loads the necessary performance data
|
||
from that machine.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Handle to dialog box containing the combo & list boxes to fill
|
||
|
||
IN LPCWSTR szNewMachineName
|
||
Machine name to open and obtain data from
|
||
|
||
Return Value:
|
||
|
||
TRUE new machine connected and data loaded
|
||
|
||
FALSE unable to connect to machine or obtain performance data from it.
|
||
|
||
|
||
--*/
|
||
{
|
||
HWND hWndMachineCombo;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
LONG lMatchIndex;
|
||
PDH_STATUS status;
|
||
int mbStatus;
|
||
BOOL bReturn = FALSE;
|
||
DWORD dwDataSourceType;
|
||
LPWSTR szMsg;
|
||
|
||
// acquire the data block associated with this dialog instance
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
// invalid data block, unable to continue
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
// get window handle of the dialog box
|
||
hWndMachineCombo = GetDlgItem (hDlg, IDC_MACHINE_COMBO);
|
||
|
||
// not in list so try to add it as long as the data source
|
||
// is "Current Activity" (ie. == NULL) For Log Files, only
|
||
// the machines listed may be selected.
|
||
dwDataSourceType = DataSourceTypeH(pData->pDlgData->hDataSource);
|
||
if (dwDataSourceType != DATA_SOURCE_LOGFILE) {
|
||
status = PdhConnectMachineW (szNewMachineName);
|
||
|
||
if (status == ERROR_SUCCESS) {
|
||
// if successful, add string to combo box
|
||
lMatchIndex = (LONG)SendMessageW (hWndMachineCombo, CB_ADDSTRING,
|
||
0, (LPARAM)szNewMachineName);
|
||
SendMessageW (hWndMachineCombo, CB_SETCURSEL,
|
||
(WPARAM)lMatchIndex, 0);
|
||
// update other controls in this dialog
|
||
PdhiLoadMachineObjects (hDlg, FALSE); // no need to update since it was just connected
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
bReturn = TRUE;
|
||
} else {
|
||
szMsg = GetStringResource (IDS_ERR_UNABLE_TO_CONNECT);
|
||
if (szMsg != NULL) {
|
||
mbStatus = MessageBoxW (hDlg, szMsg, NULL,
|
||
MB_ICONEXCLAMATION | MB_TASKMODAL | MB_OK);
|
||
if (mbStatus == IDCANCEL) {
|
||
SetFocus(GetDlgItem(hDlg, IDC_MACHINE_COMBO));
|
||
} else {
|
||
SendMessageW (hWndMachineCombo, CB_SETCURSEL,
|
||
pData->wpLastMachineSel, 0);
|
||
}
|
||
G_FREE (szMsg);
|
||
} else {
|
||
MessageBeep (MB_ICONEXCLAMATION);
|
||
}
|
||
bReturn = FALSE;
|
||
}
|
||
} else {
|
||
szMsg = GetStringResource (IDS_ERR_MACHINE_NOT_IN_LOGFILE);
|
||
if (szMsg != NULL) {
|
||
mbStatus = MessageBoxW (hDlg,
|
||
szMsg, NULL,
|
||
MB_ICONEXCLAMATION | MB_TASKMODAL | MB_OK);
|
||
|
||
G_FREE (szMsg);
|
||
} else {
|
||
MessageBeep (MB_ICONEXCLAMATION);
|
||
}
|
||
// re-select the last machine
|
||
|
||
lMatchIndex = (long)SendMessageW (hWndMachineCombo,
|
||
CB_FINDSTRINGEXACT,(WPARAM)-1,
|
||
(LPARAM)pData->szLastMachineName);
|
||
SendMessageW (hWndMachineCombo, CB_SETCURSEL,
|
||
(WPARAM)lMatchIndex, 0);
|
||
bReturn = FALSE;
|
||
}
|
||
|
||
return bReturn;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiSelectItemsInPath (
|
||
IN HWND hDlg
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Selects the items in the list box based on the counter path
|
||
string in the shared buffer.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Handle to the dialog window containing the controls
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful,
|
||
FALSE if not
|
||
|
||
--*/
|
||
{
|
||
// regular stack variables
|
||
PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElementsW;
|
||
PDH_COUNTER_PATH_ELEMENTS_A *pCounterPathElementsA;
|
||
PDH_STATUS status;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
BOOL bReturn = FALSE;
|
||
DWORD dwBufferSize;
|
||
HWND hWndMachineCombo;
|
||
HWND hWndObjectCombo;
|
||
HWND hWndCounterList;
|
||
HWND hWndInstanceList;
|
||
LONG lIndex;
|
||
WCHAR wszMachineName[MAX_PATH];
|
||
|
||
// reset the last error value
|
||
SetLastError (ERROR_SUCCESS);
|
||
|
||
// get this dialog's user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return bReturn;
|
||
}
|
||
|
||
hWndMachineCombo = GetDlgItem (hDlg, IDC_MACHINE_COMBO);
|
||
hWndObjectCombo = GetDlgItem (hDlg, IDC_OBJECT_COMBO);
|
||
hWndCounterList = GetDlgItem (hDlg, IDC_COUNTER_LIST);
|
||
hWndInstanceList = GetDlgItem (hDlg, IDC_INSTANCE_LIST);
|
||
|
||
// Call the right conversion function based on user's buffer
|
||
|
||
if (pData->pDlgData->pWideStruct != NULL) {
|
||
// UNICODE/ wide characters
|
||
dwBufferSize = MAX_PATH * 2 * sizeof (WCHAR);
|
||
pCounterPathElementsW = (PDH_COUNTER_PATH_ELEMENTS_W *)
|
||
G_ALLOC(dwBufferSize);
|
||
|
||
if (pCounterPathElementsW == NULL) {
|
||
SetLastError (PDH_MEMORY_ALLOCATION_FAILURE);
|
||
return bReturn;
|
||
}
|
||
status = PdhParseCounterPathW (
|
||
pData->pDlgData->pWideStruct->szReturnPathBuffer,
|
||
pCounterPathElementsW,
|
||
&dwBufferSize,
|
||
0);
|
||
|
||
if (status == ERROR_SUCCESS) {
|
||
// select entry in each list box
|
||
// select machine entry. Load machine if necessary
|
||
|
||
lIndex = (LONG)SendMessageW (hWndMachineCombo, CB_FINDSTRINGEXACT,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsW->szMachineName);
|
||
if (lIndex == CB_ERR) {
|
||
// try adding the machine
|
||
if (!PdhiLoadNewMachine (hDlg, pCounterPathElementsW->szMachineName)) {
|
||
// give up
|
||
bReturn = FALSE;
|
||
} else {
|
||
// the correct machine has been selected
|
||
}
|
||
} else {
|
||
// the machine has been found so select it
|
||
SendMessageW (hWndMachineCombo, CB_SETCURSEL,
|
||
(WPARAM)lIndex, 0);
|
||
// update other fields
|
||
PdhiLoadMachineObjects (hDlg, FALSE); // no need to update since it was just connected
|
||
}
|
||
|
||
// select the current object
|
||
lIndex = (LONG)SendMessageW (hWndObjectCombo, CB_FINDSTRING,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsW->szObjectName);
|
||
if (lIndex != CB_ERR) {
|
||
SendMessageW (hWndObjectCombo, CB_SETCURSEL,
|
||
(WPARAM)lIndex, 0);
|
||
// update the counters for this object
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
// now select the counter
|
||
lIndex = (LONG)SendMessageW (hWndCounterList, LB_FINDSTRING,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsW->szCounterName);
|
||
if (lIndex != LB_ERR) {
|
||
if (pData->bSelectMultipleCounters) {
|
||
SendMessageW (hWndCounterList, LB_SETSEL, FALSE, (LPARAM)-1);
|
||
SendMessageW (hWndCounterList, LB_SETSEL, TRUE, lIndex);
|
||
SendMessageW (hWndCounterList, LB_SETCARETINDEX,
|
||
(WPARAM)lIndex, MAKELPARAM(FALSE, 0));
|
||
} else {
|
||
SendMessageW (hWndCounterList, LB_SETCURSEL, lIndex, 0);
|
||
}
|
||
// display explain text if necessary
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
bReturn = TRUE;
|
||
} else {
|
||
// unable to locate counter
|
||
bReturn = FALSE;
|
||
}
|
||
} else {
|
||
// unable to locate the selected object
|
||
bReturn = FALSE;
|
||
}
|
||
} // else unable to read path so exit
|
||
|
||
G_FREE (pCounterPathElementsW);
|
||
} else {
|
||
// ANSI characters
|
||
|
||
dwBufferSize = MAX_PATH * 2 * sizeof (CHAR);
|
||
pCounterPathElementsA = (PDH_COUNTER_PATH_ELEMENTS_A *)G_ALLOC(
|
||
dwBufferSize);
|
||
|
||
if (pCounterPathElementsA == NULL) {
|
||
SetLastError (PDH_MEMORY_ALLOCATION_FAILURE);
|
||
return bReturn;
|
||
}
|
||
status = PdhParseCounterPathA (
|
||
pData->pDlgData->pAnsiStruct->szReturnPathBuffer,
|
||
pCounterPathElementsA,
|
||
&dwBufferSize,
|
||
0);
|
||
|
||
if (status == ERROR_SUCCESS) {
|
||
// select entry in each list box
|
||
// select machine entry. Load machine if necessary
|
||
|
||
lIndex = (LONG)SendMessageA (hWndMachineCombo, CB_FINDSTRINGEXACT,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsA->szMachineName);
|
||
if (lIndex == CB_ERR) {
|
||
// try adding the machine
|
||
// convert ansi buffer to wide char first
|
||
MultiByteToWideChar(_getmbcp(),
|
||
0,
|
||
pCounterPathElementsA->szMachineName,
|
||
lstrlenA(pCounterPathElementsA->szMachineName),
|
||
wszMachineName,
|
||
MAX_PATH);
|
||
if (!PdhiLoadNewMachine (hDlg, wszMachineName)) {
|
||
// give up
|
||
bReturn = FALSE;
|
||
} else {
|
||
// the correct machine has been selected
|
||
}
|
||
} else {
|
||
// the machine has been found so select it
|
||
SendMessageA (hWndMachineCombo, CB_SETCURSEL,
|
||
(WPARAM)lIndex, 0);
|
||
// update other fields
|
||
PdhiLoadMachineObjects (hDlg, FALSE); // no need to update since it was just connected
|
||
}
|
||
|
||
// select the current object
|
||
lIndex = (LONG)SendMessageA (hWndObjectCombo, CB_FINDSTRING,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsA->szObjectName);
|
||
if (lIndex != CB_ERR) {
|
||
SendMessageA (hWndObjectCombo, CB_SETCURSEL,
|
||
(WPARAM)lIndex, 0);
|
||
// update the counters for this object
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
// now select the counter
|
||
lIndex = (LONG)SendMessageA (hWndCounterList, LB_FINDSTRING,
|
||
(WPARAM)-1, (LPARAM)pCounterPathElementsA->szCounterName);
|
||
if (lIndex != LB_ERR) {
|
||
if (pData->bSelectMultipleCounters) {
|
||
SendMessageA (hWndCounterList, LB_SETSEL, FALSE, (LPARAM)-1);
|
||
SendMessageA (hWndCounterList, LB_SETSEL, TRUE, lIndex);
|
||
SendMessageA (hWndCounterList, LB_SETCARETINDEX,
|
||
(WPARAM)lIndex, MAKELPARAM(FALSE, 0));
|
||
} else {
|
||
SendMessageA (hWndCounterList, LB_SETCURSEL, lIndex, 0);
|
||
}
|
||
// display explain text if necessary
|
||
SendMessage (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
bReturn = TRUE;
|
||
} else {
|
||
// unable to locate counter
|
||
bReturn = FALSE;
|
||
}
|
||
} else {
|
||
// unable to locate the selected object
|
||
bReturn = FALSE;
|
||
}
|
||
} // else unable to read path so exit
|
||
|
||
G_FREE (pCounterPathElementsA);
|
||
}
|
||
|
||
return bReturn;
|
||
}
|
||
|
||
STATIC_DWORD
|
||
PdhiLoadDetailLevelCombo (
|
||
IN HWND hDlg,
|
||
IN DWORD dwInitialLevel
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Loads the Detail Level Combo box with the strings and ID's
|
||
defined by the PdhiDetailInfo string array above.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Handle to the dialog box containing the combo box
|
||
|
||
IN DWORD dwInitialLevel
|
||
the intitial detail level to select in the combo box.
|
||
|
||
Return Value:
|
||
|
||
Returns the selected level or 0 if an error ocurred.
|
||
|
||
--*/
|
||
{
|
||
HWND hWndCombo;
|
||
DWORD dwIndex;
|
||
DWORD dwStringLength;
|
||
DWORD dwDefaultIndex = 0;
|
||
DWORD dwSelectedLevel = 0;
|
||
DWORD dwThisCbIndex;
|
||
|
||
WCHAR szTempBuffer[MAX_PATH]; // for loading string resource
|
||
|
||
hWndCombo = GetDlgItem (hDlg, IDC_COUNTER_DETAIL_COMBO);
|
||
|
||
// load all combo box strings from static data array defined above
|
||
for (dwIndex = 0; PdhiDetailInfo[dwIndex].dwLevelValue > 0; dwIndex++) {
|
||
// load the string resource for this string
|
||
dwStringLength = LoadStringW (ThisDLLHandle,
|
||
PdhiDetailInfo[dwIndex].dwStringResourceId,
|
||
szTempBuffer, MAX_PATH);
|
||
if (dwStringLength == 0) {
|
||
// unable to read the string in, so
|
||
// substitute the value for the string
|
||
_ltow (PdhiDetailInfo[dwIndex].dwLevelValue,
|
||
szTempBuffer, 10);
|
||
}
|
||
// load the strings into the combo box in the same order they
|
||
// were described in the array above
|
||
dwThisCbIndex = (DWORD)SendMessageW (hWndCombo, CB_INSERTSTRING,
|
||
(WPARAM)-1, (LPARAM)szTempBuffer);
|
||
|
||
// set the initial CB entry to the highest item <= to the
|
||
// desired default level
|
||
if (dwThisCbIndex != CB_ERR) {
|
||
// set item data to be the corresponding detail level
|
||
SendMessageW (hWndCombo, CB_SETITEMDATA, (WPARAM)dwThisCbIndex,
|
||
(LPARAM)PdhiDetailInfo[dwIndex].dwLevelValue);
|
||
// save default selection if it matches.
|
||
if (PdhiDetailInfo[dwIndex].dwLevelValue <= dwInitialLevel) {
|
||
dwDefaultIndex = dwThisCbIndex;
|
||
dwSelectedLevel = PdhiDetailInfo[dwIndex].dwLevelValue;
|
||
}
|
||
}
|
||
}
|
||
|
||
// select desired default entry
|
||
|
||
SendMessageW (hWndCombo, CB_SETCURSEL, (WPARAM)dwDefaultIndex, 0);
|
||
|
||
return dwSelectedLevel;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadKnownMachines (
|
||
IN HWND hDlg
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get the list of machines that are currently connected and disply
|
||
them in the machine list box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Handle to the dialog window containing the controls
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful,
|
||
FALSE if not
|
||
|
||
--*/
|
||
{
|
||
// big stack variables
|
||
WCHAR mszMachineList[MACHINE_LIST_SIZE];
|
||
|
||
// regular stack variables
|
||
LPWSTR szThisMachine;
|
||
DWORD dwLength;
|
||
PDH_STATUS status;
|
||
HWND hMachineListWnd;
|
||
HCURSOR hOldCursor;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
BOOL bReturn = FALSE;
|
||
|
||
// get this dialog's user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return bReturn;
|
||
}
|
||
|
||
// clear the machine list buffer
|
||
memset (&mszMachineList[0], 0, (MACHINE_LIST_SIZE * sizeof (WCHAR)));
|
||
|
||
// display wait cursor since this is potentially time consuming
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
// get window handle to Machine list combo box
|
||
hMachineListWnd = GetDlgItem (hDlg, IDC_MACHINE_COMBO);
|
||
|
||
// clear machine combo box
|
||
SendMessageW (hMachineListWnd, CB_RESETCONTENT, 0, 0);
|
||
|
||
// get list of connected machines from PDH library
|
||
dwLength = MACHINE_LIST_SIZE;
|
||
status = PdhEnumMachinesHW (
|
||
pData->pDlgData->hDataSource,
|
||
&mszMachineList[0],
|
||
&dwLength);
|
||
|
||
if (status == ERROR_SUCCESS) {
|
||
// update the combo box
|
||
// go through MSZ and load each string into combo box
|
||
for (szThisMachine = &mszMachineList[0];
|
||
*szThisMachine != 0;
|
||
szThisMachine += lstrlenW(szThisMachine)+1) {
|
||
// add to the list box and let the list box sort them
|
||
SendMessageW (hMachineListWnd, CB_ADDSTRING, 0,
|
||
(LPARAM)szThisMachine);
|
||
}
|
||
// select the first item in the list (as the initial selection)
|
||
SendMessageW (hMachineListWnd, CB_SETCURSEL, 0, 0);
|
||
|
||
// the "current" machine has not been defined, then
|
||
// do it now
|
||
GetWindowTextW(hMachineListWnd, (LPWSTR)pData->szLastMachineName,
|
||
MAX_PATH);
|
||
|
||
bReturn = TRUE;
|
||
} else {
|
||
// no machines, so select local button and disable the edit window
|
||
CheckRadioButton (hDlg, IDC_USE_LOCAL_MACHINE, IDC_SELECT_MACHINE,
|
||
IDC_USE_LOCAL_MACHINE);
|
||
PdhiBrowseCtrDlg_MACHINE_BUTTON (hDlg, BN_CLICKED,
|
||
GetDlgItem (hDlg, IDC_USE_LOCAL_MACHINE));
|
||
bReturn = TRUE;
|
||
}
|
||
// restore cursor
|
||
SetCursor (hOldCursor);
|
||
|
||
// return status of function
|
||
return bReturn;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadMachineObjects (
|
||
IN HWND hDlg,
|
||
IN BOOL bRefresh
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
For the currently selected machine, load the object list box
|
||
with the objects supported by that machine. If the bRefresh
|
||
flag is TRUE, then query the system for the current perf data
|
||
before loading the list box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window handle of parent dialog box
|
||
|
||
IN BOOL bRefresh
|
||
TRUE = Query performance data of system before updating
|
||
FALSE = Use the current system perf data to load the objects from
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful,
|
||
FALSE if not
|
||
|
||
--*/
|
||
{
|
||
// big stack variables
|
||
WCHAR szMachineName[MAX_PATH];
|
||
WCHAR szDefaultObject[MAX_PATH];
|
||
LPWSTR mszObjectList = NULL;
|
||
|
||
// regular stack variables
|
||
DWORD dwObjectListLength = OBJECT_LIST_SIZE;
|
||
DWORD dwLength;
|
||
LPWSTR szThisObject;
|
||
HCURSOR hOldCursor;
|
||
HWND hObjectListWnd;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
PDH_STATUS pdhStatus;
|
||
DWORD dwReturn;
|
||
DWORD dwDetailLevel;
|
||
LPWSTR szMsg;
|
||
LRESULT nEntry;
|
||
DWORD dwFlags;
|
||
|
||
// get the pointer to the dialog's user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
mszObjectList = G_ALLOC (dwObjectListLength * sizeof(WCHAR));
|
||
if (mszObjectList == NULL) {
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
// save old cursor and display wait cursor
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
if (!pData->bShowObjects) {
|
||
// get window handle to combo box control
|
||
hObjectListWnd = GetDlgItem (hDlg, IDC_OBJECT_COMBO);
|
||
} else {
|
||
hObjectListWnd = GetDlgItem (hDlg, IDC_OBJECT_LIST);
|
||
}
|
||
// get current machine name
|
||
GetDlgItemTextW (hDlg, IDC_MACHINE_COMBO, szMachineName, MAX_PATH);
|
||
if (lstrcmpW(szMachineName, pData->szLastMachineName) != 0) {
|
||
|
||
#ifdef _DEBUG
|
||
// to catch any snafus during debugging & development
|
||
MessageBoxW(hDlg, cszNameDontMatch,
|
||
cszNotice, MB_OK);
|
||
#endif
|
||
lstrcpyW (pData->szLastMachineName, szMachineName);
|
||
}
|
||
|
||
if (!pData->bShowObjects) {
|
||
// first clear out any old contents
|
||
SendMessageW (hObjectListWnd, CB_RESETCONTENT, 0, 0);
|
||
} else {
|
||
SendMessageW (hObjectListWnd, LB_RESETCONTENT, 0, 0);
|
||
}
|
||
|
||
// get object list from the PDH
|
||
dwDetailLevel = pData->dwCurrentDetailLevel;
|
||
dwDetailLevel |= pData->bIncludeCostlyObjects ? PERF_DETAIL_COSTLY : 0;
|
||
dwLength = dwObjectListLength;
|
||
|
||
pdhStatus = PdhEnumObjectsHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName, mszObjectList, &dwLength,
|
||
dwDetailLevel, bRefresh);
|
||
while ( pdhStatus == PDH_MORE_DATA
|
||
|| pdhStatus == PDH_INSUFFICIENT_BUFFER) {
|
||
// then realloc and try again, but only once
|
||
G_FREE (mszObjectList);
|
||
dwObjectListLength = dwLength;
|
||
mszObjectList = G_ALLOC (dwObjectListLength * sizeof(WCHAR));
|
||
if (mszObjectList == NULL) {
|
||
pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
|
||
} else {
|
||
pdhStatus = PdhEnumObjectsHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName, mszObjectList, &dwLength,
|
||
dwDetailLevel, bRefresh);
|
||
}
|
||
}
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
EnableWindow (hObjectListWnd, TRUE);
|
||
// load object list to the list (combo) box
|
||
for (szThisObject = &mszObjectList[0];
|
||
*szThisObject != 0;
|
||
szThisObject += lstrlenW(szThisObject) + 1) {
|
||
if (pData->bShowObjects) {
|
||
DWORD dwCounterListLength = 0;
|
||
DWORD dwInstanceListLength = 0;
|
||
pdhStatus = PdhEnumObjectItemsHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szThisObject,
|
||
NULL,
|
||
& dwCounterListLength,
|
||
NULL,
|
||
& dwInstanceListLength,
|
||
PERF_DETAIL_WIZARD,
|
||
0);
|
||
if ( pdhStatus != ERROR_SUCCESS
|
||
&& pdhStatus != PDH_MORE_DATA
|
||
&& pdhStatus != PDH_INSUFFICIENT_BUFFER) {
|
||
dwInstanceListLength = 0;
|
||
}
|
||
if (dwInstanceListLength == 0 || dwInstanceListLength > 2) {
|
||
// send to list box control
|
||
nEntry = SendMessageW(hObjectListWnd, LB_ADDSTRING, 0,
|
||
(LPARAM) szThisObject);
|
||
dwFlags = 0;
|
||
if (dwInstanceListLength > 2) {
|
||
dwFlags |= PDH_OBJECT_HAS_INSTANCES;
|
||
}
|
||
SendMessageW(hObjectListWnd,
|
||
LB_SETITEMDATA,
|
||
(WPARAM) nEntry,
|
||
(LPARAM) dwFlags);
|
||
}
|
||
pdhStatus = ERROR_SUCCESS;
|
||
} else {
|
||
// send to combo box
|
||
// add each string...
|
||
SendMessageW(hObjectListWnd, CB_ADDSTRING, 0,
|
||
(LPARAM)szThisObject);
|
||
}
|
||
}
|
||
|
||
if (!pData->bShowObjects) {
|
||
// get default Object
|
||
dwLength = MAX_PATH;
|
||
pdhStatus = PdhGetDefaultPerfObjectHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szDefaultObject,
|
||
&dwLength);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
// and select it if it's present (which it should be)
|
||
dwReturn = (DWORD)SendMessageW (hObjectListWnd, CB_SELECTSTRING,
|
||
(WPARAM)-1, (LPARAM)szDefaultObject);
|
||
if (dwReturn == CB_ERR) pdhStatus = PDH_CSTATUS_NO_OBJECT;
|
||
}
|
||
if (pdhStatus != ERROR_SUCCESS) {
|
||
// default object not found in list so select the first one
|
||
SendMessageW (hObjectListWnd, CB_SETCURSEL, 0, 0);
|
||
}
|
||
}
|
||
} else {
|
||
// unable to obtain object list so display message and disable list
|
||
szMsg = GetStringResource (IDS_BRWS_NO_OBJECTS);
|
||
if (szMsg != NULL) {
|
||
if (!pData->bShowObjects) {
|
||
SendMessageW (hObjectListWnd, CB_ADDSTRING, 0, (LPARAM)szMsg);
|
||
} else {
|
||
SendMessageW (hObjectListWnd, LB_ADDSTRING, 0, (LPARAM)szMsg);
|
||
}
|
||
G_FREE (szMsg);
|
||
EnableWindow (hObjectListWnd, FALSE);
|
||
}
|
||
}
|
||
|
||
// restore cursor
|
||
SetCursor (hOldCursor);
|
||
|
||
if (mszObjectList != NULL) G_FREE (mszObjectList);
|
||
// return status
|
||
return (pdhStatus == ERROR_SUCCESS) ? (TRUE) : (FALSE);
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiLoadCountersAndInstances (
|
||
IN HWND hDlg
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Load the counters and instances of the selected object on the
|
||
current machine
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window handle of the dialog box containing these controls
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful,
|
||
FALSE if not
|
||
|
||
--*/
|
||
{
|
||
// big Stack variables
|
||
WCHAR szMachineName[MAX_PATH];
|
||
WCHAR szObjectName[MAX_PATH];
|
||
WCHAR szDefaultCounter[MAX_PATH];
|
||
WCHAR szInstanceString[MAX_PATH];
|
||
|
||
// regular Stack variables
|
||
LPWSTR szIndexStringPos;
|
||
DWORD dwCounterLen;
|
||
DWORD dwDefaultIndex;
|
||
DWORD dwCounterListLength;
|
||
DWORD dwInstanceListLength;
|
||
DWORD dwInstanceMatch;
|
||
DWORD dwInstanceIndex;
|
||
DWORD dwInstanceCount;
|
||
LPWSTR szThisItem;
|
||
HWND hWndCounterListBox;
|
||
HWND hWndInstanceListBox;
|
||
HCURSOR hOldCursor;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
PDH_STATUS pdhStatus;
|
||
LPWSTR mszCounterList = NULL;
|
||
LPWSTR mszInstanceList = NULL;
|
||
LPWSTR mszTmpList;
|
||
LPWSTR szMsg;
|
||
HDC hDcListBox;
|
||
SIZE Size;
|
||
LONG dwHorizExtent;
|
||
|
||
// get the pointer to the dialog's user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
hWndCounterListBox = GetDlgItem (hDlg, IDC_COUNTER_LIST);
|
||
hWndInstanceListBox = GetDlgItem (hDlg, IDC_INSTANCE_LIST);
|
||
if (hWndCounterListBox == NULL || hWndInstanceListBox == NULL) {
|
||
SetLastError(PDH_INVALID_HANDLE);
|
||
return FALSE;
|
||
}
|
||
|
||
// save current cursor and display wait cursor
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
// get current machine & object name
|
||
GetDlgItemTextW(hDlg, IDC_MACHINE_COMBO, szMachineName, MAX_PATH);
|
||
GetDlgItemTextW(hDlg, IDC_OBJECT_COMBO, szObjectName, MAX_PATH);
|
||
#ifdef _DEBUG
|
||
if (lstrcmpW(szMachineName, pData->szLastMachineName) != 0) {
|
||
MessageBoxW(hDlg, cszNameDontMatch,
|
||
cszNotice, MB_OK);
|
||
}
|
||
#endif
|
||
|
||
// get object list
|
||
|
||
mszCounterList = G_ALLOC (dwCounterListSize * sizeof(WCHAR));
|
||
if (mszCounterList != NULL) {
|
||
dwCounterListLength = dwCounterListSize;
|
||
} else {
|
||
return FALSE;
|
||
}
|
||
|
||
mszInstanceList = G_ALLOC (dwInstanceListSize * sizeof(WCHAR));
|
||
if (mszInstanceList != NULL) {
|
||
dwInstanceListLength = dwInstanceListSize;
|
||
} else {
|
||
G_FREE (mszCounterList);
|
||
return FALSE;
|
||
}
|
||
|
||
pdhStatus = PdhEnumObjectItemsHW(pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szObjectName,
|
||
mszCounterList,
|
||
& dwCounterListLength,
|
||
mszInstanceList,
|
||
& dwInstanceListLength,
|
||
pData->dwCurrentDetailLevel,
|
||
0);
|
||
while ( pdhStatus == PDH_MORE_DATA
|
||
|| pdhStatus == PDH_INSUFFICIENT_BUFFER) {
|
||
|
||
// enlarge the buffer if necessary
|
||
if (dwCounterListLength > dwCounterListSize) {
|
||
mszTmpList = mszCounterList;
|
||
mszCounterList = G_REALLOC (mszCounterList, (dwCounterListLength * sizeof(WCHAR)));
|
||
if (mszCounterList != NULL) {
|
||
dwCounterListSize = dwCounterListLength;
|
||
} else {
|
||
G_FREE (mszTmpList);
|
||
G_FREE (mszInstanceList);
|
||
return FALSE;
|
||
}
|
||
} else {
|
||
// reset the buffer size values
|
||
dwCounterListLength = dwCounterListSize;
|
||
}
|
||
|
||
|
||
if (dwInstanceListLength > dwInstanceListSize) {
|
||
mszTmpList = mszInstanceList;
|
||
mszInstanceList = G_REALLOC (mszInstanceList, (dwInstanceListLength * sizeof(WCHAR)));
|
||
if (mszInstanceList != NULL) {
|
||
dwInstanceListSize = dwInstanceListLength;
|
||
} else {
|
||
G_FREE (mszTmpList);
|
||
G_FREE (mszCounterList);
|
||
return FALSE;
|
||
}
|
||
} else {
|
||
// reset the buffer size values
|
||
dwInstanceListLength = dwInstanceListSize;
|
||
}
|
||
|
||
// retry the call
|
||
pdhStatus = PdhEnumObjectItemsHW(pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szObjectName,
|
||
mszCounterList,
|
||
& dwCounterListLength,
|
||
mszInstanceList,
|
||
& dwInstanceListLength,
|
||
pData->dwCurrentDetailLevel,
|
||
0);
|
||
}
|
||
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
//reset contents of both list boxes
|
||
|
||
SendMessageW (hWndCounterListBox, LB_RESETCONTENT, 0, 0);
|
||
SendMessageW (hWndInstanceListBox, LB_RESETCONTENT, 0, 0);
|
||
|
||
// enable both list boxes
|
||
|
||
EnableWindow (hWndInstanceListBox, TRUE);
|
||
EnableWindow (hWndCounterListBox, TRUE);
|
||
|
||
// now fill 'em up
|
||
// start with the counters
|
||
hDcListBox = GetDC(hWndCounterListBox);
|
||
if (hDcListBox == NULL)
|
||
return FALSE;
|
||
|
||
dwHorizExtent = 0;
|
||
|
||
for (szThisItem = mszCounterList;
|
||
*szThisItem != 0;
|
||
szThisItem += lstrlenW(szThisItem) + 1) {
|
||
|
||
if (GetTextExtentPoint32W(hDcListBox, szThisItem,
|
||
lstrlenW(szThisItem), &Size)) {
|
||
if (Size.cx > dwHorizExtent) {
|
||
dwHorizExtent = Size.cx;
|
||
SendMessageW (hWndCounterListBox,
|
||
LB_SETHORIZONTALEXTENT, (WPARAM)dwHorizExtent, 0);
|
||
}
|
||
}
|
||
SendMessageW (hWndCounterListBox, LB_ADDSTRING,
|
||
0, (LPARAM)szThisItem);
|
||
}
|
||
|
||
ReleaseDC (hWndCounterListBox, hDcListBox);
|
||
|
||
// once the list box has been loaded see if we want to keep it
|
||
// enabled. It's filled regardless just so the user can see some
|
||
// of the entries, even if they have this disabled by the "all"
|
||
// counter button
|
||
|
||
if (pData->bSelectAllCounters) {
|
||
// disable instance list
|
||
EnableWindow(hWndCounterListBox, FALSE);
|
||
} else {
|
||
// set the default selection if there are entries in the
|
||
// list box and use the correct message depending on the
|
||
// selection options
|
||
// set the default counter
|
||
dwCounterLen = MAX_PATH;
|
||
pdhStatus = PdhGetDefaultPerfCounterHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szObjectName,
|
||
szDefaultCounter,
|
||
&dwCounterLen);
|
||
|
||
if (pdhStatus != ERROR_SUCCESS) {
|
||
dwDefaultIndex = 0;
|
||
} else {
|
||
dwDefaultIndex = (DWORD)SendMessageW (hWndCounterListBox,
|
||
LB_FINDSTRINGEXACT,
|
||
(WPARAM)-1, (LPARAM)szDefaultCounter);
|
||
if (dwDefaultIndex == LB_ERR) dwDefaultIndex = 0;
|
||
}
|
||
|
||
if (pData->bSelectMultipleCounters) {
|
||
SendMessageW (hWndCounterListBox, LB_SETSEL, TRUE, dwDefaultIndex);
|
||
SendMessageW (hWndCounterListBox, LB_SETCARETINDEX,
|
||
(WPARAM)dwDefaultIndex, MAKELPARAM(FALSE, 0));
|
||
} else {
|
||
SendMessageW (hWndCounterListBox, LB_SETCURSEL, dwDefaultIndex, 0);
|
||
}
|
||
}
|
||
// now the instance list
|
||
if (dwInstanceListLength > 0) {
|
||
// there's at least one entry, so prepare the list box
|
||
// enable the list box and the instance radio buttons on the
|
||
// assumption that they will be used. this is tested later.
|
||
EnableWindow (hWndInstanceListBox, TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_INSTANCE_CAPTION), TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_ALL_INSTANCES), TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_USE_INSTANCE_LIST), TRUE);
|
||
|
||
dwInstanceCount = 0;
|
||
|
||
// load instance entries
|
||
hDcListBox = GetDC(hWndInstanceListBox);
|
||
if (hDcListBox == NULL)
|
||
return FALSE;
|
||
dwHorizExtent = 0;
|
||
for (szThisItem = mszInstanceList;
|
||
*szThisItem != 0;
|
||
szThisItem += lstrlenW(szThisItem) + 1) {
|
||
// see if the index number should be displayed
|
||
if (pData->bShowIndex) {
|
||
// if so, it must be derived,
|
||
// this is accomplished by making an index entry starting
|
||
// at 1, and looking for a match in the current entries.
|
||
// if a match is found, then the index is incremented and
|
||
// the process is repeated until the specified
|
||
// instance is not found. The first value not found is
|
||
// then the index entry for that item.
|
||
//
|
||
// first see if there's an undecorated one in the list box
|
||
// if not then add this one
|
||
lstrcpyW (szInstanceString, szThisItem);
|
||
dwInstanceMatch = (DWORD)-1;
|
||
dwInstanceMatch = (DWORD)SendMessageW (
|
||
hWndInstanceListBox, LB_FINDSTRINGEXACT,
|
||
(WPARAM)dwInstanceMatch, (LPARAM)szInstanceString);
|
||
if (dwInstanceMatch == LB_ERR) {
|
||
// then this is the first one so add it in the
|
||
// undecorated form
|
||
if (GetTextExtentPoint32W(hDcListBox, szInstanceString,
|
||
lstrlenW(szThisItem), &Size)) {
|
||
if (Size.cx > dwHorizExtent) {
|
||
dwHorizExtent = Size.cx;
|
||
SendMessageW (hWndInstanceListBox,
|
||
LB_SETHORIZONTALEXTENT, (WPARAM)dwHorizExtent, 0);
|
||
}
|
||
}
|
||
SendMessageW (hWndInstanceListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szInstanceString);
|
||
} else {
|
||
// there's already a plain one, so increment through
|
||
// the index values and find one that's not in the
|
||
// list already
|
||
|
||
dwInstanceIndex = 1;
|
||
dwInstanceMatch = (DWORD)-1;
|
||
|
||
// find the index of this instance
|
||
lstrcpyW (szInstanceString, szThisItem);
|
||
lstrcatW (szInstanceString, cszPoundSign);
|
||
szIndexStringPos = &szInstanceString[lstrlenW(szInstanceString)];
|
||
do {
|
||
_ltow ((long)dwInstanceIndex++, szIndexStringPos, 10);
|
||
dwInstanceMatch = (DWORD)SendMessageW (
|
||
hWndInstanceListBox, LB_FINDSTRINGEXACT,
|
||
(WPARAM)dwInstanceMatch, (LPARAM)szInstanceString);
|
||
} while (dwInstanceMatch != LB_ERR);
|
||
// add the last entry checked (the first one not found)
|
||
// to the list box now.
|
||
if (GetTextExtentPoint32W(hDcListBox, szInstanceString,
|
||
lstrlenW(szThisItem), &Size)) {
|
||
if (Size.cx > dwHorizExtent) {
|
||
dwHorizExtent = Size.cx;
|
||
SendMessageW (hWndInstanceListBox,
|
||
LB_SETHORIZONTALEXTENT, (WPARAM)dwHorizExtent, 0);
|
||
}
|
||
}
|
||
SendMessageW (hWndInstanceListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szInstanceString);
|
||
}
|
||
} else {
|
||
// index values are not required so just add the string
|
||
// to the list box
|
||
if (GetTextExtentPoint32W(hDcListBox, szInstanceString,
|
||
lstrlenW(szThisItem), &Size)) {
|
||
if (Size.cx > dwHorizExtent) {
|
||
dwHorizExtent = Size.cx;
|
||
SendMessageW (hWndInstanceListBox,
|
||
LB_SETHORIZONTALEXTENT, (WPARAM)dwHorizExtent, 0);
|
||
}
|
||
}
|
||
SendMessageW (hWndInstanceListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szThisItem);
|
||
}
|
||
dwInstanceCount++;
|
||
}
|
||
|
||
ReleaseDC (hWndInstanceListBox, hDcListBox);
|
||
|
||
if (dwInstanceCount == 0) {
|
||
// disable the OK/Add button, since this object has no
|
||
// current instances to monitor
|
||
EnableWindow (GetDlgItem(hDlg, IDOK), FALSE);
|
||
szMsg = GetStringResource (IDS_BRWS_NO_INSTANCES);
|
||
if (szMsg != NULL) {
|
||
SendMessageW (hWndInstanceListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
EnableWindow (GetDlgItem (hDlg, IDC_INSTANCE_CAPTION), FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_ALL_INSTANCES), FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_USE_INSTANCE_LIST), FALSE);
|
||
EnableWindow (hWndInstanceListBox, FALSE);
|
||
} else {
|
||
// enable the OK/Add button since there is some monitorable
|
||
// instance(s)
|
||
EnableWindow (GetDlgItem(hDlg, IDOK), TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_INSTANCE_CAPTION), TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_ALL_INSTANCES), TRUE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_USE_INSTANCE_LIST), TRUE);
|
||
EnableWindow (hWndInstanceListBox, TRUE);
|
||
}
|
||
// once the list box has been loaded see if we want to keep it
|
||
// enabled. It's filled regardless just so the user can see some
|
||
// of the entries, even if they have this disabled by the "all"
|
||
// instance button
|
||
|
||
if (pData->bSelectAllInstances) {
|
||
// disable instance list
|
||
EnableWindow(hWndInstanceListBox, FALSE);
|
||
} else {
|
||
// set the default selection if there are entries in the
|
||
// list box and use the correct message depending on the
|
||
// selection options
|
||
if ((dwInstanceCount > 0) &&
|
||
(SendMessageW (hWndInstanceListBox, LB_GETCOUNT, 0, 0) !=
|
||
LB_ERR)) {
|
||
if (pData->bSelectMultipleCounters) {
|
||
SendMessageW (hWndInstanceListBox, LB_SETSEL, TRUE, 0);
|
||
} else {
|
||
SendMessageW (hWndInstanceListBox, LB_SETCURSEL, 0, 0);
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// there are no instances of this counter so display the
|
||
// string and disable the buttons and the list box
|
||
EnableWindow (hWndInstanceListBox, FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_INSTANCE_CAPTION), FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_ALL_INSTANCES), FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_USE_INSTANCE_LIST), FALSE);
|
||
EnableWindow (GetDlgItem(hDlg, IDOK), TRUE);
|
||
}
|
||
} else {
|
||
// unable to retrieve the counters and instances so
|
||
// clear and then...
|
||
SendMessageW (hWndCounterListBox, LB_RESETCONTENT, 0, 0);
|
||
SendMessageW (hWndInstanceListBox, LB_RESETCONTENT, 0, 0);
|
||
// disable the windows
|
||
szMsg = GetStringResource (IDS_BRWS_NO_INSTANCES);
|
||
if (szMsg != NULL) {
|
||
SendMessageW (hWndInstanceListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
szMsg = GetStringResource (IDS_BRWS_NO_COUNTERS);
|
||
if (szMsg != NULL) {
|
||
SendMessageW (hWndCounterListBox, LB_ADDSTRING, 0,
|
||
(LPARAM)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
EnableWindow (hWndInstanceListBox, FALSE);
|
||
EnableWindow (hWndCounterListBox, FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_ALL_INSTANCES), FALSE);
|
||
EnableWindow (GetDlgItem (hDlg, IDC_USE_INSTANCE_LIST), FALSE);
|
||
EnableWindow (GetDlgItem(hDlg, IDOK), FALSE);
|
||
}
|
||
|
||
if (mszCounterList != NULL) G_FREE(mszCounterList);
|
||
if (mszInstanceList != NULL) G_FREE(mszInstanceList);
|
||
|
||
// restore the cursor to it's original shape
|
||
SetCursor (hOldCursor);
|
||
|
||
// return status
|
||
return TRUE;
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsT (
|
||
IN HWND hDlg,
|
||
IN LPVOID pUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength,
|
||
IN BOOL bUnicode
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Scans the selected objects, counter, instances and builds a multi-SZ
|
||
string containing the expanded path of all the selections, unless
|
||
the wild card syntax is specified.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle of Dialog containing the controls
|
||
|
||
IN LPVOID pUsersPathBuffer
|
||
pointer to the caller's buffer that will receive the MSZ string
|
||
|
||
IN DWORD cchUsersPathLength
|
||
size of caller's buffer in characters
|
||
|
||
IN BOOL bUnicode
|
||
size of characters to return: TRUE = WCHAR, FALSE = CHAR
|
||
|
||
Return Value:
|
||
|
||
WIN32 Status of function completion
|
||
ERROR_SUCCESS if successful
|
||
|
||
|
||
--*/
|
||
{
|
||
// big Stack Variables
|
||
|
||
static WCHAR lszMachineName[MAX_PATH];
|
||
static WCHAR lszObjectName[MAX_PATH];
|
||
static WCHAR lszInstanceName[SMALL_BUFFER_SIZE];
|
||
static WCHAR lszCounterName[SMALL_BUFFER_SIZE];
|
||
static WCHAR szWorkBuffer[SMALL_BUFFER_SIZE];
|
||
|
||
// regular Stack Variables
|
||
LRESULT iNumEntries;
|
||
int iThisEntry;
|
||
LRESULT iCurSelState;
|
||
LRESULT iTextLen;
|
||
|
||
LRESULT dwObjectFlags;
|
||
|
||
DWORD dwBufferRemaining;
|
||
|
||
DWORD dwSize1;
|
||
|
||
PDH_COUNTER_PATH_ELEMENTS_W lszPath;
|
||
LPVOID szCounterStart;
|
||
|
||
PDH_STATUS pdhStatus = ERROR_SUCCESS;
|
||
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
// get pointer to dialog user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return PDH_NO_DIALOG_DATA;
|
||
}
|
||
|
||
// clear user's string
|
||
if (pUsersPathBuffer != NULL) {
|
||
// clear first four bytes of string
|
||
*((LPDWORD)pUsersPathBuffer) = 0;
|
||
dwBufferRemaining = cchUsersPathLength;
|
||
szCounterStart = pUsersPathBuffer;
|
||
} else {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_INVALID_BUFFER);
|
||
#endif
|
||
return PDH_INVALID_BUFFER; // no point in continuing if the caller doesn't have a buffer
|
||
}
|
||
|
||
// each counter path string is built by setting the elements of
|
||
// the counter data structure and then calling the MakeCounterPath
|
||
// function to build the string
|
||
|
||
// build base string using selected machine & objects from list
|
||
|
||
if (pData->bIncludeMachineInPath) {
|
||
lszPath.szMachineName = &lszMachineName[0];
|
||
memset (lszMachineName, 0, sizeof(lszMachineName));
|
||
GetDlgItemTextW (hDlg, IDC_MACHINE_COMBO, lszMachineName, MAX_PATH);
|
||
} else {
|
||
lszPath.szMachineName = NULL;
|
||
}
|
||
|
||
// Get number of objects currently listed in the list box
|
||
|
||
iNumEntries = SendMessageW(GetDlgItem(hDlg, IDC_OBJECT_LIST), LB_GETCOUNT, 0, 0);
|
||
if (iNumEntries != LB_ERR) {
|
||
// check each one and add selected ones to the list
|
||
lszInstanceName[0] = SPLAT_L;
|
||
lszInstanceName[1] = 0;
|
||
|
||
lszCounterName[0] = SPLAT_L;
|
||
lszCounterName[1] = 0;
|
||
|
||
lszPath.szCounterName = lszCounterName; // wildcard counter entry
|
||
lszPath.szParentInstance = NULL; // no parent instances
|
||
lszPath.dwInstanceIndex = ((DWORD)-1); // no index numbers
|
||
|
||
for (iThisEntry = 0; iThisEntry < iNumEntries; iThisEntry++) {
|
||
iCurSelState = SendMessageW(GetDlgItem(hDlg, IDC_OBJECT_LIST),
|
||
LB_GETSEL, (WPARAM)iThisEntry, 0);
|
||
if (iCurSelState > 0) {
|
||
// then get the string and add it to the list
|
||
iTextLen = SendMessageW(GetDlgItem(hDlg, IDC_OBJECT_LIST),
|
||
LB_GETTEXTLEN, iThisEntry, 0);
|
||
if ((iTextLen < MAX_PATH) && (iTextLen != LB_ERR)) {
|
||
// the string and it's null will fit so fetch it
|
||
iTextLen = SendMessageW(GetDlgItem(hDlg, IDC_OBJECT_LIST),
|
||
LB_GETTEXT, iThisEntry, (LPARAM)lszObjectName);
|
||
dwObjectFlags = SendMessage (GetDlgItem(hDlg, IDC_OBJECT_LIST),
|
||
LB_GETITEMDATA, (WPARAM)iThisEntry, 0);
|
||
if (iTextLen != LB_ERR) {
|
||
// build path elements
|
||
lszPath.szObjectName = lszObjectName;
|
||
if (dwObjectFlags & PDH_OBJECT_HAS_INSTANCES) {
|
||
lszPath.szInstanceName = lszInstanceName;
|
||
} else {
|
||
lszPath.szInstanceName = NULL;
|
||
}
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
& dwSize1,
|
||
0);
|
||
}
|
||
else {
|
||
pdhStatus = PDH_INVALID_ARGUMENT;
|
||
}
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
// add the string if there's room
|
||
pdhStatus = PdhiCopyString(& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
}
|
||
} else {
|
||
// unable to read the string (to big or List Box error)
|
||
}
|
||
} // else, item isn't selected so skip
|
||
|
||
} // end for each item in the list box
|
||
|
||
if (bUnicode) {
|
||
*((LPWSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
} else {
|
||
*((LPSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
}
|
||
} else {
|
||
// no items in the list
|
||
}
|
||
|
||
return pdhStatus;
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsW (
|
||
IN HWND hDlg,
|
||
IN LPWSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
)
|
||
{
|
||
return PdhiCompileSelectedObjectsT (
|
||
hDlg,
|
||
(LPVOID)szUsersPathBuffer,
|
||
cchUsersPathLength,
|
||
TRUE);
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedObjectsA (
|
||
IN HWND hDlg,
|
||
IN LPSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
)
|
||
{
|
||
return PdhiCompileSelectedObjectsT (
|
||
hDlg,
|
||
(LPVOID)szUsersPathBuffer,
|
||
cchUsersPathLength,
|
||
FALSE);
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersT (
|
||
IN HWND hDlg,
|
||
IN LPVOID pUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength,
|
||
IN BOOL bUnicode
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Scans the selected objects, counter, instances and builds a multi-SZ
|
||
string containing the expanded path of all the selections, unless
|
||
the wild card syntax is specified.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle of Dialog containing the controls
|
||
|
||
IN LPVOID pUsersPathBuffer
|
||
pointer to the caller's buffer that will receive the MSZ string
|
||
|
||
IN DWORD cchUsersPathLength
|
||
size of caller's buffer in characters
|
||
|
||
IN BOOL bUnicode
|
||
size of characters to return: TRUE = WCHAR, FALSE = CHAR
|
||
|
||
Return Value:
|
||
|
||
WIN32 Status of function completion
|
||
ERROR_SUCCESS if successful
|
||
|
||
|
||
--*/
|
||
{
|
||
// big Stack Variables
|
||
|
||
static WCHAR lszMachineName[MAX_PATH];
|
||
static WCHAR lszObjectName[MAX_PATH];
|
||
static WCHAR lszInstanceName[SMALL_BUFFER_SIZE];
|
||
static WCHAR lszParentInstance[SMALL_BUFFER_SIZE];
|
||
static WCHAR lszCounterName[SMALL_BUFFER_SIZE];
|
||
static WCHAR szWorkBuffer[SMALL_BUFFER_SIZE];
|
||
|
||
// regular Stack Variables
|
||
DWORD dwBufferRemaining;
|
||
|
||
DWORD dwCountCounters;
|
||
DWORD dwThisCounter;
|
||
DWORD dwCountInstances;
|
||
DWORD dwThisInstance;
|
||
|
||
DWORD dwSize1, dwSize2;
|
||
|
||
PDH_COUNTER_PATH_ELEMENTS_W lszPath;
|
||
LPVOID szCounterStart;
|
||
|
||
HWND hWndCounterList;
|
||
HWND hWndInstanceList;
|
||
|
||
BOOL bSel;
|
||
|
||
PDH_STATUS pdhStatus = ERROR_SUCCESS;
|
||
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
// get pointer to dialog user data
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return PDH_NO_DIALOG_DATA;
|
||
}
|
||
|
||
// clear user's string
|
||
if (pUsersPathBuffer != NULL) {
|
||
// clear first four bytes of string
|
||
*((LPDWORD)pUsersPathBuffer) = 0;
|
||
dwBufferRemaining = cchUsersPathLength;
|
||
szCounterStart = pUsersPathBuffer;
|
||
} else {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_INVALID_BUFFER);
|
||
#endif
|
||
return PDH_INVALID_BUFFER; // no point in continuing if the caller doesn't have a buffer
|
||
}
|
||
|
||
// each counter path string is built by setting the elements of
|
||
// the counter data structure and then calling the MakeCounterPath
|
||
// function to build the string
|
||
|
||
// build base string using selected machine and object
|
||
|
||
if (pData->bIncludeMachineInPath) {
|
||
lszPath.szMachineName = &lszMachineName[0];
|
||
memset (lszMachineName, 0, sizeof(lszMachineName));
|
||
GetDlgItemTextW (hDlg, IDC_MACHINE_COMBO, lszMachineName, MAX_PATH);
|
||
} else {
|
||
lszPath.szMachineName = NULL;
|
||
}
|
||
|
||
lszPath.szObjectName = &lszObjectName[0];
|
||
memset (lszObjectName, 0, sizeof(lszObjectName));
|
||
GetDlgItemTextW (hDlg, IDC_OBJECT_COMBO, lszObjectName, MAX_PATH);
|
||
|
||
hWndCounterList = GetDlgItem (hDlg, IDC_COUNTER_LIST);
|
||
hWndInstanceList = GetDlgItem (hDlg, IDC_INSTANCE_LIST);
|
||
|
||
if (pData->bSelectMultipleCounters) {
|
||
if (pData->bWildCardInstances && pData->bSelectAllInstances) {
|
||
if (IsWindowEnabled(GetDlgItem (hDlg, IDC_ALL_INSTANCES))) {
|
||
// then this object has instances and we want ALL of them
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
memset (lszInstanceName, 0, sizeof(lszInstanceName));
|
||
lstrcpyW (lszInstanceName, cszSplat);
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
} else {
|
||
// this object has no instances
|
||
lszPath.szInstanceName = NULL;
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
}
|
||
// make a counter path for each selected counter
|
||
dwCountCounters = (DWORD)SendMessageW (hWndCounterList, LB_GETCOUNT, 0, 0);
|
||
if (pData->bSelectAllCounters) {
|
||
lszPath.szCounterName = &lszCounterName[0];
|
||
lstrcpyW (lszPath.szCounterName, cszSplat);
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
// add the string if there's room
|
||
pdhStatus = PdhiCopyString(& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
}
|
||
} else {
|
||
for (dwThisCounter = 0; dwThisCounter < dwCountCounters; dwThisCounter++) {
|
||
if (SendMessageW (hWndCounterList, LB_GETSEL, (WPARAM)dwThisCounter, 0)) {
|
||
lszPath.szCounterName = &lszCounterName[0];
|
||
memset (lszCounterName, 0, sizeof(lszCounterName));
|
||
SendMessageW (hWndCounterList, LB_GETTEXT,
|
||
(WPARAM)dwThisCounter, (LPARAM)lszCounterName);
|
||
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
// add the string if there's room
|
||
pdhStatus = PdhiCopyString(
|
||
& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
} else {
|
||
// skip this counter since it could not be formed correctly
|
||
continue;
|
||
}
|
||
} // end if this counter was selected
|
||
} // end for each counter in object list box
|
||
}
|
||
} else {
|
||
// get selected instances from list
|
||
dwCountCounters = (DWORD)SendMessageW (hWndCounterList, LB_GETCOUNT, 0, 0);
|
||
for (dwThisCounter = 0; dwThisCounter < dwCountCounters; dwThisCounter++) {
|
||
bSel = (BOOL) SendMessageW (hWndCounterList, LB_GETSEL, (WPARAM)dwThisCounter, 0);
|
||
if (bSel || pData->bSelectAllCounters ) {
|
||
lszPath.szCounterName = &lszCounterName[0];
|
||
memset (lszCounterName, 0, sizeof(lszCounterName));
|
||
SendMessageW (hWndCounterList, LB_GETTEXT,
|
||
(WPARAM)dwThisCounter, (LPARAM)lszCounterName);
|
||
|
||
if (IsWindowEnabled(hWndInstanceList) || pData->bSelectAllInstances) {
|
||
dwCountInstances = (DWORD)SendMessageW (hWndInstanceList,
|
||
LB_GETCOUNT, 0, 0);
|
||
for (dwThisInstance = 0; dwThisInstance < dwCountInstances; dwThisInstance++) {
|
||
if (SendMessageW (hWndInstanceList, LB_GETSEL,
|
||
(WPARAM)dwThisInstance, 0) || pData->bSelectAllInstances) {
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
memset (lszInstanceName, 0, sizeof(lszInstanceName));
|
||
SendMessageW (hWndInstanceList, LB_GETTEXT,
|
||
(WPARAM)dwThisInstance, (LPARAM)lszInstanceName);
|
||
|
||
lszPath.szParentInstance = &lszParentInstance[0];
|
||
memset (lszParentInstance, 0, sizeof(lszParentInstance));
|
||
|
||
dwSize1 = dwSize2 = MAX_PATH;
|
||
pdhStatus = PdhParseInstanceNameW (lszInstanceName,
|
||
lszInstanceName,
|
||
&dwSize1,
|
||
lszParentInstance,
|
||
&dwSize2,
|
||
&lszPath.dwInstanceIndex);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
// parse instance name adds in the default index if one is
|
||
// not present. so if it's not wanted, this will remove it
|
||
if (!pData->bShowIndex) {
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
} else {
|
||
// only add in the instance # if it's not 0
|
||
if (lszPath.dwInstanceIndex == 0) {
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
}
|
||
}
|
||
|
||
if (dwSize1 > 1) {
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
} else {
|
||
lszPath.szInstanceName = NULL;
|
||
}
|
||
if (dwSize2 > 1) {
|
||
lszPath.szParentInstance = &lszParentInstance[0];
|
||
} else {
|
||
lszPath.szParentInstance = NULL;
|
||
}
|
||
} else {
|
||
// ignore the instances
|
||
lszPath.szInstanceName = NULL;
|
||
lszPath.szParentInstance = NULL;
|
||
}
|
||
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
pdhStatus = PdhiCopyString(
|
||
& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
} else {
|
||
// unable to make counter path so skip
|
||
}
|
||
} // end if instance is selected
|
||
} // end for each instance in list
|
||
} else {
|
||
// this counter has no instances so process now
|
||
lszPath.szInstanceName = NULL;
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
pdhStatus = PdhiCopyString(
|
||
& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
} else {
|
||
// unable to create a path so skip and continue
|
||
}
|
||
} // end if counter has instances
|
||
} // else counter is not selected
|
||
} // end for each counter in list
|
||
} // end if not wild card instances
|
||
if (bUnicode) {
|
||
*((LPWSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
} else {
|
||
*((LPSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
}
|
||
} else {
|
||
// only single selections are allowed
|
||
if (pData->bWildCardInstances && pData->bSelectAllInstances) {
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
memset (lszInstanceName, 0, sizeof(lszInstanceName));
|
||
lstrcpyW (lszInstanceName, cszSplat);
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
|
||
dwThisCounter = (DWORD)SendMessageW (hWndCounterList, LB_GETCURSEL, 0, 0);
|
||
if (dwThisCounter != LB_ERR) {
|
||
lszPath.szCounterName = &lszCounterName[0];
|
||
memset (lszCounterName, 0, sizeof(lszCounterName));
|
||
SendMessageW (hWndCounterList, LB_GETTEXT,
|
||
(WPARAM)dwThisCounter, (LPARAM)lszCounterName);
|
||
|
||
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
pdhStatus = PdhiCopyString(& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
} else {
|
||
// unable to make counter path so skip
|
||
}
|
||
} //end if counter was found in list box
|
||
} else {
|
||
// get selected instance from list
|
||
dwThisCounter = (DWORD)SendMessageW (hWndCounterList, LB_GETCURSEL, 0, 0);
|
||
if (dwThisCounter != LB_ERR) {
|
||
lszPath.szCounterName = &lszCounterName[0];
|
||
memset (lszCounterName, 0, sizeof(lszCounterName));
|
||
SendMessageW (hWndCounterList, LB_GETTEXT,
|
||
(WPARAM)dwThisCounter, (LPARAM)lszCounterName);
|
||
|
||
if (IsWindowEnabled(hWndInstanceList)) {
|
||
dwThisInstance = (DWORD)SendMessageW (hWndInstanceList,
|
||
LB_GETCURSEL, 0, 0);
|
||
if (dwThisInstance == LB_ERR) {
|
||
// instance not found so select 0
|
||
dwThisInstance = 0;
|
||
}
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
memset (lszInstanceName, 0, sizeof(lszInstanceName));
|
||
SendMessageW (hWndInstanceList, LB_GETTEXT,
|
||
(WPARAM)dwThisInstance, (LPARAM)lszInstanceName);
|
||
|
||
lszPath.szParentInstance = &lszParentInstance[0];
|
||
memset (lszParentInstance, 0, sizeof(lszParentInstance));
|
||
|
||
dwSize1 = dwSize2 = MAX_PATH;
|
||
pdhStatus = PdhParseInstanceNameW (lszInstanceName,
|
||
lszInstanceName,
|
||
&dwSize1,
|
||
lszParentInstance,
|
||
&dwSize2,
|
||
&lszPath.dwInstanceIndex);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS ) {
|
||
// parse instance name adds in the default index of one is
|
||
// not present. so if it's not wanted, this will remove it
|
||
if (!pData->bShowIndex) {
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
}
|
||
// size values include trailing NULL char so
|
||
// strings must be > 1 char in length to have some
|
||
// text since a length of 1 would imply only a
|
||
// NULL character.
|
||
if (dwSize1 > 1) {
|
||
lszPath.szInstanceName = &lszInstanceName[0];
|
||
} else {
|
||
lszPath.szInstanceName = NULL;
|
||
}
|
||
if (dwSize2 > 1) {
|
||
lszPath.szParentInstance = &lszParentInstance[0];
|
||
} else {
|
||
lszPath.szParentInstance = NULL;
|
||
}
|
||
} else {
|
||
// skip this instance
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.szInstanceName = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
}
|
||
} else {
|
||
// this counter has no instances so process now
|
||
lszPath.szInstanceName = NULL;
|
||
lszPath.szParentInstance = NULL;
|
||
lszPath.dwInstanceIndex = (DWORD)-1;
|
||
} // end if counter has instances
|
||
|
||
dwSize1 = sizeof (szWorkBuffer) / sizeof (WCHAR);
|
||
pdhStatus = PdhMakeCounterPathW (&lszPath,
|
||
szWorkBuffer,
|
||
&dwSize1,
|
||
0);
|
||
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
pdhStatus = PdhiCopyString(& ((LPBYTE) szCounterStart),
|
||
szWorkBuffer,
|
||
& dwBufferRemaining,
|
||
bUnicode);
|
||
} else {
|
||
// unable to build a counter path so skip
|
||
}
|
||
} // end if counter found
|
||
} // end if not wild card instances
|
||
}
|
||
if (bUnicode) {
|
||
*((LPWSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
} else {
|
||
*((LPSTR)szCounterStart)++ = 0; // terminate MSZ
|
||
}
|
||
return pdhStatus;
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersW (
|
||
IN HWND hDlg,
|
||
IN LPWSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
UNICODE function wrapper for base function which scans the selected
|
||
objects, counter, instances and builds a multi-SZ string containing
|
||
the expanded path of all the selections, unless the wild card
|
||
syntax is specified.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle of Dialog containing the controls
|
||
|
||
IN LPWSTR szUsersPathBuffer
|
||
pointer to the caller's buffer that will receive the MSZ
|
||
wide characters string
|
||
|
||
IN DWORD cchUsersPathLength
|
||
size of caller's buffer in characters
|
||
|
||
Return Value:
|
||
|
||
WIN32 Status of function completion
|
||
ERROR_SUCCESS if successful
|
||
|
||
--*/
|
||
{
|
||
return PdhiCompileSelectedCountersT (
|
||
hDlg,
|
||
(LPVOID)szUsersPathBuffer,
|
||
cchUsersPathLength,
|
||
TRUE);
|
||
}
|
||
|
||
STATIC_PDH_FUNCTION
|
||
PdhiCompileSelectedCountersA (
|
||
IN HWND hDlg,
|
||
IN LPSTR szUsersPathBuffer,
|
||
IN DWORD cchUsersPathLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
ANSI function wrapper for base function which scans the selected
|
||
objects, counter, instances and builds a multi-SZ string containing
|
||
the expanded path of all the selections, unless the wild card
|
||
syntax is specified.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle of Dialog containing the controls
|
||
|
||
IN LPsSTR szUsersPathBuffer
|
||
pointer to the caller's buffer that will receive the MSZ
|
||
single-byte characters string
|
||
|
||
IN DWORD cchUsersPathLength
|
||
size of caller's buffer in characters
|
||
|
||
Return Value:
|
||
|
||
WIN32 Status of function completion
|
||
ERROR_SUCCESS if successful
|
||
|
||
--*/
|
||
{
|
||
return PdhiCompileSelectedCountersT (
|
||
hDlg,
|
||
(LPVOID)szUsersPathBuffer,
|
||
cchUsersPathLength,
|
||
FALSE);
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_MACHINE_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Machine selection combo box
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
WCHAR szNewMachineName[MAX_PATH];
|
||
HWND hWndMachineCombo = hWndControl;
|
||
long lMatchIndex;
|
||
HCURSOR hOldCursor;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case CBN_KILLFOCUS:
|
||
// the user has left the control so see if there's a new
|
||
// machine name that will need to be connected to and loaded
|
||
|
||
// display the wait cursor as this could take a while
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
// Get current combo box text
|
||
GetWindowTextW (hWndMachineCombo, szNewMachineName, MAX_PATH);
|
||
|
||
// see if it's in the combo box already
|
||
|
||
lMatchIndex = (long)SendMessageW (hWndMachineCombo,
|
||
CB_FINDSTRINGEXACT,(WPARAM)-1, (LPARAM)szNewMachineName);
|
||
|
||
// if name is in list, then select it and initialize the dialog
|
||
// update the current counter list & data block for this machine
|
||
// in the process.
|
||
if (lMatchIndex != CB_ERR) {
|
||
// this name is already in the list so see if it's the same as the last selected machine
|
||
if (lstrcmpiW (szNewMachineName, pData->szLastMachineName) != 0) {
|
||
// this is a different machine so update the display
|
||
SendMessageW (hWndMachineCombo, CB_SETCURSEL,
|
||
(WPARAM)lMatchIndex, 0);
|
||
PdhiLoadMachineObjects (hDlg, TRUE);
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
// display explain text if necessary
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
lstrcpyW (pData->szLastMachineName, szNewMachineName);
|
||
} else {
|
||
// they just reselected this machine so nothing to do
|
||
}
|
||
} else {
|
||
if (PdhiLoadNewMachine (hDlg, szNewMachineName)) {
|
||
// new machine loaded and selected so save the name.
|
||
lstrcpyW (pData->szLastMachineName, szNewMachineName);
|
||
}
|
||
}
|
||
SetCursor (hOldCursor);
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_MACHINE_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when one of the
|
||
machine context selection buttons in pressed in the dialog
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the button
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
BOOL bMode;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
HWND hWndMachineCombo;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case BN_CLICKED:
|
||
// select the current display and processing mode based
|
||
// on the button that his currently checked.
|
||
bMode = !(BOOL)IsDlgButtonChecked(hDlg, IDC_USE_LOCAL_MACHINE);
|
||
EnableWindow(GetDlgItem(hDlg, IDC_MACHINE_COMBO), bMode);
|
||
if (!bMode) {
|
||
hWndMachineCombo = GetDlgItem(hDlg, IDC_MACHINE_COMBO);
|
||
// then this is a Local machine query so
|
||
// make sure the machine name is set to the local machine
|
||
SetWindowTextW (hWndMachineCombo, szStaticLocalMachineName);
|
||
PdhiBrowseCtrDlg_MACHINE_COMBO (hDlg, CBN_KILLFOCUS, hWndMachineCombo);
|
||
}
|
||
pData->bIncludeMachineInPath = bMode;
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OBJECT_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Object selection combo box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
switch (wNotifyMsg) {
|
||
case CBN_SELCHANGE:
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_COUNTER_LIST (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Object selection combo box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
WCHAR szMachineName[MAX_PATH];
|
||
WCHAR szObjectName[MAX_PATH];
|
||
WCHAR szCounterName[MAX_PATH];
|
||
WCHAR szDisplayString[MAX_PATH*2];
|
||
LPWSTR szExplainText = NULL;
|
||
BOOL bFreeExplain = FALSE;
|
||
LONG lIndex;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
switch (wNotifyMsg) {
|
||
case LBN_SELCHANGE:
|
||
if (hExplainDlg != NULL) {
|
||
// get machine name
|
||
GetDlgItemTextW (hDlg, IDC_MACHINE_COMBO,
|
||
szMachineName, MAX_PATH);
|
||
// get object name
|
||
GetDlgItemTextW (hDlg, IDC_OBJECT_COMBO,
|
||
szObjectName, MAX_PATH);
|
||
// get counter name
|
||
// depending on list box type
|
||
lIndex = (LONG)SendDlgItemMessageW (hDlg, IDC_COUNTER_LIST,
|
||
LB_GETCARETINDEX, 0, 0);
|
||
if (lIndex != LB_ERR) {
|
||
lIndex = (LONG)SendDlgItemMessageW (hDlg, IDC_COUNTER_LIST,
|
||
LB_GETTEXT, (WPARAM)lIndex, (LPARAM)&szCounterName[0]);
|
||
// get help string
|
||
|
||
if (dwPdhiLocalDefaultDataSource == DATA_SOURCE_WBEM) {
|
||
PDH_STATUS Status = PDH_MORE_DATA;
|
||
DWORD dwExplain = 0;
|
||
|
||
szExplainText = NULL;
|
||
while (Status == PDH_MORE_DATA) {
|
||
dwExplain += MAX_PATH;
|
||
if (szExplainText != NULL) {
|
||
G_FREE(szExplainText);
|
||
}
|
||
szExplainText = G_ALLOC(dwExplain * sizeof(WCHAR));
|
||
if (szExplainText == NULL) {
|
||
bFreeExplain = FALSE;
|
||
Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
||
}
|
||
else {
|
||
bFreeExplain = TRUE;
|
||
Status = PdhiGetWbemExplainText(
|
||
szMachineName,
|
||
szObjectName,
|
||
szCounterName,
|
||
szExplainText,
|
||
& dwExplain);
|
||
}
|
||
}
|
||
if (Status != ERROR_SUCCESS) {
|
||
if (bFreeExplain) {
|
||
bFreeExplain = FALSE;
|
||
G_FREE(szExplainText);
|
||
}
|
||
szExplainText = NULL;
|
||
}
|
||
}
|
||
else {
|
||
szExplainText = PdhiGetExplainText(
|
||
szMachineName, szObjectName, szCounterName);
|
||
}
|
||
|
||
lstrcpyW(szDisplayString, szMachineName);
|
||
lstrcatW(szDisplayString, cszBackSlash);
|
||
lstrcatW(szDisplayString, szObjectName);
|
||
lstrcatW(szDisplayString, cszBackSlash);
|
||
lstrcatW(szDisplayString, szCounterName);
|
||
|
||
} else {
|
||
szExplainText = NULL;
|
||
szDisplayString[0] = 0;
|
||
}
|
||
// send to explain dialog
|
||
SendMessageW (hExplainDlg, EDM_UPDATE_EXPLAIN_TEXT,
|
||
0, (LPARAM)szExplainText);
|
||
SendMessageW (hExplainDlg, EDM_UPDATE_TITLE_TEXT,
|
||
0, (LPARAM)szDisplayString);
|
||
}
|
||
if (bFreeExplain && szExplainText != NULL) {
|
||
G_FREE(szExplainText);
|
||
}
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OBJECT_LIST (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Object selection combo box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
WCHAR szMachineName[MAX_PATH];
|
||
WCHAR szObjectName[MAX_PATH];
|
||
WCHAR szDisplayString[MAX_PATH*2];
|
||
LPWSTR szExplainText = NULL;
|
||
BOOL bFreeExplain = FALSE;
|
||
LONG lIndex;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
switch (wNotifyMsg) {
|
||
case LBN_SELCHANGE:
|
||
if (hExplainDlg != NULL) {
|
||
// get machine name
|
||
GetDlgItemTextW (hDlg, IDC_MACHINE_COMBO,
|
||
szMachineName, MAX_PATH);
|
||
// get object name depending on list box type
|
||
lIndex = (LONG)SendDlgItemMessageW (hDlg, IDC_OBJECT_LIST,
|
||
LB_GETCARETINDEX, 0, 0);
|
||
if (lIndex != LB_ERR) {
|
||
lIndex = (LONG)SendDlgItemMessageW (hDlg, IDC_OBJECT_LIST,
|
||
LB_GETTEXT, (WPARAM)lIndex, (LPARAM)&szObjectName[0]);
|
||
// get help string
|
||
|
||
if (dwPdhiLocalDefaultDataSource == DATA_SOURCE_WBEM) {
|
||
PDH_STATUS Status = PDH_MORE_DATA;
|
||
DWORD dwExplain = 0;
|
||
|
||
szExplainText = NULL;
|
||
while (Status == PDH_MORE_DATA) {
|
||
dwExplain += MAX_PATH;
|
||
if (szExplainText != NULL) {
|
||
G_FREE(szExplainText);
|
||
}
|
||
szExplainText = G_ALLOC(dwExplain * sizeof(WCHAR));
|
||
if (szExplainText == NULL) {
|
||
bFreeExplain = FALSE;
|
||
Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
||
}
|
||
else {
|
||
bFreeExplain = TRUE;
|
||
Status = PdhiGetWbemExplainText(
|
||
szMachineName,
|
||
szObjectName,
|
||
NULL,
|
||
szExplainText,
|
||
& dwExplain);
|
||
}
|
||
}
|
||
if (Status != ERROR_SUCCESS) {
|
||
if (bFreeExplain) {
|
||
bFreeExplain = FALSE;
|
||
G_FREE(szExplainText);
|
||
}
|
||
szExplainText = NULL;
|
||
}
|
||
}
|
||
else {
|
||
szExplainText = PdhiGetExplainText(
|
||
szMachineName, szObjectName, NULL);
|
||
}
|
||
|
||
lstrcpyW(szDisplayString, szMachineName);
|
||
lstrcatW(szDisplayString, cszBackSlash);
|
||
lstrcatW(szDisplayString, szObjectName);
|
||
|
||
} else {
|
||
szExplainText = NULL;
|
||
szDisplayString[0] = 0;
|
||
}
|
||
// send to explain dialog
|
||
SendMessageW (hExplainDlg, EDM_UPDATE_EXPLAIN_TEXT,
|
||
0, (LPARAM)szExplainText);
|
||
SendMessageW (hExplainDlg, EDM_UPDATE_TITLE_TEXT,
|
||
0, (LPARAM)szDisplayString);
|
||
}
|
||
if (bFreeExplain && szExplainText != NULL) {
|
||
G_FREE(szExplainText);
|
||
}
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_DETAIL_COMBO (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Detail Level Combo box.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
DWORD dwCurSel;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case CBN_SELCHANGE:
|
||
dwCurSel = (DWORD)SendMessageW (hWndControl, CB_GETCURSEL, 0, 0);
|
||
if (dwCurSel != CB_ERR) {
|
||
pData->dwCurrentDetailLevel = (DWORD)SendMessageW (hWndControl,
|
||
CB_GETITEMDATA, (WPARAM)dwCurSel, 0);
|
||
// update all the windows to show the new level
|
||
PdhiLoadMachineObjects (hDlg, FALSE);
|
||
PdhiLoadCountersAndInstances (hDlg);
|
||
// display explain text if necessary
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_INSTANCE_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Instance configuration
|
||
selection buttons
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
BOOL bMode;
|
||
HWND hWndInstanceList;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case BN_CLICKED:
|
||
bMode = (BOOL)IsDlgButtonChecked(hDlg, IDC_ALL_INSTANCES);
|
||
hWndInstanceList = GetDlgItem(hDlg, IDC_INSTANCE_LIST);
|
||
// if "Select ALL" then clear list box selections and disable
|
||
// the list box
|
||
if (bMode) {
|
||
SendMessageW (hWndInstanceList, LB_SETSEL, FALSE, (LPARAM)-1);
|
||
} else {
|
||
LRESULT dwCountInstance =
|
||
SendMessage(hWndInstanceList, LB_GETCOUNT, 0, 0);
|
||
LRESULT dwThisInstance = 0;
|
||
BOOL bSelection = FALSE;
|
||
|
||
for (dwThisInstance = 0;
|
||
! bSelection && dwThisInstance < dwCountInstance;
|
||
dwThisInstance ++) {
|
||
bSelection = (BOOL) SendMessage(hWndInstanceList,
|
||
LB_GETSEL,
|
||
(WPARAM) dwThisInstance,
|
||
0);
|
||
}
|
||
if (! bSelection) {
|
||
SendMessageW (hWndInstanceList, LB_SETSEL, TRUE, (LPARAM)0);
|
||
}
|
||
}
|
||
EnableWindow(hWndInstanceList, !bMode);
|
||
pData->bSelectAllInstances = bMode;
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_COUNTER_BUTTON (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messags sent by the Instance configuration
|
||
selection buttons
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the control
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the control
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
BOOL bMode;
|
||
HWND hWndCounterList;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case BN_CLICKED:
|
||
bMode = (BOOL)IsDlgButtonChecked(hDlg, IDC_ALL_COUNTERS);
|
||
hWndCounterList = GetDlgItem(hDlg, IDC_COUNTER_LIST);
|
||
// if "Select ALL" then clear list box selections and disable
|
||
// the list box
|
||
if (bMode) {
|
||
SendMessageW (hWndCounterList, LB_SETSEL, FALSE, (LPARAM)-1);
|
||
} else {
|
||
LRESULT dwCountCounter =
|
||
SendMessage(hWndCounterList, LB_GETCOUNT, 0, 0);
|
||
LRESULT dwThisCounter = 0;
|
||
BOOL bSelection = FALSE;
|
||
|
||
for (dwThisCounter = 0;
|
||
! bSelection && dwThisCounter < dwCountCounter;
|
||
dwThisCounter ++) {
|
||
bSelection = (BOOL) SendMessage(hWndCounterList,
|
||
LB_GETSEL,
|
||
(WPARAM) dwThisCounter,
|
||
0);
|
||
}
|
||
if (! bSelection) {
|
||
PDH_STATUS pdhStatus = ERROR_SUCCESS;
|
||
DWORD dwCounterName = MAX_PATH;
|
||
DWORD dwCounterIndex = 0;
|
||
WCHAR szMachineName[MAX_PATH + 1];
|
||
WCHAR szObjectName[MAX_PATH + 1];
|
||
WCHAR szCounterName[MAX_PATH + 1];
|
||
|
||
GetDlgItemTextW(hDlg,
|
||
IDC_MACHINE_COMBO,
|
||
szMachineName
|
||
, MAX_PATH);
|
||
GetDlgItemTextW(hDlg,
|
||
IDC_OBJECT_COMBO,
|
||
szObjectName,
|
||
MAX_PATH);
|
||
pdhStatus = PdhGetDefaultPerfCounterHW (
|
||
pData->pDlgData->hDataSource,
|
||
szMachineName,
|
||
szObjectName,
|
||
szCounterName,
|
||
& dwCounterName);
|
||
if (pdhStatus == ERROR_SUCCESS) {
|
||
dwCounterIndex = (DWORD) SendMessageW(
|
||
hWndCounterList,
|
||
LB_FINDSTRINGEXACT,
|
||
(WPARAM) -1,
|
||
(LPARAM) szCounterName);
|
||
if (dwCounterIndex == LB_ERR) {
|
||
dwCounterIndex = 0;
|
||
}
|
||
}
|
||
|
||
SendMessageW(hWndCounterList,
|
||
LB_SETSEL,
|
||
TRUE,
|
||
(LPARAM) dwCounterIndex);
|
||
}
|
||
}
|
||
EnableWindow(hWndCounterList, !bMode);
|
||
pData->bSelectAllCounters = bMode;
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
#pragma warning ( disable : 4127 )
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_OK (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the currently selected counter and instance strings to
|
||
build a list of selected paths strings in the user's supplied
|
||
buffer. This buffer will either be processed by a call back
|
||
string or the dialog box will be terminated allowing the
|
||
calling function to continue processing the returned strings.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the button
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
HCURSOR hOldCursor;
|
||
CounterPathCallBack pCallBack;
|
||
DWORD_PTR dwArg;
|
||
PDH_STATUS pdhStatus;
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
PPDHI_BROWSE_DLG_INFO pDlgData;
|
||
|
||
HWND hWndFocus;
|
||
HWND hWndMachine;
|
||
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
pDlgData = pData->pDlgData;
|
||
|
||
hWndFocus = GetFocus();
|
||
hWndMachine = GetDlgItem (hDlg, IDC_MACHINE_COMBO);
|
||
|
||
if (hWndFocus == hWndMachine) {
|
||
//special case to make sure the dialog has the current machine data
|
||
PdhiBrowseCtrDlg_MACHINE_COMBO (hDlg, CBN_KILLFOCUS, hWndMachine);
|
||
SetFocus (hWndControl);
|
||
}
|
||
|
||
switch (wNotifyMsg) {
|
||
case BN_CLICKED:
|
||
// display wait cursor while this is being processed
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
while (TRUE) {
|
||
if (pData->bShowObjects) {
|
||
// then return object spec(s) using selected perf objects
|
||
if (pDlgData->pWideStruct != NULL) {
|
||
// use wide character function
|
||
pdhStatus = PdhiCompileSelectedObjectsW (hDlg,
|
||
pDlgData->pWideStruct->szReturnPathBuffer,
|
||
pDlgData->pWideStruct->cchReturnPathLength);
|
||
pCallBack = pDlgData->pWideStruct->pCallBack;
|
||
dwArg = pDlgData->pWideStruct->dwCallBackArg;
|
||
pDlgData->pWideStruct->CallBackStatus = pdhStatus;
|
||
} else if (pDlgData->pAnsiStruct != NULL) {
|
||
// use ansi char functions
|
||
pdhStatus = PdhiCompileSelectedObjectsA (hDlg,
|
||
pDlgData->pAnsiStruct->szReturnPathBuffer,
|
||
pDlgData->pAnsiStruct->cchReturnPathLength);
|
||
pCallBack = pDlgData->pAnsiStruct->pCallBack;
|
||
dwArg = pDlgData->pAnsiStruct->dwCallBackArg;
|
||
pDlgData->pAnsiStruct->CallBackStatus = pdhStatus;
|
||
} else {
|
||
// do nothing
|
||
pCallBack = NULL;
|
||
dwArg = 0;
|
||
}
|
||
} else {
|
||
// return selected counters & instances
|
||
// process these string until it works. (note, this
|
||
// could cause an infinite loop if the callback
|
||
// function is not working correctly (i.e. always
|
||
// returning PDH_RETRY, for example)
|
||
if (pDlgData->pWideStruct != NULL) {
|
||
// use wide character function
|
||
pdhStatus = PdhiCompileSelectedCountersW (hDlg,
|
||
pDlgData->pWideStruct->szReturnPathBuffer,
|
||
pDlgData->pWideStruct->cchReturnPathLength);
|
||
pCallBack = pDlgData->pWideStruct->pCallBack;
|
||
dwArg = pDlgData->pWideStruct->dwCallBackArg;
|
||
pDlgData->pWideStruct->CallBackStatus = pdhStatus;
|
||
} else if (pDlgData->pAnsiStruct != NULL) {
|
||
// use ansi char functions
|
||
pdhStatus = PdhiCompileSelectedCountersA (hDlg,
|
||
pDlgData->pAnsiStruct->szReturnPathBuffer,
|
||
pDlgData->pAnsiStruct->cchReturnPathLength);
|
||
pCallBack = pDlgData->pAnsiStruct->pCallBack;
|
||
dwArg = pDlgData->pAnsiStruct->dwCallBackArg;
|
||
pDlgData->pAnsiStruct->CallBackStatus = pdhStatus;
|
||
} else {
|
||
// do nothing
|
||
pCallBack = NULL;
|
||
dwArg = 0;
|
||
}
|
||
|
||
}
|
||
if (pCallBack != NULL) {
|
||
pdhStatus = (*pCallBack)(dwArg);
|
||
} else {
|
||
pdhStatus = ERROR_SUCCESS;
|
||
}
|
||
|
||
// see if the callback wants to try again
|
||
if (pdhStatus != PDH_RETRY) {
|
||
break;
|
||
}
|
||
} // end while (retry loop)
|
||
|
||
// if the caller only wants to give the user ONE chance to
|
||
// add counters, then end the dialog now.
|
||
if (!pData->bAddMultipleCounters) {
|
||
EndDialog (hDlg, IDOK);
|
||
}
|
||
SetCursor (hOldCursor);
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
#pragma warning ( default : 4127 )
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_CANCEL (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows messages that occur when the cancel button
|
||
is pressed.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the button
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
switch (wNotifyMsg) {
|
||
case BN_CLICKED:
|
||
EndDialog (hDlg, IDCANCEL);
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_EXPLAIN_BTN (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when the help button
|
||
is pressed. (This feature is not currently implemented)
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the button
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
HWND hFocusWnd;
|
||
PPDHI_BROWSE_DIALOG_DATA pData =
|
||
(PPDHI_BROWSE_DIALOG_DATA) GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
|
||
UNREFERENCED_PARAMETER (wNotifyMsg);
|
||
|
||
if (hExplainDlg == NULL) {
|
||
hFocusWnd = GetFocus();
|
||
// create a modeless dialog to display the explain text
|
||
hExplainDlg = CreateDialogW (
|
||
ThisDLLHandle,
|
||
MAKEINTRESOURCEW(IDD_EXPLAIN_DLG),
|
||
hDlg,
|
||
(DLGPROC)ExplainTextDlgProc);
|
||
|
||
SetFocus(hFocusWnd);
|
||
EnableWindow (hWndControl, FALSE);
|
||
}
|
||
|
||
if (pData->bShowObjects) {
|
||
SendMessageW(hDlg,
|
||
WM_COMMAND,
|
||
MAKEWPARAM(IDC_OBJECT_LIST, LBN_SELCHANGE),
|
||
(LPARAM) GetDlgItem(hDlg, IDC_OBJECT_LIST));
|
||
}
|
||
else {
|
||
SendMessageW(hDlg,
|
||
WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM) GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
}
|
||
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_HELP_BTN (
|
||
IN HWND hDlg,
|
||
IN WORD wNotifyMsg,
|
||
IN HWND hWndControl
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when the network button
|
||
is pressed. (This feature is not currently implemented)
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wNotifyMsg
|
||
Notification message sent by the button
|
||
|
||
IN HWND hWndControl
|
||
Window handle of the control sending the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
LPWSTR szMsg;
|
||
|
||
UNREFERENCED_PARAMETER (wNotifyMsg);
|
||
UNREFERENCED_PARAMETER (hWndControl);
|
||
|
||
szMsg = GetStringResource (IDS_ERR_NO_HELP);
|
||
if (szMsg != NULL) {
|
||
MessageBoxW (hDlg, szMsg, szMsg, MB_OK);
|
||
G_FREE (szMsg);
|
||
} else {
|
||
MessageBeep (MB_ICONEXCLAMATION);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_INITDIALOG (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs just before the dialog
|
||
box is displayed for the first time.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WORD wParam
|
||
|
||
|
||
IN HWND lParam
|
||
Pointer to dialog box data block
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
PPDHI_BROWSE_DLG_INFO pDlgData;
|
||
|
||
HCURSOR hOldCursor;
|
||
LPWSTR szMsg;
|
||
|
||
UNREFERENCED_PARAMETER (wParam);
|
||
|
||
// reset the last error value
|
||
SetLastError (ERROR_SUCCESS);
|
||
|
||
hOldCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)G_ALLOC(
|
||
sizeof(PDHI_BROWSE_DIALOG_DATA));
|
||
|
||
if (pData == NULL) {
|
||
SetLastError (PDH_MEMORY_ALLOCATION_FAILURE);
|
||
EndDialog (hDlg, IDCANCEL);
|
||
return TRUE;
|
||
}
|
||
|
||
// initialize local static variables
|
||
dwCounterListSize = COUNTER_LIST_SIZE;
|
||
dwInstanceListSize = INSTANCE_LIST_SIZE;
|
||
|
||
// save user data
|
||
|
||
pDlgData = (PPDHI_BROWSE_DLG_INFO) lParam;
|
||
pData->pDlgData = (PPDHI_BROWSE_DLG_INFO) lParam;
|
||
|
||
SetWindowLongPtrW (hDlg, DWLP_USER, (LONG_PTR)pData);
|
||
|
||
// load configuration flags from user data
|
||
|
||
if (pData->pDlgData->pWideStruct != NULL) {
|
||
// use wide structure
|
||
pData->bShowIndex =
|
||
(BOOL)pDlgData->pWideStruct->bIncludeInstanceIndex;
|
||
pData->bSelectMultipleCounters =
|
||
!(BOOL)pDlgData->pWideStruct->bSingleCounterPerAdd;
|
||
pData->bAddMultipleCounters =
|
||
!(BOOL)pDlgData->pWideStruct->bSingleCounterPerDialog;
|
||
pData->bLocalCountersOnly =
|
||
(BOOL)pDlgData->pWideStruct->bLocalCountersOnly;
|
||
pData->bIncludeMachineInPath = !pData->bLocalCountersOnly;
|
||
pData->bWildCardInstances =
|
||
(BOOL)pDlgData->pWideStruct->bWildCardInstances;
|
||
pData->bHideDetailLevel =
|
||
(BOOL)pDlgData->pWideStruct->bHideDetailBox;
|
||
if (pDlgData->pWideStruct->szDialogBoxCaption != NULL) {
|
||
SetWindowTextW (hDlg, pDlgData->pWideStruct->szDialogBoxCaption);
|
||
}
|
||
pData->dwCurrentDetailLevel =
|
||
pDlgData->pWideStruct->dwDefaultDetailLevel;
|
||
pData->bDisableMachineSelection =
|
||
(BOOL)pDlgData->pWideStruct->bDisableMachineSelection;
|
||
pData->bInitializePath =
|
||
(BOOL)pDlgData->pWideStruct->bInitializePath;
|
||
pData->bIncludeCostlyObjects =
|
||
(BOOL)pDlgData->pWideStruct->bIncludeCostlyObjects;
|
||
pData->bShowObjects =
|
||
(BOOL)pDlgData->pWideStruct->bShowObjectBrowser;
|
||
} else if (pData->pDlgData->pAnsiStruct != NULL) {
|
||
// use Ansi struct
|
||
pData->bShowIndex =
|
||
(BOOL)pDlgData->pAnsiStruct->bIncludeInstanceIndex;
|
||
pData->bSelectMultipleCounters =
|
||
!(BOOL)pDlgData->pAnsiStruct->bSingleCounterPerAdd;
|
||
pData->bAddMultipleCounters =
|
||
!(BOOL)pDlgData->pAnsiStruct->bSingleCounterPerDialog;
|
||
pData->bLocalCountersOnly =
|
||
(BOOL)pDlgData->pAnsiStruct->bLocalCountersOnly;
|
||
pData->bIncludeMachineInPath = !pData->bLocalCountersOnly;
|
||
pData->bWildCardInstances =
|
||
(BOOL)pDlgData->pAnsiStruct->bWildCardInstances;
|
||
pData->bHideDetailLevel =
|
||
(BOOL)pDlgData->pAnsiStruct->bHideDetailBox;
|
||
if (pDlgData->pAnsiStruct->szDialogBoxCaption != NULL) {
|
||
SetWindowTextA (hDlg, pDlgData->pAnsiStruct->szDialogBoxCaption);
|
||
}
|
||
pData->dwCurrentDetailLevel =
|
||
pDlgData->pAnsiStruct->dwDefaultDetailLevel;
|
||
pData->bDisableMachineSelection =
|
||
(BOOL)pDlgData->pAnsiStruct->bDisableMachineSelection;
|
||
pData->bInitializePath =
|
||
(BOOL)pDlgData->pAnsiStruct->bInitializePath;
|
||
pData->bIncludeCostlyObjects =
|
||
(BOOL)pDlgData->pAnsiStruct->bIncludeCostlyObjects;
|
||
pData->bShowObjects =
|
||
(BOOL)pDlgData->pAnsiStruct->bShowObjectBrowser;
|
||
} else {
|
||
// bad data so bail out
|
||
EndDialog (hDlg, IDCANCEL);
|
||
G_FREE(pData);
|
||
return TRUE;
|
||
}
|
||
|
||
// selecting objects implies multiple selections
|
||
if (pData->bShowObjects) {
|
||
pData->bSelectMultipleCounters = TRUE;
|
||
}
|
||
// limit text to machine name
|
||
SendDlgItemMessageW (hDlg, IDC_MACHINE_COMBO, EM_LIMITTEXT, MAX_PATH, 0);
|
||
|
||
// set check boxes to the caller defined setting
|
||
|
||
if (pData->bLocalCountersOnly) {
|
||
// then only the local counters button is selected and enabled
|
||
EnableWindow (GetDlgItem(hDlg, IDC_SELECT_MACHINE), FALSE);
|
||
}
|
||
|
||
CheckRadioButton (hDlg, IDC_USE_LOCAL_MACHINE, IDC_SELECT_MACHINE,
|
||
(pData->bIncludeMachineInPath ? IDC_SELECT_MACHINE : IDC_USE_LOCAL_MACHINE));
|
||
EnableWindow (GetDlgItem(hDlg, IDC_MACHINE_COMBO),
|
||
(pData->bIncludeMachineInPath ? TRUE : FALSE));
|
||
|
||
if (!pData->bShowObjects) {
|
||
// these controls aren't found in the Object browser
|
||
CheckRadioButton (hDlg, IDC_ALL_INSTANCES, IDC_USE_INSTANCE_LIST,
|
||
IDC_USE_INSTANCE_LIST);
|
||
pData->bSelectAllInstances = FALSE;
|
||
|
||
CheckRadioButton (hDlg, IDC_ALL_COUNTERS, IDC_USE_COUNTER_LIST,
|
||
IDC_USE_COUNTER_LIST);
|
||
pData->bSelectAllCounters = FALSE;
|
||
}
|
||
|
||
// set button text strings to reflect mode of dialog
|
||
if (pData->bAddMultipleCounters) {
|
||
szMsg = GetStringResource (IDS_BRWS_ADD);
|
||
if (szMsg != NULL) {
|
||
SetWindowTextW(GetDlgItem(hDlg, IDOK), (LPCWSTR)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
szMsg = GetStringResource (IDS_BRWS_CLOSE);
|
||
if (szMsg != NULL) {
|
||
SetWindowTextW(GetDlgItem(hDlg, IDCANCEL), (LPCWSTR)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
} else {
|
||
szMsg = GetStringResource (IDS_BRWS_OK);
|
||
if (szMsg != NULL) {
|
||
SetWindowTextW(GetDlgItem(hDlg, IDOK), (LPCWSTR)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
szMsg = GetStringResource (IDS_BRWS_CANCEL);
|
||
if (szMsg != NULL) {
|
||
SetWindowTextW(GetDlgItem(hDlg, IDCANCEL), (LPCWSTR)szMsg);
|
||
G_FREE (szMsg);
|
||
}
|
||
}
|
||
|
||
// see if the data source supports detail levels
|
||
if (!PdhiDataSourceHasDetailLevelsH (pData->pDlgData->hDataSource)) {
|
||
//then set detail to wizard and hide the combo box
|
||
pData->bHideDetailLevel = TRUE;
|
||
pData->dwCurrentDetailLevel = PERF_DETAIL_WIZARD;
|
||
}
|
||
|
||
// hide detail combo box if desired
|
||
if (pData->bHideDetailLevel) {
|
||
ShowWindow (GetDlgItem(hDlg, IDC_COUNTER_DETAIL_CAPTION), SW_HIDE);
|
||
ShowWindow (GetDlgItem(hDlg, IDC_COUNTER_DETAIL_COMBO), SW_HIDE);
|
||
// make sure this is a "legal" value
|
||
switch (pData->dwCurrentDetailLevel) {
|
||
case PERF_DETAIL_NOVICE:
|
||
case PERF_DETAIL_EXPERT:
|
||
case PERF_DETAIL_ADVANCED:
|
||
case PERF_DETAIL_WIZARD:
|
||
// these are OK
|
||
break;
|
||
|
||
default:
|
||
// default is to show all
|
||
pData->dwCurrentDetailLevel = PERF_DETAIL_WIZARD;
|
||
break;
|
||
}
|
||
} else {
|
||
// load the combo box entries
|
||
pData->dwCurrentDetailLevel = PdhiLoadDetailLevelCombo (
|
||
hDlg, pData->dwCurrentDetailLevel);
|
||
}
|
||
|
||
// connect to this machine
|
||
if (pData->pDlgData->hDataSource == H_REALTIME_DATASOURCE) {
|
||
PdhConnectMachineW(NULL); // Null is local machine
|
||
}
|
||
|
||
PdhiLoadKnownMachines(hDlg); // load machine list
|
||
PdhiLoadMachineObjects(hDlg, TRUE); // load object list
|
||
if (!pData->bShowObjects) {
|
||
// these controls don't exist in the object browser
|
||
PdhiLoadCountersAndInstances(hDlg);
|
||
}
|
||
|
||
if (pData->bShowObjects) {
|
||
// display explain text if necessary
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_OBJECT_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_OBJECT_LIST));
|
||
} else {
|
||
// display explain text if necessary
|
||
SendMessageW (hDlg, WM_COMMAND,
|
||
MAKEWPARAM(IDC_COUNTER_LIST, LBN_SELCHANGE),
|
||
(LPARAM)GetDlgItem(hDlg, IDC_COUNTER_LIST));
|
||
}
|
||
|
||
if (pData->bInitializePath) {
|
||
PdhiSelectItemsInPath(hDlg);
|
||
}
|
||
|
||
// hide the machine selection buttons and disable the
|
||
// machine combo box if selected (after the connection has been
|
||
// made, of course)
|
||
|
||
if (pData->bDisableMachineSelection) {
|
||
ShowWindow (GetDlgItem(hDlg, IDC_USE_LOCAL_MACHINE), SW_HIDE);
|
||
ShowWindow (GetDlgItem(hDlg, IDC_SELECT_MACHINE), SW_HIDE);
|
||
EnableWindow (GetDlgItem(hDlg, IDC_MACHINE_COMBO), FALSE);
|
||
ShowWindow (GetDlgItem(hDlg, IDC_MACHINE_CAPTION), SW_SHOW);
|
||
} else {
|
||
EnableWindow (GetDlgItem(hDlg, IDC_MACHINE_COMBO), TRUE);
|
||
ShowWindow (GetDlgItem(hDlg, IDC_MACHINE_CAPTION), SW_HIDE);
|
||
}
|
||
pData->wpLastMachineSel = 0;
|
||
|
||
hExplainDlg = NULL;
|
||
|
||
SetCursor (hOldCursor);
|
||
return TRUE; // return TRUE unless you set the focus to a control
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_COMPAREITEM (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that are generated when a combo
|
||
box is searched
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window handle to the dialog box window
|
||
|
||
IN WPARAM wParam
|
||
HIWORD is the notification message ID
|
||
LOWORD is the control ID of the control issuing the command
|
||
|
||
IN LPARAM lParam
|
||
the pointer to a compare item structure
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
LPCOMPAREITEMSTRUCT pCIS = (LPCOMPAREITEMSTRUCT) lParam;
|
||
|
||
LPWSTR szString1;
|
||
LPWSTR szString2;
|
||
int nResult;
|
||
|
||
UNREFERENCED_PARAMETER (hDlg);
|
||
|
||
if (wParam == IDC_MACHINE_COMBO) {
|
||
// then process this
|
||
szString1 = (LPWSTR)pCIS->itemData1;
|
||
szString2 = (LPWSTR)pCIS->itemData2;
|
||
if ((szString1 != NULL) && (szString2 != NULL)) {
|
||
nResult = lstrcmpiW (szString1, szString2);
|
||
} else {
|
||
nResult = 0;
|
||
}
|
||
if (nResult < 0) {
|
||
// string 1 < string 2
|
||
return (BOOL)-1;
|
||
} else if (nResult > 0) {
|
||
// string 1 > string 2
|
||
return (BOOL)1;
|
||
} else {
|
||
// nResult must == 0
|
||
// string 1 == string 2
|
||
return (BOOL)0;
|
||
}
|
||
} else {
|
||
// who knows?
|
||
return (BOOL) 0;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_COMMAND (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when the user interacts
|
||
with the dialog box
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window handle to the dialog box window
|
||
|
||
IN WPARAM wParam
|
||
HIWORD is the notification message ID
|
||
LOWORD is the control ID of the control issuing the command
|
||
|
||
IN LPARAM lParam
|
||
The window handle of the controle issuing the message
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
WORD wNotifyMsg;
|
||
|
||
wNotifyMsg = HIWORD(wParam);
|
||
|
||
switch (LOWORD(wParam)) { // select on the control ID
|
||
case IDC_USE_LOCAL_MACHINE:
|
||
case IDC_SELECT_MACHINE:
|
||
return PdhiBrowseCtrDlg_MACHINE_BUTTON (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_MACHINE_COMBO:
|
||
return PdhiBrowseCtrDlg_MACHINE_COMBO (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_OBJECT_COMBO:
|
||
return PdhiBrowseCtrDlg_OBJECT_COMBO (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_ALL_INSTANCES:
|
||
case IDC_USE_INSTANCE_LIST:
|
||
return PdhiBrowseCtrDlg_INSTANCE_BUTTON (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_ALL_COUNTERS:
|
||
case IDC_USE_COUNTER_LIST:
|
||
return PdhiBrowseCtrDlg_COUNTER_BUTTON (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_COUNTER_LIST:
|
||
return PdhiBrowseCtrDlg_COUNTER_LIST (hDlg, wNotifyMsg, (HWND)lParam);
|
||
case IDC_OBJECT_LIST:
|
||
return PdhiBrowseCtrDlg_OBJECT_LIST (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_COUNTER_DETAIL_COMBO:
|
||
return PdhiBrowseCtrDlg_DETAIL_COMBO (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDOK:
|
||
return PdhiBrowseCtrDlg_OK (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDCANCEL:
|
||
return PdhiBrowseCtrDlg_CANCEL (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_EXPLAIN_BTN:
|
||
return PdhiBrowseCtrDlg_EXPLAIN_BTN (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
case IDC_HELP_BTN:
|
||
return PdhiBrowseCtrDlg_HELP_BTN (hDlg, wNotifyMsg, (HWND)lParam);
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_SYSCOMMAND (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when the user selects an
|
||
item from the system menu
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WPARAM wParam
|
||
menu ID of item selected
|
||
|
||
IN LPARAM lParam
|
||
Not Used
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
UNREFERENCED_PARAMETER(lParam);
|
||
|
||
switch (wParam) {
|
||
case SC_CLOSE:
|
||
EndDialog (hDlg, IDOK);
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_CLOSE (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs when the dialog box
|
||
is closed. No processing is needed so this function merely returns.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WPARAM wParam
|
||
Not Used
|
||
|
||
IN LPARAM lParam
|
||
Not Used
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
UNREFERENCED_PARAMETER (lParam);
|
||
UNREFERENCED_PARAMETER (wParam);
|
||
UNREFERENCED_PARAMETER (hDlg);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
STATIC_BOOL
|
||
PdhiBrowseCtrDlg_WM_DESTROY (
|
||
IN HWND hDlg,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes the windows message that occurs just before the window
|
||
is destroyed. Any memory allocations made are now freed.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WPARAM wParam
|
||
Not Used
|
||
|
||
IN LPARAM lParam
|
||
Not Used
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
PPDHI_BROWSE_DIALOG_DATA pData;
|
||
|
||
UNREFERENCED_PARAMETER (lParam);
|
||
UNREFERENCED_PARAMETER (wParam);
|
||
|
||
pData = (PPDHI_BROWSE_DIALOG_DATA)GetWindowLongPtrW(hDlg, DWLP_USER);
|
||
if (pData == NULL) {
|
||
#if PDHI_REPORT_CODE_ERRORS
|
||
REPORT_EVENT (EVENTLOG_ERROR_TYPE, PDH_EVENT_CATEGORY_DEBUG, PDH_NO_DIALOG_DATA);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
|
||
G_FREE (pData); // free memory block
|
||
return TRUE;
|
||
}
|
||
|
||
INT_PTR
|
||
CALLBACK
|
||
BrowseCounterDlgProc (
|
||
IN HWND hDlg,
|
||
IN UINT message,
|
||
IN WPARAM wParam,
|
||
IN LPARAM lParam
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Processes all windows messages that are sent to the dialog box window.
|
||
This function is the main dispatching function for the processing
|
||
of these messages.
|
||
|
||
Arguments:
|
||
|
||
IN HWND hDlg
|
||
Window Handle to the dialog box containing the button controls
|
||
|
||
IN WPARAM wParam
|
||
Not Used
|
||
|
||
IN LPARAM lParam
|
||
Not Used
|
||
|
||
Return Value:
|
||
|
||
TRUE if this function handles the message
|
||
FALSE if this function did not process the message and the Default
|
||
message handler for this function should handle the message
|
||
|
||
--*/
|
||
{
|
||
|
||
INT iCtrlID;
|
||
BOOL bReturn = FALSE;
|
||
iCtrlID = GetDlgCtrlID ( (HWND) wParam );
|
||
|
||
switch (message) {
|
||
case WM_INITDIALOG:
|
||
return PdhiBrowseCtrDlg_WM_INITDIALOG (hDlg, wParam, lParam);
|
||
|
||
case WM_COMMAND:
|
||
return PdhiBrowseCtrDlg_WM_COMMAND (hDlg, wParam, lParam);
|
||
|
||
case WM_SYSCOMMAND:
|
||
return PdhiBrowseCtrDlg_WM_SYSCOMMAND (hDlg, wParam, lParam);
|
||
|
||
case WM_CLOSE:
|
||
return PdhiBrowseCtrDlg_WM_CLOSE (hDlg, wParam, lParam);
|
||
|
||
case WM_DESTROY:
|
||
return PdhiBrowseCtrDlg_WM_DESTROY (hDlg, wParam, lParam);
|
||
|
||
case WM_COMPAREITEM:
|
||
return PdhiBrowseCtrDlg_WM_COMPAREITEM (hDlg, wParam, lParam);
|
||
|
||
case EDM_EXPLAIN_DLG_CLOSING:
|
||
hExplainDlg = NULL;
|
||
EnableWindow (GetDlgItem(hDlg, IDC_EXPLAIN_BTN), TRUE);
|
||
return TRUE;
|
||
|
||
case WM_CONTEXTMENU:
|
||
if ( 0 != iCtrlID ) {
|
||
TCHAR pszHelpFilePath[MAX_PATH * 2];
|
||
UINT nLen;
|
||
|
||
nLen = GetWindowsDirectory(pszHelpFilePath, 2*MAX_PATH);
|
||
lstrcpy(& pszHelpFilePath[nLen], _T("\\help\\sysmon.hlp"));
|
||
bReturn = WinHelp(
|
||
(HWND) wParam,
|
||
pszHelpFilePath,
|
||
HELP_CONTEXTMENU,
|
||
(DWORD_PTR) PdhiBrowseraulControlIdToHelpIdMap);
|
||
}
|
||
return bReturn;
|
||
|
||
case WM_HELP:
|
||
{
|
||
// Only display help for known context IDs.
|
||
TCHAR pszHelpFilePath[MAX_PATH * 2];
|
||
UINT nLen;
|
||
LPHELPINFO pInfo = NULL;
|
||
pInfo = (LPHELPINFO)lParam;
|
||
|
||
for (nLen = 0;
|
||
PdhiBrowseraulControlIdToHelpIdMap[nLen] != 0;
|
||
nLen +=2) {
|
||
if ( (INT) PdhiBrowseraulControlIdToHelpIdMap[nLen]
|
||
== pInfo->iCtrlId) {
|
||
break;
|
||
}
|
||
}
|
||
if (PdhiBrowseraulControlIdToHelpIdMap[nLen] != 0) {
|
||
nLen = GetWindowsDirectory(pszHelpFilePath, 2*MAX_PATH);
|
||
if ( nLen == 0 ) {
|
||
// Report error.
|
||
}
|
||
|
||
lstrcpy(&pszHelpFilePath[nLen], _T("\\help\\sysmon.hlp") );
|
||
if (pInfo->iContextType == HELPINFO_WINDOW){
|
||
bReturn = WinHelp (
|
||
pInfo->hItemHandle,
|
||
pszHelpFilePath,
|
||
HELP_WM_HELP,
|
||
(DWORD_PTR) PdhiBrowseraulControlIdToHelpIdMap);
|
||
}
|
||
}
|
||
else {
|
||
bReturn = FALSE;
|
||
}
|
||
return bReturn;
|
||
}
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|