able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/utils/tuneup/schedwiz.cpp

845 lines
22 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// 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;
}
Reference in a new issue Copy permalink