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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26
  27 #define COBJMACROS
  28 #define NONAMELESSUNION
  29 #define NONAMELESSSTRUCT
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wine/debug.h"
  34
  35 #include "pidl.h"
  36 #include "shell32_main.h"
  37 #include "debughlp.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  40
  41 typedef struct _ShellItem {
  42     IShellItem2             IShellItem2_iface;
  43     LONG                    ref;
  44     LPITEMIDLIST            pidl;
  45     IPersistIDList          IPersistIDList_iface;
  46 } ShellItem;
  47
  48 static inline ShellItem *impl_from_IShellItem2(IShellItem2 *iface)
  49 {
  50     return CONTAINING_RECORD(iface, ShellItem, IShellItem2_iface);
  51 }
  52
  53
  54 static inline ShellItem *impl_from_IPersistIDList( IPersistIDList *iface )
  55 {
  56     return CONTAINING_RECORD(iface, ShellItem, IPersistIDList_iface);
  57 }
  58
  59
  60 static HRESULT WINAPI ShellItem_QueryInterface(IShellItem2 *iface, REFIID riid,
  61     void **ppv)
  62 {
  63     ShellItem *This = impl_from_IShellItem2(iface);
  64
  65     TRACE("(%p,%p,%p)\n", iface, riid, ppv);
  66
  67     if (!ppv) return E_INVALIDARG;
  68
  69     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IShellItem, riid) ||
  70         IsEqualIID(&IID_IShellItem2, riid))
  71     {
  72         *ppv = &This->IShellItem2_iface;
  73     }
  74     else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistIDList, riid))
  75     {
  76         *ppv = &This->IPersistIDList_iface;
  77     }
  78     else {
  79         FIXME("not implemented for %s\n", shdebugstr_guid(riid));
  80         *ppv = NULL;
  81         return E_NOINTERFACE;
  82     }
  83
  84     IUnknown_AddRef((IUnknown*)*ppv);
  85     return S_OK;
  86 }
  87
  88 static ULONG WINAPI ShellItem_AddRef(IShellItem2 *iface)
  89 {
  90     ShellItem *This = impl_from_IShellItem2(iface);
  91     ULONG ref = InterlockedIncrement(&This->ref);
  92
  93     TRACE("(%p), new refcount=%i\n", iface, ref);
  94
  95     return ref;
  96 }
  97
  98 static ULONG WINAPI ShellItem_Release(IShellItem2 *iface)
  99 {
 100     ShellItem *This = impl_from_IShellItem2(iface);
 101     ULONG ref = InterlockedDecrement(&This->ref);
 102
 103     TRACE("(%p), new refcount=%i\n", iface, ref);
 104
 105     if (ref == 0)
 106     {
 107         ILFree(This->pidl);
 108         HeapFree(GetProcessHeap(), 0, This);
 109     }
 110
 111     return ref;
 112 }
 113
 114 static HRESULT ShellItem_get_parent_pidl(ShellItem *This, LPITEMIDLIST *parent_pidl)
 115 {
 116     *parent_pidl = ILClone(This->pidl);
 117     if (*parent_pidl)
 118     {
 119         if (ILRemoveLastID(*parent_pidl))
 120             return S_OK;
 121         else
 122         {
 123             ILFree(*parent_pidl);
 124             *parent_pidl = NULL;
 125             return E_INVALIDARG;
 126         }
 127     }
 128     else
 129     {
 130         *parent_pidl = NULL;
 131         return E_OUTOFMEMORY;
 132     }
 133 }
 134
 135 static HRESULT ShellItem_get_parent_shellfolder(ShellItem *This, IShellFolder **ppsf)
 136 {
 137     LPITEMIDLIST parent_pidl;
 138     IShellFolder *desktop;
 139     HRESULT ret;
 140
 141     ret = ShellItem_get_parent_pidl(This, &parent_pidl);
 142     if (SUCCEEDED(ret))
 143     {
 144         ret = SHGetDesktopFolder(&desktop);
 145         if (SUCCEEDED(ret))
 146         {
 147             ret = IShellFolder_BindToObject(desktop, parent_pidl, NULL, &IID_IShellFolder, (void**)ppsf);
 148             IShellFolder_Release(desktop);
 149         }
 150         ILFree(parent_pidl);
 151     }
 152
 153     return ret;
 154 }
 155
 156 static HRESULT ShellItem_get_shellfolder(ShellItem *This, IBindCtx *pbc, IShellFolder **ppsf)
 157 {
 158     IShellFolder *desktop;
 159     HRESULT ret;
 160
 161     ret = SHGetDesktopFolder(&desktop);
 162     if (SUCCEEDED(ret))
 163     {
 164         if (_ILIsDesktop(This->pidl))
 165         {
 166             *ppsf = desktop;
 167             IShellFolder_AddRef(*ppsf);
 168         }
 169         else
 170         {
 171             ret = IShellFolder_BindToObject(desktop, This->pidl, pbc, &IID_IShellFolder, (void**)ppsf);
 172         }
 173
 174         IShellFolder_Release(desktop);
 175     }
 176
 177     return ret;
 178 }
 179
 180 static HRESULT WINAPI ShellItem_BindToHandler(IShellItem2 *iface, IBindCtx *pbc,
 181     REFGUID rbhid, REFIID riid, void **ppvOut)
 182 {
 183     ShellItem *This = impl_from_IShellItem2(iface);
 184     HRESULT ret;
 185     TRACE("(%p,%p,%s,%p,%p)\n", iface, pbc, shdebugstr_guid(rbhid), riid, ppvOut);
 186
 187     *ppvOut = NULL;
 188     if (IsEqualGUID(rbhid, &BHID_SFObject))
 189     {
 190         IShellFolder *psf;
 191         ret = ShellItem_get_shellfolder(This, pbc, &psf);
 192         if (SUCCEEDED(ret))
 193         {
 194             ret = IShellFolder_QueryInterface(psf, riid, ppvOut);
 195             IShellFolder_Release(psf);
 196         }
 197         return ret;
 198     }
 199     else if (IsEqualGUID(rbhid, &BHID_SFUIObject))
 200     {
 201         IShellFolder *psf_parent;
 202         if (_ILIsDesktop(This->pidl))
 203             ret = SHGetDesktopFolder(&psf_parent);
 204         else
 205             ret = ShellItem_get_parent_shellfolder(This, &psf_parent);
 206
 207         if (SUCCEEDED(ret))
 208         {
 209             LPCITEMIDLIST pidl = ILFindLastID(This->pidl);
 210             ret = IShellFolder_GetUIObjectOf(psf_parent, NULL, 1, &pidl, riid, NULL, ppvOut);
 211             IShellFolder_Release(psf_parent);
 212         }
 213         return ret;
 214     }
 215     else if (IsEqualGUID(rbhid, &BHID_DataObject))
 216     {
 217         return ShellItem_BindToHandler(&This->IShellItem2_iface, pbc, &BHID_SFUIObject,
 218                                        &IID_IDataObject, ppvOut);
 219     }
 220
 221     FIXME("Unsupported BHID %s.\n", debugstr_guid(rbhid));
 222
 223     return MK_E_NOOBJECT;
 224 }
 225
 226 static HRESULT WINAPI ShellItem_GetParent(IShellItem2 *iface, IShellItem **ppsi)
 227 {
 228     ShellItem *This = impl_from_IShellItem2(iface);
 229     LPITEMIDLIST parent_pidl;
 230     HRESULT ret;
 231
 232     TRACE("(%p,%p)\n", iface, ppsi);
 233
 234     ret = ShellItem_get_parent_pidl(This, &parent_pidl);
 235     if (SUCCEEDED(ret))
 236     {
 237         ret = SHCreateShellItem(NULL, NULL, parent_pidl, ppsi);
 238         ILFree(parent_pidl);
 239     }
 240
 241     return ret;
 242 }
 243
 244 static HRESULT WINAPI ShellItem_GetDisplayName(IShellItem2 *iface, SIGDN sigdnName,
 245     LPWSTR *ppszName)
 246 {
 247     ShellItem *This = impl_from_IShellItem2(iface);
 248     TRACE("(%p,%x,%p)\n", iface, sigdnName, ppszName);
 249
 250     return SHGetNameFromIDList(This->pidl, sigdnName, ppszName);
 251 }
 252
 253 static HRESULT WINAPI ShellItem_GetAttributes(IShellItem2 *iface, SFGAOF sfgaoMask,
 254     SFGAOF *psfgaoAttribs)
 255 {
 256     ShellItem *This = impl_from_IShellItem2(iface);
 257     IShellFolder *parent_folder;
 258     LPITEMIDLIST child_pidl;
 259     HRESULT ret;
 260
 261     TRACE("(%p,%x,%p)\n", iface, sfgaoMask, psfgaoAttribs);
 262
 263     if (_ILIsDesktop(This->pidl))
 264         ret = SHGetDesktopFolder(&parent_folder);
 265     else
 266         ret = ShellItem_get_parent_shellfolder(This, &parent_folder);
 267     if (SUCCEEDED(ret))
 268     {
 269         child_pidl = ILFindLastID(This->pidl);
 270         *psfgaoAttribs = sfgaoMask;
 271         ret = IShellFolder_GetAttributesOf(parent_folder, 1, (LPCITEMIDLIST*)&child_pidl, psfgaoAttribs);
 272         *psfgaoAttribs &= sfgaoMask;
 273         IShellFolder_Release(parent_folder);
 274
 275         if(sfgaoMask == *psfgaoAttribs)
 276             return S_OK;
 277         else
 278             return S_FALSE;
 279     }
 280
 281     return ret;
 282 }
 283
 284 static HRESULT WINAPI ShellItem_Compare(IShellItem2 *iface, IShellItem *oth,
 285     SICHINTF hint, int *piOrder)
 286 {
 287     LPWSTR dispname, dispname_oth;
 288     HRESULT ret;
 289     TRACE("(%p,%p,%x,%p)\n", iface, oth, hint, piOrder);
 290
 291     if(hint & (SICHINT_CANONICAL | SICHINT_ALLFIELDS))
 292         FIXME("Unsupported flags 0x%08x\n", hint);
 293
 294     ret = IShellItem2_GetDisplayName(iface, SIGDN_DESKTOPABSOLUTEEDITING, &dispname);
 295     if(SUCCEEDED(ret))
 296     {
 297         ret = IShellItem_GetDisplayName(oth, SIGDN_DESKTOPABSOLUTEEDITING, &dispname_oth);
 298         if(SUCCEEDED(ret))
 299         {
 300             *piOrder = lstrcmpiW(dispname, dispname_oth);
 301             CoTaskMemFree(dispname_oth);
 302         }
 303         CoTaskMemFree(dispname);
 304     }
 305
 306     if(SUCCEEDED(ret) && *piOrder &&
 307        (hint & SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL))
 308     {
 309         LPWSTR dispname, dispname_oth;
 310
 311         TRACE("Testing filesystem path.\n");
 312         ret = IShellItem2_GetDisplayName(iface, SIGDN_FILESYSPATH, &dispname);
 313         if(SUCCEEDED(ret))
 314         {
 315             ret = IShellItem_GetDisplayName(oth, SIGDN_FILESYSPATH, &dispname_oth);
 316             if(SUCCEEDED(ret))
 317             {
 318                 *piOrder = lstrcmpiW(dispname, dispname_oth);
 319                 CoTaskMemFree(dispname_oth);
 320             }
 321             CoTaskMemFree(dispname);
 322         }
 323     }
 324
 325     if(FAILED(ret))
 326         return ret;
 327
 328     if(*piOrder)
 329         return S_FALSE;
 330     else
 331         return S_OK;
 332 }
 333
 334 static HRESULT WINAPI ShellItem2_GetPropertyStore(IShellItem2 *iface, GETPROPERTYSTOREFLAGS flags,
 335     REFIID riid, void **ppv)
 336 {
 337     ShellItem *This = impl_from_IShellItem2(iface);
 338     FIXME("Stub: %p (%d, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI ShellItem2_GetPropertyStoreWithCreateObject(IShellItem2 *iface,
 343     GETPROPERTYSTOREFLAGS flags, IUnknown *punkCreateObject, REFIID riid, void **ppv)
 344 {
 345     ShellItem *This = impl_from_IShellItem2(iface);
 346     FIXME("Stub: %p (%08x, %p, %s, %p)\n",
 347           This, flags, punkCreateObject, shdebugstr_guid(riid), ppv);
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI ShellItem2_GetPropertyStoreForKeys(IShellItem2 *iface, const PROPERTYKEY *rgKeys,
 352     UINT cKeys, GETPROPERTYSTOREFLAGS flags, REFIID riid, void **ppv)
 353 {
 354     ShellItem *This = impl_from_IShellItem2(iface);
 355     FIXME("Stub: %p (%p, %d, %08x, %s, %p)\n",
 356           This, rgKeys, cKeys, flags, shdebugstr_guid(riid), ppv);
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI ShellItem2_GetPropertyDescriptionList(IShellItem2 *iface,
 361     REFPROPERTYKEY keyType, REFIID riid, void **ppv)
 362 {
 363     ShellItem *This = impl_from_IShellItem2(iface);
 364     FIXME("Stub: %p (%p, %s, %p)\n", This, keyType, debugstr_guid(riid), ppv);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI ShellItem2_Update(IShellItem2 *iface, IBindCtx *pbc)
 369 {
 370     ShellItem *This = impl_from_IShellItem2(iface);
 371     FIXME("Stub: %p (%p)\n", This, pbc);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI ShellItem2_GetProperty(IShellItem2 *iface, REFPROPERTYKEY key, PROPVARIANT *ppropvar)
 376 {
 377     ShellItem *This = impl_from_IShellItem2(iface);
 378     FIXME("Stub: %p (%p, %p)\n", This, key, ppropvar);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI ShellItem2_GetCLSID(IShellItem2 *iface, REFPROPERTYKEY key, CLSID *pclsid)
 383 {
 384     ShellItem *This = impl_from_IShellItem2(iface);
 385     FIXME("Stub: %p (%p, %p)\n", This, key, pclsid);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI ShellItem2_GetFileTime(IShellItem2 *iface, REFPROPERTYKEY key, FILETIME *pft)
 390 {
 391     ShellItem *This = impl_from_IShellItem2(iface);
 392     FIXME("Stub: %p (%p, %p)\n", This, key, pft);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI ShellItem2_GetInt32(IShellItem2 *iface, REFPROPERTYKEY key, int *pi)
 397 {
 398     ShellItem *This = impl_from_IShellItem2(iface);
 399     FIXME("Stub: %p (%p, %p)\n", This, key, pi);
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT WINAPI ShellItem2_GetString(IShellItem2 *iface, REFPROPERTYKEY key, LPWSTR *ppsz)
 404 {
 405     ShellItem *This = impl_from_IShellItem2(iface);
 406     FIXME("Stub: %p (%p, %p)\n", This, key, ppsz);
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI ShellItem2_GetUInt32(IShellItem2 *iface, REFPROPERTYKEY key, ULONG *pui)
 411 {
 412     ShellItem *This = impl_from_IShellItem2(iface);
 413     FIXME("Stub: %p (%p, %p)\n", This, key, pui);
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI ShellItem2_GetUInt64(IShellItem2 *iface, REFPROPERTYKEY key, ULONGLONG *pull)
 418 {
 419     ShellItem *This = impl_from_IShellItem2(iface);
 420     FIXME("Stub: %p (%p, %p)\n", This, key, pull);
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI ShellItem2_GetBool(IShellItem2 *iface, REFPROPERTYKEY key, BOOL *pf)
 425 {
 426     ShellItem *This = impl_from_IShellItem2(iface);
 427     FIXME("Stub: %p (%p, %p)\n", This, key, pf);
 428     return E_NOTIMPL;
 429 }
 430
 431
 432 static const IShellItem2Vtbl ShellItem2_Vtbl = {
 433     ShellItem_QueryInterface,
 434     ShellItem_AddRef,
 435     ShellItem_Release,
 436     ShellItem_BindToHandler,
 437     ShellItem_GetParent,
 438     ShellItem_GetDisplayName,
 439     ShellItem_GetAttributes,
 440     ShellItem_Compare,
 441     ShellItem2_GetPropertyStore,
 442     ShellItem2_GetPropertyStoreWithCreateObject,
 443     ShellItem2_GetPropertyStoreForKeys,
 444     ShellItem2_GetPropertyDescriptionList,
 445     ShellItem2_Update,
 446     ShellItem2_GetProperty,
 447     ShellItem2_GetCLSID,
 448     ShellItem2_GetFileTime,
 449     ShellItem2_GetInt32,
 450     ShellItem2_GetString,
 451     ShellItem2_GetUInt32,
 452     ShellItem2_GetUInt64,
 453     ShellItem2_GetBool
 454 };
 455
 456 static HRESULT WINAPI ShellItem_IPersistIDList_QueryInterface(IPersistIDList *iface,
 457     REFIID riid, void **ppv)
 458 {
 459     ShellItem *This = impl_from_IPersistIDList(iface);
 460     return IShellItem2_QueryInterface(&This->IShellItem2_iface, riid, ppv);
 461 }
 462
 463 static ULONG WINAPI ShellItem_IPersistIDList_AddRef(IPersistIDList *iface)
 464 {
 465     ShellItem *This = impl_from_IPersistIDList(iface);
 466     return IShellItem2_AddRef(&This->IShellItem2_iface);
 467 }
 468
 469 static ULONG WINAPI ShellItem_IPersistIDList_Release(IPersistIDList *iface)
 470 {
 471     ShellItem *This = impl_from_IPersistIDList(iface);
 472     return IShellItem2_Release(&This->IShellItem2_iface);
 473 }
 474
 475 static HRESULT WINAPI ShellItem_IPersistIDList_GetClassID(IPersistIDList* iface,
 476     CLSID *pClassID)
 477 {
 478     *pClassID = CLSID_ShellItem;
 479     return S_OK;
 480 }
 481
 482 static HRESULT WINAPI ShellItem_IPersistIDList_SetIDList(IPersistIDList* iface,
 483     LPCITEMIDLIST pidl)
 484 {
 485     ShellItem *This = impl_from_IPersistIDList(iface);
 486     LPITEMIDLIST new_pidl;
 487
 488     TRACE("(%p,%p)\n", This, pidl);
 489
 490     new_pidl = ILClone(pidl);
 491
 492     if (new_pidl)
 493     {
 494         ILFree(This->pidl);
 495         This->pidl = new_pidl;
 496         return S_OK;
 497     }
 498     else
 499         return E_OUTOFMEMORY;
 500 }
 501
 502 static HRESULT WINAPI ShellItem_IPersistIDList_GetIDList(IPersistIDList* iface,
 503     LPITEMIDLIST *ppidl)
 504 {
 505     ShellItem *This = impl_from_IPersistIDList(iface);
 506
 507     TRACE("(%p,%p)\n", This, ppidl);
 508
 509     *ppidl = ILClone(This->pidl);
 510     if (*ppidl)
 511         return S_OK;
 512     else
 513         return E_OUTOFMEMORY;
 514 }
 515
 516 static const IPersistIDListVtbl ShellItem_IPersistIDList_Vtbl = {
 517     ShellItem_IPersistIDList_QueryInterface,
 518     ShellItem_IPersistIDList_AddRef,
 519     ShellItem_IPersistIDList_Release,
 520     ShellItem_IPersistIDList_GetClassID,
 521     ShellItem_IPersistIDList_SetIDList,
 522     ShellItem_IPersistIDList_GetIDList
 523 };
 524
 525
 526 HRESULT WINAPI IShellItem_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
 527 {
 528     ShellItem *This;
 529     HRESULT ret;
 530
 531     TRACE("(%p,%s)\n",pUnkOuter, debugstr_guid(riid));
 532
 533     *ppv = NULL;
 534
 535     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 536
 537     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ShellItem));
 538     This->IShellItem2_iface.lpVtbl = &ShellItem2_Vtbl;
 539     This->ref = 1;
 540     This->pidl = NULL;
 541     This->IPersistIDList_iface.lpVtbl = &ShellItem_IPersistIDList_Vtbl;
 542
 543     ret = IShellItem2_QueryInterface(&This->IShellItem2_iface, riid, ppv);
 544     IShellItem2_Release(&This->IShellItem2_iface);
 545
 546     return ret;
 547 }
 548
 549 HRESULT WINAPI SHCreateShellItem(LPCITEMIDLIST pidlParent,
 550     IShellFolder *psfParent, LPCITEMIDLIST pidl, IShellItem **ppsi)
 551 {
 552     ShellItem *This;
 553     LPITEMIDLIST new_pidl;
 554     HRESULT ret;
 555
 556     TRACE("(%p,%p,%p,%p)\n", pidlParent, psfParent, pidl, ppsi);
 557
 558     *ppsi = NULL;
 559
 560     if (!pidl)
 561     {
 562         return E_INVALIDARG;
 563     }
 564     else if (pidlParent || psfParent)
 565     {
 566         LPITEMIDLIST temp_parent=NULL;
 567         if (!pidlParent)
 568         {
 569             IPersistFolder2* ppf2Parent;
 570
 571             if (FAILED(IShellFolder_QueryInterface(psfParent, &IID_IPersistFolder2, (void**)&ppf2Parent)))
 572             {
 573                 FIXME("couldn't get IPersistFolder2 interface of parent\n");
 574                 return E_NOINTERFACE;
 575             }
 576
 577             if (FAILED(IPersistFolder2_GetCurFolder(ppf2Parent, &temp_parent)))
 578             {
 579                 FIXME("couldn't get parent PIDL\n");
 580                 IPersistFolder2_Release(ppf2Parent);
 581                 return E_NOINTERFACE;
 582             }
 583
 584             pidlParent = temp_parent;
 585             IPersistFolder2_Release(ppf2Parent);
 586         }
 587
 588         new_pidl = ILCombine(pidlParent, pidl);
 589         ILFree(temp_parent);
 590
 591         if (!new_pidl)
 592             return E_OUTOFMEMORY;
 593     }
 594     else
 595     {
 596         new_pidl = ILClone(pidl);
 597         if (!new_pidl)
 598             return E_OUTOFMEMORY;
 599     }
 600
 601     ret = IShellItem_Constructor(NULL, &IID_IShellItem, (void**)&This);
 602     if (This)
 603     {
 604         *ppsi = (IShellItem*)&This->IShellItem2_iface;
 605         This->pidl = new_pidl;
 606     }
 607     else
 608     {
 609         ILFree(new_pidl);
 610     }
 611     return ret;
 612 }
 613
 614 HRESULT WINAPI SHCreateItemFromParsingName(PCWSTR pszPath,
 615     IBindCtx *pbc, REFIID riid, void **ppv)
 616 {
 617     LPITEMIDLIST pidl;
 618     HRESULT ret;
 619
 620     *ppv = NULL;
 621
 622     ret = SHParseDisplayName(pszPath, pbc, &pidl, 0, NULL);
 623     if(SUCCEEDED(ret))
 624     {
 625         ShellItem *This;
 626         ret = IShellItem_Constructor(NULL, riid, (void**)&This);
 627
 628         if(SUCCEEDED(ret))
 629         {
 630             This->pidl = pidl;
 631             *ppv = (void*)This;
 632         }
 633         else
 634         {
 635             ILFree(pidl);
 636         }
 637     }
 638     return ret;
 639 }
 640
 641 HRESULT WINAPI SHCreateItemFromIDList(PCIDLIST_ABSOLUTE pidl, REFIID riid, void **ppv)
 642 {
 643     ShellItem *psiimpl;
 644     HRESULT ret;
 645
 646     if(!pidl)
 647         return E_INVALIDARG;
 648
 649     ret = IShellItem_Constructor(NULL, riid, ppv);
 650     if(SUCCEEDED(ret))
 651     {
 652         psiimpl = (ShellItem*)*ppv;
 653         psiimpl->pidl = ILClone(pidl);
 654     }
 655
 656     return ret;
 657 }
 658
 659 HRESULT WINAPI SHGetItemFromDataObject(IDataObject *pdtobj,
 660     DATAOBJ_GET_ITEM_FLAGS dwFlags, REFIID riid, void **ppv)
 661 {
 662     FORMATETC fmt;
 663     STGMEDIUM medium;
 664     HRESULT ret;
 665
 666     TRACE("%p, %x, %s, %p\n", pdtobj, dwFlags, debugstr_guid(riid), ppv);
 667
 668     if(!pdtobj)
 669         return E_INVALIDARG;
 670
 671     fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
 672     fmt.ptd = NULL;
 673     fmt.dwAspect = DVASPECT_CONTENT;
 674     fmt.lindex = -1;
 675     fmt.tymed = TYMED_HGLOBAL;
 676
 677     ret = IDataObject_GetData(pdtobj, &fmt, &medium);
 678     if(SUCCEEDED(ret))
 679     {
 680         LPIDA pida = GlobalLock(medium.u.hGlobal);
 681
 682         if((pida->cidl > 1 && !(dwFlags & DOGIF_ONLY_IF_ONE)) ||
 683            pida->cidl == 1)
 684         {
 685             LPITEMIDLIST pidl;
 686
 687             /* Get the first pidl (parent + child1) */
 688             pidl = ILCombine((LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]),
 689                              (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]));
 690
 691             ret = SHCreateItemFromIDList(pidl, riid, ppv);
 692             ILFree(pidl);
 693         }
 694         else
 695         {
 696             ret = E_FAIL;
 697         }
 698
 699         GlobalUnlock(medium.u.hGlobal);
 700         GlobalFree(medium.u.hGlobal);
 701     }
 702
 703     if(FAILED(ret) && !(dwFlags & DOGIF_NO_HDROP))
 704     {
 705         TRACE("Attempting to fall back on CF_HDROP.\n");
 706
 707         fmt.cfFormat = CF_HDROP;
 708         fmt.ptd = NULL;
 709         fmt.dwAspect = DVASPECT_CONTENT;
 710         fmt.lindex = -1;
 711         fmt.tymed = TYMED_HGLOBAL;
 712
 713         ret = IDataObject_GetData(pdtobj, &fmt, &medium);
 714         if(SUCCEEDED(ret))
 715         {
 716             DROPFILES *df = GlobalLock(medium.u.hGlobal);
 717             LPBYTE files = (LPBYTE)df + df->pFiles;
 718             BOOL multiple_files = FALSE;
 719
 720             ret = E_FAIL;
 721             if(!df->fWide)
 722             {
 723                 WCHAR filename[MAX_PATH];
 724                 PCSTR first_file = (PCSTR)files;
 725                 if(*(files + lstrlenA(first_file) + 1) != 0)
 726                     multiple_files = TRUE;
 727
 728                 if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) )
 729                 {
 730                     MultiByteToWideChar(CP_ACP, 0, first_file, -1, filename, MAX_PATH);
 731                     ret = SHCreateItemFromParsingName(filename, NULL, riid, ppv);
 732                 }
 733             }
 734             else
 735             {
 736                 PCWSTR first_file = (PCWSTR)files;
 737                 if(*((PCWSTR)files + lstrlenW(first_file) + 1) != 0)
 738                     multiple_files = TRUE;
 739
 740                 if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) )
 741                     ret = SHCreateItemFromParsingName(first_file, NULL, riid, ppv);
 742             }
 743
 744             GlobalUnlock(medium.u.hGlobal);
 745             GlobalFree(medium.u.hGlobal);
 746         }
 747     }
 748
 749     if(FAILED(ret) && !(dwFlags & DOGIF_NO_URL))
 750     {
 751         FIXME("Failed to create item, should try CF_URL.\n");
 752     }
 753
 754     return ret;
 755 }
 756
 757 HRESULT WINAPI SHGetItemFromObject(IUnknown *punk, REFIID riid, void **ppv)
 758 {
 759     LPITEMIDLIST pidl;
 760     HRESULT ret;
 761
 762     ret = SHGetIDListFromObject(punk, &pidl);
 763     if(SUCCEEDED(ret))
 764     {
 765         ret = SHCreateItemFromIDList(pidl, riid, ppv);
 766         ILFree(pidl);
 767     }
 768
 769     return ret;
 770 }
 771
 772 /*************************************************************************
 773  * IEnumShellItems implementation
 774  */
 775 typedef struct {
 776     IEnumShellItems IEnumShellItems_iface;
 777     LONG ref;
 778
 779     IShellItemArray *array;
 780     DWORD count;
 781     DWORD position;
 782 } IEnumShellItemsImpl;
 783
 784 static inline IEnumShellItemsImpl *impl_from_IEnumShellItems(IEnumShellItems *iface)
 785 {
 786     return CONTAINING_RECORD(iface, IEnumShellItemsImpl, IEnumShellItems_iface);
 787 }
 788
 789 static HRESULT WINAPI IEnumShellItems_fnQueryInterface(IEnumShellItems *iface,
 790                                                        REFIID riid,
 791                                                        void **ppvObject)
 792 {
 793     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 794     TRACE("%p (%s, %p)\n", This, shdebugstr_guid(riid), ppvObject);
 795
 796     *ppvObject = NULL;
 797     if(IsEqualIID(riid, &IID_IEnumShellItems) ||
 798        IsEqualIID(riid, &IID_IUnknown))
 799     {
 800         *ppvObject = &This->IEnumShellItems_iface;
 801     }
 802
 803     if(*ppvObject)
 804     {
 805         IUnknown_AddRef((IUnknown*)*ppvObject);
 806         return S_OK;
 807     }
 808
 809     return E_NOINTERFACE;
 810 }
 811
 812 static ULONG WINAPI IEnumShellItems_fnAddRef(IEnumShellItems *iface)
 813 {
 814     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 815     LONG ref = InterlockedIncrement(&This->ref);
 816     TRACE("%p - ref %d\n", This, ref);
 817
 818     return ref;
 819 }
 820
 821 static ULONG WINAPI IEnumShellItems_fnRelease(IEnumShellItems *iface)
 822 {
 823     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 824     LONG ref = InterlockedDecrement(&This->ref);
 825     TRACE("%p - ref %d\n", This, ref);
 826
 827     if(!ref)
 828     {
 829         TRACE("Freeing.\n");
 830         IShellItemArray_Release(This->array);
 831         HeapFree(GetProcessHeap(), 0, This);
 832         return 0;
 833     }
 834
 835     return ref;
 836 }
 837
 838 static HRESULT WINAPI IEnumShellItems_fnNext(IEnumShellItems* iface,
 839                                              ULONG celt,
 840                                              IShellItem **rgelt,
 841                                              ULONG *pceltFetched)
 842 {
 843     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 844     HRESULT hr = S_FALSE;
 845     UINT i;
 846     ULONG fetched = 0;
 847     TRACE("%p (%d %p %p)\n", This, celt, rgelt, pceltFetched);
 848
 849     if(pceltFetched == NULL && celt != 1)
 850         return E_INVALIDARG;
 851
 852     for(i = This->position; fetched < celt && i < This->count; i++) {
 853         hr = IShellItemArray_GetItemAt(This->array, i, &rgelt[fetched]);
 854         if(FAILED(hr))
 855             break;
 856         fetched++;
 857         This->position++;
 858     }
 859
 860     if(SUCCEEDED(hr))
 861     {
 862         if(pceltFetched != NULL)
 863             *pceltFetched = fetched;
 864
 865         if(fetched > 0)
 866             return S_OK;
 867
 868         return S_FALSE;
 869     }
 870
 871     return hr;
 872 }
 873
 874 static HRESULT WINAPI IEnumShellItems_fnSkip(IEnumShellItems* iface, ULONG celt)
 875 {
 876     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 877     TRACE("%p (%d)\n", This, celt);
 878
 879     This->position = min(This->position + celt, This->count-1);
 880
 881     return S_OK;
 882 }
 883
 884 static HRESULT WINAPI IEnumShellItems_fnReset(IEnumShellItems* iface)
 885 {
 886     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 887     TRACE("%p\n", This);
 888
 889     This->position = 0;
 890
 891     return S_OK;
 892 }
 893
 894 static HRESULT WINAPI IEnumShellItems_fnClone(IEnumShellItems* iface, IEnumShellItems **ppenum)
 895 {
 896     IEnumShellItemsImpl *This = impl_from_IEnumShellItems(iface);
 897     TRACE("%p (%p)\n", This, ppenum);
 898
 899     /* Not implemented anywhere */
 900     *ppenum = NULL;
 901
 902     return E_NOTIMPL;
 903 }
 904
 905 static const IEnumShellItemsVtbl vt_IEnumShellItems = {
 906     IEnumShellItems_fnQueryInterface,
 907     IEnumShellItems_fnAddRef,
 908     IEnumShellItems_fnRelease,
 909     IEnumShellItems_fnNext,
 910     IEnumShellItems_fnSkip,
 911     IEnumShellItems_fnReset,
 912     IEnumShellItems_fnClone
 913 };
 914
 915 static HRESULT IEnumShellItems_Constructor(IShellItemArray *array, IEnumShellItems **ppesi)
 916 {
 917     IEnumShellItemsImpl *This;
 918     HRESULT ret;
 919
 920     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IEnumShellItemsImpl));
 921     if(!This)
 922         return E_OUTOFMEMORY;
 923
 924     This->ref = 1;
 925     This->IEnumShellItems_iface.lpVtbl = &vt_IEnumShellItems;
 926     This->array = array;
 927     This->position = 0;
 928
 929     IShellItemArray_AddRef(This->array);
 930     IShellItemArray_GetCount(This->array, &This->count);
 931
 932     ret = IEnumShellItems_QueryInterface(&This->IEnumShellItems_iface, &IID_IEnumShellItems, (void**)ppesi);
 933     IEnumShellItems_Release(&This->IEnumShellItems_iface);
 934
 935     return ret;
 936 }
 937
 938
 939 /*************************************************************************
 940  * IShellItemArray implementation
 941  */
 942 typedef struct {
 943     IShellItemArray IShellItemArray_iface;
 944     LONG ref;
 945
 946     IShellItem **array;
 947     DWORD item_count;
 948 } IShellItemArrayImpl;
 949
 950 static inline IShellItemArrayImpl *impl_from_IShellItemArray(IShellItemArray *iface)
 951 {
 952     return CONTAINING_RECORD(iface, IShellItemArrayImpl, IShellItemArray_iface);
 953 }
 954
 955 static HRESULT WINAPI IShellItemArray_fnQueryInterface(IShellItemArray *iface,
 956                                                        REFIID riid,
 957                                                        void **ppvObject)
 958 {
 959     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
 960     TRACE("%p (%s, %p)\n", This, shdebugstr_guid(riid), ppvObject);
 961
 962     *ppvObject = NULL;
 963     if(IsEqualIID(riid, &IID_IShellItemArray) ||
 964        IsEqualIID(riid, &IID_IUnknown))
 965     {
 966         *ppvObject = &This->IShellItemArray_iface;
 967     }
 968
 969     if(*ppvObject)
 970     {
 971         IUnknown_AddRef((IUnknown*)*ppvObject);
 972         return S_OK;
 973     }
 974
 975     return E_NOINTERFACE;
 976 }
 977
 978 static ULONG WINAPI IShellItemArray_fnAddRef(IShellItemArray *iface)
 979 {
 980     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
 981     LONG ref = InterlockedIncrement(&This->ref);
 982     TRACE("%p - ref %d\n", This, ref);
 983
 984     return ref;
 985 }
 986
 987 static ULONG WINAPI IShellItemArray_fnRelease(IShellItemArray *iface)
 988 {
 989     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
 990     LONG ref = InterlockedDecrement(&This->ref);
 991     TRACE("%p - ref %d\n", This, ref);
 992
 993     if(!ref)
 994     {
 995         UINT i;
 996         TRACE("Freeing.\n");
 997
 998         for(i = 0; i < This->item_count; i++)
 999             IShellItem_Release(This->array[i]);
1000
1001         HeapFree(GetProcessHeap(), 0, This->array);
1002         HeapFree(GetProcessHeap(), 0, This);
1003         return 0;
1004     }
1005
1006     return ref;
1007 }
1008
1009 static HRESULT WINAPI IShellItemArray_fnBindToHandler(IShellItemArray *iface,
1010                                                       IBindCtx *pbc,
1011                                                       REFGUID bhid,
1012                                                       REFIID riid,
1013                                                       void **ppvOut)
1014 {
1015     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1016     FIXME("Stub: %p (%p, %s, %s, %p)\n",
1017           This, pbc, shdebugstr_guid(bhid), shdebugstr_guid(riid), ppvOut);
1018
1019     return E_NOTIMPL;
1020 }
1021
1022 static HRESULT WINAPI IShellItemArray_fnGetPropertyStore(IShellItemArray *iface,
1023                                                          GETPROPERTYSTOREFLAGS flags,
1024                                                          REFIID riid,
1025                                                          void **ppv)
1026 {
1027     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1028     FIXME("Stub: %p (%x, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv);
1029
1030     return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI IShellItemArray_fnGetPropertyDescriptionList(IShellItemArray *iface,
1034                                                                    REFPROPERTYKEY keyType,
1035                                                                    REFIID riid,
1036                                                                    void **ppv)
1037 {
1038     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1039     FIXME("Stub: %p (%p, %s, %p)\n",
1040           This, keyType, shdebugstr_guid(riid), ppv);
1041
1042     return E_NOTIMPL;
1043 }
1044
1045 static HRESULT WINAPI IShellItemArray_fnGetAttributes(IShellItemArray *iface,
1046                                                       SIATTRIBFLAGS AttribFlags,
1047                                                       SFGAOF sfgaoMask,
1048                                                       SFGAOF *psfgaoAttribs)
1049 {
1050     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1051     HRESULT hr = S_OK;
1052     SFGAOF attr;
1053     UINT i;
1054     TRACE("%p (%x, %x, %p)\n", This, AttribFlags, sfgaoMask, psfgaoAttribs);
1055
1056     if(AttribFlags & ~(SIATTRIBFLAGS_AND|SIATTRIBFLAGS_OR))
1057         FIXME("%08x contains unsupported attribution flags\n", AttribFlags);
1058
1059     for(i = 0; i < This->item_count; i++)
1060     {
1061         hr = IShellItem_GetAttributes(This->array[i], sfgaoMask, &attr);
1062         if(FAILED(hr))
1063             break;
1064
1065         if(i == 0)
1066         {
1067             *psfgaoAttribs = attr;
1068             continue;
1069         }
1070
1071         switch(AttribFlags & SIATTRIBFLAGS_MASK)
1072         {
1073         case SIATTRIBFLAGS_AND:
1074             *psfgaoAttribs &= attr;
1075             break;
1076         case SIATTRIBFLAGS_OR:
1077             *psfgaoAttribs |= attr;
1078             break;
1079         }
1080     }
1081
1082     if(SUCCEEDED(hr))
1083     {
1084         if(*psfgaoAttribs == sfgaoMask)
1085             return S_OK;
1086
1087         return S_FALSE;
1088     }
1089
1090     return hr;
1091 }
1092
1093 static HRESULT WINAPI IShellItemArray_fnGetCount(IShellItemArray *iface,
1094                                                  DWORD *pdwNumItems)
1095 {
1096     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1097     TRACE("%p (%p)\n", This, pdwNumItems);
1098
1099     *pdwNumItems = This->item_count;
1100
1101     return S_OK;
1102 }
1103
1104 static HRESULT WINAPI IShellItemArray_fnGetItemAt(IShellItemArray *iface,
1105                                                   DWORD dwIndex,
1106                                                   IShellItem **ppsi)
1107 {
1108     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1109     TRACE("%p (%x, %p)\n", This, dwIndex, ppsi);
1110
1111     /* zero indexed */
1112     if(dwIndex + 1 > This->item_count)
1113         return E_FAIL;
1114
1115     *ppsi = This->array[dwIndex];
1116     IShellItem_AddRef(*ppsi);
1117
1118     return S_OK;
1119 }
1120
1121 static HRESULT WINAPI IShellItemArray_fnEnumItems(IShellItemArray *iface,
1122                                                   IEnumShellItems **ppenumShellItems)
1123 {
1124     IShellItemArrayImpl *This = impl_from_IShellItemArray(iface);
1125     HRESULT hr;
1126     TRACE("%p (%p)\n", This, ppenumShellItems);
1127
1128     hr = IEnumShellItems_Constructor(iface, ppenumShellItems);
1129
1130     return hr;
1131 }
1132
1133 static const IShellItemArrayVtbl vt_IShellItemArray = {
1134     IShellItemArray_fnQueryInterface,
1135     IShellItemArray_fnAddRef,
1136     IShellItemArray_fnRelease,
1137     IShellItemArray_fnBindToHandler,
1138     IShellItemArray_fnGetPropertyStore,
1139     IShellItemArray_fnGetPropertyDescriptionList,
1140     IShellItemArray_fnGetAttributes,
1141     IShellItemArray_fnGetCount,
1142     IShellItemArray_fnGetItemAt,
1143     IShellItemArray_fnEnumItems
1144 };
1145
1146 static HRESULT IShellItemArray_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
1147 {
1148     IShellItemArrayImpl *This;
1149     HRESULT ret;
1150
1151     TRACE("(%p, %s, %p)\n",pUnkOuter, debugstr_guid(riid), ppv);
1152
1153     if(pUnkOuter)
1154         return CLASS_E_NOAGGREGATION;
1155
1156     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IShellItemArrayImpl));
1157     if(!This)
1158         return E_OUTOFMEMORY;
1159
1160     This->ref = 1;
1161     This->IShellItemArray_iface.lpVtbl = &vt_IShellItemArray;
1162     This->array = NULL;
1163     This->item_count = 0;
1164
1165     ret = IShellItemArray_QueryInterface(&This->IShellItemArray_iface, riid, ppv);
1166     IShellItemArray_Release(&This->IShellItemArray_iface);
1167
1168     return ret;
1169 }
1170
1171 HRESULT WINAPI SHCreateShellItemArray(PCIDLIST_ABSOLUTE pidlParent,
1172                                       IShellFolder *psf,
1173                                       UINT cidl,
1174                                       PCUITEMID_CHILD_ARRAY ppidl,
1175                                       IShellItemArray **ppsiItemArray)
1176 {
1177     IShellItemArrayImpl *This;
1178     IShellItem **array;
1179     HRESULT ret = E_FAIL;
1180     UINT i;
1181
1182     TRACE("%p, %p, %d, %p, %p\n", pidlParent, psf, cidl, ppidl, ppsiItemArray);
1183
1184     if(!pidlParent && !psf)
1185         return E_POINTER;
1186
1187     if(!ppidl)
1188         return E_INVALIDARG;
1189
1190     array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cidl*sizeof(IShellItem*));
1191     if(!array)
1192         return E_OUTOFMEMORY;
1193
1194     for(i = 0; i < cidl; i++)
1195     {
1196         ret = SHCreateShellItem(pidlParent, psf, ppidl[i], &array[i]);
1197         if(FAILED(ret)) break;
1198     }
1199
1200     if(SUCCEEDED(ret))
1201     {
1202         ret = IShellItemArray_Constructor(NULL, &IID_IShellItemArray, (void**)&This);
1203         if(SUCCEEDED(ret))
1204         {
1205             This->array = array;
1206             This->item_count = cidl;
1207             *ppsiItemArray = &This->IShellItemArray_iface;
1208
1209             return ret;
1210         }
1211     }
1212
1213     /* Something failed, clean up. */
1214     for(i = 0; i < cidl; i++)
1215         if(array[i]) IShellItem_Release(array[i]);
1216     HeapFree(GetProcessHeap(), 0, array);
1217     *ppsiItemArray = NULL;
1218     return ret;
1219 }
1220
1221 HRESULT WINAPI SHCreateShellItemArrayFromShellItem(IShellItem *psi, REFIID riid, void **ppv)
1222 {
1223     IShellItemArrayImpl *This;
1224     IShellItem **array;
1225     HRESULT ret;
1226
1227     TRACE("%p, %s, %p\n", psi, shdebugstr_guid(riid), ppv);
1228
1229     array = HeapAlloc(GetProcessHeap(), 0, sizeof(IShellItem*));
1230     if(!array)
1231         return E_OUTOFMEMORY;
1232
1233     ret = IShellItemArray_Constructor(NULL, riid, (void**)&This);
1234     if(SUCCEEDED(ret))
1235     {
1236         array[0] = psi;
1237         IShellItem_AddRef(psi);
1238         This->array = array;
1239         This->item_count = 1;
1240         *ppv = This;
1241     }
1242     else
1243     {
1244         HeapFree(GetProcessHeap(), 0, array);
1245         *ppv = NULL;
1246     }
1247
1248     return ret;
1249 }
1250
1251 HRESULT WINAPI SHCreateShellItemArrayFromDataObject(IDataObject *pdo, REFIID riid, void **ppv)
1252 {
1253     IShellItemArray *psia;
1254     FORMATETC fmt;
1255     STGMEDIUM medium;
1256     HRESULT ret;
1257
1258     TRACE("%p, %s, %p\n", pdo, shdebugstr_guid(riid), ppv);
1259
1260     if(!pdo)
1261         return E_INVALIDARG;
1262
1263     *ppv = NULL;
1264
1265     fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
1266     fmt.ptd = NULL;
1267     fmt.dwAspect = DVASPECT_CONTENT;
1268     fmt.lindex = -1;
1269     fmt.tymed = TYMED_HGLOBAL;
1270
1271     ret = IDataObject_GetData(pdo, &fmt, &medium);
1272     if(SUCCEEDED(ret))
1273     {
1274         LPIDA pida = GlobalLock(medium.u.hGlobal);
1275         LPCITEMIDLIST parent_pidl;
1276         LPCITEMIDLIST *children;
1277         UINT i;
1278         TRACE("Converting %d objects.\n", pida->cidl);
1279
1280         parent_pidl = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
1281
1282         children = HeapAlloc(GetProcessHeap(), 0, sizeof(LPCITEMIDLIST)*pida->cidl);
1283         for(i = 0; i < pida->cidl; i++)
1284             children[i] = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[i+1]);
1285
1286         ret = SHCreateShellItemArray(parent_pidl, NULL, pida->cidl, children, &psia);
1287
1288         HeapFree(GetProcessHeap(), 0, children);
1289
1290         GlobalUnlock(medium.u.hGlobal);
1291         GlobalFree(medium.u.hGlobal);
1292     }
1293
1294     if(SUCCEEDED(ret))
1295     {
1296         ret = IShellItemArray_QueryInterface(psia, riid, ppv);
1297         IShellItemArray_Release(psia);
1298     }
1299
1300     return ret;
1301 }
1302
1303 HRESULT WINAPI SHCreateShellItemArrayFromIDLists(UINT cidl,
1304                                                  PCIDLIST_ABSOLUTE_ARRAY pidl_array,
1305                                                  IShellItemArray **psia)
1306 {
1307     IShellItemArrayImpl *This;
1308     IShellItem **array;
1309     HRESULT ret;
1310     UINT i;
1311     TRACE("%d, %p, %p\n", cidl, pidl_array, psia);
1312
1313     *psia = NULL;
1314
1315     if(cidl == 0)
1316         return E_INVALIDARG;
1317
1318     array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IShellItem*));
1319     if(!array)
1320         return E_OUTOFMEMORY;
1321
1322     for(i = 0; i < cidl; i++)
1323     {
1324         ret = SHCreateShellItem(NULL, NULL, pidl_array[i], &array[i]);
1325         if(FAILED(ret))
1326             break;
1327     }
1328
1329     if(SUCCEEDED(ret))
1330     {
1331         ret = IShellItemArray_Constructor(NULL, &IID_IShellItemArray, (void**)psia);
1332         if(SUCCEEDED(ret))
1333         {
1334             This = impl_from_IShellItemArray(*psia);
1335             This->array = array;
1336             This->item_count = cidl;
1337             return S_OK;
1338         }
1339     }
1340
1341     for(i = 0; i < cidl; i++)
1342         if(array[i]) IShellItem_Release(array[i]);
1343     HeapFree(GetProcessHeap(), 0, array);
1344     *psia = NULL;
1345     return ret;
1346 }