[CMAKE]
[reactos.git] / dll / win32 / mstask / task.c
1 /*
2 * Copyright (C) 2008 Google (Roy Shea)
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "mstask_private.h"
20 #include "wine/debug.h"
21
22 WINE_DEFAULT_DEBUG_CHANNEL(mstask);
23
24 static inline TaskImpl *impl_from_IPersistFile( IPersistFile *iface )
25 {
26 return (TaskImpl*) ((char*)(iface) - FIELD_OFFSET(TaskImpl, persistVtbl));
27 }
28
29 static void TaskDestructor(TaskImpl *This)
30 {
31 TRACE("%p\n", This);
32 HeapFree(GetProcessHeap(), 0, This->accountName);
33 HeapFree(GetProcessHeap(), 0, This->comment);
34 HeapFree(GetProcessHeap(), 0, This->parameters);
35 HeapFree(GetProcessHeap(), 0, This->taskName);
36 HeapFree(GetProcessHeap(), 0, This);
37 InterlockedDecrement(&dll_ref);
38 }
39
40 static HRESULT WINAPI MSTASK_ITask_QueryInterface(
41 ITask* iface,
42 REFIID riid,
43 void **ppvObject)
44 {
45 TaskImpl * This = (TaskImpl *)iface;
46
47 TRACE("IID: %s\n", debugstr_guid(riid));
48 if (ppvObject == NULL)
49 return E_POINTER;
50
51 if (IsEqualGUID(riid, &IID_IUnknown) ||
52 IsEqualGUID(riid, &IID_ITask))
53 {
54 *ppvObject = &This->lpVtbl;
55 ITask_AddRef(iface);
56 return S_OK;
57 }
58 else if (IsEqualGUID(riid, &IID_IPersistFile))
59 {
60 *ppvObject = &This->persistVtbl;
61 ITask_AddRef(iface);
62 return S_OK;
63 }
64
65 WARN("Unknown interface: %s\n", debugstr_guid(riid));
66 *ppvObject = NULL;
67 return E_NOINTERFACE;
68 }
69
70 static ULONG WINAPI MSTASK_ITask_AddRef(
71 ITask* iface)
72 {
73 TaskImpl *This = (TaskImpl *)iface;
74 ULONG ref;
75 TRACE("\n");
76 ref = InterlockedIncrement(&This->ref);
77 return ref;
78 }
79
80 static ULONG WINAPI MSTASK_ITask_Release(
81 ITask* iface)
82 {
83 TaskImpl * This = (TaskImpl *)iface;
84 ULONG ref;
85 TRACE("\n");
86 ref = InterlockedDecrement(&This->ref);
87 if (ref == 0)
88 TaskDestructor(This);
89 return ref;
90 }
91
92 static HRESULT WINAPI MSTASK_ITask_CreateTrigger(
93 ITask* iface,
94 WORD *piNewTrigger,
95 ITaskTrigger **ppTrigger)
96 {
97 TRACE("(%p, %p, %p)\n", iface, piNewTrigger, ppTrigger);
98 return TaskTriggerConstructor((LPVOID *)ppTrigger);
99 }
100
101 static HRESULT WINAPI MSTASK_ITask_DeleteTrigger(
102 ITask* iface,
103 WORD iTrigger)
104 {
105 FIXME("(%p, %d): stub\n", iface, iTrigger);
106 return E_NOTIMPL;
107 }
108
109 static HRESULT WINAPI MSTASK_ITask_GetTriggerCount(
110 ITask* iface,
111 WORD *plCount)
112 {
113 FIXME("(%p, %p): stub\n", iface, plCount);
114 return E_NOTIMPL;
115 }
116
117 static HRESULT WINAPI MSTASK_ITask_GetTrigger(
118 ITask* iface,
119 WORD iTrigger,
120 ITaskTrigger **ppTrigger)
121 {
122 FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppTrigger);
123 return E_NOTIMPL;
124 }
125
126 static HRESULT WINAPI MSTASK_ITask_GetTriggerString(
127 ITask* iface,
128 WORD iTrigger,
129 LPWSTR *ppwszTrigger)
130 {
131 FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppwszTrigger);
132 return E_NOTIMPL;
133 }
134
135 static HRESULT WINAPI MSTASK_ITask_GetRunTimes(
136 ITask* iface,
137 const LPSYSTEMTIME pstBegin,
138 const LPSYSTEMTIME pstEnd,
139 WORD *pCount,
140 LPSYSTEMTIME *rgstTaskTimes)
141 {
142 FIXME("(%p, %p, %p, %p, %p): stub\n", iface, pstBegin, pstEnd, pCount,
143 rgstTaskTimes);
144 return E_NOTIMPL;
145 }
146
147 static HRESULT WINAPI MSTASK_ITask_GetNextRunTime(
148 ITask* iface,
149 SYSTEMTIME *pstNextRun)
150 {
151 FIXME("(%p, %p): stub\n", iface, pstNextRun);
152 return E_NOTIMPL;
153 }
154
155 static HRESULT WINAPI MSTASK_ITask_SetIdleWait(
156 ITask* iface,
157 WORD wIdleMinutes,
158 WORD wDeadlineMinutes)
159 {
160 FIXME("(%p, %d, %d): stub\n", iface, wIdleMinutes, wDeadlineMinutes);
161 return E_NOTIMPL;
162 }
163
164 static HRESULT WINAPI MSTASK_ITask_GetIdleWait(
165 ITask* iface,
166 WORD *pwIdleMinutes,
167 WORD *pwDeadlineMinutes)
168 {
169 FIXME("(%p, %p, %p): stub\n", iface, pwIdleMinutes, pwDeadlineMinutes);
170 return E_NOTIMPL;
171 }
172
173 static HRESULT WINAPI MSTASK_ITask_Run(
174 ITask* iface)
175 {
176 FIXME("(%p): stub\n", iface);
177 return E_NOTIMPL;
178 }
179
180 static HRESULT WINAPI MSTASK_ITask_Terminate(
181 ITask* iface)
182 {
183 FIXME("(%p): stub\n", iface);
184 return E_NOTIMPL;
185 }
186
187 static HRESULT WINAPI MSTASK_ITask_EditWorkItem(
188 ITask* iface,
189 HWND hParent,
190 DWORD dwReserved)
191 {
192 FIXME("(%p, %p, %d): stub\n", iface, hParent, dwReserved);
193 return E_NOTIMPL;
194 }
195
196 static HRESULT WINAPI MSTASK_ITask_GetMostRecentRunTime(
197 ITask* iface,
198 SYSTEMTIME *pstLastRun)
199 {
200 FIXME("(%p, %p): stub\n", iface, pstLastRun);
201 return E_NOTIMPL;
202 }
203
204 static HRESULT WINAPI MSTASK_ITask_GetStatus(
205 ITask* iface,
206 HRESULT *phrStatus)
207 {
208 FIXME("(%p, %p): stub\n", iface, phrStatus);
209 return E_NOTIMPL;
210 }
211
212 static HRESULT WINAPI MSTASK_ITask_GetExitCode(
213 ITask* iface,
214 DWORD *pdwExitCode)
215 {
216 FIXME("(%p, %p): stub\n", iface, pdwExitCode);
217 return E_NOTIMPL;
218 }
219
220 static HRESULT WINAPI MSTASK_ITask_SetComment(
221 ITask* iface,
222 LPCWSTR pwszComment)
223 {
224 DWORD n;
225 TaskImpl *This = (TaskImpl *)iface;
226 LPWSTR tmp_comment;
227
228 TRACE("(%p, %s)\n", iface, debugstr_w(pwszComment));
229
230 /* Empty comment */
231 if (pwszComment[0] == 0)
232 {
233 HeapFree(GetProcessHeap(), 0, This->comment);
234 This->comment = NULL;
235 return S_OK;
236 }
237
238 /* Set to pwszComment */
239 n = (lstrlenW(pwszComment) + 1);
240 tmp_comment = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
241 if (!tmp_comment)
242 return E_OUTOFMEMORY;
243 lstrcpyW(tmp_comment, pwszComment);
244 HeapFree(GetProcessHeap(), 0, This->comment);
245 This->comment = tmp_comment;
246
247 return S_OK;
248 }
249
250 static HRESULT WINAPI MSTASK_ITask_GetComment(
251 ITask* iface,
252 LPWSTR *ppwszComment)
253 {
254 DWORD n;
255 TaskImpl *This = (TaskImpl *)iface;
256
257 TRACE("(%p, %p)\n", iface, ppwszComment);
258
259 n = This->comment ? lstrlenW(This->comment) + 1 : 1;
260 *ppwszComment = CoTaskMemAlloc(n * sizeof(WCHAR));
261 if (!*ppwszComment)
262 return E_OUTOFMEMORY;
263
264 if (!This->comment)
265 *ppwszComment[0] = 0;
266 else
267 lstrcpyW(*ppwszComment, This->comment);
268
269 return S_OK;
270 }
271
272 static HRESULT WINAPI MSTASK_ITask_SetCreator(
273 ITask* iface,
274 LPCWSTR pwszCreator)
275 {
276 FIXME("(%p, %p): stub\n", iface, pwszCreator);
277 return E_NOTIMPL;
278 }
279
280 static HRESULT WINAPI MSTASK_ITask_GetCreator(
281 ITask* iface,
282 LPWSTR *ppwszCreator)
283 {
284 FIXME("(%p, %p): stub\n", iface, ppwszCreator);
285 return E_NOTIMPL;
286 }
287
288 static HRESULT WINAPI MSTASK_ITask_SetWorkItemData(
289 ITask* iface,
290 WORD cBytes,
291 BYTE rgbData[])
292 {
293 FIXME("(%p, %d, %p): stub\n", iface, cBytes, rgbData);
294 return E_NOTIMPL;
295 }
296
297 static HRESULT WINAPI MSTASK_ITask_GetWorkItemData(
298 ITask* iface,
299 WORD *pcBytes,
300 BYTE **ppBytes)
301 {
302 FIXME("(%p, %p, %p): stub\n", iface, pcBytes, ppBytes);
303 return E_NOTIMPL;
304 }
305
306 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryCount(
307 ITask* iface,
308 WORD wRetryCount)
309 {
310 FIXME("(%p, %d): stub\n", iface, wRetryCount);
311 return E_NOTIMPL;
312 }
313
314 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryCount(
315 ITask* iface,
316 WORD *pwRetryCount)
317 {
318 FIXME("(%p, %p): stub\n", iface, pwRetryCount);
319 return E_NOTIMPL;
320 }
321
322 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryInterval(
323 ITask* iface,
324 WORD wRetryInterval)
325 {
326 FIXME("(%p, %d): stub\n", iface, wRetryInterval);
327 return E_NOTIMPL;
328 }
329
330 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryInterval(
331 ITask* iface,
332 WORD *pwRetryInterval)
333 {
334 FIXME("(%p, %p): stub\n", iface, pwRetryInterval);
335 return E_NOTIMPL;
336 }
337
338 static HRESULT WINAPI MSTASK_ITask_SetFlags(
339 ITask* iface,
340 DWORD dwFlags)
341 {
342 FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
343 return E_NOTIMPL;
344 }
345
346 static HRESULT WINAPI MSTASK_ITask_GetFlags(
347 ITask* iface,
348 DWORD *pdwFlags)
349 {
350 FIXME("(%p, %p): stub\n", iface, pdwFlags);
351 return E_NOTIMPL;
352 }
353
354 static HRESULT WINAPI MSTASK_ITask_SetAccountInformation(
355 ITask* iface,
356 LPCWSTR pwszAccountName,
357 LPCWSTR pwszPassword)
358 {
359 DWORD n;
360 TaskImpl *This = (TaskImpl *)iface;
361 LPWSTR tmp_account_name;
362
363 TRACE("(%p, %s, %s): partial stub\n", iface, debugstr_w(pwszAccountName),
364 debugstr_w(pwszPassword));
365
366 if (pwszPassword)
367 FIXME("Partial stub ignores passwords\n");
368
369 n = (lstrlenW(pwszAccountName) + 1);
370 tmp_account_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
371 if (!tmp_account_name)
372 return E_OUTOFMEMORY;
373 lstrcpyW(tmp_account_name, pwszAccountName);
374 HeapFree(GetProcessHeap(), 0, This->accountName);
375 This->accountName = tmp_account_name;
376 return S_OK;
377 }
378
379 static HRESULT WINAPI MSTASK_ITask_GetAccountInformation(
380 ITask* iface,
381 LPWSTR *ppwszAccountName)
382 {
383 DWORD n;
384 TaskImpl *This = (TaskImpl *)iface;
385
386 TRACE("(%p, %p): partial stub\n", iface, ppwszAccountName);
387
388 /* This implements the WinXP behavior when accountName has not yet
389 * set. Win2K behaves differently, returning SCHED_E_CANNOT_OPEN_TASK */
390 if (!This->accountName)
391 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
392
393 n = (lstrlenW(This->accountName) + 1);
394 *ppwszAccountName = CoTaskMemAlloc(n * sizeof(WCHAR));
395 if (!*ppwszAccountName)
396 return E_OUTOFMEMORY;
397 lstrcpyW(*ppwszAccountName, This->accountName);
398 return S_OK;
399 }
400
401 static HRESULT WINAPI MSTASK_ITask_SetApplicationName(
402 ITask* iface,
403 LPCWSTR pwszApplicationName)
404 {
405 DWORD n;
406 TaskImpl *This = (TaskImpl *)iface;
407 LPWSTR tmp_name;
408
409 TRACE("(%p, %s)\n", iface, debugstr_w(pwszApplicationName));
410
411 /* Empty application name */
412 if (pwszApplicationName[0] == 0)
413 {
414 HeapFree(GetProcessHeap(), 0, This->applicationName);
415 This->applicationName = NULL;
416 return S_OK;
417 }
418
419 /* Attempt to set pwszApplicationName to a path resolved application name */
420 n = SearchPathW(NULL, pwszApplicationName, NULL, 0, NULL, NULL);
421 if (n)
422 {
423 tmp_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
424 if (!tmp_name)
425 return E_OUTOFMEMORY;
426 n = SearchPathW(NULL, pwszApplicationName, NULL, n, tmp_name, NULL);
427 if (n)
428 {
429 HeapFree(GetProcessHeap(), 0, This->applicationName);
430 This->applicationName = tmp_name;
431 return S_OK;
432 }
433 else
434 HeapFree(GetProcessHeap(), 0, tmp_name);
435 }
436
437 /* If unable to path resolve name, simply set to pwszApplicationName */
438 n = (lstrlenW(pwszApplicationName) + 1);
439 tmp_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
440 if (!tmp_name)
441 return E_OUTOFMEMORY;
442 lstrcpyW(tmp_name, pwszApplicationName);
443 HeapFree(GetProcessHeap(), 0, This->applicationName);
444 This->applicationName = tmp_name;
445 return S_OK;
446 }
447
448 static HRESULT WINAPI MSTASK_ITask_GetApplicationName(
449 ITask* iface,
450 LPWSTR *ppwszApplicationName)
451 {
452 DWORD n;
453 TaskImpl *This = (TaskImpl *)iface;
454
455 TRACE("(%p, %p)\n", iface, ppwszApplicationName);
456
457 n = This->applicationName ? lstrlenW(This->applicationName) + 1 : 1;
458 *ppwszApplicationName = CoTaskMemAlloc(n * sizeof(WCHAR));
459 if (!*ppwszApplicationName)
460 return E_OUTOFMEMORY;
461
462 if (!This->applicationName)
463 *ppwszApplicationName[0] = 0;
464 else
465 lstrcpyW(*ppwszApplicationName, This->applicationName);
466
467 return S_OK;
468 }
469
470 static HRESULT WINAPI MSTASK_ITask_SetParameters(
471 ITask* iface,
472 LPCWSTR pwszParameters)
473 {
474 DWORD n;
475 TaskImpl *This = (TaskImpl *)iface;
476 LPWSTR tmp_parameters;
477
478 TRACE("(%p, %s)\n", iface, debugstr_w(pwszParameters));
479
480 /* Empty parameter list */
481 if (pwszParameters[0] == 0)
482 {
483 HeapFree(GetProcessHeap(), 0, This->parameters);
484 This->parameters = NULL;
485 return S_OK;
486 }
487
488 /* Set to pwszParameters */
489 n = (lstrlenW(pwszParameters) + 1);
490 tmp_parameters = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
491 if (!tmp_parameters)
492 return E_OUTOFMEMORY;
493 lstrcpyW(tmp_parameters, pwszParameters);
494 HeapFree(GetProcessHeap(), 0, This->parameters);
495 This->parameters = tmp_parameters;
496 return S_OK;
497 }
498
499 static HRESULT WINAPI MSTASK_ITask_GetParameters(
500 ITask* iface,
501 LPWSTR *ppwszParameters)
502 {
503 DWORD n;
504 TaskImpl *This = (TaskImpl *)iface;
505
506 TRACE("(%p, %p)\n", iface, ppwszParameters);
507
508 n = This->parameters ? lstrlenW(This->parameters) + 1 : 1;
509 *ppwszParameters = CoTaskMemAlloc(n * sizeof(WCHAR));
510 if (!*ppwszParameters)
511 return E_OUTOFMEMORY;
512
513 if (!This->parameters)
514 *ppwszParameters[0] = 0;
515 else
516 lstrcpyW(*ppwszParameters, This->parameters);
517
518 return S_OK;
519 }
520
521 static HRESULT WINAPI MSTASK_ITask_SetWorkingDirectory(
522 ITask* iface,
523 LPCWSTR pwszWorkingDirectory)
524 {
525 FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszWorkingDirectory));
526 return E_NOTIMPL;
527 }
528
529 static HRESULT WINAPI MSTASK_ITask_GetWorkingDirectory(
530 ITask* iface,
531 LPWSTR *ppwszWorkingDirectory)
532 {
533 FIXME("(%p, %p): stub\n", iface, ppwszWorkingDirectory);
534 return E_NOTIMPL;
535 }
536
537 static HRESULT WINAPI MSTASK_ITask_SetPriority(
538 ITask* iface,
539 DWORD dwPriority)
540 {
541 FIXME("(%p, 0x%08x): stub\n", iface, dwPriority);
542 return E_NOTIMPL;
543 }
544
545 static HRESULT WINAPI MSTASK_ITask_GetPriority(
546 ITask* iface,
547 DWORD *pdwPriority)
548 {
549 FIXME("(%p, %p): stub\n", iface, pdwPriority);
550 return E_NOTIMPL;
551 }
552
553 static HRESULT WINAPI MSTASK_ITask_SetTaskFlags(
554 ITask* iface,
555 DWORD dwFlags)
556 {
557 FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
558 return E_NOTIMPL;
559 }
560
561 static HRESULT WINAPI MSTASK_ITask_GetTaskFlags(
562 ITask* iface,
563 DWORD *pdwFlags)
564 {
565 FIXME("(%p, %p): stub\n", iface, pdwFlags);
566 return E_NOTIMPL;
567 }
568
569 static HRESULT WINAPI MSTASK_ITask_SetMaxRunTime(
570 ITask* iface,
571 DWORD dwMaxRunTime)
572 {
573 TaskImpl *This = (TaskImpl *)iface;
574
575 TRACE("(%p, %d)\n", iface, dwMaxRunTime);
576
577 This->maxRunTime = dwMaxRunTime;
578 return S_OK;
579 }
580
581 static HRESULT WINAPI MSTASK_ITask_GetMaxRunTime(
582 ITask* iface,
583 DWORD *pdwMaxRunTime)
584 {
585 TaskImpl *This = (TaskImpl *)iface;
586
587 TRACE("(%p, %p)\n", iface, pdwMaxRunTime);
588
589 *pdwMaxRunTime = This->maxRunTime;
590 return S_OK;
591 }
592
593 static HRESULT WINAPI MSTASK_IPersistFile_QueryInterface(
594 IPersistFile* iface,
595 REFIID riid,
596 void **ppvObject)
597 {
598 TaskImpl *This = impl_from_IPersistFile(iface);
599 TRACE("(%p, %s, %p)\n", iface, debugstr_guid(riid), ppvObject);
600 return ITask_QueryInterface((ITask *) This, riid, ppvObject);
601 }
602
603 static ULONG WINAPI MSTASK_IPersistFile_AddRef(
604 IPersistFile* iface)
605 {
606 TaskImpl *This = impl_from_IPersistFile(iface);
607 ULONG ref;
608 TRACE("\n");
609 ref = InterlockedIncrement(&This->ref);
610 return ref;
611 }
612
613 static ULONG WINAPI MSTASK_IPersistFile_Release(
614 IPersistFile* iface)
615 {
616 TaskImpl *This = impl_from_IPersistFile(iface);
617 ULONG ref;
618 TRACE("\n");
619 ref = InterlockedDecrement(&This->ref);
620 if (ref == 0)
621 TaskDestructor(This);
622 return ref;
623 }
624
625 static HRESULT WINAPI MSTASK_IPersistFile_GetClassID(
626 IPersistFile* iface,
627 CLSID *pClassID)
628 {
629 FIXME("(%p, %p): stub\n", iface, pClassID);
630 return E_NOTIMPL;
631 }
632
633 static HRESULT WINAPI MSTASK_IPersistFile_IsDirty(
634 IPersistFile* iface)
635 {
636 FIXME("(%p): stub\n", iface);
637 return E_NOTIMPL;
638 }
639
640 static HRESULT WINAPI MSTASK_IPersistFile_Load(
641 IPersistFile* iface,
642 LPCOLESTR pszFileName,
643 DWORD dwMode)
644 {
645 FIXME("(%p, %p, 0x%08x): stub\n", iface, pszFileName, dwMode);
646 return E_NOTIMPL;
647 }
648
649 static HRESULT WINAPI MSTASK_IPersistFile_Save(
650 IPersistFile* iface,
651 LPCOLESTR pszFileName,
652 BOOL fRemember)
653 {
654 FIXME("(%p, %p, %d): stub\n", iface, pszFileName, fRemember);
655 WARN("Returning S_OK but not writing to disk: %s %d\n",
656 debugstr_w(pszFileName), fRemember);
657 return S_OK;
658 }
659
660 static HRESULT WINAPI MSTASK_IPersistFile_SaveCompleted(
661 IPersistFile* iface,
662 LPCOLESTR pszFileName)
663 {
664 FIXME("(%p, %p): stub\n", iface, pszFileName);
665 return E_NOTIMPL;
666 }
667
668 static HRESULT WINAPI MSTASK_IPersistFile_GetCurFile(
669 IPersistFile* iface,
670 LPOLESTR *ppszFileName)
671 {
672 FIXME("(%p, %p): stub\n", iface, ppszFileName);
673 return E_NOTIMPL;
674 }
675
676
677 static const ITaskVtbl MSTASK_ITaskVtbl =
678 {
679 MSTASK_ITask_QueryInterface,
680 MSTASK_ITask_AddRef,
681 MSTASK_ITask_Release,
682 MSTASK_ITask_CreateTrigger,
683 MSTASK_ITask_DeleteTrigger,
684 MSTASK_ITask_GetTriggerCount,
685 MSTASK_ITask_GetTrigger,
686 MSTASK_ITask_GetTriggerString,
687 MSTASK_ITask_GetRunTimes,
688 MSTASK_ITask_GetNextRunTime,
689 MSTASK_ITask_SetIdleWait,
690 MSTASK_ITask_GetIdleWait,
691 MSTASK_ITask_Run,
692 MSTASK_ITask_Terminate,
693 MSTASK_ITask_EditWorkItem,
694 MSTASK_ITask_GetMostRecentRunTime,
695 MSTASK_ITask_GetStatus,
696 MSTASK_ITask_GetExitCode,
697 MSTASK_ITask_SetComment,
698 MSTASK_ITask_GetComment,
699 MSTASK_ITask_SetCreator,
700 MSTASK_ITask_GetCreator,
701 MSTASK_ITask_SetWorkItemData,
702 MSTASK_ITask_GetWorkItemData,
703 MSTASK_ITask_SetErrorRetryCount,
704 MSTASK_ITask_GetErrorRetryCount,
705 MSTASK_ITask_SetErrorRetryInterval,
706 MSTASK_ITask_GetErrorRetryInterval,
707 MSTASK_ITask_SetFlags,
708 MSTASK_ITask_GetFlags,
709 MSTASK_ITask_SetAccountInformation,
710 MSTASK_ITask_GetAccountInformation,
711 MSTASK_ITask_SetApplicationName,
712 MSTASK_ITask_GetApplicationName,
713 MSTASK_ITask_SetParameters,
714 MSTASK_ITask_GetParameters,
715 MSTASK_ITask_SetWorkingDirectory,
716 MSTASK_ITask_GetWorkingDirectory,
717 MSTASK_ITask_SetPriority,
718 MSTASK_ITask_GetPriority,
719 MSTASK_ITask_SetTaskFlags,
720 MSTASK_ITask_GetTaskFlags,
721 MSTASK_ITask_SetMaxRunTime,
722 MSTASK_ITask_GetMaxRunTime
723 };
724
725 static const IPersistFileVtbl MSTASK_IPersistFileVtbl =
726 {
727 MSTASK_IPersistFile_QueryInterface,
728 MSTASK_IPersistFile_AddRef,
729 MSTASK_IPersistFile_Release,
730 MSTASK_IPersistFile_GetClassID,
731 MSTASK_IPersistFile_IsDirty,
732 MSTASK_IPersistFile_Load,
733 MSTASK_IPersistFile_Save,
734 MSTASK_IPersistFile_SaveCompleted,
735 MSTASK_IPersistFile_GetCurFile
736 };
737
738 HRESULT TaskConstructor(LPCWSTR pwszTaskName, LPVOID *ppObj)
739 {
740 TaskImpl *This;
741 int n;
742
743 TRACE("(%s, %p)\n", debugstr_w(pwszTaskName), ppObj);
744
745 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
746 if (!This)
747 return E_OUTOFMEMORY;
748
749 This->lpVtbl = &MSTASK_ITaskVtbl;
750 This->persistVtbl = &MSTASK_IPersistFileVtbl;
751 This->ref = 1;
752 n = (lstrlenW(pwszTaskName) + 1) * sizeof(WCHAR);
753 This->taskName = HeapAlloc(GetProcessHeap(), 0, n);
754 if (!This->taskName)
755 {
756 HeapFree(GetProcessHeap(), 0, This);
757 return E_OUTOFMEMORY;
758 }
759 lstrcpyW(This->taskName, pwszTaskName);
760 This->applicationName = NULL;
761 This->parameters = NULL;
762 This->comment = NULL;
763 This->accountName = NULL;
764
765 /* Default time is 3 days = 259200000 ms */
766 This->maxRunTime = 259200000;
767
768 *ppObj = &This->lpVtbl;
769 InterlockedIncrement(&dll_ref);
770 return S_OK;
771 }