1324 lines
39 KiB
C++
1324 lines
39 KiB
C++
/*++
|
|
|
|
Copyright (C) 1998-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ctrsprop.cpp
|
|
|
|
Abstract:
|
|
|
|
Implementation of the counters general property page.
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include <pdh.h>
|
|
#include <pdhmsg.h>
|
|
#include "smlogs.h"
|
|
#include "smcfgmsg.h"
|
|
#include "smctrqry.h"
|
|
#include "ctrsprop.h"
|
|
#include "smlogres.h"
|
|
#include <pdhp.h>
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
USE_HANDLE_MACROS("SMLOGCFG(ctrsprop.cpp)");
|
|
|
|
static ULONG
|
|
s_aulHelpIds[] =
|
|
{
|
|
IDC_CTRS_COUNTER_LIST, IDH_CTRS_COUNTER_LIST,
|
|
IDC_CTRS_ADD_BTN, IDH_CTRS_ADD_BTN,
|
|
IDC_CTRS_ADD_OBJ_BTN, IDH_CTRS_ADD_OBJ_BTN,
|
|
IDC_CTRS_REMOVE_BTN, IDH_CTRS_REMOVE_BTN,
|
|
IDC_CTRS_FILENAME_DISPLAY, IDH_CTRS_FILENAME_DISPLAY,
|
|
IDC_CTRS_SAMPLE_SPIN, IDH_CTRS_SAMPLE_EDIT,
|
|
IDC_CTRS_SAMPLE_EDIT, IDH_CTRS_SAMPLE_EDIT,
|
|
IDC_CTRS_SAMPLE_UNITS_COMBO,IDH_CTRS_SAMPLE_UNITS_COMBO,
|
|
IDC_RUNAS_EDIT, IDH_RUNAS_EDIT,
|
|
IDC_SETPWD_BTN, IDH_SETPWD_BTN,
|
|
0,0
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCountersProperty property page
|
|
|
|
IMPLEMENT_DYNCREATE(CCountersProperty, CSmPropertyPage)
|
|
|
|
CCountersProperty::CCountersProperty(MMC_COOKIE mmcCookie, LONG_PTR hConsole)
|
|
: CSmPropertyPage ( CCountersProperty::IDD, hConsole )
|
|
// lCookie is really the pointer to the Log Query object
|
|
{
|
|
//::OutputDebugStringA("\nCCountersProperty::CCountersProperty");
|
|
|
|
// save pointers from arg list
|
|
m_pCtrLogQuery = reinterpret_cast <CSmCounterLogQuery *>(mmcCookie);
|
|
|
|
ZeroMemory ( &m_dlgConfig, sizeof(m_dlgConfig) );
|
|
m_szCounterListBuffer = NULL;
|
|
m_dwCounterListBufferSize = 0;
|
|
m_lCounterListHasStars = 0;
|
|
m_dwMaxHorizListExtent = 0;
|
|
m_fHashTableSetup = FALSE;
|
|
|
|
// EnableAutomation();
|
|
//{{AFX_DATA_INIT(CCountersProperty)
|
|
m_nSampleUnits = 0;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
CCountersProperty::CCountersProperty() : CSmPropertyPage ( CCountersProperty::IDD )
|
|
{
|
|
ASSERT (FALSE); // the constructor w/ args should be used instead
|
|
}
|
|
|
|
CCountersProperty::~CCountersProperty()
|
|
{
|
|
// ::OutputDebugStringA("\nCCountersProperty::~CCountersProperty");
|
|
|
|
if (m_szCounterListBuffer != NULL) {
|
|
delete (m_szCounterListBuffer);
|
|
}
|
|
ClearCountersHashTable();
|
|
}
|
|
|
|
void CCountersProperty::OnFinalRelease()
|
|
{
|
|
// When the last reference for an automation object is released
|
|
// OnFinalRelease is called. The base class will automatically
|
|
// deletes the object. Add additional cleanup required for your
|
|
// object before calling the base class.
|
|
|
|
CPropertyPage::OnFinalRelease();
|
|
}
|
|
|
|
void CCountersProperty::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CString strTemp;
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CCountersProperty)
|
|
DDX_Text(pDX, IDC_CTRS_LOG_SCHED_TEXT, m_strStartDisplay);
|
|
ValidateTextEdit(pDX, IDC_CTRS_SAMPLE_EDIT, 6, &m_SharedData.stiSampleTime.dwValue, eMinSampleInterval, eMaxSampleInterval);
|
|
DDX_CBIndex(pDX, IDC_CTRS_SAMPLE_UNITS_COMBO, m_nSampleUnits);
|
|
DDX_Text(pDX, IDC_RUNAS_EDIT, m_strUserDisplay );
|
|
//}}AFX_DATA_MAP
|
|
|
|
if ( pDX->m_bSaveAndValidate ) {
|
|
m_SharedData.stiSampleTime.dwUnitType =
|
|
(DWORD)((CComboBox *)GetDlgItem(IDC_CTRS_SAMPLE_UNITS_COMBO))->
|
|
GetItemData(m_nSampleUnits);
|
|
}
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CCountersProperty, CSmPropertyPage)
|
|
//{{AFX_MSG_MAP(CCountersProperty)
|
|
ON_BN_CLICKED(IDC_CTRS_ADD_BTN, OnCtrsAddBtn)
|
|
ON_BN_CLICKED(IDC_CTRS_ADD_OBJ_BTN, OnCtrsAddObjBtn)
|
|
ON_BN_CLICKED(IDC_CTRS_REMOVE_BTN, OnCtrsRemoveBtn)
|
|
ON_LBN_DBLCLK(IDC_CTRS_COUNTER_LIST, OnDblclkCtrsCounterList)
|
|
ON_EN_CHANGE(IDC_CTRS_SAMPLE_EDIT, OnKillfocusSchedSampleEdit)
|
|
ON_EN_KILLFOCUS(IDC_CTRS_SAMPLE_EDIT, OnKillfocusSchedSampleEdit)
|
|
ON_EN_CHANGE( IDC_RUNAS_EDIT, OnChangeUser )
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_CTRS_SAMPLE_SPIN, OnDeltaposSchedSampleSpin)
|
|
ON_CBN_SELENDOK(IDC_CTRS_SAMPLE_UNITS_COMBO, OnSelendokSampleUnitsCombo)
|
|
ON_BN_CLICKED(IDC_SETPWD_BTN, OnPwdBtn)
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
BEGIN_DISPATCH_MAP(CCountersProperty, CSmPropertyPage)
|
|
//{{AFX_DISPATCH_MAP(CCountersProperty)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_DISPATCH_MAP
|
|
END_DISPATCH_MAP()
|
|
|
|
// Note: we add support for IID_ICountersProperty to support typesafe binding
|
|
// from VBA. This IID must match the GUID that is attached to the
|
|
// dispinterface in the .ODL file.
|
|
|
|
// {65154EA9-BDBE-11D1-BF99-00C04F94A83A}
|
|
static const IID IID_ICountersProperty =
|
|
{ 0x65154ea9, 0xbdbe, 0x11d1, { 0xbf, 0x99, 0x0, 0xc0, 0x4f, 0x94, 0xa8, 0x3a } };
|
|
|
|
BEGIN_INTERFACE_MAP(CCountersProperty, CSmPropertyPage)
|
|
INTERFACE_PART(CCountersProperty, IID_ICountersProperty, Dispatch)
|
|
END_INTERFACE_MAP()
|
|
|
|
|
|
|
|
ULONG
|
|
CCountersProperty::HashCounter(
|
|
LPTSTR szCounterName
|
|
)
|
|
{
|
|
ULONG h = 0;
|
|
ULONG a = 31415; //a, b, k are primes
|
|
const ULONG k = 16381;
|
|
const ULONG b = 27183;
|
|
LPTSTR szThisChar;
|
|
|
|
if (szCounterName) {
|
|
for (szThisChar = szCounterName; * szThisChar; szThisChar ++) {
|
|
h = (a * h + ((ULONG) (* szThisChar))) % k;
|
|
a = a * b % (k - 1);
|
|
}
|
|
}
|
|
return (h % eHashTableSize);
|
|
}
|
|
|
|
|
|
//++
|
|
// Description:
|
|
// Remove a counter path from hash table. One counter
|
|
// path must exactly match the given one in order to be
|
|
// removed, even it is one with wildcard
|
|
//
|
|
// Parameters:
|
|
// pszCounterPath - Pointer to counter path to be removed
|
|
//
|
|
// Return:
|
|
// Return TRUE if the counter path is removed, otherwis return FALSE
|
|
//--
|
|
BOOL
|
|
CCountersProperty::RemoveCounterFromHashTable(
|
|
LPTSTR szCounterName,
|
|
PPDH_COUNTER_PATH_ELEMENTS pCounterPath
|
|
)
|
|
{
|
|
ULONG lHashValue;
|
|
PHASH_ENTRY pEntry = NULL;
|
|
PHASH_ENTRY pPrev = NULL;
|
|
BOOL bReturn = FALSE;
|
|
|
|
SetLastError(ERROR_SUCCESS);
|
|
|
|
if (szCounterName == NULL || pCounterPath == NULL) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
goto ErrorOut;
|
|
}
|
|
|
|
lHashValue = HashCounter(szCounterName);
|
|
pEntry = m_HashTable[lHashValue];
|
|
|
|
//
|
|
// Check if there is a counter path which is exactly the same
|
|
// as the given one
|
|
//
|
|
while (pEntry) {
|
|
if (pEntry->pCounter == pCounterPath)
|
|
break;
|
|
pPrev = pEntry;
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
|
|
//
|
|
// If we found it, remove it
|
|
//
|
|
if (pEntry) {
|
|
if (pPrev == NULL) {
|
|
m_HashTable[lHashValue] = pEntry->pNext;
|
|
}
|
|
else {
|
|
pPrev->pNext = pEntry->pNext;
|
|
}
|
|
G_FREE(pEntry->pCounter);
|
|
G_FREE(pEntry);
|
|
bReturn = TRUE;
|
|
}
|
|
|
|
ErrorOut:
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
//++
|
|
// Description:
|
|
// Insert a counter path into hash table.
|
|
//
|
|
// Parameters:
|
|
// pszCounterPath - Pointer to counter path to be inserted
|
|
//
|
|
// Return:
|
|
// Return the pointer to new inserted PDH_COUNTER_PATH_ELEMENTS structure
|
|
//--
|
|
PPDH_COUNTER_PATH_ELEMENTS
|
|
CCountersProperty::InsertCounterToHashTable(
|
|
LPTSTR pszCounterPath
|
|
)
|
|
{
|
|
ULONG lHashValue;
|
|
PHASH_ENTRY pNewEntry = NULL;
|
|
PPDH_COUNTER_PATH_ELEMENTS pCounter = NULL;
|
|
PDH_STATUS pdhStatus;
|
|
|
|
if (pszCounterPath == NULL) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
goto ErrorOut;
|
|
}
|
|
|
|
pdhStatus = AllocInitCounterPath ( pszCounterPath, &pCounter );
|
|
|
|
if (pdhStatus != ERROR_SUCCESS) {
|
|
SetLastError( pdhStatus );
|
|
goto ErrorOut;
|
|
}
|
|
|
|
//
|
|
// Insert at head of bucket list
|
|
//
|
|
lHashValue = HashCounter(pszCounterPath);
|
|
|
|
pNewEntry = (PHASH_ENTRY) G_ALLOC(sizeof(HASH_ENTRY));
|
|
if (pNewEntry == NULL) {
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
goto ErrorOut;
|
|
}
|
|
|
|
pNewEntry->pCounter = pCounter;
|
|
pNewEntry->pNext = m_HashTable[lHashValue];
|
|
m_HashTable[lHashValue] = pNewEntry;
|
|
return pCounter;
|
|
|
|
ErrorOut:
|
|
if (pCounter != NULL)
|
|
G_FREE (pCounter);
|
|
return NULL;
|
|
}
|
|
|
|
//++
|
|
// Description:
|
|
// Check if the new counter path overlaps with a existing
|
|
// one in logical sense
|
|
//
|
|
// Parameters:
|
|
// pCounter - Pointer to counter path to be inserted
|
|
//
|
|
// Return:
|
|
// Return the relation between the new and existing counter
|
|
// paths. Possible relation is as following:
|
|
// ERROR_SUCCESS - The two counter paths are different
|
|
// SMCFG_DUPL_FIRST_IS_WILD - The first counter path has wildcard name
|
|
// SMCFG_DUPL_SECOND_IS_WILD - The second counter path has wildcard name
|
|
// SMCFG_DUPL_SINGLE_PATH - The two counter paths are the same(may
|
|
// contain wildcard)
|
|
//--
|
|
DWORD
|
|
CCountersProperty::CheckDuplicate( PPDH_COUNTER_PATH_ELEMENTS pCounter)
|
|
{
|
|
ULONG lHashValue;
|
|
PHASH_ENTRY pHead;
|
|
PHASH_ENTRY pEntry;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
for (lHashValue = 0; lHashValue < eHashTableSize; lHashValue++) {
|
|
pHead = m_HashTable[lHashValue];
|
|
if (pHead == NULL)
|
|
continue;
|
|
|
|
pEntry = pHead;
|
|
while (pEntry) {
|
|
dwStatus = CheckDuplicateCounterPaths ( pEntry->pCounter, pCounter );
|
|
if ( dwStatus != ERROR_SUCCESS ) {
|
|
return dwStatus;
|
|
}
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
}
|
|
return dwStatus;
|
|
}
|
|
|
|
//++
|
|
// Description:
|
|
// The function inserts all the current counter paths into
|
|
// hash table as a way to accelerate looking.
|
|
//
|
|
// Parameters:
|
|
// None
|
|
//
|
|
// Return:
|
|
// None
|
|
//--
|
|
void
|
|
CCountersProperty::SetupCountersHashTable( void )
|
|
{
|
|
INT iListIndex;
|
|
INT iItemCnt;
|
|
TCHAR szPath[MAX_PATH];
|
|
CListBox* pCounterList;
|
|
|
|
//
|
|
// If the hash table is already set up, return
|
|
if (m_fHashTableSetup) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Initialize the hash table
|
|
//
|
|
memset(&m_HashTable, 0, sizeof(m_HashTable));
|
|
//
|
|
// Loop throuth all the items in the list box and
|
|
// put them into hash table.
|
|
//
|
|
pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
if (pCounterList == NULL) {
|
|
return;
|
|
}
|
|
|
|
iItemCnt = pCounterList->GetCount();
|
|
|
|
if (iItemCnt != LB_ERR) {
|
|
for (iListIndex = 0; iListIndex < iItemCnt; iListIndex++) {
|
|
if (pCounterList->GetText( iListIndex, szPath ) > 0) {
|
|
InsertCounterToHashTable( szPath );
|
|
}
|
|
}
|
|
}
|
|
m_fHashTableSetup = TRUE;
|
|
}
|
|
|
|
|
|
//++
|
|
// Description:
|
|
// The function clears all the entries in hash table
|
|
// and set hash-table-not-set-up flag
|
|
//
|
|
// Parameters:
|
|
// None
|
|
//
|
|
// Return:
|
|
// None
|
|
//--
|
|
void
|
|
CCountersProperty::ClearCountersHashTable( void )
|
|
{
|
|
ULONG i;
|
|
PHASH_ENTRY pEntry;
|
|
PHASH_ENTRY pNext;
|
|
|
|
if (m_fHashTableSetup) {
|
|
for (i = 0; i < eHashTableSize; i ++) {
|
|
pNext = m_HashTable[i];
|
|
while (pNext != NULL) {
|
|
pEntry = pNext;
|
|
pNext = pEntry->pNext;
|
|
|
|
G_FREE(pEntry->pCounter);
|
|
G_FREE(pEntry);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
memset(&m_HashTable, 0, sizeof(m_HashTable));
|
|
}
|
|
m_fHashTableSetup = FALSE;
|
|
}
|
|
|
|
|
|
static
|
|
PDH_FUNCTION
|
|
DialogCallBack(CCountersProperty *pDlg)
|
|
{
|
|
// add strings in buffer to list box
|
|
LPTSTR szNewCounterName;
|
|
INT iListIndex;
|
|
INT iItemCnt;
|
|
PDH_STATUS pdhStatus = ERROR_SUCCESS;
|
|
DWORD dwReturnStatus = ERROR_SUCCESS;
|
|
CListBox *pCounterList;
|
|
DWORD dwItemExtent;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
BOOL bAtLeastOneCounterRemoved = FALSE;
|
|
BOOL bAtLeastOneCounterNotAdded = FALSE;
|
|
TCHAR szCounterPath[MAX_PATH + 1];
|
|
PPDH_COUNTER_PATH_ELEMENTS pPathInfoNew = NULL;
|
|
CDC* pCDC = NULL;
|
|
ResourceStateManager rsm;
|
|
|
|
|
|
#define CTRBUFLIMIT (0x7fffffff)
|
|
|
|
if ( PDH_MORE_DATA == pDlg->m_dlgConfig.CallBackStatus ) {
|
|
if ( pDlg->m_dlgConfig.cchReturnPathLength < CTRBUFLIMIT ) {
|
|
|
|
pDlg->m_dwCounterListBufferSize *= 2;
|
|
delete pDlg->m_szCounterListBuffer;
|
|
pDlg->m_szCounterListBuffer = NULL;
|
|
|
|
try {
|
|
pDlg->m_szCounterListBuffer = new WCHAR[pDlg->m_dwCounterListBufferSize];
|
|
|
|
} catch ( ... ) {
|
|
pDlg->m_dwCounterListBufferSize = 0;
|
|
pDlg->m_dlgConfig.CallBackStatus = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
dwReturnStatus = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
}
|
|
|
|
if ( ERROR_SUCCESS == dwReturnStatus ) {
|
|
// clear buffer
|
|
memset (pDlg->m_szCounterListBuffer, 0, pDlg->m_dwCounterListBufferSize);
|
|
|
|
pDlg->m_dlgConfig.szReturnPathBuffer = pDlg->m_szCounterListBuffer;
|
|
pDlg->m_dlgConfig.cchReturnPathLength = pDlg->m_dwCounterListBufferSize;
|
|
pDlg->m_dlgConfig.CallBackStatus = PDH_RETRY;
|
|
dwReturnStatus = PDH_RETRY;
|
|
}
|
|
} else {
|
|
pDlg->m_dlgConfig.CallBackStatus = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
dwReturnStatus = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
}
|
|
} else if ( ERROR_SUCCESS == pDlg->m_dlgConfig.CallBackStatus ) {
|
|
|
|
pCounterList = (CListBox *)pDlg->GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
|
|
pCDC = pCounterList->GetDC();
|
|
|
|
for (szNewCounterName = pDlg->m_szCounterListBuffer;
|
|
*szNewCounterName != 0;
|
|
szNewCounterName += (lstrlen(szNewCounterName) + 1)) {
|
|
|
|
//
|
|
// Parse new pathname
|
|
//
|
|
pdhStatus = pDlg->AllocInitCounterPath ( szNewCounterName, &pPathInfoNew );
|
|
|
|
//
|
|
// Check for duplicate
|
|
//
|
|
if (pdhStatus == ERROR_SUCCESS) {
|
|
dwStatus = pDlg->CheckDuplicate( pPathInfoNew);
|
|
if ( ERROR_SUCCESS != dwStatus ) {
|
|
if ( SMCFG_DUPL_SINGLE_PATH == dwStatus
|
|
|| SMCFG_DUPL_FIRST_IS_WILD == dwStatus ) {
|
|
// NOTE: This includes case where both first
|
|
// and second are wild.
|
|
bAtLeastOneCounterNotAdded = TRUE;
|
|
} else {
|
|
ASSERT( dwStatus == SMCFG_DUPL_SECOND_IS_WILD);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if there is a valid counter to add to the list
|
|
//
|
|
if ( ERROR_SUCCESS == pdhStatus &&
|
|
( ERROR_SUCCESS == dwStatus || SMCFG_DUPL_SECOND_IS_WILD == dwStatus)) {
|
|
|
|
if ( SMCFG_DUPL_SECOND_IS_WILD == dwStatus ) {
|
|
//
|
|
// Scan for the duplicated items in the list box and
|
|
// remove them
|
|
//
|
|
iItemCnt = pCounterList->GetCount();
|
|
|
|
for (iListIndex = iItemCnt-1; iListIndex >= 0; iListIndex--) {
|
|
PPDH_COUNTER_PATH_ELEMENTS pPathInfoExist;
|
|
|
|
if ( 0 < pCounterList->GetText( iListIndex, szCounterPath ) ) {
|
|
pPathInfoExist = (PPDH_COUNTER_PATH_ELEMENTS)
|
|
pCounterList->GetItemDataPtr(iListIndex);
|
|
|
|
if (pPathInfoExist == NULL)
|
|
continue;
|
|
|
|
dwStatus = CheckDuplicateCounterPaths ( pPathInfoExist, pPathInfoNew );
|
|
|
|
if (dwStatus != ERROR_SUCCESS ) {
|
|
ASSERT( dwStatus == SMCFG_DUPL_SECOND_IS_WILD );
|
|
|
|
pDlg->RemoveCounterFromHashTable(szCounterPath, pPathInfoExist);
|
|
pCounterList->DeleteString(iListIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
bAtLeastOneCounterRemoved = TRUE;
|
|
}
|
|
|
|
//
|
|
// Add new counter name and select the current entry in the list box
|
|
//
|
|
iListIndex = pCounterList->AddString(szNewCounterName);
|
|
|
|
if (iListIndex != LB_ERR) {
|
|
if (pDlg->m_lCounterListHasStars != PDLCNFIG_LISTBOX_STARS_YES) {
|
|
// save a string compare if this value is already set
|
|
if (_tcsstr (szNewCounterName, TEXT("*")) == NULL) {
|
|
pDlg->m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_YES;
|
|
}
|
|
}
|
|
|
|
if (! bAtLeastOneCounterRemoved) {
|
|
// update list box extent
|
|
if ( NULL != pCDC ) {
|
|
dwItemExtent = (DWORD)(pCDC->GetTextExtent (szNewCounterName)).cx;
|
|
if (dwItemExtent > pDlg->m_dwMaxHorizListExtent) {
|
|
pDlg->m_dwMaxHorizListExtent = dwItemExtent;
|
|
pCounterList->SetHorizontalExtent(dwItemExtent);
|
|
}
|
|
}
|
|
}
|
|
|
|
pCounterList->SetSel (-1, FALSE); // cancel existing selections
|
|
pCounterList->SetSel (iListIndex);
|
|
pCounterList->SetCaretIndex (iListIndex);
|
|
pCounterList->SetItemDataPtr(iListIndex,
|
|
(void*)pDlg->InsertCounterToHashTable(szNewCounterName));
|
|
}
|
|
}
|
|
|
|
if ( ERROR_SUCCESS != pdhStatus ) {
|
|
// Message box Pdh error message, go on to next
|
|
CString strMsg;
|
|
CString strPdhMessage;
|
|
|
|
FormatSystemMessage ( pdhStatus, strPdhMessage );
|
|
|
|
MFC_TRY
|
|
strMsg.Format ( IDS_CTRS_PDH_ERROR, szNewCounterName );
|
|
strMsg += strPdhMessage;
|
|
MFC_CATCH_MINIMUM
|
|
|
|
::AfxMessageBox( strMsg, MB_OK|MB_ICONERROR, 0 );
|
|
}
|
|
// Go on to next path to add
|
|
dwStatus = ERROR_SUCCESS;
|
|
}
|
|
|
|
if (bAtLeastOneCounterRemoved) {
|
|
//
|
|
// Clear the max extent and recalculate
|
|
//
|
|
pDlg->m_dwMaxHorizListExtent = 0;
|
|
for ( iListIndex = 0; iListIndex < pCounterList->GetCount(); iListIndex++ ) {
|
|
|
|
pCounterList->GetText(iListIndex, szCounterPath);
|
|
|
|
if ( NULL != pCDC ) {
|
|
dwItemExtent = (DWORD)(pCDC->GetTextExtent(szCounterPath)).cx;
|
|
if (dwItemExtent > pDlg->m_dwMaxHorizListExtent) {
|
|
pDlg->m_dwMaxHorizListExtent = dwItemExtent;
|
|
}
|
|
}
|
|
}
|
|
pCounterList->SetHorizontalExtent(pDlg->m_dwMaxHorizListExtent);
|
|
}
|
|
|
|
if ( NULL != pCDC ) {
|
|
pCounterList->ReleaseDC(pCDC);
|
|
pCDC = NULL;
|
|
}
|
|
|
|
// Message box re: duplicates not added, or duplicates were removed.
|
|
if ( bAtLeastOneCounterRemoved ) {
|
|
CString strMsg;
|
|
|
|
strMsg.LoadString ( IDS_CTRS_DUPL_PATH_DELETED );
|
|
|
|
::AfxMessageBox ( strMsg, MB_OK | MB_ICONWARNING, 0);
|
|
}
|
|
|
|
if ( bAtLeastOneCounterNotAdded ) {
|
|
CString strMsg;
|
|
|
|
strMsg.LoadString ( IDS_CTRS_DUPL_PATH_NOT_ADDED );
|
|
|
|
::AfxMessageBox( strMsg, MB_OK|MB_ICONWARNING, 0 );
|
|
}
|
|
|
|
// clear buffer
|
|
memset (pDlg->m_szCounterListBuffer, 0, pDlg->m_dwCounterListBufferSize);
|
|
dwReturnStatus = ERROR_SUCCESS;
|
|
} else {
|
|
// Not successful
|
|
dwReturnStatus = pDlg->m_dlgConfig.CallBackStatus;
|
|
}
|
|
|
|
return dwReturnStatus;
|
|
}
|
|
|
|
|
|
void CCountersProperty::OnPwdBtn()
|
|
{
|
|
CString strTempUser;
|
|
|
|
UpdateData(TRUE);
|
|
|
|
if (!m_bCanAccessRemoteWbem) {
|
|
ConnectRemoteWbemFail(m_pCtrLogQuery, TRUE);
|
|
return;
|
|
}
|
|
|
|
MFC_TRY
|
|
strTempUser = m_strUserDisplay;
|
|
|
|
m_strUserDisplay.TrimLeft();
|
|
m_strUserDisplay.TrimRight();
|
|
|
|
m_pCtrLogQuery->m_strUser = m_strUserDisplay;
|
|
|
|
SetRunAs(m_pCtrLogQuery);
|
|
|
|
m_strUserDisplay = m_pCtrLogQuery->m_strUser;
|
|
|
|
if ( 0 != strTempUser.CompareNoCase ( m_strUserDisplay ) ) {
|
|
SetDlgItemText ( IDC_RUNAS_EDIT, m_strUserDisplay );
|
|
}
|
|
MFC_CATCH_MINIMUM;
|
|
}
|
|
|
|
BOOL
|
|
CCountersProperty::IsValidLocalData()
|
|
{
|
|
BOOL bIsValid = TRUE;
|
|
CListBox * pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
long lNumCounters;
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
lNumCounters = pCounterList->GetCount();
|
|
if ( 0 == lNumCounters ) {
|
|
CString strMsg;
|
|
|
|
bIsValid = FALSE;
|
|
|
|
strMsg.LoadString ( IDS_CTRS_REQUIRED );
|
|
|
|
MessageBox ( strMsg, m_pCtrLogQuery->GetLogName(), MB_OK | MB_ICONERROR);
|
|
GetDlgItem ( IDC_CTRS_ADD_BTN )->SetFocus();
|
|
}
|
|
|
|
if (bIsValid) {
|
|
// Validate sample interval value
|
|
bIsValid = ValidateDWordInterval(IDC_CTRS_SAMPLE_EDIT,
|
|
m_pCtrLogQuery->GetLogName(),
|
|
(long) m_SharedData.stiSampleTime.dwValue,
|
|
eMinSampleInterval,
|
|
eMaxSampleInterval);
|
|
}
|
|
|
|
if (bIsValid) {
|
|
// Validate sample interval value and unit type
|
|
bIsValid = SampleIntervalIsInRange(
|
|
m_SharedData.stiSampleTime,
|
|
m_pCtrLogQuery->GetLogName() );
|
|
|
|
if ( !bIsValid ) {
|
|
GetDlgItem ( IDC_CTRS_SAMPLE_EDIT )->SetFocus();
|
|
}
|
|
}
|
|
|
|
return bIsValid;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCountersProperty message handlers
|
|
|
|
void
|
|
CCountersProperty::OnChangeUser()
|
|
{
|
|
//
|
|
// If you can not access remote WBEM, you can not modify RunAs info,
|
|
// changing the user name is not allowed.
|
|
//
|
|
if (m_bCanAccessRemoteWbem) {
|
|
//
|
|
// When the user hits OK in the password dialog,
|
|
// the user name might not have changed.
|
|
//
|
|
UpdateData ( TRUE );
|
|
|
|
m_strUserDisplay.TrimLeft();
|
|
m_strUserDisplay.TrimRight();
|
|
|
|
if ( 0 != m_strUserSaved.Compare ( m_strUserDisplay ) ) {
|
|
m_pCtrLogQuery->m_fDirtyPassword = PASSWORD_DIRTY;
|
|
SetModifiedPage(TRUE);
|
|
}
|
|
else {
|
|
m_pCtrLogQuery->m_fDirtyPassword &= ~PASSWORD_DIRTY;
|
|
}
|
|
//
|
|
// If default user is typed, never need to set password
|
|
//
|
|
if (m_strUserDisplay.IsEmpty() || m_strUserDisplay.GetAt(0) == L'<') {
|
|
if (m_bPwdButtonEnabled) {
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(FALSE);
|
|
m_bPwdButtonEnabled = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
if (!m_bPwdButtonEnabled) {
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(TRUE);
|
|
m_bPwdButtonEnabled = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//
|
|
// We can not modify the RunAs info, then display
|
|
// an error message and retore the original user name in RunAs
|
|
//
|
|
UpdateData(TRUE);
|
|
if (ConnectRemoteWbemFail(m_pCtrLogQuery, FALSE)) {
|
|
GetDlgItem(IDC_RUNAS_EDIT)->SetWindowText(m_strUserSaved);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnCtrsAddBtn()
|
|
{
|
|
ImplementAdd( FALSE );
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnCtrsAddObjBtn()
|
|
{
|
|
ImplementAdd( TRUE );
|
|
}
|
|
|
|
void CCountersProperty::OnCtrsRemoveBtn()
|
|
{
|
|
CListBox *pCounterList;
|
|
LONG lThisItem;
|
|
BOOL bDone;
|
|
LONG lOrigCaret;
|
|
LONG lItemStatus;
|
|
LONG lItemCount;
|
|
BOOL bChanged = FALSE;
|
|
DWORD dwItemExtent;
|
|
CString strItemText;
|
|
PPDH_COUNTER_PATH_ELEMENTS pCounter;
|
|
|
|
pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
// delete all selected items in the list box and
|
|
// set the cursor to the item above the original caret position
|
|
// or the first or last if that is out of the new range
|
|
lOrigCaret = pCounterList->GetCaretIndex();
|
|
lThisItem = 0;
|
|
bDone = FALSE;
|
|
// clear the max extent
|
|
m_dwMaxHorizListExtent = 0;
|
|
// clear the value and see if any non deleted items have a star, if so
|
|
// then set the flag back
|
|
do {
|
|
lItemStatus = pCounterList->GetSel(lThisItem);
|
|
if (lItemStatus > 0) {
|
|
// then it's selected so delete it
|
|
pCounterList->GetText(lThisItem, strItemText);
|
|
pCounter = (PPDH_COUNTER_PATH_ELEMENTS) pCounterList->GetItemDataPtr(lThisItem);
|
|
if (RemoveCounterFromHashTable(strItemText.GetBuffer(1), pCounter) == FALSE) {
|
|
ClearCountersHashTable ();
|
|
}
|
|
pCounterList->DeleteString(lThisItem);
|
|
bChanged = TRUE;
|
|
} else if (lItemStatus == 0) {
|
|
// get the text length of this item since it will stay
|
|
pCounterList->GetText(lThisItem, strItemText);
|
|
if (m_lCounterListHasStars != PDLCNFIG_LISTBOX_STARS_YES) {
|
|
// save a string compare if this value is already set
|
|
if (_tcsstr (strItemText, TEXT("*")) == NULL) {
|
|
m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_YES;
|
|
}
|
|
}
|
|
dwItemExtent = (DWORD)((pCounterList->GetDC())->GetTextExtent(strItemText)).cx;
|
|
if (dwItemExtent > m_dwMaxHorizListExtent) {
|
|
m_dwMaxHorizListExtent = dwItemExtent;
|
|
}
|
|
// then it's not selected so go to the next one
|
|
lThisItem++;
|
|
} else {
|
|
// we've run out so exit
|
|
bDone = TRUE;
|
|
}
|
|
} while (!bDone);
|
|
|
|
// update the text extent of the list box
|
|
pCounterList->SetHorizontalExtent(m_dwMaxHorizListExtent);
|
|
|
|
// see how many entries are left and update the
|
|
// caret position and the remove button state
|
|
lItemCount = pCounterList->GetCount();
|
|
if (lItemCount > 0) {
|
|
// the update the caret
|
|
if (lOrigCaret >= lItemCount) {
|
|
lOrigCaret = lItemCount-1;
|
|
} else {
|
|
// caret should be within the list
|
|
}
|
|
pCounterList->SetSel(lOrigCaret);
|
|
pCounterList->SetCaretIndex(lOrigCaret);
|
|
} else {
|
|
// the list is empty so remove caret, selection
|
|
// disable the remove button and activate the
|
|
// add button
|
|
pCounterList->SetSel(-1);
|
|
}
|
|
|
|
SetButtonState();
|
|
SetModifiedPage(bChanged);
|
|
}
|
|
|
|
void CCountersProperty::OnDblclkCtrsCounterList()
|
|
{
|
|
ImplementAdd( FALSE );
|
|
}
|
|
|
|
BOOL CCountersProperty::OnSetActive()
|
|
{
|
|
BOOL bReturn;
|
|
|
|
bReturn = CSmPropertyPage::OnSetActive();
|
|
|
|
if (bReturn) {
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
m_pCtrLogQuery->GetPropPageSharedData ( &m_SharedData );
|
|
|
|
UpdateFileNameString();
|
|
|
|
UpdateLogStartString();
|
|
|
|
m_strUserDisplay = m_pCtrLogQuery->m_strUser;
|
|
UpdateData(FALSE); //to load the edit & combo box
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL CCountersProperty::OnKillActive()
|
|
{
|
|
BOOL bContinue = TRUE;
|
|
ResourceStateManager rsm;
|
|
|
|
bContinue = CPropertyPage::OnKillActive();
|
|
|
|
if ( bContinue ) {
|
|
m_pCtrLogQuery->m_strUser = m_strUserDisplay;
|
|
bContinue = IsValidData(m_pCtrLogQuery, VALIDATE_FOCUS);
|
|
if ( bContinue ) {
|
|
m_pCtrLogQuery->SetPropPageSharedData ( &m_SharedData );
|
|
SetIsActive ( FALSE );
|
|
}
|
|
}
|
|
return bContinue;
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnCancel()
|
|
{
|
|
m_pCtrLogQuery->SyncPropPageSharedData(); // clear memory shared between property pages.
|
|
}
|
|
|
|
BOOL
|
|
CCountersProperty::OnApply()
|
|
{
|
|
CListBox * pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
long lThisCounter;
|
|
BOOL bContinue = TRUE;
|
|
WCHAR szCounterPath[MAX_PATH];
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
bContinue = UpdateData(TRUE);
|
|
|
|
if ( bContinue ) {
|
|
bContinue = IsValidData(m_pCtrLogQuery, VALIDATE_APPLY );
|
|
}
|
|
|
|
if ( bContinue ) {
|
|
bContinue = SampleTimeIsLessThanSessionTime ( m_pCtrLogQuery );
|
|
if ( !bContinue ) {
|
|
GetDlgItem ( IDC_CTRS_SAMPLE_EDIT )->SetFocus();
|
|
}
|
|
}
|
|
|
|
// Write data to the query object.
|
|
if ( bContinue ) {
|
|
|
|
ASSERT ( 0 < pCounterList->GetCount() );
|
|
|
|
// update the counter MSZ string using the counters from the list box
|
|
m_pCtrLogQuery->ResetCounterList(); // clear the old counter list
|
|
|
|
for ( lThisCounter = 0; lThisCounter < pCounterList->GetCount(); lThisCounter++ ) {
|
|
if (pCounterList->GetTextLen(lThisCounter) < MAX_PATH) {
|
|
pCounterList->GetText(lThisCounter, szCounterPath);
|
|
m_pCtrLogQuery->AddCounter(szCounterPath);
|
|
}
|
|
}
|
|
|
|
if ( bContinue ) {
|
|
|
|
// Sample interval
|
|
ASSERT ( SLQ_TT_TTYPE_SAMPLE == m_SharedData.stiSampleTime.wTimeType );
|
|
ASSERT ( SLQ_TT_DTYPE_UNITS == m_SharedData.stiSampleTime.wDataType );
|
|
|
|
bContinue = m_pCtrLogQuery->SetLogTime (&m_SharedData.stiSampleTime, (DWORD)m_SharedData.stiSampleTime.wTimeType);
|
|
|
|
// Save property page shared data.
|
|
m_pCtrLogQuery->UpdatePropPageSharedData();
|
|
|
|
if ( bContinue ) {
|
|
bContinue = UpdateService( m_pCtrLogQuery, TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bContinue ) {
|
|
bContinue = Apply(m_pCtrLogQuery);
|
|
}
|
|
|
|
if ( bContinue ){
|
|
bContinue = CPropertyPage::OnApply();
|
|
}
|
|
|
|
return bContinue;
|
|
}
|
|
|
|
void
|
|
CCountersProperty::UpdateLogStartString ()
|
|
{
|
|
eStartType eCurrentStartType;
|
|
int nResId = 0;
|
|
ResourceStateManager rsm;
|
|
|
|
eCurrentStartType = DetermineCurrentStartType();
|
|
|
|
if ( eStartManually == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_MANUALLY;
|
|
} else if ( eStartImmediately == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_IMMED;
|
|
} else if ( eStartSched == eCurrentStartType ) {
|
|
nResId = IDS_LOG_START_SCHED;
|
|
}
|
|
if ( 0 != nResId ) {
|
|
m_strStartDisplay.LoadString(nResId);
|
|
} else {
|
|
m_strStartDisplay.Empty();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void CCountersProperty::UpdateFileNameString ()
|
|
{
|
|
m_strFileNameDisplay.Empty();
|
|
|
|
// Todo: Handle failure status
|
|
// Todo: Check pointers
|
|
CreateSampleFileName (
|
|
m_pCtrLogQuery->GetLogName(),
|
|
m_pCtrLogQuery->GetLogService()->GetMachineName(),
|
|
m_SharedData.strFolderName,
|
|
m_SharedData.strFileBaseName,
|
|
m_SharedData.strSqlName,
|
|
m_SharedData.dwSuffix,
|
|
m_SharedData.dwLogFileType,
|
|
m_SharedData.dwSerialNumber,
|
|
m_strFileNameDisplay );
|
|
|
|
SetDlgItemText( IDC_CTRS_FILENAME_DISPLAY, m_strFileNameDisplay );
|
|
|
|
// Clear the selection
|
|
((CEdit*)GetDlgItem( IDC_CTRS_FILENAME_DISPLAY ))->SetSel ( -1, FALSE );
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL CCountersProperty::OnInitDialog()
|
|
{
|
|
LPWSTR szCounterName;
|
|
CListBox * pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
CComboBox *pCombo;
|
|
int nIndex;
|
|
CString strComboBoxString;
|
|
int nResult;
|
|
DWORD dwItemExtent;
|
|
PPDH_COUNTER_PATH_ELEMENTS pCounterPath;
|
|
CDC* pCDC = NULL;
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
//
|
|
// Here m_pCtrLogQuery should not be NULL, if it is,
|
|
// There must be something wrong.
|
|
//
|
|
if ( NULL == m_pCtrLogQuery ) {
|
|
return TRUE;
|
|
}
|
|
m_bCanAccessRemoteWbem = m_pCtrLogQuery->GetLogService()->CanAccessWbemRemote();
|
|
|
|
MFC_TRY
|
|
m_pCtrLogQuery->SetActivePropertyPage( this );
|
|
|
|
//load counter list box from string in counter list
|
|
pCounterList->ResetContent();
|
|
ClearCountersHashTable();
|
|
szCounterName = (LPWSTR)m_pCtrLogQuery->GetFirstCounter();
|
|
|
|
pCDC = pCounterList->GetDC();
|
|
|
|
while (szCounterName != NULL) {
|
|
|
|
nIndex = pCounterList->AddString(szCounterName);
|
|
if (nIndex < 0)
|
|
continue;
|
|
|
|
//
|
|
// Insert counter path into hash table
|
|
//
|
|
|
|
pCounterPath = InsertCounterToHashTable(szCounterName);
|
|
if (pCounterPath == NULL) {
|
|
pCounterList->DeleteString(nIndex);
|
|
continue;
|
|
}
|
|
|
|
pCounterList->SetItemDataPtr(nIndex, (void*)pCounterPath);
|
|
|
|
// update list box extent
|
|
if ( NULL != pCDC ) {
|
|
dwItemExtent = (DWORD)(pCDC->GetTextExtent (szCounterName)).cx;
|
|
if (dwItemExtent > m_dwMaxHorizListExtent) {
|
|
m_dwMaxHorizListExtent = dwItemExtent;
|
|
}
|
|
}
|
|
|
|
szCounterName = (LPWSTR)m_pCtrLogQuery->GetNextCounter();
|
|
}
|
|
|
|
if ( NULL != pCDC ) {
|
|
pCounterList->ReleaseDC(pCDC);
|
|
pCDC = NULL;
|
|
}
|
|
|
|
if (m_dwMaxHorizListExtent != 0) {
|
|
pCounterList->SetHorizontalExtent(m_dwMaxHorizListExtent);
|
|
}
|
|
|
|
if (pCounterList->GetCount() > 0) {
|
|
// select first entry
|
|
pCounterList->SetSel (0, TRUE);
|
|
pCounterList->SetCaretIndex (0, TRUE);
|
|
}
|
|
|
|
// Load the shared data to get the sample unit type selection.
|
|
m_pCtrLogQuery->GetPropPageSharedData ( &m_SharedData );
|
|
|
|
// load combo boxes
|
|
pCombo = (CComboBox *)(GetDlgItem(IDC_CTRS_SAMPLE_UNITS_COMBO));
|
|
pCombo->ResetContent();
|
|
for (nIndex = 0; nIndex < (int)dwTimeUnitComboEntries; nIndex++) {
|
|
strComboBoxString.LoadString( TimeUnitCombo[nIndex].nResId );
|
|
nResult = pCombo->InsertString (nIndex, (LPCWSTR)strComboBoxString);
|
|
ASSERT (nResult != CB_ERR);
|
|
nResult = pCombo->SetItemData (nIndex, (DWORD)TimeUnitCombo[nIndex].nData);
|
|
ASSERT (nResult != CB_ERR);
|
|
// set selected in combo box here
|
|
if ( m_SharedData.stiSampleTime.dwUnitType == (DWORD)(TimeUnitCombo[nIndex].nData)) {
|
|
m_nSampleUnits = nIndex;
|
|
nResult = pCombo->SetCurSel(nIndex);
|
|
ASSERT (nResult != CB_ERR);
|
|
}
|
|
}
|
|
|
|
CSmPropertyPage::OnInitDialog();
|
|
Initialize( m_pCtrLogQuery );
|
|
m_strUserDisplay = m_pCtrLogQuery->m_strUser;
|
|
m_strUserSaved = m_strUserDisplay;
|
|
|
|
if (m_pCtrLogQuery->GetLogService()->IsWindows2000Server()) {
|
|
CWnd* pRunAsStatic;
|
|
|
|
//
|
|
// Get the static "Run As" window, you can only call this function
|
|
// when "Run As" really exists
|
|
//
|
|
pRunAsStatic = GetRunAsWindow();
|
|
if (pRunAsStatic) {
|
|
pRunAsStatic->EnableWindow(FALSE);
|
|
}
|
|
|
|
GetDlgItem(IDC_RUNAS_EDIT)->EnableWindow(FALSE);
|
|
}
|
|
if ( m_pCtrLogQuery->GetLogService()->IsWindows2000Server() ||
|
|
m_strUserDisplay.IsEmpty() ||
|
|
m_strUserDisplay.GetAt(0) == L'<') {
|
|
|
|
GetDlgItem(IDC_SETPWD_BTN)->EnableWindow(FALSE);
|
|
m_bPwdButtonEnabled = FALSE;
|
|
}
|
|
|
|
|
|
SetHelpIds ( (DWORD*)&s_aulHelpIds );
|
|
|
|
SetButtonState();
|
|
MFC_CATCH_MINIMUM;
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnDeltaposSchedSampleSpin(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
OnDeltaposSpin(pNMHDR, pResult, &m_SharedData.stiSampleTime.dwValue, eMinSampleInterval, eMaxSampleInterval);
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnSelendokSampleUnitsCombo()
|
|
{
|
|
int nSel;
|
|
|
|
nSel = ((CComboBox *)GetDlgItem(IDC_CTRS_SAMPLE_UNITS_COMBO))->GetCurSel();
|
|
|
|
if ((nSel != LB_ERR) && (nSel != m_nSampleUnits)) {
|
|
UpdateData ( TRUE );
|
|
SetModifiedPage ( TRUE );
|
|
}
|
|
}
|
|
|
|
void
|
|
CCountersProperty::OnKillfocusSchedSampleEdit()
|
|
{
|
|
DWORD dwOldValue;
|
|
dwOldValue = m_SharedData.stiSampleTime.dwValue;
|
|
UpdateData ( TRUE );
|
|
if (dwOldValue != m_SharedData.stiSampleTime.dwValue ) {
|
|
SetModifiedPage(TRUE);
|
|
}
|
|
}
|
|
|
|
void CCountersProperty::PostNcDestroy()
|
|
{
|
|
// delete this;
|
|
|
|
if ( NULL != m_pCtrLogQuery ) {
|
|
m_pCtrLogQuery->SetActivePropertyPage( NULL );
|
|
}
|
|
|
|
CPropertyPage::PostNcDestroy();
|
|
}
|
|
|
|
//
|
|
// Helper functions.
|
|
//
|
|
void
|
|
CCountersProperty::ImplementAdd( BOOL bShowObjects )
|
|
{
|
|
CListBox *pCounterList;
|
|
LONG lBeforeCount;
|
|
LONG lAfterCount;
|
|
CString strBrowseTitle;
|
|
|
|
ResourceStateManager rsm;
|
|
|
|
if (m_szCounterListBuffer == NULL) {
|
|
CString strDefaultPath;
|
|
CString strObjCounter;
|
|
|
|
try {
|
|
strObjCounter.LoadString ( IDS_DEFAULT_PATH_OBJ_CTR );
|
|
m_dwCounterListBufferSize = 0x4000;
|
|
m_szCounterListBuffer = new WCHAR[m_dwCounterListBufferSize];
|
|
if ( ((CSmLogService*)m_pCtrLogQuery->GetLogService())->IsLocalMachine() ) {
|
|
strDefaultPath = _T("\\");
|
|
} else {
|
|
strDefaultPath = _T("\\\\");
|
|
strDefaultPath += ((CSmLogService*)m_pCtrLogQuery->GetLogService())->GetMachineName();
|
|
}
|
|
strDefaultPath += strObjCounter;
|
|
lstrcpy ( m_szCounterListBuffer, strDefaultPath);
|
|
} catch ( ... ) {
|
|
m_dwCounterListBufferSize = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
m_dlgConfig.bIncludeInstanceIndex = 1;
|
|
m_dlgConfig.bSingleCounterPerAdd = 0;
|
|
m_dlgConfig.bSingleCounterPerDialog = 0;
|
|
m_dlgConfig.bLocalCountersOnly = 0;
|
|
|
|
// allow wild cards.
|
|
// the log service should expand them if necessary.
|
|
m_dlgConfig.bWildCardInstances = 1;
|
|
|
|
m_dlgConfig.bHideDetailBox = 1;
|
|
m_dlgConfig.bInitializePath = 1;
|
|
m_dlgConfig.bDisableMachineSelection = 0;
|
|
m_dlgConfig.bIncludeCostlyObjects = 0;
|
|
m_dlgConfig.bReserved = 0;
|
|
|
|
m_dlgConfig.hWndOwner = this->m_hWnd;
|
|
m_dlgConfig.szDataSource = NULL;
|
|
|
|
m_dlgConfig.szReturnPathBuffer = m_szCounterListBuffer;
|
|
m_dlgConfig.cchReturnPathLength = m_dwCounterListBufferSize;
|
|
m_dlgConfig.pCallBack = (CounterPathCallBack)DialogCallBack;
|
|
m_dlgConfig.dwDefaultDetailLevel = PERF_DETAIL_WIZARD;
|
|
m_dlgConfig.dwCallBackArg = (UINT_PTR)this;
|
|
m_dlgConfig.CallBackStatus = ERROR_SUCCESS;
|
|
m_dlgConfig.bShowObjectBrowser = (bShowObjects ? 1 : 0);
|
|
|
|
strBrowseTitle.LoadString (bShowObjects ? IDS_ADD_OBJECTS
|
|
: IDS_ADD_COUNTERS);
|
|
m_dlgConfig.szDialogBoxCaption = strBrowseTitle.GetBuffer( strBrowseTitle.GetLength() );
|
|
|
|
pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
// get count of items in the list box before calling the browser
|
|
lBeforeCount = pCounterList->GetCount();
|
|
|
|
PdhBrowseCounters (&m_dlgConfig);
|
|
|
|
strBrowseTitle.ReleaseBuffer();
|
|
|
|
// get count of items in the list box After calling the browser
|
|
// to see if the Apply button should enabled
|
|
lAfterCount = pCounterList->GetCount();
|
|
|
|
if (lAfterCount > lBeforeCount)
|
|
SetModifiedPage(TRUE);
|
|
|
|
// see if the remove button should be enabled
|
|
SetButtonState();
|
|
|
|
delete m_szCounterListBuffer;
|
|
m_szCounterListBuffer = NULL;
|
|
m_dwCounterListBufferSize = 0;
|
|
}
|
|
|
|
void
|
|
CCountersProperty::SetButtonState ()
|
|
{
|
|
BOOL bCountersExist;
|
|
CListBox *pCounterList;
|
|
|
|
pCounterList = (CListBox *)GetDlgItem(IDC_CTRS_COUNTER_LIST);
|
|
bCountersExist = ( 0 < pCounterList->GetCount()) ? TRUE : FALSE;
|
|
|
|
GetDlgItem(IDC_CTRS_SAMPLE_CAPTION)->EnableWindow(bCountersExist);
|
|
GetDlgItem(IDC_CTRS_SAMPLE_INTERVAL_CAPTION)->EnableWindow(bCountersExist);
|
|
GetDlgItem(IDC_CTRS_SAMPLE_EDIT)->EnableWindow(bCountersExist);
|
|
GetDlgItem(IDC_CTRS_SAMPLE_SPIN)->EnableWindow(bCountersExist);
|
|
GetDlgItem(IDC_CTRS_SAMPLE_UNITS_CAPTION)->EnableWindow(bCountersExist);
|
|
GetDlgItem(IDC_CTRS_SAMPLE_UNITS_COMBO)->EnableWindow(bCountersExist);
|
|
|
|
GetDlgItem(IDC_CTRS_REMOVE_BTN)->EnableWindow(bCountersExist);
|
|
if ( bCountersExist ) {
|
|
GetDlgItem(IDC_CTRS_ADD_BTN)->SetFocus();
|
|
}
|
|
}
|