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
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winsvc.h"
  32 #include "shlwapi.h"
  33 #include "shlobj.h"
  34 #include "shldisp.h"
  35 #include "debughlp.h"
  36
  37 #include "shell32_main.h"
  38 #include "pidl.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  43
  44 static ITypeLib *typelib;
  45 static const IID * const tid_ids[] =
  46 {
  47     &IID_NULL,
  48     &IID_IShellDispatch6,
  49     &IID_IShellFolderViewDual3,
  50     &IID_Folder3,
  51     &IID_FolderItem2,
  52     &IID_FolderItems3,
  53     &IID_FolderItemVerb,
  54     &IID_FolderItemVerbs
  55 };
  56 static ITypeInfo *typeinfos[LAST_tid];
  57
  58 typedef struct {
  59     IShellDispatch6 IShellDispatch6_iface;
  60     LONG ref;
  61 } ShellDispatch;
  62
  63 typedef struct {
  64     Folder3 Folder3_iface;
  65     LONG ref;
  66     IDispatch *application;
  67     IShellFolder2 *folder;
  68     PIDLIST_ABSOLUTE pidl;
  69     BSTR path;
  70 } FolderImpl;
  71
  72 typedef struct {
  73     FolderItems3 FolderItems3_iface;
  74     LONG ref;
  75     FolderImpl *folder;
  76     BSTR *item_names;
  77     LONG item_count;
  78 } FolderItemsImpl;
  79
  80 typedef struct {
  81     FolderItem2 FolderItem2_iface;
  82     LONG ref;
  83     FolderImpl *folder;
  84     WCHAR *path; /* if NULL, folder path is used */
  85     DWORD attributes;
  86 } FolderItemImpl;
  87
  88 typedef struct {
  89     FolderItemVerbs FolderItemVerbs_iface;
  90     LONG ref;
  91
  92     IContextMenu *contextmenu;
  93     HMENU hMenu;
  94     LONG count;
  95 } FolderItemVerbsImpl;
  96
  97 typedef struct {
  98     FolderItemVerb FolderItemVerb_iface;
  99     LONG ref;
 100
 101     IContextMenu *contextmenu;
 102     BSTR name;
 103 } FolderItemVerbImpl;
 104
 105 static inline ShellDispatch *impl_from_IShellDispatch6(IShellDispatch6 *iface)
 106 {
 107     return CONTAINING_RECORD(iface, ShellDispatch, IShellDispatch6_iface);
 108 }
 109
 110 static inline FolderImpl *impl_from_Folder(Folder3 *iface)
 111 {
 112     return CONTAINING_RECORD(iface, FolderImpl, Folder3_iface);
 113 }
 114
 115 static inline FolderItemsImpl *impl_from_FolderItems(FolderItems3 *iface)
 116 {
 117     return CONTAINING_RECORD(iface, FolderItemsImpl, FolderItems3_iface);
 118 }
 119
 120 static inline FolderItemImpl *impl_from_FolderItem(FolderItem2 *iface)
 121 {
 122     return CONTAINING_RECORD(iface, FolderItemImpl, FolderItem2_iface);
 123 }
 124
 125 static inline FolderItemVerbsImpl *impl_from_FolderItemVerbs(FolderItemVerbs *iface)
 126 {
 127     return CONTAINING_RECORD(iface, FolderItemVerbsImpl, FolderItemVerbs_iface);
 128 }
 129
 130 static inline FolderItemVerbImpl *impl_from_FolderItemVerb(FolderItemVerb *iface)
 131 {
 132     return CONTAINING_RECORD(iface, FolderItemVerbImpl, FolderItemVerb_iface);
 133 }
 134
 135 static HRESULT load_typelib(void)
 136 {
 137     ITypeLib *tl;
 138     HRESULT hr;
 139
 140     hr = LoadRegTypeLib(&LIBID_Shell32, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 141     if (FAILED(hr)) {
 142         ERR("LoadRegTypeLib failed: %08x\n", hr);
 143         return hr;
 144     }
 145
 146     if (InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
 147         ITypeLib_Release(tl);
 148     return hr;
 149 }
 150
 151 void release_typelib(void)
 152 {
 153     unsigned i;
 154
 155     if (!typelib)
 156         return;
 157
 158     for (i = 0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 159         if (typeinfos[i])
 160             ITypeInfo_Release(typeinfos[i]);
 161
 162     ITypeLib_Release(typelib);
 163 }
 164
 165 HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
 166 {
 167     HRESULT hr;
 168
 169     if (!typelib)
 170         hr = load_typelib();
 171     if (!typelib)
 172         return hr;
 173
 174     if (!typeinfos[tid])
 175     {
 176         ITypeInfo *ti;
 177
 178         hr = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
 179         if (FAILED(hr))
 180         {
 181             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hr);
 182             return hr;
 183         }
 184
 185         if (InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
 186             ITypeInfo_Release(ti);
 187     }
 188
 189     *typeinfo = typeinfos[tid];
 190     return S_OK;
 191 }
 192
 193 /* FolderItemVerb */
 194 static HRESULT WINAPI FolderItemVerbImpl_QueryInterface(FolderItemVerb *iface,
 195     REFIID riid, void **ppv)
 196 {
 197     FolderItemVerbImpl *This = impl_from_FolderItemVerb(iface);
 198
 199     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 200
 201     if (IsEqualIID(&IID_IUnknown, riid) ||
 202         IsEqualIID(&IID_IDispatch, riid) ||
 203         IsEqualIID(&IID_FolderItemVerb, riid))
 204         *ppv = &This->FolderItemVerb_iface;
 205     else
 206     {
 207         WARN("not implemented for %s\n", debugstr_guid(riid));
 208         *ppv = NULL;
 209         return E_NOINTERFACE;
 210     }
 211
 212     IUnknown_AddRef((IUnknown*)*ppv);
 213     return S_OK;
 214 }
 215
 216 static ULONG WINAPI FolderItemVerbImpl_AddRef(FolderItemVerb *iface)
 217 {
 218     FolderItemVerbImpl *This = impl_from_FolderItemVerb(iface);
 219     ULONG ref = InterlockedIncrement(&This->ref);
 220
 221     TRACE("(%p), new refcount=%i\n", iface, ref);
 222
 223     return ref;
 224 }
 225
 226 static ULONG WINAPI FolderItemVerbImpl_Release(FolderItemVerb *iface)
 227 {
 228     FolderItemVerbImpl *This = impl_from_FolderItemVerb(iface);
 229     ULONG ref = InterlockedDecrement(&This->ref);
 230
 231     TRACE("(%p), new refcount=%i\n", iface, ref);
 232
 233     if (!ref)
 234     {
 235         IContextMenu_Release(This->contextmenu);
 236         SysFreeString(This->name);
 237         HeapFree(GetProcessHeap(), 0, This);
 238     }
 239
 240     return ref;
 241 }
 242
 243 static HRESULT WINAPI FolderItemVerbImpl_GetTypeInfoCount(FolderItemVerb *iface, UINT *pctinfo)
 244 {
 245     TRACE("(%p,%p)\n", iface, pctinfo);
 246     *pctinfo = 1;
 247     return S_OK;
 248 }
 249
 250 static HRESULT WINAPI FolderItemVerbImpl_GetTypeInfo(FolderItemVerb *iface, UINT iTInfo,
 251         LCID lcid, ITypeInfo **ppTInfo)
 252 {
 253     HRESULT hr;
 254
 255     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 256
 257     hr = get_typeinfo(FolderItemVerb_tid, ppTInfo);
 258     if (SUCCEEDED(hr))
 259         ITypeInfo_AddRef(*ppTInfo);
 260     return hr;
 261 }
 262
 263 static HRESULT WINAPI FolderItemVerbImpl_GetIDsOfNames(FolderItemVerb *iface,
 264         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 265 {
 266     ITypeInfo *ti;
 267     HRESULT hr;
 268
 269     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), rgszNames, cNames, lcid,
 270             rgDispId);
 271
 272     hr = get_typeinfo(FolderItemVerb_tid, &ti);
 273     if (SUCCEEDED(hr))
 274         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 275     return hr;
 276 }
 277
 278 static HRESULT WINAPI FolderItemVerbImpl_Invoke(FolderItemVerb *iface,
 279         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 280         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 281         UINT *puArgErr)
 282 {
 283     ITypeInfo *ti;
 284     HRESULT hr;
 285
 286     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, shdebugstr_guid(riid), lcid,
 287             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 288
 289     hr = get_typeinfo(FolderItemVerb_tid, &ti);
 290     if (SUCCEEDED(hr))
 291         hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 292     return hr;
 293 }
 294
 295 static HRESULT WINAPI FolderItemVerbImpl_get_Application(FolderItemVerb *iface, IDispatch **disp)
 296 {
 297     TRACE("(%p, %p)\n", iface, disp);
 298
 299     if (disp)
 300         *disp = NULL;
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI FolderItemVerbImpl_get_Parent(FolderItemVerb *iface, IDispatch **disp)
 305 {
 306     TRACE("(%p, %p)\n", iface, disp);
 307
 308     if (disp)
 309         *disp = NULL;
 310     return E_NOTIMPL;
 311 }
 312
 313 static HRESULT WINAPI FolderItemVerbImpl_get_Name(FolderItemVerb *iface, BSTR *name)
 314 {
 315     FolderItemVerbImpl *This = impl_from_FolderItemVerb(iface);
 316
 317     TRACE("(%p, %p)\n", iface, name);
 318
 319     *name = SysAllocString(This->name);
 320     return *name ? S_OK : E_OUTOFMEMORY;
 321 }
 322
 323 static HRESULT WINAPI FolderItemVerbImpl_DoIt(FolderItemVerb *iface)
 324 {
 325     FIXME("(%p)\n", iface);
 326     return E_NOTIMPL;
 327 }
 328
 329 static FolderItemVerbVtbl folderitemverbvtbl = {
 330     FolderItemVerbImpl_QueryInterface,
 331     FolderItemVerbImpl_AddRef,
 332     FolderItemVerbImpl_Release,
 333     FolderItemVerbImpl_GetTypeInfoCount,
 334     FolderItemVerbImpl_GetTypeInfo,
 335     FolderItemVerbImpl_GetIDsOfNames,
 336     FolderItemVerbImpl_Invoke,
 337     FolderItemVerbImpl_get_Application,
 338     FolderItemVerbImpl_get_Parent,
 339     FolderItemVerbImpl_get_Name,
 340     FolderItemVerbImpl_DoIt
 341 };
 342
 343 static HRESULT FolderItemVerb_Constructor(IContextMenu *contextmenu, BSTR name, FolderItemVerb **verb)
 344 {
 345     FolderItemVerbImpl *This;
 346
 347     TRACE("%p, %s\n", contextmenu, debugstr_w(name));
 348
 349     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FolderItemVerbImpl));
 350     if (!This)
 351         return E_OUTOFMEMORY;
 352
 353     This->FolderItemVerb_iface.lpVtbl = &folderitemverbvtbl;
 354     This->ref = 1;
 355     This->contextmenu = contextmenu;
 356     IContextMenu_AddRef(contextmenu);
 357     This->name = name;
 358
 359     *verb = &This->FolderItemVerb_iface;
 360     return S_OK;
 361 }
 362
 363 /* FolderItemVerbs */
 364 static HRESULT WINAPI FolderItemVerbsImpl_QueryInterface(FolderItemVerbs *iface,
 365     REFIID riid, void **ppv)
 366 {
 367     FolderItemVerbsImpl *This = impl_from_FolderItemVerbs(iface);
 368
 369     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 370
 371     if (IsEqualIID(&IID_IUnknown, riid) ||
 372         IsEqualIID(&IID_IDispatch, riid) ||
 373         IsEqualIID(&IID_FolderItemVerbs, riid))
 374         *ppv = &This->FolderItemVerbs_iface;
 375     else
 376     {
 377         WARN("not implemented for %s\n", debugstr_guid(riid));
 378         *ppv = NULL;
 379         return E_NOINTERFACE;
 380     }
 381
 382     IUnknown_AddRef((IUnknown*)*ppv);
 383     return S_OK;
 384 }
 385
 386 static ULONG WINAPI FolderItemVerbsImpl_AddRef(FolderItemVerbs *iface)
 387 {
 388     FolderItemVerbsImpl *This = impl_from_FolderItemVerbs(iface);
 389     ULONG ref = InterlockedIncrement(&This->ref);
 390
 391     TRACE("(%p), new refcount=%i\n", iface, ref);
 392
 393     return ref;
 394 }
 395
 396 static ULONG WINAPI FolderItemVerbsImpl_Release(FolderItemVerbs *iface)
 397 {
 398     FolderItemVerbsImpl *This = impl_from_FolderItemVerbs(iface);
 399     ULONG ref = InterlockedDecrement(&This->ref);
 400
 401     TRACE("(%p), new refcount=%i\n", iface, ref);
 402
 403     if (!ref)
 404     {
 405         IContextMenu_Release(This->contextmenu);
 406         DestroyMenu(This->hMenu);
 407         HeapFree(GetProcessHeap(), 0, This);
 408     }
 409
 410     return ref;
 411 }
 412
 413 static HRESULT WINAPI FolderItemVerbsImpl_GetTypeInfoCount(FolderItemVerbs *iface, UINT *pctinfo)
 414 {
 415     TRACE("(%p,%p)\n", iface, pctinfo);
 416     *pctinfo = 1;
 417     return S_OK;
 418 }
 419
 420 static HRESULT WINAPI FolderItemVerbsImpl_GetTypeInfo(FolderItemVerbs *iface, UINT iTInfo,
 421         LCID lcid, ITypeInfo **ppTInfo)
 422 {
 423     HRESULT hr;
 424
 425     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 426
 427     hr = get_typeinfo(FolderItemVerbs_tid, ppTInfo);
 428     if (SUCCEEDED(hr))
 429         ITypeInfo_AddRef(*ppTInfo);
 430     return hr;
 431 }
 432
 433 static HRESULT WINAPI FolderItemVerbsImpl_GetIDsOfNames(FolderItemVerbs *iface,
 434         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 435 {
 436     ITypeInfo *ti;
 437     HRESULT hr;
 438
 439     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), rgszNames, cNames, lcid,
 440             rgDispId);
 441
 442     hr = get_typeinfo(FolderItemVerbs_tid, &ti);
 443     if (SUCCEEDED(hr))
 444         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 445     return hr;
 446 }
 447
 448 static HRESULT WINAPI FolderItemVerbsImpl_Invoke(FolderItemVerbs *iface,
 449         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 450         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 451         UINT *puArgErr)
 452 {
 453     ITypeInfo *ti;
 454     HRESULT hr;
 455
 456     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, shdebugstr_guid(riid), lcid,
 457             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 458
 459     hr = get_typeinfo(FolderItemVerbs_tid, &ti);
 460     if (SUCCEEDED(hr))
 461         hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 462     return hr;
 463 }
 464
 465 static HRESULT WINAPI FolderItemVerbsImpl_get_Count(FolderItemVerbs *iface, LONG *count)
 466 {
 467     FolderItemVerbsImpl *This = impl_from_FolderItemVerbs(iface);
 468
 469     TRACE("(%p, %p)\n", iface, count);
 470
 471     if (!count)
 472         return E_INVALIDARG;
 473
 474     *count = This->count;
 475     return S_OK;
 476 }
 477
 478 static HRESULT WINAPI FolderItemVerbsImpl_get_Application(FolderItemVerbs *iface, IDispatch **disp)
 479 {
 480     TRACE("(%p, %p)\n", iface, disp);
 481
 482     if (disp)
 483         *disp = NULL;
 484     return E_NOTIMPL;
 485 }
 486
 487 static HRESULT WINAPI FolderItemVerbsImpl_get_Parent(FolderItemVerbs *iface, IDispatch **disp)
 488 {
 489     TRACE("(%p, %p)\n", iface, disp);
 490
 491     if (disp)
 492         *disp = NULL;
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI FolderItemVerbsImpl_Item(FolderItemVerbs *iface, VARIANT index, FolderItemVerb **verb)
 497 {
 498     FolderItemVerbsImpl *This = impl_from_FolderItemVerbs(iface);
 499     MENUITEMINFOW info;
 500     HRESULT hr;
 501     VARIANT v;
 502     BSTR name;
 503
 504     TRACE("(%p, %s, %p)\n", iface, debugstr_variant(&index), verb);
 505
 506     if (!verb)
 507         return E_INVALIDARG;
 508
 509     *verb = NULL;
 510
 511     VariantInit(&v);
 512     VariantCopyInd(&v, &index);
 513
 514     hr = VariantChangeType(&v, &v, 0, VT_I4);
 515     if (FAILED(hr))
 516     {
 517         FIXME("failed to coerce to VT_I4, %s\n", debugstr_variant(&v));
 518         return hr;
 519     }
 520
 521     if (V_I4(&v) > This->count)
 522         return S_OK;
 523
 524     if (V_I4(&v) == This->count)
 525         name = SysAllocStringLen(NULL, 0);
 526     else
 527     {
 528         /* get item name */
 529         memset(&info, 0, sizeof(info));
 530         info.cbSize = sizeof(info);
 531         info.fMask = MIIM_STRING;
 532         if (!GetMenuItemInfoW(This->hMenu, V_I4(&v), TRUE, &info))
 533             return E_FAIL;
 534
 535         name = SysAllocStringLen(NULL, info.cch);
 536         if (name)
 537         {
 538             info.dwTypeData = name;
 539             info.cch++;
 540             GetMenuItemInfoW(This->hMenu, V_I4(&v), TRUE, &info);
 541         }
 542     }
 543
 544     if (!name)
 545         return E_OUTOFMEMORY;
 546
 547     return FolderItemVerb_Constructor(This->contextmenu, name, verb);
 548 }
 549
 550 static HRESULT WINAPI FolderItemVerbsImpl__NewEnum(FolderItemVerbs *iface, IUnknown **ret)
 551 {
 552     FIXME("(%p, %p)\n", iface, ret);
 553     return E_NOTIMPL;
 554 }
 555
 556 static FolderItemVerbsVtbl folderitemverbsvtbl = {
 557     FolderItemVerbsImpl_QueryInterface,
 558     FolderItemVerbsImpl_AddRef,
 559     FolderItemVerbsImpl_Release,
 560     FolderItemVerbsImpl_GetTypeInfoCount,
 561     FolderItemVerbsImpl_GetTypeInfo,
 562     FolderItemVerbsImpl_GetIDsOfNames,
 563     FolderItemVerbsImpl_Invoke,
 564     FolderItemVerbsImpl_get_Count,
 565     FolderItemVerbsImpl_get_Application,
 566     FolderItemVerbsImpl_get_Parent,
 567     FolderItemVerbsImpl_Item,
 568     FolderItemVerbsImpl__NewEnum
 569 };
 570
 571 static HRESULT FolderItemVerbs_Constructor(BSTR path, FolderItemVerbs **verbs)
 572 {
 573     FolderItemVerbsImpl *This;
 574     IShellFolder *folder;
 575     LPCITEMIDLIST child;
 576     LPITEMIDLIST pidl;
 577     HRESULT hr;
 578
 579     *verbs = NULL;
 580
 581     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FolderItemVerbsImpl));
 582     if (!This)
 583         return E_OUTOFMEMORY;
 584
 585     This->FolderItemVerbs_iface.lpVtbl = &folderitemverbsvtbl;
 586     This->ref = 1;
 587
 588     /* build context menu for this path */
 589     hr = SHParseDisplayName(path, NULL, &pidl, 0, NULL);
 590     if (FAILED(hr))
 591         goto failed;
 592
 593     hr = SHBindToParent(pidl, &IID_IShellFolder, (void**)&folder, &child);
 594     CoTaskMemFree(pidl);
 595     if (FAILED(hr))
 596         goto failed;
 597
 598     hr = IShellFolder_GetUIObjectOf(folder, NULL, 1, &child, &IID_IContextMenu, NULL, (void**)&This->contextmenu);
 599     IShellFolder_Release(folder);
 600     if (FAILED(hr))
 601         goto failed;
 602
 603     This->hMenu = CreatePopupMenu();
 604     hr = IContextMenu_QueryContextMenu(This->contextmenu, This->hMenu, 0, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST, CMF_NORMAL);
 605     if (FAILED(hr))
 606     {
 607         FolderItemVerbs_Release(&This->FolderItemVerbs_iface);
 608         return hr;
 609     }
 610
 611     This->count = GetMenuItemCount(This->hMenu);
 612     *verbs = &This->FolderItemVerbs_iface;
 613     return S_OK;
 614
 615 failed:
 616     HeapFree(GetProcessHeap(), 0, This);
 617     return hr;
 618 }
 619
 620 static HRESULT WINAPI FolderItemImpl_QueryInterface(FolderItem2 *iface,
 621         REFIID riid, LPVOID *ppv)
 622 {
 623     FolderItemImpl *This = impl_from_FolderItem(iface);
 624
 625     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 626
 627     if (!ppv) return E_INVALIDARG;
 628
 629     if (IsEqualIID(&IID_IUnknown, riid) ||
 630         IsEqualIID(&IID_IDispatch, riid) ||
 631         IsEqualIID(&IID_FolderItem, riid) ||
 632         IsEqualIID(&IID_FolderItem2, riid))
 633         *ppv = &This->FolderItem2_iface;
 634     else
 635     {
 636         WARN("not implemented for %s\n", debugstr_guid(riid));
 637         *ppv = NULL;
 638         return E_NOINTERFACE;
 639     }
 640     IUnknown_AddRef((IUnknown*)*ppv);
 641     return S_OK;
 642 }
 643
 644 static ULONG WINAPI FolderItemImpl_AddRef(FolderItem2 *iface)
 645 {
 646     FolderItemImpl *This = impl_from_FolderItem(iface);
 647     ULONG ref = InterlockedIncrement(&This->ref);
 648
 649     TRACE("(%p), new refcount=%i\n", iface, ref);
 650
 651     return ref;
 652 }
 653
 654 static ULONG WINAPI FolderItemImpl_Release(FolderItem2 *iface)
 655 {
 656     FolderItemImpl *This = impl_from_FolderItem(iface);
 657     ULONG ref = InterlockedDecrement(&This->ref);
 658
 659     TRACE("(%p), new refcount=%i\n", iface, ref);
 660
 661     if (!ref)
 662     {
 663         Folder3_Release(&This->folder->Folder3_iface);
 664         HeapFree(GetProcessHeap(), 0, This->path);
 665         HeapFree(GetProcessHeap(), 0, This);
 666     }
 667     return ref;
 668 }
 669
 670 static HRESULT WINAPI FolderItemImpl_GetTypeInfoCount(FolderItem2 *iface,
 671         UINT *pctinfo)
 672 {
 673     TRACE("(%p,%p)\n", iface, pctinfo);
 674
 675     *pctinfo = 1;
 676     return S_OK;
 677 }
 678
 679 static HRESULT WINAPI FolderItemImpl_GetTypeInfo(FolderItem2 *iface, UINT iTInfo,
 680         LCID lcid, ITypeInfo **ppTInfo)
 681 {
 682     HRESULT hr;
 683
 684     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
 685
 686     hr = get_typeinfo(FolderItem2_tid, ppTInfo);
 687     if (SUCCEEDED(hr))
 688         ITypeInfo_AddRef(*ppTInfo);
 689     return hr;
 690 }
 691
 692 static HRESULT WINAPI FolderItemImpl_GetIDsOfNames(FolderItem2 *iface,
 693         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 694         DISPID *rgDispId)
 695 {
 696     ITypeInfo *ti;
 697     HRESULT hr;
 698
 699     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), rgszNames, cNames, lcid,
 700             rgDispId);
 701
 702     hr = get_typeinfo(FolderItem2_tid, &ti);
 703     if (SUCCEEDED(hr))
 704         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
 705     return hr;
 706 }
 707
 708 static HRESULT WINAPI FolderItemImpl_Invoke(FolderItem2 *iface,
 709         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 710         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 711         UINT *puArgErr)
 712 {
 713     FolderItemImpl *This = impl_from_FolderItem(iface);
 714     ITypeInfo *ti;
 715     HRESULT hr;
 716
 717     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, shdebugstr_guid(riid), lcid,
 718             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 719
 720     hr = get_typeinfo(FolderItem2_tid, &ti);
 721     if (SUCCEEDED(hr))
 722         hr = ITypeInfo_Invoke(ti, This, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 723     return hr;
 724 }
 725
 726 static HRESULT WINAPI FolderItemImpl_get_Application(FolderItem2 *iface, IDispatch **disp)
 727 {
 728     FolderItemImpl *This = impl_from_FolderItem(iface);
 729
 730     TRACE("(%p,%p)\n", iface, disp);
 731
 732     return Folder3_get_Application(&This->folder->Folder3_iface, disp);
 733 }
 734
 735 static HRESULT WINAPI FolderItemImpl_get_Parent(FolderItem2 *iface, IDispatch **disp)
 736 {
 737     FolderItemImpl *This = impl_from_FolderItem(iface);
 738
 739     TRACE("(%p,%p)\n", iface, disp);
 740
 741     if (disp)
 742     {
 743         *disp = (IDispatch *)&This->folder->Folder3_iface;
 744         IDispatch_AddRef(*disp);
 745     }
 746
 747     return S_OK;
 748 }
 749
 750 static HRESULT WINAPI FolderItemImpl_get_Name(FolderItem2 *iface, BSTR *name)
 751 {
 752     FolderItemImpl *This = impl_from_FolderItem(iface);
 753     LPCITEMIDLIST last_part;
 754     IShellFolder2 *parent;
 755     HRESULT hr = S_OK;
 756     LPITEMIDLIST pidl;
 757     STRRET strret;
 758
 759     TRACE("(%p,%p)\n", iface, name);
 760
 761     *name = NULL;
 762
 763     if (This->path)
 764         hr = SHParseDisplayName(This->path, NULL, &pidl, 0, NULL);
 765     else
 766         pidl = This->folder->pidl;
 767
 768     if (FAILED(hr))
 769         return S_FALSE;
 770
 771     hr = SHBindToParent(pidl, &IID_IShellFolder2, (void **)&parent, &last_part);
 772     if (hr == S_OK)
 773         hr = IShellFolder2_GetDisplayNameOf(parent, last_part, SHGDN_INFOLDER, &strret);
 774
 775     IShellFolder2_Release(parent);
 776
 777     if (hr == S_OK)
 778         hr = StrRetToBSTR(&strret, last_part, name);
 779
 780     if (This->path)
 781         ILFree(pidl);
 782
 783     return hr;
 784 }
 785
 786 static HRESULT WINAPI FolderItemImpl_put_Name(FolderItem2 *iface, BSTR bs)
 787 {
 788     FIXME("(%p,%s)\n", iface, debugstr_w(bs));
 789
 790     return E_NOTIMPL;
 791 }
 792
 793 static HRESULT WINAPI FolderItemImpl_get_Path(FolderItem2 *iface, BSTR *path)
 794 {
 795     FolderItemImpl *This = impl_from_FolderItem(iface);
 796
 797     TRACE("(%p,%p)\n", iface, path);
 798
 799     *path = SysAllocString(This->path ? This->path : This->folder->path);
 800     return *path ? S_OK : E_OUTOFMEMORY;
 801 }
 802
 803 static HRESULT WINAPI FolderItemImpl_get_GetLink(FolderItem2 *iface,
 804         IDispatch **ppid)
 805 {
 806     FIXME("(%p,%p)\n", iface, ppid);
 807
 808     *ppid = NULL;
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT WINAPI FolderItemImpl_get_GetFolder(FolderItem2 *iface,
 813         IDispatch **ppid)
 814 {
 815     FIXME("(%p,%p)\n", iface, ppid);
 816
 817     *ppid = NULL;
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI FolderItemImpl_get_IsLink(FolderItem2 *iface, VARIANT_BOOL *b)
 822 {
 823     FolderItemImpl *This = impl_from_FolderItem(iface);
 824
 825     TRACE("(%p,%p)\n", iface, b);
 826
 827     *b = This->attributes & SFGAO_LINK ? VARIANT_TRUE : VARIANT_FALSE;
 828
 829     return S_OK;
 830 }
 831
 832 static HRESULT WINAPI FolderItemImpl_get_IsFolder(FolderItem2 *iface, VARIANT_BOOL *b)
 833 {
 834     FolderItemImpl *This = impl_from_FolderItem(iface);
 835
 836     TRACE("(%p,%p)\n", iface, b);
 837
 838     *b = This->attributes & SFGAO_FOLDER ? VARIANT_TRUE : VARIANT_FALSE;
 839
 840     return S_OK;
 841 }
 842
 843 static HRESULT WINAPI FolderItemImpl_get_IsFileSystem(FolderItem2 *iface, VARIANT_BOOL *b)
 844 {
 845     FolderItemImpl *This = impl_from_FolderItem(iface);
 846
 847     TRACE("(%p,%p)\n", iface, b);
 848
 849     *b = This->attributes & SFGAO_FILESYSTEM ? VARIANT_TRUE : VARIANT_FALSE;
 850
 851     return S_OK;
 852 }
 853
 854 static HRESULT WINAPI FolderItemImpl_get_IsBrowsable(FolderItem2 *iface, VARIANT_BOOL *b)
 855 {
 856     FolderItemImpl *This = impl_from_FolderItem(iface);
 857
 858     TRACE("(%p,%p)\n", iface, b);
 859
 860     *b = This->attributes & SFGAO_BROWSABLE ? VARIANT_TRUE : VARIANT_FALSE;
 861
 862     return S_OK;
 863 }
 864
 865 static HRESULT WINAPI FolderItemImpl_get_ModifyDate(FolderItem2 *iface,
 866         DATE *pdt)
 867 {
 868     FIXME("(%p,%p)\n", iface, pdt);
 869
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI FolderItemImpl_put_ModifyDate(FolderItem2 *iface, DATE dt)
 874 {
 875     FIXME("(%p,%f)\n", iface, dt);
 876
 877     return E_NOTIMPL;
 878 }
 879
 880 static HRESULT WINAPI FolderItemImpl_get_Size(FolderItem2 *iface, LONG *pul)
 881 {
 882     FIXME("(%p,%p)\n", iface, pul);
 883
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI FolderItemImpl_get_Type(FolderItem2 *iface, BSTR *pbs)
 888 {
 889     FIXME("(%p,%p)\n", iface, pbs);
 890
 891     *pbs = NULL;
 892     return E_NOTIMPL;
 893 }
 894
 895 static HRESULT WINAPI FolderItemImpl_Verbs(FolderItem2 *iface, FolderItemVerbs **verbs)
 896 {
 897     FolderItemImpl *This = impl_from_FolderItem(iface);
 898
 899     TRACE("(%p, %p)\n", iface, verbs);
 900
 901     if (!verbs)
 902         return E_INVALIDARG;
 903
 904     return FolderItemVerbs_Constructor(This->path ? This->path : This->folder->path, verbs);
 905 }
 906
 907 static HRESULT WINAPI FolderItemImpl_InvokeVerb(FolderItem2 *iface,
 908         VARIANT vVerb)
 909 {
 910     FIXME("(%p)\n", iface);
 911
 912     return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI FolderItemImpl_InvokeVerbEx(FolderItem2 *iface, VARIANT verb, VARIANT args)
 916 {
 917     FIXME("(%p): stub\n", iface);
 918
 919     return E_NOTIMPL;
 920 }
 921
 922 static HRESULT WINAPI FolderItemImpl_ExtendedProperty(FolderItem2 *iface, BSTR propname, VARIANT *ret)
 923 {
 924     FIXME("(%p)->(%s %p): stub\n", iface, debugstr_w(propname), ret);
 925
 926     return E_NOTIMPL;
 927 }
 928
 929 static const FolderItem2Vtbl FolderItemImpl_Vtbl = {
 930     FolderItemImpl_QueryInterface,
 931     FolderItemImpl_AddRef,
 932     FolderItemImpl_Release,
 933     FolderItemImpl_GetTypeInfoCount,
 934     FolderItemImpl_GetTypeInfo,
 935     FolderItemImpl_GetIDsOfNames,
 936     FolderItemImpl_Invoke,
 937     FolderItemImpl_get_Application,
 938     FolderItemImpl_get_Parent,
 939     FolderItemImpl_get_Name,
 940     FolderItemImpl_put_Name,
 941     FolderItemImpl_get_Path,
 942     FolderItemImpl_get_GetLink,
 943     FolderItemImpl_get_GetFolder,
 944     FolderItemImpl_get_IsLink,
 945     FolderItemImpl_get_IsFolder,
 946     FolderItemImpl_get_IsFileSystem,
 947     FolderItemImpl_get_IsBrowsable,
 948     FolderItemImpl_get_ModifyDate,
 949     FolderItemImpl_put_ModifyDate,
 950     FolderItemImpl_get_Size,
 951     FolderItemImpl_get_Type,
 952     FolderItemImpl_Verbs,
 953     FolderItemImpl_InvokeVerb,
 954     FolderItemImpl_InvokeVerbEx,
 955     FolderItemImpl_ExtendedProperty
 956 };
 957
 958 static HRESULT FolderItem_Constructor(FolderImpl *folder, const WCHAR *path, FolderItem **item)
 959 {
 960     PIDLIST_ABSOLUTE pidl;
 961     FolderItemImpl *This;
 962
 963     TRACE("%s\n", debugstr_w(path));
 964
 965     *item = NULL;
 966
 967     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 968     if (!This)
 969         return E_OUTOFMEMORY;
 970
 971     This->FolderItem2_iface.lpVtbl = &FolderItemImpl_Vtbl;
 972     This->ref = 1;
 973     if (path)
 974         This->path = strdupW(path);
 975
 976     This->folder = folder;
 977     Folder3_AddRef(&folder->Folder3_iface);
 978
 979     if (SHParseDisplayName(This->path, NULL, &pidl, ~0u, &This->attributes) == S_OK)
 980         ILFree(pidl);
 981
 982     *item = (FolderItem *)&This->FolderItem2_iface;
 983     return S_OK;
 984 }
 985
 986 static HRESULT WINAPI FolderItemsImpl_QueryInterface(FolderItems3 *iface,
 987         REFIID riid, LPVOID *ppv)
 988 {
 989     FolderItemsImpl *This = impl_from_FolderItems(iface);
 990
 991     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 992
 993     if (!ppv) return E_INVALIDARG;
 994
 995     if (IsEqualIID(&IID_IUnknown, riid) ||
 996         IsEqualIID(&IID_IDispatch, riid) ||
 997         IsEqualIID(&IID_FolderItems, riid) ||
 998         IsEqualIID(&IID_FolderItems2, riid) ||
 999         IsEqualIID(&IID_FolderItems3, riid))
1000         *ppv = &This->FolderItems3_iface;
1001     else
1002     {
1003         WARN("not implemented for %s\n", debugstr_guid(riid));
1004         *ppv = NULL;
1005         return E_NOINTERFACE;
1006     }
1007     IUnknown_AddRef((IUnknown*)*ppv);
1008     return S_OK;
1009 }
1010
1011 static ULONG WINAPI FolderItemsImpl_AddRef(FolderItems3 *iface)
1012 {
1013     FolderItemsImpl *This = impl_from_FolderItems(iface);
1014     ULONG ref = InterlockedIncrement(&This->ref);
1015
1016     TRACE("(%p), new refcount=%i\n", iface, ref);
1017
1018     return ref;
1019 }
1020
1021 static ULONG WINAPI FolderItemsImpl_Release(FolderItems3 *iface)
1022 {
1023     FolderItemsImpl *This = impl_from_FolderItems(iface);
1024     ULONG ref = InterlockedDecrement(&This->ref);
1025     LONG i;
1026
1027     TRACE("(%p), new refcount=%i\n", iface, ref);
1028
1029     if (!ref)
1030     {
1031         Folder3_Release(&This->folder->Folder3_iface);
1032         for (i = 0; i < This->item_count; i++)
1033             SysFreeString(This->item_names[i]);
1034         HeapFree(GetProcessHeap(), 0, This->item_names);
1035         HeapFree(GetProcessHeap(), 0, This);
1036     }
1037     return ref;
1038 }
1039
1040 static HRESULT WINAPI FolderItemsImpl_GetTypeInfoCount(FolderItems3 *iface,
1041         UINT *count)
1042 {
1043     TRACE("(%p,%p)\n", iface, count);
1044
1045     *count = 1;
1046     return S_OK;
1047 }
1048
1049 static HRESULT WINAPI FolderItemsImpl_GetTypeInfo(FolderItems3 *iface,
1050         UINT type, LCID lcid, ITypeInfo **ppti)
1051 {
1052     HRESULT hr;
1053
1054     TRACE("(%p,%u,%d,%p)\n", iface, type, lcid, ppti);
1055
1056     hr = get_typeinfo(FolderItems3_tid, ppti);
1057     if (SUCCEEDED(hr))
1058         ITypeInfo_AddRef(*ppti);
1059     return hr;
1060 }
1061
1062 static HRESULT WINAPI FolderItemsImpl_GetIDsOfNames(FolderItems3 *iface,
1063         REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid)
1064 {
1065     ITypeInfo *ti;
1066     HRESULT hr;
1067
1068     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), names, count, lcid, dispid);
1069
1070     hr = get_typeinfo(FolderItems3_tid, &ti);
1071     if (SUCCEEDED(hr))
1072         hr = ITypeInfo_GetIDsOfNames(ti, names, count, dispid);
1073     return hr;
1074 }
1075
1076 static HRESULT WINAPI FolderItemsImpl_Invoke(FolderItems3 *iface,
1077         DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params,
1078         VARIANT *result, EXCEPINFO *ei, UINT *err)
1079 {
1080     FolderItemsImpl *This = impl_from_FolderItems(iface);
1081     ITypeInfo *ti;
1082     HRESULT hr;
1083
1084     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispid, shdebugstr_guid(riid), lcid, flags, params, result, ei, err);
1085
1086     hr = get_typeinfo(FolderItems3_tid, &ti);
1087     if (SUCCEEDED(hr))
1088         hr = ITypeInfo_Invoke(ti, This, dispid, flags, params, result, ei, err);
1089     return hr;
1090 }
1091
1092 static BOOL shellfolder_exists(const WCHAR *path)
1093 {
1094     PIDLIST_ABSOLUTE pidl = NULL;
1095     HRESULT hr;
1096
1097     hr = SHParseDisplayName(path, NULL, &pidl, 0, NULL);
1098     ILFree(pidl);
1099
1100     return SUCCEEDED(hr);
1101 }
1102
1103 static HRESULT WINAPI FolderItemsImpl_get_Count(FolderItems3 *iface, LONG *count)
1104 {
1105     FolderItemsImpl *This = impl_from_FolderItems(iface);
1106
1107     TRACE("(%p,%p)\n", iface, count);
1108
1109     *count = shellfolder_exists(This->folder->path) ? This->item_count : 0;
1110     return S_OK;
1111 }
1112
1113 static HRESULT WINAPI FolderItemsImpl_get_Application(FolderItems3 *iface, IDispatch **disp)
1114 {
1115     FolderItemsImpl *This = impl_from_FolderItems(iface);
1116
1117     TRACE("(%p,%p)\n", iface, disp);
1118
1119     return Folder3_get_Application(&This->folder->Folder3_iface, disp);
1120 }
1121
1122 static HRESULT WINAPI FolderItemsImpl_get_Parent(FolderItems3 *iface, IDispatch **ppid)
1123 {
1124     TRACE("(%p,%p)\n", iface, ppid);
1125
1126     if (ppid)
1127         *ppid = NULL;
1128
1129     return E_NOTIMPL;
1130 }
1131
1132 static HRESULT WINAPI FolderItemsImpl_Item(FolderItems3 *iface, VARIANT index, FolderItem **item)
1133 {
1134     FolderItemsImpl *This = impl_from_FolderItems(iface);
1135     BSTR display_name = NULL;
1136     HRESULT hr;
1137
1138     TRACE("(%p,%s,%p)\n", iface, debugstr_variant(&index), item);
1139
1140     *item = NULL;
1141
1142     if (!shellfolder_exists(This->folder->path))
1143         return S_FALSE;
1144
1145     switch (V_VT(&index))
1146     {
1147         case VT_I2:
1148             VariantChangeType(&index, &index, 0, VT_I4);
1149             /* fall through */
1150
1151         case VT_I4:
1152             if (V_I4(&index) >= This->item_count || V_I4(&index) < 0)
1153                 return S_FALSE;
1154
1155             display_name = SysAllocString(This->item_names[V_I4(&index)]);
1156             break;
1157
1158         case VT_BSTR:
1159         {
1160             LPITEMIDLIST pidl;
1161             STRRET strret;
1162
1163             if (!V_BSTR(&index))
1164                 return S_FALSE;
1165
1166             if (FAILED(hr = IShellFolder2_ParseDisplayName(This->folder->folder, NULL, NULL, V_BSTR(&index),
1167                     NULL, &pidl, NULL)))
1168                 return S_FALSE;
1169
1170             if (IShellFolder2_GetDisplayNameOf(This->folder->folder, pidl, SHGDN_FORPARSING, &strret) == S_OK)
1171                 StrRetToBSTR(&strret, pidl, &display_name);
1172             ILFree(pidl);
1173             break;
1174         }
1175         case VT_ERROR:
1176             break;
1177
1178         default:
1179             FIXME("Index type %d not handled.\n", V_VT(&index));
1180             /* fall through */
1181         case VT_EMPTY:
1182             return E_NOTIMPL;
1183     }
1184
1185     hr = FolderItem_Constructor(This->folder, display_name, item);
1186     SysFreeString(display_name);
1187     return hr;
1188 }
1189
1190 static HRESULT WINAPI FolderItemsImpl__NewEnum(FolderItems3 *iface, IUnknown **ppunk)
1191 {
1192     FIXME("(%p,%p)\n", iface, ppunk);
1193
1194     if (!ppunk)
1195         return E_INVALIDARG;
1196
1197     *ppunk = NULL;
1198     return E_NOTIMPL;
1199 }
1200
1201 static HRESULT WINAPI FolderItemsImpl_InvokeVerbEx(FolderItems3 *iface, VARIANT verb, VARIANT args)
1202 {
1203     FIXME("(%p,%s,%s)\n", iface, debugstr_variant(&verb), debugstr_variant(&args));
1204
1205     return E_NOTIMPL;
1206 }
1207
1208 static HRESULT WINAPI FolderItemsImpl_Filter(FolderItems3 *iface, LONG flags, BSTR spec)
1209 {
1210     FIXME("(%p,%d,%s)\n", iface, flags, wine_dbgstr_w(spec));
1211
1212     return E_NOTIMPL;
1213 }
1214
1215 static HRESULT WINAPI FolderItemsImpl_get_Verbs(FolderItems3 *iface, FolderItemVerbs **ppfic)
1216 {
1217     FIXME("(%p,%p)\n", iface, ppfic);
1218
1219     if (!ppfic)
1220         return E_INVALIDARG;
1221
1222     *ppfic = NULL;
1223     return E_NOTIMPL;
1224 }
1225
1226 static const FolderItems3Vtbl FolderItemsImpl_Vtbl = {
1227     FolderItemsImpl_QueryInterface,
1228     FolderItemsImpl_AddRef,
1229     FolderItemsImpl_Release,
1230     FolderItemsImpl_GetTypeInfoCount,
1231     FolderItemsImpl_GetTypeInfo,
1232     FolderItemsImpl_GetIDsOfNames,
1233     FolderItemsImpl_Invoke,
1234     FolderItemsImpl_get_Count,
1235     FolderItemsImpl_get_Application,
1236     FolderItemsImpl_get_Parent,
1237     FolderItemsImpl_Item,
1238     FolderItemsImpl__NewEnum,
1239     FolderItemsImpl_InvokeVerbEx,
1240     FolderItemsImpl_Filter,
1241     FolderItemsImpl_get_Verbs
1242 };
1243
1244 static void idlist_sort(LPITEMIDLIST *idlist, unsigned int l, unsigned int r, IShellFolder2 *folder)
1245 {
1246     unsigned int m;
1247
1248     if (l == r)
1249         return;
1250
1251     if (r < l)
1252     {
1253         idlist_sort(idlist, r, l, folder);
1254         return;
1255     }
1256
1257     m = (l + r) / 2;
1258     idlist_sort(idlist, l, m, folder);
1259     idlist_sort(idlist, m + 1, r, folder);
1260
1261     /* join the two sides */
1262     while (l <= m && m < r)
1263     {
1264         if ((short)IShellFolder2_CompareIDs(folder, 0, idlist[l], idlist[m + 1]) > 0)
1265         {
1266             LPITEMIDLIST t = idlist[m + 1];
1267             memmove(&idlist[l + 1], &idlist[l], (m - l + 1) * sizeof(idlist[l]));
1268             idlist[l] = t;
1269
1270             m++;
1271         }
1272         l++;
1273     }
1274 }
1275
1276 static HRESULT FolderItems_Constructor(FolderImpl *folder, FolderItems **ret)
1277 {
1278     IEnumIDList *enumidlist;
1279     FolderItemsImpl *This;
1280     LPITEMIDLIST pidl;
1281     unsigned int i;
1282     HRESULT hr;
1283
1284     TRACE("(%s,%p)\n", debugstr_w(folder->path), ret);
1285
1286     *ret = NULL;
1287
1288     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
1289     if (!This)
1290         return E_OUTOFMEMORY;
1291
1292     This->FolderItems3_iface.lpVtbl = &FolderItemsImpl_Vtbl;
1293     This->ref = 1;
1294     This->folder = folder;
1295     Folder3_AddRef(&folder->Folder3_iface);
1296
1297     enumidlist = NULL;
1298     if (FAILED(hr = IShellFolder2_EnumObjects(folder->folder, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS,
1299             &enumidlist)))
1300     {
1301         goto failed;
1302     }
1303
1304     while (IEnumIDList_Next(enumidlist, 1, &pidl, NULL) == S_OK)
1305     {
1306         This->item_count++;
1307         ILFree(pidl);
1308     }
1309
1310     if (This->item_count)
1311     {
1312         LPITEMIDLIST *pidls;
1313         ULONG fetched;
1314
1315         pidls = HeapAlloc(GetProcessHeap(), 0, This->item_count * sizeof(*pidls));
1316         This->item_names = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->item_count * sizeof(*This->item_names));
1317
1318         if (!pidls || !This->item_names)
1319         {
1320             HeapFree(GetProcessHeap(), 0, pidls);
1321             HeapFree(GetProcessHeap(), 0, This->item_names);
1322             hr = E_OUTOFMEMORY;
1323             goto failed;
1324         }
1325
1326         IEnumIDList_Reset(enumidlist);
1327         if (IEnumIDList_Next(enumidlist, This->item_count, pidls, &fetched) == S_OK)
1328             idlist_sort(pidls, 0, This->item_count - 1, folder->folder);
1329
1330         for (i = 0; i < This->item_count; i++)
1331         {
1332             STRRET strret;
1333
1334             if (IShellFolder2_GetDisplayNameOf(folder->folder, pidls[i], SHGDN_FORPARSING, &strret) == S_OK)
1335                 StrRetToBSTR(&strret, pidls[i], &This->item_names[i]);
1336
1337             ILFree(pidls[i]);
1338         }
1339         HeapFree(GetProcessHeap(), 0, pidls);
1340     }
1341     IEnumIDList_Release(enumidlist);
1342
1343     *ret = (FolderItems *)&This->FolderItems3_iface;
1344     return S_OK;
1345
1346 failed:
1347     if (enumidlist)
1348         IEnumIDList_Release(enumidlist);
1349     return hr;
1350 }
1351
1352 static HRESULT WINAPI FolderImpl_QueryInterface(Folder3 *iface, REFIID riid,
1353         LPVOID *ppv)
1354 {
1355     FolderImpl *This = impl_from_Folder(iface);
1356
1357     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
1358
1359     if (!ppv) return E_INVALIDARG;
1360
1361     if (IsEqualIID(&IID_IUnknown, riid) ||
1362         IsEqualIID(&IID_IDispatch, riid) ||
1363         IsEqualIID(&IID_Folder, riid) ||
1364         IsEqualIID(&IID_Folder2, riid) ||
1365         IsEqualIID(&IID_Folder3, riid))
1366         *ppv = &This->Folder3_iface;
1367     else
1368     {
1369         WARN("not implemented for %s\n", debugstr_guid(riid));
1370         *ppv = NULL;
1371         return E_NOINTERFACE;
1372     }
1373     IUnknown_AddRef((IUnknown*)*ppv);
1374     return S_OK;
1375 }
1376
1377 static ULONG WINAPI FolderImpl_AddRef(Folder3 *iface)
1378 {
1379     FolderImpl *This = impl_from_Folder(iface);
1380     ULONG ref = InterlockedIncrement(&This->ref);
1381
1382     TRACE("(%p), new refcount=%i\n", iface, ref);
1383
1384     return ref;
1385 }
1386
1387 static ULONG WINAPI FolderImpl_Release(Folder3 *iface)
1388 {
1389     FolderImpl *This = impl_from_Folder(iface);
1390     ULONG ref = InterlockedDecrement(&This->ref);
1391
1392     TRACE("(%p), new refcount=%i\n", iface, ref);
1393
1394     if (!ref)
1395     {
1396         ILFree(This->pidl);
1397         SysFreeString(This->path);
1398         IShellFolder2_Release(This->folder);
1399         IDispatch_Release(This->application);
1400         HeapFree(GetProcessHeap(), 0, This);
1401     }
1402     return ref;
1403 }
1404
1405 static HRESULT WINAPI FolderImpl_GetTypeInfoCount(Folder3 *iface, UINT *pctinfo)
1406 {
1407     TRACE("(%p,%p)\n", iface, pctinfo);
1408
1409     *pctinfo = 1;
1410     return S_OK;
1411 }
1412
1413 static HRESULT WINAPI FolderImpl_GetTypeInfo(Folder3 *iface, UINT iTInfo,
1414         LCID lcid, ITypeInfo **ppTInfo)
1415 {
1416     HRESULT hr;
1417
1418     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
1419
1420     hr = get_typeinfo(Folder3_tid, ppTInfo);
1421     if (SUCCEEDED(hr))
1422         ITypeInfo_AddRef(*ppTInfo);
1423
1424     return hr;
1425 }
1426
1427 static HRESULT WINAPI FolderImpl_GetIDsOfNames(Folder3 *iface, REFIID riid,
1428         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1429 {
1430     ITypeInfo *ti;
1431     HRESULT hr;
1432
1433     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), rgszNames, cNames, lcid,
1434             rgDispId);
1435
1436     hr = get_typeinfo(Folder3_tid, &ti);
1437     if (SUCCEEDED(hr))
1438         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
1439     return hr;
1440 }
1441
1442 static HRESULT WINAPI FolderImpl_Invoke(Folder3 *iface, DISPID dispIdMember,
1443         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1444         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1445 {
1446     FolderImpl *This = impl_from_Folder(iface);
1447     ITypeInfo *ti;
1448     HRESULT hr;
1449
1450     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, shdebugstr_guid(riid), lcid,
1451             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1452
1453     hr = get_typeinfo(Folder3_tid, &ti);
1454     if (SUCCEEDED(hr))
1455         hr = ITypeInfo_Invoke(ti, This, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1456     return hr;
1457 }
1458
1459 static HRESULT WINAPI FolderImpl_get_Title(Folder3 *iface, BSTR *title)
1460 {
1461     FolderImpl *This = impl_from_Folder(iface);
1462     PCUITEMID_CHILD last_part;
1463     IShellFolder2 *parent;
1464     SHELLDETAILS sd;
1465     HRESULT hr;
1466
1467     TRACE("(%p,%p)\n", iface, title);
1468
1469     *title = NULL;
1470
1471     if (FAILED(hr = SHBindToParent(This->pidl, &IID_IShellFolder2, (void **)&parent, &last_part)))
1472         return hr;
1473
1474     hr = IShellFolder2_GetDetailsOf(parent, last_part, 0, &sd);
1475     IShellFolder2_Release(parent);
1476     if (FAILED(hr))
1477         return hr;
1478
1479     return StrRetToBSTR(&sd.str, last_part, title);
1480 }
1481
1482 static HRESULT WINAPI FolderImpl_get_Application(Folder3 *iface, IDispatch **disp)
1483 {
1484     FolderImpl *This = impl_from_Folder(iface);
1485
1486     TRACE("(%p,%p)\n", iface, disp);
1487
1488     if (!disp)
1489         return E_INVALIDARG;
1490
1491     *disp = This->application;
1492     IDispatch_AddRef(*disp);
1493
1494     return S_OK;
1495 }
1496
1497 static HRESULT WINAPI FolderImpl_get_Parent(Folder3 *iface, IDispatch **disp)
1498 {
1499     TRACE("(%p,%p)\n", iface, disp);
1500
1501     if (disp)
1502         *disp = NULL;
1503     return E_NOTIMPL;
1504 }
1505
1506 static HRESULT WINAPI FolderImpl_get_ParentFolder(Folder3 *iface, Folder **ppsf)
1507 {
1508     FIXME("(%p,%p)\n", iface, ppsf);
1509
1510     *ppsf = NULL;
1511     return E_NOTIMPL;
1512 }
1513
1514 static HRESULT WINAPI FolderImpl_Items(Folder3 *iface, FolderItems **ppid)
1515 {
1516     FolderImpl *This = impl_from_Folder(iface);
1517
1518     TRACE("(%p,%p)\n", iface, ppid);
1519
1520     return FolderItems_Constructor(This, ppid);
1521 }
1522
1523 static HRESULT WINAPI FolderImpl_ParseName(Folder3 *iface, BSTR name, FolderItem **item)
1524 {
1525     FolderImpl *This = impl_from_Folder(iface);
1526     LPITEMIDLIST pidl;
1527     STRRET strret;
1528     HRESULT hr;
1529     BSTR path;
1530
1531     TRACE("(%p,%s,%p)\n", iface, debugstr_w(name), item);
1532
1533     *item = NULL;
1534
1535     if (FAILED(IShellFolder2_ParseDisplayName(This->folder, NULL, NULL, name, NULL, &pidl, NULL)))
1536         return S_FALSE;
1537
1538     if ((hr = IShellFolder2_GetDisplayNameOf(This->folder, pidl, SHGDN_FORPARSING, &strret)) == S_OK)
1539         StrRetToBSTR(&strret, pidl, &path);
1540
1541     ILFree(pidl);
1542     if (FAILED(hr))
1543         return S_FALSE;
1544
1545     hr = FolderItem_Constructor(This, path, item);
1546     SysFreeString(path);
1547     return hr;
1548 }
1549
1550 static HRESULT WINAPI FolderImpl_NewFolder(Folder3 *iface, BSTR name, VARIANT options)
1551 {
1552     FIXME("(%p,%s,%s)\n", iface, debugstr_w(name), debugstr_variant(&options));
1553
1554     return E_NOTIMPL;
1555 }
1556
1557 static HRESULT WINAPI FolderImpl_MoveHere(Folder3 *iface, VARIANT item, VARIANT options)
1558 {
1559     FIXME("(%p,%s,%s)\n", iface, debugstr_variant(&item), debugstr_variant(&options));
1560
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI FolderImpl_CopyHere(Folder3 *iface, VARIANT item, VARIANT options)
1565 {
1566     FIXME("(%p,%s,%s)\n", iface, debugstr_variant(&item), debugstr_variant(&options));
1567
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI FolderImpl_GetDetailsOf(Folder3 *iface, VARIANT item, int column, BSTR *str)
1572 {
1573     FIXME("(%p,%s,%d,%p)\n", iface, debugstr_variant(&item), column, str);
1574
1575     *str = NULL;
1576     return E_NOTIMPL;
1577 }
1578
1579 static HRESULT WINAPI FolderImpl_get_Self(Folder3 *iface, FolderItem **item)
1580 {
1581     FolderImpl *This = impl_from_Folder(iface);
1582
1583     TRACE("(%p,%p)\n", iface, item);
1584
1585     return FolderItem_Constructor(This, NULL, item);
1586 }
1587
1588 static HRESULT WINAPI FolderImpl_get_OfflineStatus(Folder3 *iface, LONG *pul)
1589 {
1590     FIXME("(%p,%p)\n", iface, pul);
1591
1592     return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI FolderImpl_Synchronize(Folder3 *iface)
1596 {
1597     FIXME("(%p)\n", iface);
1598
1599     return E_NOTIMPL;
1600 }
1601
1602 static HRESULT WINAPI FolderImpl_get_HaveToShowWebViewBarricade(Folder3 *iface,
1603         VARIANT_BOOL *pbHaveToShowWebViewBarricade)
1604 {
1605     FIXME("(%p,%p)\n", iface, pbHaveToShowWebViewBarricade);
1606
1607     return E_NOTIMPL;
1608 }
1609
1610 static HRESULT WINAPI FolderImpl_DismissedWebViewBarricade(Folder3 *iface)
1611 {
1612     FIXME("(%p)\n", iface);
1613
1614     return E_NOTIMPL;
1615 }
1616
1617 static HRESULT WINAPI FolderImpl_get_ShowWebViewBarricade(Folder3 *iface,
1618         VARIANT_BOOL *pbShowWebViewBarricade)
1619 {
1620     FIXME("(%p,%p)\n", iface, pbShowWebViewBarricade);
1621
1622     return E_NOTIMPL;
1623 }
1624
1625 static HRESULT WINAPI FolderImpl_put_ShowWebViewBarricade(Folder3 *iface,
1626         VARIANT_BOOL bShowWebViewBarricade)
1627 {
1628     FIXME("(%p,%d)\n", iface, bShowWebViewBarricade);
1629
1630     return E_NOTIMPL;
1631 }
1632
1633 static const Folder3Vtbl FolderImpl_Vtbl = {
1634     FolderImpl_QueryInterface,
1635     FolderImpl_AddRef,
1636     FolderImpl_Release,
1637     FolderImpl_GetTypeInfoCount,
1638     FolderImpl_GetTypeInfo,
1639     FolderImpl_GetIDsOfNames,
1640     FolderImpl_Invoke,
1641     FolderImpl_get_Title,
1642     FolderImpl_get_Application,
1643     FolderImpl_get_Parent,
1644     FolderImpl_get_ParentFolder,
1645     FolderImpl_Items,
1646     FolderImpl_ParseName,
1647     FolderImpl_NewFolder,
1648     FolderImpl_MoveHere,
1649     FolderImpl_CopyHere,
1650     FolderImpl_GetDetailsOf,
1651     FolderImpl_get_Self,
1652     FolderImpl_get_OfflineStatus,
1653     FolderImpl_Synchronize,
1654     FolderImpl_get_HaveToShowWebViewBarricade,
1655     FolderImpl_DismissedWebViewBarricade,
1656     FolderImpl_get_ShowWebViewBarricade,
1657     FolderImpl_put_ShowWebViewBarricade
1658 };
1659
1660 static HRESULT Folder_Constructor(IShellFolder2 *folder, LPITEMIDLIST pidl, Folder **ret)
1661 {
1662     PCUITEMID_CHILD last_part;
1663     IShellFolder2 *parent;
1664     FolderImpl *This;
1665     STRRET strret;
1666     HRESULT hr;
1667
1668     *ret = NULL;
1669
1670     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1671     if (!This)
1672         return E_OUTOFMEMORY;
1673
1674     This->Folder3_iface.lpVtbl = &FolderImpl_Vtbl;
1675     This->ref = 1;
1676     This->folder = folder;
1677     This->pidl = pidl;
1678
1679     hr = SHBindToParent(pidl, &IID_IShellFolder2, (void **)&parent, &last_part);
1680     IShellFolder2_GetDisplayNameOf(parent, last_part, SHGDN_FORPARSING, &strret);
1681     StrRetToBSTR(&strret, last_part, &This->path);
1682     IShellFolder2_Release(parent);
1683
1684     IShellDispatch_Constructor(NULL, &IID_IDispatch, (void **)&This->application);
1685
1686     *ret = (Folder *)&This->Folder3_iface;
1687     return hr;
1688 }
1689
1690 static HRESULT WINAPI ShellDispatch_QueryInterface(IShellDispatch6 *iface,
1691         REFIID riid, LPVOID *ppv)
1692 {
1693     ShellDispatch *This = impl_from_IShellDispatch6(iface);
1694
1695     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
1696
1697     if (!ppv) return E_INVALIDARG;
1698
1699     if (IsEqualIID(&IID_IUnknown, riid) ||
1700         IsEqualIID(&IID_IDispatch, riid) ||
1701         IsEqualIID(&IID_IShellDispatch, riid) ||
1702         IsEqualIID(&IID_IShellDispatch2, riid) ||
1703         IsEqualIID(&IID_IShellDispatch3, riid) ||
1704         IsEqualIID(&IID_IShellDispatch4, riid) ||
1705         IsEqualIID(&IID_IShellDispatch5, riid) ||
1706         IsEqualIID(&IID_IShellDispatch6, riid))
1707         *ppv = &This->IShellDispatch6_iface;
1708     else
1709     {
1710         WARN("not implemented for %s\n", debugstr_guid(riid));
1711         *ppv = NULL;
1712         return E_NOINTERFACE;
1713     }
1714
1715     IShellDispatch6_AddRef(iface);
1716     return S_OK;
1717 }
1718
1719 static ULONG WINAPI ShellDispatch_AddRef(IShellDispatch6 *iface)
1720 {
1721     ShellDispatch *This = impl_from_IShellDispatch6(iface);
1722     ULONG ref = InterlockedIncrement(&This->ref);
1723
1724     TRACE("(%p), new refcount=%i\n", iface, ref);
1725
1726     return ref;
1727 }
1728
1729 static ULONG WINAPI ShellDispatch_Release(IShellDispatch6 *iface)
1730 {
1731     ShellDispatch *This = impl_from_IShellDispatch6(iface);
1732     ULONG ref = InterlockedDecrement(&This->ref);
1733
1734     TRACE("(%p), new refcount=%i\n", iface, ref);
1735
1736     if (!ref)
1737         HeapFree(GetProcessHeap(), 0, This);
1738
1739     return ref;
1740 }
1741
1742 static HRESULT WINAPI ShellDispatch_GetTypeInfoCount(IShellDispatch6 *iface,
1743         UINT *pctinfo)
1744 {
1745     TRACE("(%p,%p)\n", iface, pctinfo);
1746
1747     *pctinfo = 1;
1748     return S_OK;
1749 }
1750
1751 static HRESULT WINAPI ShellDispatch_GetTypeInfo(IShellDispatch6 *iface,
1752         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1753 {
1754     HRESULT hr;
1755
1756     TRACE("(%p,%u,%d,%p)\n", iface, iTInfo, lcid, ppTInfo);
1757
1758     hr = get_typeinfo(IShellDispatch6_tid, ppTInfo);
1759     if (SUCCEEDED(hr))
1760         ITypeInfo_AddRef(*ppTInfo);
1761     return hr;
1762 }
1763
1764 static HRESULT WINAPI ShellDispatch_GetIDsOfNames(IShellDispatch6 *iface,
1765         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1766 {
1767     ITypeInfo *ti;
1768     HRESULT hr;
1769
1770     TRACE("(%p,%s,%p,%u,%d,%p)\n", iface, shdebugstr_guid(riid), rgszNames, cNames, lcid,
1771             rgDispId);
1772
1773     hr = get_typeinfo(IShellDispatch6_tid, &ti);
1774     if (SUCCEEDED(hr))
1775         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
1776     return hr;
1777 }
1778
1779 static HRESULT WINAPI ShellDispatch_Invoke(IShellDispatch6 *iface,
1780         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
1781         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
1782         UINT *puArgErr)
1783 {
1784     ShellDispatch *This = impl_from_IShellDispatch6(iface);
1785     ITypeInfo *ti;
1786     HRESULT hr;
1787
1788     TRACE("(%p,%d,%s,%d,%u,%p,%p,%p,%p)\n", iface, dispIdMember, shdebugstr_guid(riid), lcid,
1789             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1790
1791     hr = get_typeinfo(IShellDispatch6_tid, &ti);
1792     if (SUCCEEDED(hr))
1793         hr = ITypeInfo_Invoke(ti, &This->IShellDispatch6_iface, dispIdMember, wFlags, pDispParams,
1794             pVarResult, pExcepInfo, puArgErr);
1795     return hr;
1796 }
1797
1798 static HRESULT WINAPI ShellDispatch_get_Application(IShellDispatch6 *iface, IDispatch **disp)
1799 {
1800     TRACE("(%p,%p)\n", iface, disp);
1801
1802     if (!disp)
1803         return E_INVALIDARG;
1804
1805     *disp = (IDispatch *)iface;
1806     IDispatch_AddRef(*disp);
1807     return S_OK;
1808 }
1809
1810 static HRESULT WINAPI ShellDispatch_get_Parent(IShellDispatch6 *iface, IDispatch **disp)
1811 {
1812     TRACE("(%p,%p)\n", iface, disp);
1813
1814     if (disp)
1815     {
1816         *disp = (IDispatch *)iface;
1817         IDispatch_AddRef(*disp);
1818     }
1819
1820     return S_OK;
1821 }
1822
1823 static HRESULT WINAPI ShellDispatch_NameSpace(IShellDispatch6 *iface,
1824         VARIANT dir, Folder **ret)
1825 {
1826     IShellFolder2 *folder;
1827     IShellFolder *desktop;
1828     LPITEMIDLIST pidl;
1829     HRESULT hr;
1830
1831     TRACE("(%p,%s,%p)\n", iface, debugstr_variant(&dir), ret);
1832
1833     *ret = NULL;
1834
1835     switch (V_VT(&dir))
1836     {
1837         case VT_I2:
1838             if (FAILED(hr = VariantChangeType(&dir, &dir, 0, VT_I4)))
1839                 return hr;
1840
1841             /* fallthrough */
1842         case VT_I4:
1843             if (FAILED(hr = SHGetFolderLocation(NULL, V_I4(&dir), NULL, 0, &pidl)))
1844                 return S_FALSE;
1845
1846             break;
1847         case VT_BSTR:
1848             if (FAILED(hr = SHParseDisplayName(V_BSTR(&dir), NULL, &pidl, 0, NULL)))
1849                 return S_FALSE;
1850
1851             break;
1852         default:
1853             WARN("Ignoring directory value %s\n", debugstr_variant(&dir));
1854             return S_FALSE;
1855     }
1856
1857     if (FAILED(hr = SHGetDesktopFolder(&desktop)))
1858         return hr;
1859
1860     if (_ILIsDesktop(pidl))
1861         hr = IShellFolder_QueryInterface(desktop, &IID_IShellFolder2, (void **)&folder);
1862     else
1863         hr = IShellFolder_BindToObject(desktop, pidl, NULL, &IID_IShellFolder2, (void **)&folder);
1864
1865     IShellFolder_Release(desktop);
1866
1867     if (FAILED(hr))
1868         return S_FALSE;
1869
1870     return Folder_Constructor(folder, pidl, ret);
1871 }
1872
1873 static HRESULT WINAPI ShellDispatch_BrowseForFolder(IShellDispatch6 *iface,
1874         LONG Hwnd, BSTR Title, LONG Options, VARIANT RootFolder, Folder **ppsdf)
1875 {
1876     FIXME("(%p,%x,%s,%x,%s,%p)\n", iface, Hwnd, debugstr_w(Title), Options, debugstr_variant(&RootFolder), ppsdf);
1877
1878     *ppsdf = NULL;
1879     return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI ShellDispatch_Windows(IShellDispatch6 *iface,
1883         IDispatch **ppid)
1884 {
1885     FIXME("(%p,%p)\n", iface, ppid);
1886
1887     *ppid = NULL;
1888     return E_NOTIMPL;
1889 }
1890
1891 static HRESULT WINAPI ShellDispatch_Open(IShellDispatch6 *iface, VARIANT dir)
1892 {
1893     FIXME("(%p,%s)\n", iface, debugstr_variant(&dir));
1894
1895     return E_NOTIMPL;
1896 }
1897
1898 static HRESULT WINAPI ShellDispatch_Explore(IShellDispatch6 *iface, VARIANT dir)
1899 {
1900     FIXME("(%p,%s)\n", iface, debugstr_variant(&dir));
1901
1902     return E_NOTIMPL;
1903 }
1904
1905 static HRESULT WINAPI ShellDispatch_MinimizeAll(IShellDispatch6 *iface)
1906 {
1907     FIXME("(%p)\n", iface);
1908
1909     return E_NOTIMPL;
1910 }
1911
1912 static HRESULT WINAPI ShellDispatch_UndoMinimizeALL(IShellDispatch6 *iface)
1913 {
1914     FIXME("(%p)\n", iface);
1915
1916     return E_NOTIMPL;
1917 }
1918
1919 static HRESULT WINAPI ShellDispatch_FileRun(IShellDispatch6 *iface)
1920 {
1921     FIXME("(%p)\n", iface);
1922
1923     return E_NOTIMPL;
1924 }
1925
1926 static HRESULT WINAPI ShellDispatch_CascadeWindows(IShellDispatch6 *iface)
1927 {
1928     FIXME("(%p)\n", iface);
1929
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI ShellDispatch_TileVertically(IShellDispatch6 *iface)
1934 {
1935     FIXME("(%p)\n", iface);
1936
1937     return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI ShellDispatch_TileHorizontally(IShellDispatch6 *iface)
1941 {
1942     FIXME("(%p)\n", iface);
1943
1944     return E_NOTIMPL;
1945 }
1946
1947 static HRESULT WINAPI ShellDispatch_ShutdownWindows(IShellDispatch6 *iface)
1948 {
1949     FIXME("(%p)\n", iface);
1950
1951     return E_NOTIMPL;
1952 }
1953
1954 static HRESULT WINAPI ShellDispatch_Suspend(IShellDispatch6 *iface)
1955 {
1956     FIXME("(%p)\n", iface);
1957
1958     return E_NOTIMPL;
1959 }
1960
1961 static HRESULT WINAPI ShellDispatch_EjectPC(IShellDispatch6 *iface)
1962 {
1963     FIXME("(%p)\n", iface);
1964
1965     return E_NOTIMPL;
1966 }
1967
1968 static HRESULT WINAPI ShellDispatch_SetTime(IShellDispatch6 *iface)
1969 {
1970     FIXME("(%p)\n", iface);
1971
1972     return E_NOTIMPL;
1973 }
1974
1975 static HRESULT WINAPI ShellDispatch_TrayProperties(IShellDispatch6 *iface)
1976 {
1977     FIXME("(%p)\n", iface);
1978
1979     return E_NOTIMPL;
1980 }
1981
1982 static HRESULT WINAPI ShellDispatch_Help(IShellDispatch6 *iface)
1983 {
1984     FIXME("(%p)\n", iface);
1985
1986     return E_NOTIMPL;
1987 }
1988
1989 static HRESULT WINAPI ShellDispatch_FindFiles(IShellDispatch6 *iface)
1990 {
1991     FIXME("(%p)\n", iface);
1992
1993     return E_NOTIMPL;
1994 }
1995
1996 static HRESULT WINAPI ShellDispatch_FindComputer(IShellDispatch6 *iface)
1997 {
1998     FIXME("(%p)\n", iface);
1999
2000     return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI ShellDispatch_RefreshMenu(IShellDispatch6 *iface)
2004 {
2005     FIXME("(%p)\n", iface);
2006
2007     return E_NOTIMPL;
2008 }
2009
2010 static HRESULT WINAPI ShellDispatch_ControlPanelItem(IShellDispatch6 *iface,
2011         BSTR szDir)
2012 {
2013     FIXME("(%p,%s)\n", iface, debugstr_w(szDir));
2014
2015     return E_NOTIMPL;
2016 }
2017
2018 static HRESULT WINAPI ShellDispatch_IsRestricted(IShellDispatch6 *iface, BSTR group, BSTR restriction, LONG *value)
2019 {
2020     FIXME("(%s, %s, %p): stub\n", debugstr_w(group), debugstr_w(restriction), value);
2021     return E_NOTIMPL;
2022 }
2023
2024 static HRESULT WINAPI ShellDispatch_ShellExecute(IShellDispatch6 *iface,
2025         BSTR file, VARIANT v_args, VARIANT v_dir, VARIANT v_op, VARIANT v_show)
2026 {
2027     VARIANT args_str, dir_str, op_str, show_int;
2028     WCHAR *args = NULL, *dir = NULL, *op = NULL;
2029     INT show = 0;
2030     HINSTANCE ret;
2031
2032     TRACE("(%s, %s, %s, %s, %s)\n", debugstr_w(file), debugstr_variant(&v_args),
2033             debugstr_variant(&v_dir), debugstr_variant(&v_op), debugstr_variant(&v_show));
2034
2035     VariantInit(&args_str);
2036     VariantChangeType(&args_str, &v_args, 0, VT_BSTR);
2037     if (V_VT(&args_str) == VT_BSTR)
2038         args = V_BSTR(&args_str);
2039
2040     VariantInit(&dir_str);
2041     VariantChangeType(&dir_str, &v_dir, 0, VT_BSTR);
2042     if (V_VT(&dir_str) == VT_BSTR)
2043         dir = V_BSTR(&dir_str);
2044
2045     VariantInit(&op_str);
2046     VariantChangeType(&op_str, &v_op, 0, VT_BSTR);
2047     if (V_VT(&op_str) == VT_BSTR)
2048         op = V_BSTR(&op_str);
2049
2050     VariantInit(&show_int);
2051     VariantChangeType(&show_int, &v_show, 0, VT_I4);
2052     if (V_VT(&show_int) == VT_I4)
2053         show = V_I4(&show_int);
2054
2055     ret = ShellExecuteW(NULL, op, file, args, dir, show);
2056
2057     VariantClear(&args_str);
2058     VariantClear(&dir_str);
2059     VariantClear(&op_str);
2060     VariantClear(&show_int);
2061
2062     return (ULONG_PTR)ret > 32 ? S_OK : S_FALSE;
2063 }
2064
2065 static HRESULT WINAPI ShellDispatch_FindPrinter(IShellDispatch6 *iface, BSTR name, BSTR location, BSTR model)
2066 {
2067     FIXME("(%s, %s, %s): stub\n", debugstr_w(name), debugstr_w(location), debugstr_w(model));
2068     return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI ShellDispatch_GetSystemInformation(IShellDispatch6 *iface, BSTR name, VARIANT *ret)
2072 {
2073     FIXME("(%s, %p): stub\n", debugstr_w(name), ret);
2074     return E_NOTIMPL;
2075 }
2076
2077 static HRESULT WINAPI ShellDispatch_ServiceStart(IShellDispatch6 *iface, BSTR service, VARIANT persistent, VARIANT *ret)
2078 {
2079     FIXME("(%s, %s, %p): stub\n", debugstr_w(service), debugstr_variant(&persistent), ret);
2080     return E_NOTIMPL;
2081 }
2082
2083 static HRESULT WINAPI ShellDispatch_ServiceStop(IShellDispatch6 *iface, BSTR service, VARIANT persistent, VARIANT *ret)
2084 {
2085     FIXME("(%s, %s, %p): stub\n", debugstr_w(service), debugstr_variant(&persistent), ret);
2086     return E_NOTIMPL;
2087 }
2088
2089 static HRESULT WINAPI ShellDispatch_IsServiceRunning(IShellDispatch6 *iface, BSTR name, VARIANT *running)
2090 {
2091     SERVICE_STATUS_PROCESS status;
2092     SC_HANDLE scm, service;
2093     DWORD dummy;
2094
2095     TRACE("(%s, %p)\n", debugstr_w(name), running);
2096
2097     V_VT(running) = VT_BOOL;
2098     V_BOOL(running) = VARIANT_FALSE;
2099
2100     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
2101     if (!scm)
2102     {
2103         ERR("failed to connect to service manager\n");
2104         return S_OK;
2105     }
2106
2107     service = OpenServiceW(scm, name, SERVICE_QUERY_STATUS);
2108     if (!service)
2109     {
2110         ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
2111         CloseServiceHandle(scm);
2112         return S_OK;
2113     }
2114
2115     if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status,
2116              sizeof(SERVICE_STATUS_PROCESS), &dummy))
2117     {
2118         TRACE("failed to query service status (%u)\n", GetLastError());
2119         CloseServiceHandle(service);
2120         CloseServiceHandle(scm);
2121         return S_OK;
2122     }
2123
2124     if (status.dwCurrentState == SERVICE_RUNNING)
2125        V_BOOL(running) = VARIANT_TRUE;
2126
2127     CloseServiceHandle(service);
2128     CloseServiceHandle(scm);
2129
2130     return S_OK;
2131 }
2132
2133 static HRESULT WINAPI ShellDispatch_CanStartStopService(IShellDispatch6 *iface, BSTR service, VARIANT *ret)
2134 {
2135     FIXME("(%s, %p): stub\n", debugstr_w(service), ret);
2136     return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI ShellDispatch_ShowBrowserBar(IShellDispatch6 *iface, BSTR clsid, VARIANT show, VARIANT *ret)
2140 {
2141     FIXME("(%s, %s, %p): stub\n", debugstr_w(clsid), debugstr_variant(&show), ret);
2142     return E_NOTIMPL;
2143 }
2144
2145 static HRESULT WINAPI ShellDispatch_AddToRecent(IShellDispatch6 *iface, VARIANT file, BSTR category)
2146 {
2147     FIXME("(%s, %s): stub\n", debugstr_variant(&file), debugstr_w(category));
2148     return E_NOTIMPL;
2149 }
2150
2151 static HRESULT WINAPI ShellDispatch_WindowsSecurity(IShellDispatch6 *iface)
2152 {
2153     FIXME("stub\n");
2154     return E_NOTIMPL;
2155 }
2156
2157 static HRESULT WINAPI ShellDispatch_ToggleDesktop(IShellDispatch6 *iface)
2158 {
2159     FIXME("stub\n");
2160     return E_NOTIMPL;
2161 }
2162
2163 static HRESULT WINAPI ShellDispatch_ExplorerPolicy(IShellDispatch6 *iface, BSTR policy, VARIANT *value)
2164 {
2165     FIXME("(%s, %p): stub\n", debugstr_w(policy), value);
2166     return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI ShellDispatch_GetSetting(IShellDispatch6 *iface, LONG setting, VARIANT_BOOL *result)
2170 {
2171     FIXME("(%d %p): stub\n", setting, result);
2172     return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI ShellDispatch_WindowSwitcher(IShellDispatch6 *iface)
2176 {
2177     FIXME("stub\n");
2178     return E_NOTIMPL;
2179 }
2180
2181 static HRESULT WINAPI ShellDispatch_SearchCommand(IShellDispatch6 *iface)
2182 {
2183     FIXME("stub\n");
2184     return E_NOTIMPL;
2185 }
2186
2187 static const IShellDispatch6Vtbl ShellDispatchVtbl = {
2188     ShellDispatch_QueryInterface,
2189     ShellDispatch_AddRef,
2190     ShellDispatch_Release,
2191     ShellDispatch_GetTypeInfoCount,
2192     ShellDispatch_GetTypeInfo,
2193     ShellDispatch_GetIDsOfNames,
2194     ShellDispatch_Invoke,
2195     ShellDispatch_get_Application,
2196     ShellDispatch_get_Parent,
2197     ShellDispatch_NameSpace,
2198     ShellDispatch_BrowseForFolder,
2199     ShellDispatch_Windows,
2200     ShellDispatch_Open,
2201     ShellDispatch_Explore,
2202     ShellDispatch_MinimizeAll,
2203     ShellDispatch_UndoMinimizeALL,
2204     ShellDispatch_FileRun,
2205     ShellDispatch_CascadeWindows,
2206     ShellDispatch_TileVertically,
2207     ShellDispatch_TileHorizontally,
2208     ShellDispatch_ShutdownWindows,
2209     ShellDispatch_Suspend,
2210     ShellDispatch_EjectPC,
2211     ShellDispatch_SetTime,
2212     ShellDispatch_TrayProperties,
2213     ShellDispatch_Help,
2214     ShellDispatch_FindFiles,
2215     ShellDispatch_FindComputer,
2216     ShellDispatch_RefreshMenu,
2217     ShellDispatch_ControlPanelItem,
2218     ShellDispatch_IsRestricted,
2219     ShellDispatch_ShellExecute,
2220     ShellDispatch_FindPrinter,
2221     ShellDispatch_GetSystemInformation,
2222     ShellDispatch_ServiceStart,
2223     ShellDispatch_ServiceStop,
2224     ShellDispatch_IsServiceRunning,
2225     ShellDispatch_CanStartStopService,
2226     ShellDispatch_ShowBrowserBar,
2227     ShellDispatch_AddToRecent,
2228     ShellDispatch_WindowsSecurity,
2229     ShellDispatch_ToggleDesktop,
2230     ShellDispatch_ExplorerPolicy,
2231     ShellDispatch_GetSetting,
2232     ShellDispatch_WindowSwitcher,
2233     ShellDispatch_SearchCommand
2234 };
2235
2236 HRESULT WINAPI IShellDispatch_Constructor(IUnknown *outer, REFIID riid, void **ppv)
2237 {
2238     ShellDispatch *This;
2239     HRESULT ret;
2240
2241     TRACE("(%p, %s)\n", outer, debugstr_guid(riid));
2242
2243     *ppv = NULL;
2244
2245     if (outer) return CLASS_E_NOAGGREGATION;
2246
2247     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ShellDispatch));
2248     if (!This) return E_OUTOFMEMORY;
2249     This->IShellDispatch6_iface.lpVtbl = &ShellDispatchVtbl;
2250     This->ref = 1;
2251
2252     ret = IShellDispatch6_QueryInterface(&This->IShellDispatch6_iface, riid, ppv);
2253     IShellDispatch6_Release(&This->IShellDispatch6_iface);
2254     return ret;
2255 }