mirror of https://github.com/tongzx/nt5src
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.
844 lines
22 KiB
844 lines
22 KiB
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SCHEDWIZ.CPP / Tuneup
|
|
//
|
|
// Microsoft Confidential
|
|
// Copyright (c) Microsoft Corporation 1998
|
|
// All rights reserved
|
|
//
|
|
// Functions for the summary wizard page.
|
|
//
|
|
// 8/98 - Jason Cohen (JCOHEN)
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//
|
|
// Internal include file(s).
|
|
//
|
|
|
|
#include <windows.h>
|
|
#include <prsht.h>
|
|
#include "schedwiz.h"
|
|
#include "main.h"
|
|
//#include "resource.h"
|
|
//#include "mstask.h"
|
|
#include <io.h>
|
|
//#include <oleguid.h>
|
|
|
|
|
|
//
|
|
// Internal defined value(s).
|
|
//
|
|
|
|
#define TASK_BIMONTH_ODD (TASK_JANUARY | TASK_MARCH | TASK_MAY | TASK_JULY | TASK_SEPTEMBER | TASK_NOVEMBER)
|
|
#define TASK_BIMONTH_EVEN (TASK_FEBRUARY | TASK_APRIL | TASK_JUNE | TASK_AUGUST | TASK_OCTOBER | TASK_DECEMBER)
|
|
#define TASK_QUARTER_1 (TASK_JANUARY | TASK_MAY | TASK_SEPTEMBER)
|
|
#define TASK_QUARTER_2 (TASK_FEBRUARY | TASK_JUNE | TASK_OCTOBER)
|
|
#define TASK_QUARTER_3 (TASK_MARCH | TASK_JULY | TASK_NOVEMBER)
|
|
#define TASK_QUARTER_4 (TASK_APRIL | TASK_AUGUST | TASK_DECEMBER)
|
|
#define TASK_WHOLE_YEAR (TASK_BIMONTH_ODD | TASK_BIMONTH_EVEN)
|
|
|
|
|
|
//
|
|
// Internal defined macro(s).
|
|
//
|
|
|
|
#define E_JOB_FAIL(x) (x == E_OUTOFMEMORY ? IDS_OUTOFMEMORY : IDS_JOB_CREATE_FAIL)
|
|
|
|
|
|
//
|
|
// Internal global variable(s).
|
|
//
|
|
|
|
ITaskScheduler *g_psa = NULL;
|
|
|
|
|
|
//
|
|
// Inernal function prototype(s).
|
|
//
|
|
|
|
static VOID InitJobTime(TASK_TRIGGER *, INT, INT);
|
|
static BOOL GetJobFileName(LPTSTR, LPTSTR);
|
|
static VOID IncDate(LPWORD, LPWORD, LPWORD, INT);
|
|
static BOOL DeleteOrgJobFile(LPTSTR);
|
|
static INT WeekDayToNum(INT);
|
|
static VOID taskSetNextDay(TASK_TRIGGER *);
|
|
static BOOL IsScheduledTasks(LPTASKDATA);
|
|
static BOOL GetTaskTrigger(ITask *, TASK_TRIGGER *);
|
|
|
|
|
|
//
|
|
// External function(s).
|
|
//
|
|
|
|
|
|
BOOL InitJobs(LPTASKDATA lpGlobalTasks)
|
|
{
|
|
ITaskTrigger *pTrigger = NULL;
|
|
WORD wTrigger;
|
|
HRESULT hResult;
|
|
BOOL bErr = FALSE;
|
|
LPTASKDATA lpTask;
|
|
|
|
#ifdef _UNICODE
|
|
LPWSTR lpwBuffer;
|
|
#else // _UNICODE
|
|
WCHAR szwBuffer[256];
|
|
LPWSTR lpwBuffer = szwBuffer;
|
|
#endif // _UNICODE
|
|
|
|
// Initialize the COM library.
|
|
//
|
|
if ( ( (hResult = CoInitialize(NULL)) != S_OK ) && (hResult == S_FALSE) )
|
|
return FALSE;
|
|
|
|
// Initialize ISchedulingAgent.
|
|
//
|
|
if ( CoCreateInstance(CLSID_CSchedulingAgent, NULL, CLSCTX_INPROC_SERVER, IID_ISchedulingAgent, (void **) &g_psa) != S_OK )
|
|
return FALSE;
|
|
|
|
for (lpTask = lpGlobalTasks; lpTask && !bErr; lpTask = lpTask->lpNext)
|
|
{
|
|
// Load the task (.job) with ITaskScheduler::Activate().
|
|
//
|
|
ANSIWCHAR(lpwBuffer, lpTask->lpJobName, sizeof(szwBuffer));
|
|
if ( (hResult = g_psa->Activate((LPCWSTR) lpwBuffer, IID_ITask, (IUnknown**) &lpTask->pTask)) == E_OUTOFMEMORY )
|
|
bErr = ErrMsg(NULL, IDS_OUTOFMEMORY);
|
|
else
|
|
{
|
|
// We should search for a task with the same app name if the
|
|
// above activate call failed.
|
|
//
|
|
if ( hResult == S_OK )
|
|
{
|
|
// Get the existing flags for the job with IScheduledWorkItem::GetFlags().
|
|
//
|
|
if ( (hResult = lpTask->pTask->GetFlags(&lpTask->dwFlags)) == S_OK )
|
|
{
|
|
// Setup our internal flags for the task.
|
|
//
|
|
if ( lpTask->dwFlags & TASK_FLAG_DISABLED )
|
|
lpTask->dwOptions &= ~TASK_SCHEDULED;
|
|
else
|
|
lpTask->dwOptions |= TASK_SCHEDULED;
|
|
|
|
// IScheduledWorkItem::GetTrigger().
|
|
//
|
|
// TODO: why do we need this data saved.
|
|
//
|
|
if ( (hResult = lpTask->pTask->GetTrigger((WORD) 0, &pTrigger)) == S_OK )
|
|
{
|
|
pTrigger->GetTrigger(&lpTask->Trigger);
|
|
|
|
pTrigger->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we didn't load the entire task successfully, we should
|
|
// delete any that is there and create a new one.
|
|
//
|
|
if (hResult != S_OK)
|
|
{
|
|
// Delete existing (maybe corrupted) job file.
|
|
//
|
|
if ( !DeleteOrgJobFile(lpTask->lpJobName) )
|
|
bErr = ErrMsg(NULL, IDS_DEL_FILE);
|
|
else
|
|
{
|
|
ANSIWCHAR(lpwBuffer, lpTask->lpJobName, sizeof(szwBuffer));
|
|
hResult = g_psa->NewWorkItem((LPCWSTR) lpwBuffer, CLSID_CTask, IID_ITask, (IUnknown**) &lpTask->pTask);
|
|
if ( (hResult != S_OK) || (lpTask->pTask == NULL) )
|
|
bErr = ErrMsg(NULL, E_JOB_FAIL(hResult));
|
|
else
|
|
{
|
|
// Make sure Tuneup knows this is a new task and is
|
|
// scheduled by default.
|
|
//
|
|
lpTask->dwOptions |= TASK_NEW;
|
|
lpTask->dwOptions |= TASK_SCHEDULED;
|
|
|
|
// Set the application name to the full path name of the task.
|
|
//
|
|
ANSIWCHAR(lpwBuffer, lpTask->lpFullPathName, sizeof(szwBuffer));
|
|
lpTask->pTask->SetApplicationName((LPCWSTR) lpwBuffer);
|
|
|
|
// Set the working directory for the task (always empty string).
|
|
//
|
|
lpTask->pTask->SetWorkingDirectory((LPCWSTR) L"");
|
|
|
|
// Set the parameters for the task (not required).
|
|
//
|
|
if ( lpTask->lpParameters )
|
|
{
|
|
ANSIWCHAR(lpwBuffer, lpTask->lpParameters, sizeof(szwBuffer));
|
|
lpTask->pTask->SetParameters(lpwBuffer);
|
|
}
|
|
|
|
// Set the comment for the task (not required).
|
|
//
|
|
if ( lpTask->lpComment )
|
|
{
|
|
ANSIWCHAR(lpwBuffer, lpTask->lpComment, sizeof(szwBuffer));
|
|
lpTask->pTask->SetComment(lpwBuffer);
|
|
}
|
|
|
|
// Set the default flags for the task.
|
|
//
|
|
lpTask->pTask->SetFlags(lpTask->dwFlags);
|
|
|
|
// For some reason we do this for all tasks
|
|
// but cleanup.
|
|
//
|
|
if ( !( lpTask->dwOptions & TASK_NOIDLE ) )
|
|
lpTask->pTask->SetIdleWait(10, 999);
|
|
|
|
// Create trigger item.
|
|
//
|
|
if ( (hResult = lpTask->pTask->CreateTrigger(&wTrigger, &pTrigger)) != S_OK)
|
|
bErr = ErrMsg(NULL, E_JOB_FAIL(hResult));
|
|
else
|
|
{
|
|
InitJobTime(&lpTask->Trigger, lpTask->nSchedule, g_nTimeScheme);
|
|
pTrigger->SetTrigger(&lpTask->Trigger);
|
|
|
|
pTrigger->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bErr)
|
|
ReleaseJobs(lpGlobalTasks, FALSE);
|
|
return bErr;
|
|
}
|
|
|
|
|
|
VOID ReleaseJobs(LPTASKDATA lpGlobalTasks, BOOL bFinish)
|
|
{
|
|
ITaskTrigger *pTrigger;
|
|
IPersistFile *pPersistFile;
|
|
LPTASKDATA lpTask;
|
|
|
|
for (lpTask = lpGlobalTasks; lpTask; lpTask = lpTask->lpNext)
|
|
{
|
|
// Check to see if used in initialization fail handler
|
|
// or the item is not needed.
|
|
//
|
|
if ( lpTask->pTask != (ITask*) NULL )
|
|
{
|
|
if ( ( lpTask->dwOptions & TASK_NEW ) && !bFinish )
|
|
{
|
|
// The .job is newly created, and user choose Cancel.
|
|
//
|
|
DeleteOrgJobFile(lpTask->lpJobName);
|
|
}
|
|
else
|
|
{
|
|
// Even if the item is not scheduled, we still save it, because we
|
|
// use the Enable/Disable flag in the .job to keep the Yes/No state.
|
|
//
|
|
if (bFinish)
|
|
{
|
|
// Take care the flag only, since the Task_Trigger is
|
|
// auto saved in Schedule property page.
|
|
//
|
|
if ( !(g_dwFlags & TUNEUP_CUSTOM) || (lpTask->dwOptions & TASK_SCHEDULED) )
|
|
lpTask->dwFlags &= ~TASK_FLAG_DISABLED;
|
|
else
|
|
lpTask->dwFlags |= TASK_FLAG_DISABLED;
|
|
}
|
|
else
|
|
{
|
|
// User canceled so restore Task_Trigger.
|
|
//
|
|
if ( lpTask->pTask->GetTrigger((WORD) 0, &pTrigger) == S_OK )
|
|
{
|
|
pTrigger->SetTrigger(&lpTask->Trigger);
|
|
pTrigger->Release();
|
|
}
|
|
}
|
|
|
|
// Set or restore flags.
|
|
//
|
|
lpTask->pTask->SetFlags(lpTask->dwFlags);
|
|
|
|
// Save the file, release the interfaces.
|
|
//
|
|
if ( lpTask->pTask->QueryInterface(IID_IPersistFile, (VOID **) &pPersistFile) == S_OK )
|
|
{
|
|
pPersistFile->Save((LPCOLESTR) NULL, TRUE);
|
|
pPersistFile->Release();
|
|
}
|
|
lpTask->pTask->Release();
|
|
|
|
/* BUGBUG: I don't understand why this is here!
|
|
|
|
// Rename the old task.
|
|
//
|
|
if ( ItemData[i].lpOldTaskName )
|
|
{
|
|
if ( bSave )
|
|
{
|
|
TCHAR szSrc[MAX_PATH],
|
|
szTgt[MAX_PATH],
|
|
*ptr;
|
|
|
|
//GetJobFileName(i, szTgt); // get filename for delete or hide
|
|
DeleteFile(szTgt);
|
|
lstrcpy(szSrc, szTgt);
|
|
if ( ptr = strrchr(szSrc, '\\') )
|
|
lstrcpy(ptr+1, ItemData[i].lpOldTaskName);
|
|
MoveFile(szSrc, szTgt);
|
|
}
|
|
}
|
|
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
|
|
// Release ISchedulingAgent.
|
|
//
|
|
g_psa->Release();
|
|
|
|
// Close the OLE COM library.
|
|
//
|
|
CoUninitialize();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// EXTERNAL:
|
|
// JobReschedule()
|
|
// - Reschedules a particular job.
|
|
//
|
|
// ENTRY:
|
|
// hDlg - Parent dialog for property sheet.
|
|
//
|
|
// EXIT:
|
|
// BOOL
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL JobReschedule(HWND hDlg, ITask * pJob)
|
|
{
|
|
HPROPSHEETPAGE hpsp[1];
|
|
PROPSHEETHEADER psh;
|
|
TASK_TRIGGER OldTrigger,
|
|
NewTrigger;
|
|
IProvideTaskPage *pProvideTaskPage;
|
|
LPTSTR lpCaption;
|
|
|
|
if ( pJob->QueryInterface(IID_IProvideTaskPage, (VOID**) &pProvideTaskPage) != S_OK )
|
|
return FALSE;
|
|
|
|
// We need the Schedule page only.
|
|
//
|
|
if ( pProvideTaskPage->GetPage(TASKPAGE_SCHEDULE, TRUE, &(hpsp[0])) != S_OK )
|
|
return FALSE;
|
|
|
|
// Get the caption string.
|
|
//
|
|
lpCaption = AllocateString(NULL, IDS_RESCHED);
|
|
|
|
// Setup the property page header.
|
|
//
|
|
psh.dwSize = sizeof(PROPSHEETHEADER);
|
|
psh.dwFlags = PSH_DEFAULT | PSH_NOAPPLYNOW;
|
|
psh.hwndParent = hDlg;
|
|
psh.nPages = 1;
|
|
psh.nStartPage = 0;
|
|
psh.phpage = (HPROPSHEETPAGE *) hpsp;
|
|
psh.pszCaption = lpCaption;
|
|
|
|
// Keep original trigger.
|
|
//
|
|
GetTaskTrigger(pJob, &OldTrigger);
|
|
|
|
// Display the property sheet page.
|
|
//
|
|
PropertySheet(&psh);
|
|
|
|
// Release the page and other resources.
|
|
//
|
|
FREE(lpCaption);
|
|
pProvideTaskPage->Release();
|
|
|
|
// Get the new trigger, compare it to see whether it's changed.
|
|
//
|
|
GetTaskTrigger(pJob, &NewTrigger);
|
|
|
|
// If the new time and the old time don't compare, then
|
|
// we must change the time scheme to custom.
|
|
//
|
|
if ( memcmp((const void *) &OldTrigger, (const void *) &NewTrigger, sizeof(TASK_TRIGGER)) == 0 )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
LPTSTR GetTaskTriggerText(ITask * pTask)
|
|
{
|
|
LPWSTR lpwBuffer;
|
|
LPTSTR lpReturn = NULL;
|
|
#ifdef _UNICODE
|
|
LPTSTR lpBuffer;
|
|
#else // _UNICODE
|
|
TCHAR szBuffer[256];
|
|
LPTSTR lpBuffer = szBuffer;
|
|
#endif // _UNICODE
|
|
|
|
if ( pTask->GetTriggerString((WORD) 0, (LPWSTR *) &lpwBuffer) == S_OK )
|
|
{
|
|
// Convert the string if _UNICODE is not defined and set the
|
|
// window to the new text.
|
|
//
|
|
WCHARANSI(lpBuffer, lpwBuffer, sizeof(szBuffer));
|
|
|
|
if ( lpReturn = (LPTSTR) MALLOC(sizeof(TCHAR) * (lstrlen(lpBuffer) + 1)) )
|
|
lstrcpy(lpReturn, lpBuffer);
|
|
|
|
// Free the string returned from IScheduledWorkitem::GetTriggerString().
|
|
//
|
|
CoTaskMemFree(lpwBuffer);
|
|
}
|
|
return lpReturn;
|
|
}
|
|
|
|
|
|
LPTSTR GetNextRunTimeText(ITask * pTask, DWORD dwFlags)
|
|
{
|
|
TCHAR szTime[128],
|
|
szDate[128];
|
|
LPTSTR lpReturn = NULL;
|
|
SYSTEMTIME stm;
|
|
|
|
// If it's disabled, we can't get run time string.
|
|
// JobRelease will clear it if the user cancels.
|
|
//
|
|
if ( dwFlags & TASK_FLAG_DISABLED )
|
|
{
|
|
dwFlags &= ~TASK_FLAG_DISABLED;
|
|
pTask->SetFlags(dwFlags);
|
|
}
|
|
|
|
pTask->GetNextRunTime(&stm);
|
|
|
|
if ( ( GetTimeFormat(GetUserDefaultLCID(), TIME_NOSECONDS, &stm, NULL, (LPTSTR) szTime, sizeof(szTime) / sizeof(TCHAR)) ) &&
|
|
( GetDateFormat(GetUserDefaultLCID(), DATE_LONGDATE, &stm, NULL, (LPTSTR) szDate, sizeof(szDate) / sizeof(TCHAR)) ) &&
|
|
( lpReturn = (LPTSTR) MALLOC(sizeof(TCHAR) * (lstrlen(szTime) + lstrlen(szDate) + 3)) ) )
|
|
{
|
|
wsprintf(lpReturn, _T("%s, %s"), szTime, szDate);
|
|
}
|
|
return lpReturn;
|
|
}
|
|
|
|
|
|
VOID SetTimeScheme(INT nTimeScheme)
|
|
{
|
|
ITaskTrigger *pTrigger;
|
|
TASK_TRIGGER SchemeTrigger;
|
|
LPTASKDATA lpTask;
|
|
|
|
// Reset the static values in InitJobTime() since
|
|
// we are resetting all the job times.
|
|
//
|
|
InitJobTime(NULL, 0, 0);
|
|
|
|
// Go through all the tasks and update the task trigger for
|
|
// the new time scheme.
|
|
//
|
|
for (lpTask = g_Tasks; lpTask; lpTask = lpTask->lpNext)
|
|
{
|
|
// Get the ITaskTrigger interface so we can set the task trigger.
|
|
//
|
|
if (lpTask->pTask->GetTrigger((WORD) 0, &pTrigger) == S_OK)
|
|
{
|
|
// Get the new task trigger for this job.
|
|
//
|
|
InitJobTime(&SchemeTrigger, lpTask->nSchedule, nTimeScheme);
|
|
|
|
// Save the new task trigger to the job.
|
|
//
|
|
pTrigger->SetTrigger(&SchemeTrigger);
|
|
|
|
// Release the ITaskTrigger interface.
|
|
//
|
|
pTrigger->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static VOID InitJobTime(TASK_TRIGGER *pTrigger, INT nSchedule, INT nTimeScheme)
|
|
{
|
|
SYSTEMTIME stNow;
|
|
static INT nMonthDay = 0, // Used to stagger monthly items.
|
|
nWeekDay = 1, // Used to staggar weekly items.
|
|
nOnceDay = 1; // Used to staggar once items.
|
|
|
|
INT nDays[] = { TASK_SUNDAY, TASK_MONDAY, TASK_TUESDAY, TASK_WEDNESDAY, TASK_THURSDAY, TASK_FRIDAY, TASK_SATURDAY };
|
|
INT nMonths[] = { TASK_JANUARY, TASK_FEBRUARY, TASK_MARCH, TASK_APRIL, TASK_MAY, TASK_JUNE, TASK_JULY, TASK_AUGUST, TASK_SEPTEMBER, TASK_OCTOBER, TASK_NOVEMBER, TASK_DECEMBER };
|
|
INT nQuarters[] = { TASK_QUARTER_1, TASK_QUARTER_2, TASK_QUARTER_3, TASK_QUARTER_4 };
|
|
|
|
// If NULL is passed in for pTrigger, we should reset the
|
|
// initial values used for scheduling the tasks.
|
|
//
|
|
if ( pTrigger == NULL )
|
|
{
|
|
// Reset the static values.
|
|
//
|
|
nMonthDay = 0;
|
|
nWeekDay = 1;
|
|
nOnceDay = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
// Init the default trigger structure values.
|
|
//
|
|
ZeroMemory(pTrigger, sizeof(TASK_TRIGGER));
|
|
pTrigger->cbTriggerSize = sizeof(TASK_TRIGGER);
|
|
pTrigger->MinutesDuration = 999;
|
|
|
|
// Set the trigger to activate today.
|
|
//
|
|
GetLocalTime(&stNow);
|
|
pTrigger->wBeginMonth = stNow.wMonth;
|
|
pTrigger->wBeginDay = stNow.wDay;
|
|
pTrigger->wBeginYear = stNow.wYear;
|
|
|
|
// Set the start hour and minute based on the time scheme.
|
|
//
|
|
switch (nTimeScheme)
|
|
{
|
|
case IDC_NIGHT:
|
|
pTrigger->wStartHour = 0;
|
|
pTrigger->wStartMinute = 0;
|
|
break;
|
|
case IDC_DAY:
|
|
pTrigger->wStartHour = 12;
|
|
pTrigger->wStartMinute = 00;
|
|
break;
|
|
case IDC_EVENING:
|
|
pTrigger->wStartHour = 20;
|
|
pTrigger->wStartMinute = 0;
|
|
break;
|
|
}
|
|
|
|
// Set the schedule (once, daily, weekly, monthly, bimonthly, quarterly, or yearly).
|
|
// The day of the week or month is incrimented each time so that once, weekly and
|
|
// monthly tasks aren't scheduled for the same days.
|
|
//
|
|
switch (nSchedule)
|
|
{
|
|
case TASK_ONCE:
|
|
pTrigger->TriggerType = TASK_TIME_TRIGGER_ONCE;
|
|
IncDate(&(pTrigger->wBeginMonth), &(pTrigger->wBeginDay), &(pTrigger->wBeginYear), nOnceDay++);
|
|
pTrigger->wStartHour += 2;
|
|
break;
|
|
case TASK_DAILY:
|
|
pTrigger->TriggerType = TASK_TIME_TRIGGER_DAILY;
|
|
pTrigger->Type.Daily.DaysInterval = 1;
|
|
break;
|
|
case TASK_WEEKLY:
|
|
pTrigger->TriggerType = TASK_TIME_TRIGGER_WEEKLY;
|
|
pTrigger->Type.Weekly.rgfDaysOfTheWeek = (USHORT)nDays[(((stNow.wDayOfWeek + nWeekDay++) % 7) + 7) % 7];
|
|
pTrigger->Type.Weekly.WeeksInterval = 1;
|
|
pTrigger->wStartMinute += 30;
|
|
break;
|
|
case TASK_MONTHLY:
|
|
case TASK_BIMONTHLY:
|
|
case TASK_QUARTLY:
|
|
case TASK_YEARLY:
|
|
pTrigger->TriggerType = TASK_TIME_TRIGGER_MONTHLYDATE;
|
|
pTrigger->Type.MonthlyDate.rgfDays = (nMonthDay++ % 28) + 1;
|
|
pTrigger->wStartHour++;
|
|
switch (nSchedule)
|
|
{
|
|
case TASK_MONTHLY:
|
|
pTrigger->Type.MonthlyDate.rgfMonths = TASK_WHOLE_YEAR;
|
|
break;
|
|
case TASK_BIMONTHLY:
|
|
pTrigger->Type.MonthlyDate.rgfMonths = ((stNow.wMonth % 2) ? TASK_BIMONTH_EVEN : TASK_BIMONTH_ODD);
|
|
break;
|
|
case TASK_QUARTLY:
|
|
pTrigger->Type.MonthlyDate.rgfMonths = (USHORT)nQuarters[(((stNow.wMonth + 1) % 4) + 4) % 4];
|
|
break;
|
|
case TASK_YEARLY:
|
|
pTrigger->Type.MonthlyDate.rgfMonths = (USHORT)nMonths[(((stNow.wMonth + 1) % 12) + 12) % 12];
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static VOID IncDate(LPWORD lpwMonth, LPWORD lpwDay, LPWORD lpwYear, INT iDays)
|
|
{
|
|
SYSTEMTIME SysTime;
|
|
FILETIME FileTime;
|
|
LARGE_INTEGER LargeInt;
|
|
BOOL bTwoDigit;
|
|
|
|
// Setup the system structure.
|
|
//
|
|
ZeroMemory(&SysTime, sizeof(SYSTEMTIME));
|
|
SysTime.wMonth = *lpwMonth;
|
|
SysTime.wDay = *lpwDay;
|
|
SysTime.wYear = *lpwYear;
|
|
|
|
// Support two digit dates.
|
|
//
|
|
if ( bTwoDigit = ( SysTime.wYear < 100 ) )
|
|
{
|
|
if ( SysTime.wYear >= 80 )
|
|
SysTime.wYear += 1900;
|
|
else
|
|
SysTime.wYear += 2000;
|
|
}
|
|
|
|
// Convert it to file time.
|
|
//
|
|
SystemTimeToFileTime(&SysTime, &FileTime);
|
|
|
|
// Copy it to a large integer so we can add or subtract days.
|
|
//
|
|
memcpy(&LargeInt, &FileTime, sizeof(LARGE_INTEGER));
|
|
|
|
// Add or subtract the days in nanoseconds.
|
|
//
|
|
LargeInt.QuadPart += iDays * Int32x32To64(24 * 60 * 60, 1000 * 10000);
|
|
|
|
// Copy it back to the filetime structure.
|
|
//
|
|
memcpy(&FileTime, &LargeInt, sizeof(LARGE_INTEGER));
|
|
|
|
// Convert it back to a systime structure.
|
|
//
|
|
FileTimeToSystemTime(&FileTime, &SysTime);
|
|
|
|
// Return supported two digit dates.
|
|
//
|
|
if ( bTwoDigit )
|
|
{
|
|
if ( SysTime.wYear <= 2000 )
|
|
SysTime.wYear -= 1900;
|
|
else
|
|
SysTime.wYear -= 2000;
|
|
}
|
|
|
|
// Return the new date.
|
|
//
|
|
*lpwMonth = SysTime.wMonth;
|
|
*lpwDay = SysTime.wDay;
|
|
*lpwYear = SysTime.wYear;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INTERNAL:
|
|
// GetJobFileName()
|
|
// This routine returns the full path and file name to the job file
|
|
// specified by the job name passed in.
|
|
//
|
|
// ENTRY:
|
|
// LPTSTR lpJobName
|
|
// This is the name of the job (as it appears in Task Scheduler) passed in.
|
|
//
|
|
// LPTSTR lpJobFileName
|
|
// This is the buffer that receives the full path and file name of the job
|
|
// (%WINDIR%\Tasks\lpJobName.JOB). Should be atleast MAX_PATH.
|
|
//
|
|
//
|
|
// EXIT:
|
|
// BOOL
|
|
// TRUE - Successfully retrieved all the information and filled in the buffer.
|
|
// FALSE - Something failed.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
static BOOL GetJobFileName(LPTSTR lpJobName, LPTSTR lpJobFileName)
|
|
{
|
|
TCHAR szWindowsDir[MAX_PATH];
|
|
LPTSTR lpTaskDir,
|
|
lpJobExt;
|
|
DWORD dwLength;
|
|
|
|
// Get the windows directory.
|
|
//
|
|
if ( GetWindowsDirectory(szWindowsDir, sizeof(szWindowsDir)) == 0 )
|
|
return FALSE;
|
|
|
|
// Get rid of the backslash if windows is in the root of a drive.
|
|
//
|
|
if ( (dwLength = lstrlen(szWindowsDir)) == 3 )
|
|
szWindowsDir[dwLength - 1] = _T('\0');
|
|
|
|
// Get the task dir from the string resource.
|
|
//
|
|
if ( (lpTaskDir = AllocateString(NULL, IDS_TASKDIR)) == NULL )
|
|
return FALSE;
|
|
|
|
// Get the job extension from the string resource.
|
|
//
|
|
if ( (lpJobExt = AllocateString(NULL, IDS_JOBEXT)) == NULL )
|
|
{
|
|
FREE(lpTaskDir);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the job name with all the data we have.
|
|
//
|
|
wsprintf(lpJobFileName, _T("%s%s\\%s%s"), szWindowsDir, lpTaskDir, lpJobName, lpJobExt);
|
|
FREE(lpJobExt);
|
|
FREE(lpTaskDir);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
void ConcatNextRunTime(LPSTR szOrgText, int nItem)
|
|
{
|
|
int nLen;
|
|
SYSTEMTIME stm;
|
|
char szTemp[128];
|
|
DWORD dwFlags;
|
|
|
|
lstrcat(szOrgText, "\n");
|
|
|
|
// get next run time string
|
|
dwFlags = ItemData[nItem].dwFlags;
|
|
dwFlags &= ~TASK_FLAG_DISABLED; // if it's disabled, we can't get run time string
|
|
pTask[nItem]->SetFlags(dwFlags); // JobRelease will clear it if Cancel finally
|
|
pTask[nItem]->GetNextRunTime(&stm);
|
|
|
|
if (GetTimeFormat(GetUserDefaultLCID(), TIME_NOSECONDS, &stm, NULL,
|
|
(LPTSTR)szTemp, 128)) {
|
|
lstrcat(szTemp, ", ");
|
|
nLen = lstrlen(szTemp);
|
|
if (GetDateFormat(GetUserDefaultLCID(), DATE_LONGDATE, &stm, NULL,
|
|
(LPTSTR)szTemp + nLen, 126-nLen))
|
|
lstrcat(szOrgText, szTemp);
|
|
}
|
|
}
|
|
|
|
|
|
static void taskSetNextDay(TASK_TRIGGER *pTaskTrigger)
|
|
{
|
|
if (pTaskTrigger->wBeginMonth == 2 && pTaskTrigger->wBeginDay >= 28)
|
|
{ pTaskTrigger->wBeginMonth++, pTaskTrigger->wBeginDay = 1; }
|
|
else if (pTaskTrigger->wBeginDay < 30)
|
|
pTaskTrigger->wBeginDay++;
|
|
else if (pTaskTrigger->wBeginMonth == 4 || pTaskTrigger->wBeginMonth == 6 ||
|
|
pTaskTrigger->wBeginMonth == 9 || pTaskTrigger->wBeginMonth == 11)
|
|
{ pTaskTrigger->wBeginMonth++, pTaskTrigger->wBeginDay = 1; }
|
|
else if (pTaskTrigger->wBeginDay < 31)
|
|
pTaskTrigger->wBeginDay++;
|
|
else if (pTaskTrigger->wBeginMonth == 12)
|
|
{ pTaskTrigger->wBeginYear++, pTaskTrigger->wBeginMonth = pTaskTrigger->wBeginDay = 1; }
|
|
else
|
|
{ pTaskTrigger->wBeginMonth++, pTaskTrigger->wBeginDay = 1; }
|
|
}
|
|
*/
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INTERNAL:
|
|
// DeleteOrgJobFile()
|
|
// This routine deletes the job (if it exists) with the job name passed in.
|
|
//
|
|
// ENTRY:
|
|
// LPTSTR lpJobName -
|
|
// This is the name of the job (as it appears in Task Scheduler) passed in.
|
|
//
|
|
// EXIT:
|
|
// BOOL
|
|
// TRUE - Either the file was successfully deleted or it didn't exist.
|
|
// FALSE - Something failed.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
static BOOL DeleteOrgJobFile(LPTSTR lpJobName)
|
|
{
|
|
TCHAR szJobFileName[MAX_PATH];
|
|
DWORD dwAttr;
|
|
|
|
// First get the full path and file name of
|
|
// the job file.
|
|
//
|
|
if ( !GetJobFileName(lpJobName, szJobFileName) )
|
|
return FALSE;
|
|
|
|
// If it doesn't exit, return TRUE.
|
|
//
|
|
if ( !(EXIST(szJobFileName)) )
|
|
return TRUE;
|
|
|
|
// Make sure the file isn't read only.
|
|
//
|
|
if ( (dwAttr = GetFileAttributes(szJobFileName)) & _A_RDONLY )
|
|
{
|
|
dwAttr &= ~_A_RDONLY;
|
|
SetFileAttributes(szJobFileName, dwAttr);
|
|
}
|
|
|
|
// Return the success or failure of DeleteFile().
|
|
//
|
|
return DeleteFile(szJobFileName);
|
|
}
|
|
|
|
|
|
/*
|
|
int GetTimeScheme()
|
|
{
|
|
int i, nTimeScheme;
|
|
ITaskTrigger *pTrigger = NULL;
|
|
TASK_TRIGGER TaskTrigger, SchemeTrigger[ITEM_NUM];
|
|
|
|
if (g_bEnableDefaultScheme == FALSE)
|
|
return g_nTimeScheme;
|
|
|
|
// check scheme by scheme
|
|
for (nTimeScheme = IDC_NIGHT; nTimeScheme <= IDC_EVENING; nTimeScheme++) {
|
|
for (i = TASK_FIRST; i <= TASK_LAST; i++) {
|
|
if (!ItemData[i].bNeeded)
|
|
continue;
|
|
//InitJobTime(i, nTimeScheme, &SchemeTrigger[i]);
|
|
}
|
|
|
|
for (i = TASK_FIRST; i <= TASK_LAST; i++) {
|
|
if (!ItemData[i].bNeeded)
|
|
continue;
|
|
|
|
if (!GetTaskTrigger(pTask[i], &TaskTrigger))
|
|
break;
|
|
if (memcmp((const void*)&TaskTrigger, (const void*)&SchemeTrigger[i], sizeof(TASK_TRIGGER)))
|
|
break;
|
|
}
|
|
if (i == (TASK_LAST + 1)) // all the item match this scheme setting
|
|
return nTimeScheme;
|
|
}
|
|
return IDC_CUSTOM;
|
|
}
|
|
*/
|
|
|
|
static BOOL GetTaskTrigger(ITask *pJob, TASK_TRIGGER *pTaskTrigger)
|
|
{
|
|
ITaskTrigger *pTrigger = NULL;
|
|
|
|
if (pJob->GetTrigger((WORD)0, &pTrigger) != S_OK)
|
|
return FALSE;
|
|
|
|
ZeroMemory(pTaskTrigger, sizeof(TASK_TRIGGER));
|
|
pTrigger->GetTrigger(pTaskTrigger);
|
|
pTrigger->Release();
|
|
return TRUE;
|
|
}
|