|
From: Mark H. <mha...@us...> - 2004-04-10 05:32:08
|
Update of /cvsroot/pywin32/pywin32/com/win32comext/taskscheduler/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30440/win32comext/taskscheduler/src Added Files: PyIScheduledWorkItem.cpp PyIScheduledWorkItem.h PyITask.cpp PyITask.h PyITaskScheduler.cpp PyITaskScheduler.h PyITaskTrigger.cpp PyITaskTrigger.h taskscheduler.cpp Log Message: Add a module for the TaskScheduler interfaces - from Roger Upole --- NEW FILE: PyITaskTrigger.cpp --- // This file implements the ITaskTrigger Interface for Python. // Generated by makegw.py #include "PyITaskTrigger.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyITaskTrigger::PyITaskTrigger(IUnknown *pdisp): PyIUnknown(pdisp) { ob_type = &type; } PyITaskTrigger::~PyITaskTrigger() { } /* static */ ITaskTrigger *PyITaskTrigger::GetI(PyObject *self) { return (ITaskTrigger *)PyIUnknown::GetI(self); } // @pymethod |PyITaskTrigger|SetTrigger|Set trigger parameters from a PyTASK_TRIGGER object PyObject *PyITaskTrigger::SetTrigger(PyObject *self, PyObject *args) { ITaskTrigger *pITT = GetI(self); if ( pITT == NULL ) return NULL; PyObject *obtt; if ( !PyArg_ParseTuple(args, "O:PyITaskTrigger::SetTrigger",&obtt)) return NULL; if (!PyTASK_TRIGGER_check(obtt)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITT->SetTrigger(&((PyTASK_TRIGGER *)obtt)->task_trigger); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pITT, IID_ITaskTrigger ); Py_INCREF(Py_None); return Py_None; } // @pymethod <o PyTASK_TRIGGER>|PyITaskTrigger|GetTrigger|Retrieves trigger parms as a PyTASK_TRIGGER object PyObject *PyITaskTrigger::GetTrigger(PyObject *self, PyObject *args) { TASK_TRIGGER tt; ITaskTrigger *pITT = GetI(self); if ( pITT == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":PyITaskTrigger::GetTrigger")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITT->GetTrigger(&tt); PY_INTERFACE_POSTCALL; if (FAILED(hr)) return PyCom_BuildPyException(hr, pITT, IID_ITaskTrigger); return new PyTASK_TRIGGER(&tt); } // @pymethod <o PyUnicode>|PyITaskTrigger|GetTriggerString|Build text summary of trigger PyObject *PyITaskTrigger::GetTriggerString(PyObject *self, PyObject *args) { PyObject *ret=NULL; ITaskTrigger *pITT = GetI(self); if ( pITT == NULL ) return NULL; LPWSTR TriggerString; if ( !PyArg_ParseTuple(args, ":PyITaskTrigger::GetTriggerString")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITT->GetTriggerString(&TriggerString); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) ret=PyCom_BuildPyException(hr, pITT, IID_ITaskTrigger); else ret=PyWinObject_FromWCHAR(TriggerString); CoTaskMemFree(TriggerString); return ret; } // @object PyITaskTrigger|Description of the interface static struct PyMethodDef PyITaskTrigger_methods[] = { { "SetTrigger", PyITaskTrigger::SetTrigger, 1 }, // @pymeth SetTrigger|Set trigger parameters from a PyTASK_TRIGGER object { "GetTrigger", PyITaskTrigger::GetTrigger, 1 }, // @pymeth GetTrigger|Retrieves trigger parms as a PyTASK_TRIGGER object { "GetTriggerString", PyITaskTrigger::GetTriggerString, 1 }, // @pymeth GetTriggerString|Build text summary of trigger { NULL } }; PyComTypeObject PyITaskTrigger::type("PyITaskTrigger", &PyIUnknown::type, sizeof(PyITaskTrigger), PyITaskTrigger_methods, GET_PYCOM_CTOR(PyITaskTrigger)); static struct PyMethodDef PyTASK_TRIGGER_methods[] = { { NULL } }; #define OFF(e) offsetof(PyTASK_TRIGGER, e) static struct PyMemberDef PyTASK_TRIGGER_members[] = { {"Reserved1", T_USHORT, OFF(task_trigger.Reserved1), 0, "Reserved, do not use"}, {"Reserved2", T_USHORT, OFF(task_trigger.Reserved2), 0, "Reserved, do not use"}, {"BeginYear", T_USHORT, OFF(task_trigger.wBeginYear), 0, NULL}, {"BeginMonth", T_USHORT, OFF(task_trigger.wBeginMonth), 0, NULL}, {"BeginDay", T_USHORT, OFF(task_trigger.wBeginDay), 0, NULL}, {"EndYear", T_USHORT, OFF(task_trigger.wEndYear), 0, NULL}, {"EndMonth", T_USHORT, OFF(task_trigger.wEndMonth), 0, NULL}, {"EndDay", T_USHORT, OFF(task_trigger.wEndDay), 0, NULL}, {"StartHour", T_USHORT, OFF(task_trigger.wStartHour), 0, NULL}, {"StartMinute", T_USHORT, OFF(task_trigger.wStartMinute), 0, NULL}, {"MinutesDuration", T_ULONG, OFF(task_trigger.MinutesDuration), 0, NULL}, {"MinutesInterval", T_ULONG, OFF(task_trigger.MinutesInterval), 0, NULL}, {"RandomMinutesInterval", T_USHORT, OFF(task_trigger.wRandomMinutesInterval), 0, NULL}, {"Flags", T_ULONG, OFF(task_trigger.rgFlags), 0, "Combination of TASK_TRIGGER_FLAG_HAS_END_DATE,TASK_TRIGGER_FLAG_KILL_AT_DURATION_END,TASK_TRIGGER_FLAG_DISABLED"}, {"TriggerType", T_ULONG, OFF(task_trigger.TriggerType), 0, "Value from TASK_TRIGGER_TYPE enum:\n" "TASK_TIME_TRIGGER_ONCE,TASK_TIME_TRIGGER_DAILY,\n" "TASK_TIME_TRIGGER_WEEKLY,TASK_TIME_TRIGGER_MONTHLYDATE,\n" "TASK_TIME_TRIGGER_MONTHLYDOW,TASK_EVENT_TRIGGER_ON_IDLE,\n" "TASK_EVENT_TRIGGER_AT_SYSTEMSTART,TASK_EVENT_TRIGGER_AT_LOGON"}, {"Daily_DaysInterval", T_USHORT, OFF(task_trigger.Type.Daily.DaysInterval),0,"TASK_TIME_TRIGGER_DAILY"}, {"Weekly_WeeksInterval", T_USHORT, OFF(task_trigger.Type.Weekly.WeeksInterval),0,"TASK_TIME_TRIGGER_WEEKLY"}, {"Weekly_DaysOfTheWeek", T_USHORT, OFF(task_trigger.Type.Weekly.rgfDaysOfTheWeek),0,"TASK_TIME_TRIGGER_WEEKLY"}, {"MonthlyDate_Days", T_ULONG, OFF(task_trigger.Type.MonthlyDate.rgfDays),0,"TASK_TIME_TRIGGER_MONTHLYDATE"}, {"MonthlyDate_Months", T_USHORT, OFF(task_trigger.Type.MonthlyDate.rgfMonths),0,"TASK_TIME_TRIGGER_MONTHLYDATE"}, {"MonthlyDOW_WhichWeek", T_USHORT, OFF(task_trigger.Type.MonthlyDOW.wWhichWeek),0,"Only used for TASK_TIME_TRIGGER_MONTHLYDOW"}, {"MonthlyDOW_DaysOfTheWeek", T_USHORT, OFF(task_trigger.Type.MonthlyDOW.rgfDaysOfTheWeek),0,"Only used for TASK_TIME_TRIGGER_MONTHLYDOW"}, {"MonthlyDOW_Months", T_USHORT, OFF(task_trigger.Type.MonthlyDOW.rgfMonths),0,"Only used for TASK_TIME_TRIGGER_MONTHLYDOW"}, {NULL} }; static PyTypeObject PyTASK_TRIGGERType = { PyObject_HEAD_INIT(&PyType_Type) 0, "PyTASK_TRIGGER", sizeof(PyTASK_TRIGGER), 0, PyTASK_TRIGGER::deallocFunc, 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, 0, /* tp_call */ 0, /* tp_str */ PyObject_GenericGetAttr, // PyTASK_TRIGGER::getattro, PyObject_GenericSetAttr, // PyTASK_TRIGGER::setattro, 0, // tp_as_buffer; Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags; 0, // tp_doc; /* Documentation string */ 0, // traverseproc tp_traverse; 0, // tp_clear; 0, // tp_richcompare; 0, // tp_weaklistoffset; 0, // tp_iter 0, // iternextfunc tp_iternext PyTASK_TRIGGER_methods, PyTASK_TRIGGER_members }; PyTASK_TRIGGER::PyTASK_TRIGGER(PTASK_TRIGGER ptt) { ob_type = &PyTASK_TRIGGERType; task_trigger=*ptt; task_trigger.cbTriggerSize=sizeof(TASK_TRIGGER); _Py_NewReference(this); } PyTASK_TRIGGER::PyTASK_TRIGGER(void) { ob_type = &PyTASK_TRIGGERType; // ob_type->tp_members=PyTASK_TRIGGER::memberdef; ZeroMemory(&task_trigger,sizeof(TASK_TRIGGER)); task_trigger.cbTriggerSize=sizeof(TASK_TRIGGER); _Py_NewReference(this); } PyTASK_TRIGGER::~PyTASK_TRIGGER() { } BOOL PyTASK_TRIGGER_check(PyObject *ob) { if (ob->ob_type!=&PyTASK_TRIGGERType){ PyErr_SetString(PyExc_TypeError,"Object must be a PyTASK_TRIGGER"); return FALSE; } return TRUE; } void PyTASK_TRIGGER::deallocFunc(PyObject *ob) { delete (PyTASK_TRIGGER *)ob; } --- NEW FILE: PyITaskScheduler.h --- // This file declares the ITaskScheduler Interface for Python. // Generated by makegw.py // --------------------------------------------------- // // Interface Declaration #include "mstask.h" #include "PythonCOM.h" class PyITaskScheduler : public PyIUnknown { public: MAKE_PYCOM_CTOR(PyITaskScheduler); static ITaskScheduler *GetI(PyObject *self); static PyComTypeObject type; // The Python methods static PyObject *SetTargetComputer(PyObject *self, PyObject *args); static PyObject *GetTargetComputer(PyObject *self, PyObject *args); static PyObject *Enum(PyObject *self, PyObject *args); static PyObject *Activate(PyObject *self, PyObject *args); static PyObject *Delete(PyObject *self, PyObject *args); static PyObject *NewWorkItem(PyObject *self, PyObject *args); static PyObject *AddWorkItem(PyObject *self, PyObject *args); static PyObject *IsOfType(PyObject *self, PyObject *args); protected: PyITaskScheduler(IUnknown *pdisp); ~PyITaskScheduler(); }; --- NEW FILE: PyITaskScheduler.cpp --- // This file implements the ITaskScheduler Interface for Python. // Generated by makegw.py #include "PyITaskScheduler.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation BOOL wchar_input_noneok(PyObject *ob, WCHAR **ppwchar) { return PyWinObject_AsWCHAR(ob,ppwchar,TRUE); } BOOL wchar_input_nonenotok(PyObject *ob, WCHAR **ppwchar) { return PyWinObject_AsWCHAR(ob,ppwchar,FALSE); } PyITaskScheduler::PyITaskScheduler(IUnknown *pdisp): PyIUnknown(pdisp) { ob_type = &type; } PyITaskScheduler::~PyITaskScheduler() { } /* static */ ITaskScheduler *PyITaskScheduler::GetI(PyObject *self) { return (ITaskScheduler *)PyIUnknown::GetI(self); } // @pymethod |PyITaskScheduler|SetTargetComputer|Connect to another machine to manage its tasks PyObject *PyITaskScheduler::SetTargetComputer(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; // @pyparm <o unicode>|Computer||Name of system to connect to LPWSTR Computer; if ( !PyArg_ParseTuple(args, "O&:PyITaskScheduler::SetTargetComputer", wchar_input_nonenotok, &Computer) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITS->SetTargetComputer(Computer); PyWinObject_FreeWCHAR(Computer); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler ); Py_INCREF(Py_None); return Py_None; } // @pymethod <o unicode>|PyITaskScheduler|GetTargetComputer|Returns name of computer that the Task Scheduler is connected to PyObject *PyITaskScheduler::GetTargetComputer(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; PyObject *ret=NULL; HRESULT hr = NULL; WCHAR *Computer=NULL; if ( !PyArg_ParseTuple(args, ":PyITaskScheduler::GetTargetComputer")) return NULL; PY_INTERFACE_PRECALL; hr = pITS->GetTargetComputer(&Computer); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler ); else ret=PyWinObject_FromWCHAR(Computer); if (Computer!=NULL) CoTaskMemFree(Computer); return ret; } // @pymethod <o PyUnicode>,...|PyITaskScheduler|Enum|Retrieve list of task names PyObject *PyITaskScheduler::Enum(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; if (!PyArg_ParseTuple(args, ":PyITaskScheduler::Enum")) return NULL; PyObject *task_name_obj=NULL, *ret_list=NULL; HRESULT hr = S_OK; IEnumWorkItems *pIEnumWorkItems; ULONG ulTasksToGet=10, ulActualTasksRetrieved=0, task_ind=0; LPWSTR *task_names=NULL; PY_INTERFACE_PRECALL; // create an enumerator hr = pITS->Enum(&pIEnumWorkItems); if (FAILED(hr)){ PyWin_SetAPIError("PyITaskScheduler::Enum",hr); return NULL; } ret_list = PyList_New(0); if (ret_list==NULL) return NULL; // loop over all tasks do{ hr = pIEnumWorkItems->Next(ulTasksToGet, &task_names, &ulActualTasksRetrieved); if (FAILED(hr)){ PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler ); Py_DECREF(ret_list); ret_list=NULL; break; } for (task_ind=0;task_ind<ulActualTasksRetrieved;task_ind++){ task_name_obj = PyWinObject_FromWCHAR(task_names[task_ind]); PyList_Append(ret_list,task_name_obj); Py_DECREF(task_name_obj); CoTaskMemFree(task_names[task_ind]); } CoTaskMemFree(task_names); } while(hr==S_OK); if(pIEnumWorkItems){ pIEnumWorkItems->Release(); pIEnumWorkItems = NULL; } PY_INTERFACE_POSTCALL; return ret_list; } // @pymethod <o PyITask>|PyITaskScheduler|Activate|Opens the specified task and returns an ITask interface for it PyObject *PyITaskScheduler::Activate(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; // @pyparm <o unicode>|Name||Name of task to retreive // @pyparm <o PyIID>|riid||IID to return, currently only IID_ITask accepted PyObject *obtask_name=NULL, *obriid=NULL; LPWSTR task_name; IID riid=IID_ITask; IUnknown* pUnk; if (!PyArg_ParseTuple(args, "O|O:PyITaskScheduler::Activate", &obtask_name, &obriid) ) return NULL; if (obriid!=NULL) if (!PyWinObject_AsIID(obriid, &riid)) return NULL; if (!PyWinObject_AsWCHAR(obtask_name, &task_name, FALSE)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITS->Activate(task_name, riid, &pUnk); PyWinObject_FreeWCHAR(task_name); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler ); return PyCom_PyObjectFromIUnknown(pUnk, riid, FALSE); } // @pymethod |PyITaskScheduler|Delete|Delete task by name PyObject *PyITaskScheduler::Delete(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; PyObject *ret=NULL; HRESULT hr = NULL; LPWSTR task_name=NULL; // @pyparm <o unicode>|TaskName||Name of task to delete if (!PyArg_ParseTuple(args,"O&:PyITaskScheduler::Delete", wchar_input_nonenotok, &task_name)) return NULL; PY_INTERFACE_PRECALL; hr = pITS->Delete(task_name); PyWinObject_FreeWCHAR(task_name); PY_INTERFACE_POSTCALL; if (FAILED(hr)) PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler); else{ Py_INCREF(Py_None); ret=Py_None; } return ret; } // @pymethod <o PyITask>|PyITaskScheduler|NewWorkItem|Creates a new task PyObject *PyITaskScheduler::NewWorkItem(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; // @pyparm <o unicode>|TaskName||Name of new task // @pyparm <o PyIID>|rclsid||Class id of work item, currently only CLSID_CTask (defaults if not passed in) // @pyparm <o PyIID>|riid||Interface IID to return, currently only IID_ITask (defaults if not passed in) PyObject *obTaskName=NULL; PyObject *obrclsid=NULL; PyObject *obriid=NULL; LPWSTR TaskName=NULL; IID rclsid=CLSID_CTask, riid=IID_ITask; IUnknown *pUnk; if (!PyArg_ParseTuple(args, "O|OO:NewWorkItem", &obTaskName, &obrclsid, &obriid) ) return NULL; if (obrclsid!=NULL) if (!PyWinObject_AsIID(obrclsid, &rclsid)) return NULL; if (obriid!=NULL) if (!PyWinObject_AsIID(obriid, &riid)) return NULL; if (!PyWinObject_AsWCHAR(obTaskName, &TaskName)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITS->NewWorkItem(TaskName, rclsid, riid, &pUnk ); PyWinObject_FreeWCHAR(TaskName); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler); return PyCom_PyObjectFromIUnknown(pUnk, riid, FALSE); } // @pymethod <o PyUnicode>,<o PyITask>|PyITaskScheduler|AddWorkItem|Create a new scheduled task from PyITask object // @comm The PyItask passed in is modified in place and on success is associated with the new task, not the old one PyObject *PyITaskScheduler::AddWorkItem(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; // @pyparm <o unicode>|TaskName||Name of task to be created // @pyparm <o PyITask>|WorkItem||Existing PyITask object LPWSTR TaskName=NULL; IScheduledWorkItem *pISWI=NULL; PyObject *obpISWI=NULL; if (!PyArg_ParseTuple(args, "O&O:PyITaskScheduler::AddWorkItem", wchar_input_nonenotok, &TaskName, &obpISWI)) return NULL; if (!PyCom_InterfaceFromPyObject(obpISWI, IID_IScheduledWorkItem, (void **)&pISWI, FALSE)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITS->AddWorkItem(TaskName, pISWI); pISWI->Release(); PyWinObject_FreeWCHAR(TaskName); PY_INTERFACE_POSTCALL; if (FAILED(hr)) return PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler ); Py_INCREF(Py_None); return Py_None; // return PyCom_PyObjectFromIUnknown(pISWI, IID_IScheduledWorkItem, FALSE); } // @pymethod |PyITaskScheduler|IsOfType|Check if named object supports specified interface PyObject *PyITaskScheduler::IsOfType(PyObject *self, PyObject *args) { ITaskScheduler *pITS = GetI(self); if ( pITS == NULL ) return NULL; // @pyparm <o unicode>|Name||Name of object // @pyparm <o PyIID>|riid||Named object is checked that it supports the interface of this IID PyObject *obName=NULL, *obriid=NULL, *ret=NULL; LPWSTR Name=NULL; IID riid; if ( !PyArg_ParseTuple(args, "OO:IsOfType", &obName, &obriid) ) return NULL; if (!PyWinObject_AsIID(obriid, &riid)) return NULL; if (!PyWinObject_AsWCHAR(obName, &Name)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pITS->IsOfType(Name, riid); PyWinObject_FreeWCHAR(Name); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pITS, IID_ITaskScheduler); if (hr==S_OK) ret=Py_True; else ret=Py_False; Py_INCREF(ret); return ret; } // @object PyITaskScheduler|Interface to the Windows Task Scheduler static struct PyMethodDef PyITaskScheduler_methods[] = { { "SetTargetComputer", PyITaskScheduler::SetTargetComputer, 1 }, // @pymeth SetTargetComputer|Connect to another machine to manage its tasks { "GetTargetComputer", PyITaskScheduler::GetTargetComputer, 1 }, // @pymeth GetTargetComputer|Returns name of computer that the Task Scheduler is connected to { "Enum", PyITaskScheduler::Enum, 1 }, // @pymeth Enum|Retrieve list of task names { "Activate", PyITaskScheduler::Activate, 1 }, // @pymeth Activate|Opens the specified task and returns an ITask interface for it { "Delete", PyITaskScheduler::Delete, 1 }, // @pymeth Delete|Delete task by name { "NewWorkItem", PyITaskScheduler::NewWorkItem, 1 }, // @pymeth NewWorkItem|Creates a new task { "AddWorkItem", PyITaskScheduler::AddWorkItem, 1 }, // @pymeth AddWorkItem|Create a new scheduled task from PyITask object { "IsOfType", PyITaskScheduler::IsOfType, 1 }, // @pymeth IsOfType|Check if named task supports specified interface { NULL } }; PyComTypeObject PyITaskScheduler::type("PyITaskScheduler", &PyIUnknown::type, sizeof(PyITaskScheduler), PyITaskScheduler_methods, GET_PYCOM_CTOR(PyITaskScheduler)); --- NEW FILE: taskscheduler.cpp --- # include "PythonCOM.h" # include "PythonCOMRegister.h" # include "mstask.h" # include "PyITaskScheduler.h" // # include "PyIScheduledWorkItem.h" # include "PyITask.h" # include "PyITaskTrigger.h" static struct PyMethodDef taskscheduler_methods[]= { NULL }; static const PyCom_InterfaceSupportInfo register_data[] = { PYCOM_INTERFACE_CLSID_ONLY ( CTaskScheduler ), PYCOM_INTERFACE_CLIENT_ONLY( TaskScheduler), PYCOM_INTERFACE_CLSID_ONLY ( CTask ), PYCOM_INTERFACE_CLIENT_ONLY( Task ), PYCOM_INTERFACE_CLIENT_ONLY( TaskTrigger ), PYCOM_INTERFACE_CLIENT_ONLY( ScheduledWorkItem ) }; extern "C" __declspec(dllexport) void inittaskscheduler() { PyObject *module; module = Py_InitModule("taskscheduler", taskscheduler_methods); if (module==NULL) return; PyObject *dict = PyModule_GetDict(module); if (dict==NULL) return; // Register all of our interfaces, gateways and IIDs. PyCom_RegisterExtensionSupport(dict, register_data, sizeof(register_data)/sizeof(PyCom_InterfaceSupportInfo)); // trigger types PyModule_AddIntConstant(module,"TASK_TIME_TRIGGER_ONCE", TASK_TIME_TRIGGER_ONCE); PyModule_AddIntConstant(module,"TASK_TIME_TRIGGER_DAILY", TASK_TIME_TRIGGER_DAILY); PyModule_AddIntConstant(module,"TASK_TIME_TRIGGER_WEEKLY", TASK_TIME_TRIGGER_WEEKLY); PyModule_AddIntConstant(module,"TASK_TIME_TRIGGER_MONTHLYDATE", TASK_TIME_TRIGGER_MONTHLYDATE); PyModule_AddIntConstant(module,"TASK_TIME_TRIGGER_MONTHLYDOW", TASK_TIME_TRIGGER_MONTHLYDOW); PyModule_AddIntConstant(module,"TASK_EVENT_TRIGGER_ON_IDLE", TASK_EVENT_TRIGGER_ON_IDLE); PyModule_AddIntConstant(module,"TASK_EVENT_TRIGGER_AT_SYSTEMSTART", TASK_EVENT_TRIGGER_AT_SYSTEMSTART); PyModule_AddIntConstant(module,"TASK_EVENT_TRIGGER_AT_LOGON", TASK_EVENT_TRIGGER_AT_LOGON); // trigger flags PyModule_AddIntConstant(module,"TASK_TRIGGER_FLAG_HAS_END_DATE", TASK_TRIGGER_FLAG_HAS_END_DATE); PyModule_AddIntConstant(module,"TASK_TRIGGER_FLAG_KILL_AT_DURATION_END", TASK_TRIGGER_FLAG_KILL_AT_DURATION_END); PyModule_AddIntConstant(module,"TASK_TRIGGER_FLAG_DISABLED", TASK_TRIGGER_FLAG_DISABLED); // task statuses from msterr.h PyModule_AddIntConstant(module,"SCHED_S_TASK_READY", SCHED_S_TASK_READY); PyModule_AddIntConstant(module,"SCHED_S_TASK_NOT_SCHEDULED", SCHED_S_TASK_NOT_SCHEDULED); PyModule_AddIntConstant(module,"SCHED_S_TASK_RUNNING", SCHED_S_TASK_RUNNING); PyModule_AddIntConstant(module,"SCHED_S_TASK_DISABLED", SCHED_S_TASK_DISABLED); PyModule_AddIntConstant(module,"SCHED_S_TASK_HAS_NOT_RUN", SCHED_S_TASK_HAS_NOT_RUN); PyModule_AddIntConstant(module,"SCHED_S_TASK_NO_MORE_RUNS", SCHED_S_TASK_NO_MORE_RUNS); PyModule_AddIntConstant(module,"SCHED_S_TASK_TERMINATED", SCHED_S_TASK_TERMINATED); PyModule_AddIntConstant(module,"SCHED_S_TASK_NO_VALID_TRIGGERS", SCHED_S_TASK_NO_VALID_TRIGGERS); PyModule_AddIntConstant(module,"SCHED_S_EVENT_TRIGGER", SCHED_S_EVENT_TRIGGER); // error codes from msterr.h PyModule_AddIntConstant(module,"SCHED_E_TRIGGER_NOT_FOUND", SCHED_E_TRIGGER_NOT_FOUND); PyModule_AddIntConstant(module,"SCHED_E_TASK_NOT_READY", SCHED_E_TASK_NOT_READY); PyModule_AddIntConstant(module,"SCHED_E_TASK_NOT_RUNNING", SCHED_E_TASK_NOT_RUNNING); PyModule_AddIntConstant(module,"SCHED_E_SERVICE_NOT_INSTALLED", SCHED_E_SERVICE_NOT_INSTALLED); PyModule_AddIntConstant(module,"SCHED_E_CANNOT_OPEN_TASK", SCHED_E_CANNOT_OPEN_TASK); PyModule_AddIntConstant(module,"SCHED_E_INVALID_TASK", SCHED_E_INVALID_TASK); PyModule_AddIntConstant(module,"SCHED_E_ACCOUNT_INFORMATION_NOT_SET", SCHED_E_ACCOUNT_INFORMATION_NOT_SET); PyModule_AddIntConstant(module,"SCHED_E_ACCOUNT_NAME_NOT_FOUND", SCHED_E_ACCOUNT_NAME_NOT_FOUND); PyModule_AddIntConstant(module,"SCHED_E_ACCOUNT_DBASE_CORRUPT", SCHED_E_ACCOUNT_DBASE_CORRUPT); PyModule_AddIntConstant(module,"SCHED_E_ACCOUNT_DBASE_CORRUPT", SCHED_E_ACCOUNT_DBASE_CORRUPT); PyModule_AddIntConstant(module,"SCHED_E_UNKNOWN_OBJECT_VERSION", SCHED_E_UNKNOWN_OBJECT_VERSION); // priority codes PyModule_AddIntConstant(module,"REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS); PyModule_AddIntConstant(module,"HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS); PyModule_AddIntConstant(module,"NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS); PyModule_AddIntConstant(module,"IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS); // task flags PyModule_AddIntConstant(module,"TASK_FLAG_INTERACTIVE", TASK_FLAG_INTERACTIVE); PyModule_AddIntConstant(module,"TASK_FLAG_DELETE_WHEN_DONE", TASK_FLAG_DELETE_WHEN_DONE); PyModule_AddIntConstant(module,"TASK_FLAG_DISABLED", TASK_FLAG_DISABLED ); PyModule_AddIntConstant(module,"TASK_FLAG_HIDDEN", TASK_FLAG_HIDDEN); PyModule_AddIntConstant(module,"TASK_FLAG_RUN_ONLY_IF_LOGGED_ON", TASK_FLAG_RUN_ONLY_IF_LOGGED_ON); PyModule_AddIntConstant(module,"TASK_FLAG_START_ONLY_IF_IDLE", TASK_FLAG_START_ONLY_IF_IDLE); PyModule_AddIntConstant(module,"TASK_FLAG_RUN_ONLY_IF_DOCKED", TASK_FLAG_RUN_ONLY_IF_DOCKED); PyModule_AddIntConstant(module,"TASK_FLAG_SYSTEM_REQUIRED", TASK_FLAG_SYSTEM_REQUIRED); PyModule_AddIntConstant(module,"TASK_FLAG_KILL_ON_IDLE_END", TASK_FLAG_KILL_ON_IDLE_END); PyModule_AddIntConstant(module,"TASK_FLAG_RESTART_ON_IDLE_RESUME", TASK_FLAG_RESTART_ON_IDLE_RESUME); PyModule_AddIntConstant(module,"TASK_FLAG_DONT_START_IF_ON_BATTERIES", TASK_FLAG_DONT_START_IF_ON_BATTERIES); PyModule_AddIntConstant(module,"TASK_FLAG_KILL_IF_GOING_ON_BATTERIES", TASK_FLAG_KILL_IF_GOING_ON_BATTERIES); PyModule_AddIntConstant(module,"TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET", TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET); // DOW constants PyModule_AddIntConstant(module,"TASK_SUNDAY", TASK_SUNDAY); PyModule_AddIntConstant(module,"TASK_MONDAY", TASK_MONDAY); PyModule_AddIntConstant(module,"TASK_TUESDAY", TASK_TUESDAY); PyModule_AddIntConstant(module,"TASK_WEDNESDAY", TASK_WEDNESDAY); PyModule_AddIntConstant(module,"TASK_THURSDAY", TASK_THURSDAY); PyModule_AddIntConstant(module,"TASK_FRIDAY", TASK_FRIDAY); PyModule_AddIntConstant(module,"TASK_SATURDAY", TASK_SATURDAY); // month contants PyModule_AddIntConstant(module,"TASK_JANUARY", TASK_JANUARY); PyModule_AddIntConstant(module,"TASK_FEBRUARY", TASK_FEBRUARY); PyModule_AddIntConstant(module,"TASK_MARCH", TASK_MARCH); PyModule_AddIntConstant(module,"TASK_APRIL", TASK_APRIL); PyModule_AddIntConstant(module,"TASK_MAY", TASK_MAY); PyModule_AddIntConstant(module,"TASK_JUNE", TASK_JUNE); PyModule_AddIntConstant(module,"TASK_JULY", TASK_JULY); PyModule_AddIntConstant(module,"TASK_AUGUST", TASK_AUGUST); PyModule_AddIntConstant(module,"TASK_SEPTEMBER", TASK_SEPTEMBER); PyModule_AddIntConstant(module,"TASK_OCTOBER", TASK_OCTOBER); PyModule_AddIntConstant(module,"TASK_NOVEMBER", TASK_NOVEMBER); PyModule_AddIntConstant(module,"TASK_DECEMBER", TASK_DECEMBER); // week nbr constants PyModule_AddIntConstant(module,"TASK_FIRST_WEEK", TASK_FIRST_WEEK); PyModule_AddIntConstant(module,"TASK_SECOND_WEEK", TASK_SECOND_WEEK); PyModule_AddIntConstant(module,"TASK_THIRD_WEEK", TASK_THIRD_WEEK); PyModule_AddIntConstant(module,"TASK_FOURTH_WEEK", TASK_FOURTH_WEEK); PyModule_AddIntConstant(module,"TASK_LAST_WEEK", TASK_LAST_WEEK); } --- NEW FILE: PyITask.cpp --- // This file implements the ITask Interface for Python. // Generated by makegw.py #include "PyITask.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyITask::PyITask(IUnknown *pdisp): PyIScheduledWorkItem(pdisp) { ob_type = &type; } PyITask::~PyITask() { } /* static */ ITask *PyITask::GetI(PyObject *self) { return (ITask *)PyIScheduledWorkItem::GetI(self); } // @pymethod |PyITask|SetApplicationName|Specify which program the task will run PyObject *PyITask::SetApplicationName(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm <o unicode>|ApplicationName||Program to execute PyObject *obpwszApplicationName; LPWSTR pwszApplicationName; if ( !PyArg_ParseTuple(args, "O:SetApplicationName", &obpwszApplicationName) ) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsBstr(obpwszApplicationName, &pwszApplicationName)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetApplicationName( pwszApplicationName ); SysFreeString(pwszApplicationName); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetApplicationName|Retrieve name of program that task will run PyObject *PyITask::GetApplicationName(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; LPWSTR ApplicationName=NULL; PyObject *ret=NULL; if (!PyArg_ParseTuple(args, ":PyITask::GetApplicationName")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetApplicationName(&ApplicationName); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) PyCom_BuildPyException(hr, pIT, IID_ITask ); else ret=PyWinObject_FromWCHAR(ApplicationName); CoTaskMemFree(ApplicationName); return ret; } // @pymethod |PyITask|SetParameters|Sets command line parameters PyObject *PyITask::SetParameters(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm <o unicode>|Parameters||String containing command line parameters PyObject *obpwszParameters; LPWSTR pwszParameters; if ( !PyArg_ParseTuple(args, "O:SetParameters", &obpwszParameters) ) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsBstr(obpwszParameters, &pwszParameters)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetParameters( pwszParameters ); SysFreeString(pwszParameters); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetParameters|Returns command line parameters for task PyObject *PyITask::GetParameters(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; LPWSTR Parameters; PyObject *ret=NULL; if (!PyArg_ParseTuple(args, ":PyITask::GetParameters")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetParameters(&Parameters); PY_INTERFACE_POSTCALL; if (FAILED(hr)) PyCom_BuildPyException(hr, pIT, IID_ITask); else ret=PyWinObject_FromWCHAR(Parameters); CoTaskMemFree(Parameters); return ret; } // @pymethod |PyITask|SetWorkingDirectory|Sets initial working directory for task PyObject *PyITask::SetWorkingDirectory(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm <o unicode>|WorkingDirectory||Initial working directory PyObject *obpwszWorkingDirectory; LPWSTR pwszWorkingDirectory; if ( !PyArg_ParseTuple(args, "O:SetWorkingDirectory", &obpwszWorkingDirectory) ) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsBstr(obpwszWorkingDirectory, &pwszWorkingDirectory)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetWorkingDirectory( pwszWorkingDirectory ); SysFreeString(pwszWorkingDirectory); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetWorkingDirectory|Return working directory that the task will start out in PyObject *PyITask::GetWorkingDirectory(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; LPWSTR WorkingDirectory=NULL; PyObject *ret=NULL; if ( !PyArg_ParseTuple(args, ":PyITask::GetWorkingDirectory")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetWorkingDirectory(&WorkingDirectory); PY_INTERFACE_POSTCALL; if (FAILED(hr)) PyCom_BuildPyException(hr, pIT, IID_ITask); else ret=PyWinObject_FromWCHAR(WorkingDirectory); CoTaskMemFree(WorkingDirectory); return ret; } // @pymethod |PyITask|SetPriority|Sets priority for task PyObject *PyITask::SetPriority(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm int|Priority||One of REALTIME_PRIORITY_CLASS, HIGH_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS, IDLE_PRIORITY_CLASS DWORD dwPriority; if ( !PyArg_ParseTuple(args, "l:SetPriority", &dwPriority) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetPriority( dwPriority ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetPriority|Gets priority that will be assigned to process when task starts PyObject *PyITask::GetPriority(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; DWORD dwPriority; if (!PyArg_ParseTuple(args, ":PyITask::GetPriority")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetPriority(&dwPriority); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask); return Py_BuildValue("l",dwPriority); } // @pymethod |PyITask|SetTaskFlags|Sets flag for task. PyObject *PyITask::SetTaskFlags(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm int|dwFlags||None currently defined DWORD dwFlags; if ( !PyArg_ParseTuple(args, "l:SetTaskFlags", &dwFlags) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetTaskFlags(dwFlags); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetTaskFlags|Retrieve task flags (None currently defined) PyObject *PyITask::GetTaskFlags(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; DWORD dwFlags; if ( !PyArg_ParseTuple(args, ":PyITask::GetTaskFlags")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetTaskFlags(&dwFlags); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); return Py_BuildValue("l", dwFlags); } // @pymethod |PyITask|SetMaxRunTime|Sets maximun run time for task, use -1 to disable PyObject *PyITask::SetMaxRunTime(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; // @pyparm int|MaxRunTimeMS||Specified in milliseconds (use -1 to disable, not 0) DWORD dwMaxRunTimeMS; if ( !PyArg_ParseTuple(args, "l:SetMaxRunTime", &dwMaxRunTimeMS) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->SetMaxRunTime( dwMaxRunTimeMS ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyITask|GetMaxRunTime|Returns maximun run time for task PyObject *PyITask::GetMaxRunTime(PyObject *self, PyObject *args) { ITask *pIT = GetI(self); if ( pIT == NULL ) return NULL; DWORD dwMaxRunTimeMS=0; if ( !PyArg_ParseTuple(args, ":PyITask::GetMaxRunTime")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIT->GetMaxRunTime(&dwMaxRunTimeMS); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIT, IID_ITask); return Py_BuildValue("l",dwMaxRunTimeMS); Py_INCREF(Py_None); return Py_None; } // @object PyITask|Description of the interface static struct PyMethodDef PyITask_methods[] = { { "SetApplicationName", PyITask::SetApplicationName, 1 }, // @pymeth SetApplicationName|Specify which program the task will run { "GetApplicationName", PyITask::GetApplicationName, 1 }, // @pymeth GetApplicationName|Retrieve name of program that task will run { "SetParameters", PyITask::SetParameters, 1 }, // @pymeth SetParameters|Sets command line parameters { "GetParameters", PyITask::GetParameters, 1 }, // @pymeth GetParameters|Returns command line parameters for task { "SetWorkingDirectory", PyITask::SetWorkingDirectory, 1 }, // @pymeth SetWorkingDirectory|Sets initial working directory for task { "GetWorkingDirectory", PyITask::GetWorkingDirectory, 1 }, // @pymeth GetWorkingDirectory|Return working directory that the task will start out in { "SetPriority", PyITask::SetPriority, 1 }, // @pymeth SetPriority|Sets priority for task { "GetPriority", PyITask::GetPriority, 1 }, // @pymeth GetPriority|Gets priority that will be assigned to process when task starts { "SetTaskFlags", PyITask::SetTaskFlags, 1 }, // @pymeth SetTaskFlags|Sets flag for task { "GetTaskFlags", PyITask::GetTaskFlags, 1 }, // @pymeth GetTaskFlags|Retrieve task flags (None currently defined) { "SetMaxRunTime", PyITask::SetMaxRunTime, 1 }, // @pymeth SetMaxRunTime|Sets maximun run time for task, use -1 to disable { "GetMaxRunTime", PyITask::GetMaxRunTime, 1 }, // @pymeth GetMaxRunTime|Returns maximun run time for task { NULL } }; PyComTypeObject PyITask::type("PyITask", &PyIScheduledWorkItem::type, sizeof(PyITask), PyITask_methods, GET_PYCOM_CTOR(PyITask)); --- NEW FILE: PyIScheduledWorkItem.cpp --- // This file implements the IScheduledWorkItem Interface for Python. // Generated by makegw.py #include "PyIScheduledWorkItem.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyIScheduledWorkItem::PyIScheduledWorkItem(IUnknown *pdisp): PyIUnknown(pdisp) { ob_type = &type; } PyIScheduledWorkItem::~PyIScheduledWorkItem() { } /* static */ IScheduledWorkItem *PyIScheduledWorkItem::GetI(PyObject *self) { return (IScheduledWorkItem *)PyIUnknown::GetI(self); } // @pymethod int|PyIScheduledWorkItem|CreateTrigger|Creates a new trigger for a task, returns index and new ITaskTrigger interface PyObject *PyIScheduledWorkItem::CreateTrigger(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; ITaskTrigger *pITT; WORD trig_ind=0; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::CreateTrigger")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->CreateTrigger(&trig_ind, &pITT); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("lN", trig_ind, PyCom_PyObjectFromIUnknown(pITT, IID_ITaskTrigger, FALSE)); } // @pymethod |PyIScheduledWorkItem|DeleteTrigger|Deletes specified trigger PyObject *PyIScheduledWorkItem::DeleteTrigger(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; INT iiTrigger; WORD iTrigger; if ( !PyArg_ParseTuple(args, "i:PyIScheduledWorkItem::DeleteTrigger", &iiTrigger) ) return NULL; //@pyparm int|Trigger||Index of trigger to delete iTrigger = iiTrigger; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->DeleteTrigger( iTrigger ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|GetTriggerCount|Returns number of triggers defined for the task PyObject *PyIScheduledWorkItem::GetTriggerCount(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; WORD wCount=0; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetTriggerCount")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetTriggerCount(&wCount); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); else return Py_BuildValue("i",wCount); } // @pymethod <o PyITaskTrigger>|PyIScheduledWorkItem|GetTrigger|Retrieves ITaskTrigger interface for specified trigger index PyObject *PyIScheduledWorkItem::GetTrigger(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|iTrigger||Index of trigger to retrieve INT iiTrigger; WORD iTrigger; ITaskTrigger *pITT; if ( !PyArg_ParseTuple(args, "i:PyIScheduledWorkItem::GetTrigger", &iiTrigger) ) return NULL; iTrigger = iiTrigger; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetTrigger( iTrigger, &pITT); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return PyCom_PyObjectFromIUnknown(pITT, IID_ITaskTrigger, FALSE); } // @pymethod |PyIScheduledWorkItem|GetTriggerString|Creates a human-readable summary of specified trigger PyObject *PyIScheduledWorkItem::GetTriggerString(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; LPWSTR TriggerString; PyObject *ret=NULL; INT iiTrigger; WORD iTrigger; if (!PyArg_ParseTuple(args, "i:PyIScheduledWorkItem::GetTriggerString", &iiTrigger)) return NULL; iTrigger = iiTrigger; ; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetTriggerString( iTrigger, &TriggerString); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem); else ret=PyWinObject_FromWCHAR(TriggerString); CoTaskMemFree(TriggerString); return ret; } // @pymethod |PyIScheduledWorkItem|GetRunTimes|Return specified number of run times within given time frame PyObject *PyIScheduledWorkItem::GetRunTimes(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|Count|Number of run times to retrieve // @pyparm <o PyTime>|Begin||Start time, defaults to current time if not passed or None // @pyparm <o PyTime>|End||End time, defaults to unlimited if not passed or None WORD wCount=0, time_ind=0; SYSTEMTIME start_time, end_time; LPSYSTEMTIME run_time=NULL, first_run_time=NULL, lpend_time=NULL; PyObject *ret=NULL, *run_time_obj=NULL; PyObject *obstart_time=NULL, *obend_time=NULL; if (!PyArg_ParseTuple(args, "l|OO:GetRunTimes", &wCount, &obstart_time, &obend_time)) return NULL; if ((obstart_time==NULL)||(obstart_time==Py_None)) GetLocalTime(&start_time); else if (!PyWinObject_AsSYSTEMTIME(obstart_time, &start_time)) return NULL; if ((obend_time!=NULL)&&(obend_time!=Py_None)){ if (!PyWinObject_AsSYSTEMTIME(obend_time, &end_time)) return NULL; lpend_time=&end_time; } HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetRunTimes( &start_time, lpend_time, &wCount, &first_run_time); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); ret = PyTuple_New(wCount); run_time = first_run_time; for (time_ind = 0; time_ind < wCount; time_ind++){ run_time_obj = PyWinObject_FromSYSTEMTIME(*run_time); PyTuple_SetItem(ret, time_ind, run_time_obj); run_time++; } CoTaskMemFree(first_run_time); return ret; } // @pymethod |PyIScheduledWorkItem|GetNextRunTime|Returns next time that task is scheduled to run PyObject *PyIScheduledWorkItem::GetNextRunTime(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; SYSTEMTIME NextRun; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetNextRunTime")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetNextRunTime(&NextRun); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return PyWinObject_FromSYSTEMTIME(NextRun); } // @pymethod |PyIScheduledWorkItem|SetIdleWait|Sets idle parms for task with trigger of type TASK_EVENT_TRIGGER_ON_IDLE PyObject *PyIScheduledWorkItem::SetIdleWait(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|wIdleMinutes||Nbr of minutes computer must be idle before task fires // @pyparm int|wDeadlineMinutes||Maximum nbr of minutes task will wait for computer to become idle INT iwIdleMinutes; INT iwDeadlineMinutes; WORD wIdleMinutes; WORD wDeadlineMinutes; if ( !PyArg_ParseTuple(args, "ii:SetIdleWait", &iwIdleMinutes, &iwDeadlineMinutes) ) return NULL; BOOL bPythonIsHappy = TRUE; wIdleMinutes = iwIdleMinutes; wDeadlineMinutes = iwDeadlineMinutes; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetIdleWait( wIdleMinutes, wDeadlineMinutes ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod int,int|PyIScheduledWorkItem|GetIdleWait|Gets IdleMinutes and DeadlineMinutes parms for task with trigger of type TASK_EVENT_TRIGGER_ON_IDLE PyObject *PyIScheduledWorkItem::GetIdleWait(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; HRESULT hr; WORD IdleMinutes=0,DeadlineMinutes=0; PyObject *obIdleMinutes=NULL, *obDeadlineMinutes=NULL; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetIdleWait")) return NULL; PY_INTERFACE_PRECALL; hr = pISWI->GetIdleWait(&IdleMinutes,&DeadlineMinutes ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("ll",IdleMinutes, DeadlineMinutes); } // @pymethod |PyIScheduledWorkItem|Run|Starts task PyObject *PyIScheduledWorkItem::Run(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::Run") ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->Run( ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|Terminate|Terminate process if task is running PyObject *PyIScheduledWorkItem::Terminate(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::Terminate") ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->Terminate( ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|EditWorkItem|Brings up standard Scheduled Task dialog PyObject *PyIScheduledWorkItem::EditWorkItem(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm HWND|hParent||Reserved, use 0 if passed // @pyparm int|dwReserved||Reserved, use 0 if passed HWND hParent=NULL; DWORD dwReserved=0; if (!PyArg_ParseTuple(args, "|ll:PyIScheduledWorkItem::EditWorkItem", &hParent, &dwReserved)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->EditWorkItem( hParent, dwReserved ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod <o PyTime>|PyIScheduledWorkItem|GetMostRecentRunTime|Returns last time task ran PyObject *PyIScheduledWorkItem::GetMostRecentRunTime(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; SYSTEMTIME LastRun; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetMostRecentRunTime")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetMostRecentRunTime(&LastRun ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem); return PyWinObject_FromSYSTEMTIME(LastRun); } // @pymethod int|PyIScheduledWorkItem|GetStatus|Returns status (SCHED_S_TASK... constants) PyObject *PyIScheduledWorkItem::GetStatus(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; HRESULT hr, hrStatus; PY_INTERFACE_PRECALL; hr = pISWI->GetStatus(&hrStatus); PY_INTERFACE_POSTCALL; if ( FAILED(hr)) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("l",hrStatus); } // @pymethod (int,int)|PyIScheduledWorkItem|GetExitCode|Returns tuple of task's exit code and error returned to Task Scheduler if process could not start PyObject *PyIScheduledWorkItem::GetExitCode(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; HRESULT hr=0; DWORD ExitCode=0; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetExitCode")) return NULL; PY_INTERFACE_PRECALL; // this hr receives the startup error code if task could not start hr = pISWI->GetExitCode(&ExitCode); PY_INTERFACE_POSTCALL; return Py_BuildValue("ll",ExitCode,hr); } // @pymethod |PyIScheduledWorkItem|SetComment|Set comment string for task PyObject *PyIScheduledWorkItem::SetComment(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm <o unicode>|Comment||Freeform comment string PyObject *obpwszComment; LPWSTR pwszComment; if ( !PyArg_ParseTuple(args, "O:SetComment", &obpwszComment) ) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsBstr(obpwszComment, &pwszComment)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetComment( pwszComment ); SysFreeString(pwszComment); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod <o PyUnicode>|PyIScheduledWorkItem|GetComment|Return comment string associated with task. PyObject *PyIScheduledWorkItem::GetComment(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; LPWSTR Comment=NULL; PyObject *ret=NULL; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetComment")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetComment(&Comment); PY_INTERFACE_POSTCALL; if (FAILED(hr)) PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem); else ret=PyWinObject_FromWCHAR(Comment); CoTaskMemFree(Comment); return ret; } // @pymethod |PyIScheduledWorkItem|SetCreator|Specify who (or what) created task, can be any string PyObject *PyIScheduledWorkItem::SetCreator(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm <o unicode>|pwszCreator||Description for pwszCreator PyObject *obpwszCreator; LPWSTR pwszCreator; if ( !PyArg_ParseTuple(args, "O:SetCreator", &obpwszCreator) ) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsBstr(obpwszCreator, &pwszCreator)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetCreator( pwszCreator ); SysFreeString(pwszCreator); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|GetCreator|Returns creator info, can be any string data PyObject *PyIScheduledWorkItem::GetCreator(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; LPWSTR Creator; PyObject *ret=NULL; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetCreator")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetCreator(&Creator); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); else ret=PyWinObject_FromWCHAR(Creator); CoTaskMemFree(Creator); return ret; } // @pymethod |PyIScheduledWorkItem|SetWorkItemData|Set data associated with task (treated as uninterpreted bytes) PyObject *PyIScheduledWorkItem::SetWorkItemData(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm string|Data||Character data, treated as uninterpreted bytes BYTE *workitem_data=NULL; WORD data_len=0; PyObject *obworkitem_data=NULL; if ( !PyArg_ParseTuple(args, "O:PyIScheduledWorkItem::SetWorkItemData", &obworkitem_data)) return NULL; if (obworkitem_data!=Py_None) if (PyString_AsStringAndSize(obworkitem_data, (CHAR **)&workitem_data, (int *)&data_len)==-1) return NULL; else // Task Scheduler won't take an empty string for data anymore ?????? if (data_len==0) workitem_data=NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetWorkItemData(data_len, workitem_data); PY_INTERFACE_POSTCALL; if( FAILED(hr)) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod string|PyIScheduledWorkItem|GetWorkItemData|Retrieve data associated with task PyObject *PyIScheduledWorkItem::GetWorkItemData(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; WORD data_len; PyObject *ret=NULL; BYTE *workitem_data; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetWorkItemData")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetWorkItemData(&data_len, &workitem_data); PY_INTERFACE_POSTCALL; if (FAILED(hr)) PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem); else if (workitem_data!=NULL) ret=PyString_FromStringAndSize((const char *)workitem_data,data_len); else{ Py_INCREF(Py_None); ret=Py_None; } CoTaskMemFree(workitem_data); return ret; } // @pymethod |PyIScheduledWorkItem|SetErrorRetryCount|Specify nbr of times to attempt to run task if it can't start (not currently implemented) PyObject *PyIScheduledWorkItem::SetErrorRetryCount(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|wRetryCount||Nbr of attemps to start task INT iwRetryCount; WORD wRetryCount; if ( !PyArg_ParseTuple(args, "i:SetErrorRetryCount", &iwRetryCount) ) return NULL; wRetryCount = iwRetryCount; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetErrorRetryCount( wRetryCount ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|GetErrorRetryCount|Return nbr of times Task scheduler should try to run task (not currently implemented) PyObject *PyIScheduledWorkItem::GetErrorRetryCount(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; WORD wRetryCount; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetErrorRetryCount")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetErrorRetryCount(&wRetryCount); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("l",wRetryCount); } // @pymethod |PyIScheduledWorkItem|SetErrorRetryInterval|Interval in minutes between attempts to run task. Not implemented according to SDK PyObject *PyIScheduledWorkItem::SetErrorRetryInterval(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|RetryInterval||Interval in minutes INT iwRetryInterval; WORD wRetryInterval; if ( !PyArg_ParseTuple(args, "i:PyIScheduledWorkItem::SetErrorRetryInterval", &iwRetryInterval) ) return NULL; wRetryInterval = iwRetryInterval; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetErrorRetryInterval( wRetryInterval ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|GetErrorRetryInterval|Returns nbr of minutes between attempts to run task. Not implemented according to SDK PyObject *PyIScheduledWorkItem::GetErrorRetryInterval(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; WORD wRetryInterval=0; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetErrorRetryInterval")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetErrorRetryInterval(&wRetryInterval); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("l",wRetryInterval); } // @pymethod |PyIScheduledWorkItem|SetFlags|Set flags for task PyObject *PyIScheduledWorkItem::SetFlags(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm int|dwFlags||Combination of TASK_FLAG_* constants DWORD dwFlags; if ( !PyArg_ParseTuple(args, "l:PyIScheduledWorkItem::SetFlags", &dwFlags) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetFlags( dwFlags ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod int|PyIScheduledWorkItem|GetFlags|Returns flags for task (TASK_FLAG_* constants) PyObject *PyIScheduledWorkItem::GetFlags(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; DWORD dwFlags; if (!PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetFlags")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetFlags(&dwFlags); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); return Py_BuildValue("l",dwFlags); } // @pymethod |PyIScheduledWorkItem|SetAccountInformation|Set username and password under which task will run // @comm On some systems, username and password are verified at the time the task is saved, on others when the task tries to run PyObject *PyIScheduledWorkItem::SetAccountInformation(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; // @pyparm <o unicode>|AccountName||AccountName, use "" for local system account (can only be used by Administrators) // @pyparm <o unicode>|Password||Password - Can be None for local System account, or if TASK_FLAG_RUN_ONLY_IF_LOGGED_ON is set PyObject *obAccountName=NULL, *obPassword=NULL; LPWSTR AccountName=NULL, Password=NULL; if ( !PyArg_ParseTuple(args, "OO:SetAccountInformation", &obAccountName, &obPassword) ) return NULL; if (!PyWinObject_AsWCHAR(obAccountName, &AccountName, FALSE)) return NULL; if (!PyWinObject_AsWCHAR(obPassword, &Password, TRUE)){ PyWinObject_FreeWCHAR(AccountName); return NULL; } HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->SetAccountInformation(AccountName, Password); PyWinObject_FreeWCHAR(AccountName); PyWinObject_FreeWCHAR(Password); PY_INTERFACE_POSTCALL; if (FAILED(hr)) return PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIScheduledWorkItem|GetAccountInformation|Returns username that task will run under PyObject *PyIScheduledWorkItem::GetAccountInformation(PyObject *self, PyObject *args) { IScheduledWorkItem *pISWI = GetI(self); if ( pISWI == NULL ) return NULL; LPWSTR AccountName; PyObject *ret=NULL; if ( !PyArg_ParseTuple(args, ":PyIScheduledWorkItem::GetAccountInformation")) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pISWI->GetAccountInformation(&AccountName); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) PyCom_BuildPyException(hr, pISWI, IID_IScheduledWorkItem); else ret=PyWinObject_FromWCHAR(AccountName); CoTaskMemFree(AccountName); return ret; } // @object PyIScheduledWorkItem|Description of the interface static struct PyMethodDef PyIScheduledWorkItem_methods[] = { { "CreateTrigger", PyIScheduledWorkItem::CreateTrigger, 1 }, // @pymeth CreateTrigger|Creates a new trigger for a task, returns index and new ITaskTrigger interface { "DeleteTrigger", PyIScheduledWorkItem::DeleteTrigger, 1 }, // @pymeth DeleteTrigger|Deletes specified trigger { "GetTriggerCount", PyIScheduledWorkItem::GetTriggerCount, 1 }, // @pymeth GetTriggerCount|Returns number of triggers defined for the task { "GetTrigger", PyIScheduledWorkItem::GetTrigger, 1 }, // @pymeth GetTrigger|Retrieves ITaskTrigger interface for specified trigger index { "GetTriggerString", PyIScheduledWorkItem::GetTriggerString, 1 }, // @pymeth GetTriggerString|Creates a human-readable summary of specified trigger { "GetRunTimes", PyIScheduledWorkItem::GetRunTimes, 1 }, // @pymeth GetRunTimes|Return specified number of run times within given time frame { "GetNextRunTime", PyIScheduledWorkItem::GetNextRunTime, 1 }, // @pymeth GetNextRunTime|Returns next time that task is scheduled to run { "SetIdleWait", PyIScheduledWorkItem::SetIdleWait, 1 }, // @pymeth SetIdleWait|Sets idle parms for task with trigger of type TASK_EVENT_TRIGGER_ON_IDLE { "GetIdleWait", PyIScheduledWorkItem::GetIdleWait, 1 }, // @pymeth GetIdleWait|Gets idle parms for task with trigger of type TASK_EVENT_TRIGGER_ON_IDLE { "Run", PyIScheduledWorkItem::Run, 1 }, // @pymeth Run|Starts task { "Terminate", PyIScheduledWorkItem::Terminate, 1 }, // @pymeth Terminate|Terminate process if task is running { "EditWorkItem", PyIScheduledWorkItem::EditWorkItem, 1 }, // @pymeth EditWorkItem|Brings up standard Scheduled Task dialog { "GetMostRecentRunTime", PyIScheduledWorkItem::GetMostRecentRunTime, 1 }, // @pymeth GetMostRecentRunTime|Returns last time task ran { "GetStatus", PyIScheduledWorkItem::GetStatus, 1 }, // @pymeth GetStatus|Returns status (SCHED_S_TASK... constants) { "GetExitCode", PyIScheduledWorkItem::GetExitCode, 1 }, // @pymeth GetExitCode|Returns tuple of task's exit code and error returned to Task Scheduler if process could not start { "SetComment", PyIScheduledWorkItem::SetComment, 1 }, // @pymeth SetComment|Set comment string for task { "GetComment", PyIScheduledWorkItem::GetComment, 1 }, // @pymeth GetComment|Return comment string associated with task. { "SetCreator", PyIScheduledWorkItem::SetCreator, 1 }, // @pymeth SetCreator|Specify who (or what) created task, can be any string { "GetCreator", PyIScheduledWorkItem... [truncated message content] |
