archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/admin/services/sched/schedui/settings.cxx

1012 lines
26 KiB
Raw Permalink Blame History

//____________________________________________________________________________
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995 - 1996.
//
// File: settings.cxx
//
// Contents:
//
// Classes:
//
// Functions:
//
// Notes: For the first release of the scheduling agent, all security
// operations are disabled under Win95, even Win95 to NT.
//
// History: 3/4/1996 RaviR Created
//
//____________________________________________________________________________
#include "..\pch\headers.hxx"
#pragma hdrstop
#include <mstask.h>
#include "..\inc\common.hxx"
#include "..\folderui\dbg.h"
#include "..\folderui\macros.h"
#include "..\folderui\util.hxx"
#include "..\inc\network.hxx"
#include "..\inc\dll.hxx"
#include "dlg.hxx"
#include "rc.h"
#include "defines.h"
#include "uiutil.hxx"
#include "helpids.h"
#include "schedui.hxx"
#include "misc.hxx"
//
// (Control id, help id) list for context sensitivity help.
//
ULONG s_aSettingsPageHelpIds[] =
{
chk_start_on_idle, Hchk_start_on_idle,
chk_stop_if_not_idle, Hchk_stop_if_not_idle,
chk_dont_start_if_on_batteries, Hchk_dont_start_if_on_batteries,
chk_kill_if_going_on_batteries, Hchk_kill_if_going_on_batteries,
chk_delete_when_done, Hchk_delete_when_done,
chk_stop_after, Hchk_stop_after,
txt_stop_after_hr, Htxt_stop_after_hr,
spin_stop_after_hr, Hspin_stop_after_hr,
txt_stop_after_min, Htxt_stop_after_min,
spin_stop_after_min, Hspin_stop_after_min,
txt_idle_min, Htxt_idle_min,
spin_idle_min, Hspin_idle_min,
lbl_idle_deadline1, Hlbl_idle_deadline,
lbl_idle_deadline2, Hlbl_idle_deadline,
txt_idle_deadline, Htxt_idle_deadline,
spin_idle_deadline, Hspin_idle_deadline,
lbl_min, Hlbl_settings_min,
lbl_hours, Hlbl_settings_hours,
grp_idle_time, Hgrp_idle_time,
txt_idle_minutes, Htxt_idle_minutes,
grp_task_completed, Hgrp_task_completed,
grp_power_management, Hgrp_power_management,
btn_new, Hbtn_new,
btn_delete, Hbtn_delete,
chk_system_required, Hchk_system_required,
0,0
};
extern "C" TCHAR szMstaskHelp[];
//
// extern
//
extern HINSTANCE g_hInstance;
//
// All task flags included in this define will be modified when the page
// values are persisted in the _OnApply method.
//
// If we're running on NT and targeting NT, the controls for some of these
// flags will be initialized to the job's values and hidden.
//
#define TASK_FLAGS_IN_SETTINGS_PAGE (TASK_FLAG_START_ONLY_IF_IDLE | \
TASK_FLAG_KILL_ON_IDLE_END | \
TASK_FLAG_DONT_START_IF_ON_BATTERIES | \
TASK_FLAG_KILL_IF_GOING_ON_BATTERIES | \
TASK_FLAG_SYSTEM_REQUIRED | \
TASK_FLAG_DELETE_WHEN_DONE)
//____________________________________________________________________________
//____________________________________________________________________________
//________________ ______________________________________
//________________ class CSettingsPage ______________________________________
//________________ ______________________________________
//____________________________________________________________________________
//____________________________________________________________________________
class CSettingsPage : public CPropPage
{
public:
CSettingsPage(ITask * pIJob,
LPTSTR ptszTaskPath,
BOOL fPersistChanges);
~CSettingsPage();
private:
virtual LRESULT _OnInitDialog(LPARAM lParam);
virtual LRESULT _OnCommand(int id, HWND hwndCtl, UINT codeNotify);
virtual LRESULT _OnApply();
virtual LRESULT _OnPSMQuerySibling(WPARAM wParam, LPARAM lParam);
virtual LRESULT _OnPSNSetActive(LPARAM lParam);
virtual LRESULT _OnPSNKillActive(LPARAM lParam);
virtual LRESULT _OnHelp(HANDLE hRequesting, UINT uiHelpCommand);
void _ReadIdleSettings();
void _ErrorDialog(int idsErr, LONG error = 0, UINT idsHelpHint = 0)
{ SchedUIErrorDialog(Hwnd(), idsErr, error, idsHelpHint); }
void _DisableUI(void);
BOOL _PerformSanityChk();
ITask * m_pIJob;
DWORD m_dwFlags;
DWORD m_dwMaxRunTime;
WORD m_wIdleWait;
WORD m_wIdleDeadline;
//
// Should we save on Apply or OK.
//
BOOL m_fPersistChanges;
}; // class CSettingsPage
inline
CSettingsPage::CSettingsPage(
ITask * pIJob,
LPTSTR ptszTaskPath,
BOOL fPersistChanges)
:
m_pIJob(pIJob),
m_fPersistChanges(fPersistChanges),
m_dwFlags(0),
m_dwMaxRunTime(0),
m_wIdleWait(0),
m_wIdleDeadline(0),
CPropPage(MAKEINTRESOURCE(settings_page), ptszTaskPath)
{
TRACE(CSettingsPage, CSettingsPage);
Win4Assert(m_pIJob != NULL);
pIJob->AddRef();
}
inline
CSettingsPage::~CSettingsPage()
{
TRACE(CSettingsPage, ~CSettingsPage);
if (m_pIJob != NULL)
{
m_pIJob->Release();
}
}
LRESULT
CSettingsPage::_OnHelp(
HANDLE hRequesting,
UINT uiHelpCommand)
{
WinHelp((HWND)hRequesting,
szMstaskHelp,
uiHelpCommand,
(DWORD_PTR)(LPSTR)s_aSettingsPageHelpIds);
return TRUE;
}
LRESULT
CSettingsPage::_OnInitDialog(
LPARAM lParam)
{
TRACE(CSettingsPage, _OnInitDialog);
HRESULT hr = S_OK;
ITask * pIJob = m_pIJob;
Spin_SetRange(m_hPage, spin_idle_min, 1, MAX_IDLE_MINUTES);
Edit_LimitText(_hCtrl(txt_idle_min), MAX_IDLE_DIGITS);
Spin_SetRange(m_hPage, spin_idle_deadline, 0, MAX_IDLE_MINUTES);
Edit_LimitText(_hCtrl(txt_idle_deadline), MAX_IDLE_DIGITS);
Spin_SetRange(m_hPage, spin_stop_after_hr, 0, MAX_MAXRUNTIME_HOURS);
Edit_LimitText(_hCtrl(txt_stop_after_hr), MAX_MAXRUNTIME_DIGITS);
Spin_SetRange(m_hPage, spin_stop_after_min, 0, 59);
Edit_LimitText(_hCtrl(txt_stop_after_min), 2);
do
{
//
// Set job flags
//
hr = pIJob->GetFlags(&m_dwFlags);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
CheckDlgButton(m_hPage, chk_start_on_idle,
(m_dwFlags & TASK_FLAG_START_ONLY_IF_IDLE));
CheckDlgButton(m_hPage, chk_stop_if_not_idle,
(m_dwFlags & TASK_FLAG_KILL_ON_IDLE_END));
CheckDlgButton(m_hPage, chk_dont_start_if_on_batteries,
(m_dwFlags & TASK_FLAG_DONT_START_IF_ON_BATTERIES));
CheckDlgButton(m_hPage, chk_kill_if_going_on_batteries,
(m_dwFlags & TASK_FLAG_KILL_IF_GOING_ON_BATTERIES));
CheckDlgButton(m_hPage, chk_system_required,
(m_dwFlags & TASK_FLAG_SYSTEM_REQUIRED));
CheckDlgButton(m_hPage, chk_delete_when_done,
(m_dwFlags & TASK_FLAG_DELETE_WHEN_DONE));
//
// Not all machines have resume timers, which are used to support the
// TASK_FLAG_SYSTEM_REQUIRED flag. If the target machine doesn't
// have resume timers, hide the control.
//
if (!SupportsSystemRequired())
{
RECT rcSysReq;
RECT rcGroup;
LONG cy;
//
// Get the distance in pixels from the top of the system required
// checkbox to the bottom of the group window.
//
// Reduce the height of the groupbox by this amount.
//
GetWindowRect(_hCtrl(chk_system_required), &rcSysReq);
GetWindowRect(_hCtrl(grp_power_management), &rcGroup);
cy = rcGroup.bottom - rcSysReq.top + 1;
//
// Hide the checkbox and resize the group window
//
ShowWindow(_hCtrl(chk_system_required), SW_HIDE);
SetWindowPos(_hCtrl(grp_power_management),
NULL,
0,0,
rcGroup.right - rcGroup.left + 1,
rcGroup.bottom - rcGroup.top - cy + 1,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
//
// Init idle controls
//
hr = m_pIJob->GetIdleWait(&m_wIdleWait, &m_wIdleDeadline);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
if (m_wIdleWait > MAX_IDLE_MINUTES)
{
m_wIdleWait = MAX_IDLE_MINUTES;
}
if (m_wIdleDeadline > MAX_IDLE_MINUTES)
{
m_wIdleDeadline = MAX_IDLE_MINUTES;
}
if (m_dwFlags & TASK_FLAG_START_ONLY_IF_IDLE)
{
Spin_Enable(m_hPage, spin_idle_min, m_wIdleWait);
Spin_Enable(m_hPage, spin_idle_deadline, m_wIdleDeadline);
Spin_SetPos(m_hPage, spin_idle_min, m_wIdleWait);
Spin_SetPos(m_hPage, spin_idle_deadline, m_wIdleDeadline);
}
else
{
m_wIdleWait = SCH_DEFAULT_IDLE_TIME;
m_wIdleDeadline = SCH_DEFAULT_IDLE_DEADLINE;
Spin_Disable(m_hPage, spin_idle_min);
Spin_Disable(m_hPage, spin_idle_deadline);
}
//
// Set max run time
//
hr = pIJob->GetMaxRunTime(&m_dwMaxRunTime);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
if (m_dwMaxRunTime != (DWORD)-1)
{
CheckDlgButton(m_hPage, chk_stop_after, BST_CHECKED);
//
// Convert to minutes from milliseconds. If the value is larger
// than the UI supports, reduce it.
//
m_dwMaxRunTime /= 60000;
if (m_dwMaxRunTime > (MAX_MAXRUNTIME_HOURS * 60 + 59))
{
m_dwMaxRunTime = MAX_MAXRUNTIME_HOURS * 60 + 59;
}
WORD wHours = (WORD) (m_dwMaxRunTime / 60);
WORD wMins = (WORD) (m_dwMaxRunTime % 60);
Spin_SetPos(m_hPage, spin_stop_after_hr, wHours);
Spin_SetPos(m_hPage, spin_stop_after_min, wMins);
}
else
{
CheckDlgButton(m_hPage, chk_stop_after, BST_UNCHECKED);
Spin_Disable(m_hPage, spin_stop_after_hr);
Spin_Disable(m_hPage, spin_stop_after_min);
}
} while (0);
if (m_dwFlags & JOB_I_FLAG_NET_SCHEDULE)
_DisableUI();
if (FAILED(hr))
{
if (hr == E_OUTOFMEMORY)
{
_ErrorDialog(IERR_OUT_OF_MEMORY);
}
else
{
_ErrorDialog(IERR_SETTINGS_PAGE_INIT, hr);
}
EnableWindow(Hwnd(), FALSE);
return FALSE;
}
m_fDirty = FALSE;
return TRUE;
}
//+--------------------------------------------------------------------------
//
// Member: CSettingsPage::_DisableUI
//
// Synopsis: Disable UI so the user can only view the settings
//
// History: 2001-11-13 ShBrown Created
//
//---------------------------------------------------------------------------
void
CSettingsPage::_DisableUI(void)
{
HWND hwnd;
if (hwnd = _hCtrl(chk_delete_when_done)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_stop_after)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(txt_stop_after_hr)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(spin_stop_after_hr)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(txt_stop_after_min)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(spin_stop_after_min)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_start_on_idle)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(txt_idle_min)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(spin_idle_min)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(txt_idle_deadline)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(spin_idle_deadline)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_stop_if_not_idle)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_dont_start_if_on_batteries)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_kill_if_going_on_batteries)) EnableWindow(hwnd, FALSE);
if (hwnd = _hCtrl(chk_system_required)) EnableWindow(hwnd, FALSE);
}
LRESULT
CSettingsPage::_OnCommand(
int id,
HWND hwndCtl,
UINT codeNotify)
{
TRACE(CSettingsPage, _OnCommand);
switch (id)
{
case chk_stop_after:
if (codeNotify != BN_CLICKED)
{
return TRUE;
}
if (IsDlgButtonChecked(m_hPage, chk_stop_after) == BST_CHECKED)
{
Spin_Enable(m_hPage,
spin_stop_after_hr,
DEFAULT_MAXRUNTIME_HOURS);
Spin_Enable(m_hPage,
spin_stop_after_min,
DEFAULT_MAXRUNTIME_MINUTES);
}
else
{
Spin_Disable(m_hPage, spin_stop_after_hr);
Spin_Disable(m_hPage, spin_stop_after_min);
}
break;
case chk_start_on_idle:
if (codeNotify != BN_CLICKED)
{
return TRUE;
}
if (IsDlgButtonChecked(m_hPage, chk_start_on_idle) == BST_CHECKED)
{
Spin_Enable(m_hPage, spin_idle_min, m_wIdleWait);
Spin_Enable(m_hPage, spin_idle_deadline, m_wIdleDeadline);
}
else
{
Spin_Disable(m_hPage, spin_idle_min);
Spin_Disable(m_hPage, spin_idle_deadline);
}
break;
case txt_idle_min:
case txt_idle_deadline:
case txt_stop_after_hr:
case txt_stop_after_min:
if (codeNotify != EN_CHANGE)
{
return TRUE;
}
break;
// case spin_stop_after_hr:
// case spin_stop_after_min:
// break;
case chk_stop_if_not_idle:
case chk_dont_start_if_on_batteries:
case chk_kill_if_going_on_batteries:
case chk_delete_when_done:
case chk_system_required:
if (codeNotify != BN_CLICKED)
{
return TRUE;
}
break;
default:
return FALSE;
}
_EnableApplyButton();
return TRUE;
}
//+--------------------------------------------------------------------------
//
// Member: CSettingsPage::_ReadIdleSettings
//
// Synopsis: Move the idle settings from the edit controls to the member
// variables, setting them on the job if they have been
// updated.
//
// History: 07-17-1997 DavidMun Created
//
//---------------------------------------------------------------------------
void
CSettingsPage::_ReadIdleSettings()
{
ULONG ulSpinPos;
WORD wIdleWait;
WORD wIdleDeadline;
//
// If idle wait isn't turned on, the controls don't have meaningful
// values.
//
if (IsDlgButtonChecked(m_hPage, chk_start_on_idle) != BST_CHECKED)
{
return;
}
ulSpinPos = Spin_GetPos(m_hPage, spin_idle_min);
if (HIWORD(ulSpinPos))
{
wIdleWait = SCH_DEFAULT_IDLE_TIME;
}
else
{
wIdleWait = LOWORD(ulSpinPos);
}
ulSpinPos = Spin_GetPos(m_hPage, spin_idle_deadline);
if (HIWORD(ulSpinPos))
{
wIdleDeadline = SCH_DEFAULT_IDLE_DEADLINE;
}
else
{
wIdleDeadline = LOWORD(ulSpinPos);
}
if (m_wIdleWait != wIdleWait || m_wIdleDeadline != wIdleDeadline)
{
HRESULT hr;
hr = m_pIJob->SetIdleWait(wIdleWait, wIdleDeadline);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
{
m_wIdleWait = wIdleWait;
m_wIdleDeadline = wIdleDeadline;
}
}
}
BOOL
CSettingsPage::_PerformSanityChk(void)
{
ULONG ul;
if (IsDlgButtonChecked(m_hPage, chk_stop_after) == BST_CHECKED)
{
ul = GetDlgItemInt(Hwnd(), txt_stop_after_hr, NULL, FALSE);
if (!ul)
{
ul = GetDlgItemInt(Hwnd(), txt_stop_after_min, NULL, FALSE);
if (!ul)
{
Spin_SetPos(Hwnd(), spin_stop_after_min, 1);
_ErrorDialog(IERR_MAXRUNTIME);
return FALSE;
}
}
}
return TRUE;
}
LRESULT
CSettingsPage::_OnPSNKillActive(
LPARAM lParam)
{
TRACE(CSettingsPage, _OnPSNKillActive);
if (_PerformSanityChk() == FALSE)
{
// Returns TRUE to prevent the page from losing the activation
SetWindowLongPtr(m_hPage, DWLP_MSGRESULT, TRUE);
return TRUE;
}
//
// Make sure Schedule page is synchronized with IdleWait changes.
//
_ReadIdleSettings();
return CPropPage::_OnPSNKillActive(lParam);
}
LRESULT
CSettingsPage::_OnPSNSetActive(LPARAM lParam)
{
m_fInInit = TRUE;
//
// Make sure IdleWait is synchronized with Schedule page changes.
//
WORD wDummy;
HRESULT hr = m_pIJob->GetIdleWait(&m_wIdleWait, &wDummy);
if (SUCCEEDED(hr) &&
IsDlgButtonChecked(m_hPage, chk_start_on_idle) == BST_CHECKED)
{
Spin_SetPos(m_hPage, spin_idle_min, m_wIdleWait);
}
m_fInInit = FALSE;
return CPropPage::_OnPSNSetActive(lParam);
}
LRESULT
CSettingsPage::_OnApply(void)
{
TRACE(CSettingsPage, _OnApply);
//DbxDisplay("CSettingsPage::_OnApply");
if (m_fDirty == FALSE)
{
return TRUE;
}
if (_PerformSanityChk() == FALSE)
{
SetWindowLongPtr(Hwnd(), DWLP_MSGRESULT, FALSE);
return FALSE;
}
HRESULT hr = S_OK;
ITask * pIJob = m_pIJob;
DWORD dwFlags = 0;
do
{
if (IsDlgButtonChecked(m_hPage, chk_start_on_idle) == BST_CHECKED)
{
dwFlags |= TASK_FLAG_START_ONLY_IF_IDLE;
}
if (IsDlgButtonChecked(m_hPage, chk_stop_if_not_idle) == BST_CHECKED)
{
dwFlags |= TASK_FLAG_KILL_ON_IDLE_END;
}
if (IsDlgButtonChecked(m_hPage, chk_dont_start_if_on_batteries)
== BST_CHECKED)
{
dwFlags |= TASK_FLAG_DONT_START_IF_ON_BATTERIES;
}
if (IsDlgButtonChecked(m_hPage, chk_kill_if_going_on_batteries) ==
BST_CHECKED)
{
dwFlags |= TASK_FLAG_KILL_IF_GOING_ON_BATTERIES;
}
if (IsDlgButtonChecked(m_hPage, chk_system_required) ==
BST_CHECKED)
{
dwFlags |= TASK_FLAG_SYSTEM_REQUIRED;
}
if (IsDlgButtonChecked(m_hPage, chk_delete_when_done) == BST_CHECKED)
{
dwFlags |= TASK_FLAG_DELETE_WHEN_DONE;
}
if ((m_dwFlags & TASK_FLAGS_IN_SETTINGS_PAGE) != dwFlags)
{
hr = pIJob->GetFlags(&m_dwFlags);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
dwFlags |= (m_dwFlags & ~TASK_FLAGS_IN_SETTINGS_PAGE);
hr = pIJob->SetFlags(dwFlags);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
m_dwFlags = dwFlags;
}
_ReadIdleSettings();
DWORD dwMins = (DWORD)-1;
if (IsDlgButtonChecked(m_hPage, chk_stop_after) == BST_CHECKED)
{
ULONG ulSpinPos = Spin_GetPos(m_hPage, spin_stop_after_hr);
if (HIWORD(ulSpinPos))
{
dwMins = DEFAULT_MAXRUNTIME_HOURS * 60;
}
else
{
dwMins = LOWORD(ulSpinPos) * 60;
}
ulSpinPos = Spin_GetPos(m_hPage, spin_stop_after_min);
if (HIWORD(ulSpinPos))
{
dwMins += DEFAULT_MAXRUNTIME_MINUTES;
}
else
{
dwMins += LOWORD(ulSpinPos);
}
}
Win4Assert(dwMins != 0);
if (m_dwMaxRunTime != dwMins)
{
// Max run time is in milliseconds
hr = pIJob->SetMaxRunTime(
((dwMins == (DWORD)-1) ? (DWORD)-1 : (dwMins * 60000)));
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
m_dwMaxRunTime = dwMins;
}
//
// reset dirty flag
//
m_fDirty = FALSE;
//
// If evrything went well see if the other pages are ready to
// save the job to storage.
//
if ((m_fPersistChanges == TRUE) &&
(PropSheet_QuerySiblings(GetParent(Hwnd()),
QUERY_READY_TO_BE_SAVED, 0))
== 0)
{
//
// Save the job file to storage.
//
// First, fetch general page task, application dirty status flags.
// Default to not dirty if the general page isn't present.
//
BOOL fTaskApplicationChange = FALSE;
PropSheet_QuerySiblings(GetParent(Hwnd()),
QUERY_TASK_APPLICATION_DIRTY_STATUS,
(LPARAM)&fTaskApplicationChange);
BOOL fTaskAccountChange = FALSE;
PropSheet_QuerySiblings(GetParent(Hwnd()),
QUERY_TASK_ACCOUNT_INFO_DIRTY_STATUS,
(LPARAM)&fTaskAccountChange);
BOOL fSuppressAccountInfoRequest = FALSE;
PropSheet_QuerySiblings(GetParent(Hwnd()),
QUERY_SUPPRESS_ACCOUNT_INFO_REQUEST_FLAG,
(LPARAM)&fSuppressAccountInfoRequest);
hr = JFSaveJob(Hwnd(),
pIJob,
this->GetPlatformId() == VER_PLATFORM_WIN32_NT &&
this->IsTaskInTasksFolder(),
fTaskAccountChange,
fTaskApplicationChange,
fSuppressAccountInfoRequest);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
PropSheet_QuerySiblings(GetParent(Hwnd()),
RESET_TASK_APPLICATION_DIRTY_STATUS, 0);
PropSheet_QuerySiblings(GetParent(Hwnd()),
RESET_TASK_ACCOUNT_INFO_DIRTY_STATUS, 0);
PropSheet_QuerySiblings(GetParent(Hwnd()),
RESET_SUPPRESS_ACCOUNT_INFO_REQUEST_FLAG, 0);
//
// Instruct the general page to refresh account information.
//
PropSheet_QuerySiblings(GetParent(Hwnd()),
TASK_ACCOUNT_CHANGE_NOTIFY, 0);
}
} while (0);
if (FAILED(hr))
{
if (hr == E_OUTOFMEMORY)
{
_ErrorDialog(IERR_OUT_OF_MEMORY);
}
else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
{
_ErrorDialog(IERR_FILE_NOT_FOUND);
}
else if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
{
_ErrorDialog(IERR_ACCESS_DENIED);
}
else
{
_ErrorDialog(IERR_INTERNAL_ERROR, hr);
}
}
return TRUE;
}
LRESULT
CSettingsPage::_OnPSMQuerySibling(
WPARAM wParam,
LPARAM lParam)
{
int iRet = 0;
switch (wParam)
{
case QUERY_READY_TO_BE_SAVED:
iRet = (int)m_fDirty;
break;
}
SetWindowLongPtr(Hwnd(), DWLP_MSGRESULT, iRet);
return iRet;
}
HRESULT
GetSettingsPage(
ITask * pIJob,
LPTSTR ptszTaskPath,
BOOL fPersistChanges,
HPROPSHEETPAGE * phpage)
{
Win4Assert(pIJob != NULL);
Win4Assert(phpage != NULL);
LPTSTR ptszPath = NULL;
HRESULT hr = S_OK;
WORD cTriggers = 0;
do
{
//
// Get the job name.
//
if (ptszTaskPath != NULL)
{
//
// Use passed-in path
//
ptszPath = ptszTaskPath;
}
else
{
//
// Obtain the job path from the interfaces.
//
hr = GetJobPath(pIJob, &ptszPath);
BREAK_ON_FAIL(hr);
}
hr = pIJob->GetTriggerCount(&cTriggers);
if (FAILED(hr))
{
CHECK_HRESULT(hr);
break;
}
CSettingsPage * pPage = new CSettingsPage(
pIJob,
ptszPath,
fPersistChanges);
if (pPage == NULL)
{
hr = E_OUTOFMEMORY;
CHECK_HRESULT(hr);
break;
}
HPROPSHEETPAGE hpage = CreatePropertySheetPage(&pPage->m_psp);
if (hpage == NULL)
{
delete pPage;
hr = E_OUTOFMEMORY;
CHECK_HRESULT(hr);
break;
}
*phpage = hpage;
} while (0);
//
// If we made a copy of pIJob's path string, free it.
//
if (ptszPath != ptszTaskPath)
{
delete [] ptszPath;
}
return hr;
}
HRESULT
AddSettingsPage(
PROPSHEETHEADER &psh,
ITask * pIJob)
{
HPROPSHEETPAGE hpage = NULL;
HRESULT hr = GetSettingsPage(pIJob, NULL, TRUE, &hpage);
if (SUCCEEDED(hr))
{
psh.phpage[psh.nPages++] = hpage;
}
return hr;
}
HRESULT
AddSettingsPage(
LPFNADDPROPSHEETPAGE lpfnAddPage,
LPARAM cookie,
ITask * pIJob)
{
HPROPSHEETPAGE hpage = NULL;
HRESULT hr = GetSettingsPage(pIJob, NULL, TRUE, &hpage);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
{
if (!lpfnAddPage(hpage, cookie))
{
DestroyPropertySheetPage(hpage);
hr = E_FAIL;
CHECK_HRESULT(hr);
}
}
return hr;
}