archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 75c48ba87f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '75c48ba87f'
${ noResults }
windows-xp/Source/XPSP1/NT/sdktools/proccon/snapin/managementpages.cpp

1940 lines
56 KiB
Raw Blame History

/*======================================================================================//
| Process Control //
| //
|Copyright (c) 1998 Sequent Computer Systems, Incorporated. All rights reserved. //
| //
|File Name: ManagementPages.cpp //
| //
|Description: Implementation of Management Property pages //
| Affinity, Priority, Workingset, Scheduling, Process Count //
| //
|Created: Paul Skoglund 09-1998 //
| //
|Notes: //
| 9/9/1999 Paul Skoglund //
| On the up-down controls even though the controls are configured not to wrap //
| there appears to be a bug in the control that allows wrapping to occur if an //
| arrow is held down and is accelating. The control appears to fails to accout //
| for acceleration when range checking. Note the wizard dialogs are affected //
| by the same bug if a workaround is constructed. //
| //
|Rev History: //
| //
|=======================================================================================*/
#include "stdafx.h"
#include "ManagementPages.h"
#if _MSC_VER >= 1200
#pragma warning( push )
#endif
#pragma warning( disable : 4800 ) //warning C4800: 'unsigned long' : forcing value to bool 'true' or 'false' (performance warning)
void SetMGMTFlag(PC_MGMT_FLAGS &flag, PCMgmtFlags bit, BOOL bOn)
{
if (bOn) flag |= bit;
else flag &= ~bit;
}
BOOL GetValue(TCHAR *const str, __int64 &value, __int64 &max);
BOOL GetValue(TCHAR *const str, __int64 &value, __int64 &max)
{
TCHAR *pos = str;
value = 0;
while (*pos && *pos == _T('0') ) pos++;
while (*pos)
{
if (value > (max/10) ||
(*pos - _T('0')) > (max - (10 * value))
)
{
value = 0;
return FALSE;
}
value = 10 * value + *pos - _T('0');
pos++;
}
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// some formating helper functions
//
LPCTSTR FormatMatchType( ITEM_STR strOut, const MATCH_TYPE matchType )
{
switch (matchType)
{
case MATCH_PGM:
LoadStringHelper(strOut, IDS_MATCH_IMAGE);
break;
case MATCH_DIR:
LoadStringHelper(strOut, IDS_MATCH_DIR);
break;
case MATCH_ANY:
LoadStringHelper(strOut, IDS_MATCH_STRING);
break;
default:
ASSERT(FALSE);
LoadStringHelper(strOut, IDS_UNKNOWN);
break;
}
return strOut;
}
LPCTSTR FormatAffinity(ITEM_STR str, const AFFINITY affinity)
{
str[MAX_ITEM_LEN-1] = 0;
_sntprintf(str, MAX_ITEM_LEN-1, _T("0x%I64X"), affinity);
return str;
}
LPCTSTR FormatPriority(ITEM_STR str, const PRIORITY priority)
{
if (priority == PCPrioNormal)
LoadStringHelper(str, IDS_NORMAL);
else if (priority == PCPrioRealTime)
LoadStringHelper(str, IDS_REALTIME);
else if (priority == PCPrioHigh)
LoadStringHelper(str, IDS_HIGH);
else if (priority == PCPrioAboveNormal)
LoadStringHelper(str, IDS_ABOVE_NORMAL);
else if (priority == PCPrioBelowNormal)
LoadStringHelper(str, IDS_BELOW_NORMAL);
else if (priority == PCPrioIdle)
LoadStringHelper(str, IDS_LOW);
else
LoadStringHelper(str, IDS_UNKNOWN);
return str;
}
LPCTSTR FormatSchedulingClass(ITEM_STR str, const SCHEDULING_CLASS schedClass)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%u"), schedClass);
return str;
}
LPCTSTR FormatProcCount(ITEM_STR str, const PROC_COUNT procCount)
{
ASSERT(sizeof(PROC_COUNT) == sizeof(int));
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%u"), procCount);
return str;
}
LPCTSTR FormatPCUINT32(ITEM_STR str, const PCUINT32 uInt)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%u"), uInt);
return str;
}
LPCTSTR FormatPCINT32(ITEM_STR str, const PCINT32 aInt)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%d"), aInt);
return str;
}
LPCTSTR FormatPCUINT64(ITEM_STR str, const PCUINT64 aUInt64)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%I64u"), aUInt64);
return str;
}
LPCTSTR FormatApplyFlag(ITEM_STR str, const BOOL applied)
{
str[MAX_ITEM_LEN - 1] = 0;
if (applied)
LoadStringHelper(str, IDS_YES );
else
LoadStringHelper(str, IDS_NO );
return str;
}
LPCTSTR FormatMemory(ITEM_STR str, const MEMORY_VALUE memory_value)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%I64u"), memory_value/1024 );
return str;
}
LPCTSTR FormatTime(ITEM_STR str, const TIME_VALUE time)
{
SYSTEMTIME systime, localsystime;
int len;
str[MAX_ITEM_LEN - 1] = 0;
if ( FileTimeToSystemTime((FILETIME *) &time, &systime) &&
SystemTimeToTzSpecificLocalTime(NULL, &systime, &localsystime) )
{
if (len = GetDateFormat( LOCALE_USER_DEFAULT, 0, &localsystime, NULL, str, MAX_ITEM_LEN - 1 ))
{
str[len - 1 ] = _T(' ');
if (GetTimeFormat( LOCALE_USER_DEFAULT, 0, &localsystime, NULL, &str[len], MAX_ITEM_LEN - len - 1))
{
return str;
}
}
}
str[0] = 0;
return str;
}
LPCTSTR FormatTimeToms(ITEM_STR str, const TIME_VALUE time)
{
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%I64u"), time/10000 );
return str;
}
LPCTSTR FormatCNSTime(ITEM_STR str, TIME_VALUE time)
{
TIME_VALUE hours = time / CNSperHour;
time -= CNSperHour * hours;
TIME_VALUE minutes = time / CNSperMinute;
time -= CNSperMinute * minutes;
TIME_VALUE seconds = time / CNSperSec;
time -= CNSperSec * seconds;
str[MAX_ITEM_LEN - 1] = 0;
_sntprintf(str, MAX_ITEM_LEN - 1, _T("%I64u:%.2I64u:%.2I64u.%.7I64u"), hours, minutes, seconds, time);
int len = _tcslen(str);
while (len && str[--len] == _T('0') ) //strip trailing 0's
str[len] = 0;
return str;
}
LPCTSTR FormatCPUTIMELimitAction(ITEM_STR str, BOOL bMsgOnLimit)
{
str[MAX_ITEM_LEN - 1] = 0;
if (bMsgOnLimit)
LoadStringHelper(str, IDS_CPUTIMELIMT_ACTION_MSG );
else
LoadStringHelper(str, IDS_CPUTIMELIMT_ACTION_TERM );
return str;
}
LPCTSTR FormatSheetTitle(CComBSTR &Title, const CComBSTR &item_name, const COMPUTER_CONNECTION_INFO &Target)
{
Title = item_name;
CComBSTR bTemp;
if (bTemp.LoadString(IDS_ON))
Title.Append(bTemp);
if (Target.bLocalComputer)
{
if (bTemp.LoadString(IDS_LOCAL_COMPUTER) )
Title.Append(bTemp);
}
else
{
Title.Append(Target.RemoteComputer);
}
return Title.m_str;
}
///////////////////////////////////////////////////////////////////////////
// some dialog helper functions
//
int PriorityToID(PRIORITY p)
{
ASSERT(IDC_REALTIME == 1 + IDC_HIGH && IDC_HIGH == 1 + IDC_ABOVE_NORMAL &&
IDC_ABOVE_NORMAL == 1 + IDC_NORMAL && IDC_NORMAL == 1 + IDC_BELOW_NORMAL &&
IDC_BELOW_NORMAL == 1 + IDC_LOW );
if (p == PCPrioRealTime)
return IDC_REALTIME;
else if (p == PCPrioHigh)
return IDC_HIGH;
else if (p == PCPrioAboveNormal)
return IDC_ABOVE_NORMAL;
else if (p == PCPrioNormal)
return IDC_NORMAL;
else if (p == PCPrioBelowNormal)
return IDC_BELOW_NORMAL;
else if (p == PCPrioIdle)
return IDC_LOW;
ASSERT(FALSE);
return IDC_NORMAL;
}
PRIORITY IDToPriority(int id)
{
ASSERT(IDC_REALTIME == 1 + IDC_HIGH && IDC_HIGH == 1 + IDC_ABOVE_NORMAL &&
IDC_ABOVE_NORMAL == 1 + IDC_NORMAL && IDC_NORMAL == 1 + IDC_BELOW_NORMAL &&
IDC_BELOW_NORMAL == 1 + IDC_LOW );
if (id == IDC_REALTIME)
return PCPrioRealTime;
else if (id == IDC_HIGH)
return PCPrioHigh;
else if (id == IDC_ABOVE_NORMAL)
return PCPrioAboveNormal;
else if (id == IDC_NORMAL)
return PCPrioNormal;
else if (id == IDC_BELOW_NORMAL)
return PCPrioBelowNormal;
else if (id == IDC_LOW)
return PCPrioIdle;
ASSERT(FALSE);
return PCPrioNormal;
}
int MatchTypeToID(MATCH_TYPE matchType)
{
ASSERT(IDC_DIR + 1 == IDC_IMAGE &&
IDC_IMAGE + 1 == IDC_STRING );
if (matchType == MATCH_PGM)
return IDC_IMAGE;
else if (matchType == MATCH_DIR)
return IDC_DIR;
else if (matchType == MATCH_ANY)
return IDC_STRING;
ASSERT(FALSE);
return IDC_IMAGE;
}
BOOL ValidateTimeField(HWND hDlg, WORD wID, TIME_VALUE &newtime)
{
TCHAR ValidChars[] = _T("0123456789.:");
TCHAR Digits[] = _T("0123456789");
TCHAR StrBuffer[32];
newtime = 0;
StrBuffer[ARRAY_SIZE(StrBuffer) - 1 ] = 0;
LRESULT pos = SendDlgItemMessage(hDlg, wID, WM_GETTEXT, ARRAY_SIZE(StrBuffer)-1, (LPARAM) &StrBuffer);
if (pos > 0 )
{
if (pos != (int) _tcsspn(&StrBuffer[0], &ValidChars[0]) )
return FALSE;
__int64 cns = 0;
__int64 seconds = 0;
__int64 minutes = 0;
__int64 hours = 0;
TCHAR *dot = _tcsrchr(&StrBuffer[0], _T('.'));
if (dot) // convert tenths of second to CNS
{
*dot = 0;
dot++;
unsigned int len = _tcslen(dot);
if (len > 7 || len != _tcsspn(dot, Digits) )
return FALSE;
cns = _ttoi64(dot);
for(unsigned int x = 0; cns && x < (7 - len); x++)
cns *= 10;
}
struct {
__int64 *val;
__int64 max;
} fields [] = {
{&seconds, MAXLONGLONG/CNSperSec },
{&minutes, MAXLONGLONG/CNSperMinute},
{&hours, MAXLONGLONG/CNSperHour }
};
for (int i = 0; i < ARRAY_SIZE(fields); i++)
{
dot = _tcsrchr(&StrBuffer[0], _T(':'));
if (!dot)
{
dot = &StrBuffer[0];
}
else
{
*dot = 0;
dot++;
}
if (_tcslen(dot) != _tcsspn(dot, Digits))
return FALSE;
if ( !GetValue(dot, *(fields[i].val), fields[i].max) )
return FALSE;
if (dot == &StrBuffer[0])
break;
}
newtime = cns;
if ( (CNSperSec * seconds) <= (MAXLONGLONG - newtime) )
{
newtime += CNSperSec * seconds;
if ( (CNSperMinute * minutes) <= (MAXLONGLONG - newtime) )
{
newtime += CNSperMinute * minutes;
if (CNSperHour * hours <= (MAXLONGLONG - newtime) )
{
newtime += CNSperHour * hours;
return TRUE;
}
}
}
}
newtime = 0;
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Affinity Management Page Implementation
CMGMTAffinityPage::CMGMTAffinityPage(int nTitle, CProcDetailContainer *pContainer, AFFINITY ProcessorMask) :
CMySnapInPropertyPageImpl<CMGMTAffinityPage>(nTitle),
m_PageType(PROCESS_PAGE), m_pProcContainer(pContainer), m_pJobContainer(NULL),
m_ProcessorMask(ProcessorMask)
{
m_pProcContainer->AddRef();
Initialize();
}
CMGMTAffinityPage::CMGMTAffinityPage(int nTitle, CJobDetailContainer *pContainer, AFFINITY ProcessorMask) :
CMySnapInPropertyPageImpl<CMGMTAffinityPage>(nTitle),
m_PageType(JOB_PAGE), m_pProcContainer(NULL), m_pJobContainer(pContainer),
m_ProcessorMask(ProcessorMask)
{
m_pJobContainer->AddRef();
Initialize();
}
void CMGMTAffinityPage::Initialize()
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_affinitychk = FALSE;
m_affinity = 0;
m_hIconImage = NULL;
m_psp.dwFlags |= PSP_HASHELP;
}
CMGMTAffinityPage::~CMGMTAffinityPage()
{
if (m_PageType == PROCESS_PAGE)
m_pProcContainer->Release();
else if (m_PageType == JOB_PAGE)
m_pJobContainer->Release();
if (m_hIconImage)
VERIFY(::DestroyIcon( (HICON) m_hIconImage));
}
LRESULT CMGMTAffinityPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CComBSTR bStr;
int PromptID;
if (m_PageType == PROCESS_PAGE)
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_PROCESSES), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
PromptID = IDS_AFFINITY_JOBWARNING;
}
else
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_JOBS), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
PromptID = IDS_AFFINITY_NOJOBWARNING;
}
ASSERT(m_hIconImage);
if (m_hIconImage)
SendDlgItemMessage(IDC_PAGE_ICON, STM_SETICON, (WPARAM) m_hIconImage, 0);
if (bStr.LoadString(PromptID))
VERIFY(SetDlgItemText(IDC_AFFINITY_PROMPT, bStr.m_str));
UpdateData(FALSE);
bHandled = FALSE;
return TRUE; // Let the system set the focus
}
LRESULT CMGMTAffinityPage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
if (phi->iCtrlId > IDC_AFFINITY1 && phi->iCtrlId < IDC_AFFINITY64)
{
phi->iCtrlId = IDC_AFFINITY1;
phi->hItemHandle = GetDlgItem(phi->iCtrlId);
}
if (m_pJobContainer)
{
IDCsToIDHs HelpMap[] = {{IDC_AFFINITY_FRAME, HELP_GRP_AFFINITY_FRAME },
{IDC_AFFINITY_CHK, HELP_GRP_AFFINITY_APPLY },
{IDC_AFFINITY1, HELP_GRP_AFFINITY},
{IDC_AFFINITY64, HELP_GRP_AFFINITY},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
else
{
IDCsToIDHs HelpMap[] = {{IDC_AFFINITY_FRAME, HELP_PROC_AFFINITY_FRAME },
{IDC_AFFINITY_CHK, HELP_PROC_AFFINITY_APPLY },
{IDC_AFFINITY1, HELP_PROC_AFFINITY},
{IDC_AFFINITY64, HELP_PROC_AFFINITY},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTAffinityPage::OnHelp()
{
MMCPropertyHelp(const_cast<TCHAR*>(HELP_ru_affinity));
return TRUE;
}
BOOL CMGMTAffinityPage::Validate(BOOL bSave /* = FALSE */)
{
AFFINITY affinity = 0;
bool affinitychk = (BST_CHECKED == IsDlgButtonChecked(IDC_AFFINITY_CHK));
for (int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
{
if ( BST_UNCHECKED != IsDlgButtonChecked(i) )
affinity |= (ProcessorBit << (i - IDC_AFFINITY1));
}
// warn the user if they make changes but have an apply affinity rule without
// referencing at least one available processor
if (affinitychk && !(affinity & m_ProcessorMask) && PageFields.on)
{
ITEM_STR strOut;
LoadStringHelper(strOut, IDS_AFFINITY_WARNING);
if (IDYES != MessageBox(strOut, NULL, MB_YESNO | MB_ICONQUESTION))
return FALSE;
}
if (bSave)
{
if (m_PageType == PROCESS_PAGE)
{
m_pProcContainer->m_new.base.mgmtParms.affinity = affinity;
SetMGMTFlag(m_pProcContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, affinitychk);
}
else if (m_PageType == JOB_PAGE)
{
m_pJobContainer->m_new.base.mgmtParms.affinity = affinity;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, affinitychk);
}
}
return TRUE;
}
BOOL CMGMTAffinityPage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
ASSERT(IDC_AFFINITY1 + 63 == IDC_AFFINITY64);
for(int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
{
if (m_affinity & (ProcessorBit << (i - IDC_AFFINITY1) ) )
{
if (m_ProcessorMask & (ProcessorBit << (i - IDC_AFFINITY1)))
CheckDlgButton(i, BST_CHECKED);
else
CheckDlgButton(i, BST_INDETERMINATE);
}
else
CheckDlgButton(i, BST_UNCHECKED);
}
CheckDlgButton(IDC_AFFINITY_CHK, m_affinitychk ? BST_CHECKED : BST_UNCHECKED);
ApplyControlEnableRules(FALSE);
return TRUE;
}
}
void CMGMTAffinityPage::ApplyControlEnableRules(BOOL bForceDisable)
{
BOOL bEnable;
if (m_bReadOnly || !m_affinitychk || bForceDisable)
bEnable = FALSE;
else
bEnable = TRUE;
for (int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
::EnableWindow(GetDlgItem(i), bEnable);
::EnableWindow(GetDlgItem(IDC_AFFINITY_CHK), !(m_bReadOnly || bForceDisable));
}
BOOL CMGMTAffinityPage::OnSetActive()
{
if ( m_PageType == PROCESS_PAGE )
{
if (m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
ApplyControlEnableRules(TRUE);
else
ApplyControlEnableRules(FALSE);
}
return TRUE;
}
LRESULT CMGMTAffinityPage::OnAffinityEdit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wNotifyCode == BN_CLICKED)
{
ASSERT(wID >= IDC_AFFINITY1 && wID <= IDC_AFFINITY64);
int bit = wID - IDC_AFFINITY1;
UINT btnState = IsDlgButtonChecked(wID);
if (btnState == BST_UNCHECKED)
{
if ( m_ProcessorMask & (ProcessorBit << bit))
CheckDlgButton(wID, BST_CHECKED);
else
CheckDlgButton(wID, BST_INDETERMINATE);
}
else
{
CheckDlgButton(wID, BST_UNCHECKED);
}
AFFINITY affinity = 0;
for ( int i = IDC_AFFINITY1; i<= IDC_AFFINITY64; i++)
{
if ( BST_UNCHECKED != IsDlgButtonChecked(i) )
affinity |= (ProcessorBit << (i - IDC_AFFINITY1));
}
PageFields.Fields.affinity = (m_affinity != affinity);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
LRESULT CMGMTAffinityPage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_AFFINITY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_AFFINITY_CHK));
PageFields.Fields.affinitychk = (m_affinitychk != checked);
for (int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
::EnableWindow(GetDlgItem(i), checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTAffinityPage::OnApply()
{
if (m_bReadOnly || !PageFields.on)
return TRUE;
if ( (m_PageType == PROCESS_PAGE && m_pProcContainer->Apply(GetParent())) ||
(m_PageType == JOB_PAGE && m_pJobContainer->Apply(GetParent())) )
{
PageFields.on = 0;
if (m_PageType == PROCESS_PAGE)
{
m_affinity = m_pProcContainer->m_new.base.mgmtParms.affinity;
m_affinitychk = (m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_AFFINITY);
}
else if (m_PageType == JOB_PAGE)
{
m_affinity = m_pJobContainer->m_new.base.mgmtParms.affinity;
m_affinitychk = (m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_AFFINITY);
}
return TRUE;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Priority Management Page Implementation
CMGMTPriorityPage::CMGMTPriorityPage(int nTitle, CProcDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTPriorityPage>(nTitle),
m_pProcContainer(pContainer), m_pJobContainer(NULL), m_PageType(PROCESS_PAGE)
{
m_pProcContainer->AddRef();
Initialize();
}
CMGMTPriorityPage::CMGMTPriorityPage(int nTitle, CJobDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTPriorityPage>(nTitle),
m_pProcContainer(NULL), m_pJobContainer(pContainer), m_PageType(JOB_PAGE)
{
m_pJobContainer->AddRef();
Initialize();
}
void CMGMTPriorityPage::Initialize()
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_prioritychk = FALSE;
m_priority = PCPrioNormal;
m_hIconImage = NULL;
m_psp.dwFlags |= PSP_HASHELP;
}
CMGMTPriorityPage::~CMGMTPriorityPage()
{
if (m_PageType == PROCESS_PAGE)
m_pProcContainer->Release();
else if (m_PageType == JOB_PAGE)
m_pJobContainer->Release();
if (m_hIconImage)
VERIFY(::DestroyIcon( (HICON) m_hIconImage));
}
LRESULT CMGMTPriorityPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CComBSTR bStr;
int PromptID;
if (m_PageType == PROCESS_PAGE)
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_PROCESSES), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
ASSERT(m_hIconImage);
PromptID = IDS_PRIORITY_JOBWARNING;
}
else
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_JOBS), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
ASSERT(m_hIconImage);
PromptID = IDS_PRIORITY_NOJOBWARNING;
}
if (m_hIconImage)
SendDlgItemMessage(IDC_PAGE_ICON, STM_SETICON, (WPARAM) m_hIconImage, 0);
if (bStr.LoadString(PromptID))
VERIFY(SetDlgItemText(IDC_PRIORITY_PROMPT, bStr.m_str));
UpdateData(FALSE);
bHandled = FALSE;
return TRUE; // Let the system set the focus
}
LRESULT CMGMTPriorityPage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
if (m_pJobContainer)
{
IDCsToIDHs HelpMap[] = {{IDC_PRIORITY_FRAME, HELP_GRP_PRIORITY_FRAME },
{IDC_PRIORITY_CHK, HELP_GRP_PRIORITY_APPLY },
{IDC_REALTIME, HELP_GRP_PRIORITY_REAL},
{IDC_HIGH, HELP_GRP_PRIORITY_HIGH},
{IDC_ABOVE_NORMAL, HELP_GRP_PRIORITY_ABOVENORMAL},
{IDC_NORMAL, HELP_GRP_PRIORITY_NORMAL},
{IDC_BELOW_NORMAL, HELP_GRP_PRIORITY_BELOWNORMAL},
{IDC_LOW, HELP_GRP_PRIORITY_LOW},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
else
{
IDCsToIDHs HelpMap[] = {{IDC_PRIORITY_FRAME, HELP_PROC_PRIORITY_FRAME },
{IDC_PRIORITY_CHK, HELP_PROC_PRIORITY_APPLY },
{IDC_REALTIME, HELP_PROC_PRIORITY_REAL},
{IDC_HIGH, HELP_PROC_PRIORITY_HIGH},
{IDC_ABOVE_NORMAL, HELP_PROC_PRIORITY_ABOVENORMAL},
{IDC_NORMAL, HELP_PROC_PRIORITY_NORMAL},
{IDC_BELOW_NORMAL, HELP_PROC_PRIORITY_BELOWNORMAL},
{IDC_LOW, HELP_PROC_PRIORITY_LOW},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTPriorityPage::OnHelp()
{
MMCPropertyHelp(const_cast<TCHAR*>(HELP_ru_priority));
return TRUE;
}
BOOL CMGMTPriorityPage::Validate(BOOL bSave)
{
PRIORITY p = 0;
for ( int i = IDC_LOW; i <= IDC_REALTIME; i++)
{
if ( BST_CHECKED == IsDlgButtonChecked(i) )
p += IDToPriority(i);
}
if (IDToPriority(PriorityToID(p)) != p) //not fool proof, but do we really need to check this? no
{
MessageBeep(MB_ICONASTERISK);
return FALSE;
}
if (bSave)
{
if (m_PageType == PROCESS_PAGE)
{
m_pProcContainer->m_new.base.mgmtParms.priority = p;
SetMGMTFlag(m_pProcContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, (BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK)));
}
else if (m_PageType == JOB_PAGE)
{
m_pJobContainer->m_new.base.mgmtParms.priority = p;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, (BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK)));
}
}
return TRUE;
}
BOOL CMGMTPriorityPage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
CheckRadioButton(IDC_LOW, IDC_REALTIME, PriorityToID(m_priority));
CheckDlgButton(IDC_PRIORITY_CHK, m_prioritychk ? BST_CHECKED : BST_UNCHECKED);
ApplyControlEnableRules(FALSE);
return TRUE;
}
}
void CMGMTPriorityPage::ApplyControlEnableRules(BOOL bForceDisable)
{
BOOL bEnable;
if (m_bReadOnly || !m_prioritychk || bForceDisable)
bEnable = FALSE;
else
bEnable = TRUE;
UINT ids[] = { IDC_REALTIME, IDC_HIGH, IDC_ABOVE_NORMAL, IDC_NORMAL, IDC_BELOW_NORMAL, IDC_LOW, 0 };
for (int i = 0; ids[i]; i++)
::EnableWindow(GetDlgItem(ids[i]), bEnable);
::EnableWindow(GetDlgItem(IDC_PRIORITY_CHK), !(m_bReadOnly || bForceDisable));
}
BOOL CMGMTPriorityPage::OnSetActive()
{
if ( m_PageType == PROCESS_PAGE )
{
if (m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
ApplyControlEnableRules(TRUE);
else
ApplyControlEnableRules(FALSE);
}
return TRUE;
}
LRESULT CMGMTPriorityPage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_PRIORITY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK));
PageFields.Fields.prioritychk = (m_prioritychk != checked);
UINT ids[] = { IDC_REALTIME, IDC_HIGH, IDC_ABOVE_NORMAL, IDC_NORMAL, IDC_BELOW_NORMAL, IDC_LOW,0 };
for (int i = 0; ids[i]; i++)
::EnableWindow(GetDlgItem(ids[i]), checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
LRESULT CMGMTPriorityPage::OnPriorityEdit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wNotifyCode == BN_CLICKED)
{
ASSERT(wID >= IDC_LOW && wID <= IDC_REALTIME );
PRIORITY p = 0;
for ( int i = IDC_LOW; i <= IDC_REALTIME; i++)
{
if ( BST_CHECKED == IsDlgButtonChecked(i) )
p += IDToPriority(i);
}
PageFields.Fields.priority = (m_priority != p);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTPriorityPage::OnApply()
{
if (m_bReadOnly || !PageFields.on)
return TRUE;
if ( (m_PageType == PROCESS_PAGE && m_pProcContainer->Apply(GetParent()) ) ||
(m_PageType == JOB_PAGE && m_pJobContainer->Apply(GetParent()) ) )
{
PageFields.on = 0;
if (m_PageType == PROCESS_PAGE)
{
m_priority = m_pProcContainer->m_new.base.mgmtParms.priority;
m_prioritychk = m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_PRIORITY;
}
else if (m_PageType == JOB_PAGE)
{
m_priority = m_pJobContainer->m_new.base.mgmtParms.priority;
m_prioritychk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_PRIORITY;
}
return TRUE;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Scheduling Class Management Page Implementation
CMGMTSchedulingClassPage::CMGMTSchedulingClassPage(int nTitle, CJobDetailContainer *pContainer)
: CMySnapInPropertyPageImpl<CMGMTSchedulingClassPage>(nTitle),
m_pJobContainer(pContainer)
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_schedClasschk = FALSE;
m_schedClass = 5;
m_psp.dwFlags |= PSP_HASHELP;
m_pJobContainer->AddRef();
}
CMGMTSchedulingClassPage::~CMGMTSchedulingClassPage()
{
m_pJobContainer->Release();
}
LRESULT CMGMTSchedulingClassPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
UpdateData(FALSE);
bHandled = FALSE;
return TRUE; // Let the system set the focus
}
LRESULT CMGMTSchedulingClassPage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
IDCsToIDHs HelpMap[] = {{IDC_SCHEDULING_FRAME, HELP_SCHEDULING_FRAME },
{IDC_SCHEDULING_CHK, HELP_SCHEDULING_APPLY },
{IDC_SCLASS, HELP_SCHEDULING_CLASS},
{IDC_SPIN, HELP_SCHEDULING_CLASS_SPIN},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTSchedulingClassPage::OnHelp()
{
MMCPropertyHelp(const_cast<TCHAR*>(HELP_ru_job_sch));
return TRUE;
}
BOOL CMGMTSchedulingClassPage::Validate(BOOL bSave)
{
LRESULT pos = SendDlgItemMessage(IDC_SPIN, UDM_GETPOS, 0, 0);
if (0 == HIWORD(pos) && LOWORD(pos) >= 0 && LOWORD(pos) <= 9 )
{
if (bSave)
{
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_SCHEDULING_CLASS, (BST_CHECKED == IsDlgButtonChecked(IDC_SCHEDULING_CHK)));
m_pJobContainer->m_new.base.mgmtParms.schedClass = (SCHEDULING_CLASS) LOWORD(pos);
}
return TRUE;
}
HWND hWndCtl = GetDlgItem(IDC_SCLASS);
if(hWndCtl)
::SetFocus(hWndCtl);
MessageBeep(MB_ICONASTERISK);
return FALSE;
}
BOOL CMGMTSchedulingClassPage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
CheckDlgButton(IDC_SCHEDULING_CHK, m_schedClasschk ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(IDC_SPIN, UDM_SETPOS, 0, MAKELONG(m_schedClass, 0) );
SendDlgItemMessage(IDC_SPIN, UDM_SETRANGE32, 0, 9);
if (m_bReadOnly || !m_schedClasschk)
{
DisableControl(IDC_SCLASS);
DisableControl(IDC_SPIN);
}
if (m_bReadOnly)
DisableControl(IDC_SCHEDULING_CHK);
return TRUE;
}
}
LRESULT CMGMTSchedulingClassPage::OnEditChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_SCLASS)
{
PageFields.Fields.schedClass = FALSE;
LRESULT pos = SendDlgItemMessage(IDC_SPIN, UDM_GETPOS, 0,0);
if (0 == HIWORD(pos) && LOWORD(pos) >= 0 && LOWORD(pos) <= 9 )
PageFields.Fields.schedClass = (m_schedClass != LOWORD(pos));
}
SetModified(PageFields.on);
bHandled = FALSE;
return 0;
}
LRESULT CMGMTSchedulingClassPage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_SCHEDULING_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_SCHEDULING_CHK));
PageFields.Fields.schedClasschk = (m_schedClasschk != checked);
::EnableWindow(GetDlgItem(IDC_SCLASS), checked);
::EnableWindow(GetDlgItem(IDC_SPIN), checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTSchedulingClassPage::OnApply()
{
if (m_bReadOnly || !PageFields.on) // read only, nothing modified
return TRUE;
if ( m_pJobContainer->Apply(GetParent()) )
{
PageFields.on = 0;
m_schedClasschk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_SCHEDULING_CLASS;
m_schedClass = m_pJobContainer->m_new.base.mgmtParms.schedClass;
return TRUE;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Memory Management Page Implementation
CMGMTMemoryPage::CMGMTMemoryPage(int nTitle, CProcDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTMemoryPage>(nTitle),
m_pProcContainer(pContainer), m_pJobContainer(NULL)
{
m_pProcContainer->AddRef();
Initialize();
}
CMGMTMemoryPage::CMGMTMemoryPage(int nTitle, CJobDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTMemoryPage>(nTitle),
m_pProcContainer(NULL), m_pJobContainer(pContainer)
{
m_pJobContainer->AddRef();
Initialize();
}
void CMGMTMemoryPage::Initialize()
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_WSchk = FALSE;
m_minWS = 0;
m_maxWS = 0;
m_procmemorylimitchk = FALSE;
m_procmemorylimit = 0;
m_jobmemorylimitchk = FALSE;
m_jobmemorylimit = 0;
m_hIconImage = NULL;
m_psp.dwFlags |= PSP_HASHELP;
}
CMGMTMemoryPage::~CMGMTMemoryPage()
{
if (m_pProcContainer)
m_pProcContainer->Release();
if (m_pJobContainer)
m_pJobContainer->Release();
if (m_hIconImage)
VERIFY(::DestroyIcon( (HICON) m_hIconImage));
}
LRESULT CMGMTMemoryPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if (m_pProcContainer)
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_PROCESSES), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
//PromptID = IDS_AFFINITY_JOBWARNING;
}
else if (m_pJobContainer)
{
m_hIconImage = ::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_JOBS), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR );
//PromptID = IDS_AFFINITY_NOJOBWARNING;
}
ASSERT(m_hIconImage);
if (m_hIconImage)
SendDlgItemMessage(IDC_PAGE_ICON, STM_SETICON, (WPARAM) m_hIconImage, 0);
UpdateData(FALSE);
bHandled = FALSE;
return TRUE; // Let the system set the focus
}
LRESULT CMGMTMemoryPage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
if (m_pJobContainer)
{
IDCsToIDHs HelpMap[]={{IDC_WORKINGSET_FRAME, HELP_GRP_WS_FRAME },
{IDC_WORKINGSET_CHK, HELP_GRP_WS_APPLY },
{IDC_MINWS, HELP_GRP_WS_MIN },
{IDC_MINWS_SPIN, HELP_GRP_WS_MIN_SPIN},
{IDC_MAXWS, HELP_GRP_WS_MAX},
{IDC_MAXWS_SPIN, HELP_GRP_WS_MAX_SPIN },
{IDC_PROCMEM_FRM, HELP_GRP_PROCCOM_FRAME },
{IDC_PROCMEMORY_CHK, HELP_GRP_PROCCOM_APPLY },
{IDC_PROCMEMORY, HELP_GRP_PROCCOM_MAX },
{IDC_PROC_SPIN, HELP_GRP_PROCCOM_MAX_SPIN},
{IDC_JOBMEM_FRM, HELP_GRP_GRPCOM_FRAME },
{IDC_JOBMEMORY_CHK, HELP_GRP_GRPCOM_APPLY },
{IDC_JOBMEMORY, HELP_GRP_GRPCOM_MAX },
{IDC_JOB_SPIN, HELP_GRP_GRPCOM_MAX_SPIN},
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
else
{
IDCsToIDHs HelpMap[]={{IDC_WORKINGSET_FRAME, HELP_PROC_WS_FRAME },
{IDC_WORKINGSET_CHK, HELP_PROC_WS_APPLY },
{IDC_MINWS, HELP_PROC_WS_MIN },
{IDC_MINWS_SPIN, HELP_PROC_WS_MIN_SPIN},
{IDC_MAXWS, HELP_PROC_WS_MAX},
{IDC_MAXWS_SPIN, HELP_PROC_WS_MAX_SPIN },
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
}
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTMemoryPage::OnHelp()
{
TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_workset);
if (m_pJobContainer)
pTopic = const_cast<TCHAR*>(HELP_ru_job_mem);
MMCPropertyHelp(pTopic);
return TRUE;
}
BOOL CMGMTMemoryPage::Validate(BOOL bSave)
{
LONG_PTR PosErr = 0;
MEMORY_VALUE minWS;
MEMORY_VALUE maxWS;
MEMORY_VALUE procmemorylimit;
MEMORY_VALUE jobmemorylimit;
BOOL WSchk = (BST_CHECKED == IsDlgButtonChecked(IDC_WORKINGSET_CHK));
minWS = SendDlgItemMessage(IDC_MINWS_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);
if (PosErr || minWS > MAXLONG - 1 || (WSchk && minWS <= 0) )
{
HWND hWndCtl = GetDlgItem(IDC_MINWS);
if(hWndCtl)
::SetFocus(hWndCtl);
ITEM_STR strOut;
LoadStringHelper(strOut, IDS_WSMINMAX_WARNING);
MessageBox(strOut, NULL, MB_OK | MB_ICONWARNING);
return FALSE;
}
maxWS = SendDlgItemMessage(IDC_MAXWS_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);
if (PosErr || maxWS > MAXLONG - 1 || (WSchk && minWS >= maxWS) )
{
HWND hWndCtl = GetDlgItem(IDC_MAXWS);
if(hWndCtl)
::SetFocus(hWndCtl);
ITEM_STR strOut;
LoadStringHelper(strOut, IDS_WSMINMAX_WARNING);
MessageBox(strOut, NULL, MB_OK | MB_ICONWARNING);
return FALSE;
}
if (m_pJobContainer)
{
procmemorylimit = SendDlgItemMessage(IDC_PROC_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);
if (PosErr || procmemorylimit > MAXLONG - 1 )
{
HWND hWndCtl = GetDlgItem(IDC_PROCMEMORY);
if(hWndCtl)
::SetFocus(hWndCtl);
MessageBeep(MB_ICONASTERISK);
return FALSE;
}
jobmemorylimit = SendDlgItemMessage(IDC_JOB_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);
if (PosErr || jobmemorylimit > MAXLONG - 1 )
{
HWND hWndCtl = GetDlgItem(IDC_JOBMEMORY);
if(hWndCtl)
::SetFocus(hWndCtl);
MessageBeep(MB_ICONASTERISK);
return FALSE;
}
}
if (bSave)
{
if (m_pProcContainer)
{
SetMGMTFlag(m_pProcContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_WS_MINMAX, WSchk);
m_pProcContainer->m_new.base.mgmtParms.minWS = minWS * 1024;
m_pProcContainer->m_new.base.mgmtParms.maxWS = maxWS * 1024;
}
else if (m_pJobContainer)
{
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_WS_MINMAX, WSchk);
m_pJobContainer->m_new.base.mgmtParms.minWS = minWS * 1024;
m_pJobContainer->m_new.base.mgmtParms.maxWS = maxWS * 1024;
m_procmemorylimitchk = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCMEMORY_CHK));
m_procmemorylimit = procmemorylimit * 1024;
m_jobmemorylimitchk = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMORY_CHK));
m_jobmemorylimit = jobmemorylimit * 1024;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_PROC_MEMORY_LIMIT, (BST_CHECKED == IsDlgButtonChecked(IDC_PROCMEMORY_CHK)));
m_pJobContainer->m_new.base.mgmtParms.procMemoryLimit = procmemorylimit * 1024;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_JOB_MEMORY_LIMIT, (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMORY_CHK)));
m_pJobContainer->m_new.base.mgmtParms.jobMemoryLimit = jobmemorylimit * 1024;
}
}
return TRUE;
}
BOOL CMGMTMemoryPage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
if ( m_minWS/1024 > (MAXLONG - 1) ||
m_maxWS/1024 > (MAXLONG - 1) ||
m_procmemorylimit/1024 > (MAXLONG - 1) ||
m_jobmemorylimit/1024 > (MAXLONG - 1) )
m_bReadOnly = TRUE;
long minWSInK = (long) (m_minWS/1024);
long maxWSInK = (long) (m_maxWS/1024);
CheckDlgButton(IDC_WORKINGSET_CHK, m_WSchk ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(IDC_MINWS_SPIN, UDM_SETRANGE32, 0, MAXLONG - 1 );
SendDlgItemMessage(IDC_MINWS_SPIN, UDM_SETPOS32, 0, minWSInK );
SendDlgItemMessage(IDC_MAXWS_SPIN, UDM_SETRANGE32, 0, MAXLONG - 1);
SendDlgItemMessage(IDC_MAXWS_SPIN, UDM_SETPOS32, 0, maxWSInK );
if (m_pJobContainer)
{
long ProcMemInK = (long) (m_procmemorylimit/1024);
long JobMemInK = (long) (m_jobmemorylimit/1024);
CheckDlgButton(IDC_PROCMEMORY_CHK, m_procmemorylimitchk ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(IDC_PROC_SPIN, UDM_SETRANGE32, 0, MAXLONG - 1);
SendDlgItemMessage(IDC_PROC_SPIN, UDM_SETPOS32, 0, ProcMemInK );
CheckDlgButton(IDC_JOBMEMORY_CHK, m_jobmemorylimitchk ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(IDC_JOB_SPIN, UDM_SETRANGE32, 0, MAXLONG - 1);
SendDlgItemMessage(IDC_JOB_SPIN, UDM_SETPOS32, 0, JobMemInK );
}
if (m_pProcContainer)
{
UINT nIDs[] = { IDC_PROCMEM_FRM, IDC_PROCMEMORY_CHK, IDC_PROCMEM_LBL, IDC_PROCMEMORY, IDC_PROC_SPIN, IDC_JOBMEM_FRM, IDC_JOBMEMORY_CHK, IDC_JOBMEM_LBL, IDC_JOBMEMORY, IDC_JOB_SPIN };
for (int i = 0; i < ARRAY_SIZE(nIDs); i++ )
{
HWND hWndCtl = GetDlgItem(nIDs[i]);
if(hWndCtl)
::ShowWindow(hWndCtl, SW_HIDE);
}
}
ApplyControlEnableRules(FALSE);
if (m_bReadOnly || !m_procmemorylimitchk)
DisableControl(IDC_PROCMEMORY);
if (m_bReadOnly || !m_jobmemorylimitchk)
DisableControl(IDC_JOBMEMORY);
if (m_bReadOnly)
{
DisableControl(IDC_PROCMEMORY_CHK);
DisableControl(IDC_JOBMEMORY_CHK);
}
return TRUE;
}
}
void CMGMTMemoryPage::ApplyControlEnableRules(BOOL bForceDisable)
{
BOOL bEnable;
if (m_bReadOnly || !(BST_CHECKED == IsDlgButtonChecked(IDC_WORKINGSET_CHK)) || bForceDisable)
bEnable = FALSE;
else
bEnable = TRUE;
UINT ids[] = { IDC_MINWS, IDC_MAXWS, IDC_MINWS_SPIN, IDC_MAXWS_SPIN };
for (int i = 0; i < ARRAY_SIZE(ids); i++)
::EnableWindow(GetDlgItem(ids[i]), bEnable);
::EnableWindow(GetDlgItem(IDC_WORKINGSET_CHK), !(m_bReadOnly || bForceDisable));
}
BOOL CMGMTMemoryPage::OnSetActive()
{
if ( m_pProcContainer )
{
if (m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
ApplyControlEnableRules(TRUE);
else
ApplyControlEnableRules(FALSE);
}
return TRUE;
}
LRESULT CMGMTMemoryPage::OnSpin(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
if (idCtrl == IDC_MINWS_SPIN ||
idCtrl == IDC_MAXWS_SPIN ||
idCtrl == IDC_PROC_SPIN ||
idCtrl == IDC_JOB_SPIN )
{
NMUPDOWN * nmupdown = (NMUPDOWN *) pnmh;
__int64 value = (__int64) nmupdown->iPos + 1024 * (__int64) nmupdown->iDelta;
if ( value <= MAXLONG - 1 )
nmupdown->iDelta *= 1024;
}
bHandled = FALSE;
return 0;
}
LRESULT CMGMTMemoryPage::OnEditChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LONG_PTR PosErr = 0;
LRESULT pos;
if (wID == IDC_MINWS)
{
PageFields.Fields.minWS = FALSE;
pos = SendDlgItemMessage(IDC_MINWS_SPIN, UDM_GETPOS32, 0,(LPARAM) &PosErr);
if (!PosErr && pos <= MAXLONG - 1)
PageFields.Fields.minWS = (m_minWS != pos * 1024 );
pos = SendDlgItemMessage(IDC_MINWS_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);
}
else if (wID == IDC_MAXWS)
{
PageFields.Fields.maxWS = FALSE;
pos = SendDlgItemMessage(IDC_MAXWS_SPIN, UDM_GETPOS32, 0,(LPARAM) &PosErr);
if (!PosErr && pos <= MAXLONG - 1 )
PageFields.Fields.maxWS = (m_maxWS != pos * 1024);
}
else if (wID == IDC_PROCMEMORY)
{
PageFields.Fields.procmemorylimit = FALSE;
pos = SendDlgItemMessage(IDC_PROC_SPIN, UDM_GETPOS32, 0,(LPARAM) &PosErr);
if (!PosErr && pos <= MAXLONG - 1)
PageFields.Fields.procmemorylimit = (m_procmemorylimit != pos * 1024);
}
else if (wID == IDC_JOBMEMORY)
{
PageFields.Fields.jobmemorylimit = FALSE;
pos = SendDlgItemMessage(IDC_JOB_SPIN, UDM_GETPOS32, 0,(LPARAM) &PosErr);
if (!PosErr && pos <= MAXLONG - 1)
PageFields.Fields.jobmemorylimit = (m_jobmemorylimit != pos * 1024);
}
SetModified(PageFields.on);
bHandled = FALSE;
return 0;
}
LRESULT CMGMTMemoryPage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_WORKINGSET_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_WORKINGSET_CHK));
PageFields.Fields.WSchk = (m_WSchk != checked);
::EnableWindow(GetDlgItem(IDC_MINWS), checked);
::EnableWindow(GetDlgItem(IDC_MAXWS), checked);
::EnableWindow(GetDlgItem(IDC_MINWS_SPIN), checked);
::EnableWindow(GetDlgItem(IDC_MAXWS_SPIN), checked);
SetModified(PageFields.on);
}
else if (wID == IDC_PROCMEMORY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCMEMORY_CHK));
PageFields.Fields.procmemorylimitchk = (m_procmemorylimitchk != checked);
::EnableWindow(GetDlgItem(IDC_PROCMEMORY), checked);
::EnableWindow(GetDlgItem(IDC_PROC_SPIN), checked);
SetModified(PageFields.on);
}
else if (wID == IDC_JOBMEMORY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMORY_CHK));
PageFields.Fields.jobmemorylimitchk = (m_jobmemorylimitchk != checked);
::EnableWindow(GetDlgItem(IDC_JOBMEMORY), checked);
::EnableWindow(GetDlgItem(IDC_JOB_SPIN), checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTMemoryPage::OnApply()
{
if (m_bReadOnly || !PageFields.on) // read only, nothing modified
return TRUE;
if ( (m_pProcContainer && m_pProcContainer->Apply(GetParent())) ||
(m_pJobContainer && m_pJobContainer->Apply( GetParent())) )
{
PageFields.on = 0;
if (m_pProcContainer)
{
m_WSchk = m_pProcContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_WS_MINMAX;
m_minWS = m_pProcContainer->m_new.base.mgmtParms.minWS;
m_maxWS = m_pProcContainer->m_new.base.mgmtParms.maxWS;
}
else if (m_pJobContainer)
{
m_WSchk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_WS_MINMAX;
m_minWS = m_pJobContainer->m_new.base.mgmtParms.minWS;
m_maxWS = m_pJobContainer->m_new.base.mgmtParms.maxWS;
m_procmemorylimitchk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_PROC_MEMORY_LIMIT;
m_procmemorylimit = m_pJobContainer->m_new.base.mgmtParms.procMemoryLimit;
m_jobmemorylimitchk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMORY_LIMIT;
m_jobmemorylimit = m_pJobContainer->m_new.base.mgmtParms.jobMemoryLimit;
}
return TRUE;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Time Limits Page Implementation
CMGMTTimePage::CMGMTTimePage(int nTitle, CJobDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTTimePage>(nTitle),
m_pJobContainer(pContainer)
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_procusertimechk = FALSE;
m_procusertime = 0;
m_jobusertimechk = FALSE;
m_jobmsgontimelimit = FALSE;
m_jobusertime = 0;
m_psp.dwFlags |= PSP_HASHELP;
m_pJobContainer->AddRef();
}
CMGMTTimePage::~CMGMTTimePage()
{
m_pJobContainer->Release();
}
LRESULT CMGMTTimePage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
UpdateData(FALSE);
bHandled = FALSE;
return TRUE; // Let the system set the focus
}
LRESULT CMGMTTimePage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
IDCsToIDHs HelpMap[]={{IDC_PROCUSERTIME_FRAME, HELP_TIME_PROC_FRAME },
{IDC_PROCUSERTIME_CHK, HELP_TIME_PROC_APPLY },
{IDC_PROCUSERTIME, HELP_TIME_PROC_MAX },
{IDC_JOBUSERTIME_FRAME, HELP_TIME_GRP_FRAME},
{IDC_JOBUSERTIME_CHK, HELP_TIME_GRP_APPLY },
{IDC_JOBUSERTIME, HELP_TIME_GRP_MAX },
{IDC_JOBTIMELIMIT_TERM, HELP_TIME_GRP_TERMINATE },
{IDC_JOBTIMELIMIT_MSG, HELP_TIME_GRP_LOG },
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTTimePage::OnHelp()
{
MMCPropertyHelp(const_cast<TCHAR*>(HELP_ru_job_time));
return TRUE;
}
BOOL CMGMTTimePage::Validate(BOOL bSave)
{
TIME_VALUE procusertime;
TIME_VALUE jobusertime;
bool procusertimechk = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCUSERTIME_CHK));
bool jobusertimechk = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBUSERTIME_CHK));
if ( !ValidateTimeField(m_hWnd, IDC_PROCUSERTIME, procusertime) ||
(procusertimechk && procusertime < PC_MIN_TIME_LIMIT) )
{
HWND hWndCtl = GetDlgItem(IDC_PROCUSERTIME);
if(hWndCtl)
::SetFocus(hWndCtl);
MessageBeep(MB_ICONASTERISK);
CComBSTR bTemp;
if (bTemp.LoadString(IDS_TIMEENTRY))
MessageBox(bTemp.m_str, NULL, MB_OK | MB_ICONWARNING);
return FALSE;
}
if ( !ValidateTimeField(m_hWnd, IDC_JOBUSERTIME, jobusertime) ||
(jobusertimechk && jobusertime < PC_MIN_TIME_LIMIT) )
{
HWND hWndCtl = GetDlgItem(IDC_JOBUSERTIME);
if(hWndCtl)
::SetFocus(hWndCtl);
MessageBeep(MB_ICONASTERISK);
CComBSTR bTemp;
if (bTemp.LoadString(IDS_TIMEENTRY))
MessageBox(bTemp.m_str, NULL, MB_OK | MB_ICONWARNING);
return FALSE;
}
if (bSave)
{
m_pJobContainer->m_new.base.mgmtParms.procTimeLimitCNS = procusertime;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_PROC_TIME_LIMIT, procusertimechk);
m_pJobContainer->m_new.base.mgmtParms.jobTimeLimitCNS = jobusertime;
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_APPLY_JOB_TIME_LIMIT, jobusertimechk);
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_MSG_ON_JOB_TIME_LIMIT_HIT, (BST_CHECKED == IsDlgButtonChecked(IDC_JOBTIMELIMIT_MSG)));
}
return TRUE;
}
BOOL CMGMTTimePage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
ITEM_STR str;
CheckDlgButton(IDC_PROCUSERTIME_CHK, m_procusertimechk ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemText(IDC_PROCUSERTIME, FormatCNSTime(str, m_procusertime));
CheckDlgButton(IDC_JOBUSERTIME_CHK, m_jobusertimechk ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemText(IDC_JOBUSERTIME, FormatCNSTime(str, m_jobusertime));
ASSERT(IDC_JOBTIMELIMIT_TERM + 1 == IDC_JOBTIMELIMIT_MSG);
CheckRadioButton(IDC_JOBTIMELIMIT_TERM, IDC_JOBTIMELIMIT_MSG, m_jobmsgontimelimit ? IDC_JOBTIMELIMIT_MSG : IDC_JOBTIMELIMIT_TERM );
if (m_bReadOnly || !m_procusertimechk)
DisableControl(IDC_PROCUSERTIME);
if (m_bReadOnly || !m_jobusertimechk)
{
DisableControl(IDC_JOBUSERTIME);
DisableControl(IDC_JOBTIMELIMIT_TERM);
DisableControl(IDC_JOBTIMELIMIT_MSG);
}
if (m_bReadOnly)
{
DisableControl(IDC_PROCUSERTIME_CHK);
DisableControl(IDC_JOBUSERTIME_CHK);
}
return TRUE;
}
}
LRESULT CMGMTTimePage::OnEditChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
TIME_VALUE time;
if (wID == IDC_PROCUSERTIME)
{
PageFields.Fields.procusertime = FALSE;
if ( ValidateTimeField(m_hWnd, wID, time) )
PageFields.Fields.procusertime = (m_procusertime != time);
}
else if (wID == IDC_JOBUSERTIME)
{
PageFields.Fields.jobusertime = FALSE;
if ( ValidateTimeField(m_hWnd, wID, time) )
PageFields.Fields.jobusertime = (m_jobusertime != time);
}
SetModified(PageFields.on);
bHandled = FALSE;
return 0;
}
LRESULT CMGMTTimePage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_PROCUSERTIME_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCUSERTIME_CHK));
PageFields.Fields.procusertimechk = (m_procusertimechk != checked);
::EnableWindow(GetDlgItem(IDC_PROCUSERTIME), checked);
SetModified(PageFields.on);
}
else if (wID == IDC_JOBUSERTIME_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBUSERTIME_CHK));
PageFields.Fields.jobusertimechk = (m_jobusertimechk != checked);
::EnableWindow(GetDlgItem(IDC_JOBUSERTIME), checked);
::EnableWindow(GetDlgItem(IDC_JOBTIMELIMIT_TERM), checked);
::EnableWindow(GetDlgItem(IDC_JOBTIMELIMIT_MSG), checked);
SetModified(PageFields.on);
}
else if (wID == IDC_JOBTIMELIMIT_TERM)
{
bool checked = !(BST_CHECKED == IsDlgButtonChecked(IDC_JOBTIMELIMIT_TERM));
PageFields.Fields.jobmsgontimelimit = (m_jobmsgontimelimit != checked);
SetModified(PageFields.on);
}
else if (wID == IDC_JOBTIMELIMIT_MSG)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBTIMELIMIT_MSG));
PageFields.Fields.jobmsgontimelimit = (m_jobmsgontimelimit != checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTTimePage::OnApply()
{
if (m_bReadOnly || !PageFields.on) // read only, nothing modified
return TRUE;
if (m_pJobContainer->Apply(GetParent()) )
{
PageFields.on = 0;
m_procusertime = m_pJobContainer->m_new.base.mgmtParms.procTimeLimitCNS;
m_procusertimechk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_PROC_TIME_LIMIT;
m_jobusertime = m_pJobContainer->m_new.base.mgmtParms.jobTimeLimitCNS;
m_jobusertimechk = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_TIME_LIMIT;
m_jobmsgontimelimit = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_MSG_ON_JOB_TIME_LIMIT_HIT;
return TRUE;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
// Advanced Page Implementation
CMGMTAdvancedPage::CMGMTAdvancedPage(int nTitle, CJobDetailContainer *pContainer) :
CMySnapInPropertyPageImpl<CMGMTAdvancedPage>(nTitle),
m_pJobContainer(pContainer)
{
ASSERT(sizeof(PageFields.on) == sizeof(PageFields));
PageFields.on = 0;
m_bReadOnly = FALSE;
m_endjob = FALSE;
m_unhandledexcept = FALSE;
m_breakaway = FALSE;
m_silentbreakaway = FALSE;
m_psp.dwFlags |= PSP_HASHELP;
m_pJobContainer->AddRef();
}
CMGMTAdvancedPage::~CMGMTAdvancedPage()
{
m_pJobContainer->Release();
}
LRESULT CMGMTAdvancedPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
UpdateData(FALSE);
bHandled = FALSE;
// Setting focus when a property page does not work...
return TRUE; // Let the system set the focus
}
LRESULT CMGMTAdvancedPage::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HELPINFO *phi = (HELPINFO*) lParam;
if (phi && phi->iContextType == HELPINFO_WINDOW)
{
IDCsToIDHs HelpMap[]={{IDC_ADV_FRAME, HELP_ADV_FRAME },
{IDC_ENDJOB_CHK, HELP_ADV_ENDGRP },
{IDC_UNHANDLEDEXCEPT_CHK, HELP_ADV_NODIEONEX },
{IDC_SILENTBREAKAWAY_CHK, HELP_ADV_SILENT_BREAKAWAY},
{IDC_BREAKAWAY_CHK, HELP_ADV_BREAKAWAY_OK },
{0,0} };
::WinHelp((HWND) phi->hItemHandle, ContextHelpFile, HELP_WM_HELP, (DWORD_PTR) &HelpMap);
return TRUE;
}
bHandled = FALSE;
return FALSE;
}
BOOL CMGMTAdvancedPage::OnHelp()
{
MMCPropertyHelp(const_cast<TCHAR*>(HELP_ru_job_adv));
return TRUE;
}
BOOL CMGMTAdvancedPage::Validate(BOOL bSave)
{
if (bSave)
{
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_END_JOB_WHEN_EMPTY, (BST_CHECKED == IsDlgButtonChecked(IDC_ENDJOB_CHK)));
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_SET_DIE_ON_UH_EXCEPTION, (BST_CHECKED == IsDlgButtonChecked(IDC_UNHANDLEDEXCEPT_CHK)));
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_SET_PROC_BREAKAWAY_OK, (BST_CHECKED == IsDlgButtonChecked(IDC_BREAKAWAY_CHK )));
SetMGMTFlag(m_pJobContainer->m_new.base.mgmtParms.mFlags, PCMFLAG_SET_SILENT_BREAKAWAY, (BST_CHECKED == IsDlgButtonChecked(IDC_SILENTBREAKAWAY_CHK)));
}
return TRUE;
}
BOOL CMGMTAdvancedPage::UpdateData(BOOL bSaveAndValidate)
{
if (bSaveAndValidate)
{
return Validate(TRUE);
}
else
{
CheckDlgButton(IDC_ENDJOB_CHK, m_endjob ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_UNHANDLEDEXCEPT_CHK, m_unhandledexcept ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_BREAKAWAY_CHK, m_breakaway ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(IDC_SILENTBREAKAWAY_CHK, m_silentbreakaway ? BST_CHECKED : BST_UNCHECKED);
if (m_bReadOnly)
{
DisableControl(IDC_ENDJOB_CHK);
DisableControl(IDC_UNHANDLEDEXCEPT_CHK);
DisableControl(IDC_BREAKAWAY_CHK);
DisableControl(IDC_SILENTBREAKAWAY_CHK);
}
return TRUE;
}
}
LRESULT CMGMTAdvancedPage::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wID == IDC_BREAKAWAY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_BREAKAWAY_CHK));
PageFields.Fields.breakaway = (m_breakaway != checked);
SetModified(PageFields.on);
}
else if (wID == IDC_SILENTBREAKAWAY_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_SILENTBREAKAWAY_CHK));
PageFields.Fields.silentbreakaway = (m_silentbreakaway != checked);
SetModified(PageFields.on);
}
else if (wID == IDC_ENDJOB_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_ENDJOB_CHK));
PageFields.Fields.endjob = (m_endjob != checked);
SetModified(PageFields.on);
}
else if (wID == IDC_UNHANDLEDEXCEPT_CHK)
{
bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_UNHANDLEDEXCEPT_CHK));
PageFields.Fields.unhandledexcept = (m_unhandledexcept != checked);
SetModified(PageFields.on);
}
bHandled = FALSE;
return 0;
}
BOOL CMGMTAdvancedPage::OnApply()
{
if (m_bReadOnly || !PageFields.on)
return TRUE;
if (m_pJobContainer->Apply( GetParent() ))
{
PageFields.on = 0;
m_endjob = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_END_JOB_WHEN_EMPTY;
m_unhandledexcept = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_SET_DIE_ON_UH_EXCEPTION;
m_breakaway = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_SET_PROC_BREAKAWAY_OK;
m_silentbreakaway = m_pJobContainer->m_new.base.mgmtParms.mFlags & PCMFLAG_SET_SILENT_BREAKAWAY;
return TRUE;
}
return FALSE;
}
#if _MSC_VER >= 1200
#pragma warning( pop )
#endif