dlls/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 void TaskDestructor(TaskImpl *This)
  25 {
  26     TRACE("%p\n", This);
  27     HeapFree(GetProcessHeap(), 0, This->taskName);
  28     HeapFree(GetProcessHeap(), 0, This);
  29     InterlockedDecrement(&dll_ref);
  30 }
  31
  32 static HRESULT WINAPI MSTASK_ITask_QueryInterface(
  33         ITask* iface,
  34         REFIID riid,
  35         void **ppvObject)
  36 {
  37     TaskImpl * This = (TaskImpl *)iface;
  38
  39     TRACE("IID: %s\n", debugstr_guid(riid));
  40     if (ppvObject == NULL)
  41         return E_POINTER;
  42
  43     if (IsEqualGUID(riid, &IID_IUnknown) ||
  44             IsEqualGUID(riid, &IID_ITask))
  45     {
  46         *ppvObject = &This->lpVtbl;
  47         ITask_AddRef(iface);
  48         return S_OK;
  49     }
  50
  51     WARN("Unknown interface: %s\n", debugstr_guid(riid));
  52     *ppvObject = NULL;
  53     return E_NOINTERFACE;
  54 }
  55
  56 static ULONG WINAPI MSTASK_ITask_AddRef(
  57         ITask* iface)
  58 {
  59     TaskImpl *This = (TaskImpl *)iface;
  60     ULONG ref;
  61     TRACE("\n");
  62     ref = InterlockedIncrement(&This->ref);
  63     return ref;
  64 }
  65
  66 static ULONG WINAPI MSTASK_ITask_Release(
  67         ITask* iface)
  68 {
  69     TaskImpl * This = (TaskImpl *)iface;
  70     ULONG ref;
  71     TRACE("\n");
  72     ref = InterlockedDecrement(&This->ref);
  73     if (ref == 0)
  74         TaskDestructor(This);
  75     return ref;
  76 }
  77
  78 static HRESULT WINAPI MSTASK_ITask_CreateTrigger(
  79         ITask* iface,
  80         WORD *piNewTrigger,
  81         ITaskTrigger **ppTrigger)
  82 {
  83     FIXME("(%p, %p, %p): stub\n", iface, piNewTrigger, ppTrigger);
  84     return E_NOTIMPL;
  85 }
  86
  87 static HRESULT WINAPI MSTASK_ITask_DeleteTrigger(
  88         ITask* iface,
  89         WORD iTrigger)
  90 {
  91     FIXME("(%p, %d): stub\n", iface, iTrigger);
  92     return E_NOTIMPL;
  93 }
  94
  95 static HRESULT WINAPI MSTASK_ITask_GetTriggerCount(
  96         ITask* iface,
  97         WORD *plCount)
  98 {
  99     FIXME("(%p, %p): stub\n", iface, plCount);
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT WINAPI MSTASK_ITask_GetTrigger(
 104         ITask* iface,
 105         WORD iTrigger,
 106         ITaskTrigger **ppTrigger)
 107 {
 108     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppTrigger);
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI MSTASK_ITask_GetTriggerString(
 113         ITask* iface,
 114         WORD iTrigger,
 115         LPWSTR *ppwszTrigger)
 116 {
 117     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppwszTrigger);
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT WINAPI MSTASK_ITask_GetRunTimes(
 122         ITask* iface,
 123         const LPSYSTEMTIME pstBegin,
 124         const LPSYSTEMTIME pstEnd,
 125         WORD *pCount,
 126         LPSYSTEMTIME *rgstTaskTimes)
 127 {
 128     FIXME("(%p, %p, %p, %p, %p): stub\n", iface, pstBegin, pstEnd, pCount,
 129             rgstTaskTimes);
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI MSTASK_ITask_GetNextRunTime(
 134         ITask* iface,
 135         SYSTEMTIME *pstNextRun)
 136 {
 137     FIXME("(%p, %p): stub\n", iface, pstNextRun);
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI MSTASK_ITask_SetIdleWait(
 142         ITask* iface,
 143         WORD wIdleMinutes,
 144         WORD wDeadlineMinutes)
 145 {
 146     FIXME("(%p, %d, %d): stub\n", iface, wIdleMinutes, wDeadlineMinutes);
 147     return E_NOTIMPL;
 148 }
 149
 150 static HRESULT WINAPI MSTASK_ITask_GetIdleWait(
 151         ITask* iface,
 152         WORD *pwIdleMinutes,
 153         WORD *pwDeadlineMinutes)
 154 {
 155     FIXME("(%p, %p, %p): stub\n", iface, pwIdleMinutes, pwDeadlineMinutes);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI MSTASK_ITask_Run(
 160         ITask* iface)
 161 {
 162     FIXME("(%p): stub\n", iface);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI MSTASK_ITask_Terminate(
 167         ITask* iface)
 168 {
 169     FIXME("(%p): stub\n", iface);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI MSTASK_ITask_EditWorkItem(
 174         ITask* iface,
 175         HWND hParent,
 176         DWORD dwReserved)
 177 {
 178     FIXME("(%p, %p, %d): stub\n", iface, hParent, dwReserved);
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI MSTASK_ITask_GetMostRecentRunTime(
 183         ITask* iface,
 184         SYSTEMTIME *pstLastRun)
 185 {
 186     FIXME("(%p, %p): stub\n", iface, pstLastRun);
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI MSTASK_ITask_GetStatus(
 191         ITask* iface,
 192         HRESULT *phrStatus)
 193 {
 194     FIXME("(%p, %p): stub\n", iface, phrStatus);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI MSTASK_ITask_GetExitCode(
 199         ITask* iface,
 200         DWORD *pdwExitCode)
 201 {
 202     FIXME("(%p, %p): stub\n", iface, pdwExitCode);
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI MSTASK_ITask_SetComment(
 207         ITask* iface,
 208         LPCWSTR pwszComment)
 209 {
 210     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszComment));
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI MSTASK_ITask_GetComment(
 215         ITask* iface,
 216         LPWSTR *ppwszComment)
 217 {
 218     FIXME("(%p, %p): stub\n", iface, ppwszComment);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI MSTASK_ITask_SetCreator(
 223         ITask* iface,
 224         LPCWSTR pwszCreator)
 225 {
 226     FIXME("(%p, %p): stub\n", iface, pwszCreator);
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI MSTASK_ITask_GetCreator(
 231         ITask* iface,
 232         LPWSTR *ppwszCreator)
 233 {
 234     FIXME("(%p, %p): stub\n", iface, ppwszCreator);
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI MSTASK_ITask_SetWorkItemData(
 239         ITask* iface,
 240         WORD cBytes,
 241         BYTE rgbData[])
 242 {
 243     FIXME("(%p, %d, %p): stub\n", iface, cBytes, rgbData);
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI MSTASK_ITask_GetWorkItemData(
 248         ITask* iface,
 249         WORD *pcBytes,
 250         BYTE **ppBytes)
 251 {
 252     FIXME("(%p, %p, %p): stub\n", iface, pcBytes, ppBytes);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryCount(
 257         ITask* iface,
 258         WORD wRetryCount)
 259 {
 260     FIXME("(%p, %d): stub\n", iface, wRetryCount);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryCount(
 265         ITask* iface,
 266         WORD *pwRetryCount)
 267 {
 268     FIXME("(%p, %p): stub\n", iface, pwRetryCount);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryInterval(
 273         ITask* iface,
 274         WORD wRetryInterval)
 275 {
 276     FIXME("(%p, %d): stub\n", iface, wRetryInterval);
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryInterval(
 281         ITask* iface,
 282         WORD *pwRetryInterval)
 283 {
 284     FIXME("(%p, %p): stub\n", iface, pwRetryInterval);
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI MSTASK_ITask_SetFlags(
 289         ITask* iface,
 290         DWORD dwFlags)
 291 {
 292     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI MSTASK_ITask_GetFlags(
 297         ITask* iface,
 298         DWORD *pdwFlags)
 299 {
 300     FIXME("(%p, %p): stub\n", iface, pdwFlags);
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI MSTASK_ITask_SetAccountInformation(
 305         ITask* iface,
 306         LPCWSTR pwszAccountName,
 307         LPCWSTR pwszPassword)
 308 {
 309     FIXME("(%p, %s, %s): stub\n", iface, debugstr_w(pwszAccountName),
 310             debugstr_w(pwszPassword));
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI MSTASK_ITask_GetAccountInformation(
 315         ITask* iface,
 316         LPWSTR *ppwszAccountName)
 317 {
 318     FIXME("(%p, %p): stub\n", iface, ppwszAccountName);
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI MSTASK_ITask_SetApplicationName(
 323         ITask* iface,
 324         LPCWSTR pwszApplicationName)
 325 {
 326     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszApplicationName));
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI MSTASK_ITask_GetApplicationName(
 331         ITask* iface,
 332         LPWSTR *ppwszApplicationName)
 333 {
 334     FIXME("(%p, %p): stub\n", iface, ppwszApplicationName);
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI MSTASK_ITask_SetParameters(
 339         ITask* iface,
 340         LPCWSTR pwszParameters)
 341 {
 342     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszParameters));
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI MSTASK_ITask_GetParameters(
 347         ITask* iface,
 348         LPWSTR *ppwszParameters)
 349 {
 350     FIXME("(%p, %p): stub\n", iface, ppwszParameters);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI MSTASK_ITask_SetWorkingDirectory(
 355         ITask* iface,
 356         LPCWSTR pwszWorkingDirectory)
 357 {
 358     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszWorkingDirectory));
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI MSTASK_ITask_GetWorkingDirectory(
 363         ITask* iface,
 364         LPWSTR *ppwszWorkingDirectory)
 365 {
 366     FIXME("(%p, %p): stub\n", iface, ppwszWorkingDirectory);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI MSTASK_ITask_SetPriority(
 371         ITask* iface,
 372         DWORD dwPriority)
 373 {
 374     FIXME("(%p, 0x%08x): stub\n", iface, dwPriority);
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI MSTASK_ITask_GetPriority(
 379         ITask* iface,
 380         DWORD *pdwPriority)
 381 {
 382     FIXME("(%p, %p): stub\n", iface, pdwPriority);
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI MSTASK_ITask_SetTaskFlags(
 387         ITask* iface,
 388         DWORD dwFlags)
 389 {
 390     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI MSTASK_ITask_GetTaskFlags(
 395         ITask* iface,
 396         DWORD *pdwFlags)
 397 {
 398     FIXME("(%p, %p): stub\n", iface, pdwFlags);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI MSTASK_ITask_SetMaxRunTime(
 403         ITask* iface,
 404         DWORD dwMaxRunTime)
 405 {
 406     FIXME("(%p, %d): stub\n", iface, dwMaxRunTime);
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI MSTASK_ITask_GetMaxRunTime(
 411         ITask* iface,
 412         DWORD *pdwMaxRunTime)
 413 {
 414     FIXME("(%p, %p): stub\n", iface, pdwMaxRunTime);
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI MSTASK_IPersistFile_QueryInterface(
 419         IPersistFile* iface,
 420         REFIID riid,
 421         void **ppvObject)
 422 {
 423     FIXME("(%p, %s, %p): stub\n", iface, debugstr_guid(riid), ppvObject);
 424     return E_NOTIMPL;
 425 }
 426
 427 static ULONG WINAPI MSTASK_IPersistFile_AddRef(
 428         IPersistFile* iface)
 429 {
 430     FIXME("(%p): stub\n", iface);
 431     return E_NOTIMPL;
 432 }
 433
 434 static ULONG WINAPI MSTASK_IPersistFile_Release(
 435         IPersistFile* iface)
 436 {
 437     FIXME("(%p): stub\n", iface);
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI MSTASK_IPersistFile_GetClassID(
 442         IPersistFile* iface,
 443         CLSID *pClassID)
 444 {
 445     FIXME("(%p, %p): stub\n", iface, pClassID);
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI MSTASK_IPersistFile_IsDirty(
 450         IPersistFile* iface)
 451 {
 452     FIXME("(%p): stub\n", iface);
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI MSTASK_IPersistFile_Load(
 457         IPersistFile* iface,
 458         LPCOLESTR pszFileName,
 459         DWORD dwMode)
 460 {
 461     FIXME("(%p, %p, 0x%08x): stub\n", iface, pszFileName, dwMode);
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI MSTASK_IPersistFile_Save(
 466         IPersistFile* iface,
 467         LPCOLESTR pszFileName,
 468         BOOL fRemember)
 469 {
 470     FIXME("(%p, %p, %d): stub\n", iface, pszFileName, fRemember);
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI MSTASK_IPersistFile_SaveCompleted(
 475         IPersistFile* iface,
 476         LPCOLESTR pszFileName)
 477 {
 478     FIXME("(%p, %p): stub\n", iface, pszFileName);
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI MSTASK_IPersistFile_GetCurFile(
 483         IPersistFile* iface,
 484         LPOLESTR *ppszFileName)
 485 {
 486     FIXME("(%p, %p): stub\n", iface, ppszFileName);
 487     return E_NOTIMPL;
 488 }
 489
 490
 491 static const ITaskVtbl MSTASK_ITaskVtbl =
 492 {
 493     MSTASK_ITask_QueryInterface,
 494     MSTASK_ITask_AddRef,
 495     MSTASK_ITask_Release,
 496     MSTASK_ITask_CreateTrigger,
 497     MSTASK_ITask_DeleteTrigger,
 498     MSTASK_ITask_GetTriggerCount,
 499     MSTASK_ITask_GetTrigger,
 500     MSTASK_ITask_GetTriggerString,
 501     MSTASK_ITask_GetRunTimes,
 502     MSTASK_ITask_GetNextRunTime,
 503     MSTASK_ITask_SetIdleWait,
 504     MSTASK_ITask_GetIdleWait,
 505     MSTASK_ITask_Run,
 506     MSTASK_ITask_Terminate,
 507     MSTASK_ITask_EditWorkItem,
 508     MSTASK_ITask_GetMostRecentRunTime,
 509     MSTASK_ITask_GetStatus,
 510     MSTASK_ITask_GetExitCode,
 511     MSTASK_ITask_SetComment,
 512     MSTASK_ITask_GetComment,
 513     MSTASK_ITask_SetCreator,
 514     MSTASK_ITask_GetCreator,
 515     MSTASK_ITask_SetWorkItemData,
 516     MSTASK_ITask_GetWorkItemData,
 517     MSTASK_ITask_SetErrorRetryCount,
 518     MSTASK_ITask_GetErrorRetryCount,
 519     MSTASK_ITask_SetErrorRetryInterval,
 520     MSTASK_ITask_GetErrorRetryInterval,
 521     MSTASK_ITask_SetFlags,
 522     MSTASK_ITask_GetFlags,
 523     MSTASK_ITask_SetAccountInformation,
 524     MSTASK_ITask_GetAccountInformation,
 525     MSTASK_ITask_SetApplicationName,
 526     MSTASK_ITask_GetApplicationName,
 527     MSTASK_ITask_SetParameters,
 528     MSTASK_ITask_GetParameters,
 529     MSTASK_ITask_SetWorkingDirectory,
 530     MSTASK_ITask_GetWorkingDirectory,
 531     MSTASK_ITask_SetPriority,
 532     MSTASK_ITask_GetPriority,
 533     MSTASK_ITask_SetTaskFlags,
 534     MSTASK_ITask_GetTaskFlags,
 535     MSTASK_ITask_SetMaxRunTime,
 536     MSTASK_ITask_GetMaxRunTime
 537 };
 538
 539 static const IPersistFileVtbl MSTASK_IPersistFileVtbl =
 540 {
 541     MSTASK_IPersistFile_QueryInterface,
 542     MSTASK_IPersistFile_AddRef,
 543     MSTASK_IPersistFile_Release,
 544     MSTASK_IPersistFile_GetClassID,
 545     MSTASK_IPersistFile_IsDirty,
 546     MSTASK_IPersistFile_Load,
 547     MSTASK_IPersistFile_Save,
 548     MSTASK_IPersistFile_SaveCompleted,
 549     MSTASK_IPersistFile_GetCurFile
 550 };
 551
 552 HRESULT TaskConstructor(LPCWSTR pwszTaskName, LPVOID *ppObj)
 553 {
 554     TaskImpl *This;
 555     int n;
 556
 557     TRACE("(%s, %p)\n", debugstr_w(pwszTaskName), ppObj);
 558
 559     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 560     if (!This)
 561         return E_OUTOFMEMORY;
 562
 563     This->lpVtbl = &MSTASK_ITaskVtbl;
 564     This->persistVtbl = &MSTASK_IPersistFileVtbl;
 565     This->ref = 1;
 566     n = (lstrlenW(pwszTaskName) + 1) * sizeof(WCHAR);
 567     This->taskName = HeapAlloc(GetProcessHeap(), 0, n);
 568     if (!This->taskName)
 569     {
 570         HeapFree(GetProcessHeap(), 0, This);
 571         return E_OUTOFMEMORY;
 572     }
 573     lstrcpyW(This->taskName, pwszTaskName);
 574
 575     *ppObj = &This->lpVtbl;
 576     InterlockedIncrement(&dll_ref);
 577     return S_OK;
 578 }