windows-xp/Source/XPSP1/NT/sdktools/proccon/snapin/managementpages.cpp

/*======================================================================================//
|  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