/*======================================================================================//
|  Process Control                                                                      //
|                                                                                       //
|Copyright (c) 1998  Sequent Computer Systems, Incorporated.  All rights reserved.      //
|                                                                                       //
|File Name:    ManagementRuleWizards.cpp                                                //
|                                                                                       //
|Description:  Implementation of process management rule wizards                        //
|                                                                                       //
|Created:      Paul Skoglund 09-1998                                                    //
|                                                                                       //
|Rev History:                                                                           //
|                                                                                       //
|=======================================================================================*/

#include "stdafx.h"

#include "ManagementRuleWizards.h"
#include "ManagementPages.h"


using std::list<tstring>;


bool GetGrpNameList(PCid id, list<tstring> &jobs)
{
  PCINT32 res  = 0;

  PCJobSummary jlist[min((COM_BUFFER_SIZE/sizeof(PCJobSummary)), 100)];

  memset(&jlist[0], 0, sizeof(PCJobSummary));

  do
  {
    res = PCGetJobSummary( id, jlist, ARRAY_SIZE(jlist) * sizeof(PCJobSummary));
    if (res < 0 )
    {
      PCULONG32 err = PCGetLastError(id);
      return false;
    }

    if (res > 0)
    {
      for (INT32 i = 0; i < res; i++)
      {
        jobs.push_back(jlist[i].jobName);
      }
      memcpy(&jlist[0], &jlist[res-1], sizeof(PCJobSummary));
    }
  } while (res > 0 && PCERROR_MORE_DATA == PCGetLastError(id) );

  return true;
}

list<tstring> *GetGrpNameList(PCid id)
{
  list<tstring> *jlist = new list<tstring>;

  if (jlist)
    GetGrpNameList(id, *jlist);

  return jlist;
}

BOOL IsValidName(const CComBSTR &bStr, const BOOL nullOK)
{
  ASSERT(PROC_NAME_LEN == JOB_NAME_LEN);

  const TCHAR BLANK = _T(' ');

  if ( !bStr.Length() )  // empty string
    return nullOK;

  unsigned int len = bStr.Length();
  if ( len > JOB_NAME_LEN )
    return FALSE;

  if ( bStr[0] == BLANK || bStr[len - 1] == BLANK )
     return FALSE;  // leading/trailing blank

  if ( len != _tcscspn( bStr, _T("\\,\"")) )
    return FALSE; // hit invalid character

  return TRUE;
}


BOOL ProcRuleWizard(int nTitle, const list<tstring> &jobsdefined, PCProcDetail &out, const PCSystemParms &SystemParms, PROC_NAME *procName /* = NULL */)
{
  PROPSHEETHEADER sheet;
  HPROPSHEETPAGE  hPages[5];

  memset(&sheet, 0, sizeof(PROPSHEETHEADER));
  sheet.dwSize = sizeof(PROPSHEETHEADER);
  sheet.dwFlags = PSH_WIZARD; // | PSH_USEICONID;
  sheet.hwndParent = ::GetActiveWindow();
  sheet.hInstance = _Module.GetResourceInstance();
  sheet.pszIcon = NULL;                               // MAKEINTRESOURCE(IDI_MANAGEMENT);
  sheet.pszCaption = MAKEINTRESOURCE(nTitle);
  sheet.nPages = ARRAY_SIZE(hPages);
  sheet.nStartPage = 0;
  sheet.phpage = &hPages[0];
  sheet.pfnCallback = NULL;

#if USE_WIZARD97_WATERMARKS
  sheet.dwFlags |= PSH_WIZARD97 | PSH_WATERMARK;
  sheet.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK1);  
#endif
#if USE_WIZARD97_HEADERS
  sheet.dwFlags |= PSH_WIZARD97 | PSH_HEADER;
  sheet.pszbmHeader    = MAKEINTRESOURCE(IDB_HEADER1);
#endif

  memset(&out, 0, sizeof(PCProcDetail));

  if (procName)
    _tcscpy(out.base.procName, *procName);

  // set any ProcDetail Defaults...

  //memset(out.base.memberOfJobName, 0, sizeof(JOB_NAME));
  //SetMGMTFlag(out.base.mgmtParms.mFlags, PCMFLAG_APPLY_JOB_MEMBERSHIP, FALSE);

  //out.base.mgmtParms.affinity = 0;
  //SetMGMTFlag(out.base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, FALSE);

  out.base.mgmtParms.priority = PCPrioNormal;
  //SetMGMTFlag(out.base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, FALSE);

  CProcNameWiz *pPage1 = new CProcNameWiz(CProcNameWiz::FIRST_PAGE, nTitle, &out);
  if (!pPage1)
    return -1;
  hPages[0] = pPage1->Create();

  if (procName)
    pPage1->SetNoNameChange();

  CProcGrpMemberWiz *pPage2 = new CProcGrpMemberWiz(CProcGrpMemberWiz::MIDDLE_PAGE, nTitle, &out, jobsdefined);
  if (!pPage2)
  {
    delete pPage1;
    return -1;
  }
  hPages[1] = pPage2->Create();

  CAffinityWiz *pPage3 = new CAffinityWiz(CAffinityWiz::MIDDLE_PAGE, nTitle, &out, SystemParms.processorMask);
  if (!pPage3)
  {
    delete pPage1;
    delete pPage2;
    return -1;
  }
  hPages[2] = pPage3->Create();

  CPriorityWiz *pPage4 = new CPriorityWiz(CPriorityWiz::MIDDLE_PAGE, nTitle, &out);
  if (!pPage4)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    return -1;
  }
  hPages[3] = pPage4->Create();

  CWorkingSetWiz *pPage5 = new CWorkingSetWiz(CWorkingSetWiz::LAST_PAGE, nTitle, &out);
  if (!pPage5)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    return -1;
  }
  hPages[4] = pPage5->Create();

  INT_PTR id = PropertySheet(&sheet);
  if (id > 0)
    return TRUE;

  return FALSE;
}


BOOL GroupRuleWizard(int nTitle, PCJobDetail &out, const PCSystemParms &SystemParms, JOB_NAME *jobName /* = NULL */)
{
  PROPSHEETHEADER sheet;
  HPROPSHEETPAGE  hPages[10];

  memset(&sheet, 0, sizeof(PROPSHEETHEADER));
  sheet.dwSize = sizeof(PROPSHEETHEADER);
  sheet.dwFlags = PSH_WIZARD;
  sheet.hwndParent = ::GetActiveWindow();
  sheet.hInstance = _Module.GetResourceInstance();
  sheet.pszIcon = NULL;
  sheet.pszCaption = MAKEINTRESOURCE(nTitle);
  sheet.nPages = ARRAY_SIZE(hPages);
  sheet.nStartPage = 0;
  sheet.phpage = &hPages[0];
  sheet.pfnCallback = NULL;

#if USE_WIZARD97_WATERMARKS
  sheet.dwFlags        |= PSH_WIZARD97 | PSH_WATERMARK;
  sheet.pszbmWatermark  = MAKEINTRESOURCE(IDB_WATERMARK1);
#endif
#if USE_WIZARD97_HEADERS
  sheet.dwFlags        |= PSH_WIZARD97 | PSH_HEADER;
  sheet.pszbmHeader     = MAKEINTRESOURCE(IDB_HEADER1);
#endif

  bool              applyschedulingclass;
  SCHEDULING_CLASS  schedulingclass;

  bool              procmemorylimitchk;
  MEMORY_VALUE      procmemorylimit;
  bool              jobmemorylimitchk;
  MEMORY_VALUE      jobmemorylimit;

  bool              processcountchk;
  PROC_COUNT        processcount;

  bool              procusertimechk;
  TIME_VALUE        procusertime;

  bool              jobusertimechk;
  TIME_VALUE        jobusertime;
  bool              jobmsgontimelimit;

  bool              breakaway;
  bool              silentbreakaway;

  bool              endjob;
  bool              unhandledexcept;

  memset(&out, 0, sizeof(PCJobDetail));

  // set any JobDetail Defaults...
  if (jobName)
    _tcscpy(out.base.jobName, *jobName);

  //out.base.mgmtParms.affinity = 0;
  //SetMGMTFlag(out.base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, FALSE);

  out.base.mgmtParms.priority = PCPrioNormal;
  //SetMGMTFlag(out.base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, FALSE);

  CJobNameWiz *pPage1 = new CJobNameWiz(CJobNameWiz::FIRST_PAGE, nTitle, &out);
  if (!pPage1)
    return -1;
  hPages[0] = pPage1->Create();

  if (jobName)
    pPage1->SetNoNameChange();

  CAffinityWiz *pPage2 = new CAffinityWiz(CAffinityWiz::MIDDLE_PAGE, nTitle, &out, SystemParms.processorMask);
  if (!pPage2)
  {
    delete pPage1;
    return -1;
  }
  hPages[1] = pPage2->Create();


  CPriorityWiz *pPage3 = new CPriorityWiz(CPriorityWiz::MIDDLE_PAGE, nTitle, &out);
  if (!pPage3)
  {
    delete pPage1;
    delete pPage2;
    return -1;
  }
  hPages[2] = pPage3->Create();

  CSchedulingClassWiz *pPage4 = new CSchedulingClassWiz(CSchedulingClassWiz::MIDDLE_PAGE, nTitle, &schedulingclass, &applyschedulingclass);
  if (!pPage4)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    return -1;
  }
  hPages[3] = pPage4->Create();

  CWorkingSetWiz *pPage5 = new CWorkingSetWiz(CWorkingSetWiz::MIDDLE_PAGE, nTitle, &out);
  if (!pPage5)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    return -1;
  }
  hPages[4] = pPage5->Create();

  CCommittedMemoryWiz *pPage6 = new CCommittedMemoryWiz(CCommittedMemoryWiz::MIDDLE_PAGE, nTitle, &procmemorylimit, &procmemorylimitchk, &jobmemorylimit, &jobmemorylimitchk);
  if (!pPage6)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    delete pPage5;
    return -1;
  }
  hPages[5] = pPage6->Create();

  CProcCountWiz *pPage7 = new CProcCountWiz(CProcCountWiz::MIDDLE_PAGE, nTitle, &processcount, &processcountchk);
  if (!pPage7)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    delete pPage5;
    delete pPage6;
    return -1;
  }
  hPages[6] = pPage7->Create();

  CTimeWiz *pPage8 = new CTimeWiz(CTimeWiz::MIDDLE_PAGE, nTitle, &procusertime, &procusertimechk, &jobusertime, &jobusertimechk, &jobmsgontimelimit);
  if (!pPage8)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    delete pPage5;
    delete pPage6;
    delete pPage7;
    return -1;
  }
  hPages[7] = pPage8->Create();

  CAdvancedWiz *pPage9 = new CAdvancedWiz(CAdvancedWiz::MIDDLE_PAGE, nTitle, &endjob, &unhandledexcept);
  if (!pPage9)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    delete pPage5;
    delete pPage6;
    delete pPage7;
    delete pPage8;
    return -1;
  }
  hPages[8] = pPage9->Create();


  CAdvBreakawayWiz *pPage10 = new CAdvBreakawayWiz(CAdvBreakawayWiz::LAST_PAGE, nTitle, &breakaway, &silentbreakaway);
  if (!pPage10)
  {
    delete pPage1;
    delete pPage2;
    delete pPage3;
    delete pPage4;
    delete pPage5;
    delete pPage6;
    delete pPage7;
    delete pPage8;
    delete pPage9;
    return -1;
  }
  hPages[9] = pPage10->Create();

  INT_PTR id = PropertySheet(&sheet);
  if (id > 0)
  {
    out.base.mgmtParms.schedClass = schedulingclass;
    if (applyschedulingclass)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_SCHEDULING_CLASS;

    out.base.mgmtParms.procMemoryLimit = procmemorylimit;
    if (procmemorylimitchk)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_PROC_MEMORY_LIMIT;

    out.base.mgmtParms.jobMemoryLimit = jobmemorylimit;
    if (jobmemorylimitchk)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_JOB_MEMORY_LIMIT;

    out.base.mgmtParms.procCountLimit = processcount;
    if (processcountchk)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_PROC_COUNT_LIMIT;

    out.base.mgmtParms.procTimeLimitCNS = procusertime;
    if (procusertimechk)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_PROC_TIME_LIMIT;

    out.base.mgmtParms.jobTimeLimitCNS = jobusertime;
    if (jobusertimechk)
      out.base.mgmtParms.mFlags |= PCMFLAG_APPLY_JOB_TIME_LIMIT;

    if (jobmsgontimelimit)
      out.base.mgmtParms.mFlags |= PCMFLAG_MSG_ON_JOB_TIME_LIMIT_HIT;

    if (endjob)
      out.base.mgmtParms.mFlags |= PCMFLAG_END_JOB_WHEN_EMPTY;
    if (unhandledexcept)
      out.base.mgmtParms.mFlags |= PCMFLAG_SET_DIE_ON_UH_EXCEPTION;

    if (breakaway)
      out.base.mgmtParms.mFlags |= PCMFLAG_SET_PROC_BREAKAWAY_OK;
    if (silentbreakaway)
      out.base.mgmtParms.mFlags |= PCMFLAG_SET_SILENT_BREAKAWAY;

    return TRUE;
  }
  return FALSE;
}

///////////////////////////////////////////////////////////////////////////
//  ProcName

CProcNameWiz::CProcNameWiz(WIZ_POSITION pos, int nTitle, PCProcDetail *ProcDetail) :
   CMySnapInPropertyWizardImpl<CProcNameWiz>(pos, nTitle), m_pProcDetail(ProcDetail)
{
  ASSERT(m_pProcDetail);

  m_bReadOnly     = FALSE;
  m_bNoNameChange = FALSE;
}

CProcNameWiz::~CProcNameWiz()
{
}


LRESULT CProcNameWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CProcNameWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_proc_name);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CProcNameWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    CComBSTR bName;
    if (!GetDlgItemText( IDC_NAME, bName.m_str ) ||
      !IsValidName(bName, FALSE) )
    {
      HWND hWndCtl = GetDlgItem(IDC_NAME);
      if(hWndCtl)
        ::SetFocus(hWndCtl);
      ITEM_STR strOut;
      LoadStringHelper(strOut, IDS_JOBNAME_WARNING);
      MessageBox(strOut, NULL, MB_OK | MB_ICONWARNING);
      return FALSE;
    }

    CComBSTR bComment;
    if ( !GetDlgItemText(IDC_COMMENT, bComment.m_str) )
      bComment = _T("");
    if (bComment.Length() > RULE_DESCRIPTION_LEN)
    {
      HWND hWndCtl = GetDlgItem(IDC_COMMENT);
      if(hWndCtl)
        ::SetFocus(hWndCtl);
      MessageBeep(MB_ICONASTERISK);
      return FALSE;
    }

    // everything validated so save 
    _tcscpy(m_pProcDetail->base.procName, bName);
    _tcscpy(m_pProcDetail->base.mgmtParms.description, bComment);

    return TRUE;
  }
  else
  {
    VERIFY(SetDlgItemText( IDC_NAME, m_pProcDetail->base.procName ));
    SendDlgItemMessage( IDC_NAME, EM_SETLIMITTEXT, PROC_NAME_LEN, 0);

    VERIFY(SetDlgItemText( IDC_COMMENT, m_pProcDetail->base.mgmtParms.description ));
    SendDlgItemMessage( IDC_COMMENT, EM_SETLIMITTEXT, RULE_DESCRIPTION_LEN, 0);

    if (m_bReadOnly)
    {
      DisableControl(IDC_NAME);
      DisableControl(IDC_COMMENT);
    }

    if (m_bNoNameChange)
      DisableControl(IDC_NAME);

    return TRUE;
  }
}


BOOL CProcNameWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  JobMember

CProcGrpMemberWiz::CProcGrpMemberWiz(WIZ_POSITION pos, int nTitle, PCProcDetail *ProcDetail, const list<tstring> &jobsdefined) 
    : CMySnapInPropertyWizardImpl<CProcGrpMemberWiz>(pos, nTitle), 
      m_pProcDetail(ProcDetail), m_JobsExisting(jobsdefined)
{
  ASSERT(ProcDetail);

  m_bReadOnly = FALSE;
}

CProcGrpMemberWiz::~CProcGrpMemberWiz()
{
}


LRESULT CProcGrpMemberWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CProcGrpMemberWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_pr_job_name);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CProcGrpMemberWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    CComBSTR bStr;
    bool bChecked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMBER_CHK));

    if (!GetDlgItemText( IDC_JOB_LIST, bStr.m_str ) )
      bStr = _T("");

    if ( !IsValidName(bStr, !bChecked) )
    {
      HWND hWndCtl = NULL;
      if (bChecked)
        hWndCtl = GetDlgItem(IDC_JOB_LIST);
      else
        hWndCtl = GetDlgItem(IDC_JOBMEMBER_CHK);
      if(hWndCtl)
        ::SetFocus(hWndCtl);

      ITEM_STR strOut;
      LoadStringHelper(strOut, IDS_JOBNAME_WARNING);
      MessageBox(strOut, NULL, MB_OK | MB_ICONWARNING);

      return FALSE;
    }

    SetMGMTFlag(m_pProcDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_JOB_MEMBERSHIP, bChecked);
    _tcscpy(m_pProcDetail->base.memberOfJobName, bStr);

    return TRUE;
  }
  else
  {
  list<tstring>::const_iterator i;
  for (i = m_JobsExisting.begin(); i != m_JobsExisting.end(); i++)
    SendDlgItemMessage(IDC_JOB_LIST, CB_ADDSTRING, 0, (LPARAM) (*i).c_str() );

  SendDlgItemMessage( IDC_JOB_LIST, CB_LIMITTEXT, JOB_NAME_LEN,  0);

    VERIFY(SetDlgItemText( IDC_JOB_LIST,  m_pProcDetail->base.memberOfJobName ));

    CheckDlgButton(IDC_JOBMEMBER_CHK, (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP) ? BST_CHECKED : BST_UNCHECKED);

    if (m_bReadOnly || !(m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP) )
      DisableControl(IDC_JOB_LIST);

    if (m_bReadOnly)
      DisableControl(IDC_JOBMEMBER_CHK);

    return TRUE;
  }
}

LRESULT CProcGrpMemberWiz::OnJobChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_JOBMEMBER_CHK )
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMBER_CHK));
    ::EnableWindow(GetDlgItem(IDC_JOB_LIST), checked);
  }

  bHandled = FALSE;
  return 0;
}

BOOL CProcGrpMemberWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  Affinity
CAffinityWiz::CAffinityWiz(WIZ_POSITION pos, int nTitle, PCProcDetail *ProcDetail, AFFINITY ProcessorMask) : 
              CMySnapInPropertyWizardImpl<CAffinityWiz>(pos, nTitle),
              m_PageType(PROCESS_PAGE), m_pProcDetail(ProcDetail), m_pJobDetail(NULL),
              m_ProcessorMask(ProcessorMask)
{
  Initialize();
}

CAffinityWiz::CAffinityWiz(WIZ_POSITION pos, int nTitle, PCJobDetail *JobDetail, AFFINITY ProcessorMask) :
              CMySnapInPropertyWizardImpl<CAffinityWiz>(pos, nTitle),
              m_PageType(JOB_PAGE), m_pProcDetail(NULL), m_pJobDetail(JobDetail),
              m_ProcessorMask(ProcessorMask)
{
  Initialize();
}

CAffinityWiz::~CAffinityWiz()
{
}

void CAffinityWiz::Initialize()
{
  ASSERT(m_PageType == PROCESS_PAGE && m_pProcDetail || m_PageType == JOB_PAGE && m_pJobDetail);

  m_bReadOnly = FALSE;
}

LRESULT CAffinityWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UINT nPromptID;
  if (m_PageType == PROCESS_PAGE)
    nPromptID = IDS_AFFINITY_JOBWARNING;
  else
    nPromptID = IDS_AFFINITY_NOJOBWARNING;

  CComBSTR bStr;
  if (bStr.LoadString(nPromptID))
    VERIFY(SetDlgItemText(IDC_AFFINITY_PROMPT, bStr.m_str));

  UpdateData(FALSE);
  bHandled = FALSE;
  return TRUE;  // Let the system set the focus
}

LRESULT CAffinityWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_affinity);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CAffinityWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    AFFINITY affinity = 0;
    bool     affinitychk = (BST_CHECKED == IsDlgButtonChecked(IDC_AFFINITY_CHK));

    int i;
    for ( i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
    {
      if ( BST_UNCHECKED != IsDlgButtonChecked(i) )
        affinity |= (ProcessorBit << (i - IDC_AFFINITY1));
    }

    // Warn the user if the affinity and processor mask don't
    // reference at least one processor
    if (affinitychk && !(affinity & m_ProcessorMask) )
    {
      ITEM_STR strOut;
      LoadStringHelper(strOut, IDS_AFFINITY_WARNING);
      if (IDYES != MessageBox(strOut, NULL, MB_YESNO | MB_ICONQUESTION))
        return FALSE;
    }

    if (m_PageType == PROCESS_PAGE)
    {
      m_pProcDetail->base.mgmtParms.affinity = affinity;
      SetMGMTFlag(m_pProcDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, affinitychk);
    }
    else if (m_PageType == JOB_PAGE)
    {
      m_pJobDetail->base.mgmtParms.affinity  = affinity;
      SetMGMTFlag(m_pJobDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_AFFINITY, affinitychk);
    }

    return TRUE;
  }
  else
  {
    ASSERT(IDC_AFFINITY1 + 63 == IDC_AFFINITY64);

    AFFINITY affinity    = 0;
    bool     affinitychk = FALSE;

    if ( m_PageType == PROCESS_PAGE )
    {
      affinity = m_pProcDetail->base.mgmtParms.affinity;
      if (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_AFFINITY)
        affinitychk = TRUE;
    }
    else if ( m_PageType == JOB_PAGE )
    {
      affinity = m_pJobDetail->base.mgmtParms.affinity;
      if (m_pJobDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_AFFINITY)
        affinitychk = TRUE;
    }

    for(int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
    {
      if (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, affinitychk ? BST_CHECKED : BST_UNCHECKED);

    ApplyControlEnableRules(FALSE);

    return TRUE;
  }
}

void CAffinityWiz::ApplyControlEnableRules(BOOL bForceDisable)
{
  BOOL bEnable;
  if (m_bReadOnly || !(BST_CHECKED == IsDlgButtonChecked(IDC_AFFINITY_CHK)) || 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 CAffinityWiz::OnSetActive()
{
  if ( m_PageType == PROCESS_PAGE )
  {
    if (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
      ApplyControlEnableRules(TRUE);
    else
      ApplyControlEnableRules(FALSE);
  }
  return TRUE;
}

LRESULT CAffinityWiz::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);
    }
  }

  bHandled = FALSE;
  return 0;
}

LRESULT CAffinityWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_AFFINITY_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_AFFINITY_CHK));
    for (int i = IDC_AFFINITY1; i <= IDC_AFFINITY64; i++)
      ::EnableWindow(GetDlgItem(i), checked);
  }

  bHandled = FALSE;
  return 0;
}

BOOL CAffinityWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  Priority

CPriorityWiz::CPriorityWiz(WIZ_POSITION pos, int nTitle, PCProcDetail *ProcDetail) :
               CMySnapInPropertyWizardImpl<CPriorityWiz>(pos, nTitle),
               m_PageType(PROCESS_PAGE), m_pProcDetail(ProcDetail), m_pJobDetail(NULL)
{
  Initialize();
}

CPriorityWiz::CPriorityWiz(WIZ_POSITION pos, int nTitle, PCJobDetail *JobDetail) :
               CMySnapInPropertyWizardImpl<CPriorityWiz>(pos, nTitle),
               m_PageType(JOB_PAGE), m_pProcDetail(NULL), m_pJobDetail(JobDetail)
{
  Initialize();
}

CPriorityWiz::~CPriorityWiz()
{
}

void CPriorityWiz::Initialize()
{
  ASSERT(m_PageType == PROCESS_PAGE && m_pProcDetail || m_PageType == JOB_PAGE && m_pJobDetail);

  m_bReadOnly = FALSE;
}


LRESULT CPriorityWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UINT nPromptID;
  if (m_PageType == PROCESS_PAGE)
    nPromptID = IDS_PRIORITY_JOBWARNING;
  else
    nPromptID = IDS_PRIORITY_NOJOBWARNING;

  CComBSTR bStr;
  if (bStr.LoadString(nPromptID))
    VERIFY(SetDlgItemText(IDC_PRIORITY_PROMPT, bStr.m_str));

  UpdateData(FALSE);
  bHandled = FALSE;
  return TRUE;  // Let the system set the focus
}

LRESULT CPriorityWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_priority);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CPriorityWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    BOOL prioritychk = (BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK));
    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 (m_PageType == PROCESS_PAGE)
    {
      m_pProcDetail->base.mgmtParms.priority = p;
      SetMGMTFlag(m_pProcDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, prioritychk);
    }
    else if (m_PageType == JOB_PAGE)
    {
      m_pJobDetail->base.mgmtParms.priority  = p;
      SetMGMTFlag(m_pJobDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_PRIORITY, prioritychk);
    }
    return TRUE;
  }
  else
  {
    BOOL     prioritychk = FALSE;
    PRIORITY p           = PCPrioNormal;
    if (m_PageType == PROCESS_PAGE)
    {
      if (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_PRIORITY)
        prioritychk = TRUE;
      m_pProcDetail->base.mgmtParms.priority = p;
    }
    else if (m_PageType == JOB_PAGE)
    {
      if (m_pJobDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_PRIORITY)
        prioritychk = TRUE;
      m_pJobDetail->base.mgmtParms.priority  = p;
    }

    CheckDlgButton(IDC_PRIORITY_CHK, prioritychk ? BST_CHECKED : BST_UNCHECKED);

    CheckRadioButton(IDC_LOW, IDC_REALTIME, PriorityToID(p));

    ApplyControlEnableRules(FALSE);

    return TRUE;
  }
}

void CPriorityWiz::ApplyControlEnableRules(BOOL bForceDisable)
{
  BOOL bEnable;
  if (m_bReadOnly || !(BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK)) || 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 CPriorityWiz::OnSetActive()
{
  if ( m_PageType == PROCESS_PAGE )
  {
    if (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
      ApplyControlEnableRules(TRUE);
    else
      ApplyControlEnableRules(FALSE);
  }
  return TRUE;
}

LRESULT CPriorityWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_PRIORITY_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PRIORITY_CHK));

    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);
  }

  bHandled = FALSE;
  return 0;
}

BOOL CPriorityWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}


///////////////////////////////////////////////////////////////////////////
//  JobName

CJobNameWiz::CJobNameWiz(WIZ_POSITION pos, int nTitle, PCJobDetail *JobDetail) 
    : CMySnapInPropertyWizardImpl<CJobNameWiz>(pos, nTitle), 
    m_pJobDetail(JobDetail)
{
  ASSERT(m_pJobDetail);

  m_bReadOnly     = FALSE;
  m_bNoNameChange = FALSE;
}

CJobNameWiz::~CJobNameWiz()
{
}

LRESULT CJobNameWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CJobNameWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_name);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CJobNameWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    CComBSTR bName;
    if (!GetDlgItemText( IDC_NAME, bName.m_str ) || 
        !IsValidName(bName, FALSE) )
    {
      HWND hWndCtl = GetDlgItem(IDC_NAME);
      if(hWndCtl)
        ::SetFocus(hWndCtl);

      ITEM_STR strOut;
      LoadStringHelper(strOut, IDS_JOBNAME_WARNING);
      MessageBox(strOut, NULL, MB_OK | MB_ICONWARNING);

      return FALSE;
    }
    CComBSTR bComment;
    if ( !GetDlgItemText(IDC_COMMENT, bComment.m_str) )
      bComment = _T("");
    if (bComment.Length() > RULE_DESCRIPTION_LEN)
    {
      HWND hWndCtl = GetDlgItem(IDC_COMMENT);
      if(hWndCtl)
        ::SetFocus(hWndCtl);
      MessageBeep(MB_ICONASTERISK);
      return FALSE;
    }

    // everything validated so save 
    _tcscpy(m_pJobDetail->base.jobName, bName);
    _tcscpy(m_pJobDetail->base.mgmtParms.description, bComment);

    return TRUE;
  }
  else
  {
    VERIFY(SetDlgItemText( IDC_NAME, m_pJobDetail->base.jobName ));
    SendDlgItemMessage( IDC_NAME, EM_SETLIMITTEXT, JOB_NAME_LEN, 0);

    VERIFY(SetDlgItemText( IDC_COMMENT, m_pJobDetail->base.mgmtParms.description ));
    SendDlgItemMessage( IDC_COMMENT, EM_SETLIMITTEXT, RULE_DESCRIPTION_LEN, 0);

    if (m_bReadOnly)
    {
      DisableControl(IDC_NAME);
      DisableControl(IDC_COMMENT);
    }

    if (m_bNoNameChange)
      DisableControl(IDC_NAME);

    return TRUE;
  }
}

BOOL CJobNameWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  CSchedulingClassWiz

CSchedulingClassWiz::CSchedulingClassWiz(WIZ_POSITION pos, int nTitle, SCHEDULING_CLASS *sclass, bool *chk)
    : CMySnapInPropertyWizardImpl<CSchedulingClassWiz>(pos, nTitle), m_schedClass(*sclass), m_schedClasschk(*chk)
{
  m_bReadOnly = FALSE;

  m_schedClass    = 5;
  m_schedClasschk = FALSE;
}

CSchedulingClassWiz::~CSchedulingClassWiz()
{
}

LRESULT CSchedulingClassWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CSchedulingClassWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_sch);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CSchedulingClassWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    LRESULT pos = SendDlgItemMessage(IDC_SPIN, UDM_GETPOS, 0, 0);
    if (0 == HIWORD(pos) && LOWORD(pos) >= 0 && LOWORD(pos) <= 9 )
    {
      m_schedClass    = (SCHEDULING_CLASS) LOWORD(pos);
      m_schedClasschk = (BST_CHECKED == IsDlgButtonChecked(IDC_SCHEDULING_CHK));
      return TRUE;
    }

    HWND hWndCtl = GetDlgItem(IDC_SCLASS);
    if(hWndCtl)
      ::SetFocus(hWndCtl);
    MessageBeep(MB_ICONASTERISK);
    return FALSE;
  }
  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 CSchedulingClassWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_SCHEDULING_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_SCHEDULING_CHK));

    ::EnableWindow(GetDlgItem(IDC_SCLASS), checked);
    ::EnableWindow(GetDlgItem(IDC_SPIN),   checked);
  }

  bHandled = FALSE;
  return 0;
}

BOOL CSchedulingClassWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  CWorkingSetWiz
CWorkingSetWiz::CWorkingSetWiz(WIZ_POSITION pos, int nTitle, PCProcDetail *ProcDetail) 
    : CMySnapInPropertyWizardImpl<CWorkingSetWiz>(pos, nTitle), m_pProcDetail(ProcDetail), m_pJobDetail(NULL)
{
  Initialize();
}

CWorkingSetWiz::CWorkingSetWiz(WIZ_POSITION pos, int nTitle, PCJobDetail *JobDetail)  
    : CMySnapInPropertyWizardImpl<CWorkingSetWiz>(pos, nTitle), m_pProcDetail(NULL), m_pJobDetail(JobDetail)
{
  Initialize();
}

void CWorkingSetWiz::Initialize()
{
  m_bReadOnly = FALSE;
}

CWorkingSetWiz::~CWorkingSetWiz()
{
}

LRESULT CWorkingSetWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CWorkingSetWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_mem);
    if (m_pProcDetail)
      pTopic = const_cast<TCHAR*>(HELP_ru_workset);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CWorkingSetWiz::Validate(BOOL bSave)
{
  LONG_PTR         PosErr = 0;
  MEMORY_VALUE     minWS;
  MEMORY_VALUE     maxWS;

  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 (bSave)
  {

    if (m_pProcDetail)
    {
      SetMGMTFlag(m_pProcDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_WS_MINMAX, WSchk);
      m_pProcDetail->base.mgmtParms.minWS = minWS *1024;
      m_pProcDetail->base.mgmtParms.maxWS = maxWS *1024;

    }
    else if (m_pJobDetail)
    {
      SetMGMTFlag(m_pJobDetail->base.mgmtParms.mFlags, PCMFLAG_APPLY_WS_MINMAX, WSchk);
      m_pJobDetail->base.mgmtParms.minWS  = minWS * 1024;
      m_pJobDetail->base.mgmtParms.maxWS  = maxWS * 1024;
    }

  }
  return TRUE;
}

BOOL CWorkingSetWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    return Validate(TRUE);
  }
  else
  {
    BOOL        WSchk = FALSE;
    MEMORY_VALUE minWS = 0;
    MEMORY_VALUE maxWS = 0;

    if (m_pProcDetail)
    {
      WSchk = m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_WS_MINMAX;
      minWS = m_pProcDetail->base.mgmtParms.minWS;
      maxWS = m_pProcDetail->base.mgmtParms.maxWS;

    }
    else if (m_pJobDetail)
    {
      WSchk = m_pJobDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_WS_MINMAX;
      minWS = m_pJobDetail->base.mgmtParms.minWS;
      maxWS = m_pJobDetail->base.mgmtParms.maxWS;
    }
    if ( minWS/1024           > (MAXLONG - 1) ||
         maxWS/1024           > (MAXLONG - 1) )
      m_bReadOnly = TRUE;

    long minWSInK = (long) (minWS/1024);
    long maxWSInK = (long) (maxWS/1024);

    CheckDlgButton(IDC_WORKINGSET_CHK, 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 );

    ApplyControlEnableRules(FALSE);

    return TRUE;
  }
}

void CWorkingSetWiz::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, 0 };
  for (int i = 0; ids[i]; i++)
    ::EnableWindow(GetDlgItem(ids[i]), bEnable);

  ::EnableWindow(GetDlgItem(IDC_WORKINGSET_CHK), !(m_bReadOnly || bForceDisable));
}

BOOL CWorkingSetWiz::OnSetActive()
{
  if ( m_pProcDetail )
  {
    if (m_pProcDetail->base.mgmtParms.mFlags & PCMFLAG_APPLY_JOB_MEMBERSHIP)
      ApplyControlEnableRules(TRUE);
    else
      ApplyControlEnableRules(FALSE);
  }
  return TRUE;
}

LRESULT CWorkingSetWiz::OnSpin(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
  if (idCtrl == IDC_MINWS_SPIN ||
      idCtrl == IDC_MAXWS_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 CWorkingSetWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_WORKINGSET_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_WORKINGSET_CHK));
    ::EnableWindow(GetDlgItem(IDC_MINWS),      checked);
    ::EnableWindow(GetDlgItem(IDC_MAXWS),      checked);
    ::EnableWindow(GetDlgItem(IDC_MINWS_SPIN), checked);
    ::EnableWindow(GetDlgItem(IDC_MAXWS_SPIN), checked);
  }
  bHandled = FALSE;
  return 0;
}

BOOL CWorkingSetWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  CCommittedMemoryWiz

CCommittedMemoryWiz::CCommittedMemoryWiz(WIZ_POSITION pos, int nTitle, MEMORY_VALUE *procmemorylimit, bool *procmemorylimitchk, MEMORY_VALUE *jobmemorylimit, bool *jobmemorylimitchk) : 
    CMySnapInPropertyWizardImpl<CCommittedMemoryWiz>(pos, nTitle), 
    m_procmemorylimit(*procmemorylimit), m_procmemorylimitchk(*procmemorylimitchk),
    m_jobmemorylimit(*jobmemorylimit), m_jobmemorylimitchk(*jobmemorylimitchk)
{
  m_bReadOnly = FALSE;

  m_procmemorylimitchk = m_jobmemorylimitchk = FALSE;
  m_procmemorylimit    = m_jobmemorylimit = 0;
}

CCommittedMemoryWiz::~CCommittedMemoryWiz()
{
}

LRESULT CCommittedMemoryWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CCommittedMemoryWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_mem);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CCommittedMemoryWiz::Validate(BOOL bSave)
{
  LONG_PTR          PosErr = 0;
  MEMORY_VALUE      procmemorylimit;
  MEMORY_VALUE      jobmemorylimit;

  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)
  {
    m_procmemorylimitchk = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCMEMORY_CHK));
    m_procmemorylimit    = procmemorylimit * 1024;
    m_jobmemorylimitchk  = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMORY_CHK));
    m_jobmemorylimit     = jobmemorylimit * 1024;
  }
  return TRUE;
}

BOOL CCommittedMemoryWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    return Validate(TRUE);
  }
  else
  {
    if ( m_procmemorylimit/1024 > (MAXLONG - 1) ||
         m_jobmemorylimit/1024  > (MAXLONG - 1) )
      m_bReadOnly = TRUE;

    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_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;
  }
}

LRESULT CCommittedMemoryWiz::OnSpin(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
  if (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 CCommittedMemoryWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_PROCMEMORY_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCMEMORY_CHK));
    ::EnableWindow(GetDlgItem(IDC_PROCMEMORY), checked);
    ::EnableWindow(GetDlgItem(IDC_PROC_SPIN),  checked);
  }
  else if (wID == IDC_JOBMEMORY_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBMEMORY_CHK));
    ::EnableWindow(GetDlgItem(IDC_JOBMEMORY), checked);
    ::EnableWindow(GetDlgItem(IDC_JOB_SPIN),  checked);
  }

  bHandled = FALSE;
  return 0;
}

BOOL CCommittedMemoryWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  CProcCountWiz
CProcCountWiz::CProcCountWiz(WIZ_POSITION pos, int nTitle, PROC_COUNT *processcount, bool *processcountchk ) :
    CMySnapInPropertyWizardImpl<CProcCountWiz>(pos, nTitle),
    m_processcount(*processcount), m_processcountchk(*processcountchk)
{
  m_bReadOnly = FALSE;

  m_processcount = 0;
  m_processcountchk = FALSE;
}

CProcCountWiz::~CProcCountWiz()
{
}

LRESULT CProcCountWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CProcCountWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_procs);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CProcCountWiz::Validate(BOOL bSave)
{
  LONG_PTR PosErr = 0;
  LRESULT processcount = SendDlgItemMessage(IDC_SPIN, UDM_GETPOS32, 0, (LPARAM) &PosErr);

  if (PosErr || processcount < 0)
  {
    HWND hWndCtl = GetDlgItem(IDC_PROCESSCOUNT);
    if(hWndCtl)
      ::SetFocus(hWndCtl);
    MessageBeep(MB_ICONASTERISK);
    return FALSE;
  }

  if (bSave)
  {
    m_processcountchk = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCESSCOUNT_CHK));
    m_processcount    = (PROC_COUNT) processcount;
  }
  return TRUE;
}

BOOL CProcCountWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    return Validate(TRUE);
  }
  else
  {
    CheckDlgButton(IDC_PROCESSCOUNT_CHK, m_processcountchk ? BST_CHECKED : BST_UNCHECKED);

    SendDlgItemMessage(IDC_SPIN, UDM_SETRANGE32, 0, MAXLONG-1);
    SendDlgItemMessage(IDC_SPIN, UDM_SETPOS32,   0, m_processcount );

    if (m_bReadOnly || !m_processcountchk)
    {
      DisableControl(IDC_PROCESSCOUNT);
      DisableControl(IDC_SPIN);
    }
    if (m_bReadOnly)
      DisableControl(IDC_PROCESSCOUNT_CHK);

    return TRUE;
  }
}

LRESULT CProcCountWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_PROCESSCOUNT_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCESSCOUNT_CHK));
    ::EnableWindow(GetDlgItem(IDC_PROCESSCOUNT), checked);
    ::EnableWindow(GetDlgItem(IDC_SPIN),         checked);
  }
  bHandled = FALSE;
  return 0;
}

BOOL CProcCountWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}


///////////////////////////////////////////////////////////////////////////
//  CTimeWiz
CTimeWiz::CTimeWiz(WIZ_POSITION pos, int nTitle,
                   TIME_VALUE *procusertime, bool *procusertimechk,
                   TIME_VALUE *jobusertime, bool *jobusertimechk, bool *jobmsgontimelimit) :
    CMySnapInPropertyWizardImpl<CTimeWiz>(pos, nTitle),
    m_procusertime(*procusertime), m_procusertimechk(*procusertimechk),
    m_jobusertime(*jobusertime), m_jobusertimechk(*jobusertimechk), m_jobmsgontimelimit(*jobmsgontimelimit)
{
  m_bReadOnly = FALSE;

  m_procusertimechk = m_jobusertimechk = m_jobmsgontimelimit = FALSE;
  m_procusertime    = m_jobusertime = 0;
}

CTimeWiz::~CTimeWiz()
{
}


LRESULT CTimeWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CTimeWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_time);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CTimeWiz::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_procusertimechk = procusertimechk;
    m_procusertime    = procusertime;
    m_jobusertimechk  = jobusertimechk;
    m_jobusertime     = jobusertime;
    m_jobmsgontimelimit =  (BST_CHECKED == IsDlgButtonChecked(IDC_JOBTIMELIMIT_MSG));
  }
  return TRUE;
}

BOOL CTimeWiz::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) );

    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 CTimeWiz::OnChk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
  if (wID == IDC_PROCUSERTIME_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_PROCUSERTIME_CHK));
    ::EnableWindow(GetDlgItem(IDC_PROCUSERTIME), checked);
  }
  else if (wID == IDC_JOBUSERTIME_CHK)
  {
    bool checked = (BST_CHECKED == IsDlgButtonChecked(IDC_JOBUSERTIME_CHK));
    ::EnableWindow(GetDlgItem(IDC_JOBUSERTIME),       checked);
    ::EnableWindow(GetDlgItem(IDC_JOBTIMELIMIT_TERM), checked);
    ::EnableWindow(GetDlgItem(IDC_JOBTIMELIMIT_MSG),  checked);
  }
  bHandled = FALSE;
  return 0;
}

BOOL CTimeWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}


///////////////////////////////////////////////////////////////////////////
//  CAdvancedWiz

CAdvancedWiz::CAdvancedWiz(WIZ_POSITION pos, int nTitle, bool *endjob, bool *unhandledexcept ) :
    CMySnapInPropertyWizardImpl<CAdvancedWiz>(pos, nTitle),
    m_endjob(*endjob),m_unhandledexcept(*unhandledexcept)
{
  m_bReadOnly = FALSE;

  m_endjob = m_unhandledexcept = FALSE;
}

CAdvancedWiz::~CAdvancedWiz()
{
}

LRESULT CAdvancedWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CAdvancedWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_adv);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CAdvancedWiz::Validate(BOOL bSave)
{
  if (bSave)
  {
    m_endjob          = (BST_CHECKED == IsDlgButtonChecked(IDC_ENDJOB_CHK));
    m_unhandledexcept = (BST_CHECKED == IsDlgButtonChecked(IDC_UNHANDLEDEXCEPT_CHK));
  }
  return TRUE;
}

BOOL CAdvancedWiz::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);

    if (m_bReadOnly)
    {
      DisableControl(IDC_ENDJOB_CHK);
      DisableControl(IDC_UNHANDLEDEXCEPT_CHK);
    }

    return TRUE;
  }
}

BOOL CAdvancedWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//  CAdvBreakawayWiz

CAdvBreakawayWiz::CAdvBreakawayWiz(WIZ_POSITION pos, int nTitle, bool *breakaway, bool *silentbreakaway) :
    CMySnapInPropertyWizardImpl<CAdvBreakawayWiz>(pos, nTitle),
    m_breakaway(*breakaway), m_silentbreakaway(*silentbreakaway)
{
  m_bReadOnly = FALSE;

  m_breakaway = m_silentbreakaway = FALSE;
}

CAdvBreakawayWiz::~CAdvBreakawayWiz()
{
}

LRESULT CAdvBreakawayWiz::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  UpdateData(FALSE);

  bHandled = FALSE;

  return TRUE;  // Let the system set the focus
}

LRESULT CAdvBreakawayWiz::OnWMHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  HELPINFO *phi = (HELPINFO*) lParam;
  if (phi && phi->iContextType == HELPINFO_WINDOW)
  {
    TCHAR *pTopic = const_cast<TCHAR*>(HELP_ru_job_adv);

    MMCPropertyHelp(pTopic);

    return TRUE;
  }
  bHandled = FALSE;
  return FALSE;
}

BOOL CAdvBreakawayWiz::Validate(BOOL bSave)
{
  if (bSave)
  {
    m_breakaway       = (BST_CHECKED == IsDlgButtonChecked(IDC_BREAKAWAY_CHK));
    m_silentbreakaway = (BST_CHECKED == IsDlgButtonChecked(IDC_SILENTBREAKAWAY_CHK));
  }
  return TRUE;
}

BOOL CAdvBreakawayWiz::UpdateData(BOOL bSaveAndValidate)
{
  if (bSaveAndValidate)
  {
    return Validate(TRUE);
  }
  else
  {
    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_BREAKAWAY_CHK);
      DisableControl(IDC_SILENTBREAKAWAY_CHK);
    }

    return TRUE;
  }
}

BOOL CAdvBreakawayWiz::OnWizardNext()
{
  if (!UpdateData(TRUE) )
    return FALSE;

  return TRUE;
}