dlls/shell32/pidl.c

   1 /*
   2  *    pidl Handling
   3  *
   4  *    Copyright 1998    Juergen Schmied
   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  * NOTES
  21  *  a pidl == NULL means desktop and is legal
  22  *
  23  */
  24
  25 #include <ctype.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #define COBJMACROS
  31 #define NONAMELESSUNION
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winreg.h"
  36 #include "objbase.h"
  37 #include "shlguid.h"
  38 #include "winerror.h"
  39 #include "winnls.h"
  40 #include "shell32_main.h"
  41 #include "shlwapi.h"
  42
  43 #include "pidl.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(pidl);
  47 WINE_DECLARE_DEBUG_CHANNEL(shell);
  48
  49 /* from comctl32.dll */
  50 extern LPVOID WINAPI Alloc(INT);
  51 extern BOOL WINAPI Free(LPVOID);
  52
  53 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl);
  54 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl);
  55
  56 /*************************************************************************
  57  * ILGetDisplayNameExA
  58  *
  59  * Retrieves the display name of an ItemIDList
  60  *
  61  * PARAMS
  62  *  psf        [I]   Shell Folder to start with, if NULL the desktop is used
  63  *  pidl       [I]   ItemIDList relative to the psf to get the display name for
  64  *  path       [O]   Filled in with the display name, assumed to be at least MAX_PATH long
  65  *  type       [I]   Type of display name to retrieve
  66  *                    0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
  67  *                    1 = SHGDN_NORMAL relative to the root folder
  68  *                    2 = SHGDN_INFOLDER relative to the root folder, only the last name
  69  *
  70  * RETURNS
  71  *  True if the display name could be retrieved successfully, False otherwise
  72  */
  73 static BOOL ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
  74 {
  75     BOOL ret = FALSE;
  76     WCHAR wPath[MAX_PATH];
  77
  78     TRACE("%p %p %p %ld\n", psf, pidl, path, type);
  79
  80     if (!pidl || !path)
  81         return FALSE;
  82
  83     ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
  84     WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
  85     TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
  86
  87     return ret;
  88 }
  89
  90 BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
  91 {
  92     LPSHELLFOLDER psfParent, lsf = psf;
  93     HRESULT ret = NO_ERROR;
  94     LPCITEMIDLIST pidllast;
  95     STRRET strret;
  96     DWORD flag;
  97
  98     TRACE("%p %p %p %lx\n", psf, pidl, path, type);
  99
 100     if (!pidl || !path)
 101         return FALSE;
 102
 103     if (!lsf)
 104     {
 105         ret = SHGetDesktopFolder(&lsf);
 106         if (FAILED(ret))
 107             return FALSE;
 108     }
 109
 110     switch (type)
 111     {
 112     case ILGDN_FORPARSING:
 113         flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
 114         break;
 115     case ILGDN_NORMAL:
 116         flag = SHGDN_NORMAL;
 117         break;
 118     case ILGDN_INFOLDER:
 119         flag = SHGDN_INFOLDER;
 120         break;
 121     default:
 122         FIXME("Unknown type parameter = %lx\n", type);
 123         flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
 124         break;
 125     }
 126
 127     if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
 128     {
 129         ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
 130         if (SUCCEEDED(ret))
 131         {
 132             if(!StrRetToStrNW(path, MAX_PATH, &strret, pidl))
 133                 ret = E_FAIL;
 134         }
 135     }
 136     else
 137     {
 138         ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
 139         if (SUCCEEDED(ret))
 140         {
 141             ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
 142             if (SUCCEEDED(ret))
 143             {
 144                 if(!StrRetToStrNW(path, MAX_PATH, &strret, pidllast))
 145                     ret = E_FAIL;
 146             }
 147             IShellFolder_Release(psfParent);
 148         }
 149     }
 150
 151     TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
 152
 153     if (!psf)
 154         IShellFolder_Release(lsf);
 155     return SUCCEEDED(ret);
 156 }
 157
 158 /*************************************************************************
 159  * ILGetDisplayNameEx        [SHELL32.186]
 160  */
 161 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
 162 {
 163     TRACE_(shell)("%p %p %p %ld\n", psf, pidl, path, type);
 164
 165     if (SHELL_OsIsUnicode())
 166         return ILGetDisplayNameExW(psf, pidl, path, type);
 167     return ILGetDisplayNameExA(psf, pidl, path, type);
 168 }
 169
 170 /*************************************************************************
 171  * ILGetDisplayName            [SHELL32.15]
 172  */
 173 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
 174 {
 175     TRACE_(shell)("%p %p\n", pidl, path);
 176
 177     if (SHELL_OsIsUnicode())
 178         return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
 179     return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
 180 }
 181
 182 /*************************************************************************
 183  * ILFindLastID [SHELL32.16]
 184  *
 185  * NOTES
 186  *   observed: pidl=Desktop return=pidl
 187  */
 188 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
 189 {
 190     LPCITEMIDLIST   pidlLast = pidl;
 191
 192     TRACE("(pidl=%p)\n",pidl);
 193
 194     if (!pidl)
 195         return NULL;
 196
 197     while (pidl->mkid.cb)
 198     {
 199         pidlLast = pidl;
 200         pidl = ILGetNext(pidl);
 201     }
 202     return (LPITEMIDLIST)pidlLast;
 203 }
 204
 205 /*************************************************************************
 206  * ILRemoveLastID [SHELL32.17]
 207  *
 208  * NOTES
 209  *   when pidl=Desktop return=FALSE
 210  */
 211 BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
 212 {
 213     TRACE_(shell)("pidl=%p\n",pidl);
 214
 215     if (_ILIsEmpty(pidl))
 216         return FALSE;
 217     ILFindLastID(pidl)->mkid.cb = 0;
 218     return TRUE;
 219 }
 220
 221 /*************************************************************************
 222  * ILClone [SHELL32.18]
 223  *
 224  * NOTES
 225  *    duplicate an idlist
 226  */
 227 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
 228 {
 229     DWORD    len;
 230     LPITEMIDLIST  newpidl;
 231
 232     if (!pidl)
 233         return NULL;
 234
 235     len = ILGetSize(pidl);
 236     newpidl = SHAlloc(len);
 237     if (newpidl)
 238         memcpy(newpidl,pidl,len);
 239
 240     TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
 241     pdump(pidl);
 242
 243     return newpidl;
 244 }
 245
 246 /*************************************************************************
 247  * ILCloneFirst [SHELL32.19]
 248  *
 249  * NOTES
 250  *  duplicates the first idlist of a complex pidl
 251  */
 252 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
 253 {
 254     DWORD len;
 255     LPITEMIDLIST pidlNew = NULL;
 256
 257     TRACE("pidl=%p\n", pidl);
 258     pdump(pidl);
 259
 260     if (pidl)
 261     {
 262         len = pidl->mkid.cb;
 263         pidlNew = SHAlloc(len+2);
 264         if (pidlNew)
 265         {
 266             memcpy(pidlNew,pidl,len+2);        /* 2 -> mind a desktop pidl */
 267
 268             if (len)
 269                 ILGetNext(pidlNew)->mkid.cb = 0x00;
 270         }
 271     }
 272     TRACE("-- newpidl=%p\n",pidlNew);
 273
 274     return pidlNew;
 275 }
 276
 277 /*************************************************************************
 278  * ILLoadFromStream (SHELL32.26)
 279  *
 280  * NOTES
 281  *   the first two bytes are the len, the pidl is following then
 282  */
 283 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
 284 {
 285     WORD        wLen = 0;
 286     DWORD       dwBytesRead;
 287     HRESULT     ret = E_FAIL;
 288
 289
 290     TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
 291
 292     SHFree(*ppPidl);
 293     *ppPidl = NULL;
 294
 295     IStream_AddRef (pStream);
 296
 297     if (SUCCEEDED(IStream_Read(pStream, &wLen, 2, &dwBytesRead)))
 298     {
 299         TRACE("PIDL length is %d\n", wLen);
 300         if (wLen != 0)
 301         {
 302             *ppPidl = SHAlloc (wLen);
 303             if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
 304             {
 305                 TRACE("Stream read OK\n");
 306                 ret = S_OK;
 307             }
 308             else
 309             {
 310                 WARN("reading pidl failed\n");
 311                 SHFree(*ppPidl);
 312                 *ppPidl = NULL;
 313             }
 314         }
 315         else
 316         {
 317             *ppPidl = NULL;
 318             ret = S_OK;
 319         }
 320     }
 321
 322     /* we are not yet fully compatible */
 323     if (*ppPidl && !pcheck(*ppPidl))
 324     {
 325         WARN("Check failed\n");
 326         SHFree(*ppPidl);
 327         *ppPidl = NULL;
 328     }
 329
 330     IStream_Release (pStream);
 331     TRACE("done\n");
 332     return ret;
 333 }
 334
 335 /*************************************************************************
 336  * ILSaveToStream (SHELL32.27)
 337  *
 338  * NOTES
 339  *   the first two bytes are the len, the pidl is following then
 340  */
 341 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
 342 {
 343     WORD        wLen = 0;
 344     HRESULT        ret = E_FAIL;
 345
 346     TRACE_(shell)("%p %p\n", pStream, pPidl);
 347
 348     IStream_AddRef (pStream);
 349
 350     wLen = ILGetSize(pPidl);
 351
 352     if (SUCCEEDED(IStream_Write(pStream, &wLen, 2, NULL)))
 353     {
 354         if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
 355             ret = S_OK;
 356     }
 357     IStream_Release (pStream);
 358
 359     return ret;
 360 }
 361
 362 /*************************************************************************
 363  * SHILCreateFromPath        [SHELL32.28]
 364  *
 365  * Create an ItemIDList from a path
 366  *
 367  * PARAMS
 368  *  path       [I]
 369  *  ppidl      [O]
 370  *  attributes [I/O] requested attributes on call and actual attributes when
 371  *                   the function returns
 372  *
 373  * RETURNS
 374  *  NO_ERROR if successful, or an OLE errer code otherwise
 375  *
 376  * NOTES
 377  *  Wrapper for IShellFolder_ParseDisplayName().
 378  */
 379 static HRESULT SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 380 {
 381     WCHAR lpszDisplayName[MAX_PATH];
 382
 383     TRACE_(shell)("%s %p 0x%08lx\n", path, ppidl, attributes ? *attributes : 0);
 384
 385     if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
 386         lpszDisplayName[MAX_PATH-1] = 0;
 387
 388     return SHILCreateFromPathW(lpszDisplayName, ppidl, attributes);
 389 }
 390
 391 HRESULT SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 392 {
 393     LPSHELLFOLDER sf;
 394     DWORD pchEaten;
 395     HRESULT ret = E_FAIL;
 396
 397     TRACE_(shell)("%s %p 0x%08lx\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
 398
 399     if (SUCCEEDED (SHGetDesktopFolder(&sf)))
 400     {
 401         ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
 402         IShellFolder_Release(sf);
 403     }
 404     return ret;
 405 }
 406
 407 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
 408 {
 409     if ( SHELL_OsIsUnicode())
 410         return SHILCreateFromPathW (path, ppidl, attributes);
 411     return SHILCreateFromPathA (path, ppidl, attributes);
 412 }
 413
 414 /*************************************************************************
 415  * SHCloneSpecialIDList      [SHELL32.89]
 416  *
 417  * Create an ItemIDList to one of the special folders.
 418
 419  * PARAMS
 420  *  hwndOwner    [in]
 421  *  nFolder      [in]    CSIDL_xxxxx
 422  *  fCreate      [in]    Create folder if it does not exist
 423  *
 424  * RETURNS
 425  *  Success: The newly created pidl
 426  *  Failure: NULL, if inputs are invalid.
 427  *
 428  * NOTES
 429  *  exported by ordinal.
 430  *  Caller is responsible for deallocating the returned ItemIDList with the
 431  *  shells IMalloc interface, aka ILFree.
 432  */
 433 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
 434 {
 435     LPITEMIDLIST ppidl;
 436     TRACE_(shell)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
 437
 438     if (fCreate)
 439         nFolder |= CSIDL_FLAG_CREATE;
 440
 441     SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
 442     return ppidl;
 443 }
 444
 445 /*************************************************************************
 446  * ILGlobalClone             [SHELL32.20]
 447  *
 448  * Clones an ItemIDList using Alloc.
 449  *
 450  * PARAMS
 451  *  pidl       [I]   ItemIDList to clone
 452  *
 453  * RETURNS
 454  *  Newly allocated ItemIDList.
 455  *
 456  * NOTES
 457  *  exported by ordinal.
 458  */
 459 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
 460 {
 461     DWORD    len;
 462     LPITEMIDLIST  newpidl;
 463
 464     if (!pidl)
 465         return NULL;
 466
 467     len = ILGetSize(pidl);
 468     newpidl = Alloc(len);
 469     if (newpidl)
 470         memcpy(newpidl,pidl,len);
 471
 472     TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
 473     pdump(pidl);
 474
 475     return newpidl;
 476 }
 477
 478 /*************************************************************************
 479  * ILIsEqual [SHELL32.21]
 480  *
 481  */
 482 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 483 {
 484     char    szData1[MAX_PATH];
 485     char    szData2[MAX_PATH];
 486
 487     LPCITEMIDLIST pidltemp1 = pidl1;
 488     LPCITEMIDLIST pidltemp2 = pidl2;
 489
 490     TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 491
 492     /*
 493      * Explorer reads from registry directly (StreamMRU),
 494      * so we can only check here
 495      */
 496     if (!pcheck(pidl1) || !pcheck (pidl2))
 497         return FALSE;
 498
 499     pdump (pidl1);
 500     pdump (pidl2);
 501
 502     if (!pidl1 || !pidl2)
 503         return FALSE;
 504
 505     while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 506     {
 507         _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
 508         _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
 509
 510         if (lstrcmpiA( szData1, szData2 ))
 511             return FALSE;
 512
 513         pidltemp1 = ILGetNext(pidltemp1);
 514         pidltemp2 = ILGetNext(pidltemp2);
 515     }
 516
 517     if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
 518         return TRUE;
 519
 520     return FALSE;
 521 }
 522
 523 /*************************************************************************
 524  * ILIsParent                [SHELL32.23]
 525  *
 526  * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
 527  *
 528  * PARAMS
 529  *  pidlParent [I]
 530  *  pidlChild  [I]
 531  *  bImmediate [I]   only return true if the parent is the direct parent
 532  *                   of the child
 533  *
 534  * RETURNS
 535  *  True if the parent ItemIDlist is a complete part of the child ItemIdList,
 536  *  False otherwise.
 537  *
 538  * NOTES
 539  *  parent = a/b, child = a/b/c -> true, c is in folder a/b
 540  *  child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
 541  *  child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
 542  *  child = a/b -> false if bImmediate is true
 543  *  child = a/b -> true if bImmediate is false
 544  */
 545 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
 546 {
 547     char    szData1[MAX_PATH];
 548     char    szData2[MAX_PATH];
 549     LPCITEMIDLIST pParent = pidlParent;
 550     LPCITEMIDLIST pChild = pidlChild;
 551
 552     TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
 553
 554     if (!pParent || !pChild)
 555         return FALSE;
 556
 557     while (pParent->mkid.cb && pChild->mkid.cb)
 558     {
 559         _ILSimpleGetText(pParent, szData1, MAX_PATH);
 560         _ILSimpleGetText(pChild, szData2, MAX_PATH);
 561
 562         if (lstrcmpiA( szData1, szData2 ))
 563             return FALSE;
 564
 565         pParent = ILGetNext(pParent);
 566         pChild = ILGetNext(pChild);
 567     }
 568
 569     /* child has shorter name than parent */
 570     if (pParent->mkid.cb)
 571         return FALSE;
 572
 573     /* not immediate descent */
 574     if ((!pChild->mkid.cb || ILGetNext(pChild)->mkid.cb) && bImmediate)
 575         return FALSE;
 576
 577     return TRUE;
 578 }
 579
 580 /*************************************************************************
 581  * ILFindChild               [SHELL32.24]
 582  *
 583  *  Compares elements from pidl1 and pidl2.
 584  *
 585  * PARAMS
 586  *  pidl1      [I]
 587  *  pidl2      [I]
 588  *
 589  * RETURNS
 590  *  pidl1 is desktop      pidl2
 591  *  pidl1 shorter pidl2   pointer to first different element of pidl2
 592  *                        if there was at least one equal element
 593  *  pidl2 shorter pidl1   0
 594  *  pidl2 equal pidl1     pointer to last 0x00-element of pidl2
 595  *
 596  * NOTES
 597  *  exported by ordinal.
 598  */
 599 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 600 {
 601     char    szData1[MAX_PATH];
 602     char    szData2[MAX_PATH];
 603
 604     LPCITEMIDLIST pidltemp1 = pidl1;
 605     LPCITEMIDLIST pidltemp2 = pidl2;
 606     LPCITEMIDLIST ret=NULL;
 607
 608     TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 609
 610     /* explorer reads from registry directly (StreamMRU),
 611        so we can only check here */
 612     if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
 613         return FALSE;
 614
 615     pdump (pidl1);
 616     pdump (pidl2);
 617
 618     if (_ILIsDesktop(pidl1))
 619     {
 620         ret = pidl2;
 621     }
 622     else
 623     {
 624         while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 625         {
 626             _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
 627             _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
 628
 629             if (lstrcmpiA(szData1,szData2))
 630                 break;
 631
 632             pidltemp1 = ILGetNext(pidltemp1);
 633             pidltemp2 = ILGetNext(pidltemp2);
 634             ret = pidltemp2;
 635         }
 636
 637         if (pidltemp1->mkid.cb)
 638             ret = NULL; /* elements of pidl1 left*/
 639     }
 640     TRACE_(shell)("--- %p\n", ret);
 641     return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
 642 }
 643
 644 /*************************************************************************
 645  * ILCombine                 [SHELL32.25]
 646  *
 647  * Concatenates two complex ItemIDLists.
 648  *
 649  * PARAMS
 650  *  pidl1      [I]   first complex ItemIDLists
 651  *  pidl2      [I]   complex ItemIDLists to append
 652  *
 653  * RETURNS
 654  *  if both pidl's == NULL      NULL
 655  *  if pidl1 == NULL            cloned pidl2
 656  *  if pidl2 == NULL            cloned pidl1
 657  *  otherwise new pidl with pidl2 appended to pidl1
 658  *
 659  * NOTES
 660  *  exported by ordinal.
 661  *  Does not destroy the passed in ItemIDLists!
 662  */
 663 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 664 {
 665     DWORD    len1,len2;
 666     LPITEMIDLIST  pidlNew;
 667
 668     TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
 669
 670     if (!pidl1 && !pidl2) return NULL;
 671
 672     pdump (pidl1);
 673     pdump (pidl2);
 674
 675     if (!pidl1)
 676     {
 677         pidlNew = ILClone(pidl2);
 678         return pidlNew;
 679     }
 680
 681     if (!pidl2)
 682     {
 683         pidlNew = ILClone(pidl1);
 684         return pidlNew;
 685     }
 686
 687     len1  = ILGetSize(pidl1)-2;
 688     len2  = ILGetSize(pidl2);
 689     pidlNew  = SHAlloc(len1+len2);
 690
 691     if (pidlNew)
 692     {
 693         memcpy(pidlNew,pidl1,len1);
 694         memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
 695     }
 696
 697     /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
 698     return pidlNew;
 699 }
 700
 701 /*************************************************************************
 702  *  SHGetRealIDL [SHELL32.98]
 703  *
 704  * NOTES
 705  */
 706 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
 707 {
 708     IDataObject* pDataObj;
 709     HRESULT hr;
 710
 711     hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple,
 712                              &IID_IDataObject, 0, (LPVOID*)&pDataObj);
 713     if (SUCCEEDED(hr))
 714     {
 715         STGMEDIUM medium;
 716         FORMATETC fmt;
 717
 718         fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
 719         fmt.ptd = NULL;
 720         fmt.dwAspect = DVASPECT_CONTENT;
 721         fmt.lindex = -1;
 722         fmt.tymed = TYMED_HGLOBAL;
 723
 724         hr = IDataObject_GetData(pDataObj, &fmt, &medium);
 725
 726         IDataObject_Release(pDataObj);
 727
 728         if (SUCCEEDED(hr))
 729         {
 730             /*assert(pida->cidl==1);*/
 731             LPIDA pida = GlobalLock(medium.u.hGlobal);
 732
 733             LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
 734             LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
 735
 736             *pidlReal = ILCombine(pidl_folder, pidl_child);
 737
 738             if (!*pidlReal)
 739                 hr = E_OUTOFMEMORY;
 740
 741             GlobalUnlock(medium.u.hGlobal);
 742             GlobalFree(medium.u.hGlobal);
 743         }
 744     }
 745
 746     return hr;
 747 }
 748
 749 /*************************************************************************
 750  *  SHLogILFromFSIL [SHELL32.95]
 751  *
 752  * NOTES
 753  *  pild = CSIDL_DESKTOP    ret = 0
 754  *  pild = CSIDL_DRIVES     ret = 0
 755  */
 756 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
 757 {
 758     FIXME("(pidl=%p)\n",pidl);
 759
 760     pdump(pidl);
 761
 762     return 0;
 763 }
 764
 765 /*************************************************************************
 766  * ILGetSize                 [SHELL32.152]
 767  *
 768  * Gets the byte size of an ItemIDList including zero terminator
 769  *
 770  * PARAMS
 771  *  pidl       [I]   ItemIDList
 772  *
 773  * RETURNS
 774  *  size of pidl in bytes
 775  *
 776  * NOTES
 777  *  exported by ordinal
 778  */
 779 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
 780 {
 781     LPCSHITEMID si = &(pidl->mkid);
 782     UINT len=0;
 783
 784     if (pidl)
 785     {
 786         while (si->cb)
 787         {
 788             len += si->cb;
 789             si  = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
 790         }
 791         len += 2;
 792     }
 793     TRACE("pidl=%p size=%u\n",pidl, len);
 794     return len;
 795 }
 796
 797 /*************************************************************************
 798  * ILGetNext                 [SHELL32.153]
 799  *
 800  * Gets the next ItemID of an ItemIDList
 801  *
 802  * PARAMS
 803  *  pidl       [I]   ItemIDList
 804  *
 805  * RETURNS
 806  *  null -> null
 807  *  desktop -> null
 808  *  simple pidl -> pointer to 0x0000 element
 809  *
 810  * NOTES
 811  *  exported by ordinal.
 812  */
 813 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
 814 {
 815     WORD len;
 816
 817     TRACE("%p\n", pidl);
 818
 819     if (pidl)
 820     {
 821         len =  pidl->mkid.cb;
 822         if (len)
 823         {
 824             pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
 825             TRACE("-- %p\n", pidl);
 826             return (LPITEMIDLIST)pidl;
 827         }
 828     }
 829     return NULL;
 830 }
 831
 832 /*************************************************************************
 833  * ILAppendID                [SHELL32.154]
 834  *
 835  * Adds the single ItemID item to the ItemIDList indicated by pidl.
 836  * If bEnd is FALSE, inserts the item in the front of the list,
 837  * otherwise it adds the item to the end. (???)
 838  *
 839  * PARAMS
 840  *  pidl       [I]   ItemIDList to extend
 841  *  item       [I]   ItemID to prepend/append
 842  *  bEnd       [I]   Indicates if the item should be appended
 843  *
 844  * NOTES
 845  *  Destroys the passed in idlist! (???)
 846  */
 847 LPITEMIDLIST WINAPI ILAppendID(LPITEMIDLIST pidl, LPCSHITEMID item, BOOL bEnd)
 848 {
 849     LPITEMIDLIST idlRet;
 850     LPCITEMIDLIST itemid = (LPCITEMIDLIST)item;
 851
 852     WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
 853
 854     pdump (pidl);
 855     pdump (itemid);
 856
 857     if (_ILIsDesktop(pidl))
 858     {
 859         idlRet = ILClone(itemid);
 860         SHFree (pidl);
 861         return idlRet;
 862     }
 863
 864     if (bEnd)
 865         idlRet = ILCombine(pidl, itemid);
 866     else
 867         idlRet = ILCombine(itemid, pidl);
 868
 869     SHFree(pidl);
 870     return idlRet;
 871 }
 872
 873 /*************************************************************************
 874  * ILFree                    [SHELL32.155]
 875  *
 876  * Frees memory (if not NULL) allocated by SHMalloc allocator
 877  *
 878  * PARAMS
 879  *  pidl         [I]
 880  *
 881  * RETURNS
 882  *  Nothing
 883  *
 884  * NOTES
 885  *  exported by ordinal
 886  */
 887 void WINAPI ILFree(LPITEMIDLIST pidl)
 888 {
 889     TRACE("(pidl=%p)\n",pidl);
 890     SHFree(pidl);
 891 }
 892
 893 /*************************************************************************
 894  * ILGlobalFree              [SHELL32.156]
 895  *
 896  * Frees memory (if not NULL) allocated by Alloc allocator
 897  *
 898  * PARAMS
 899  *  pidl         [I]
 900  *
 901  * RETURNS
 902  *  Nothing
 903  *
 904  * NOTES
 905  *  exported by ordinal.
 906  */
 907 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
 908 {
 909     TRACE("%p\n", pidl);
 910
 911     Free(pidl);
 912 }
 913
 914 /*************************************************************************
 915  * ILCreateFromPathA         [SHELL32.189]
 916  *
 917  * Creates a complex ItemIDList from a path and returns it.
 918  *
 919  * PARAMS
 920  *  path         [I]
 921  *
 922  * RETURNS
 923  *  the newly created complex ItemIDList or NULL if failed
 924  *
 925  * NOTES
 926  *  exported by ordinal.
 927  */
 928 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
 929 {
 930     LPITEMIDLIST pidlnew = NULL;
 931
 932     TRACE_(shell)("%s\n", debugstr_a(path));
 933
 934     if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
 935         return pidlnew;
 936     return NULL;
 937 }
 938
 939 /*************************************************************************
 940  * ILCreateFromPathW         [SHELL32.190]
 941  *
 942  * See ILCreateFromPathA.
 943  */
 944 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
 945 {
 946     LPITEMIDLIST pidlnew = NULL;
 947
 948     TRACE_(shell)("%s\n", debugstr_w(path));
 949
 950     if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
 951         return pidlnew;
 952     return NULL;
 953 }
 954
 955 /*************************************************************************
 956  * ILCreateFromPath          [SHELL32.157]
 957  */
 958 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
 959 {
 960     if ( SHELL_OsIsUnicode())
 961         return ILCreateFromPathW (path);
 962     return ILCreateFromPathA (path);
 963 }
 964
 965 /*************************************************************************
 966  * _ILParsePathW             [internal]
 967  *
 968  * Creates an ItemIDList from a path and returns it.
 969  *
 970  * PARAMS
 971  *  path         [I]   path to parse and convert into an ItemIDList
 972  *  lpFindFile   [I]   pointer to buffer to initialize the FileSystem
 973  *                     Bind Data object with
 974  *  bBindCtx     [I]   indicates to create a BindContext and assign a
 975  *                     FileSystem Bind Data object
 976  *  ppidl        [O]   the newly create ItemIDList
 977  *  prgfInOut    [I/O] requested attributes on input and actual
 978  *                     attributes on return
 979  *
 980  * RETURNS
 981  *  NO_ERROR on success or an OLE error code
 982  *
 983  * NOTES
 984  *  If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
 985  *  creates a BindContext object and assigns a FileSystem Bind Data object
 986  *  to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
 987  *  IShellFolder uses that FileSystem Bind Data object of the BindContext
 988  *  to pass data about the current path element to the next object. This
 989  *  is used to avoid having to verify the current path element on disk, so
 990  *  that creating an ItemIDList from a nonexistent path still can work.
 991  */
 992 static HRESULT _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
 993                              BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
 994 {
 995     LPSHELLFOLDER pSF = NULL;
 996     LPBC pBC = NULL;
 997     HRESULT ret;
 998
 999     TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
1000                                              ppidl, ppidl ? *ppidl : NULL,
1001                                              prgfInOut, prgfInOut ? *prgfInOut : 0);
1002
1003     ret = SHGetDesktopFolder(&pSF);
1004     if (FAILED(ret))
1005         return ret;
1006
1007     if (lpFindFile || bBindCtx)
1008         ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1009
1010     if (SUCCEEDED(ret))
1011     {
1012         ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1013     }
1014
1015     if (pBC)
1016     {
1017         IBindCtx_Release(pBC);
1018         pBC = NULL;
1019     }
1020
1021     IShellFolder_Release(pSF);
1022
1023     if (FAILED(ret) && ppidl)
1024         *ppidl = NULL;
1025
1026     TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1027
1028     return ret;
1029 }
1030
1031 /*************************************************************************
1032  * SHSimpleIDListFromPath    [SHELL32.162]
1033  *
1034  * Creates a simple ItemIDList from a path and returns it. This function
1035  * does not fail on nonexistent paths.
1036  *
1037  * PARAMS
1038  *  path         [I]   path to parse and convert into an ItemIDList
1039  *
1040  * RETURNS
1041  *  the newly created simple ItemIDList
1042  *
1043  * NOTES
1044  *  Simple in the name does not mean a relative ItemIDList but rather a
1045  *  fully qualified list, where only the file name is filled in and the
1046  *  directory flag for those ItemID elements this is known about, eg.
1047  *  it is not the last element in the ItemIDList or the actual directory
1048  *  exists on disk.
1049  *  exported by ordinal.
1050  */
1051 LPITEMIDLIST SHSimpleIDListFromPathA(LPCSTR lpszPath)
1052 {
1053     LPITEMIDLIST pidl = NULL;
1054     LPWSTR wPath = NULL;
1055     int len;
1056
1057     TRACE("%s\n", debugstr_a(lpszPath));
1058
1059     if (lpszPath)
1060     {
1061         len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1062         wPath = heap_alloc(len * sizeof(WCHAR));
1063         MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1064     }
1065
1066     _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1067
1068     heap_free(wPath);
1069     TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1070     return pidl;
1071 }
1072
1073 LPITEMIDLIST SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1074 {
1075     LPITEMIDLIST pidl = NULL;
1076
1077     TRACE("%s\n", debugstr_w(lpszPath));
1078
1079     _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1080     TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1081     return pidl;
1082 }
1083
1084 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1085 {
1086     if ( SHELL_OsIsUnicode())
1087         return SHSimpleIDListFromPathW (lpszPath);
1088     return SHSimpleIDListFromPathA (lpszPath);
1089 }
1090
1091 /*************************************************************************
1092  * SHGetDataFromIDListA [SHELL32.247]
1093  *
1094  * NOTES
1095  *  the pidl can be a simple one. since we can't get the path out of the pidl
1096  *  we have to take all data from the pidl
1097  */
1098 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1099                                     int nFormat, LPVOID dest, int len)
1100 {
1101     LPSTR filename, shortname;
1102     WIN32_FIND_DATAA * pfd;
1103
1104     TRACE_(shell)("%p, %p, %d, %p, %d.\n", psf, pidl, nFormat, dest, len);
1105
1106     pdump(pidl);
1107     if (!psf || !dest)
1108         return E_INVALIDARG;
1109
1110     switch (nFormat)
1111     {
1112     case SHGDFIL_FINDDATA:
1113         pfd = dest;
1114
1115         if (_ILIsDrive(pidl) || _ILIsSpecialFolder(pidl))
1116             return E_INVALIDARG;
1117
1118         if (len < sizeof(WIN32_FIND_DATAA))
1119             return E_INVALIDARG;
1120
1121         ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1122         _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1123         pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1124         pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1125
1126         filename = _ILGetTextPointer(pidl);
1127         shortname = _ILGetSTextPointer(pidl);
1128
1129         if (filename)
1130             lstrcpynA(pfd->cFileName, filename, sizeof(pfd->cFileName));
1131         else
1132             pfd->cFileName[0] = '\0';
1133
1134         if (shortname)
1135             lstrcpynA(pfd->cAlternateFileName, shortname, sizeof(pfd->cAlternateFileName));
1136         else
1137             pfd->cAlternateFileName[0] = '\0';
1138         return S_OK;
1139
1140     case SHGDFIL_NETRESOURCE:
1141     case SHGDFIL_DESCRIPTIONID:
1142         FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1143         break;
1144
1145     default:
1146         ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1147     }
1148
1149     return E_INVALIDARG;
1150 }
1151
1152 /*************************************************************************
1153  * SHGetDataFromIDListW [SHELL32.248]
1154  *
1155  */
1156 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1157                                     int nFormat, LPVOID dest, int len)
1158 {
1159     LPSTR filename, shortname;
1160     WIN32_FIND_DATAW * pfd = dest;
1161
1162     TRACE_(shell)("%p, %p, %d, %p, %d.\n", psf, pidl, nFormat, dest, len);
1163
1164     pdump(pidl);
1165
1166     if (!psf || !dest)
1167         return E_INVALIDARG;
1168
1169     switch (nFormat)
1170     {
1171     case SHGDFIL_FINDDATA:
1172         pfd = dest;
1173
1174         if (_ILIsDrive(pidl))
1175             return E_INVALIDARG;
1176
1177         if (len < sizeof(WIN32_FIND_DATAW))
1178             return E_INVALIDARG;
1179
1180         ZeroMemory(pfd, sizeof (WIN32_FIND_DATAW));
1181         _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1182         pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1183         pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1184
1185         filename = _ILGetTextPointer(pidl);
1186         shortname = _ILGetSTextPointer(pidl);
1187
1188         if (!filename)
1189             pfd->cFileName[0] = '\0';
1190         else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1191             pfd->cFileName[MAX_PATH-1] = 0;
1192
1193         if (!shortname)
1194             pfd->cAlternateFileName[0] = '\0';
1195         else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1196             pfd->cAlternateFileName[13] = 0;
1197         return S_OK;
1198
1199     case SHGDFIL_NETRESOURCE:
1200     case SHGDFIL_DESCRIPTIONID:
1201         FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1202         break;
1203
1204     default:
1205         ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1206     }
1207
1208     return E_INVALIDARG;
1209 }
1210
1211 /*************************************************************************
1212  * SHGetPathFromIDListA        [SHELL32.@][NT 4.0: SHELL32.220]
1213  *
1214  * PARAMETERS
1215  *  pidl,   [IN] pidl
1216  *  pszPath [OUT] path
1217  *
1218  * RETURNS
1219  *  path from a passed PIDL.
1220  *
1221  * NOTES
1222  *    NULL returns FALSE
1223  *    desktop pidl gives path to desktop directory back
1224  *    special pidls returning FALSE
1225  */
1226 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1227 {
1228     WCHAR wszPath[MAX_PATH];
1229     BOOL bSuccess;
1230
1231     bSuccess = SHGetPathFromIDListW(pidl, wszPath);
1232     WideCharToMultiByte(CP_ACP, 0, wszPath, -1, pszPath, MAX_PATH, NULL, NULL);
1233
1234     return bSuccess;
1235 }
1236
1237 /*************************************************************************
1238  * SHGetPathFromIDListW             [SHELL32.@]
1239  *
1240  * See SHGetPathFromIDListA.
1241  */
1242 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1243 {
1244     return SHGetPathFromIDListEx(pidl, pszPath, MAX_PATH, 0);
1245 }
1246
1247 /*************************************************************************
1248  * SHGetPathFromIDListEx             [SHELL32.@]
1249  */
1250 BOOL WINAPI SHGetPathFromIDListEx(LPCITEMIDLIST pidl, WCHAR *path, DWORD path_size, GPFIDL_FLAGS flags)
1251 {
1252     HRESULT hr;
1253     LPCITEMIDLIST pidlLast;
1254     LPSHELLFOLDER psfFolder;
1255     DWORD dwAttributes;
1256     STRRET strret;
1257
1258     TRACE_(shell)("(pidl=%p,%p,%lu,%x)\n", pidl, path, path_size, flags);
1259     pdump(pidl);
1260
1261     if (flags != GPFIDL_DEFAULT)
1262         FIXME("Unsupported flags %x\n", flags);
1263
1264     *path = '\0';
1265     if (!pidl)
1266         return FALSE;
1267
1268     hr = SHBindToParent(pidl, &IID_IShellFolder, (VOID**)&psfFolder, &pidlLast);
1269     if (FAILED(hr)) return FALSE;
1270
1271     dwAttributes = SFGAO_FILESYSTEM;
1272     hr = IShellFolder_GetAttributesOf(psfFolder, 1, &pidlLast, &dwAttributes);
1273     if (FAILED(hr) || !(dwAttributes & SFGAO_FILESYSTEM)) {
1274         IShellFolder_Release(psfFolder);
1275         return FALSE;
1276     }
1277
1278     hr = IShellFolder_GetDisplayNameOf(psfFolder, pidlLast, SHGDN_FORPARSING, &strret);
1279     IShellFolder_Release(psfFolder);
1280     if (FAILED(hr)) return FALSE;
1281
1282     hr = StrRetToBufW(&strret, pidlLast, path, path_size);
1283
1284     TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(path), hr);
1285     return SUCCEEDED(hr);
1286 }
1287
1288 /*************************************************************************
1289  *    SHBindToParent        [shell version 5.0]
1290  */
1291 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1292 {
1293     IShellFolder    * psfDesktop;
1294     HRESULT         hr=E_FAIL;
1295
1296     TRACE_(shell)("pidl=%p\n", pidl);
1297     pdump(pidl);
1298
1299     if (!pidl || !ppv)
1300         return E_INVALIDARG;
1301
1302     *ppv = NULL;
1303     if (ppidlLast)
1304         *ppidlLast = NULL;
1305
1306     hr = SHGetDesktopFolder(&psfDesktop);
1307     if (FAILED(hr))
1308         return hr;
1309
1310     if (_ILIsPidlSimple(pidl))
1311     {
1312         /* we are on desktop level */
1313         hr = IShellFolder_QueryInterface(psfDesktop, riid, ppv);
1314     }
1315     else
1316     {
1317         LPITEMIDLIST pidlParent = ILClone(pidl);
1318         ILRemoveLastID(pidlParent);
1319         hr = IShellFolder_BindToObject(psfDesktop, pidlParent, NULL, riid, ppv);
1320         SHFree (pidlParent);
1321     }
1322
1323     IShellFolder_Release(psfDesktop);
1324
1325     if (SUCCEEDED(hr) && ppidlLast)
1326         *ppidlLast = ILFindLastID(pidl);
1327
1328     TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1329     return hr;
1330 }
1331
1332 HRESULT WINAPI SHBindToObject(IShellFolder *psf, LPCITEMIDLIST pidl, IBindCtx *pbc, REFIID riid, void **ppv)
1333 {
1334     IShellFolder *psfDesktop = NULL;
1335     HRESULT hr;
1336
1337     TRACE_(shell)("%p,%p,%p,%s,%p\n", psf, pidl, pbc, debugstr_guid(riid), ppv);
1338     pdump(pidl);
1339
1340     if (!ppv)
1341         return E_INVALIDARG;
1342
1343     *ppv = NULL;
1344
1345     if (!psf)
1346     {
1347         hr = SHGetDesktopFolder(&psfDesktop);
1348         if (FAILED(hr))
1349             return hr;
1350         psf = psfDesktop;
1351     }
1352
1353     if (_ILIsPidlSimple(pidl))
1354         /* we are on desktop level */
1355         hr = IShellFolder_QueryInterface(psf, riid, ppv);
1356     else
1357         hr = IShellFolder_BindToObject(psf, pidl, pbc, riid, ppv);
1358
1359     if (psfDesktop)
1360         IShellFolder_Release(psfDesktop);
1361
1362     TRACE_(shell)("-- ppv=%p ret=0x%08lx\n", *ppv, hr);
1363     return hr;
1364 }
1365
1366
1367 /*************************************************************************
1368  * SHParseDisplayName             [SHELL32.@]
1369  */
1370 HRESULT WINAPI SHParseDisplayName(LPCWSTR name, IBindCtx *bindctx, LPITEMIDLIST *pidlist,
1371                                   SFGAOF attr_in, SFGAOF *attr_out)
1372 {
1373     IShellFolder *desktop;
1374     HRESULT hr;
1375
1376     TRACE("%s %p %p %ld %p\n", debugstr_w(name), bindctx, pidlist, attr_in, attr_out);
1377
1378     *pidlist = NULL;
1379
1380     if (!name) return E_INVALIDARG;
1381
1382     hr = SHGetDesktopFolder(&desktop);
1383     if (hr != S_OK) return hr;
1384
1385     hr = IShellFolder_ParseDisplayName(desktop, NULL, bindctx, (LPWSTR)name, NULL, pidlist, &attr_in);
1386     if (attr_out) *attr_out = attr_in;
1387
1388     IShellFolder_Release(desktop);
1389
1390     return hr;
1391 }
1392
1393 /*************************************************************************
1394  * SHGetNameFromIDList             [SHELL32.@]
1395  */
1396 HRESULT WINAPI SHGetNameFromIDList(PCIDLIST_ABSOLUTE pidl, SIGDN sigdnName, PWSTR *ppszName)
1397 {
1398     IShellFolder *psfparent;
1399     LPCITEMIDLIST child_pidl;
1400     STRRET disp_name;
1401     HRESULT ret;
1402
1403     TRACE("%p 0x%08x %p\n", pidl, sigdnName, ppszName);
1404
1405     *ppszName = NULL;
1406     ret = SHBindToParent(pidl, &IID_IShellFolder, (void**)&psfparent, &child_pidl);
1407     if(SUCCEEDED(ret))
1408     {
1409         switch(sigdnName)
1410         {
1411                                                 /* sigdnName & 0xffff */
1412         case SIGDN_NORMALDISPLAY:               /* SHGDN_NORMAL */
1413         case SIGDN_PARENTRELATIVEPARSING:       /* SHGDN_INFOLDER | SHGDN_FORPARSING */
1414         case SIGDN_PARENTRELATIVEEDITING:       /* SHGDN_INFOLDER | SHGDN_FOREDITING */
1415         case SIGDN_DESKTOPABSOLUTEPARSING:      /* SHGDN_FORPARSING */
1416         case SIGDN_DESKTOPABSOLUTEEDITING:      /* SHGDN_FOREDITING | SHGDN_FORADDRESSBAR*/
1417         case SIGDN_PARENTRELATIVEFORADDRESSBAR: /* SIGDN_INFOLDER | SHGDN_FORADDRESSBAR */
1418         case SIGDN_PARENTRELATIVE:              /* SIGDN_INFOLDER */
1419
1420             disp_name.uType = STRRET_WSTR;
1421             ret = IShellFolder_GetDisplayNameOf(psfparent, child_pidl,
1422                                                 sigdnName & 0xffff,
1423                                                 &disp_name);
1424             if(SUCCEEDED(ret))
1425                 ret = StrRetToStrW(&disp_name, pidl, ppszName);
1426
1427             break;
1428
1429         case SIGDN_FILESYSPATH:
1430             *ppszName = CoTaskMemAlloc(sizeof(WCHAR)*MAX_PATH);
1431             if(SHGetPathFromIDListW(pidl, *ppszName))
1432             {
1433                 TRACE("Got string %s\n", debugstr_w(*ppszName));
1434                 ret = S_OK;
1435             }
1436             else
1437             {
1438                 CoTaskMemFree(*ppszName);
1439                 ret = E_INVALIDARG;
1440             }
1441             break;
1442
1443         case SIGDN_URL:
1444         default:
1445             FIXME("Unsupported SIGDN %x\n", sigdnName);
1446             ret = E_FAIL;
1447         }
1448
1449         IShellFolder_Release(psfparent);
1450     }
1451     return ret;
1452 }
1453
1454 /*************************************************************************
1455  * SHGetIDListFromObject             [SHELL32.@]
1456  */
1457 HRESULT WINAPI SHGetIDListFromObject(IUnknown *punk, PIDLIST_ABSOLUTE *ppidl)
1458 {
1459     IPersistIDList *ppersidl;
1460     IPersistFolder2 *ppf2;
1461     IDataObject *pdo;
1462     IFolderView *pfv;
1463     HRESULT ret;
1464
1465     if(!punk)
1466         return E_NOINTERFACE;
1467
1468     *ppidl = NULL;
1469
1470     /* Try IPersistIDList */
1471     ret = IUnknown_QueryInterface(punk, &IID_IPersistIDList, (void**)&ppersidl);
1472     if(SUCCEEDED(ret))
1473     {
1474         TRACE("IPersistIDList (%p)\n", ppersidl);
1475         ret = IPersistIDList_GetIDList(ppersidl, ppidl);
1476         IPersistIDList_Release(ppersidl);
1477         if(SUCCEEDED(ret))
1478             return ret;
1479     }
1480
1481     /* Try IPersistFolder2 */
1482     ret = IUnknown_QueryInterface(punk, &IID_IPersistFolder2, (void**)&ppf2);
1483     if(SUCCEEDED(ret))
1484     {
1485         TRACE("IPersistFolder2 (%p)\n", ppf2);
1486         ret = IPersistFolder2_GetCurFolder(ppf2, ppidl);
1487         IPersistFolder2_Release(ppf2);
1488         if(SUCCEEDED(ret))
1489             return ret;
1490     }
1491
1492     /* Try IDataObject */
1493     ret = IUnknown_QueryInterface(punk, &IID_IDataObject, (void**)&pdo);
1494     if(SUCCEEDED(ret))
1495     {
1496         IShellItem *psi;
1497         TRACE("IDataObject (%p)\n", pdo);
1498         ret = SHGetItemFromDataObject(pdo, DOGIF_ONLY_IF_ONE,
1499                                       &IID_IShellItem, (void**)&psi);
1500         if(SUCCEEDED(ret))
1501         {
1502             ret = SHGetIDListFromObject((IUnknown*)psi, ppidl);
1503             IShellItem_Release(psi);
1504         }
1505         IDataObject_Release(pdo);
1506
1507         if(SUCCEEDED(ret))
1508             return ret;
1509     }
1510
1511     /* Try IFolderView */
1512     ret = IUnknown_QueryInterface(punk, &IID_IFolderView, (void**)&pfv);
1513     if(SUCCEEDED(ret))
1514     {
1515         IShellFolder *psf;
1516         TRACE("IFolderView (%p)\n", pfv);
1517         ret = IFolderView_GetFolder(pfv, &IID_IShellFolder, (void**)&psf);
1518         if(SUCCEEDED(ret))
1519         {
1520             /* We might be able to get IPersistFolder2 from a shellfolder. */
1521             ret = SHGetIDListFromObject((IUnknown*)psf, ppidl);
1522             IShellFolder_Release(psf);
1523         }
1524         IFolderView_Release(pfv);
1525         return ret;
1526     }
1527
1528     return ret;
1529 }
1530
1531 /**************************************************************************
1532  *
1533  *        internal functions
1534  *
1535  *    ### 1. section creating pidls ###
1536  *
1537  *************************************************************************
1538  */
1539
1540 /* Basic PIDL constructor.  Allocates size + 5 bytes, where:
1541  * - two bytes are SHITEMID.cb
1542  * - one byte is PIDLDATA.type
1543  * - two bytes are the NULL PIDL terminator
1544  * Sets type of the returned PIDL to type.
1545  */
1546 static LPITEMIDLIST _ILAlloc(PIDLTYPE type, unsigned int size)
1547 {
1548     LPITEMIDLIST pidlOut = NULL;
1549
1550     pidlOut = SHAlloc(size + 5);
1551     if(pidlOut)
1552     {
1553         LPPIDLDATA pData;
1554         LPITEMIDLIST pidlNext;
1555
1556         ZeroMemory(pidlOut, size + 5);
1557         pidlOut->mkid.cb = size + 3;
1558
1559         pData = _ILGetDataPointer(pidlOut);
1560         if (pData)
1561             pData->type = type;
1562
1563         pidlNext = ILGetNext(pidlOut);
1564         if (pidlNext)
1565             pidlNext->mkid.cb = 0x00;
1566         TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1567     }
1568
1569     return pidlOut;
1570 }
1571
1572 LPITEMIDLIST _ILCreateDesktop(void)
1573 {
1574     LPITEMIDLIST ret;
1575
1576     TRACE("()\n");
1577     ret = SHAlloc(sizeof(*ret));
1578     if (ret)
1579         ret->mkid.cb = 0;
1580     return ret;
1581 }
1582
1583 LPITEMIDLIST _ILCreateMyComputer(void)
1584 {
1585     TRACE("()\n");
1586     return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1587 }
1588
1589 LPITEMIDLIST _ILCreateMyDocuments(void)
1590 {
1591     TRACE("()\n");
1592     return _ILCreateGuid(PT_GUID, &CLSID_MyDocuments);
1593 }
1594
1595 LPITEMIDLIST _ILCreateIExplore(void)
1596 {
1597     TRACE("()\n");
1598     return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1599 }
1600
1601 LPITEMIDLIST _ILCreateControlPanel(void)
1602 {
1603     LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1604
1605     TRACE("()\n");
1606     if (parent)
1607     {
1608         LPITEMIDLIST cpl = _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1609
1610         if (cpl)
1611         {
1612             ret = ILCombine(parent, cpl);
1613             SHFree(cpl);
1614         }
1615         SHFree(parent);
1616     }
1617     return ret;
1618 }
1619
1620 LPITEMIDLIST _ILCreatePrinters(void)
1621 {
1622     LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1623
1624     TRACE("()\n");
1625     if (parent)
1626     {
1627         LPITEMIDLIST printers = _ILCreateGuid(PT_YAGUID, &CLSID_Printers);
1628
1629         if (printers)
1630         {
1631             ret = ILCombine(parent, printers);
1632             SHFree(printers);
1633         }
1634         SHFree(parent);
1635     }
1636     return ret;
1637 }
1638
1639 LPITEMIDLIST _ILCreateNetwork(void)
1640 {
1641     TRACE("()\n");
1642     return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1643 }
1644
1645 LPITEMIDLIST _ILCreateBitBucket(void)
1646 {
1647     TRACE("()\n");
1648     return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1649 }
1650
1651 LPITEMIDLIST _ILCreateNetHood(void)
1652 {
1653     TRACE("()\n");
1654     return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1655 }
1656
1657 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1658 {
1659     LPITEMIDLIST pidlOut;
1660
1661     if (type == PT_SHELLEXT || type == PT_GUID || type == PT_YAGUID)
1662     {
1663         pidlOut = _ILAlloc(type, sizeof(GUIDStruct));
1664         if (pidlOut)
1665         {
1666             LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1667
1668             pData->u.guid.guid = *guid;
1669             TRACE("-- create GUID-pidl %s\n",
1670                   debugstr_guid(&(pData->u.guid.guid)));
1671         }
1672     }
1673     else
1674     {
1675         WARN("%d: invalid type for GUID\n", type);
1676         pidlOut = NULL;
1677     }
1678     return pidlOut;
1679 }
1680
1681 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1682 {
1683     IID iid;
1684
1685     if (FAILED(SHCLSIDFromStringA(szGUID, &iid)))
1686     {
1687         ERR("%s is not a GUID\n", szGUID);
1688         return NULL;
1689     }
1690     return _ILCreateGuid(PT_GUID, &iid);
1691 }
1692
1693 LPITEMIDLIST _ILCreateGuidFromStrW(LPCWSTR szGUID)
1694 {
1695     IID iid;
1696
1697     if (FAILED(SHCLSIDFromStringW(szGUID, &iid)))
1698     {
1699         ERR("%s is not a GUID\n", debugstr_w(szGUID));
1700         return NULL;
1701     }
1702     return _ILCreateGuid(PT_GUID, &iid);
1703 }
1704
1705 LPITEMIDLIST _ILCreateFromFindDataW( const WIN32_FIND_DATAW *wfd )
1706 {
1707     DWORD   wlen, alen;
1708     LPITEMIDLIST pidl;
1709     PIDLTYPE type;
1710
1711     if (!wfd)
1712         return NULL;
1713
1714     TRACE("(%s, %s)\n",debugstr_w(wfd->cAlternateFileName), debugstr_w(wfd->cFileName));
1715
1716     type = (wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
1717
1718     alen = WideCharToMultiByte( CP_ACP, 0, wfd->cFileName, -1, NULL, 0, NULL, NULL );
1719     wlen = lstrlenW(wfd->cFileName) + 1;
1720     pidl = _ILAlloc(type, FIELD_OFFSET(FileStruct, szNames[alen + (alen & 1)]) +
1721                     FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD));
1722     if (pidl)
1723     {
1724         LPPIDLDATA pData = _ILGetDataPointer(pidl);
1725         FileStruct *fs = &pData->u.file;
1726         FileStructW *fsw;
1727         WORD *pOffsetW;
1728
1729         FileTimeToDosDateTime( &wfd->ftLastWriteTime, &fs->uFileDate, &fs->uFileTime);
1730         fs->dwFileSize = wfd->nFileSizeLow;
1731         fs->uFileAttribs = wfd->dwFileAttributes;
1732         WideCharToMultiByte( CP_ACP, 0, wfd->cFileName, -1, fs->szNames, alen, NULL, NULL );
1733
1734         fsw = (FileStructW*)(pData->u.file.szNames + alen + (alen & 0x1));
1735         fsw->cbLen = FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD);
1736         FileTimeToDosDateTime( &wfd->ftCreationTime, &fsw->uCreationDate, &fsw->uCreationTime);
1737         FileTimeToDosDateTime( &wfd->ftLastAccessTime, &fsw->uLastAccessDate, &fsw->uLastAccessTime);
1738         memcpy(fsw->wszName, wfd->cFileName, wlen * sizeof(WCHAR));
1739
1740         pOffsetW = (WORD*)((LPBYTE)pidl + pidl->mkid.cb - sizeof(WORD));
1741         *pOffsetW = (LPBYTE)fsw - (LPBYTE)pidl;
1742         TRACE("-- Set Value: %s\n",debugstr_w(fsw->wszName));
1743     }
1744     return pidl;
1745
1746 }
1747
1748 HRESULT _ILCreateFromPathW(LPCWSTR szPath, LPITEMIDLIST* ppidl)
1749 {
1750     HANDLE hFile;
1751     WIN32_FIND_DATAW stffile;
1752
1753     if (!ppidl)
1754         return E_INVALIDARG;
1755
1756     hFile = FindFirstFileW(szPath, &stffile);
1757     if (hFile == INVALID_HANDLE_VALUE)
1758         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1759
1760     FindClose(hFile);
1761
1762     *ppidl = _ILCreateFromFindDataW(&stffile);
1763
1764     return *ppidl ? S_OK : E_OUTOFMEMORY;
1765 }
1766
1767 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
1768 {
1769     LPITEMIDLIST pidlOut;
1770
1771     TRACE("(%s)\n",debugstr_w(lpszNew));
1772
1773     pidlOut = _ILAlloc(PT_DRIVE, sizeof(DriveStruct));
1774     if (pidlOut)
1775     {
1776         LPSTR pszDest;
1777
1778         pszDest = _ILGetTextPointer(pidlOut);
1779         if (pszDest)
1780         {
1781             strcpy(pszDest, "x:\\");
1782             pszDest[0]=towupper(lpszNew[0]);
1783             TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1784         }
1785     }
1786     return pidlOut;
1787 }
1788
1789 LPITEMIDLIST _ILCreateEntireNetwork(void)
1790 {
1791     LPITEMIDLIST pidlOut;
1792
1793     TRACE("\n");
1794
1795     pidlOut = _ILAlloc(PT_NETWORK, FIELD_OFFSET(PIDLDATA, u.network.szNames[sizeof("Entire Network")]));
1796     if (pidlOut)
1797     {
1798         LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1799
1800         pData->u.network.dummy = 0;
1801         strcpy(pData->u.network.szNames, "Entire Network");
1802     }
1803     return pidlOut;
1804 }
1805
1806 /**************************************************************************
1807  *  _ILGetDrive()
1808  *
1809  *  Gets the text for the drive eg. 'c:\'
1810  *
1811  * RETURNS
1812  *  strlen (lpszText)
1813  */
1814 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1815 {
1816     TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1817
1818     if(_ILIsMyComputer(pidl))
1819         pidl = ILGetNext(pidl);
1820
1821     if (pidl && _ILIsDrive(pidl))
1822         return _ILSimpleGetText(pidl, pOut, uSize);
1823
1824     return 0;
1825 }
1826
1827 /**************************************************************************
1828  *
1829  *    ### 2. section testing pidls ###
1830  *
1831  **************************************************************************
1832  *  _ILIsUnicode()
1833  *  _ILIsDesktop()
1834  *  _ILIsMyComputer()
1835  *  _ILIsSpecialFolder()
1836  *  _ILIsDrive()
1837  *  _ILIsFolder()
1838  *  _ILIsValue()
1839  *  _ILIsPidlSimple()
1840  */
1841 BOOL _ILIsUnicode(LPCITEMIDLIST pidl)
1842 {
1843     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1844
1845     TRACE("(%p)\n",pidl);
1846
1847     return (pidl && lpPData && PT_VALUEW == lpPData->type);
1848 }
1849
1850 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1851 {
1852     TRACE("(%p)\n",pidl);
1853
1854     return !pidl || !pidl->mkid.cb;
1855 }
1856
1857 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1858 {
1859     REFIID iid = _ILGetGUIDPointer(pidl);
1860
1861     TRACE("(%p)\n",pidl);
1862
1863     if (iid)
1864         return IsEqualIID(iid, &CLSID_MyComputer);
1865     return FALSE;
1866 }
1867
1868 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1869 {
1870     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1871
1872     TRACE("(%p)\n",pidl);
1873
1874     return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type || PT_YAGUID == lpPData->type)) ||
1875               (pidl && pidl->mkid.cb == 0x00)
1876             ));
1877 }
1878
1879 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1880 {
1881     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1882
1883     TRACE("(%p)\n",pidl);
1884
1885     return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1886                     PT_DRIVE1 == lpPData->type ||
1887                     PT_DRIVE2 == lpPData->type ||
1888                     PT_DRIVE3 == lpPData->type));
1889 }
1890
1891 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1892 {
1893     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1894
1895     TRACE("(%p)\n",pidl);
1896
1897     return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1898 }
1899
1900 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1901 {
1902     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1903
1904     TRACE("(%p)\n",pidl);
1905
1906     return (pidl && lpPData && PT_VALUE == lpPData->type);
1907 }
1908
1909 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1910 {
1911     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1912
1913     TRACE("(%p)\n",pidl);
1914
1915     return (pidl && lpPData && (lpPData->type == 0));
1916 }
1917
1918 /**************************************************************************
1919  *    _ILIsPidlSimple
1920  */
1921 BOOL _ILIsPidlSimple(LPCITEMIDLIST pidl)
1922 {
1923     BOOL ret = TRUE;
1924
1925     if(! _ILIsDesktop(pidl))    /* pidl=NULL or mkid.cb=0 */
1926     {
1927         WORD len = pidl->mkid.cb;
1928         LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
1929
1930         if (pidlnext->mkid.cb)
1931             ret = FALSE;
1932     }
1933
1934     TRACE("%s\n", ret ? "Yes" : "No");
1935     return ret;
1936 }
1937
1938 /**************************************************************************
1939  *
1940  *    ### 3. section getting values from pidls ###
1941  */
1942
1943  /**************************************************************************
1944  *  _ILSimpleGetText
1945  *
1946  * gets the text for the first item in the pidl (eg. simple pidl)
1947  *
1948  * returns the length of the string
1949  */
1950 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1951 {
1952     DWORD        dwReturn=0;
1953     LPSTR        szSrc;
1954     LPWSTR       szSrcW;
1955     GUID const * riid;
1956     char szTemp[MAX_PATH];
1957
1958     TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1959
1960     if (!pidl)
1961         return 0;
1962
1963     if (szOut)
1964         *szOut = 0;
1965
1966     if (_ILIsDesktop(pidl))
1967     {
1968         /* desktop */
1969         if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1970         {
1971             if (szOut)
1972                 lstrcpynA(szOut, szTemp, uOutSize);
1973
1974             dwReturn = strlen (szTemp);
1975         }
1976     }
1977     else if (( szSrc = _ILGetTextPointer(pidl) ))
1978     {
1979         /* filesystem */
1980         if (szOut)
1981             lstrcpynA(szOut, szSrc, uOutSize);
1982
1983         dwReturn = strlen(szSrc);
1984     }
1985     else if (( szSrcW = _ILGetTextPointerW(pidl) ))
1986     {
1987         /* unicode filesystem */
1988         WideCharToMultiByte(CP_ACP,0,szSrcW, -1, szTemp, MAX_PATH, NULL, NULL);
1989
1990         if (szOut)
1991             lstrcpynA(szOut, szTemp, uOutSize);
1992
1993         dwReturn = strlen (szTemp);
1994     }
1995     else if (( riid = _ILGetGUIDPointer(pidl) ))
1996     {
1997         /* special folder */
1998         if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1999         {
2000             if (szOut)
2001                 lstrcpynA(szOut, szTemp, uOutSize);
2002
2003             dwReturn = strlen (szTemp);
2004         }
2005     }
2006     else
2007     {
2008         ERR("-- no text\n");
2009     }
2010
2011     TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
2012     return dwReturn;
2013 }
2014
2015  /**************************************************************************
2016  *  _ILSimpleGetTextW
2017  *
2018  * gets the text for the first item in the pidl (eg. simple pidl)
2019  *
2020  * returns the length of the string
2021  */
2022 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
2023 {
2024     DWORD   dwReturn;
2025     FileStructW *pFileStructW = _ILGetFileStructW(pidl);
2026
2027     TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
2028
2029     if (pFileStructW) {
2030         lstrcpynW(szOut, pFileStructW->wszName, uOutSize);
2031         dwReturn = lstrlenW(pFileStructW->wszName);
2032     } else {
2033         GUID const * riid;
2034         WCHAR szTemp[MAX_PATH];
2035         LPSTR szSrc;
2036         LPWSTR szSrcW;
2037         dwReturn=0;
2038
2039         if (!pidl)
2040             return 0;
2041
2042         if (szOut)
2043             *szOut = 0;
2044
2045         if (_ILIsDesktop(pidl))
2046         {
2047             /* desktop */
2048             if (HCR_GetClassNameW(&CLSID_ShellDesktop, szTemp, MAX_PATH))
2049             {
2050                 if (szOut)
2051                     lstrcpynW(szOut, szTemp, uOutSize);
2052
2053                 dwReturn = lstrlenW (szTemp);
2054             }
2055         }
2056         else if (( szSrcW = _ILGetTextPointerW(pidl) ))
2057         {
2058             /* unicode filesystem */
2059             if (szOut)
2060                 lstrcpynW(szOut, szSrcW, uOutSize);
2061
2062             dwReturn = lstrlenW(szSrcW);
2063         }
2064         else if (( szSrc = _ILGetTextPointer(pidl) ))
2065         {
2066             /* filesystem */
2067             MultiByteToWideChar(CP_ACP, 0, szSrc, -1, szTemp, MAX_PATH);
2068
2069             if (szOut)
2070                 lstrcpynW(szOut, szTemp, uOutSize);
2071
2072             dwReturn = lstrlenW (szTemp);
2073         }
2074         else if (( riid = _ILGetGUIDPointer(pidl) ))
2075         {
2076             /* special folder */
2077             if ( HCR_GetClassNameW(riid, szTemp, MAX_PATH) )
2078             {
2079                 if (szOut)
2080                     lstrcpynW(szOut, szTemp, uOutSize);
2081
2082                 dwReturn = lstrlenW (szTemp);
2083             }
2084         }
2085         else
2086         {
2087             ERR("-- no text\n");
2088         }
2089     }
2090
2091     TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
2092     return dwReturn;
2093 }
2094
2095 /**************************************************************************
2096  *
2097  *    ### 4. getting pointers to parts of pidls ###
2098  *
2099  **************************************************************************
2100  *  _ILGetDataPointer()
2101  */
2102 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
2103 {
2104     if(!_ILIsEmpty(pidl))
2105         return (LPPIDLDATA)pidl->mkid.abID;
2106     return NULL;
2107 }
2108
2109 /**************************************************************************
2110  *  _ILGetTextPointerW()
2111  * gets a pointer to the unicode long filename string stored in the pidl
2112  */
2113 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl)
2114 {
2115     /* TRACE(pidl,"(pidl%p)\n", pidl);*/
2116
2117     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2118
2119     if (!pdata)
2120         return NULL;
2121
2122     switch (pdata->type)
2123     {
2124     case PT_GUID:
2125     case PT_SHELLEXT:
2126     case PT_YAGUID:
2127         return NULL;
2128
2129     case PT_DRIVE:
2130     case PT_DRIVE1:
2131     case PT_DRIVE2:
2132     case PT_DRIVE3:
2133         /*return (LPSTR)&(pdata->u.drive.szDriveName);*/
2134         return NULL;
2135
2136     case PT_FOLDER:
2137     case PT_FOLDER1:
2138     case PT_VALUE:
2139     case PT_IESPECIAL1:
2140     case PT_IESPECIAL2:
2141         /*return (LPSTR)&(pdata->u.file.szNames);*/
2142         return NULL;
2143
2144     case PT_WORKGRP:
2145     case PT_COMP:
2146     case PT_NETWORK:
2147     case PT_NETPROVIDER:
2148     case PT_SHARE:
2149         /*return (LPSTR)&(pdata->u.network.szNames);*/
2150         return NULL;
2151
2152     case PT_VALUEW:
2153         return (LPWSTR)pdata->u.file.szNames;
2154     }
2155     return NULL;
2156 }
2157
2158
2159 /**************************************************************************
2160  *  _ILGetTextPointer()
2161  * gets a pointer to the long filename string stored in the pidl
2162  */
2163 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
2164 {
2165     /* TRACE(pidl,"(pidl%p)\n", pidl);*/
2166
2167     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2168
2169     if (!pdata)
2170         return NULL;
2171
2172     switch (pdata->type)
2173     {
2174     case PT_GUID:
2175     case PT_SHELLEXT:
2176     case PT_YAGUID:
2177         return NULL;
2178
2179     case PT_DRIVE:
2180     case PT_DRIVE1:
2181     case PT_DRIVE2:
2182     case PT_DRIVE3:
2183         return pdata->u.drive.szDriveName;
2184
2185     case PT_FOLDER:
2186     case PT_FOLDER1:
2187     case PT_VALUE:
2188     case PT_IESPECIAL1:
2189     case PT_IESPECIAL2:
2190         return pdata->u.file.szNames;
2191
2192     case PT_WORKGRP:
2193     case PT_COMP:
2194     case PT_NETWORK:
2195     case PT_NETPROVIDER:
2196     case PT_SHARE:
2197         return pdata->u.network.szNames;
2198     }
2199     return NULL;
2200 }
2201
2202 /**************************************************************************
2203  *  _ILGetSTextPointer()
2204  * gets a pointer to the short filename string stored in the pidl
2205  */
2206 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
2207 {
2208     /* TRACE(pidl,"(pidl%p)\n", pidl); */
2209
2210     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2211
2212     if (!pdata)
2213         return NULL;
2214
2215     switch (pdata->type)
2216     {
2217     case PT_FOLDER:
2218     case PT_VALUE:
2219     case PT_IESPECIAL1:
2220     case PT_IESPECIAL2:
2221         return pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1;
2222
2223     case PT_WORKGRP:
2224         return pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1;
2225     }
2226     return NULL;
2227 }
2228
2229 /**************************************************************************
2230  * _ILGetGUIDPointer()
2231  *
2232  * returns reference to guid stored in some pidls
2233  */
2234 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
2235 {
2236     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2237
2238     TRACE("%p\n", pidl);
2239
2240     if (!pdata)
2241         return NULL;
2242
2243     TRACE("pdata->type 0x%04x\n", pdata->type);
2244     switch (pdata->type)
2245     {
2246     case PT_SHELLEXT:
2247     case PT_GUID:
2248     case PT_YAGUID:
2249         return &(pdata->u.guid.guid);
2250
2251     default:
2252         TRACE("Unknown pidl type 0x%04x\n", pdata->type);
2253         break;
2254     }
2255     return NULL;
2256 }
2257
2258 /******************************************************************************
2259  * _ILGetFileStructW [Internal]
2260  *
2261  * Get pointer the a SHITEMID's FileStructW field if present
2262  *
2263  * PARAMS
2264  *  pidl [I] The SHITEMID
2265  *
2266  * RETURNS
2267  *  Success: Pointer to pidl's FileStructW field.
2268  *  Failure: NULL
2269  */
2270 FileStructW* _ILGetFileStructW(LPCITEMIDLIST pidl) {
2271     FileStructW *pFileStructW;
2272     WORD cbOffset;
2273
2274     if (!(_ILIsValue(pidl) || _ILIsFolder(pidl)))
2275         return NULL;
2276
2277     cbOffset = *(const WORD *)((const BYTE *)pidl + pidl->mkid.cb - sizeof(WORD));
2278     pFileStructW = (FileStructW*)((LPBYTE)pidl + cbOffset);
2279
2280     /* Currently I don't see a fool prove way to figure out if a pidl is for sure of WinXP
2281      * style with a FileStructW member. If we switch all our shellfolder-implementations to
2282      * the new format, this won't be a problem. For now, we do as many sanity checks as possible. */
2283     if ((cbOffset & 0x1) || /* FileStructW member is word aligned in the pidl */
2284         /* FileStructW is positioned after FileStruct */
2285         cbOffset < sizeof(pidl->mkid.cb) + sizeof(PIDLTYPE) + sizeof(FileStruct) ||
2286         /* There has to be enough space at cbOffset in the pidl to hold FileStructW and cbOffset */
2287         cbOffset > pidl->mkid.cb - sizeof(cbOffset) - sizeof(FileStructW) ||
2288         pidl->mkid.cb != cbOffset + pFileStructW->cbLen)
2289     {
2290         WARN("Invalid pidl format (cbOffset = %d)!\n", cbOffset);
2291         return NULL;
2292     }
2293
2294     return pFileStructW;
2295 }
2296
2297 /*************************************************************************
2298  * _ILGetFileDateTime
2299  *
2300  * Given the ItemIdList, get the FileTime
2301  *
2302  * PARAMS
2303  *      pidl        [I] The ItemIDList
2304  *      pFt         [I] the resulted FILETIME of the file
2305  *
2306  * RETURNS
2307  *     True if Successful
2308  *
2309  * NOTES
2310  *
2311  */
2312 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
2313 {
2314     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2315
2316     if (!pdata)
2317         return FALSE;
2318
2319     switch (pdata->type)
2320     {
2321     case PT_FOLDER:
2322     case PT_VALUE:
2323         DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
2324         break;
2325     default:
2326         return FALSE;
2327     }
2328     return TRUE;
2329 }
2330
2331 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2332 {
2333     FILETIME ft,lft;
2334     SYSTEMTIME time;
2335     BOOL ret;
2336
2337     if (_ILGetFileDateTime( pidl, &ft ))
2338     {
2339         FileTimeToLocalFileTime(&ft, &lft);
2340         FileTimeToSystemTime (&lft, &time);
2341
2342         ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
2343         if (ret)
2344         {
2345             /* Append space + time without seconds */
2346             pOut[ret-1] = ' ';
2347             GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &pOut[ret], uOutSize - ret);
2348         }
2349     }
2350     else
2351     {
2352         pOut[0] = '\0';
2353         ret = FALSE;
2354     }
2355     return ret;
2356 }
2357
2358 /*************************************************************************
2359  * _ILGetFileSize
2360  *
2361  * Given the ItemIdList, get the FileSize
2362  *
2363  * PARAMS
2364  *    pidl     [I] The ItemIDList
2365  *    pOut     [I] The buffer to save the result
2366  *    uOutsize [I] The size of the buffer
2367  *
2368  * RETURNS
2369  *    The FileSize
2370  *
2371  * NOTES
2372  *    pOut can be null when no string is needed
2373  *
2374  */
2375 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2376 {
2377     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2378     DWORD dwSize;
2379
2380     if (!pdata)
2381         return 0;
2382
2383     switch (pdata->type)
2384     {
2385     case PT_VALUE:
2386         dwSize = pdata->u.file.dwFileSize;
2387         if (pOut)
2388             StrFormatKBSizeA(dwSize, pOut, uOutSize);
2389         return dwSize;
2390     }
2391     if (pOut)
2392         *pOut = 0x00;
2393     return 0;
2394 }
2395
2396 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2397 {
2398     char szTemp[MAX_PATH];
2399     const char * pPoint;
2400     LPCITEMIDLIST  pidlTemp=pidl;
2401
2402     TRACE("pidl=%p\n",pidl);
2403
2404     if (!pidl)
2405         return FALSE;
2406
2407     pidlTemp = ILFindLastID(pidl);
2408
2409     if (!_ILIsValue(pidlTemp))
2410         return FALSE;
2411     if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
2412         return FALSE;
2413
2414     pPoint = PathFindExtensionA(szTemp);
2415
2416     if (!*pPoint)
2417         return FALSE;
2418
2419     pPoint++;
2420     lstrcpynA(pOut, pPoint, uOutSize);
2421     TRACE("%s\n",pOut);
2422
2423     return TRUE;
2424 }
2425
2426 /*************************************************************************
2427  * _ILGetFileType
2428  *
2429  * Given the ItemIdList, get the file type description
2430  *
2431  * PARAMS
2432  *      pidl        [I] The ItemIDList (simple)
2433  *      pOut        [I] The buffer to save the result
2434  *      uOutsize    [I] The size of the buffer
2435  *
2436  * RETURNS
2437  *    nothing
2438  *
2439  * NOTES
2440  *    This function copies as much as possible into the buffer.
2441  */
2442 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2443 {
2444     if(_ILIsValue(pidl))
2445     {
2446         char sTemp[64];
2447
2448         /* "name" or "name." or any unhandled => "File" */
2449         lstrcpynA (pOut, "File", uOutSize);
2450
2451         /* If there's space for more, try to get a better description. */
2452         if (uOutSize > 6 && _ILGetExtension (pidl, sTemp, 64))
2453         {
2454             if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2455                 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE ))
2456                 && sTemp[0])
2457             {
2458                 lstrcpynA (pOut, sTemp, uOutSize - 6);
2459                 strcat (pOut, " file");
2460             }
2461         }
2462     }
2463     else
2464         lstrcpynA(pOut, "Folder", uOutSize);
2465 }
2466
2467 /*************************************************************************
2468  * _ILGetFileAttributes
2469  *
2470  * Given the ItemIdList, get the Attrib string format
2471  *
2472  * PARAMS
2473  *      pidl        [I] The ItemIDList
2474  *      pOut        [I] The buffer to save the result
2475  *      uOutsize    [I] The size of the Buffer
2476  *
2477  * RETURNS
2478  *     Attributes
2479  *
2480  * FIXME
2481  *  return value 0 in case of error is a valid return value
2482  *
2483  */
2484 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2485 {
2486     LPPIDLDATA pData = _ILGetDataPointer(pidl);
2487     WORD wAttrib = 0;
2488     int i;
2489
2490     if (!pData)
2491         return 0;
2492
2493     switch(pData->type)
2494     {
2495     case PT_FOLDER:
2496     case PT_VALUE:
2497         wAttrib = pData->u.file.uFileAttribs;
2498         break;
2499     }
2500
2501     if(uOutSize >= 6)
2502     {
2503         i=0;
2504         if(wAttrib & FILE_ATTRIBUTE_READONLY)
2505             pOut[i++] = 'R';
2506         if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2507             pOut[i++] = 'H';
2508         if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2509             pOut[i++] = 'S';
2510         if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2511             pOut[i++] = 'A';
2512         if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2513             pOut[i++] = 'C';
2514         pOut[i] = 0x00;
2515     }
2516     return wAttrib;
2517 }
2518
2519 /*************************************************************************
2520  * ILFreeaPidl
2521  *
2522  * frees an aPidl struct
2523  */
2524 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2525 {
2526     UINT   i;
2527
2528     if (apidl)
2529     {
2530         for (i = 0; i < cidl; i++)
2531             SHFree(apidl[i]);
2532         SHFree(apidl);
2533     }
2534 }
2535
2536 /*************************************************************************
2537  * ILCopyaPidl
2538  *
2539  * copies an aPidl struct
2540  */
2541 LPITEMIDLIST* _ILCopyaPidl(const LPCITEMIDLIST * apidlsrc, UINT cidl)
2542 {
2543     UINT i;
2544     LPITEMIDLIST *apidldest;
2545
2546     if (!apidlsrc)
2547         return NULL;
2548
2549     apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
2550
2551     for (i = 0; i < cidl; i++)
2552         apidldest[i] = ILClone(apidlsrc[i]);
2553
2554     return apidldest;
2555 }
2556
2557 /*************************************************************************
2558  * _ILCopyCidaToaPidl
2559  *
2560  * creates aPidl from CIDA
2561  */
2562 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, const CIDA * cida)
2563 {
2564     UINT i;
2565     LPITEMIDLIST *dst;
2566
2567     dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2568     if (!dst)
2569         return NULL;
2570
2571     if (pidl)
2572         *pidl = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[0]]));
2573
2574     for (i = 0; i < cida->cidl; i++)
2575         dst[i] = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[i + 1]]));
2576
2577     return dst;
2578 }