dlls/shell32/shelldispatch.c

   1 /*
   2  * IShellDispatch implementation
   3  *
   4  * Copyright 2010 Alexander Morozov for Etersoft
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25
  26 #define COBJMACROS
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winreg.h"
  33 #include "winsvc.h"
  34 #include "shlwapi.h"
  35 #include "shlobj.h"
  36 #include "shldisp.h"
  37 #include "debughlp.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  42
  43 enum tid_t {
  44     NULL_tid,
  45     IShellDispatch5_tid,
  46     Folder3_tid,
  47     FolderItem_tid,
  48     LAST_tid
  49 };
  50
  51 static ITypeLib *typelib;
  52 static const IID * const tid_ids[] =
  53 {
  54     &IID_NULL,
  55     &IID_IShellDispatch5,
  56     &IID_Folder3,
  57     &IID_FolderItem
  58 };
  59 static ITypeInfo *typeinfos[LAST_tid];
  60
  61 typedef struct {
  62     IShellDispatch5 IShellDispatch5_iface;
  63     LONG ref;
  64 } ShellDispatch;
  65
  66 typedef struct {
  67     Folder3 Folder3_iface;
  68     LONG ref;
  69     VARIANT dir;
  70 } FolderImpl;
  71
  72 typedef struct {
  73     FolderItem FolderItem_iface;
  74     LONG ref;
  75     VARIANT dir;
  76 } FolderItemImpl;
  77
  78 static inline ShellDispatch *impl_from_IShellDispatch5(IShellDispatch5 *iface)
  79 {
  80     return CONTAINING_RECORD(iface, ShellDispatch, IShellDispatch5_iface);
  81 }
  82
  83 static inline FolderImpl *impl_from_Folder(Folder3 *iface)
  84 {
  85     return CONTAINING_RECORD(iface, FolderImpl, Folder3_iface);
  86 }
  87
  88 static inline FolderItemImpl *impl_from_FolderItem(FolderItem *iface)
  89 {
  90     return CONTAINING_RECORD(iface, FolderItemImpl, FolderItem_iface);
  91 }
  92
  93 static HRESULT load_typelib(void)
  94 {
  95     ITypeLib *tl;
  96     HRESULT hr;
  97
  98     hr = LoadRegTypeLib(&LIBID_Shell32, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
  99     if (FAILED(hr)) {
 100         ERR("LoadRegTypeLib failed: %08x\n", hr);
 101         return hr;
 102     }
 103
 104     if (InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
 105         ITypeLib_Release(tl);
 106     return hr;
 107 }
 108
 109 void release_typelib(void)
 110 {
 111     unsigned i;
 112
 113     if (!typelib)
 114         return;
 115
 116     for (i = 0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 117         if (typeinfos[i])
 118             ITypeInfo_Release(typeinfos[i]);
 119
 120     ITypeLib_Release(typelib);
 121 }
 122
 123 static HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
 124 {
 125     HRESULT hr;
 126
 127     if (!typelib)
 128         hr = load_typelib();
 129     if (!typelib)
 130         return hr;
 131
 132     if (!typeinfos[tid])
 133     {
 134         ITypeInfo *ti;
 135
 136         hr = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
 137         if (FAILED(hr))
 138         {
 139             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hr);
 140             return hr;
 141         }
 142
 143         if (InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
 144             ITypeInfo_Release(ti);
 145     }
 146
 147     *typeinfo = typeinfos[tid];
 148     return S_OK;
 149 }
 150
 151 static HRESULT WINAPI FolderItemImpl_QueryInterface(FolderItem *iface,
 152         REFIID riid, LPVOID *ppv)
 153 {
 154     FolderItemImpl *This = impl_from_FolderItem(iface);
 155
 156     TRACE("(%p,%p,%p)\n", iface, riid, ppv);
 157
 158     if (!ppv) return E_INVALIDARG;
 159
 160     if (IsEqualIID(&IID_IUnknown, riid) ||
 161         IsEqualIID(&IID_IDispatch, riid) ||
 162         IsEqualIID(&IID_FolderItem, riid))
 163         *ppv = &This->FolderItem_iface;
 164     else
 165     {
 166         FIXME("not implemented for %s\n", shdebugstr_guid(riid));
 167         *ppv = NULL;
 168         return E_NOINTERFACE;
 169     }
 170     IUnknown_AddRef((IUnknown*)*ppv);
 171     return S_OK;
 172 }
 173
 174 static ULONG WINAPI FolderItemImpl_AddRef(FolderItem *iface)
 175 {
 176     FolderItemImpl *This = impl_from_FolderItem(iface);
 177     ULONG ref = InterlockedIncrement(&This->ref);
 178
 179     TRACE("(%p), new refcount=%i\n", iface, ref);
 180
 181     return ref;
 182 }
 183
 184 static ULONG WINAPI FolderItemImpl_Release(FolderItem *iface)
 185 {
 186     FolderItemImpl *This = impl_from_FolderItem(iface);
 187     ULONG ref = InterlockedDecrement(&This->ref);
 188
 189     TRACE("(%p), new refcount=%i\n", iface, ref);
 190
 191     if (!ref)
 192     {
 193         VariantClear(&This->dir);
 194         HeapFree(GetProcessHeap(), 0, This);
 195     }
 196     return ref;
 197 }
 198
 199 static HRESULT WINAPI FolderItemImpl_GetTypeInfoCount(FolderItem *iface,
 200         UINT *pctinfo)
 201 {
 202     TRACE("(%p,%p)\n", iface, pctinfo);
 203
 204     *pctinfo = 1;
 205     return S_OK;
 206 }
 207
 208 static HRESULT WINAPI FolderItemImpl_GetTypeInfo(FolderItem *iface, UINT iTInfo,
 209         LCID lcid, ITypeInfo **ppTInfo)
 210 {
 211     HRESULT hr;
 212
 213     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 214
 215     hr = get_typeinfo(FolderItem_tid, ppTInfo);
 216     if (SUCCEEDED(hr))
 217         ITypeInfo_AddRef(*ppTInfo);
 218     return hr;
 219 }
 220
 221 static HRESULT WINAPI FolderItemImpl_GetIDsOfNames(FolderItem *iface,
 222         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 223         DISPID *rgDispId)
 224 {
 225     ITypeInfo *ti;
 226     HRESULT hr;
 227
 228     TRACE("(%p,%p,%p,%u,%d,%p)\n", iface, riid, rgszNames, cNames, lcid,
 229             rgDispId);
 230
 231     hr = get_typeinfo(FolderItem_tid, &ti);
 232     if (SUCCEEDED(hr))
 233         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 234     return hr;
 235 }
 236
 237 static HRESULT WINAPI FolderItemImpl_Invoke(FolderItem *iface,
 238         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 239         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 240         UINT *puArgErr)
 241 {
 242     FolderItemImpl *This = impl_from_FolderItem(iface);
 243     ITypeInfo *ti;
 244     HRESULT hr;
 245
 246     TRACE("(%p,%d,%p,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, riid, lcid,
 247             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 248
 249     hr = get_typeinfo(FolderItem_tid, &ti);
 250     if (SUCCEEDED(hr))
 251         hr = ITypeInfo_Invoke(ti, This, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 252     return hr;
 253 }
 254
 255 static HRESULT WINAPI FolderItemImpl_get_Application(FolderItem *iface,
 256         IDispatch **ppid)
 257 {
 258     FIXME("(%p,%p)\n", iface, ppid);
 259
 260     *ppid = NULL;
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI FolderItemImpl_get_Parent(FolderItem *iface,
 265         IDispatch **ppid)
 266 {
 267     FIXME("(%p,%p)\n", iface, ppid);
 268
 269     *ppid = NULL;
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI FolderItemImpl_get_Name(FolderItem *iface, BSTR *pbs)
 274 {
 275     FIXME("(%p,%p)\n", iface, pbs);
 276
 277     *pbs = NULL;
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI FolderItemImpl_put_Name(FolderItem *iface, BSTR bs)
 282 {
 283     FIXME("(%p,%s)\n", iface, debugstr_w(bs));
 284
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI FolderItemImpl_get_Path(FolderItem *iface, BSTR *pbs)
 289 {
 290     FolderItemImpl *This = impl_from_FolderItem(iface);
 291     HRESULT ret = S_OK;
 292     WCHAR *pathW;
 293     int len;
 294
 295     TRACE("(%p,%p)\n", iface, pbs);
 296
 297     *pbs = NULL;
 298     if (V_VT(&This->dir) == VT_I4)
 299     {
 300         pathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
 301         if (!pathW) return E_OUTOFMEMORY;
 302         ret = SHGetFolderPathW(NULL, V_I4(&This->dir), NULL, SHGFP_TYPE_CURRENT,
 303                 pathW);
 304         if (ret == S_OK)
 305             *pbs = SysAllocString(pathW);
 306         else if (ret == E_INVALIDARG)
 307         {
 308             FIXME("not implemented for %#x\n", V_I4(&This->dir));
 309             ret = E_NOTIMPL;
 310         }
 311         HeapFree(GetProcessHeap(), 0, pathW);
 312     }
 313     else /* VT_BSTR */
 314     {
 315         pathW = V_BSTR(&This->dir);
 316         len = lstrlenW(pathW);
 317         *pbs = SysAllocStringLen(pathW, pathW[len - 1] == '\\' ? len - 1 : len);
 318     }
 319     if (ret == S_OK && !*pbs)
 320         ret = E_OUTOFMEMORY;
 321     return ret;
 322 }
 323
 324 static HRESULT WINAPI FolderItemImpl_get_GetLink(FolderItem *iface,
 325         IDispatch **ppid)
 326 {
 327     FIXME("(%p,%p)\n", iface, ppid);
 328
 329     *ppid = NULL;
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI FolderItemImpl_get_GetFolder(FolderItem *iface,
 334         IDispatch **ppid)
 335 {
 336     FIXME("(%p,%p)\n", iface, ppid);
 337
 338     *ppid = NULL;
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI FolderItemImpl_get_IsLink(FolderItem *iface,
 343         VARIANT_BOOL *pb)
 344 {
 345     FIXME("(%p,%p)\n", iface, pb);
 346
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT WINAPI FolderItemImpl_get_IsFolder(FolderItem *iface,
 351         VARIANT_BOOL *pb)
 352 {
 353     FIXME("(%p,%p)\n", iface, pb);
 354
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI FolderItemImpl_get_IsFileSystem(FolderItem *iface,
 359         VARIANT_BOOL *pb)
 360 {
 361     FIXME("(%p,%p)\n", iface, pb);
 362
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI FolderItemImpl_get_IsBrowsable(FolderItem *iface,
 367         VARIANT_BOOL *pb)
 368 {
 369     FIXME("(%p,%p)\n", iface, pb);
 370
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI FolderItemImpl_get_ModifyDate(FolderItem *iface,
 375         DATE *pdt)
 376 {
 377     FIXME("(%p,%p)\n", iface, pdt);
 378
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI FolderItemImpl_put_ModifyDate(FolderItem *iface, DATE dt)
 383 {
 384     FIXME("(%p,%f)\n", iface, dt);
 385
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI FolderItemImpl_get_Size(FolderItem *iface, LONG *pul)
 390 {
 391     FIXME("(%p,%p)\n", iface, pul);
 392
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI FolderItemImpl_get_Type(FolderItem *iface, BSTR *pbs)
 397 {
 398     FIXME("(%p,%p)\n", iface, pbs);
 399
 400     *pbs = NULL;
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI FolderItemImpl_Verbs(FolderItem *iface,
 405         FolderItemVerbs **ppfic)
 406 {
 407     FIXME("(%p,%p)\n", iface, ppfic);
 408
 409     *ppfic = NULL;
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI FolderItemImpl_InvokeVerb(FolderItem *iface,
 414         VARIANT vVerb)
 415 {
 416     FIXME("(%p)\n", iface);
 417
 418     return E_NOTIMPL;
 419 }
 420
 421 static const FolderItemVtbl FolderItemImpl_Vtbl = {
 422     FolderItemImpl_QueryInterface,
 423     FolderItemImpl_AddRef,
 424     FolderItemImpl_Release,
 425     FolderItemImpl_GetTypeInfoCount,
 426     FolderItemImpl_GetTypeInfo,
 427     FolderItemImpl_GetIDsOfNames,
 428     FolderItemImpl_Invoke,
 429     FolderItemImpl_get_Application,
 430     FolderItemImpl_get_Parent,
 431     FolderItemImpl_get_Name,
 432     FolderItemImpl_put_Name,
 433     FolderItemImpl_get_Path,
 434     FolderItemImpl_get_GetLink,
 435     FolderItemImpl_get_GetFolder,
 436     FolderItemImpl_get_IsLink,
 437     FolderItemImpl_get_IsFolder,
 438     FolderItemImpl_get_IsFileSystem,
 439     FolderItemImpl_get_IsBrowsable,
 440     FolderItemImpl_get_ModifyDate,
 441     FolderItemImpl_put_ModifyDate,
 442     FolderItemImpl_get_Size,
 443     FolderItemImpl_get_Type,
 444     FolderItemImpl_Verbs,
 445     FolderItemImpl_InvokeVerb
 446 };
 447
 448 static HRESULT FolderItem_Constructor(VARIANT *dir, FolderItem **ppfi)
 449 {
 450     FolderItemImpl *This;
 451     HRESULT ret;
 452
 453     *ppfi = NULL;
 454
 455     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FolderItemImpl));
 456     if (!This) return E_OUTOFMEMORY;
 457     This->FolderItem_iface.lpVtbl = &FolderItemImpl_Vtbl;
 458     This->ref = 1;
 459
 460     VariantInit(&This->dir);
 461     ret = VariantCopy(&This->dir, dir);
 462     if (FAILED(ret))
 463     {
 464         HeapFree(GetProcessHeap(), 0, This);
 465         return E_OUTOFMEMORY;
 466     }
 467
 468     *ppfi = &This->FolderItem_iface;
 469     return ret;
 470 }
 471
 472 static HRESULT WINAPI FolderImpl_QueryInterface(Folder3 *iface, REFIID riid,
 473         LPVOID *ppv)
 474 {
 475     FolderImpl *This = impl_from_Folder(iface);
 476
 477     TRACE("(%p,%p,%p)\n", iface, riid, ppv);
 478
 479     if (!ppv) return E_INVALIDARG;
 480
 481     if (IsEqualIID(&IID_IUnknown, riid) ||
 482         IsEqualIID(&IID_IDispatch, riid) ||
 483         IsEqualIID(&IID_Folder, riid) ||
 484         IsEqualIID(&IID_Folder2, riid) ||
 485         IsEqualIID(&IID_Folder3, riid))
 486         *ppv = &This->Folder3_iface;
 487     else
 488     {
 489         FIXME("not implemented for %s\n", shdebugstr_guid(riid));
 490         *ppv = NULL;
 491         return E_NOINTERFACE;
 492     }
 493     IUnknown_AddRef((IUnknown*)*ppv);
 494     return S_OK;
 495 }
 496
 497 static ULONG WINAPI FolderImpl_AddRef(Folder3 *iface)
 498 {
 499     FolderImpl *This = impl_from_Folder(iface);
 500     ULONG ref = InterlockedIncrement(&This->ref);
 501
 502     TRACE("(%p), new refcount=%i\n", iface, ref);
 503
 504     return ref;
 505 }
 506
 507 static ULONG WINAPI FolderImpl_Release(Folder3 *iface)
 508 {
 509     FolderImpl *This = impl_from_Folder(iface);
 510     ULONG ref = InterlockedDecrement(&This->ref);
 511
 512     TRACE("(%p), new refcount=%i\n", iface, ref);
 513
 514     if (!ref)
 515     {
 516         VariantClear(&This->dir);
 517         HeapFree(GetProcessHeap(), 0, This);
 518     }
 519     return ref;
 520 }
 521
 522 static HRESULT WINAPI FolderImpl_GetTypeInfoCount(Folder3 *iface, UINT *pctinfo)
 523 {
 524     TRACE("(%p,%p)\n", iface, pctinfo);
 525
 526     *pctinfo = 1;
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI FolderImpl_GetTypeInfo(Folder3 *iface, UINT iTInfo,
 531         LCID lcid, ITypeInfo **ppTInfo)
 532 {
 533     HRESULT hr;
 534
 535     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 536
 537     hr = get_typeinfo(Folder3_tid, ppTInfo);
 538     if (SUCCEEDED(hr))
 539         ITypeInfo_AddRef(*ppTInfo);
 540
 541     return hr;
 542 }
 543
 544 static HRESULT WINAPI FolderImpl_GetIDsOfNames(Folder3 *iface, REFIID riid,
 545         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 546 {
 547     ITypeInfo *ti;
 548     HRESULT hr;
 549
 550     TRACE("(%p,%p,%p,%u,%d,%p)\n", iface, riid, rgszNames, cNames, lcid,
 551             rgDispId);
 552
 553     hr = get_typeinfo(Folder3_tid, &ti);
 554     if (SUCCEEDED(hr))
 555         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 556     return hr;
 557 }
 558
 559 static HRESULT WINAPI FolderImpl_Invoke(Folder3 *iface, DISPID dispIdMember,
 560         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 561         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 562 {
 563     FolderImpl *This = impl_from_Folder(iface);
 564     ITypeInfo *ti;
 565     HRESULT hr;
 566
 567     TRACE("(%p,%d,%p,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, riid, lcid,
 568             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 569
 570     hr = get_typeinfo(Folder3_tid, &ti);
 571     if (SUCCEEDED(hr))
 572         hr = ITypeInfo_Invoke(ti, This, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 573     return hr;
 574 }
 575
 576 static HRESULT WINAPI FolderImpl_get_Title(Folder3 *iface, BSTR *pbs)
 577 {
 578     FolderImpl *This = impl_from_Folder(iface);
 579     WCHAR *p;
 580     int len;
 581
 582     TRACE("(%p,%p)\n", iface, pbs);
 583
 584     *pbs = NULL;
 585
 586     if (V_VT(&This->dir) == VT_I4)
 587     {
 588         FIXME("special folder constants are not supported\n");
 589         return E_NOTIMPL;
 590     }
 591     p = PathFindFileNameW(V_BSTR(&This->dir));
 592     len = lstrlenW(p);
 593     *pbs = SysAllocStringLen(p, p[len - 1] == '\\' ? len - 1 : len);
 594     return *pbs ? S_OK : E_OUTOFMEMORY;
 595 }
 596
 597 static HRESULT WINAPI FolderImpl_get_Application(Folder3 *iface,
 598         IDispatch **ppid)
 599 {
 600     FIXME("(%p,%p)\n", iface, ppid);
 601
 602     *ppid = NULL;
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI FolderImpl_get_Parent(Folder3 *iface, IDispatch **ppid)
 607 {
 608     FIXME("(%p,%p)\n", iface, ppid);
 609
 610     *ppid = NULL;
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI FolderImpl_get_ParentFolder(Folder3 *iface, Folder **ppsf)
 615 {
 616     FIXME("(%p,%p)\n", iface, ppsf);
 617
 618     *ppsf = NULL;
 619     return E_NOTIMPL;
 620 }
 621
 622 static HRESULT WINAPI FolderImpl_Items(Folder3 *iface, FolderItems **ppid)
 623 {
 624     FIXME("(%p,%p)\n", iface, ppid);
 625
 626     *ppid = NULL;
 627     return E_NOTIMPL;
 628 }
 629
 630 static HRESULT WINAPI FolderImpl_ParseName(Folder3 *iface, BSTR bName,
 631         FolderItem **ppid)
 632 {
 633     FIXME("(%p,%s,%p)\n", iface, debugstr_w(bName), ppid);
 634
 635     *ppid = NULL;
 636     return E_NOTIMPL;
 637 }
 638
 639 static HRESULT WINAPI FolderImpl_NewFolder(Folder3 *iface, BSTR bName,
 640         VARIANT vOptions)
 641 {
 642     FIXME("(%p,%s)\n", iface, debugstr_w(bName));
 643
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI FolderImpl_MoveHere(Folder3 *iface, VARIANT vItem,
 648         VARIANT vOptions)
 649 {
 650     FIXME("(%p)\n", iface);
 651
 652     return E_NOTIMPL;
 653 }
 654
 655 static HRESULT WINAPI FolderImpl_CopyHere(Folder3 *iface, VARIANT vItem,
 656         VARIANT vOptions)
 657 {
 658     FIXME("(%p)\n", iface);
 659
 660     return E_NOTIMPL;
 661 }
 662
 663 static HRESULT WINAPI FolderImpl_GetDetailsOf(Folder3 *iface, VARIANT vItem,
 664         int iColumn, BSTR *pbs)
 665 {
 666     FIXME("(%p,%d,%p)\n", iface, iColumn, pbs);
 667
 668     *pbs = NULL;
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI FolderImpl_get_Self(Folder3 *iface, FolderItem **ppfi)
 673 {
 674     FolderImpl *This = impl_from_Folder(iface);
 675
 676     TRACE("(%p,%p)\n", iface, ppfi);
 677
 678     return FolderItem_Constructor(&This->dir, ppfi);
 679 }
 680
 681 static HRESULT WINAPI FolderImpl_get_OfflineStatus(Folder3 *iface, LONG *pul)
 682 {
 683     FIXME("(%p,%p)\n", iface, pul);
 684
 685     return E_NOTIMPL;
 686 }
 687
 688 static HRESULT WINAPI FolderImpl_Synchronize(Folder3 *iface)
 689 {
 690     FIXME("(%p)\n", iface);
 691
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI FolderImpl_get_HaveToShowWebViewBarricade(Folder3 *iface,
 696         VARIANT_BOOL *pbHaveToShowWebViewBarricade)
 697 {
 698     FIXME("(%p,%p)\n", iface, pbHaveToShowWebViewBarricade);
 699
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI FolderImpl_DismissedWebViewBarricade(Folder3 *iface)
 704 {
 705     FIXME("(%p)\n", iface);
 706
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI FolderImpl_get_ShowWebViewBarricade(Folder3 *iface,
 711         VARIANT_BOOL *pbShowWebViewBarricade)
 712 {
 713     FIXME("(%p,%p)\n", iface, pbShowWebViewBarricade);
 714
 715     return E_NOTIMPL;
 716 }
 717
 718 static HRESULT WINAPI FolderImpl_put_ShowWebViewBarricade(Folder3 *iface,
 719         VARIANT_BOOL bShowWebViewBarricade)
 720 {
 721     FIXME("(%p,%d)\n", iface, bShowWebViewBarricade);
 722
 723     return E_NOTIMPL;
 724 }
 725
 726 static const Folder3Vtbl FolderImpl_Vtbl = {
 727     FolderImpl_QueryInterface,
 728     FolderImpl_AddRef,
 729     FolderImpl_Release,
 730     FolderImpl_GetTypeInfoCount,
 731     FolderImpl_GetTypeInfo,
 732     FolderImpl_GetIDsOfNames,
 733     FolderImpl_Invoke,
 734     FolderImpl_get_Title,
 735     FolderImpl_get_Application,
 736     FolderImpl_get_Parent,
 737     FolderImpl_get_ParentFolder,
 738     FolderImpl_Items,
 739     FolderImpl_ParseName,
 740     FolderImpl_NewFolder,
 741     FolderImpl_MoveHere,
 742     FolderImpl_CopyHere,
 743     FolderImpl_GetDetailsOf,
 744     FolderImpl_get_Self,
 745     FolderImpl_get_OfflineStatus,
 746     FolderImpl_Synchronize,
 747     FolderImpl_get_HaveToShowWebViewBarricade,
 748     FolderImpl_DismissedWebViewBarricade,
 749     FolderImpl_get_ShowWebViewBarricade,
 750     FolderImpl_put_ShowWebViewBarricade
 751 };
 752
 753 static HRESULT Folder_Constructor(VARIANT *dir, Folder **ppsdf)
 754 {
 755     FolderImpl *This;
 756     HRESULT ret;
 757
 758     *ppsdf = NULL;
 759
 760     switch (V_VT(dir))
 761     {
 762         case VT_I4:
 763             /* FIXME: add some checks */
 764             break;
 765         case VT_BSTR:
 766             if (PathIsDirectoryW(V_BSTR(dir)) &&
 767                 !PathIsRelativeW(V_BSTR(dir)) &&
 768                 PathFileExistsW(V_BSTR(dir)))
 769                 break;
 770         default:
 771             return S_FALSE;
 772     }
 773
 774     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FolderImpl));
 775     if (!This) return E_OUTOFMEMORY;
 776     This->Folder3_iface.lpVtbl = &FolderImpl_Vtbl;
 777     This->ref = 1;
 778
 779     VariantInit(&This->dir);
 780     ret = VariantCopy(&This->dir, dir);
 781     if (FAILED(ret))
 782     {
 783         HeapFree(GetProcessHeap(), 0, This);
 784         return E_OUTOFMEMORY;
 785     }
 786
 787     *ppsdf = (Folder*)This;
 788     return ret;
 789 }
 790
 791 static HRESULT WINAPI ShellDispatch_QueryInterface(IShellDispatch5 *iface,
 792         REFIID riid, LPVOID *ppv)
 793 {
 794     ShellDispatch *This = impl_from_IShellDispatch5(iface);
 795
 796     TRACE("(%p,%p,%p)\n", iface, riid, ppv);
 797
 798     if (!ppv) return E_INVALIDARG;
 799
 800     if (IsEqualIID(&IID_IUnknown, riid) ||
 801         IsEqualIID(&IID_IDispatch, riid) ||
 802         IsEqualIID(&IID_IShellDispatch, riid) ||
 803         IsEqualIID(&IID_IShellDispatch2, riid) ||
 804         IsEqualIID(&IID_IShellDispatch3, riid) ||
 805         IsEqualIID(&IID_IShellDispatch4, riid) ||
 806         IsEqualIID(&IID_IShellDispatch5, riid))
 807         *ppv = &This->IShellDispatch5_iface;
 808     else
 809     {
 810         FIXME("not implemented for %s\n", shdebugstr_guid(riid));
 811         *ppv = NULL;
 812         return E_NOINTERFACE;
 813     }
 814
 815     IShellDispatch5_AddRef(iface);
 816     return S_OK;
 817 }
 818
 819 static ULONG WINAPI ShellDispatch_AddRef(IShellDispatch5 *iface)
 820 {
 821     ShellDispatch *This = impl_from_IShellDispatch5(iface);
 822     ULONG ref = InterlockedIncrement(&This->ref);
 823
 824     TRACE("(%p), new refcount=%i\n", iface, ref);
 825
 826     return ref;
 827 }
 828
 829 static ULONG WINAPI ShellDispatch_Release(IShellDispatch5 *iface)
 830 {
 831     ShellDispatch *This = impl_from_IShellDispatch5(iface);
 832     ULONG ref = InterlockedDecrement(&This->ref);
 833
 834     TRACE("(%p), new refcount=%i\n", iface, ref);
 835
 836     if (!ref)
 837         HeapFree(GetProcessHeap(), 0, This);
 838
 839     return ref;
 840 }
 841
 842 static HRESULT WINAPI ShellDispatch_GetTypeInfoCount(IShellDispatch5 *iface,
 843         UINT *pctinfo)
 844 {
 845     TRACE("(%p,%p)\n", iface, pctinfo);
 846
 847     *pctinfo = 1;
 848     return S_OK;
 849 }
 850
 851 static HRESULT WINAPI ShellDispatch_GetTypeInfo(IShellDispatch5 *iface,
 852         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 853 {
 854     HRESULT hr;
 855
 856     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 857
 858     hr = get_typeinfo(IShellDispatch5_tid, ppTInfo);
 859     if (SUCCEEDED(hr))
 860         ITypeInfo_AddRef(*ppTInfo);
 861     return hr;
 862 }
 863
 864 static HRESULT WINAPI ShellDispatch_GetIDsOfNames(IShellDispatch5 *iface,
 865         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 866 {
 867     ITypeInfo *ti;
 868     HRESULT hr;
 869
 870     TRACE("(%p,%p,%p,%u,%d,%p)\n", iface, riid, rgszNames, cNames, lcid,
 871             rgDispId);
 872
 873     hr = get_typeinfo(IShellDispatch5_tid, &ti);
 874     if (SUCCEEDED(hr))
 875         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 876     return hr;
 877 }
 878
 879 static HRESULT WINAPI ShellDispatch_Invoke(IShellDispatch5 *iface,
 880         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 881         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 882         UINT *puArgErr)
 883 {
 884     ShellDispatch *This = impl_from_IShellDispatch5(iface);
 885     ITypeInfo *ti;
 886     HRESULT hr;
 887
 888     TRACE("(%p,%d,%p,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, riid, lcid,
 889             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 890
 891     hr = get_typeinfo(IShellDispatch5_tid, &ti);
 892     if (SUCCEEDED(hr))
 893         hr = ITypeInfo_Invoke(ti, This, dispIdMember, wFlags, pDispParams,
 894             pVarResult, pExcepInfo, puArgErr);
 895     return hr;
 896 }
 897
 898 static HRESULT WINAPI ShellDispatch_get_Application(IShellDispatch5 *iface,
 899         IDispatch **ppid)
 900 {
 901     FIXME("(%p,%p)\n", iface, ppid);
 902
 903     *ppid = NULL;
 904     return E_NOTIMPL;
 905 }
 906
 907 static HRESULT WINAPI ShellDispatch_get_Parent(IShellDispatch5 *iface,
 908         IDispatch **ppid)
 909 {
 910     FIXME("(%p,%p)\n", iface, ppid);
 911
 912     *ppid = NULL;
 913     return E_NOTIMPL;
 914 }
 915
 916 static HRESULT WINAPI ShellDispatch_NameSpace(IShellDispatch5 *iface,
 917         VARIANT vDir, Folder **ppsdf)
 918 {
 919     TRACE("(%p,%p)\n", iface, ppsdf);
 920
 921     return Folder_Constructor(&vDir, ppsdf);
 922 }
 923
 924 static HRESULT WINAPI ShellDispatch_BrowseForFolder(IShellDispatch5 *iface,
 925         LONG Hwnd, BSTR Title, LONG Options, VARIANT RootFolder, Folder **ppsdf)
 926 {
 927     FIXME("(%p,%x,%s,%x,%p)\n", iface, Hwnd, debugstr_w(Title), Options, ppsdf);
 928
 929     *ppsdf = NULL;
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI ShellDispatch_Windows(IShellDispatch5 *iface,
 934         IDispatch **ppid)
 935 {
 936     FIXME("(%p,%p)\n", iface, ppid);
 937
 938     *ppid = NULL;
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI ShellDispatch_Open(IShellDispatch5 *iface, VARIANT vDir)
 943 {
 944     FIXME("(%p)\n", iface);
 945
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI ShellDispatch_Explore(IShellDispatch5 *iface, VARIANT vDir)
 950 {
 951     FIXME("(%p)\n", iface);
 952
 953     return E_NOTIMPL;
 954 }
 955
 956 static HRESULT WINAPI ShellDispatch_MinimizeAll(IShellDispatch5 *iface)
 957 {
 958     FIXME("(%p)\n", iface);
 959
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI ShellDispatch_UndoMinimizeALL(IShellDispatch5 *iface)
 964 {
 965     FIXME("(%p)\n", iface);
 966
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI ShellDispatch_FileRun(IShellDispatch5 *iface)
 971 {
 972     FIXME("(%p)\n", iface);
 973
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI ShellDispatch_CascadeWindows(IShellDispatch5 *iface)
 978 {
 979     FIXME("(%p)\n", iface);
 980
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI ShellDispatch_TileVertically(IShellDispatch5 *iface)
 985 {
 986     FIXME("(%p)\n", iface);
 987
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI ShellDispatch_TileHorizontally(IShellDispatch5 *iface)
 992 {
 993     FIXME("(%p)\n", iface);
 994
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI ShellDispatch_ShutdownWindows(IShellDispatch5 *iface)
 999 {
1000     FIXME("(%p)\n", iface);
1001
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI ShellDispatch_Suspend(IShellDispatch5 *iface)
1006 {
1007     FIXME("(%p)\n", iface);
1008
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI ShellDispatch_EjectPC(IShellDispatch5 *iface)
1013 {
1014     FIXME("(%p)\n", iface);
1015
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI ShellDispatch_SetTime(IShellDispatch5 *iface)
1020 {
1021     FIXME("(%p)\n", iface);
1022
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI ShellDispatch_TrayProperties(IShellDispatch5 *iface)
1027 {
1028     FIXME("(%p)\n", iface);
1029
1030     return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI ShellDispatch_Help(IShellDispatch5 *iface)
1034 {
1035     FIXME("(%p)\n", iface);
1036
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI ShellDispatch_FindFiles(IShellDispatch5 *iface)
1041 {
1042     FIXME("(%p)\n", iface);
1043
1044     return E_NOTIMPL;
1045 }
1046
1047 static HRESULT WINAPI ShellDispatch_FindComputer(IShellDispatch5 *iface)
1048 {
1049     FIXME("(%p)\n", iface);
1050
1051     return E_NOTIMPL;
1052 }
1053
1054 static HRESULT WINAPI ShellDispatch_RefreshMenu(IShellDispatch5 *iface)
1055 {
1056     FIXME("(%p)\n", iface);
1057
1058     return E_NOTIMPL;
1059 }
1060
1061 static HRESULT WINAPI ShellDispatch_ControlPanelItem(IShellDispatch5 *iface,
1062         BSTR szDir)
1063 {
1064     FIXME("(%p,%s)\n", iface, debugstr_w(szDir));
1065
1066     return E_NOTIMPL;
1067 }
1068
1069 static HRESULT WINAPI ShellDispatch_IsRestricted(IShellDispatch5 *iface, BSTR group, BSTR restriction, LONG *value)
1070 {
1071     FIXME("(%s, %s, %p): stub\n", debugstr_w(group), debugstr_w(restriction), value);
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI ShellDispatch_ShellExecute(IShellDispatch5 *iface, BSTR file, VARIANT args, VARIANT dir,
1076         VARIANT op, VARIANT show)
1077 {
1078     FIXME("(%s): stub\n", debugstr_w(file));
1079     return E_NOTIMPL;
1080 }
1081
1082 static HRESULT WINAPI ShellDispatch_FindPrinter(IShellDispatch5 *iface, BSTR name, BSTR location, BSTR model)
1083 {
1084     FIXME("(%s, %s, %s): stub\n", debugstr_w(name), debugstr_w(location), debugstr_w(model));
1085     return E_NOTIMPL;
1086 }
1087
1088 static HRESULT WINAPI ShellDispatch_GetSystemInformation(IShellDispatch5 *iface, BSTR name, VARIANT *ret)
1089 {
1090     FIXME("(%s, %p): stub\n", debugstr_w(name), ret);
1091     return E_NOTIMPL;
1092 }
1093
1094 static HRESULT WINAPI ShellDispatch_ServiceStart(IShellDispatch5 *iface, BSTR service, VARIANT persistent, VARIANT *ret)
1095 {
1096     FIXME("(%s, %p): stub\n", debugstr_w(service), ret);
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI ShellDispatch_ServiceStop(IShellDispatch5 *iface, BSTR service, VARIANT persistent, VARIANT *ret)
1101 {
1102     FIXME("(%s, %p): stub\n", debugstr_w(service), ret);
1103     return E_NOTIMPL;
1104 }
1105
1106 static HRESULT WINAPI ShellDispatch_IsServiceRunning(IShellDispatch5 *iface, BSTR name, VARIANT *running)
1107 {
1108     SERVICE_STATUS_PROCESS status;
1109     SC_HANDLE scm, service;
1110     DWORD dummy;
1111
1112     TRACE("(%s, %p)\n", debugstr_w(name), running);
1113
1114     V_VT(running) = VT_BOOL;
1115     V_BOOL(running) = VARIANT_FALSE;
1116
1117     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
1118     if (!scm)
1119     {
1120         ERR("failed to connect to service manager\n");
1121         return S_OK;
1122     }
1123
1124     service = OpenServiceW(scm, name, SERVICE_QUERY_STATUS);
1125     if (!service)
1126     {
1127         ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
1128         CloseServiceHandle(scm);
1129         return S_OK;
1130     }
1131
1132     if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status,
1133              sizeof(SERVICE_STATUS_PROCESS), &dummy))
1134     {
1135         TRACE("failed to query service status (%u)\n", GetLastError());
1136         CloseServiceHandle(service);
1137         CloseServiceHandle(scm);
1138         return S_OK;
1139     }
1140
1141     if (status.dwCurrentState == SERVICE_RUNNING)
1142        V_BOOL(running) = VARIANT_TRUE;
1143
1144     CloseServiceHandle(service);
1145     CloseServiceHandle(scm);
1146
1147     return S_OK;
1148 }
1149
1150 static HRESULT WINAPI ShellDispatch_CanStartStopService(IShellDispatch5 *iface, BSTR service, VARIANT *ret)
1151 {
1152     FIXME("(%s, %p): stub\n", debugstr_w(service), ret);
1153     return E_NOTIMPL;
1154 }
1155
1156 static HRESULT WINAPI ShellDispatch_ShowBrowserBar(IShellDispatch5 *iface, BSTR clsid, VARIANT show, VARIANT *ret)
1157 {
1158     FIXME("(%s, %p): stub\n", debugstr_w(clsid), ret);
1159     return E_NOTIMPL;
1160 }
1161
1162 static HRESULT WINAPI ShellDispatch_AddToRecent(IShellDispatch5 *iface, VARIANT file, BSTR category)
1163 {
1164     FIXME("(%s): stub\n", debugstr_w(category));
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI ShellDispatch_WindowsSecurity(IShellDispatch5 *iface)
1169 {
1170     FIXME("stub\n");
1171     return E_NOTIMPL;
1172 }
1173
1174 static HRESULT WINAPI ShellDispatch_ToggleDesktop(IShellDispatch5 *iface)
1175 {
1176     FIXME("stub\n");
1177     return E_NOTIMPL;
1178 }
1179
1180 static HRESULT WINAPI ShellDispatch_ExplorerPolicy(IShellDispatch5 *iface, BSTR policy, VARIANT *value)
1181 {
1182     FIXME("(%s, %p): stub\n", debugstr_w(policy), value);
1183     return E_NOTIMPL;
1184 }
1185
1186 static HRESULT WINAPI ShellDispatch_GetSetting(IShellDispatch5 *iface, LONG setting, VARIANT_BOOL *result)
1187 {
1188     FIXME("(%d %p): stub\n", setting, result);
1189     return E_NOTIMPL;
1190 }
1191
1192 static HRESULT WINAPI ShellDispatch_WindowSwitcher(IShellDispatch5 *iface)
1193 {
1194     FIXME("stub\n");
1195     return E_NOTIMPL;
1196 }
1197
1198 static const IShellDispatch5Vtbl ShellDispatch5Vtbl = {
1199     ShellDispatch_QueryInterface,
1200     ShellDispatch_AddRef,
1201     ShellDispatch_Release,
1202     ShellDispatch_GetTypeInfoCount,
1203     ShellDispatch_GetTypeInfo,
1204     ShellDispatch_GetIDsOfNames,
1205     ShellDispatch_Invoke,
1206     ShellDispatch_get_Application,
1207     ShellDispatch_get_Parent,
1208     ShellDispatch_NameSpace,
1209     ShellDispatch_BrowseForFolder,
1210     ShellDispatch_Windows,
1211     ShellDispatch_Open,
1212     ShellDispatch_Explore,
1213     ShellDispatch_MinimizeAll,
1214     ShellDispatch_UndoMinimizeALL,
1215     ShellDispatch_FileRun,
1216     ShellDispatch_CascadeWindows,
1217     ShellDispatch_TileVertically,
1218     ShellDispatch_TileHorizontally,
1219     ShellDispatch_ShutdownWindows,
1220     ShellDispatch_Suspend,
1221     ShellDispatch_EjectPC,
1222     ShellDispatch_SetTime,
1223     ShellDispatch_TrayProperties,
1224     ShellDispatch_Help,
1225     ShellDispatch_FindFiles,
1226     ShellDispatch_FindComputer,
1227     ShellDispatch_RefreshMenu,
1228     ShellDispatch_ControlPanelItem,
1229     ShellDispatch_IsRestricted,
1230     ShellDispatch_ShellExecute,
1231     ShellDispatch_FindPrinter,
1232     ShellDispatch_GetSystemInformation,
1233     ShellDispatch_ServiceStart,
1234     ShellDispatch_ServiceStop,
1235     ShellDispatch_IsServiceRunning,
1236     ShellDispatch_CanStartStopService,
1237     ShellDispatch_ShowBrowserBar,
1238     ShellDispatch_AddToRecent,
1239     ShellDispatch_WindowsSecurity,
1240     ShellDispatch_ToggleDesktop,
1241     ShellDispatch_ExplorerPolicy,
1242     ShellDispatch_GetSetting,
1243     ShellDispatch_WindowSwitcher
1244 };
1245
1246 HRESULT WINAPI IShellDispatch_Constructor(IUnknown *outer, REFIID riid, void **ppv)
1247 {
1248     ShellDispatch *This;
1249     HRESULT ret;
1250
1251     TRACE("(%p, %s)\n", outer, debugstr_guid(riid));
1252
1253     *ppv = NULL;
1254
1255     if (outer) return CLASS_E_NOAGGREGATION;
1256
1257     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ShellDispatch));
1258     if (!This) return E_OUTOFMEMORY;
1259     This->IShellDispatch5_iface.lpVtbl = &ShellDispatch5Vtbl;
1260     This->ref = 1;
1261
1262     ret = IShellDispatch5_QueryInterface(&This->IShellDispatch5_iface, riid, ppv);
1263     IShellDispatch5_Release(&This->IShellDispatch5_iface);
1264     return ret;
1265 }