able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/perflog/pdlcnfig/setpage.cpp

1094 lines
31 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// SettingsPage.cpp : implementation file
//
#include "stdafx.h"
#include "pdlcnfig.h"
#include "SetPage.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CSettingsPropPage property page
IMPLEMENT_DYNCREATE(CSettingsPropPage, CPropertyPage)
CSettingsPropPage::CSettingsPropPage() : CPropertyPage(CSettingsPropPage::IDD)
{
//{{AFX_DATA_INIT(CSettingsPropPage)
m_IntervalTime = 0;
m_SettingsFile = _T("");
m_IntervalUnitsIndex = -1;
//}}AFX_DATA_INIT
m_hKeyLogSettingsDefault = NULL;
m_hKeyLogService = NULL;
// counter buffer
m_szCounterListBuffer = NULL;
m_dwCounterListBufferSize = 0;
// list box information
m_dwMaxHorizListExtent = 0;
m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_DONT_KNOW;
// prototype use only
bServiceStopped = TRUE;
bServicePaused = FALSE;
m_bInitialized = FALSE;
}
CSettingsPropPage::~CSettingsPropPage()
{
if (m_hKeyLogSettingsDefault != NULL) RegCloseKey(m_hKeyLogSettingsDefault);
if (m_hKeyLogService != NULL) RegCloseKey(m_hKeyLogService);
}
void CSettingsPropPage::DoDataExchange(CDataExchange* pDX)
{
CPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CSettingsPropPage)
DDX_Text(pDX, IDC_INTERVAL_TIME, m_IntervalTime);
DDX_CBIndex(pDX, IDC_INTERVAL_UNITS, m_IntervalUnitsIndex);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CSettingsPropPage, CPropertyPage)
//{{AFX_MSG_MAP(CSettingsPropPage)
ON_BN_CLICKED(IDC_BROWSE_COUNTERS, OnBrowseCounters)
ON_BN_CLICKED(IDC_MAN_START, OnManStart)
ON_BN_CLICKED(IDC_MAN_STOP, OnManStop)
ON_BN_CLICKED(IDC_REMOVE, OnRemove)
ON_BN_CLICKED(IDC_SERVICE_AUTO, OnServiceAuto)
ON_BN_CLICKED(IDC_SERVICE_MAN, OnServiceMan)
ON_NOTIFY(UDN_DELTAPOS, IDC_INTERVAL_SPIN, OnDeltaposIntervalSpin)
ON_CBN_SELCHANGE(IDC_INTERVAL_UNITS, OnSelchangeIntervalUnits)
ON_BN_CLICKED(IDC_REMOVE_SERVICE, OnRemoveService)
ON_EN_CHANGE(IDC_INTERVAL_TIME, OnChangeIntervalTime)
//}}AFX_MSG_MAP
ON_MESSAGE (PSM_QUERYSIBLINGS, OnQuerySiblings)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CSettingsPropPage Helper Functions
void CSettingsPropPage::InitDialogData (void)
{
LONG lStatus = ERROR_INVALID_FUNCTION;
DWORD dwRegValType;
DWORD dwRegValue;
DWORD dwRegValueSize;
DWORD dwIndex;
if (m_bInitialized) return;
if (m_hKeyLogService == NULL) {
// open registry key to service
lStatus = RegOpenKeyEx (
HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Services\\PerfDataLog"),
0,
KEY_READ | KEY_WRITE,
&m_hKeyLogService);
}
if ((m_hKeyLogSettingsDefault == NULL) &&
(m_hKeyLogService != NULL)) {
// open registry to default log query
lStatus = RegOpenKeyEx (
m_hKeyLogService,
TEXT("Log Queries\\Default"),
0,
KEY_READ | KEY_WRITE,
&m_hKeyLogSettingsDefault);
}
if (lStatus != ERROR_SUCCESS) {
return;
// display error, close dialog and exit
}
// continue
// set sample time
if (m_IntervalTime == 0) {
dwRegValType = 0;
dwRegValue = 0;
dwRegValueSize = sizeof(DWORD);
lStatus = RegQueryValueEx (
m_hKeyLogSettingsDefault,
TEXT("Sample Interval"),
NULL,
&dwRegValType,
(LPBYTE)&dwRegValue,
&dwRegValueSize);
if ((lStatus == ERROR_SUCCESS) &&
(dwRegValType == REG_DWORD)) {
if ((dwRegValue % SECONDS_IN_DAY) == 0) {
// then this is in days so scale
dwRegValue /= SECONDS_IN_DAY;
dwIndex = SIU_DAYS;
} else if ((dwRegValue % SECONDS_IN_HOUR) == 0) {
// scale to hours
dwRegValue /= SECONDS_IN_HOUR;
dwIndex = SIU_HOURS;
} else if ((dwRegValue % SECONDS_IN_MINUTE) == 0) {
// scale to minutes
dwRegValue /= SECONDS_IN_MINUTE;
dwIndex = SIU_MINUTES;
} else {
// use as seconds
dwIndex = SIU_SECONDS;
}
// check for zero values & apply default if found
if (dwRegValue == 0) {
dwRegValue = 15; // default is 15 sec.
dwIndex = SIU_SECONDS;
}
} else {
// load default values
dwRegValue = 15;
dwIndex = SIU_SECONDS;
}
m_IntervalTime = dwRegValue;
m_IntervalUnitsIndex = dwIndex;
}
return;
}
afx_msg LRESULT CSettingsPropPage::OnQuerySiblings (WPARAM wParam, LPARAM lParam)
{
switch (wParam) {
case PDLCNFIG_PSM_QS_LISTBOX_STARS:
return m_lCounterListHasStars;
case PDLCNFIG_PSM_QS_ARE_YOU_READY:
if (!m_bInitialized) {
InitDialogData();
}
return 0;
default:
return 0; // to pass to the next property page
}
}
LONG CSettingsPropPage::GetCounterListStarInfo (void)
{
return m_lCounterListHasStars;
}
LONG CSettingsPropPage::SetCurrentServiceState (DWORD dwNewState)
{
SC_HANDLE hSC = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS ssData;
DWORD dwTimeout = 20;
BOOL bStopped, bPaused;
LONG lStatus;
HCURSOR hOrigCursor;
hOrigCursor = ::SetCursor(::LoadCursor(NULL, IDC_WAIT));
// open SC database
hSC = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSC == NULL) {
lStatus = GetLastError();
ASSERT (lStatus != ERROR_SUCCESS);
}
// open service
hService = OpenService (hSC, TEXT("PerfDataLog"),
SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE);
if (hService != NULL) {
switch (dwNewState) {
case LOG_SERV_START:
StartService (hService, 0, NULL);
// wait for the service to start before returning
while (--dwTimeout) {
GetCurrentServiceState (&bStopped, &bPaused);
if (bStopped) {
Sleep(500);
} else {
break;
}
}
break;
case LOG_SERV_STOP:
ControlService (hService, SERVICE_CONTROL_STOP, &ssData);
// wait for the service to stop before returning
while (--dwTimeout) {
GetCurrentServiceState (&bStopped, &bPaused);
if (!bStopped) {
Sleep(500);
} else {
break;
}
}
break;
case LOG_SERV_PAUSE:
ControlService (hService, SERVICE_CONTROL_PAUSE, &ssData);
// wait for the service to start pause returning
while (--dwTimeout) {
GetCurrentServiceState (&bStopped, &bPaused);
if (!bPaused) {
Sleep(500);
} else {
break;
}
}
break;
case LOG_SERV_RESUME:
ControlService (hService, SERVICE_CONTROL_CONTINUE, &ssData);
// wait for the service to start before returning
while (--dwTimeout) {
GetCurrentServiceState (&bStopped, &bPaused);
if (bPaused) {
Sleep(500);
} else {
break;
}
}
break;
default:
// no change if not recognized
break;
}
CloseServiceHandle (hService);
} else {
lStatus = GetLastError();
ASSERT (lStatus != 0);
}
// close handles
if (hSC != NULL) CloseServiceHandle (hSC);
::SetCursor (hOrigCursor);
return ERROR_SUCCESS;
}
LONG CSettingsPropPage::GetCurrentServiceState (BOOL * bStopped, BOOL * bPaused)
{
SC_HANDLE hSC = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS ssData;
LONG lStatus;
HCURSOR hOrigCursor;
BOOL bServiceStopped, bServicePaused;
hOrigCursor = ::SetCursor(::LoadCursor(NULL, IDC_WAIT));
bServiceStopped = TRUE;
bServicePaused = TRUE;
// open SC database
hSC = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSC == NULL) {
lStatus = GetLastError();
ASSERT (lStatus != ERROR_SUCCESS);
}
// open service
hService = OpenService (hSC, TEXT("PerfDataLog"), SERVICE_INTERROGATE);
// get service status
if (hService != NULL) {
if (ControlService (
hService, SERVICE_CONTROL_INTERROGATE,
&ssData)) {
switch (ssData.dwCurrentState) {
case SERVICE_STOPPED:
bServiceStopped = TRUE;
bServicePaused = FALSE;
break;
case SERVICE_START_PENDING:
bServiceStopped = TRUE;
bServicePaused = FALSE;
break;
case SERVICE_STOP_PENDING:
bServiceStopped = FALSE;
bServicePaused = FALSE;
break;
case SERVICE_RUNNING:
bServiceStopped = FALSE;
bServicePaused = FALSE;
break;
case SERVICE_CONTINUE_PENDING:
bServiceStopped = FALSE;
bServicePaused = FALSE;
break;
case SERVICE_PAUSE_PENDING:
bServiceStopped = FALSE;
bServicePaused = FALSE;
break;
case SERVICE_PAUSED:
bServiceStopped = FALSE;
bServicePaused = TRUE;
break;
default:
bServiceStopped = TRUE;
bServicePaused = TRUE;
;// no op
}
} else {
bServiceStopped = TRUE;
bServicePaused = TRUE;
}
CloseServiceHandle (hService);
} else {
lStatus = GetLastError();
ASSERT (lStatus != 0);
}
*bStopped = bServiceStopped;
*bPaused = bServicePaused;
// close handles
if (hSC != NULL) CloseServiceHandle (hSC);
::SetCursor (hOrigCursor);
return ERROR_SUCCESS;
}
UINT
ConnectMachineThreadProc (LPVOID lpArg)
{
return PdhConnectMachine (NULL);
}
LONG CSettingsPropPage::SyncServiceStartWithButtons(void)
{
SC_HANDLE hSC = NULL;
SC_HANDLE hService = NULL;
DWORD dwMoreBytes = 0;
BOOL bManualEnabled = FALSE;
BOOL bUpdate = FALSE;
LONG lStatus;
QUERY_SERVICE_CONFIG qsConfig;
HCURSOR hOrigCursor;
hOrigCursor = ::SetCursor(LoadCursor(NULL, IDC_WAIT));
// get button state
if (IsDlgButtonChecked(IDC_SERVICE_MAN)) {
bManualEnabled = TRUE;
}
// open SC database
hSC = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSC == NULL) {
lStatus = GetLastError();
ASSERT (lStatus != ERROR_SUCCESS);
}
// open service
hService = OpenService (hSC, TEXT("PerfDataLog"),
SERVICE_CHANGE_CONFIG | SERVICE_QUERY_CONFIG);
if (hService != NULL) {
// get current config
memset (&qsConfig, 0, sizeof(qsConfig));
if (QueryServiceConfig (hService, &qsConfig,
sizeof(qsConfig), &dwMoreBytes)) {
// see if the current status is different
// from the selection. if it is, then change
// the current mode.
if (bManualEnabled) {
if (qsConfig.dwStartType == SERVICE_AUTO_START) {
bUpdate = TRUE;
}
} else {
// auto start selected
if (qsConfig.dwStartType == SERVICE_DEMAND_START) {
bUpdate = TRUE;
}
}
} else {
// else unable to read the current status so update anyway
bUpdate = TRUE;
}
if (bUpdate) {
ChangeServiceConfig (
hService,
SERVICE_NO_CHANGE,
(bManualEnabled ? SERVICE_DEMAND_START : SERVICE_AUTO_START),
SERVICE_NO_CHANGE,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
}
CloseServiceHandle (hService);
} else {
lStatus = GetLastError();
ASSERT (lStatus != 0);
}
// close handles
if (hSC != NULL) CloseServiceHandle (hSC);
::SetCursor (hOrigCursor);
return ERROR_SUCCESS;
}
void CSettingsPropPage::UpdateManualButtonsState()
{
BOOL bServiceIsStopped;
BOOL bServiceIsPaused;
LONG lStatus;
BOOL bManualEnabled;
if (IsDlgButtonChecked(IDC_SERVICE_AUTO)) {
bManualEnabled = FALSE;
} else if (IsDlgButtonChecked(IDC_SERVICE_MAN)) {
bManualEnabled = TRUE;
} else {
// if no button is checked, then check the auto
// button and continue
CheckRadioButton (IDC_SERVICE_AUTO, IDC_SERVICE_MAN, IDC_SERVICE_AUTO);
bManualEnabled = FALSE;
}
GetDlgItem(IDC_MAN_START)->EnableWindow(bManualEnabled);
GetDlgItem(IDC_MAN_STOP)->EnableWindow(bManualEnabled);
if (bManualEnabled) {
// check with service controller to get the current state of the service
lStatus = GetCurrentServiceState (&bServiceIsStopped, &bServiceIsPaused);
GetDlgItem(IDC_MAN_START)->EnableWindow(bServiceIsStopped);
GetDlgItem(IDC_MAN_STOP)->EnableWindow(!bServiceIsStopped);
}
}
static void DialogCallBack(CSettingsPropPage *pDlg)
{
// add strings in buffer to list box
LPTSTR NewCounterName;
LRESULT lIndex;
PDH_STATUS pdhStatus;
CListBox *cCounterList;
DWORD dwItemExtent;
cCounterList = (CListBox *)pDlg->GetDlgItem(IDC_COUNTER_LIST);
for (NewCounterName = pDlg->m_szCounterListBuffer;
*NewCounterName != 0;
NewCounterName += (lstrlen(NewCounterName) + 1)) {
pdhStatus = PdhValidatePath(NewCounterName);
if (pdhStatus == ERROR_SUCCESS) {
// this is a valid counter so add it to the list
lIndex = cCounterList->AddString(NewCounterName);
// select the current entry in the list box
if (lIndex != LB_ERR) {
if (pDlg->m_lCounterListHasStars != PDLCNFIG_LISTBOX_STARS_YES) {
// save a string compare if this value is already set
if (_tcsstr (NewCounterName, TEXT("*")) == NULL) {
pDlg->m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_YES;
}
}
// update list box extent
dwItemExtent = (DWORD)((cCounterList->GetDC())->GetTextExtent (NewCounterName)).cx;
if (dwItemExtent > pDlg->m_dwMaxHorizListExtent) {\
pDlg->m_dwMaxHorizListExtent = dwItemExtent;
cCounterList->SetHorizontalExtent(dwItemExtent);
}
cCounterList->SetSel (-1, FALSE); // cancel existing selections
cCounterList->SetSel ((int)lIndex);
cCounterList->SetCaretIndex ((int)lIndex);
}
} else {
MessageBeep (MB_ICONEXCLAMATION);
}
}
// clear buffer
memset (pDlg->m_szCounterListBuffer, 0, pDlg->m_dwCounterListBufferSize);
}
/////////////////////////////////////////////////////////////////////////////
// CSettingsPropPage message handlers
BOOL CSettingsPropPage::OnInitDialog()
{
LONG lStatus;
DWORD dwRegValType;
DWORD dwRegValue;
DWORD dwRegValueSize;
DWORD dwIndex;
LPTSTR mszCounterPathList;
LPTSTR szThisCounterPath;
CListBox *cCounterList;
DWORD dwItemExtent;
InitDialogData();
// now init other pages
QuerySiblings (PDLCNFIG_PSM_QS_ARE_YOU_READY, 0);
// start machine connection thread to make initial "ADD" dialog
// "snappier"
// AfxBeginThread ((AFX_THREADPROC)ConnectMachineThreadProc, NULL);
// initialize the service state
dwRegValType = 0;
dwRegValue = 0;
dwRegValueSize = sizeof(DWORD);
lStatus = RegQueryValueEx (
m_hKeyLogService,
TEXT("Start"),
NULL,
&dwRegValType,
(LPBYTE)&dwRegValue,
&dwRegValueSize);
if ((lStatus == ERROR_SUCCESS) &&
(dwRegValType == REG_DWORD) &&
(dwRegValue == SERVICE_DEMAND_START)) {
// then set manual control
CheckRadioButton (IDC_SERVICE_AUTO,
IDC_SERVICE_MAN, IDC_SERVICE_MAN);
} else {
// set automatic control (default)
CheckRadioButton (IDC_SERVICE_AUTO,
IDC_SERVICE_MAN, IDC_SERVICE_AUTO);
}
// set manual buttons to reflect current state of control
UpdateManualButtonsState();
// load counter list box
GetDlgItem(IDC_COUNTER_LIST)->SendMessage(LB_RESETCONTENT, 0, 0);
// read path string from registry
// find out buffer size required
dwRegValType = 0;
dwRegValue = 0;
dwRegValueSize = 0;
lStatus = RegQueryValueEx (
m_hKeyLogSettingsDefault,
TEXT("Counter List"),
NULL,
&dwRegValType,
NULL,
&dwRegValueSize);
cCounterList = (CListBox *)GetDlgItem(IDC_COUNTER_LIST);
if (dwRegValueSize > 0) {
// allocate buffer
mszCounterPathList = new TCHAR[dwRegValueSize/sizeof(TCHAR)];
ASSERT (mszCounterPathList != NULL);
*mszCounterPathList = 0;
dwRegValType = 0;
dwRegValue = 0;
lStatus = RegQueryValueEx (
m_hKeyLogSettingsDefault,
TEXT("Counter List"),
NULL,
&dwRegValType,
(LPBYTE)mszCounterPathList,
&dwRegValueSize);
if (lStatus != ERROR_SUCCESS) {
// assign a MSZ termination
mszCounterPathList[0] = 0;
mszCounterPathList[1] = 0;
}
// load list box.
dwIndex = 0;
cCounterList->ResetContent();
for (szThisCounterPath = mszCounterPathList;
*szThisCounterPath != 0;
szThisCounterPath += lstrlen(szThisCounterPath)+1) {
lStatus = cCounterList->AddString (szThisCounterPath);
if (lStatus != LB_ERR) {
if (m_lCounterListHasStars != PDLCNFIG_LISTBOX_STARS_YES) {
// save a string compare if this value is already set
if (_tcsstr (szThisCounterPath, TEXT("*")) == NULL) {
m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_YES;
}
}
dwItemExtent = (DWORD)((cCounterList->GetDC())->GetTextExtent (szThisCounterPath)).cx;
if (dwItemExtent > m_dwMaxHorizListExtent) {
m_dwMaxHorizListExtent = dwItemExtent;
cCounterList->SetHorizontalExtent(dwItemExtent);
}
dwIndex++;
}
}
cCounterList->SetSel(dwIndex-1);
cCounterList->SetCaretIndex(dwIndex-1);
delete mszCounterPathList;
} else {
// no counters presently in the list so just initialize everything
cCounterList->ResetContent();
}
// select first counter in list (if present)
if (GetDlgItem(IDC_COUNTER_LIST)->SendMessage(LB_GETCOUNT) > 0) {
GetDlgItem(IDC_COUNTER_LIST)->SendMessage(LB_SETCURSEL, 0, 0);
// highlight remove button if an item is selected
GetDlgItem(IDC_REMOVE)->EnableWindow (TRUE);
} else {
GetDlgItem(IDC_REMOVE)->EnableWindow (FALSE);
}
if (m_lCounterListHasStars == PDLCNFIG_LISTBOX_STARS_DONT_KNOW) {
// if here and the value hasn't been changed, then that means
// there are no wild card entries in the list box
m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_NO;
}
CPropertyPage::OnInitDialog();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CSettingsPropPage::OnBrowseCounters()
{
PDH_BROWSE_DLG_CONFIG dlgConfig;
CListBox *cCounterList;
LONG lBeforeCount;
LONG lAfterCount;
LRESULT lWildCardOk;
DWORD dwRegValType;
DWORD dwRegValue;
DWORD dwRegValueSize;
LONG lStatus;
if (m_szCounterListBuffer == NULL) {
m_dwCounterListBufferSize = 16384;
m_szCounterListBuffer = new TCHAR[m_dwCounterListBufferSize];
}
dlgConfig.bIncludeInstanceIndex = 0;
dlgConfig.bSingleCounterPerAdd = 0;
dlgConfig.bSingleCounterPerDialog = 0;
dlgConfig.bLocalCountersOnly = 0;
lWildCardOk = QuerySiblings (PDLCNFIG_PSM_QS_WILDCARD_LOG, 0);
if ( lWildCardOk == PDLCNFIG_WILDCARD_LOG_YES) {
dlgConfig.bWildCardInstances = 1;
} else if (lWildCardOk == PDLCNFIG_WILDCARD_LOG_DONT_KNOW ){
// the property page doesn't know so ask the registry
// read log file format
dwRegValType = 0;
dwRegValue = 0;
dwRegValueSize = sizeof(DWORD);
lStatus = RegQueryValueEx (
m_hKeyLogSettingsDefault,
TEXT("Log File Type"),
NULL,
&dwRegValType,
(LPBYTE)&dwRegValue,
&dwRegValueSize);
if (lStatus != ERROR_SUCCESS) {
// then apply default value
dwRegValue = OPD_CSV_FILE;
}
switch (dwRegValue) {
case OPD_BIN_FILE:
// the current log file does support wildcards
dlgConfig.bWildCardInstances = 1;
break;
case OPD_CSV_FILE:
case OPD_TSV_FILE:
default:
// the current log file doesn't support wildcards
dlgConfig.bWildCardInstances = 0;
break;
}
} else {
// the current log file doesn't support wildcards
dlgConfig.bWildCardInstances = 0;
}
dlgConfig.bHideDetailBox = 0;
dlgConfig.bInitializePath = 0;
dlgConfig.bDisableMachineSelection = 0;
dlgConfig.bIncludeCostlyObjects = 0;
dlgConfig.bReserved = 0;
dlgConfig.hWndOwner = this->m_hWnd;
dlgConfig.szDataSource = NULL;
dlgConfig.szReturnPathBuffer = m_szCounterListBuffer;
dlgConfig.cchReturnPathLength = m_dwCounterListBufferSize;
dlgConfig.pCallBack = (CounterPathCallBack)DialogCallBack;
dlgConfig.dwDefaultDetailLevel = PERF_DETAIL_WIZARD;
dlgConfig.dwCallBackArg = (DWORD_PTR)this;
dlgConfig.szDialogBoxCaption = TEXT("Select Counters To Log");
cCounterList = (CListBox *)GetDlgItem(IDC_COUNTER_LIST);
// get count of items in the list box before calling the browser
lBeforeCount = cCounterList->GetCount();
PdhBrowseCounters (&dlgConfig);
// get count of items in the list box After calling the browser
// to see if the Apply button should enabled
lAfterCount = cCounterList->GetCount();
if (lAfterCount > lBeforeCount) SetModified(TRUE);
// see if the remove button should be enabled
GetDlgItem (IDC_REMOVE)->EnableWindow(
lAfterCount > 0 ? TRUE : FALSE);
delete m_szCounterListBuffer;
m_szCounterListBuffer = NULL;
m_dwCounterListBufferSize = 0;
}
void CSettingsPropPage::OnManStart()
{
SetCurrentServiceState (LOG_SERV_START);
UpdateManualButtonsState();
// set focus to stop button
GetDlgItem(IDC_MAN_STOP)->SetFocus();
}
void CSettingsPropPage::OnManStop()
{
SetCurrentServiceState (LOG_SERV_STOP);
UpdateManualButtonsState();
// set focus to start button
GetDlgItem(IDC_MAN_START)->SetFocus();
}
void CSettingsPropPage::OnRemove()
{
CListBox *cCounterList;
LONG lThisItem;
BOOL bDone;
LONG lOrigCaret;
LONG lItemStatus;
LONG lItemCount;
BOOL bChanged = FALSE;
DWORD dwItemExtent;
CString csItemText;
cCounterList = (CListBox *)GetDlgItem(IDC_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 = cCounterList->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 = cCounterList->GetSel(lThisItem);
if (lItemStatus > 0) {
// then it's selected so delete it
cCounterList->DeleteString(lThisItem);
bChanged = TRUE;
} else if (lItemStatus == 0) {
// get the text length of this item since it will stay
cCounterList->GetText(lThisItem, csItemText);
if (m_lCounterListHasStars != PDLCNFIG_LISTBOX_STARS_YES) {
// save a string compare if this value is already set
if (_tcsstr (csItemText, TEXT("*")) == NULL) {
m_lCounterListHasStars = PDLCNFIG_LISTBOX_STARS_YES;
}
}
dwItemExtent = (DWORD)((cCounterList->GetDC())->GetTextExtent(csItemText)).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
cCounterList->SetHorizontalExtent(m_dwMaxHorizListExtent);
// see how many entries are left and update the
// caret position and the remove button state
lItemCount = cCounterList->GetCount();
if (lItemCount > 0) {
// the update the caret
if (lOrigCaret >= lItemCount) {
lOrigCaret = lItemCount-1;
} else {
// caret should be within the list
}
cCounterList->SetSel(lOrigCaret);
cCounterList->SetCaretIndex(lOrigCaret);
} else {
// the list is empty so remove caret, selection
// disable the remove button and activate the
// add button
cCounterList->SetSel(-1);
GetDlgItem(IDC_BROWSE_COUNTERS)->SetFocus();
GetDlgItem(IDC_REMOVE)->EnableWindow(FALSE);
}
SetModified(bChanged);
}
void CSettingsPropPage::OnServiceAuto()
{
// set service to AutoStart
UpdateManualButtonsState();
SetModified(TRUE);
}
void CSettingsPropPage::OnServiceMan()
{
// set service to manual Start
UpdateManualButtonsState();
SetModified(TRUE);
}
void CSettingsPropPage::OnDeltaposIntervalSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
TCHAR szStringValue[MAX_PATH];
DWORD dwNumValue;
int nChange;
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// get current value from edit window
GetDlgItemText (IDC_INTERVAL_TIME, szStringValue, MAX_PATH);
// convert to integer
dwNumValue = _tcstoul (szStringValue, NULL, 10);
// delta is opposite of arrow direction
nChange = -pNMUpDown->iDelta;
// apply value from spin control
if (nChange < 0) {
// make sure we haven't hit bottom already
// we can't allow a 0 to be "spin-ed" in
if (dwNumValue > 1) {
dwNumValue += nChange;
}
} else {
dwNumValue += nChange;
}
// update edit window
_ultot (dwNumValue, szStringValue, 10);
SetDlgItemText(IDC_INTERVAL_TIME, szStringValue);
SetModified(TRUE);
*pResult = 0;
}
void CSettingsPropPage::OnCancel()
{
CPropertyPage::OnCancel();
}
void CSettingsPropPage::OnOK()
{
CListBox *cCounterList;
CString cIntervalString;
CString cCounterListString;
CString cThisCounterName;
DWORD dwSampleInterval;
LONG lIntervalUnits;
DWORD dwNumCounters;
DWORD dwThisCounter;
DWORD dwBufferLength;
LONG lStatus;
LPTSTR mszCounterPathList = NULL;
LPTSTR szNextItemInList;
BOOL bStopped, bPaused;
cCounterList = (CListBox *)GetDlgItem(IDC_COUNTER_LIST);
// get service state
GetCurrentServiceState (&bStopped, &bPaused);
if (!bStopped) {
AfxMessageBox (IDS_STOP_AND_START);
}
// write changes to registry
//*********************************
// update service start mode if necessary
SyncServiceStartWithButtons();
// sample interval
// read value
GetDlgItemText (IDC_INTERVAL_TIME, cIntervalString);
dwSampleInterval = _tcstoul((LPCTSTR)cIntervalString, NULL, 10);
// read units
lIntervalUnits = ((CComboBox *)GetDlgItem(IDC_INTERVAL_UNITS))->GetCurSel();
// convert value to seconds based on units
switch (lIntervalUnits) {
case SIU_MINUTES:
dwSampleInterval *= SECONDS_IN_MINUTE;
break;
case SIU_HOURS:
dwSampleInterval *= SECONDS_IN_HOUR;
break;
case SIU_DAYS:
dwSampleInterval *= SECONDS_IN_DAY;
break;
case SIU_SECONDS:
default:
// already in second so leave it
break;
}
// write value to registry
lStatus = RegSetValueEx (
m_hKeyLogSettingsDefault,
TEXT("Sample Interval"),
0L,
REG_DWORD,
(LPBYTE)&dwSampleInterval,
sizeof(DWORD));
if (lStatus != ERROR_SUCCESS) {
// unable to update value
}
//*********************************
// counter list
// retrieve items from list box
dwNumCounters = cCounterList->GetCount();
dwBufferLength = 0;
// determine required buffer size
for (dwThisCounter = 0; dwThisCounter < dwNumCounters; dwThisCounter++) {
dwBufferLength += cCounterList->GetTextLen (dwThisCounter) + 1;
}
// add terminating NULL char
dwBufferLength++;
// allocate string buffer and copy list box entries to MSZ
mszCounterPathList = new TCHAR[dwBufferLength];
ASSERT (mszCounterPathList != NULL);
// load listbox entries into MSZ
szNextItemInList = mszCounterPathList;
*szNextItemInList = 0;
for (dwThisCounter = 0; dwThisCounter < dwNumCounters; dwThisCounter++) {
lStatus = cCounterList->GetText(dwThisCounter, szNextItemInList);
lStatus /= sizeof(TCHAR);
szNextItemInList += lStatus;
*szNextItemInList++ = 0;
}
*szNextItemInList++ = 0;
dwBufferLength = (DWORD)((LPBYTE)szNextItemInList - (LPBYTE)mszCounterPathList);
// write MSZ to registry
lStatus = RegSetValueEx (
m_hKeyLogSettingsDefault,
TEXT("Counter List"),
0L,
REG_MULTI_SZ,
(LPBYTE)mszCounterPathList,
dwBufferLength);
if (lStatus != ERROR_SUCCESS) {
// unable to update value
}
delete mszCounterPathList;
CancelToClose();
}
BOOL CSettingsPropPage::OnQueryCancel()
{
return CPropertyPage::OnQueryCancel();
}
void CSettingsPropPage::OnSelchangeIntervalUnits()
{
SetModified(TRUE);
}
void CSettingsPropPage::OnRemoveService()
{
SC_HANDLE hSC = NULL;
SC_HANDLE hService = NULL;
DWORD dwMoreBytes = 0;
LONG lStatus;
if (AfxMessageBox (IDS_REMOVE_SERVICE_WARNING,
MB_OKCANCEL | MB_DEFBUTTON2) == IDCANCEL) {
return;
}
// open SC database
hSC = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSC == NULL) {
lStatus = GetLastError();
ASSERT (lStatus != ERROR_SUCCESS);
}
// open service
hService = OpenService (hSC, TEXT("PerfDataLog"),
SERVICE_CHANGE_CONFIG | DELETE);
if (hService != NULL) {
// Delete the service
if (DeleteService (hService)) {
EndDialog (IDCANCEL);
}
CloseServiceHandle (hService);
} else {
lStatus = GetLastError();
ASSERT (lStatus != 0);
}
// close handles
if (hSC != NULL) CloseServiceHandle (hSC);
return;
}
void CSettingsPropPage::OnChangeIntervalTime()
{
// TODO: Add your control notification handler code here
SetModified(TRUE);
}
Reference in a new issue Copy permalink