dlls/shell32/shellitem.c

   1 /*
   2  * IShellItem and IShellItemArray implementations
   3  *
   4  * Copyright 2008 Vincent Povirk for CodeWeavers
   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 <stdio.h>
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wine/debug.h"
  28
  29 #include "pidl.h"
  30 #include "shell32_main.h"
  31 #include "debughlp.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  34
  35 struct shell_item {
  36     IShellItem2             IShellItem2_iface;
  37     LONG                    ref;
  38     LPITEMIDLIST            pidl;
  39     IPersistIDList          IPersistIDList_iface;
  40     IShellItemImageFactory  IShellItemImageFactory_iface;
  41 };
  42
  43 typedef struct _CustomDestinationList {
  44     ICustomDestinationList ICustomDestinationList_iface;
  45     LONG ref;
  46 } CustomDestinationList;
  47
  48 static struct shell_item *impl_from_IShellItem2(IShellItem2 *iface)
  49 {
  50     return CONTAINING_RECORD(iface, struct shell_item, IShellItem2_iface);
  51 }
  52
  53 static struct shell_item *impl_from_IPersistIDList(IPersistIDList *iface)
  54 {
  55     return CONTAINING_RECORD(iface, struct shell_item, IPersistIDList_iface);
  56 }
  57
  58 static struct shell_item *impl_from_IShellItemImageFactory(IShellItemImageFactory *iface)
  59 {
  60     return CONTAINING_RECORD(iface, struct shell_item, IShellItemImageFactory_iface);
  61 }
  62
  63 static inline CustomDestinationList *impl_from_ICustomDestinationList( ICustomDestinationList *iface )
  64 {
  65     return CONTAINING_RECORD(iface, CustomDestinationList, ICustomDestinationList_iface);
  66 }
  67
  68 static HRESULT WINAPI ShellItem_QueryInterface(IShellItem2 *iface, REFIID riid,
  69     void **ppv)
  70 {
  71     struct shell_item *This = impl_from_IShellItem2(iface);
  72
  73     TRACE("(%p, %s, %p)\n", iface, debugstr_guid(riid), ppv);
  74
  75     if (!ppv) return E_INVALIDARG;
  76
  77     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IShellItem, riid) ||
  78         IsEqualIID(&IID_IShellItem2, riid))
  79     {
  80         *ppv = &This->IShellItem2_iface;
  81     }
  82     else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistIDList, riid))
  83     {
  84         *ppv = &This->IPersistIDList_iface;
  85     }
  86     else if (IsEqualIID(&IID_IShellItemImageFactory, riid))
  87     {
  88         *ppv = &This->IShellItemImageFactory_iface;
  89     }
  90     else {
  91         FIXME("not implemented for %s\n", shdebugstr_guid(riid));
  92         *ppv = NULL;
  93         return E_NOINTERFACE;
  94     }
  95
  96     IUnknown_AddRef((IUnknown*)*ppv);
  97     return S_OK;
  98 }
  99
 100 static ULONG WINAPI ShellItem_AddRef(IShellItem2 *iface)
 101 {
 102     struct shell_item *This = impl_from_IShellItem2(iface);
 103     ULONG ref = InterlockedIncrement(&This->ref);
 104
 105     TRACE("(%p), new refcount=%li\n", iface, ref);
 106
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI ShellItem_Release(IShellItem2 *iface)
 111 {
 112     struct shell_item *This = impl_from_IShellItem2(iface);
 113     ULONG ref = InterlockedDecrement(&This->ref);
 114
 115     TRACE("(%p), new refcount=%li\n", iface, ref);
 116
 117     if (ref == 0)
 118     {
 119         ILFree(This->pidl);
 120         free(This);
 121     }
 122
 123     return ref;
 124 }
 125
 126 static HRESULT ShellItem_get_parent_pidl(struct shell_item *This, ITEMIDLIST **parent_pidl)
 127 {
 128     *parent_pidl = ILClone(This->pidl);
 129     if (*parent_pidl)
 130     {
 131         if (ILRemoveLastID(*parent_pidl))
 132             return S_OK;
 133         else
 134         {
 135             ILFree(*parent_pidl);
 136             *parent_pidl = NULL;
 137             return E_INVALIDARG;
 138         }
 139     }
 140     else
 141     {
 142         *parent_pidl = NULL;
 143         return E_OUTOFMEMORY;
 144     }
 145 }
 146
 147 static HRESULT ShellItem_get_parent_shellfolder(struct shell_item *This, IShellFolder **ppsf)
 148 {
 149     LPITEMIDLIST parent_pidl;
 150     IShellFolder *desktop;
 151     HRESULT ret;
 152
 153     ret = ShellItem_get_parent_pidl(This, &parent_pidl);
 154     if (SUCCEEDED(ret))
 155     {
 156         ret = SHGetDesktopFolder(&desktop);
 157         if (SUCCEEDED(ret))
 158         {
 159             if (_ILIsDesktop(parent_pidl))
 160             {
 161                 *ppsf = desktop;
 162             }
 163             else
 164             {
 165                 ret = IShellFolder_BindToObject(desktop, parent_pidl, NULL, &IID_IShellFolder, (void**)ppsf);
 166                 IShellFolder_Release(desktop);
 167             }
 168         }
 169         ILFree(parent_pidl);
 170     }
 171
 172     return ret;
 173 }
 174
 175 static HRESULT ShellItem_get_shellfolder(struct shell_item *This, IBindCtx *pbc, IShellFolder **ppsf)
 176 {
 177     IShellFolder *desktop;
 178     HRESULT ret;
 179
 180     ret = SHGetDesktopFolder(&desktop);
 181     if (SUCCEEDED(ret))
 182     {
 183         if (_ILIsDesktop(This->pidl))
 184         {
 185             *ppsf = desktop;
 186             IShellFolder_AddRef(*ppsf);
 187         }
 188         else
 189         {
 190             ret = IShellFolder_BindToObject(desktop, This->pidl, pbc, &IID_IShellFolder, (void**)ppsf);
 191         }
 192
 193         IShellFolder_Release(desktop);
 194     }
 195
 196     return ret;
 197 }
 198
 199 static HRESULT WINAPI ShellItem_BindToHandler(IShellItem2 *iface, IBindCtx *pbc,
 200     REFGUID rbhid, REFIID riid, void **ppvOut)
 201 {
 202     struct shell_item *This = impl_from_IShellItem2(iface);
 203     HRESULT ret;
 204     TRACE("(%p,%p,%s,%p,%p)\n", iface, pbc, shdebugstr_guid(rbhid), riid, ppvOut);
 205
 206     *ppvOut = NULL;
 207     if (IsEqualGUID(rbhid, &BHID_SFObject))
 208     {
 209         IShellFolder *psf;
 210         ret = ShellItem_get_shellfolder(This, pbc, &psf);
 211         if (SUCCEEDED(ret))
 212         {
 213             ret = IShellFolder_QueryInterface(psf, riid, ppvOut);
 214             IShellFolder_Release(psf);
 215         }
 216         return ret;
 217     }
 218     else if (IsEqualGUID(rbhid, &BHID_SFUIObject))
 219     {
 220         IShellFolder *psf_parent;
 221         if (_ILIsDesktop(This->pidl))
 222             ret = SHGetDesktopFolder(&psf_parent);
 223         else
 224             ret = ShellItem_get_parent_shellfolder(This, &psf_parent);
 225
 226         if (SUCCEEDED(ret))
 227         {
 228             LPCITEMIDLIST pidl = ILFindLastID(This->pidl);
 229             ret = IShellFolder_GetUIObjectOf(psf_parent, NULL, 1, &pidl, riid, NULL, ppvOut);
 230             IShellFolder_Release(psf_parent);
 231         }
 232         return ret;
 233     }
 234     else if (IsEqualGUID(rbhid, &BHID_DataObject))
 235     {
 236         return ShellItem_BindToHandler(&This->IShellItem2_iface, pbc, &BHID_SFUIObject,
 237                                        &IID_IDataObject, ppvOut);
 238     }
 239
 240     FIXME("Unsupported BHID %s.\n", debugstr_guid(rbhid));
 241
 242     return MK_E_NOOBJECT;
 243 }
 244
 245 static HRESULT WINAPI ShellItem_GetParent(IShellItem2 *iface, IShellItem **ppsi)
 246 {
 247     struct shell_item *This = impl_from_IShellItem2(iface);
 248     LPITEMIDLIST parent_pidl;
 249     HRESULT ret;
 250
 251     TRACE("(%p,%p)\n", iface, ppsi);
 252
 253     ret = ShellItem_get_parent_pidl(This, &parent_pidl);
 254     if (SUCCEEDED(ret))
 255     {
 256         ret = SHCreateShellItem(NULL, NULL, parent_pidl, ppsi);
 257         ILFree(parent_pidl);
 258     }
 259
 260     return ret;
 261 }
 262
 263 static HRESULT WINAPI ShellItem_GetDisplayName(IShellItem2 *iface, SIGDN sigdnName,
 264     LPWSTR *ppszName)
 265 {
 266     struct shell_item *This = impl_from_IShellItem2(iface);
 267     TRACE("(%p,%x,%p)\n", iface, sigdnName, ppszName);
 268
 269     return SHGetNameFromIDList(This->pidl, sigdnName, ppszName);
 270 }
 271
 272 static HRESULT WINAPI ShellItem_GetAttributes(IShellItem2 *iface, SFGAOF sfgaoMask,
 273     SFGAOF *psfgaoAttribs)
 274 {
 275     struct shell_item *This = impl_from_IShellItem2(iface);
 276     IShellFolder *parent_folder;
 277     LPITEMIDLIST child_pidl;
 278     HRESULT ret;
 279
 280     TRACE("(%p,%lx,%p)\n", iface, sfgaoMask, psfgaoAttribs);
 281
 282     if (_ILIsDesktop(This->pidl))
 283         ret = SHGetDesktopFolder(&parent_folder);
 284     else
 285         ret = ShellItem_get_parent_shellfolder(This, &parent_folder);
 286     if (SUCCEEDED(ret))
 287     {
 288         child_pidl = ILFindLastID(This->pidl);
 289         *psfgaoAttribs = sfgaoMask;
 290         ret = IShellFolder_GetAttributesOf(parent_folder, 1, (LPCITEMIDLIST*)&child_pidl, psfgaoAttribs);
 291         *psfgaoAttribs &= sfgaoMask;
 292         IShellFolder_Release(parent_folder);
 293
 294         if (SUCCEEDED(ret))
 295         {
 296             if(sfgaoMask == *psfgaoAttribs)
 297                 return S_OK;
 298             else
 299                 return S_FALSE;
 300         }
 301     }
 302
 303     return ret;
 304 }
 305
 306 static HRESULT WINAPI ShellItem_Compare(IShellItem2 *iface, IShellItem *oth,
 307     SICHINTF hint, int *piOrder)
 308 {
 309     LPWSTR dispname, dispname_oth;
 310     HRESULT ret;
 311     TRACE("(%p,%p,%lx,%p)\n", iface, oth, hint, piOrder);
 312
 313     if(hint & (SICHINT_CANONICAL | SICHINT_ALLFIELDS))
 314         FIXME("Unsupported flags 0x%08lx\n", hint);
 315
 316     ret = IShellItem2_GetDisplayName(iface, SIGDN_DESKTOPABSOLUTEEDITING, &dispname);
 317     if(SUCCEEDED(ret))
 318     {
 319         ret = IShellItem_GetDisplayName(oth, SIGDN_DESKTOPABSOLUTEEDITING, &dispname_oth);
 320         if(SUCCEEDED(ret))
 321         {
 322             *piOrder = lstrcmpiW(dispname, dispname_oth);
 323             CoTaskMemFree(dispname_oth);
 324         }
 325         CoTaskMemFree(dispname);
 326     }
 327
 328     if(SUCCEEDED(ret) && *piOrder &&
 329        (hint & SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL))
 330     {
 331         LPWSTR dispname, dispname_oth;
 332
 333         TRACE("Testing filesystem path.\n");
 334         ret = IShellItem2_GetDisplayName(iface, SIGDN_FILESYSPATH, &dispname);
 335         if(SUCCEEDED(ret))
 336         {
 337             ret = IShellItem_GetDisplayName(oth, SIGDN_FILESYSPATH, &dispname_oth);
 338             if(SUCCEEDED(ret))
 339             {
 340                 *piOrder = lstrcmpiW(dispname, dispname_oth);
 341                 CoTaskMemFree(dispname_oth);
 342             }
 343             CoTaskMemFree(dispname);
 344         }
 345     }
 346
 347     if(FAILED(ret))
 348         return ret;
 349
 350     if(*piOrder)
 351         return S_FALSE;
 352     else
 353         return S_OK;
 354 }
 355
 356 static HRESULT WINAPI ShellItem2_GetPropertyStore(IShellItem2 *iface, GETPROPERTYSTOREFLAGS flags,
 357     REFIID riid, void **ppv)
 358 {
 359     struct shell_item *This = impl_from_IShellItem2(iface);
 360     FIXME("Stub: %p (%d, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv);
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI ShellItem2_GetPropertyStoreWithCreateObject(IShellItem2 *iface,
 365     GETPROPERTYSTOREFLAGS flags, IUnknown *punkCreateObject, REFIID riid, void **ppv)
 366 {
 367     struct shell_item *This = impl_from_IShellItem2(iface);
 368     FIXME("Stub: %p (%08x, %p, %s, %p)\n",
 369           This, flags, punkCreateObject, shdebugstr_guid(riid), ppv);
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI ShellItem2_GetPropertyStoreForKeys(IShellItem2 *iface, const PROPERTYKEY *rgKeys,
 374     UINT cKeys, GETPROPERTYSTOREFLAGS flags, REFIID riid, void **ppv)
 375 {
 376     struct shell_item *This = impl_from_IShellItem2(iface);
 377     FIXME("Stub: %p (%p, %d, %08x, %s, %p)\n",
 378           This, rgKeys, cKeys, flags, shdebugstr_guid(riid), ppv);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI ShellItem2_GetPropertyDescriptionList(IShellItem2 *iface,
 383     REFPROPERTYKEY keyType, REFIID riid, void **ppv)
 384 {
 385     struct shell_item *This = impl_from_IShellItem2(iface);
 386     FIXME("Stub: %p (%p, %s, %p)\n", This, keyType, debugstr_guid(riid), ppv);
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI ShellItem2_Update(IShellItem2 *iface, IBindCtx *pbc)
 391 {
 392     struct shell_item *This = impl_from_IShellItem2(iface);
 393     FIXME("Stub: %p (%p)\n", This, pbc);
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI ShellItem2_GetProperty(IShellItem2 *iface, REFPROPERTYKEY key, PROPVARIANT *ppropvar)
 398 {
 399     struct shell_item *This = impl_from_IShellItem2(iface);
 400     FIXME("Stub: %p (%p, %p)\n", This, key, ppropvar);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI ShellItem2_GetCLSID(IShellItem2 *iface, REFPROPERTYKEY key, CLSID *pclsid)
 405 {
 406     struct shell_item *This = impl_from_IShellItem2(iface);
 407     FIXME("Stub: %p (%p, %p)\n", This, key, pclsid);
 408     return E_NOTIMPL;
 409 }
 410
 411 static HRESULT WINAPI ShellItem2_GetFileTime(IShellItem2 *iface, REFPROPERTYKEY key, FILETIME *pft)
 412 {
 413     struct shell_item *This = impl_from_IShellItem2(iface);
 414     FIXME("Stub: %p (%p, %p)\n", This, key, pft);
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI ShellItem2_GetInt32(IShellItem2 *iface, REFPROPERTYKEY key, int *pi)
 419 {
 420     struct shell_item *This = impl_from_IShellItem2(iface);
 421     FIXME("Stub: %p (%p, %p)\n", This, key, pi);
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI ShellItem2_GetString(IShellItem2 *iface, REFPROPERTYKEY key, LPWSTR *ppsz)
 426 {
 427     struct shell_item *This = impl_from_IShellItem2(iface);
 428     FIXME("Stub: %p (%p, %p)\n", This, key, ppsz);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI ShellItem2_GetUInt32(IShellItem2 *iface, REFPROPERTYKEY key, ULONG *pui)
 433 {
 434     struct shell_item *This = impl_from_IShellItem2(iface);
 435     FIXME("Stub: %p (%p, %p)\n", This, key, pui);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI ShellItem2_GetUInt64(IShellItem2 *iface, REFPROPERTYKEY key, ULONGLONG *pull)
 440 {
 441     struct shell_item *This = impl_from_IShellItem2(iface);
 442     FIXME("Stub: %p (%p, %p)\n", This, key, pull);
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI ShellItem2_GetBool(IShellItem2 *iface, REFPROPERTYKEY key, BOOL *pf)
 447 {
 448     struct shell_item *This = impl_from_IShellItem2(iface);
 449     FIXME("Stub: %p (%p, %p)\n", This, key, pf);
 450     return E_NOTIMPL;
 451 }
 452
 453
 454 static const IShellItem2Vtbl ShellItem2_Vtbl = {
 455     ShellItem_QueryInterface,
 456     ShellItem_AddRef,
 457     ShellItem_Release,
 458     ShellItem_BindToHandler,
 459     ShellItem_GetParent,
 460     ShellItem_GetDisplayName,
 461     ShellItem_GetAttributes,
 462     ShellItem_Compare,
 463     ShellItem2_GetPropertyStore,
 464     ShellItem2_GetPropertyStoreWithCreateObject,
 465     ShellItem2_GetPropertyStoreForKeys,
 466     ShellItem2_GetPropertyDescriptionList,
 467     ShellItem2_Update,
 468     ShellItem2_GetProperty,
 469     ShellItem2_GetCLSID,
 470     ShellItem2_GetFileTime,
 471     ShellItem2_GetInt32,
 472     ShellItem2_GetString,
 473     ShellItem2_GetUInt32,
 474     ShellItem2_GetUInt64,
 475     ShellItem2_GetBool
 476 };
 477
 478 static HRESULT WINAPI ShellItem_IPersistIDList_QueryInterface(IPersistIDList *iface,
 479     REFIID riid, void **ppv)
 480 {
 481     struct shell_item *This = impl_from_IPersistIDList(iface);
 482     return IShellItem2_QueryInterface(&This->IShellItem2_iface, riid, ppv);
 483 }
 484
 485 static ULONG WINAPI ShellItem_IPersistIDList_AddRef(IPersistIDList *iface)
 486 {
 487     struct shell_item *This = impl_from_IPersistIDList(iface);
 488     return IShellItem2_AddRef(&This->IShellItem2_iface);
 489 }
 490
 491 static ULONG WINAPI ShellItem_IPersistIDList_Release(IPersistIDList *iface)
 492 {
 493     struct shell_item *This = impl_from_IPersistIDList(iface);
 494     return IShellItem2_Release(&This->IShellItem2_iface);
 495 }
 496
 497 static HRESULT WINAPI ShellItem_IPersistIDList_GetClassID(IPersistIDList* iface,
 498     CLSID *pClassID)
 499 {
 500     *pClassID = CLSID_ShellItem;
 501     return S_OK;
 502 }
 503
 504 static HRESULT WINAPI ShellItem_IPersistIDList_SetIDList(IPersistIDList* iface,
 505     LPCITEMIDLIST pidl)
 506 {
 507     struct shell_item *This = impl_from_IPersistIDList(iface);
 508     LPITEMIDLIST new_pidl;
 509
 510     TRACE("(%p,%p)\n", This, pidl);
 511
 512     new_pidl = ILClone(pidl);
 513
 514     if (new_pidl)
 515     {
 516         ILFree(This->pidl);
 517         This->pidl = new_pidl;
 518         return S_OK;
 519     }
 520     else
 521         return E_OUTOFMEMORY;
 522 }
 523
 524 static HRESULT WINAPI ShellItem_IPersistIDList_GetIDList(IPersistIDList* iface,
 525     LPITEMIDLIST *ppidl)
 526 {
 527     struct shell_item *This = impl_from_IPersistIDList(iface);
 528
 529     TRACE("(%p,%p)\n", This, ppidl);
 530
 531     *ppidl = ILClone(This->pidl);
 532     if (*ppidl)
 533         return S_OK;
 534     else
 535         return E_OUTOFMEMORY;
 536 }
 537
 538 static const IPersistIDListVtbl ShellItem_IPersistIDList_Vtbl = {
 539     ShellItem_IPersistIDList_QueryInterface,
 540     ShellItem_IPersistIDList_AddRef,
 541     ShellItem_IPersistIDList_Release,
 542     ShellItem_IPersistIDList_GetClassID,
 543     ShellItem_IPersistIDList_SetIDList,
 544     ShellItem_IPersistIDList_GetIDList
 545 };
 546
 547 static HRESULT WINAPI ShellItem_IShellItemImageFactory_QueryInterface(IShellItemImageFactory *iface,
 548     REFIID riid, void **ppv)
 549 {
 550     struct shell_item *This = impl_from_IShellItemImageFactory(iface);
 551     return IShellItem2_QueryInterface(&This->IShellItem2_iface, riid, ppv);
 552 }
 553
 554 static ULONG WINAPI ShellItem_IShellItemImageFactory_AddRef(IShellItemImageFactory *iface)
 555 {
 556     struct shell_item *This = impl_from_IShellItemImageFactory(iface);
 557     return IShellItem2_AddRef(&This->IShellItem2_iface);
 558 }
 559
 560 static ULONG WINAPI ShellItem_IShellItemImageFactory_Release(IShellItemImageFactory *iface)
 561 {
 562     struct shell_item *This = impl_from_IShellItemImageFactory(iface);
 563     return IShellItem2_Release(&This->IShellItem2_iface);
 564 }
 565
 566 static HRESULT WINAPI ShellItem_IShellItemImageFactory_GetImage(IShellItemImageFactory *iface,
 567     SIZE size, SIIGBF flags, HBITMAP *phbm)
 568 {
 569     struct shell_item *This = impl_from_IShellItemImageFactory(iface);
 570     static const BITMAPINFOHEADER dummy_bmi_header = {
 571         .biSize = sizeof(dummy_bmi_header),
 572         .biWidth = 1,
 573         .biHeight = 1,
 574         .biPlanes = 1,
 575         .biBitCount = 32,
 576         .biCompression = BI_RGB
 577     };
 578     static int once;
 579
 580     if (!once++)
 581         FIXME("%p ({%lu, %lu} %d %p): stub\n", This, size.cx, size.cy, flags, phbm);
 582
 583     if (!(*phbm = CreateDIBSection(NULL, (const BITMAPINFO *)&dummy_bmi_header,
 584                                    DIB_RGB_COLORS, NULL, NULL, 0)))
 585     {
 586         return E_OUTOFMEMORY;
 587     }
 588
 589     return S_OK;
 590 }
 591
 592 static const IShellItemImageFactoryVtbl ShellItem_IShellItemImageFactory_Vtbl = {
 593     ShellItem_IShellItemImageFactory_QueryInterface,
 594     ShellItem_IShellItemImageFactory_AddRef,
 595     ShellItem_IShellItemImageFactory_Release,
 596     ShellItem_IShellItemImageFactory_GetImage,
 597 };
 598
 599
 600 HRESULT WINAPI IShellItem_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
 601 {
 602     struct shell_item *This;
 603     HRESULT ret;
 604
 605     TRACE("(%p,%s)\n",pUnkOuter, debugstr_guid(riid));
 606
 607     *ppv = NULL;
 608
 609     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 610
 611     This = malloc(sizeof(*This));
 612     This->IShellItem2_iface.lpVtbl = &ShellItem2_Vtbl;
 613     This->ref = 1;
 614     This->pidl = NULL;
 615     This->IPersistIDList_iface.lpVtbl = &ShellItem_IPersistIDList_Vtbl;
 616     This->IShellItemImageFactory_iface.lpVtbl = &ShellItem_IShellItemImageFactory_Vtbl;
 617
 618     ret = IShellItem2_QueryInterface(&This->IShellItem2_iface, riid, ppv);
 619     IShellItem2_Release(&This->IShellItem2_iface);
 620
 621     return ret;
 622 }
 623
 624 HRESULT WINAPI SHCreateShellItem(LPCITEMIDLIST pidlParent,
 625     IShellFolder *psfParent, LPCITEMIDLIST pidl, IShellItem **ppsi)
 626 {
 627     LPITEMIDLIST new_pidl;
 628     HRESULT ret;
 629
 630     TRACE("(%p,%p,%p,%p)\n", pidlParent, psfParent, pidl, ppsi);
 631
 632     *ppsi = NULL;
 633
 634     if (!pidl)
 635     {
 636         return E_INVALIDARG;
 637     }
 638     else if (pidlParent || psfParent)
 639     {
 640         LPITEMIDLIST temp_parent=NULL;
 641         if (!pidlParent)
 642         {
 643             IPersistFolder2* ppf2Parent;
 644
 645             if (FAILED(IShellFolder_QueryInterface(psfParent, &IID_IPersistFolder2, (void**)&ppf2Parent)))
 646             {
 647                 FIXME("couldn't get IPersistFolder2 interface of parent\n");
 648                 return E_NOINTERFACE;
 649             }
 650
 651             if (FAILED(IPersistFolder2_GetCurFolder(ppf2Parent, &temp_parent)))
 652             {
 653                 FIXME("couldn't get parent PIDL\n");
 654                 IPersistFolder2_Release(ppf2Parent);
 655                 return E_NOINTERFACE;
 656             }
 657
 658             pidlParent = temp_parent;
 659             IPersistFolder2_Release(ppf2Parent);
 660         }
 661
 662         new_pidl = ILCombine(pidlParent, pidl);
 663         ILFree(temp_parent);
 664
 665         if (!new_pidl)
 666             return E_OUTOFMEMORY;
 667     }
 668     else
 669     {
 670         new_pidl = ILClone(pidl);
 671         if (!new_pidl)
 672             return E_OUTOFMEMORY;
 673     }
 674
 675     ret = SHCreateItemFromIDList(new_pidl, &IID_IShellItem, (void**)ppsi);
 676     ILFree(new_pidl);
 677
 678     return ret;
 679 }
 680
 681 HRESULT WINAPI SHCreateItemFromParsingName(PCWSTR pszPath,
 682     IBindCtx *pbc, REFIID riid, void **ppv)
 683 {
 684     LPITEMIDLIST pidl;
 685     HRESULT ret;
 686
 687     *ppv = NULL;
 688
 689     ret = SHParseDisplayName(pszPath, pbc, &pidl, 0, NULL);
 690     if(SUCCEEDED(ret))
 691     {
 692         ret = SHCreateItemFromIDList(pidl, riid, ppv);
 693         ILFree(pidl);
 694     }
 695     return ret;
 696 }
 697
 698 HRESULT WINAPI SHCreateItemFromRelativeName(IShellItem *parent, PCWSTR name, IBindCtx *pbc,
 699                                             REFIID riid, void **ppv)
 700 {
 701     LPITEMIDLIST pidl_folder = NULL, pidl = NULL;
 702     IShellFolder *desktop = NULL, *folder = NULL;
 703     HRESULT hr;
 704
 705     TRACE("(%p, %s, %p, %s, %p)\n", parent, wine_dbgstr_w(name), pbc, debugstr_guid(riid), ppv);
 706
 707     if(!ppv)
 708         return E_INVALIDARG;
 709     *ppv = NULL;
 710     if(!name)
 711         return E_INVALIDARG;
 712
 713     hr = SHGetIDListFromObject((IUnknown*)parent, &pidl_folder);
 714     if(hr != S_OK)
 715         return hr;
 716
 717     hr = SHGetDesktopFolder(&desktop);
 718     if(hr != S_OK)
 719         goto cleanup;
 720
 721     if(!_ILIsDesktop(pidl_folder))
 722     {
 723         hr = IShellFolder_BindToObject(desktop, pidl_folder, NULL, &IID_IShellFolder,
 724                                        (void**)&folder);
 725         if(hr != S_OK)
 726             goto cleanup;
 727     }
 728
 729     hr = IShellFolder_ParseDisplayName(folder ? folder : desktop, NULL, pbc, (LPWSTR)name,
 730                                        NULL, &pidl, NULL);
 731     if(hr != S_OK)
 732         goto cleanup;
 733     hr = SHCreateItemFromIDList(pidl, riid, ppv);
 734
 735 cleanup:
 736     if(pidl_folder)
 737         ILFree(pidl_folder);
 738     if(pidl)
 739         ILFree(pidl);
 740     if(desktop)
 741         IShellFolder_Release(desktop);
 742     if(folder)
 743         IShellFolder_Release(folder);
 744     return hr;
 745 }
 746
 747 HRESULT WINAPI SHCreateItemFromIDList(PCIDLIST_ABSOLUTE pidl, REFIID riid, void **ppv)
 748 {
 749     IPersistIDList *persist;
 750     HRESULT ret;
 751
 752     if(!pidl)
 753         return E_INVALIDARG;
 754
 755     *ppv = NULL;
 756     ret = IShellItem_Constructor(NULL, &IID_IPersistIDList, (void**)&persist);
 757     if(FAILED(ret))
 758         return ret;
 759
 760     ret = IPersistIDList_SetIDList(persist, pidl);
 761     if(FAILED(ret))
 762     {
 763         IPersistIDList_Release(persist);
 764         return ret;
 765     }
 766
 767     ret = IPersistIDList_QueryInterface(persist, riid, ppv);
 768     IPersistIDList_Release(persist);
 769     return ret;
 770 }
 771
 772 HRESULT WINAPI SHCreateItemWithParent(PCIDLIST_ABSOLUTE pidl_parent, IShellFolder *psf,
 773                                 PCUITEMID_CHILD pidl, REFIID riid, void **ppv)
 774 {
 775     FIXME("(%p, %p, %p, %s, %p)\n", pidl_parent, psf, pidl, debugstr_guid(riid), ppv);
 776
 777     return E_NOTIMPL;
 778 }
 779
 780 HRESULT WINAPI SHCreateItemInKnownFolder(REFKNOWNFOLDERID rfid, DWORD flags,
 781                                          PCWSTR filename, REFIID riid, void **ppv)
 782 {
 783     HRESULT hr;
 784     IShellItem *parent = NULL;
 785     LPITEMIDLIST pidl = NULL;
 786
 787     TRACE("(%p, %lx, %s, %s, %p)\n", rfid, flags, wine_dbgstr_w(filename),
 788           debugstr_guid(riid), ppv);
 789
 790     if(!rfid || !ppv)
 791         return E_INVALIDARG;
 792
 793     *ppv = NULL;
 794     hr = SHGetKnownFolderIDList(rfid, flags, NULL, &pidl);
 795     if(hr != S_OK)
 796         return hr;
 797
 798     hr = SHCreateItemFromIDList(pidl, &IID_IShellItem, (void**)&parent);
 799     if(hr != S_OK)
 800     {
 801         ILFree(pidl);
 802         return hr;
 803     }
 804
 805     if(filename)
 806         hr = SHCreateItemFromRelativeName(parent, filename, NULL, riid, ppv);
 807     else
 808         hr = IShellItem_QueryInterface(parent, riid, ppv);
 809
 810     ILFree(pidl);
 811     IShellItem_Release(parent);
 812     return hr;
 813 }
 814
 815 HRESULT WINAPI SHGetItemFromDataObject(IDataObject *pdtobj,
 816     DATAOBJ_GET_ITEM_FLAGS dwFlags, REFIID riid, void **ppv)
 817 {
 818     FORMATETC fmt;
 819     STGMEDIUM medium;
 820     HRESULT ret;
 821
 822     TRACE("%p, %x, %s, %p\n", pdtobj, dwFlags, debugstr_guid(riid), ppv);
 823
 824     if(!pdtobj)
 825         return E_INVALIDARG;
 826
 827     fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
 828     fmt.ptd = NULL;
 829     fmt.dwAspect = DVASPECT_CONTENT;
 830     fmt.lindex = -1;
 831     fmt.tymed = TYMED_HGLOBAL;
 832
 833     ret = IDataObject_GetData(pdtobj, &fmt, &medium);
 834     if(SUCCEEDED(ret))
 835     {
 836         LPIDA pida = GlobalLock(medium.hGlobal);
 837
 838         if((pida->cidl > 1 && !(dwFlags & DOGIF_ONLY_IF_ONE)) ||
 839            pida->cidl == 1)
 840         {
 841             LPITEMIDLIST pidl;
 842
 843             /* Get the first pidl (parent + child1) */
 844             pidl = ILCombine((LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]),
 845                              (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]));
 846
 847             ret = SHCreateItemFromIDList(pidl, riid, ppv);
 848             ILFree(pidl);
 849         }
 850         else
 851         {
 852             ret = E_FAIL;
 853         }
 854
 855         GlobalUnlock(medium.hGlobal);
 856         GlobalFree(medium.hGlobal);
 857     }
 858
 859     if(FAILED(ret) && !(dwFlags & DOGIF_NO_HDROP))
 860     {
 861         TRACE("Attempting to fall back on CF_HDROP.\n");
 862
 863         fmt.cfFormat = CF_HDROP;
 864         fmt.ptd = NULL;
 865         fmt.dwAspect = DVASPECT_CONTENT;
 866         fmt.lindex = -1;
 867         fmt.tymed = TYMED_HGLOBAL;
 868
 869         ret = IDataObject_GetData(pdtobj, &fmt, &medium);
 870         if(SUCCEEDED(ret))
 871         {
 872             DROPFILES *df = GlobalLock(medium.hGlobal);
 873             LPBYTE files = (LPBYTE)df + df->pFiles;
 874             BOOL multiple_files = FALSE;
 875
 876             ret = E_FAIL;
 877             if(!df->fWide)
 878             {
 879                 WCHAR filename[MAX_PATH];
 880                 PCSTR first_file = (PCSTR)files;
 881                 if(*(files + lstrlenA(first_file) + 1) != 0)
 882                     multiple_files = TRUE;
 883
 884                 if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) )
 885                 {
 886                     MultiByteToWideChar(CP_ACP, 0, first_file, -1, filename, MAX_PATH);
 887                     ret = SHCreateItemFromParsingName(filename, NULL, riid, ppv);
 888                 }
 889             }
 890             else
 891             {
 892                 PCWSTR first_file = (PCWSTR)files;
 893                 if(*((PCWSTR)files + lstrlenW(first_file) + 1) != 0)
 894                     multiple_files = TRUE;
 895
 896                 if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) )
 897                     ret = SHCreateItemFromParsingName(first_file, NULL, riid, ppv);
 898             }
 899
 900             GlobalUnlock(medium.hGlobal);
 901             GlobalFree(medium.hGlobal);
 902         }
 903     }
 904
 905     if(FAILED(ret) && !(dwFlags & DOGIF_NO_URL))
 906     {
 907         FIXME("Failed to create item, should try CF_URL.\n");
 908     }
 909
 910     return ret;
 911 }
 912
 913 HRESULT WINAPI SHGetItemFromObject(IUnknown *punk, REFIID riid, void **ppv)
 914 {
 915     LPITEMIDLIST pidl;
 916     HRESULT ret;
 917
 918     ret = SHGetIDListFromObject(punk, &pidl);
 919     if(SUCCEEDED(ret))
 920     {
 921         ret = SHCreateItemFromIDList(pidl, riid, ppv);
 922         ILFree(pidl);
 923     }
 924
 925     return ret;
 926 }
 927
 928 /*************************************************************************
 929  * IEnumShellItems implementation
 930  */
 931 typedef struct {
 932     IEnumShellItems IEnumShellItems_iface;
 933     LONG ref;
 934
 935     IShellItemArray *array;
 936     DWORD count;
 937     DWORD position;
 938 } IEnumShellItemsImpl;
 939
 940 static inline IEnumShellItemsImpl *impl_from_IEnumShellItems(IEnumShellItems *iface)
 941 {
 942     return CONTAINING_RECORD(iface, IEnumShellItemsImpl, IEnumShellItems_iface);
 943 }
 944
 945 static HRESULT WINAPI IEnumShellItems_fnQueryInterface(IEnumShellItems *iface,
 946                                                        REFIID riid,
 947                                                        void **ppvObject)
 948 {
 949     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 950     TRACE("%p (%s, %p)\n", This, shdebugstr_guid(riid), ppvObject);
 951
 952     *ppvObject = NULL;
 953     if(IsEqualIID(riid, &IID_IEnumShellItems) ||
 954        IsEqualIID(riid, &IID_IUnknown))
 955     {
 956         *ppvObject = &This->IEnumShellItems_iface;
 957     }
 958
 959     if(*ppvObject)
 960     {
 961         IUnknown_AddRef((IUnknown*)*ppvObject);
 962         return S_OK;
 963     }
 964
 965     return E_NOINTERFACE;
 966 }
 967
 968 static ULONG WINAPI IEnumShellItems_fnAddRef(IEnumShellItems *iface)
 969 {
 970     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 971     LONG ref = InterlockedIncrement(&This->ref);
 972     TRACE("%p - ref %ld\n", This, ref);
 973
 974     return ref;
 975 }
 976
 977 static ULONG WINAPI IEnumShellItems_fnRelease(IEnumShellItems *iface)
 978 {
 979     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 980     LONG ref = InterlockedDecrement(&This->ref);
 981     TRACE("%p - ref %ld\n", This, ref);
 982
 983     if(!ref)
 984     {
 985         TRACE("Freeing.\n");
 986         IShellItemArray_Release(This->array);
 987         free(This);
 988         return 0;
 989     }
 990
 991     return ref;
 992 }
 993
 994 static HRESULT WINAPI IEnumShellItems_fnNext(IEnumShellItems* iface,
 995                                              ULONG celt,
 996                                              IShellItem **rgelt,
 997                                              ULONG *pceltFetched)
 998 {
 999     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
1000     HRESULT hr = S_FALSE;
1001     UINT i;
1002     ULONG fetched = 0;
1003     TRACE("%p (%ld %p %p)\n", This, celt, rgelt, pceltFetched);
1004
1005     if(pceltFetched == NULL && celt != 1)
1006         return E_INVALIDARG;
1007
1008     for(i = This->position; fetched < celt && i < This->count; i++) {
1009         hr = IShellItemArray_GetItemAt(This->array, i, &rgelt[fetched]);
1010         if(FAILED(hr))
1011             break;
1012         fetched++;
1013         This->position++;
1014     }
1015
1016     if(SUCCEEDED(hr))
1017     {
1018         if(pceltFetched != NULL)
1019             *pceltFetched = fetched;
1020
1021         if(fetched > 0)
1022             return S_OK;
1023
1024         return S_FALSE;
1025     }
1026
1027     return hr;
1028 }
1029
1030 static HRESULT WINAPI IEnumShellItems_fnSkip(IEnumShellItems* iface, ULONG celt)
1031 {
1032     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
1033     TRACE("%p (%ld)\n", This, celt);
1034
1035     This->position = min(This->position + celt, This->count-1);
1036
1037     return S_OK;
1038 }
1039
1040 static HRESULT WINAPI IEnumShellItems_fnReset(IEnumShellItems* iface)
1041 {
1042     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
1043     TRACE("%p\n", This);
1044
1045     This->position = 0;
1046
1047     return S_OK;
1048 }
1049
1050 static HRESULT WINAPI IEnumShellItems_fnClone(IEnumShellItems* iface, IEnumShellItems **ppenum)
1051 {
1052     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
1053     TRACE("%p (%p)\n", This, ppenum);
1054
1055     /* Not implemented anywhere */
1056     *ppenum = NULL;
1057
1058     return E_NOTIMPL;
1059 }
1060
1061 static const IEnumShellItemsVtbl vt_IEnumShellItems = {
1062     IEnumShellItems_fnQueryInterface,
1063     IEnumShellItems_fnAddRef,
1064     IEnumShellItems_fnRelease,
1065     IEnumShellItems_fnNext,
1066     IEnumShellItems_fnSkip,
1067     IEnumShellItems_fnReset,
1068     IEnumShellItems_fnClone
1069 };
1070
1071 static HRESULT IEnumShellItems_Constructor(IShellItemArray *array, IEnumShellItems **ppesi)
1072 {
1073     IEnumShellItemsImpl *This;
1074     HRESULT ret;
1075
1076     This = malloc(sizeof(*This));
1077     if(!This)
1078         return E_OUTOFMEMORY;
1079
1080     This->ref = 1;
1081     This->IEnumShellItems_iface.lpVtbl = &vt_IEnumShellItems;
1082     This->array = array;
1083     This->position = 0;
1084
1085     IShellItemArray_AddRef(This->array);
1086     IShellItemArray_GetCount(This->array, &This->count);
1087
1088     ret = IEnumShellItems_QueryInterface(&This->IEnumShellItems_iface, &IID_IEnumShellItems, (void**)ppesi);
1089     IEnumShellItems_Release(&This->IEnumShellItems_iface);
1090
1091     return ret;
1092 }
1093
1094
1095 /*************************************************************************
1096  * IShellItemArray implementation
1097  */
1098 typedef struct {
1099     IShellItemArray IShellItemArray_iface;
1100     LONG ref;
1101
1102     IShellItem **array;
1103     DWORD item_count;
1104 } IShellItemArrayImpl;
1105
1106 static inline IShellItemArrayImpl *impl_from_IShellItemArray(IShellItemArray *iface)
1107 {
1108     return CONTAINING_RECORD(iface, IShellItemArrayImpl, IShellItemArray_iface);
1109 }
1110
1111 static HRESULT WINAPI IShellItemArray_fnQueryInterface(IShellItemArray *iface,
1112                                                        REFIID riid,
1113                                                        void **ppvObject)
1114 {
1115     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1116     TRACE("%p (%s, %p)\n", This, shdebugstr_guid(riid), ppvObject);
1117
1118     *ppvObject = NULL;
1119     if(IsEqualIID(riid, &IID_IShellItemArray) ||
1120        IsEqualIID(riid, &IID_IUnknown))
1121     {
1122         *ppvObject = &This->IShellItemArray_iface;
1123     }
1124
1125     if(*ppvObject)
1126     {
1127         IUnknown_AddRef((IUnknown*)*ppvObject);
1128         return S_OK;
1129     }
1130
1131     return E_NOINTERFACE;
1132 }
1133
1134 static ULONG WINAPI IShellItemArray_fnAddRef(IShellItemArray *iface)
1135 {
1136     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1137     LONG ref = InterlockedIncrement(&This->ref);
1138     TRACE("%p - ref %ld\n", This, ref);
1139
1140     return ref;
1141 }
1142
1143 static ULONG WINAPI IShellItemArray_fnRelease(IShellItemArray *iface)
1144 {
1145     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1146     LONG ref = InterlockedDecrement(&This->ref);
1147     TRACE("%p - ref %ld\n", This, ref);
1148
1149     if(!ref)
1150     {
1151         UINT i;
1152         TRACE("Freeing.\n");
1153
1154         for(i = 0; i < This->item_count; i++)
1155             IShellItem_Release(This->array[i]);
1156
1157         free(This->array);
1158         free(This);
1159         return 0;
1160     }
1161
1162     return ref;
1163 }
1164
1165 static HRESULT WINAPI IShellItemArray_fnBindToHandler(IShellItemArray *iface,
1166                                                       IBindCtx *pbc,
1167                                                       REFGUID bhid,
1168                                                       REFIID riid,
1169                                                       void **ppvOut)
1170 {
1171     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1172     FIXME("Stub: %p (%p, %s, %s, %p)\n",
1173           This, pbc, shdebugstr_guid(bhid), shdebugstr_guid(riid), ppvOut);
1174
1175     return E_NOTIMPL;
1176 }
1177
1178 static HRESULT WINAPI IShellItemArray_fnGetPropertyStore(IShellItemArray *iface,
1179                                                          GETPROPERTYSTOREFLAGS flags,
1180                                                          REFIID riid,
1181                                                          void **ppv)
1182 {
1183     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1184     FIXME("Stub: %p (%x, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv);
1185
1186     return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI IShellItemArray_fnGetPropertyDescriptionList(IShellItemArray *iface,
1190                                                                    REFPROPERTYKEY keyType,
1191                                                                    REFIID riid,
1192                                                                    void **ppv)
1193 {
1194     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1195     FIXME("Stub: %p (%p, %s, %p)\n",
1196           This, keyType, shdebugstr_guid(riid), ppv);
1197
1198     return E_NOTIMPL;
1199 }
1200
1201 static HRESULT WINAPI IShellItemArray_fnGetAttributes(IShellItemArray *iface,
1202                                                       SIATTRIBFLAGS AttribFlags,
1203                                                       SFGAOF sfgaoMask,
1204                                                       SFGAOF *psfgaoAttribs)
1205 {
1206     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1207     HRESULT hr = S_OK;
1208     SFGAOF attr;
1209     UINT i;
1210     TRACE("%p (%x, %lx, %p)\n", This, AttribFlags, sfgaoMask, psfgaoAttribs);
1211
1212     if(AttribFlags & ~(SIATTRIBFLAGS_AND|SIATTRIBFLAGS_OR))
1213         FIXME("%08x contains unsupported attribution flags\n", AttribFlags);
1214
1215     for(i = 0; i < This->item_count; i++)
1216     {
1217         hr = IShellItem_GetAttributes(This->array[i], sfgaoMask, &attr);
1218         if(FAILED(hr))
1219             break;
1220
1221         if(i == 0)
1222         {
1223             *psfgaoAttribs = attr;
1224             continue;
1225         }
1226
1227         switch(AttribFlags & SIATTRIBFLAGS_MASK)
1228         {
1229         case SIATTRIBFLAGS_AND:
1230             *psfgaoAttribs &= attr;
1231             break;
1232         case SIATTRIBFLAGS_OR:
1233             *psfgaoAttribs |= attr;
1234             break;
1235         }
1236     }
1237
1238     if(SUCCEEDED(hr))
1239     {
1240         if(*psfgaoAttribs == sfgaoMask)
1241             return S_OK;
1242
1243         return S_FALSE;
1244     }
1245
1246     return hr;
1247 }
1248
1249 static HRESULT WINAPI IShellItemArray_fnGetCount(IShellItemArray *iface,
1250                                                  DWORD *pdwNumItems)
1251 {
1252     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1253     TRACE("%p (%p)\n", This, pdwNumItems);
1254
1255     *pdwNumItems = This->item_count;
1256
1257     return S_OK;
1258 }
1259
1260 static HRESULT WINAPI IShellItemArray_fnGetItemAt(IShellItemArray *iface,
1261                                                   DWORD dwIndex,
1262                                                   IShellItem **ppsi)
1263 {
1264     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1265     TRACE("%p (%lx, %p)\n", This, dwIndex, ppsi);
1266
1267     /* zero indexed */
1268     if(dwIndex + 1 > This->item_count)
1269         return E_FAIL;
1270
1271     *ppsi = This->array[dwIndex];
1272     IShellItem_AddRef(*ppsi);
1273
1274     return S_OK;
1275 }
1276
1277 static HRESULT WINAPI IShellItemArray_fnEnumItems(IShellItemArray *iface,
1278                                                   IEnumShellItems **ppenumShellItems)
1279 {
1280     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1281     TRACE("%p (%p)\n", This, ppenumShellItems);
1282     return IEnumShellItems_Constructor(iface, ppenumShellItems);
1283 }
1284
1285 static const IShellItemArrayVtbl vt_IShellItemArray = {
1286     IShellItemArray_fnQueryInterface,
1287     IShellItemArray_fnAddRef,
1288     IShellItemArray_fnRelease,
1289     IShellItemArray_fnBindToHandler,
1290     IShellItemArray_fnGetPropertyStore,
1291     IShellItemArray_fnGetPropertyDescriptionList,
1292     IShellItemArray_fnGetAttributes,
1293     IShellItemArray_fnGetCount,
1294     IShellItemArray_fnGetItemAt,
1295     IShellItemArray_fnEnumItems
1296 };
1297
1298 /* Caller is responsible to AddRef all items */
1299 static HRESULT create_shellitemarray(IShellItem **items, DWORD count, IShellItemArray **ret)
1300 {
1301     IShellItemArrayImpl *This;
1302
1303     TRACE("(%p, %ld, %p)\n", items, count, ret);
1304
1305     This = malloc(sizeof(*This));
1306     if(!This)
1307         return E_OUTOFMEMORY;
1308
1309     This->IShellItemArray_iface.lpVtbl = &vt_IShellItemArray;
1310     This->ref = 1;
1311
1312     This->array = malloc(count * sizeof(IShellItem*));
1313     if (!This->array)
1314     {
1315         free(This);
1316         return E_OUTOFMEMORY;
1317     }
1318     memcpy(This->array, items, count*sizeof(IShellItem*));
1319     This->item_count = count;
1320
1321     *ret = &This->IShellItemArray_iface;
1322     return S_OK;
1323 }
1324
1325 HRESULT WINAPI SHCreateShellItemArray(PCIDLIST_ABSOLUTE pidlParent,
1326                                       IShellFolder *psf,
1327                                       UINT cidl,
1328                                       PCUITEMID_CHILD_ARRAY ppidl,
1329                                       IShellItemArray **ppsiItemArray)
1330 {
1331     IShellItem **array;
1332     HRESULT ret = E_FAIL;
1333     UINT i;
1334
1335     TRACE("%p, %p, %d, %p, %p\n", pidlParent, psf, cidl, ppidl, ppsiItemArray);
1336
1337     *ppsiItemArray = NULL;
1338
1339     if(!pidlParent && !psf)
1340         return E_POINTER;
1341
1342     if(!ppidl)
1343         return E_INVALIDARG;
1344
1345     array = calloc(cidl, sizeof(IShellItem*));
1346     if(!array)
1347         return E_OUTOFMEMORY;
1348
1349     for(i = 0; i < cidl; i++)
1350     {
1351         ret = SHCreateShellItem(pidlParent, psf, ppidl[i], &array[i]);
1352         if(FAILED(ret)) break;
1353     }
1354
1355     if(SUCCEEDED(ret))
1356     {
1357         ret = create_shellitemarray(array, cidl, ppsiItemArray);
1358     }
1359
1360     if(FAILED(ret))
1361     {
1362         for(i = 0; i < cidl; i++)
1363             if(array[i]) IShellItem_Release(array[i]);
1364     }
1365     free(array);
1366     return ret;
1367 }
1368
1369 HRESULT WINAPI SHCreateShellItemArrayFromShellItem(IShellItem *item, REFIID riid, void **ppv)
1370 {
1371     IShellItemArray *array;
1372     HRESULT ret;
1373
1374     TRACE("%p, %s, %p\n", item, shdebugstr_guid(riid), ppv);
1375
1376     *ppv = NULL;
1377
1378     IShellItem_AddRef(item);
1379     ret = create_shellitemarray(&item, 1, &array);
1380     if(FAILED(ret))
1381     {
1382         IShellItem_Release(item);
1383         return ret;
1384     }
1385
1386     ret = IShellItemArray_QueryInterface(array, riid, ppv);
1387     IShellItemArray_Release(array);
1388     return ret;
1389 }
1390
1391 HRESULT WINAPI SHCreateShellItemArrayFromDataObject(IDataObject *pdo, REFIID riid, void **ppv)
1392 {
1393     IShellItemArray *psia;
1394     FORMATETC fmt;
1395     STGMEDIUM medium;
1396     HRESULT ret;
1397
1398     TRACE("%p, %s, %p\n", pdo, shdebugstr_guid(riid), ppv);
1399
1400     if(!pdo)
1401         return E_INVALIDARG;
1402
1403     *ppv = NULL;
1404
1405     fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
1406     fmt.ptd = NULL;
1407     fmt.dwAspect = DVASPECT_CONTENT;
1408     fmt.lindex = -1;
1409     fmt.tymed = TYMED_HGLOBAL;
1410
1411     ret = IDataObject_GetData(pdo, &fmt, &medium);
1412     if(SUCCEEDED(ret))
1413     {
1414         LPIDA pida = GlobalLock(medium.hGlobal);
1415         LPCITEMIDLIST parent_pidl;
1416         LPCITEMIDLIST *children;
1417         UINT i;
1418         TRACE("Converting %d objects.\n", pida->cidl);
1419
1420         parent_pidl = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
1421
1422         children = malloc(sizeof(const ITEMIDLIST*) * pida->cidl);
1423         for(i = 0; i < pida->cidl; i++)
1424             children[i] = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[i+1]);
1425
1426         ret = SHCreateShellItemArray(parent_pidl, NULL, pida->cidl, children, &psia);
1427
1428         free(children);
1429
1430         GlobalUnlock(medium.hGlobal);
1431         GlobalFree(medium.hGlobal);
1432     }
1433
1434     if(SUCCEEDED(ret))
1435     {
1436         ret = IShellItemArray_QueryInterface(psia, riid, ppv);
1437         IShellItemArray_Release(psia);
1438     }
1439
1440     return ret;
1441 }
1442
1443 HRESULT WINAPI SHCreateShellItemArrayFromIDLists(UINT cidl,
1444                                                  PCIDLIST_ABSOLUTE_ARRAY pidl_array,
1445                                                  IShellItemArray **psia)
1446 {
1447     IShellItem **array;
1448     HRESULT ret;
1449     UINT i;
1450     TRACE("%d, %p, %p\n", cidl, pidl_array, psia);
1451
1452     *psia = NULL;
1453
1454     if(cidl == 0)
1455         return E_INVALIDARG;
1456
1457     array = calloc(cidl, sizeof(IShellItem*));
1458     if(!array)
1459         return E_OUTOFMEMORY;
1460
1461     for(i = 0; i < cidl; i++)
1462     {
1463         ret = SHCreateShellItem(NULL, NULL, pidl_array[i], &array[i]);
1464         if(FAILED(ret))
1465             break;
1466     }
1467
1468     if(SUCCEEDED(ret))
1469     {
1470         ret = create_shellitemarray(array, cidl, psia);
1471     }
1472
1473     if(FAILED(ret))
1474     {
1475         for(i = 0; i < cidl; i++)
1476             if(array[i]) IShellItem_Release(array[i]);
1477         *psia = NULL;
1478     }
1479     free(array);
1480     return ret;
1481 }
1482
1483 HRESULT WINAPI SHGetPropertyStoreFromParsingName(const WCHAR *path, IBindCtx *pbc, GETPROPERTYSTOREFLAGS flags,
1484     REFIID riid, void **ppv)
1485 {
1486     IShellItem2 *item;
1487     HRESULT hr;
1488
1489     TRACE("(%s %p %#x %p %p)\n", debugstr_w(path), pbc, flags, riid, ppv);
1490
1491     hr = SHCreateItemFromParsingName(path, pbc, &IID_IShellItem2, (void **)&item);
1492     if(SUCCEEDED(hr))
1493     {
1494         hr = IShellItem2_GetPropertyStore(item, flags, riid, ppv);
1495         IShellItem2_Release(item);
1496     }
1497
1498     return hr;
1499 }
1500
1501 static HRESULT WINAPI CustomDestinationList_QueryInterface(ICustomDestinationList *iface, REFIID riid, void **obj)
1502 {
1503     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1504
1505     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), obj);
1506
1507     if (IsEqualIID(&IID_ICustomDestinationList, riid) || IsEqualIID(&IID_IUnknown, riid))
1508     {
1509         *obj = &This->ICustomDestinationList_iface;
1510     }
1511     else {
1512         WARN("Unsupported interface %s.\n", shdebugstr_guid(riid));
1513         *obj = NULL;
1514         return E_NOINTERFACE;
1515     }
1516
1517     IUnknown_AddRef((IUnknown*)*obj);
1518     return S_OK;
1519 }
1520
1521 static ULONG WINAPI CustomDestinationList_AddRef(ICustomDestinationList *iface)
1522 {
1523     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1524     ULONG ref = InterlockedIncrement(&This->ref);
1525
1526     TRACE("(%p), new refcount=%li\n", This, ref);
1527
1528     return ref;
1529 }
1530
1531 static ULONG WINAPI CustomDestinationList_Release(ICustomDestinationList *iface)
1532 {
1533     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1534     ULONG ref = InterlockedDecrement(&This->ref);
1535
1536     TRACE("(%p), new refcount=%li\n", This, ref);
1537
1538     if (ref == 0)
1539         free(This);
1540
1541     return ref;
1542 }
1543
1544 static HRESULT WINAPI CustomDestinationList_SetAppID(ICustomDestinationList *iface, const WCHAR *appid)
1545 {
1546     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1547
1548     FIXME("%p (%s): stub\n", This, debugstr_w(appid));
1549
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI CustomDestinationList_BeginList(ICustomDestinationList *iface, UINT *min_slots, REFIID riid, void **obj)
1554 {
1555     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1556
1557     FIXME("%p (%p %s %p): stub\n", This, min_slots, debugstr_guid(riid), obj);
1558
1559     return E_NOTIMPL;
1560 }
1561
1562 static HRESULT WINAPI CustomDestinationList_AppendCategory(ICustomDestinationList *iface, const WCHAR *category, IObjectArray *array)
1563 {
1564     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1565
1566     FIXME("%p (%s %p): stub\n", This, debugstr_w(category), array);
1567
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI CustomDestinationList_AppendKnownCategory(ICustomDestinationList *iface, KNOWNDESTCATEGORY category)
1572 {
1573     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1574
1575     FIXME("%p (%d): stub\n", This, category);
1576
1577     return E_NOTIMPL;
1578 }
1579
1580 static HRESULT WINAPI CustomDestinationList_AddUserTasks(ICustomDestinationList *iface, IObjectArray *tasks)
1581 {
1582     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1583
1584     FIXME("%p (%p): stub\n", This, tasks);
1585
1586     return E_NOTIMPL;
1587 }
1588
1589 static HRESULT WINAPI CustomDestinationList_CommitList(ICustomDestinationList *iface)
1590 {
1591     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1592
1593     FIXME("%p: stub\n", This);
1594
1595     return E_NOTIMPL;
1596 }
1597
1598 static HRESULT WINAPI CustomDestinationList_GetRemovedDestinations(ICustomDestinationList *iface, REFIID riid, void **obj)
1599 {
1600     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1601
1602     FIXME("%p (%s %p): stub\n", This, debugstr_guid(riid), obj);
1603
1604     return E_NOTIMPL;
1605 }
1606
1607 static HRESULT WINAPI CustomDestinationList_DeleteList(ICustomDestinationList *iface, const WCHAR *appid)
1608 {
1609     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1610
1611     FIXME("%p (%s): stub\n", This, debugstr_w(appid));
1612
1613     return E_NOTIMPL;
1614 }
1615
1616 static HRESULT WINAPI CustomDestinationList_AbortList(ICustomDestinationList *iface)
1617 {
1618     CustomDestinationList *This = impl_from_ICustomDestinationList(iface);
1619
1620     FIXME("%p: stub\n", This);
1621
1622     return E_NOTIMPL;
1623 }
1624
1625 static const ICustomDestinationListVtbl CustomDestinationListVtbl =
1626 {
1627     CustomDestinationList_QueryInterface,
1628     CustomDestinationList_AddRef,
1629     CustomDestinationList_Release,
1630     CustomDestinationList_SetAppID,
1631     CustomDestinationList_BeginList,
1632     CustomDestinationList_AppendCategory,
1633     CustomDestinationList_AppendKnownCategory,
1634     CustomDestinationList_AddUserTasks,
1635     CustomDestinationList_CommitList,
1636     CustomDestinationList_GetRemovedDestinations,
1637     CustomDestinationList_DeleteList,
1638     CustomDestinationList_AbortList
1639 };
1640
1641 HRESULT WINAPI CustomDestinationList_Constructor(IUnknown *outer, REFIID riid, void **obj)
1642 {
1643     CustomDestinationList *list;
1644     HRESULT hr;
1645
1646     TRACE("%p %s %p\n", outer, debugstr_guid(riid), obj);
1647
1648     if (outer)
1649         return CLASS_E_NOAGGREGATION;
1650
1651     if(!(list = malloc(sizeof(*list))))
1652         return E_OUTOFMEMORY;
1653
1654     list->ICustomDestinationList_iface.lpVtbl = &CustomDestinationListVtbl;
1655     list->ref = 1;
1656
1657     hr = ICustomDestinationList_QueryInterface(&list->ICustomDestinationList_iface, riid, obj);
1658     ICustomDestinationList_Release(&list->ICustomDestinationList_iface);
1659     return hr;
1660 }
1661
1662 HRESULT WINAPI SHSetTemporaryPropertyForItem(IShellItem *psi, REFPROPERTYKEY propkey, REFPROPVARIANT propvar)
1663 {
1664     FIXME("%p %p %p: stub\n", psi, propkey, propvar);
1665
1666     return E_NOTIMPL;
1667 }