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