dlls/shell32/pidl.c

   1 /*
   2  *      pidl Handling
   3  *
   4  *      Copyright 1998  Juergen Schmied
   5  *
   6  * NOTES
   7  *  a pidl == NULL means desktop and is legal
   8  *
   9  */
  10
  11 #include <ctype.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include "winbase.h"
  15 #include "debugtools.h"
  16 #include "shlguid.h"
  17 #include "winerror.h"
  18 #include "winnls.h"
  19 #include "wine/undocshell.h"
  20 #include "shell32_main.h"
  21 #include "shellapi.h"
  22 #include "shlwapi.h"
  23
  24 #include "pidl.h"
  25
  26 DEFAULT_DEBUG_CHANNEL(pidl);
  27 DECLARE_DEBUG_CHANNEL(shell);
  28
  29 void pdump (LPCITEMIDLIST pidl)
  30 {
  31         BOOL bIsShellDebug;
  32
  33         LPITEMIDLIST pidltemp = pidl;
  34         if (!TRACE_ON(pidl))
  35           return;
  36
  37         /* silence the sub-functions */
  38         bIsShellDebug = TRACE_ON(shell);
  39         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, FALSE);
  40         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
  41
  42         if (! pidltemp)
  43         {
  44           MESSAGE ("-------- pidl=NULL (Desktop)\n");
  45         }
  46         else
  47         {
  48           MESSAGE ("-------- pidl=%p\n", pidl);
  49           if (pidltemp->mkid.cb)
  50           {
  51             do
  52             {
  53               DWORD dwAttrib = 0;
  54               LPPIDLDATA pData   = _ILGetDataPointer(pidltemp);
  55               DWORD type         = pData->type;
  56               LPSTR szLongName   = _ILGetTextPointer(pidltemp);
  57               LPSTR szShortName  = _ILGetSTextPointer(pidltemp);
  58               char szName[MAX_PATH];
  59
  60               _ILSimpleGetText(pidltemp, szName, MAX_PATH);
  61               if( PT_FOLDER == type)
  62                 dwAttrib = pData->u.folder.uFileAttribs;
  63               else if( PT_VALUE == type)
  64                 dwAttrib = pData->u.file.uFileAttribs;
  65
  66               MESSAGE ("-- pidl=%p size=%u type=%lx attr=0x%08lx name=%s (%s,%s)\n",
  67                        pidltemp, pidltemp->mkid.cb,type,dwAttrib,szName,debugstr_a(szLongName), debugstr_a(szShortName));
  68
  69               pidltemp = ILGetNext(pidltemp);
  70
  71             } while (pidltemp->mkid.cb);
  72           }
  73           else
  74           {
  75             MESSAGE ("empty pidl (Desktop)\n");
  76           }
  77           pcheck(pidl);
  78         }
  79
  80         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, bIsShellDebug);
  81         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, TRUE);
  82
  83 }
  84 #define BYTES_PRINTED 32
  85 BOOL pcheck (LPCITEMIDLIST pidl)
  86 {       DWORD type, ret=TRUE;
  87         BOOL bIsPidlDebug;
  88
  89         LPITEMIDLIST pidltemp = pidl;
  90
  91         bIsPidlDebug = TRACE_ON(shell);
  92         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
  93
  94         if (pidltemp && pidltemp->mkid.cb)
  95         { do
  96           { type   = _ILGetDataPointer(pidltemp)->type;
  97             switch (type)
  98             { case PT_DESKTOP:
  99               case PT_MYCOMP:
 100               case PT_SPECIAL:
 101               case PT_DRIVE:
 102               case PT_DRIVE1:
 103               case PT_DRIVE2:
 104               case PT_DRIVE3:
 105               case PT_FOLDER:
 106               case PT_VALUE:
 107               case PT_FOLDER1:
 108               case PT_WORKGRP:
 109               case PT_COMP:
 110               case PT_NETWORK:
 111               case PT_SHARE:
 112               case PT_IESPECIAL:
 113                 break;
 114               default:
 115               {
 116                 char szTemp[BYTES_PRINTED*4 + 1];
 117                 int i;
 118                 unsigned char c;
 119
 120                 memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
 121                 for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
 122                 {
 123                   c = ((unsigned char *)pidltemp)[i];
 124
 125                   szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
 126                   szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
 127                   szTemp[i*3+2] = ' ';
 128                   szTemp[i+BYTES_PRINTED*3]  =  (c>=0x20 && c <=0x80) ? c : '.';
 129                 }
 130                 szTemp[BYTES_PRINTED*4] = 0x00;
 131                 ERR("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
 132                 ret = FALSE;
 133               }
 134             }
 135             pidltemp = ILGetNext(pidltemp);
 136           } while (pidltemp->mkid.cb);
 137         }
 138         __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, bIsPidlDebug);
 139         return ret;
 140 }
 141
 142 /*************************************************************************
 143  * ILGetDisplayName                     [SHELL32.15]
 144  */
 145 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl,LPSTR path)
 146 {
 147         TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
 148         return SHGetPathFromIDListA(pidl, path);
 149 }
 150 /*************************************************************************
 151  * ILFindLastID [SHELL32.16]
 152  *
 153  * NOTES
 154  *   observed: pidl=Desktop return=pidl
 155  */
 156 LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl)
 157 {       LPITEMIDLIST   pidlLast = pidl;
 158
 159         TRACE("(pidl=%p)\n",pidl);
 160
 161         while (pidl->mkid.cb)
 162         {
 163           pidlLast = pidl;
 164           pidl = ILGetNext(pidl);
 165         }
 166         return pidlLast;
 167 }
 168 /*************************************************************************
 169  * ILRemoveLastID [SHELL32.17]
 170  *
 171  * NOTES
 172  *   when pidl=Desktop return=FALSE
 173  */
 174 BOOL WINAPI ILRemoveLastID(LPCITEMIDLIST pidl)
 175 {
 176         TRACE_(shell)("pidl=%p\n",pidl);
 177
 178         if (!pidl || !pidl->mkid.cb)
 179           return 0;
 180         ILFindLastID(pidl)->mkid.cb = 0;
 181         return 1;
 182 }
 183
 184 /*************************************************************************
 185  * ILClone [SHELL32.18]
 186  *
 187  * NOTES
 188  *    dupicate an idlist
 189  */
 190 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
 191 { DWORD    len;
 192   LPITEMIDLIST  newpidl;
 193
 194   if (!pidl)
 195     return NULL;
 196
 197   len = ILGetSize(pidl);
 198   newpidl = (LPITEMIDLIST)SHAlloc(len);
 199   if (newpidl)
 200     memcpy(newpidl,pidl,len);
 201
 202   TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
 203   pdump(pidl);
 204
 205   return newpidl;
 206 }
 207 /*************************************************************************
 208  * ILCloneFirst [SHELL32.19]
 209  *
 210  * NOTES
 211  *  duplicates the first idlist of a complex pidl
 212  */
 213 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
 214 {       DWORD len;
 215         LPITEMIDLIST pidlNew = NULL;
 216
 217         TRACE("pidl=%p \n",pidl);
 218         pdump(pidl);
 219
 220         if (pidl)
 221         {
 222           len = pidl->mkid.cb;
 223           pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
 224           if (pidlNew)
 225           {
 226             memcpy(pidlNew,pidl,len+2);         /* 2 -> mind a desktop pidl */
 227
 228             if (len)
 229               ILGetNext(pidlNew)->mkid.cb = 0x00;
 230           }
 231         }
 232         TRACE("-- newpidl=%p\n",pidlNew);
 233
 234         return pidlNew;
 235 }
 236 /*************************************************************************
 237  * ILLoadFromStream
 238  *
 239  * NOTES
 240  *   the first two bytes are the len, the pidl is following then
 241  */
 242 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
 243 {       WORD            wLen = 0;
 244         DWORD           dwBytesRead;
 245         HRESULT         ret = E_FAIL;
 246
 247
 248         TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
 249
 250         if (*ppPidl)
 251         { SHFree(*ppPidl);
 252           *ppPidl = NULL;
 253         }
 254
 255         IStream_AddRef (pStream);
 256
 257         if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
 258         { *ppPidl = SHAlloc (wLen);
 259           if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
 260           { ret = S_OK;
 261           }
 262           else
 263           { SHFree(*ppPidl);
 264             *ppPidl = NULL;
 265           }
 266         }
 267
 268         /* we are not jet fully compatible */
 269         if (!pcheck(*ppPidl))
 270         { SHFree(*ppPidl);
 271           *ppPidl = NULL;
 272         }
 273
 274
 275         IStream_Release (pStream);
 276
 277         return ret;
 278 }
 279 /*************************************************************************
 280  * SHILCreateFromPath   [SHELL32.28]
 281  *
 282  * NOTES
 283  *   wraper for IShellFolder::ParseDisplayName()
 284  */
 285 HRESULT WINAPI SHILCreateFromPathA (LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 286 {       LPSHELLFOLDER sf;
 287         WCHAR lpszDisplayName[MAX_PATH];
 288         DWORD pchEaten;
 289         HRESULT ret = E_FAIL;
 290
 291         TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes?*attributes:0);
 292
 293         if (!MultiByteToWideChar( CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH ))
 294             lpszDisplayName[MAX_PATH-1] = 0;
 295
 296         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
 297         {
 298           ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
 299           IShellFolder_Release(sf);
 300         }
 301         return ret;
 302 }
 303 HRESULT WINAPI SHILCreateFromPathW (LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 304 {       LPSHELLFOLDER sf;
 305         DWORD pchEaten;
 306         HRESULT ret = E_FAIL;
 307
 308         TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes?*attributes:0);
 309
 310         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
 311         {
 312           ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPWSTR) path, &pchEaten, ppidl, attributes);
 313           IShellFolder_Release(sf);
 314         }
 315         return ret;
 316 }
 317 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
 318 {
 319         if ( SHELL_OsIsUnicode())
 320           return SHILCreateFromPathW (path, ppidl, attributes);
 321         return SHILCreateFromPathA (path, ppidl, attributes);
 322 }
 323
 324 /*************************************************************************
 325  * SHCloneSpecialIDList [SHELL32.89]
 326  *
 327  * PARAMETERS
 328  *  hwndOwner   [in]
 329  *  nFolder     [in]    CSIDL_xxxxx ??
 330  *
 331  * RETURNS
 332  *  pidl ??
 333  * NOTES
 334  *     exported by ordinal
 335  */
 336 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner,DWORD nFolder,DWORD x3)
 337 {       LPITEMIDLIST ppidl;
 338         WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
 339                                          hwndOwner,nFolder,x3);
 340
 341         SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
 342
 343         return ppidl;
 344 }
 345
 346 /*************************************************************************
 347  * ILGlobalClone [SHELL32.97]
 348  *
 349  */
 350 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
 351 {       DWORD    len;
 352         LPITEMIDLIST  newpidl;
 353
 354         if (!pidl)
 355           return NULL;
 356
 357         len = ILGetSize(pidl);
 358         newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
 359         if (newpidl)
 360           memcpy(newpidl,pidl,len);
 361
 362         TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
 363         pdump(pidl);
 364
 365         return newpidl;
 366 }
 367
 368 /*************************************************************************
 369  * ILIsEqual [SHELL32.21]
 370  *
 371  */
 372 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 373 {
 374         char    szData1[MAX_PATH];
 375         char    szData2[MAX_PATH];
 376
 377         LPITEMIDLIST pidltemp1 = pidl1;
 378         LPITEMIDLIST pidltemp2 = pidl2;
 379
 380         TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 381
 382         /* explorer reads from registry directly (StreamMRU),
 383            so we can only check here */
 384         if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
 385
 386         pdump (pidl1);
 387         pdump (pidl2);
 388
 389         if ( (!pidl1) || (!pidl2) ) return FALSE;
 390
 391         while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 392         {
 393             _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
 394             _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
 395
 396             if (strcasecmp ( szData1, szData2 )!=0 )
 397               return FALSE;
 398
 399             pidltemp1 = ILGetNext(pidltemp1);
 400             pidltemp2 = ILGetNext(pidltemp2);
 401         }
 402
 403         if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
 404         {
 405           return TRUE;
 406         }
 407
 408         return FALSE;
 409 }
 410 /*************************************************************************
 411  * ILIsParent [SHELL32.23]
 412  *
 413  * parent=a/b   child=a/b/c -> true, c is in folder a/b
 414  *              child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
 415  *              child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
 416  */
 417 BOOL WINAPI ILIsParent( LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
 418 {
 419         char    szData1[MAX_PATH];
 420         char    szData2[MAX_PATH];
 421
 422         LPITEMIDLIST pParent = pidlParent;
 423         LPITEMIDLIST pChild = pidlChild;
 424
 425         TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
 426
 427         while (pParent->mkid.cb && pChild->mkid.cb)
 428         {
 429           _ILSimpleGetText(pParent, szData1, MAX_PATH);
 430           _ILSimpleGetText(pChild, szData2, MAX_PATH);
 431
 432           if (strcasecmp ( szData1, szData2 )!=0 )
 433             return FALSE;
 434
 435           pParent = ILGetNext(pParent);
 436           pChild = ILGetNext(pChild);
 437         }
 438
 439         if ( pParent->mkid.cb || ! pChild->mkid.cb)     /* child shorter or has equal length to parent */
 440           return FALSE;
 441
 442         if ( ILGetNext(pChild)->mkid.cb && bImmediate)  /* not immediate descent */
 443           return FALSE;
 444
 445         return TRUE;
 446 }
 447
 448 /*************************************************************************
 449  * ILFindChild [SHELL32.24]
 450  *
 451  * NOTES
 452  *  Compares elements from pidl1 and pidl2.
 453  *
 454  *  pidl1 is desktop            pidl2
 455  *  pidl1 shorter pidl2         pointer to first different element of pidl2
 456  *                              if there was at least one equal element
 457  *  pidl2 shorter pidl1         0
 458  *  pidl2 equal pidl1           pointer to last 0x00-element of pidl2
 459  */
 460 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 461 {
 462         char    szData1[MAX_PATH];
 463         char    szData2[MAX_PATH];
 464
 465         LPITEMIDLIST pidltemp1 = pidl1;
 466         LPITEMIDLIST pidltemp2 = pidl2;
 467         LPITEMIDLIST ret=NULL;
 468
 469         TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 470
 471         /* explorer reads from registry directly (StreamMRU),
 472            so we can only check here */
 473         if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
 474           return FALSE;
 475
 476         pdump (pidl1);
 477         pdump (pidl2);
 478
 479         if ( _ILIsDesktop(pidl1) )
 480         {
 481           ret = pidl2;
 482         }
 483         else
 484         {
 485           while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 486           {
 487             _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
 488             _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
 489
 490             if (strcasecmp(szData1,szData2))
 491               break;
 492
 493             pidltemp1 = ILGetNext(pidltemp1);
 494             pidltemp2 = ILGetNext(pidltemp2);
 495             ret = pidltemp2;
 496           }
 497
 498           if (pidltemp1->mkid.cb)
 499           {
 500             ret = NULL; /* elements of pidl1 left*/
 501           }
 502         }
 503         TRACE_(shell)("--- %p\n", ret);
 504         return ret; /* pidl 1 is shorter */
 505 }
 506
 507 /*************************************************************************
 508  * ILCombine [SHELL32.25]
 509  *
 510  * NOTES
 511  *  Concatenates two complex idlists.
 512  *  The pidl is the first one, pidlsub the next one
 513  *  Does not destroy the passed in idlists!
 514  */
 515 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 516 {
 517         DWORD    len1,len2;
 518         LPITEMIDLIST  pidlNew;
 519
 520         TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
 521
 522         if(!pidl1 && !pidl2) return NULL;
 523
 524         pdump (pidl1);
 525         pdump (pidl2);
 526
 527         if(!pidl1)
 528         {
 529           pidlNew = ILClone(pidl2);
 530           return pidlNew;
 531         }
 532
 533         if(!pidl2)
 534         {
 535           pidlNew = ILClone(pidl1);
 536           return pidlNew;
 537         }
 538
 539         len1  = ILGetSize(pidl1)-2;
 540         len2  = ILGetSize(pidl2);
 541         pidlNew  = SHAlloc(len1+len2);
 542
 543         if (pidlNew)
 544         {
 545           memcpy(pidlNew,pidl1,len1);
 546           memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
 547         }
 548
 549         /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
 550         return pidlNew;
 551 }
 552 /*************************************************************************
 553  *  SHGetRealIDL [SHELL32.98]
 554  *
 555  * NOTES
 556  */
 557 LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
 558 {
 559         FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
 560
 561         pdump (pidl);
 562         return 0;
 563 }
 564
 565 /*************************************************************************
 566  *  SHLogILFromFSIL [SHELL32.95]
 567  *
 568  * NOTES
 569  *  pild = CSIDL_DESKTOP        ret = 0
 570  *  pild = CSIDL_DRIVES         ret = 0
 571  */
 572 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
 573 {
 574         FIXME("(pidl=%p)\n",pidl);
 575
 576         pdump(pidl);
 577
 578         return 0;
 579 }
 580
 581 /*************************************************************************
 582  * ILGetSize [SHELL32.152]
 583  *  gets the byte size of an idlist including zero terminator (pidl)
 584  *
 585  * PARAMETERS
 586  *  pidl ITEMIDLIST
 587  *
 588  * RETURNS
 589  *  size of pidl
 590  *
 591  * NOTES
 592  *  exported by ordinal
 593  */
 594 DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
 595 {
 596         LPSHITEMID si = &(pidl->mkid);
 597         DWORD  len=0;
 598
 599         if (pidl)
 600         { while (si->cb)
 601           { len += si->cb;
 602             si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
 603           }
 604           len += 2;
 605         }
 606         TRACE("pidl=%p size=%lu\n",pidl, len);
 607         return len;
 608 }
 609
 610 /*************************************************************************
 611  * ILGetNext [SHELL32.153]
 612  *  gets the next simple pidl of a complex pidl
 613  *
 614  * observed return values:
 615  *  null -> null
 616  *  desktop -> null
 617  *  simple pidl -> pointer to 0x0000 element
 618  *
 619  */
 620 LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
 621 {
 622         WORD len;
 623
 624         TRACE("(pidl=%p)\n",pidl);
 625
 626         if(pidl)
 627         {
 628           len =  pidl->mkid.cb;
 629           if (len)
 630           {
 631             pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
 632             return pidl;
 633           }
 634         }
 635         return NULL;
 636 }
 637 /*************************************************************************
 638  * ILAppend [SHELL32.154]
 639  *
 640  * NOTES
 641  *  Adds the single item to the idlist indicated by pidl.
 642  *  if bEnd is 0, adds the item to the front of the list,
 643  *  otherwise adds the item to the end. (???)
 644  *  Destroys the passed in idlist! (???)
 645  */
 646 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
 647 {
 648         LPITEMIDLIST idlRet;
 649
 650         WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
 651
 652         pdump (pidl);
 653         pdump (item);
 654
 655         if (_ILIsDesktop(pidl))
 656         {
 657            idlRet = ILClone(item);
 658            if (pidl)
 659              SHFree (pidl);
 660            return idlRet;
 661         }
 662
 663         if (bEnd)
 664         {
 665           idlRet=ILCombine(pidl,item);
 666         }
 667         else
 668         {
 669           idlRet=ILCombine(item,pidl);
 670         }
 671
 672         SHFree(pidl);
 673         return idlRet;
 674 }
 675 /*************************************************************************
 676  * ILFree [SHELL32.155]
 677  *
 678  * NOTES
 679  *     free_check_ptr - frees memory (if not NULL)
 680  *     allocated by SHMalloc allocator
 681  *     exported by ordinal
 682  */
 683 DWORD WINAPI ILFree(LPITEMIDLIST pidl)
 684 {
 685         TRACE("(pidl=0x%08lx)\n",(DWORD)pidl);
 686
 687         if(!pidl) return FALSE;
 688         SHFree(pidl);
 689         return TRUE;
 690 }
 691 /*************************************************************************
 692  * ILGlobalFree [SHELL32.156]
 693  *
 694  */
 695 void WINAPI ILGlobalFree( LPCITEMIDLIST pidl)
 696 {
 697         TRACE("%p\n",pidl);
 698
 699         if(!pidl) return;
 700         pCOMCTL32_Free(pidl);
 701 }
 702 /*************************************************************************
 703  * ILCreateFromPath [SHELL32.157]
 704  *
 705  */
 706 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
 707 {
 708         LPITEMIDLIST pidlnew;
 709         DWORD attributes = 0;
 710
 711         TRACE_(shell)("%s\n",path);
 712
 713         if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, &attributes)))
 714           return pidlnew;
 715         return FALSE;
 716 }
 717 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
 718 {
 719         LPITEMIDLIST pidlnew;
 720         DWORD attributes = 0;
 721
 722         TRACE_(shell)("%s\n",debugstr_w(path));
 723
 724         if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, &attributes)))
 725           return pidlnew;
 726         return FALSE;
 727 }
 728 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
 729 {
 730         if ( SHELL_OsIsUnicode())
 731           return ILCreateFromPathW (path);
 732         return ILCreateFromPathA (path);
 733 }
 734 /*************************************************************************
 735  *  SHSimpleIDListFromPath [SHELL32.162]
 736  */
 737 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPCSTR lpszPath)
 738 {
 739         LPITEMIDLIST    pidl=NULL;
 740         HANDLE  hFile;
 741         WIN32_FIND_DATAA        stffile;
 742
 743         TRACE("path=%s\n", lpszPath);
 744
 745         if (!lpszPath) return NULL;
 746
 747         hFile = FindFirstFileA(lpszPath, &stffile);
 748
 749         if ( hFile != INVALID_HANDLE_VALUE )
 750         {
 751           if (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 752           {
 753             pidl = _ILCreateFolder (&stffile);
 754           }
 755           else
 756           {
 757             pidl = _ILCreateValue (&stffile);
 758           }
 759           FindClose (hFile);
 760         }
 761         return pidl;
 762 }
 763 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW (LPCWSTR lpszPath)
 764 {
 765         char    lpszTemp[MAX_PATH];
 766         TRACE("path=%s\n",debugstr_w(lpszPath));
 767
 768         if (!WideCharToMultiByte( CP_ACP, 0, lpszPath, -1, lpszTemp, sizeof(lpszTemp), NULL, NULL ))
 769             lpszTemp[sizeof(lpszTemp)-1] = 0;
 770
 771         return SHSimpleIDListFromPathA (lpszTemp);
 772 }
 773
 774 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW (LPCVOID lpszPath)
 775 {
 776         if ( SHELL_OsIsUnicode())
 777           return SHSimpleIDListFromPathW (lpszPath);
 778         return SHSimpleIDListFromPathA (lpszPath);
 779 }
 780
 781 /*************************************************************************
 782  * SHGetSpecialFolderLocation           [SHELL32.223]
 783  *
 784  * gets the folder locations from the registry and creates a pidl
 785  * creates missing reg keys and directorys
 786  *
 787  * PARAMS
 788  *   hwndOwner [I]
 789  *   nFolder   [I] CSIDL_xxxxx
 790  *   ppidl     [O] PIDL of a special folder
 791  *
 792  */
 793 HRESULT WINAPI SHGetSpecialFolderLocation(
 794         HWND hwndOwner,
 795         INT nFolder,
 796         LPITEMIDLIST * ppidl)
 797 {
 798         CHAR            szPath[MAX_PATH];
 799         HRESULT         hr = E_INVALIDARG;
 800
 801         TRACE_(shell)("(%04x,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
 802
 803         if (ppidl)
 804         {
 805           *ppidl = NULL;
 806           switch (nFolder)
 807           {
 808             case CSIDL_DESKTOP:
 809               *ppidl = _ILCreateDesktop();
 810               break;
 811
 812             case CSIDL_DRIVES:
 813               *ppidl = _ILCreateMyComputer();
 814               break;
 815
 816             case CSIDL_NETWORK:
 817               *ppidl = _ILCreateNetwork ();
 818               break;
 819
 820             case CSIDL_CONTROLS:
 821               *ppidl = _ILCreateControl ();
 822               break;
 823
 824             case CSIDL_PRINTERS:
 825               *ppidl = _ILCreatePrinter ();
 826               break;
 827
 828             case CSIDL_BITBUCKET:
 829               *ppidl = _ILCreateBitBucket ();
 830               break;
 831
 832             default:
 833               if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
 834               {
 835                 DWORD attributes=0;
 836                 TRACE_(shell)("Value=%s\n",szPath);
 837                 hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
 838               }
 839           }
 840           if(*ppidl) hr = NOERROR;
 841         }
 842
 843         TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
 844         return hr;
 845 }
 846
 847 /*************************************************************************
 848  * SHGetFolderLocation [SHELL32]
 849  *
 850  * NOTES
 851  *  the pidl can be a simple one. since we cant get the path out of the pidl
 852  *  we have to take all data from the pidl
 853  */
 854 HRESULT WINAPI SHGetFolderLocation(
 855         HWND hwnd,
 856         int csidl,
 857         HANDLE hToken,
 858         DWORD dwFlags,
 859         LPITEMIDLIST *ppidl)
 860 {
 861         FIXME("0x%04x 0x%08x 0x%08x 0x%08lx %p\n",
 862          hwnd, csidl, hToken, dwFlags, ppidl);
 863         return SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
 864 }
 865
 866 /*************************************************************************
 867  * SHGetDataFromIDListA [SHELL32.247]
 868  *
 869  * NOTES
 870  *  the pidl can be a simple one. since we cant get the path out of the pidl
 871  *  we have to take all data from the pidl
 872  */
 873 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
 874 {
 875         TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 876
 877         pdump(pidl);
 878         if (!psf || !dest )  return E_INVALIDARG;
 879
 880         switch (nFormat)
 881         {
 882           case SHGDFIL_FINDDATA:
 883             {
 884                WIN32_FIND_DATAA * pfd = dest;
 885
 886                if ( len < sizeof (WIN32_FIND_DATAA)) return E_INVALIDARG;
 887
 888                ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
 889                _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
 890                pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
 891                pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
 892                lstrcpynA(pfd->cFileName,_ILGetTextPointer(pidl), MAX_PATH);
 893                lstrcpynA(pfd->cAlternateFileName,_ILGetSTextPointer(pidl), 14);
 894             }
 895             return NOERROR;
 896
 897           case SHGDFIL_NETRESOURCE:
 898           case SHGDFIL_DESCRIPTIONID:
 899             FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
 900             break;
 901
 902           default:
 903             ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
 904         }
 905
 906         return E_INVALIDARG;
 907 }
 908 /*************************************************************************
 909  * SHGetDataFromIDListW [SHELL32.247]
 910  *
 911  */
 912 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
 913 {
 914         TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 915
 916         pdump(pidl);
 917
 918         if (! psf || !dest )  return E_INVALIDARG;
 919
 920         switch (nFormat)
 921         {
 922           case SHGDFIL_FINDDATA:
 923             {
 924                WIN32_FIND_DATAW * pfd = dest;
 925
 926                if ( len < sizeof (WIN32_FIND_DATAW)) return E_INVALIDARG;
 927
 928                ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
 929                _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
 930                pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
 931                pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
 932                if (!MultiByteToWideChar( CP_ACP, 0, _ILGetTextPointer(pidl), -1,
 933                                          pfd->cFileName, MAX_PATH ))
 934                    pfd->cFileName[MAX_PATH-1] = 0;
 935                if (!MultiByteToWideChar( CP_ACP, 0, _ILGetSTextPointer(pidl), -1,
 936                                          pfd->cAlternateFileName, 14 ))
 937                    pfd->cFileName[13] = 0;
 938             }
 939             return NOERROR;
 940           case SHGDFIL_NETRESOURCE:
 941           case SHGDFIL_DESCRIPTIONID:
 942             FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
 943             break;
 944
 945           default:
 946             ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
 947         }
 948
 949         return E_INVALIDARG;
 950 }
 951
 952 /*************************************************************************
 953  * SHGetPathFromIDListA         [SHELL32.261][NT 4.0: SHELL32.220]
 954  *
 955  * PARAMETERS
 956  *  pidl,   [IN] pidl
 957  *  pszPath [OUT] path
 958  *
 959  * RETURNS
 960  *  path from a passed PIDL.
 961  *
 962  * NOTES
 963  *      NULL returns FALSE
 964  *      desktop pidl gives path to desktopdirectory back
 965  *      special pidls returning FALSE
 966  *
 967  * FIXME
 968  *  fnGetDisplayNameOf can return different types of OLEString
 969  */
 970 BOOL WINAPI SHGetPathFromIDListA (LPCITEMIDLIST pidl,LPSTR pszPath)
 971 {       STRRET str;
 972         LPSHELLFOLDER shellfolder;
 973
 974         TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
 975
 976         if (!pidl) return FALSE;
 977
 978         pdump(pidl);
 979
 980         if(_ILIsDesktop(pidl))
 981         {
 982            SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
 983         }
 984         else if (_ILIsSpecialFolder(ILFindLastID(pidl)))
 985         {
 986           /* we are somewhere in a special folder */
 987           return FALSE;
 988         }
 989         else
 990         {
 991           if (SHGetDesktopFolder(&shellfolder)==S_OK)
 992           {
 993             IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
 994             StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
 995             IShellFolder_Release(shellfolder);
 996           }
 997         }
 998         TRACE_(shell)("-- (%s)\n",pszPath);
 999
1000         return TRUE;
1001 }
1002 /*************************************************************************
1003  * SHGetPathFromIDListW                         [SHELL32.262]
1004  */
1005 BOOL WINAPI SHGetPathFromIDListW (LPCITEMIDLIST pidl,LPWSTR pszPath)
1006 {       char sTemp[MAX_PATH];
1007
1008         TRACE_(shell)("(pidl=%p)\n", pidl);
1009
1010         SHGetPathFromIDListA (pidl, sTemp);
1011         MultiByteToWideChar( CP_ACP, 0, sTemp, -1, pszPath, MAX_PATH );
1012
1013         TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
1014
1015         return TRUE;
1016 }
1017
1018 /*************************************************************************
1019  *      SHBindToParent          [shell version 5.0]
1020  */
1021 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1022 {
1023         IShellFolder    * psf;
1024         LPITEMIDLIST    pidlChild, pidlParent;
1025         HRESULT         hr=E_FAIL;
1026
1027         TRACE_(shell)("pidl=%p\n", pidl);
1028         pdump(pidl);
1029
1030         *ppv = NULL;
1031         if (ppidlLast) *ppidlLast = NULL;
1032
1033         if (_ILIsPidlSimple(pidl))
1034         {
1035           /* we are on desktop level */
1036           if (ppidlLast)
1037             *ppidlLast = ILClone(pidl);
1038           hr = SHGetDesktopFolder((IShellFolder**)ppv);
1039         }
1040         else
1041         {
1042           pidlChild =  ILClone(ILFindLastID(pidl));
1043           pidlParent = ILClone(pidl);
1044           ILRemoveLastID(pidlParent);
1045
1046           hr = SHGetDesktopFolder(&psf);
1047
1048           if (SUCCEEDED(hr))
1049             hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
1050
1051           if (SUCCEEDED(hr) && ppidlLast)
1052             *ppidlLast = pidlChild;
1053           else
1054             ILFree (pidlChild);
1055
1056           SHFree (pidlParent);
1057           if (psf) IShellFolder_Release(psf);
1058         }
1059
1060
1061         TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1062         return hr;
1063 }
1064
1065 /*************************************************************************
1066  * SHGetPathFromIDListAW                [SHELL32.221][NT 4.0: SHELL32.219]
1067  */
1068 BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath)
1069 {
1070         TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
1071
1072         if (SHELL_OsIsUnicode())
1073           return SHGetPathFromIDListW(pidl,pszPath);
1074         return SHGetPathFromIDListA(pidl,pszPath);
1075 }
1076
1077 /**************************************************************************
1078  *
1079  *              internal functions
1080  *
1081  *      ### 1. section creating pidls ###
1082  *
1083  *************************************************************************
1084  *  _ILCreateDesktop()
1085  *  _ILCreateIExplore()
1086  *  _ILCreateMyComputer()
1087  *  _ILCreateDrive()
1088  *  _ILCreateFolder()
1089  *  _ILCreateValue()
1090  */
1091 LPITEMIDLIST _ILCreateDesktop()
1092 {       TRACE("()\n");
1093         return _ILCreate(PT_DESKTOP, NULL, 0);
1094 }
1095
1096 LPITEMIDLIST _ILCreateMyComputer()
1097 {       TRACE("()\n");
1098         return _ILCreate(PT_MYCOMP, &CLSID_MyComputer, sizeof(GUID));
1099 }
1100
1101 LPITEMIDLIST _ILCreateIExplore()
1102 {       TRACE("()\n");
1103         return _ILCreate(PT_MYCOMP, &CLSID_Internet, sizeof(GUID));
1104 }
1105
1106 LPITEMIDLIST _ILCreateControl()
1107 {       TRACE("()\n");
1108         return _ILCreate(PT_SPECIAL, &CLSID_ControlPanel, sizeof(GUID));
1109 }
1110
1111 LPITEMIDLIST _ILCreatePrinter()
1112 {       TRACE("()\n");
1113         return _ILCreate(PT_SPECIAL, &CLSID_Printers, sizeof(GUID));
1114 }
1115
1116 LPITEMIDLIST _ILCreateNetwork()
1117 {       TRACE("()\n");
1118         return _ILCreate(PT_MYCOMP, &CLSID_NetworkPlaces, sizeof(GUID));
1119 }
1120
1121 LPITEMIDLIST _ILCreateBitBucket()
1122 {       TRACE("()\n");
1123         return _ILCreate(PT_MYCOMP, &CLSID_RecycleBin, sizeof(GUID));
1124 }
1125
1126 LPITEMIDLIST _ILCreateDrive( LPCSTR lpszNew)
1127 {       char sTemp[4];
1128         lstrcpynA (sTemp,lpszNew,4);
1129         sTemp[2]='\\';
1130         sTemp[3]=0x00;
1131         TRACE("(%s)\n",sTemp);
1132         return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
1133 }
1134
1135 LPITEMIDLIST _ILCreateFolder( WIN32_FIND_DATAA * stffile )
1136 {
1137         char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1138         char *  pbuff = buff;
1139         ULONG   len, len1;
1140         LPITEMIDLIST pidl;
1141
1142         TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1143
1144         /* prepare buffer with both names */
1145         len = strlen (stffile->cFileName) + 1;
1146         memcpy (pbuff, stffile->cFileName, len);
1147         pbuff += len;
1148
1149         if (stffile->cAlternateFileName)
1150         {
1151           len1 = strlen (stffile->cAlternateFileName)+1;
1152           memcpy (pbuff, stffile->cAlternateFileName, len1);
1153         }
1154         else
1155         {
1156           len1 = 1;
1157           *pbuff = 0x00;
1158         }
1159
1160         pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
1161
1162         /* set attributes */
1163         if (pidl)
1164         {
1165           LPPIDLDATA pData;
1166           pData = _ILGetDataPointer(pidl);
1167           FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
1168           pData->u.folder.dwFileSize = stffile->nFileSizeLow;
1169           pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
1170         }
1171
1172         return pidl;
1173 }
1174
1175 LPITEMIDLIST _ILCreateValue(WIN32_FIND_DATAA * stffile)
1176 {
1177         char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1178         char *  pbuff = buff;
1179         ULONG   len, len1;
1180         LPITEMIDLIST pidl;
1181
1182         TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1183
1184         /* prepare buffer with both names */
1185         len = strlen (stffile->cFileName) + 1;
1186         memcpy (pbuff, stffile->cFileName, len);
1187         pbuff += len;
1188
1189         if (stffile->cAlternateFileName)
1190         {
1191           len1 = strlen (stffile->cAlternateFileName)+1;
1192           memcpy (pbuff, stffile->cAlternateFileName, len1);
1193         }
1194         else
1195         {
1196           len1 = 1;
1197           *pbuff = 0x00;
1198         }
1199
1200         pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
1201
1202         /* set attributes */
1203         if (pidl)
1204         {
1205           LPPIDLDATA pData;
1206           pData = _ILGetDataPointer(pidl);
1207           FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
1208           pData->u.folder.dwFileSize = stffile->nFileSizeLow;
1209           pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
1210         }
1211
1212         return pidl;
1213 }
1214
1215 LPITEMIDLIST _ILCreateSpecial(LPCSTR szGUID)
1216 {
1217     IID iid;
1218     WCHAR buffer[40];
1219
1220     if (!MultiByteToWideChar( CP_ACP, 0, szGUID, -1, buffer, sizeof(buffer)/sizeof(WCHAR) ))
1221         return NULL;
1222     CLSIDFromString( buffer, &iid );
1223     return _ILCreate(PT_MYCOMP, &iid, sizeof(IID));
1224 }
1225
1226 /**************************************************************************
1227  *  _ILCreate()
1228  *  Creates a new PIDL
1229  *  type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1230  *  pIn = data
1231  *  uInSize = size of data (raw)
1232  */
1233
1234 LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT uInSize)
1235 {
1236         LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
1237         LPPIDLDATA     pData;
1238         UINT           uSize = 0;
1239         LPSTR   pszDest;
1240
1241         TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
1242
1243         switch (type)
1244         {
1245           case PT_DESKTOP:
1246             uSize = 0;
1247             break;
1248           case PT_SPECIAL:
1249           case PT_MYCOMP:
1250             uSize = 2 + 2 + sizeof(GUID);
1251             break;
1252           case PT_DRIVE:
1253             uSize = 2 + 23;
1254             break;
1255           case PT_FOLDER:
1256           case PT_VALUE:
1257             uSize = 2 + 12 + uInSize;
1258             break;
1259           default:
1260             FIXME("can't create type: 0x%08x\n",type);
1261             return NULL;
1262         }
1263
1264         if(!(pidlOut = SHAlloc(uSize + 2))) return NULL;
1265         ZeroMemory(pidlOut, uSize + 2);
1266         pidlOut->mkid.cb = uSize;
1267
1268         switch (type)
1269         {
1270           case PT_DESKTOP:
1271             TRACE("- create Desktop\n");
1272             break;
1273
1274           case PT_SPECIAL:
1275           case PT_MYCOMP:
1276             pData =_ILGetDataPointer(pidlOut);
1277             pData->type = type;
1278             memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
1279             TRACE("- create GUID-pidl\n");
1280             break;
1281
1282           case PT_DRIVE:
1283             pData =_ILGetDataPointer(pidlOut);
1284             pData->type = type;
1285             pszDest = _ILGetTextPointer(pidlOut);
1286             memcpy(pszDest, pIn, uInSize);
1287             TRACE("- create Drive: %s\n",debugstr_a(pszDest));
1288             break;
1289
1290           case PT_FOLDER:
1291           case PT_VALUE:
1292             pData =_ILGetDataPointer(pidlOut);
1293             pData->type = type;
1294             pszDest =  _ILGetTextPointer(pidlOut);
1295             memcpy(pszDest, pIn, uInSize);
1296             TRACE("- create Value: %s\n",debugstr_a(pszDest));
1297             break;
1298         }
1299
1300         pidlTemp = ILGetNext(pidlOut);
1301         if (pidlTemp)
1302           pidlTemp->mkid.cb = 0x00;
1303
1304         TRACE("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
1305         return pidlOut;
1306 }
1307
1308 /**************************************************************************
1309  *  _ILGetDrive()
1310  *
1311  *  Gets the text for the drive eg. 'c:\'
1312  *
1313  * RETURNS
1314  *  strlen (lpszText)
1315  */
1316 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1317 {       TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1318
1319         if(_ILIsMyComputer(pidl))
1320           pidl = ILGetNext(pidl);
1321
1322         if (pidl && _ILIsDrive(pidl))
1323           return _ILSimpleGetText(pidl, pOut, uSize);
1324
1325         return 0;
1326 }
1327
1328 /**************************************************************************
1329  *
1330  *      ### 2. section testing pidls ###
1331  *
1332  **************************************************************************
1333  *  _ILIsDesktop()
1334  *  _ILIsMyComputer()
1335  *  _ILIsSpecialFolder()
1336  *  _ILIsDrive()
1337  *  _ILIsFolder()
1338  *  _ILIsValue()
1339  *  _ILIsPidlSimple()
1340  */
1341 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1342 {       TRACE("(%p)\n",pidl);
1343         return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
1344 }
1345
1346 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1347 {
1348         REFIID iid = _ILGetGUIDPointer(pidl);
1349
1350         TRACE("(%p)\n",pidl);
1351
1352         if (iid)
1353           return IsEqualIID(iid, &CLSID_MyComputer);
1354         return FALSE;
1355 }
1356
1357 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1358 {
1359         LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1360         TRACE("(%p)\n",pidl);
1361         return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
1362                           (pidl && pidl->mkid.cb == 0x00)
1363                         ));
1364 }
1365
1366 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1367 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1368         TRACE("(%p)\n",pidl);
1369         return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1370                                     PT_DRIVE1 == lpPData->type ||
1371                                     PT_DRIVE2 == lpPData->type ||
1372                                     PT_DRIVE3 == lpPData->type));
1373 }
1374
1375 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1376 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1377         TRACE("(%p)\n",pidl);
1378         return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1379 }
1380
1381 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1382 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1383         TRACE("(%p)\n",pidl);
1384         return (pidl && lpPData && PT_VALUE == lpPData->type);
1385 }
1386
1387 /**************************************************************************
1388  *      _ILIsPidlSimple
1389  */
1390 BOOL _ILIsPidlSimple ( LPCITEMIDLIST pidl)
1391 {
1392         BOOL ret = TRUE;
1393
1394         if(! _ILIsDesktop(pidl))        /* pidl=NULL or mkid.cb=0 */
1395         {
1396           WORD len = pidl->mkid.cb;
1397           LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
1398           if (pidlnext->mkid.cb)
1399             ret = FALSE;
1400         }
1401
1402         TRACE("%s\n", ret ? "Yes" : "No");
1403         return ret;
1404 }
1405
1406 /**************************************************************************
1407  *
1408  *      ### 3. section getting values from pidls ###
1409  */
1410
1411  /**************************************************************************
1412  *  _ILSimpleGetText
1413  *
1414  * gets the text for the first item in the pidl (eg. simple pidl)
1415  *
1416  * returns the length of the string
1417  */
1418 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1419 {
1420         DWORD           dwReturn=0;
1421         LPSTR           szSrc;
1422         GUID const *    riid;
1423         char szTemp[MAX_PATH];
1424
1425         TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1426
1427         if (!pidl) return 0;
1428
1429         if (szOut)
1430           *szOut = 0;
1431
1432         if (_ILIsDesktop(pidl))
1433         {
1434          /* desktop */
1435           if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1436           {
1437             if (szOut)
1438               lstrcpynA(szOut, szTemp, uOutSize);
1439
1440             dwReturn = strlen (szTemp);
1441           }
1442         }
1443         else if (( szSrc = _ILGetTextPointer(pidl) ))
1444         {
1445           /* filesystem */
1446           if (szOut)
1447             lstrcpynA(szOut, szSrc, uOutSize);
1448
1449           dwReturn = strlen(szSrc);
1450         }
1451         else if (( riid = _ILGetGUIDPointer(pidl) ))
1452         {
1453           /* special folder */
1454           if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
1455           {
1456             if (szOut)
1457               lstrcpynA(szOut, szTemp, uOutSize);
1458
1459             dwReturn = strlen (szTemp);
1460           }
1461         }
1462         else
1463         {
1464           ERR("-- no text\n");
1465         }
1466
1467         TRACE("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
1468         return dwReturn;
1469 }
1470
1471 /**************************************************************************
1472  *
1473  *      ### 4. getting pointers to parts of pidls ###
1474  *
1475  **************************************************************************
1476  *  _ILGetDataPointer()
1477  */
1478 LPPIDLDATA _ILGetDataPointer(LPITEMIDLIST pidl)
1479 {
1480         if(pidl && pidl->mkid.cb != 0x00)
1481           return (LPPIDLDATA) &(pidl->mkid.abID);
1482         return NULL;
1483 }
1484
1485 /**************************************************************************
1486  *  _ILGetTextPointer()
1487  * gets a pointer to the long filename string stored in the pidl
1488  */
1489 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
1490 {/*     TRACE(pidl,"(pidl%p)\n", pidl);*/
1491
1492         LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1493
1494         if (pdata)
1495         {
1496           switch (pdata->type)
1497           {
1498             case PT_MYCOMP:
1499             case PT_SPECIAL:
1500               return NULL;
1501
1502             case PT_DRIVE:
1503             case PT_DRIVE1:
1504             case PT_DRIVE2:
1505             case PT_DRIVE3:
1506               return (LPSTR)&(pdata->u.drive.szDriveName);
1507
1508             case PT_FOLDER:
1509             case PT_FOLDER1:
1510             case PT_VALUE:
1511             case PT_IESPECIAL:
1512               return (LPSTR)&(pdata->u.file.szNames);
1513
1514             case PT_WORKGRP:
1515             case PT_COMP:
1516             case PT_NETWORK:
1517             case PT_SHARE:
1518               return (LPSTR)&(pdata->u.network.szNames);
1519           }
1520         }
1521         return NULL;
1522 }
1523
1524 /**************************************************************************
1525  *  _ILGetSTextPointer()
1526  * gets a pointer to the short filename string stored in the pidl
1527  */
1528 LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
1529 {/*     TRACE(pidl,"(pidl%p)\n", pidl);*/
1530
1531         LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1532
1533         if (pdata)
1534         {
1535           switch (pdata->type)
1536           {
1537             case PT_FOLDER:
1538             case PT_VALUE:
1539             case PT_IESPECIAL:
1540               return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
1541
1542             case PT_WORKGRP:
1543               return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
1544           }
1545         }
1546         return NULL;
1547 }
1548
1549 /**************************************************************************
1550  * _ILGetGUIDPointer()
1551  *
1552  * returns reference to guid stored in some pidls
1553  */
1554 REFIID _ILGetGUIDPointer(LPCITEMIDLIST pidl)
1555 {
1556         LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1557
1558         if (pdata)
1559         {
1560           switch (pdata->type)
1561           {
1562             case PT_SPECIAL:
1563             case PT_MYCOMP:
1564               return (REFIID) &(pdata->u.mycomp.guid);
1565           }
1566         }
1567         return NULL;
1568 }
1569
1570 /*************************************************************************
1571  * _ILGetFileDateTime
1572  *
1573  * Given the ItemIdList, get the FileTime
1574  *
1575  * PARAMS
1576  *      pidl        [I] The ItemIDList
1577  *      pFt         [I] the resulted FILETIME of the file
1578  *
1579  * RETURNS
1580  *     True if Successful
1581  *
1582  * NOTES
1583  *
1584  */
1585 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
1586 {
1587     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1588
1589     if(! pdata) return FALSE;
1590
1591     switch (pdata->type)
1592     {
1593         case PT_FOLDER:
1594             DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, pFt);
1595             break;
1596         case PT_VALUE:
1597             DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
1598             break;
1599         default:
1600             return FALSE;
1601     }
1602     return TRUE;
1603 }
1604
1605 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1606 {
1607         FILETIME ft,lft;
1608         SYSTEMTIME time;
1609
1610         if (! _ILGetFileDateTime( pidl, &ft )) return FALSE;
1611
1612         FileTimeToLocalFileTime(&ft, &lft);
1613         FileTimeToSystemTime (&lft, &time);
1614         return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
1615 }
1616
1617 /*************************************************************************
1618  * _ILGetFileSize
1619  *
1620  * Given the ItemIdList, get the FileSize
1621  *
1622  * PARAMS
1623  *      pidl    [I] The ItemIDList
1624  *      pOut    [I] The buffer to save the result
1625  *      uOutsize [I] The size of the buffer
1626  *
1627  * RETURNS
1628  *     The FileSize
1629  *
1630  * NOTES
1631  *      pOut can be null when no string is needed
1632  *
1633  */
1634 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1635 {
1636         LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1637         DWORD dwSize;
1638
1639         if(! pdata) return 0;
1640
1641         switch (pdata->type)
1642         {
1643           case PT_VALUE:
1644             dwSize = pdata->u.file.dwFileSize;
1645             if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
1646             return dwSize;
1647         }
1648         if (pOut) *pOut = 0x00;
1649         return 0;
1650 }
1651
1652 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1653 {
1654         char szTemp[MAX_PATH];
1655         const char * pPoint;
1656         LPITEMIDLIST  pidlTemp=pidl;
1657
1658         TRACE("pidl=%p\n",pidl);
1659
1660         if (!pidl) return FALSE;
1661
1662         pidlTemp = ILFindLastID(pidl);
1663
1664         if (!_ILIsValue(pidlTemp)) return FALSE;
1665         if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
1666
1667         pPoint = PathFindExtensionA(szTemp);
1668
1669         if (! *pPoint) return FALSE;
1670
1671         pPoint++;
1672         lstrcpynA(pOut, pPoint, uOutSize);
1673         TRACE("%s\n",pOut);
1674
1675         return TRUE;
1676 }
1677
1678 /*************************************************************************
1679  * _ILGetFileType
1680  *
1681  * Given the ItemIdList, get the file type description
1682  *
1683  * PARAMS
1684  *      pidl        [I] The ItemIDList (simple)
1685  *      pOut        [I] The buffer to save the result
1686  *      uOutsize    [I] The size of the buffer
1687  *
1688  * RETURNS
1689  *      nothing
1690  *
1691  * NOTES
1692  *      This function copies as much as possible into the buffer.
1693  */
1694 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1695 {
1696         if(_ILIsValue(pidl))
1697         {
1698           char sTemp[64];
1699           if(uOutSize > 0)
1700           {
1701             pOut[0] = 0;
1702           }
1703           if (_ILGetExtension (pidl, sTemp, 64))
1704           {
1705             if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
1706                 && HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
1707             {
1708               lstrcpynA (pOut, sTemp, uOutSize - 6);
1709               strcat (pOut, "-file");
1710             }
1711           }
1712         }
1713         else
1714         {
1715           lstrcpynA(pOut, "Folder", uOutSize);
1716         }
1717 }
1718
1719 /*************************************************************************
1720  * _ILGetFileAttributes
1721  *
1722  * Given the ItemIdList, get the Attrib string format
1723  *
1724  * PARAMS
1725  *      pidl        [I] The ItemIDList
1726  *      pOut        [I] The buffer to save the result
1727  *      uOutsize    [I] The size of the Buffer
1728  *
1729  * RETURNS
1730  *     Attributes
1731  *
1732  * FIXME
1733  *  return value 0 in case of error is a valid return value
1734  *
1735  */
1736 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1737 {
1738         LPPIDLDATA pData =_ILGetDataPointer(pidl);
1739         WORD wAttrib = 0;
1740         int i;
1741
1742         if(! pData) return 0;
1743
1744         switch(pData->type)
1745         {
1746           case PT_FOLDER:
1747             wAttrib = pData->u.folder.uFileAttribs;
1748             break;
1749           case PT_VALUE:
1750             wAttrib = pData->u.file.uFileAttribs;
1751             break;
1752         }
1753
1754         if(uOutSize >= 6)
1755         {
1756           i=0;
1757           if(wAttrib & FILE_ATTRIBUTE_READONLY)
1758           {
1759             pOut[i++] = 'R';
1760           }
1761           if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
1762           {
1763             pOut[i++] = 'H';
1764           }
1765           if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
1766           {
1767             pOut[i++] = 'S';
1768           }
1769           if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
1770           {
1771             pOut[i++] = 'A';
1772           }
1773           if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
1774           {
1775             pOut[i++] = 'C';
1776           }
1777           pOut[i] = 0x00;
1778         }
1779         return wAttrib;
1780 }
1781
1782 /*************************************************************************
1783 * ILFreeaPidl
1784 *
1785 * free a aPidl struct
1786 */
1787 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
1788 {
1789         int   i;
1790
1791         if(apidl)
1792         {
1793           for(i = 0; i < cidl; i++) SHFree(apidl[i]);
1794           SHFree(apidl);
1795         }
1796 }
1797
1798 /*************************************************************************
1799 * ILCopyaPidl
1800 *
1801 * copys a aPidl struct
1802 */
1803 LPITEMIDLIST *  _ILCopyaPidl(LPITEMIDLIST * apidlsrc, UINT cidl)
1804 {
1805         int i;
1806         LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
1807         if(!apidlsrc) return NULL;
1808
1809         for(i = 0; i < cidl; i++)
1810           apidldest[i] = ILClone(apidlsrc[i]);
1811
1812         return apidldest;
1813 }
1814
1815 /*************************************************************************
1816 * _ILCopyCidaToaPidl
1817 *
1818 * creates aPidl from CIDA
1819 */
1820 LPITEMIDLIST * _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPCIDA cida)
1821 {
1822         int i;
1823         LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
1824
1825         if(!dst) return NULL;
1826
1827         if (pidl)
1828           *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
1829
1830         for(i = 0; i < cida->cidl; i++)
1831           dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
1832
1833         return dst;
1834 }