git.oblomov.eu Git - wine/blob - 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 <assert.h>
  15 #include "debugtools.h"
  16 #include "shell.h"
  17 #include "shlguid.h"
  18 #include "winerror.h"
  19 #include "winnls.h"
  20 #include "winversion.h"
  21 #include "shell32_main.h"
  22
  23 #include "pidl.h"
  24
  25 DECLARE_DEBUG_CHANNEL(pidl)
  26 DECLARE_DEBUG_CHANNEL(shell)
  27
  28 static char * szMyComp = "My Computer"; /* for comparing */
  29
  30 void pdump (LPCITEMIDLIST pidl)
  31 {       DWORD type;
  32         CHAR * szData;
  33         CHAR * szShortName;
  34         LPITEMIDLIST pidltemp = pidl;
  35         if (! pidltemp)
  36         { TRACE_(pidl)("-------- pidl = NULL (Root)\n");
  37           return;
  38         }
  39         TRACE_(pidl)("-------- pidl=%p \n", pidl);
  40         if (pidltemp->mkid.cb)
  41         { do
  42           { type   = _ILGetDataPointer(pidltemp)->type;
  43             szData = _ILGetTextPointer(type, _ILGetDataPointer(pidltemp));
  44             szShortName = _ILGetSTextPointer(type, _ILGetDataPointer(pidltemp));
  45
  46             TRACE_(pidl)("---- pidl=%p size=%u type=%lx %s, (%s)\n",
  47                        pidltemp, pidltemp->mkid.cb,type,debugstr_a(szData), debugstr_a(szShortName));
  48
  49             pidltemp = ILGetNext(pidltemp);
  50           } while (pidltemp->mkid.cb);
  51           return;
  52         }
  53         else
  54           TRACE_(pidl)("empty pidl (Desktop)\n");
  55 }
  56
  57 #define BYTES_PRINTED 32
  58 BOOL pcheck (LPCITEMIDLIST pidl)
  59 {       DWORD type, ret=TRUE;
  60
  61         LPITEMIDLIST pidltemp = pidl;
  62
  63         if (pidltemp && pidltemp->mkid.cb)
  64         { do
  65           { type   = _ILGetDataPointer(pidltemp)->type;
  66             switch (type)
  67             { case PT_DESKTOP:
  68               case PT_MYCOMP:
  69               case PT_SPECIAL:
  70               case PT_DRIVE:
  71               case PT_FOLDER:
  72               case PT_VALUE:
  73               case PT_DRIVE1:
  74               case PT_FOLDER1:
  75               case PT_WORKGRP:
  76               case PT_COMP:
  77               case PT_NETWORK:
  78               case PT_SHARE:
  79                 break;
  80               default:
  81               {
  82                 char szTemp[BYTES_PRINTED*4 + 1];
  83                 int i;
  84                 unsigned char c;
  85
  86                 memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
  87                 for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
  88                 {
  89                   c = ((unsigned char *)pidltemp)[i];
  90
  91                   szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
  92                   szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
  93                   szTemp[i*3+2] = ' ';
  94                   szTemp[i+BYTES_PRINTED*3]  =  (c>=0x20 && c <=0x80) ? c : '.';
  95                 }
  96                 szTemp[BYTES_PRINTED*4] = 0x00;
  97                 ERR_(pidl)("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
  98                 ret = FALSE;
  99               }
 100             }
 101             pidltemp = ILGetNext(pidltemp);
 102           } while (pidltemp->mkid.cb);
 103         }
 104         return ret;
 105 }
 106
 107 /*************************************************************************
 108  * ILGetDisplayName                     [SHELL32.15]
 109  */
 110 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl,LPSTR path)
 111 {       TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
 112         return SHGetPathFromIDListA(pidl, path);
 113 }
 114 /*************************************************************************
 115  * ILFindLastID [SHELL32.16]
 116  */
 117 LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl)
 118 {       LPITEMIDLIST   pidlLast = NULL;
 119
 120         TRACE_(pidl)("(pidl=%p)\n",pidl);
 121
 122         while (pidl->mkid.cb)
 123         { pidlLast = pidl;
 124           pidl = ILGetNext(pidl);
 125         }
 126         return pidlLast;
 127 }
 128 /*************************************************************************
 129  * ILRemoveLastID [SHELL32.17]
 130  * NOTES
 131  *  Removes the last item
 132  */
 133 BOOL WINAPI ILRemoveLastID(LPCITEMIDLIST pidl)
 134 {       TRACE_(shell)("pidl=%p\n",pidl);
 135         if (!pidl || !pidl->mkid.cb)
 136           return 0;
 137         ILFindLastID(pidl)->mkid.cb = 0;
 138         return 1;
 139 }
 140
 141 /*************************************************************************
 142  * ILClone [SHELL32.18]
 143  *
 144  * NOTES
 145  *    dupicate an idlist
 146  */
 147 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
 148 { DWORD    len;
 149   LPITEMIDLIST  newpidl;
 150
 151   if (!pidl)
 152     return NULL;
 153
 154   len = ILGetSize(pidl);
 155   newpidl = (LPITEMIDLIST)SHAlloc(len);
 156   if (newpidl)
 157     memcpy(newpidl,pidl,len);
 158
 159   TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
 160   pdump(pidl);
 161
 162   return newpidl;
 163 }
 164 /*************************************************************************
 165  * ILCloneFirst [SHELL32.19]
 166  *
 167  * NOTES
 168  *  duplicates the first idlist of a complex pidl
 169  */
 170 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
 171 {       DWORD len;
 172         LPITEMIDLIST newpidl=NULL;
 173
 174         TRACE_(pidl)("pidl=%p \n",pidl);
 175         pdump(pidl);
 176
 177         if (pidl)
 178         { len = pidl->mkid.cb;
 179           newpidl = (LPITEMIDLIST) SHAlloc (len+2);
 180           if (newpidl)
 181           { memcpy(newpidl,pidl,len);
 182             ILGetNext(newpidl)->mkid.cb = 0x00;
 183           }
 184         }
 185         TRACE_(pidl)("-- newpidl=%p\n",newpidl);
 186
 187         return newpidl;
 188 }
 189 /*************************************************************************
 190  * ILLoadFromStream
 191  *
 192  * NOTES
 193  *   the first two bytes are the len, the pidl is following then
 194  */
 195 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
 196 {       WORD            wLen = 0;
 197         DWORD           dwBytesRead;
 198         HRESULT         ret = E_FAIL;
 199
 200
 201         TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
 202
 203         if (*ppPidl)
 204         { SHFree(*ppPidl);
 205           *ppPidl = NULL;
 206         }
 207
 208         IStream_AddRef (pStream);
 209
 210         if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
 211         { *ppPidl = SHAlloc (wLen);
 212           if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
 213           { ret = S_OK;
 214           }
 215           else
 216           { SHFree(*ppPidl);
 217             *ppPidl = NULL;
 218           }
 219         }
 220
 221         /* we are not jet fully compatible */
 222         if (!pcheck(*ppPidl))
 223         { SHFree(*ppPidl);
 224           *ppPidl = NULL;
 225         }
 226
 227
 228         IStream_Release (pStream);
 229
 230         return ret;
 231 }
 232 /*************************************************************************
 233  * SHILCreateFromPath   [SHELL32.28]
 234  *
 235  * NOTES
 236  *   wraper for IShellFolder::ParseDisplayName()
 237  */
 238 HRESULT WINAPI SHILCreateFromPathA (LPSTR path, LPITEMIDLIST * ppidl, DWORD attributes)
 239 {       LPSHELLFOLDER sf;
 240         WCHAR lpszDisplayName[MAX_PATH];
 241         DWORD pchEaten;
 242         HRESULT ret = E_FAIL;
 243
 244         TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes);
 245
 246         LocalToWideChar(lpszDisplayName, path, MAX_PATH);
 247
 248         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
 249         { ret = sf->lpvtbl->fnParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,&attributes);
 250           sf->lpvtbl->fnRelease(sf);
 251         }
 252         return ret;
 253 }
 254 HRESULT WINAPI SHILCreateFromPathW (LPWSTR path, LPITEMIDLIST * ppidl, DWORD attributes)
 255 {       LPSHELLFOLDER sf;
 256         DWORD pchEaten;
 257         HRESULT ret = E_FAIL;
 258
 259         TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes);
 260
 261         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
 262         { ret = sf->lpvtbl->fnParseDisplayName(sf,0, NULL, path, &pchEaten, ppidl, &attributes);
 263           sf->lpvtbl->fnRelease(sf);
 264         }
 265         return ret;
 266 }
 267 HRESULT WINAPI SHILCreateFromPathAW (LPVOID path, LPITEMIDLIST * ppidl, DWORD attributes)
 268 {
 269         if ( VERSION_OsIsUnicode())
 270           return SHILCreateFromPathW (path, ppidl, attributes);
 271         return SHILCreateFromPathA (path, ppidl, attributes);
 272 }
 273
 274 /*************************************************************************
 275  * SHCloneSpecialIDList [SHELL32.89]
 276  *
 277  * PARAMETERS
 278  *  hwndOwner   [in]
 279  *  nFolder     [in]    CSIDL_xxxxx ??
 280  *
 281  * RETURNS
 282  *  pidl ??
 283  * NOTES
 284  *     exported by ordinal
 285  */
 286 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner,DWORD nFolder,DWORD x3)
 287 {       LPITEMIDLIST ppidl;
 288         WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
 289                                          hwndOwner,nFolder,x3);
 290
 291         SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
 292
 293         return ppidl;
 294 }
 295
 296 /*************************************************************************
 297  * ILGlobalClone [SHELL32.97]
 298  *
 299  */
 300 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
 301 {       DWORD    len;
 302         LPITEMIDLIST  newpidl;
 303
 304         if (!pidl)
 305           return NULL;
 306
 307         len = ILGetSize(pidl);
 308         newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
 309         if (newpidl)
 310           memcpy(newpidl,pidl,len);
 311
 312         TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
 313         pdump(pidl);
 314
 315         return newpidl;
 316 }
 317
 318 /*************************************************************************
 319  * ILIsEqual [SHELL32.21]
 320  *
 321  */
 322 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 323 {       LPPIDLDATA ppidldata;
 324         CHAR * szData1;
 325         CHAR * szData2;
 326
 327         LPITEMIDLIST pidltemp1 = pidl1;
 328         LPITEMIDLIST pidltemp2 = pidl2;
 329
 330         TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 331
 332         /* explorer reads from registry directly (StreamMRU),
 333            so we can only check here */
 334         if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
 335           return FALSE;
 336
 337         pdump (pidl1);
 338         pdump (pidl2);
 339
 340         if ( (!pidl1) || (!pidl2) )
 341         { return FALSE;
 342         }
 343
 344         if (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 345         { do
 346           { ppidldata = _ILGetDataPointer(pidltemp1);
 347             szData1 = _ILGetTextPointer(ppidldata->type, ppidldata);
 348
 349             ppidldata = _ILGetDataPointer(pidltemp2);
 350             szData2 = _ILGetTextPointer(ppidldata->type, ppidldata);
 351
 352             if (strcmp ( szData1, szData2 )!=0 )
 353               return FALSE;
 354
 355             pidltemp1 = ILGetNext(pidltemp1);
 356             pidltemp2 = ILGetNext(pidltemp2);
 357
 358           } while (pidltemp1->mkid.cb && pidltemp2->mkid.cb);
 359         }
 360         if (!pidltemp1 && !pidltemp2)
 361         { TRACE_(shell)("--- equal\n");
 362           return TRUE;
 363         }
 364
 365         return FALSE;
 366 }
 367 /*************************************************************************
 368  * ILIsParent [SHELL32.23]
 369  *
 370  */
 371 DWORD WINAPI ILIsParent( DWORD x, DWORD y, DWORD z)
 372 {       FIXME_(pidl)("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
 373         return 0;
 374 }
 375
 376 /*************************************************************************
 377  * ILFindChild [SHELL32.24]
 378  *
 379  * NOTES
 380  *  Compares elements from pidl1 and pidl2.
 381  *  When at least the first element is equal, it gives a pointer
 382  *  to the first different element of pidl 2 back.
 383  *  Returns 0 if pidl 2 is shorter.
 384  */
 385 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 386 {       LPPIDLDATA ppidldata;
 387         CHAR * szData1;
 388         CHAR * szData2;
 389
 390         LPITEMIDLIST pidltemp1 = pidl1;
 391         LPITEMIDLIST pidltemp2 = pidl2;
 392         LPITEMIDLIST ret=NULL;
 393
 394         TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 395
 396         /* explorer reads from registry directly (StreamMRU),
 397            so we can only check here */
 398         if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
 399           return FALSE;
 400
 401         pdump (pidl1);
 402         pdump (pidl2);
 403
 404         if ( !pidl1 || !pidl1->mkid.cb)         /* pidl 1 is desktop (root) */
 405         { TRACE_(shell)("--- %p\n", pidl2);
 406           return pidl2;
 407         }
 408
 409         if (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
 410         { do
 411           { ppidldata = _ILGetDataPointer(pidltemp1);
 412             szData1 = _ILGetTextPointer(ppidldata->type, ppidldata);
 413
 414             ppidldata = _ILGetDataPointer(pidltemp2);
 415             szData2 = _ILGetTextPointer(ppidldata->type, ppidldata);
 416
 417             pidltemp2 = ILGetNext(pidltemp2);   /* points behind the pidl2 */
 418
 419             if (strcmp(szData1,szData2) == 0)
 420             { ret = pidltemp2;  /* found equal element */
 421             }
 422             else
 423             { if (ret)          /* different element after equal -> break */
 424               { ret = NULL;
 425                 break;
 426               }
 427             }
 428             pidltemp1 = ILGetNext(pidltemp1);
 429           } while (pidltemp1->mkid.cb && pidltemp2->mkid.cb);
 430         }
 431
 432         if (!pidltemp2->mkid.cb)
 433         { return NULL; /* complete equal or pidl 2 is shorter */
 434         }
 435
 436         TRACE_(shell)("--- %p\n", ret);
 437         return ret; /* pidl 1 is shorter */
 438 }
 439
 440 /*************************************************************************
 441  * ILCombine [SHELL32.25]
 442  *
 443  * NOTES
 444  *  Concatenates two complex idlists.
 445  *  The pidl is the first one, pidlsub the next one
 446  *  Does not destroy the passed in idlists!
 447  */
 448 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 449 { DWORD    len1,len2;
 450   LPITEMIDLIST  pidlNew;
 451
 452   TRACE_(pidl)("pidl=%p pidl=%p\n",pidl1,pidl2);
 453
 454   if(!pidl1 && !pidl2)
 455   {  return NULL;
 456   }
 457
 458   pdump (pidl1);
 459   pdump (pidl2);
 460
 461   if(!pidl1)
 462   { pidlNew = ILClone(pidl2);
 463     return pidlNew;
 464   }
 465
 466   if(!pidl2)
 467   { pidlNew = ILClone(pidl1);
 468     return pidlNew;
 469   }
 470
 471   len1  = ILGetSize(pidl1)-2;
 472   len2  = ILGetSize(pidl2);
 473   pidlNew  = SHAlloc(len1+len2);
 474
 475   if (pidlNew)
 476   { memcpy(pidlNew,pidl1,len1);
 477     memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
 478   }
 479
 480 /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
 481   return pidlNew;
 482 }
 483 /*************************************************************************
 484  *  SHGetRealIDL [SHELL32.98]
 485  *
 486  * NOTES
 487  */
 488 LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
 489 {       FIXME_(pidl)("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
 490         pdump (pidl);
 491         return 0;
 492 }
 493
 494 /*************************************************************************
 495  *  SHLogILFromFSIL [SHELL32.95]
 496  *
 497  * NOTES
 498  */
 499 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
 500 {       FIXME_(pidl)("(pidl=%p)\n",pidl);
 501         pdump(pidl);
 502         return 0;
 503 }
 504
 505 /*************************************************************************
 506  * ILGetSize [SHELL32.152]
 507  *  gets the byte size of an idlist including zero terminator (pidl)
 508  *
 509  * PARAMETERS
 510  *  pidl ITEMIDLIST
 511  *
 512  * RETURNS
 513  *  size of pidl
 514  *
 515  * NOTES
 516  *  exported by ordinal
 517  */
 518 DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
 519 {       LPSHITEMID si = &(pidl->mkid);
 520         DWORD  len=0;
 521
 522         if (pidl)
 523         { while (si->cb)
 524           { len += si->cb;
 525             si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
 526           }
 527           len += 2;
 528         }
 529         TRACE_(pidl)("pidl=%p size=%lu\n",pidl, len);
 530         return len;
 531 }
 532 /*************************************************************************
 533  * ILGetNext [SHELL32.153]
 534  *  gets the next simple pidl of a complex pidl
 535  *
 536  * PARAMETERS
 537  *  pidl ITEMIDLIST
 538  *
 539  * RETURNS
 540  *  pointer to next element
 541  *  NULL when last element ist reached
 542  *
 543  */
 544 LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
 545 {       LPITEMIDLIST nextpidl;
 546         WORD len;
 547
 548         TRACE_(pidl)("(pidl=%p)\n",pidl);
 549         if(pidl)
 550         { len =  pidl->mkid.cb;
 551           if (len)
 552           { nextpidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
 553             return nextpidl;
 554           }
 555         }
 556         return NULL;
 557 }
 558 /*************************************************************************
 559  * ILAppend [SHELL32.154]
 560  *
 561  * NOTES
 562  *  Adds the single item to the idlist indicated by pidl.
 563  *  if bEnd is 0, adds the item to the front of the list,
 564  *  otherwise adds the item to the end. (???)
 565  *  Destroys the passed in idlist! (???)
 566  */
 567 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
 568 {       LPITEMIDLIST idlRet;
 569         WARN_(pidl)("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
 570         pdump (pidl);
 571         pdump (item);
 572
 573         if (_ILIsDesktop(pidl))
 574         {  idlRet = ILClone(item);
 575            if (pidl)
 576              SHFree (pidl);
 577            return idlRet;
 578         }
 579         if (bEnd)
 580         { idlRet=ILCombine(pidl,item);
 581         }
 582         else
 583         { idlRet=ILCombine(item,pidl);
 584         }
 585         SHFree(pidl);
 586         return idlRet;
 587 }
 588 /*************************************************************************
 589  * ILFree [SHELL32.155]
 590  *
 591  * NOTES
 592  *     free_check_ptr - frees memory (if not NULL)
 593  *     allocated by SHMalloc allocator
 594  *     exported by ordinal
 595  */
 596 DWORD WINAPI ILFree(LPITEMIDLIST pidl)
 597 {       TRACE_(pidl)("(pidl=0x%08lx)\n",(DWORD)pidl);
 598
 599         if (!pidl)
 600           return FALSE;
 601
 602         return SHFree(pidl);
 603 }
 604 /*************************************************************************
 605  * ILGlobalFree [SHELL32.156]
 606  *
 607  */
 608 DWORD WINAPI ILGlobalFree( LPITEMIDLIST pidl)
 609 {       TRACE_(pidl)("%p\n",pidl);
 610
 611         if (!pidl)
 612           return FALSE;
 613
 614         return pCOMCTL32_Free (pidl);
 615 }
 616 /*************************************************************************
 617  * ILCreateFromPath [SHELL32.157]
 618  *
 619  */
 620 LPITEMIDLIST WINAPI ILCreateFromPathA (LPSTR path)
 621 {       LPITEMIDLIST pidlnew;
 622
 623         TRACE_(shell)("%s\n",path);
 624         if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, 0)))
 625           return pidlnew;
 626         return FALSE;
 627 }
 628 LPITEMIDLIST WINAPI ILCreateFromPathW (LPWSTR path)
 629 {       LPITEMIDLIST pidlnew;
 630
 631         TRACE_(shell)("%s\n",debugstr_w(path));
 632
 633         if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, 0)))
 634           return pidlnew;
 635         return FALSE;
 636 }
 637 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPVOID path)
 638 {
 639         if ( VERSION_OsIsUnicode())
 640           return ILCreateFromPathW (path);
 641         return ILCreateFromPathA (path);
 642 }
 643 /*************************************************************************
 644  *  SHSimpleIDListFromPath [SHELL32.162]
 645  *
 646  */
 647 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW (LPVOID lpszPath)
 648 {       LPCSTR  lpszElement;
 649         char    lpszTemp[MAX_PATH];
 650
 651         if (!lpszPath)
 652           return 0;
 653
 654         if ( VERSION_OsIsUnicode())
 655         { TRACE_(pidl)("(path=L%s)\n",debugstr_w((LPWSTR)lpszPath));
 656           WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
 657         }
 658         else
 659         { TRACE_(pidl)("(path=%s)\n",(LPSTR)lpszPath);
 660           strcpy(lpszTemp, lpszPath);
 661         }
 662
 663         lpszElement = PathFindFilenameA(lpszTemp);
 664         if( GetFileAttributesA(lpszTemp) & FILE_ATTRIBUTE_DIRECTORY )
 665         { return _ILCreateFolder(NULL, lpszElement);    /*FIXME: fill shortname */
 666         }
 667         return _ILCreateValue(NULL, lpszElement);       /*FIXME: fill shortname */
 668 }
 669 /*************************************************************************
 670  * SHGetDataFromIDListA [SHELL32.247]
 671  *
 672  */
 673 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
 674 {       TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 675
 676         if (! psf || !dest )
 677           return E_INVALIDARG;
 678
 679         switch (nFormat)
 680         { case SHGDFIL_FINDDATA:
 681             {  WIN32_FIND_DATAA * pfd = dest;
 682                STRRET   lpName;
 683                CHAR     pszPath[MAX_PATH];
 684                HANDLE handle;
 685
 686                if ( len < sizeof (WIN32_FIND_DATAA))
 687                  return E_INVALIDARG;
 688
 689                psf->lpvtbl->fnAddRef(psf);
 690                psf->lpvtbl->fnGetDisplayNameOf( psf, pidl, SHGDN_FORPARSING, &lpName);
 691                psf->lpvtbl->fnRelease(psf);
 692
 693                strcpy(pszPath,lpName.u.cStr);
 694                if ((handle  = FindFirstFileA ( pszPath, pfd)))
 695                  FindClose (handle);
 696             }
 697             break;
 698           case SHGDFIL_NETRESOURCE:
 699           case SHGDFIL_DESCRIPTIONID:
 700             FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
 701             break;
 702           default:
 703             ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
 704         }
 705         return E_INVALIDARG;
 706 }
 707 /*************************************************************************
 708  * SHGetDataFromIDListW [SHELL32.247]
 709  *
 710  */
 711 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
 712 {       FIXME_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 713         return SHGetDataFromIDListA( psf, pidl, nFormat, dest, len);
 714 }
 715
 716 /**************************************************************************
 717 * internal functions
 718 */
 719
 720 /**************************************************************************
 721  *  _ILCreateDesktop()
 722  *  _ILCreateMyComputer()
 723  *  _ILCreateDrive()
 724  *  _ILCreateFolder()
 725  *  _ILCreateValue()
 726  */
 727 LPITEMIDLIST WINAPI _ILCreateDesktop()
 728 {       TRACE_(pidl)("()\n");
 729         return _ILCreate(PT_DESKTOP, NULL, 0);
 730 }
 731 LPITEMIDLIST WINAPI _ILCreateMyComputer()
 732 {       TRACE_(pidl)("()\n");
 733         return _ILCreate(PT_MYCOMP, &IID_MyComputer, sizeof(GUID));
 734 }
 735 LPITEMIDLIST WINAPI _ILCreateDrive( LPCSTR lpszNew)
 736 {       char sTemp[4];
 737         strncpy (sTemp,lpszNew,4);
 738         sTemp[2]='\\';
 739         sTemp[3]=0x00;
 740         TRACE_(pidl)("(%s)\n",sTemp);
 741         return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
 742 }
 743 LPITEMIDLIST WINAPI _ILCreateFolder( LPCSTR lpszShortName, LPCSTR lpszName)
 744 {       char    buff[MAX_PATH];
 745         char *  pbuff = buff;
 746         ULONG   len, len1;
 747
 748         TRACE_(pidl)("(%s, %s)\n",lpszShortName, lpszName);
 749
 750         len = strlen (lpszName)+1;
 751         memcpy (pbuff, lpszName, len);
 752         pbuff += len;
 753
 754         if (lpszShortName)
 755         { len1 = strlen (lpszShortName)+1;
 756           memcpy (pbuff, lpszShortName, len1);
 757         }
 758         else
 759         { len1 = 1;
 760           *pbuff = 0x00;
 761         }
 762         return _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
 763 }
 764 LPITEMIDLIST WINAPI _ILCreateValue(LPCSTR lpszShortName, LPCSTR lpszName)
 765 {       char    buff[MAX_PATH];
 766         char *  pbuff = buff;
 767         ULONG   len, len1;
 768
 769         TRACE_(pidl)("(%s, %s)\n", lpszShortName, lpszName);
 770
 771         len = strlen (lpszName)+1;
 772         memcpy (pbuff, lpszName, len);
 773         pbuff += len;
 774
 775         if (lpszShortName)
 776         { len1 = strlen (lpszShortName)+1;
 777           memcpy (pbuff, lpszShortName, len1);
 778         }
 779         else
 780         { len1 = 1;
 781           *pbuff = 0x00;
 782         }
 783         return _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
 784 }
 785
 786 /**************************************************************************
 787  *  _ILGetDrive()
 788  *
 789  *  Gets the text for the drive eg. 'c:\'
 790  *
 791  * RETURNS
 792  *  strlen (lpszText)
 793  */
 794 DWORD WINAPI _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
 795 {       TRACE_(pidl)("(%p,%p,%u)\n",pidl,pOut,uSize);
 796
 797         if(_ILIsMyComputer(pidl))
 798           pidl = ILGetNext(pidl);
 799
 800         if (pidl && _ILIsDrive(pidl))
 801           return _ILGetData(PT_DRIVE, pidl, (LPVOID)pOut, uSize)-1;
 802
 803         return 0;
 804 }
 805 /**************************************************************************
 806  *  _ILGetItemText()
 807  *  Gets the text for only the first item
 808  *
 809  * RETURNS
 810  *  strlen (lpszText)
 811  */
 812 DWORD WINAPI _ILGetItemText(LPCITEMIDLIST pidl, LPSTR lpszText, UINT16 uSize)
 813 {       DWORD ret = 0;
 814
 815         TRACE_(pidl)("(pidl=%p %p %d)\n",pidl,lpszText,uSize);
 816         if (_ILIsMyComputer(pidl))
 817         { ret = _ILGetData(PT_MYCOMP, pidl, (LPVOID)lpszText, uSize)-1;
 818         }
 819         else if (_ILIsDrive(pidl))
 820         { ret = _ILGetData(PT_DRIVE, pidl, (LPVOID)lpszText, uSize)-1;
 821         }
 822         else if (_ILIsFolder (pidl))
 823         { ret = _ILGetData(PT_FOLDER, pidl, (LPVOID)lpszText, uSize)-1;
 824         }
 825         else if (_ILIsValue (pidl))
 826         { ret = _ILGetData(PT_VALUE, pidl, (LPVOID)lpszText, uSize)-1;
 827         }
 828         TRACE_(pidl)("(-- %s)\n",debugstr_a(lpszText));
 829         return ret;
 830 }
 831 /**************************************************************************
 832  *  _ILIsDesktop()
 833  *  _ILIsDrive()
 834  *  _ILIsFolder()
 835  *  _ILIsValue()
 836  */
 837 BOOL WINAPI _ILIsDesktop(LPCITEMIDLIST pidl)
 838 {       TRACE_(pidl)("(%p)\n",pidl);
 839         return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
 840 }
 841
 842 BOOL WINAPI _ILIsMyComputer(LPCITEMIDLIST pidl)
 843 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
 844         TRACE_(pidl)("(%p)\n",pidl);
 845         return (pidl && lpPData && PT_MYCOMP == lpPData->type);
 846 }
 847
 848 BOOL WINAPI _ILIsDrive(LPCITEMIDLIST pidl)
 849 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
 850         TRACE_(pidl)("(%p)\n",pidl);
 851         return (pidl && lpPData && (PT_DRIVE == lpPData->type || PT_DRIVE1 == lpPData->type));
 852 }
 853
 854 BOOL WINAPI _ILIsFolder(LPCITEMIDLIST pidl)
 855 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
 856         TRACE_(pidl)("(%p)\n",pidl);
 857         return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
 858 }
 859
 860 BOOL WINAPI _ILIsValue(LPCITEMIDLIST pidl)
 861 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
 862         TRACE_(pidl)("(%p)\n",pidl);
 863         return (pidl && lpPData && PT_VALUE == lpPData->type);
 864 }
 865
 866 /**************************************************************************
 867  *  _ILGetFolderText()
 868  *  Creates a Path string from a PIDL, filtering out the special Folders and values
 869  *  There is no trailing backslash
 870  *  When lpszPath is NULL the needed size is returned
 871  *
 872  * RETURNS
 873  *  strlen(lpszPath)
 874  */
 875 DWORD WINAPI _ILGetFolderText(LPCITEMIDLIST pidl,LPSTR lpszPath, DWORD dwSize)
 876 {       LPITEMIDLIST    pidlTemp;
 877         LPPIDLDATA      pData;
 878         DWORD           dwCopied = 0;
 879         LPSTR           pText;
 880
 881         TRACE_(pidl)("(%p path=%p)\n",pidl, lpszPath);
 882
 883         if(!pidl)
 884           return 0;
 885
 886         if(_ILIsMyComputer(pidl))
 887         { pidlTemp = ILGetNext(pidl);
 888           TRACE_(pidl)("-- skip My Computer\n");
 889         }
 890         else
 891         { pidlTemp = (LPITEMIDLIST)pidl;
 892         }
 893
 894         if(lpszPath)
 895           *lpszPath = 0;
 896
 897         pData = _ILGetDataPointer(pidlTemp);
 898
 899         while(pidlTemp->mkid.cb && !(PT_VALUE == pData->type))
 900         {
 901           if (!(pText = _ILGetTextPointer(pData->type,pData)))
 902             return 0;                           /* foreign pidl */
 903
 904           dwCopied += strlen(pText);
 905
 906           pidlTemp = ILGetNext(pidlTemp);
 907           pData = _ILGetDataPointer(pidlTemp);
 908
 909           if (lpszPath)
 910           { strcat(lpszPath, pText);
 911
 912             if (pidlTemp->mkid.cb               /* last element ? */
 913                 && (pText[2] != '\\')           /* drive has own '\' */
 914                 && (PT_VALUE != pData->type))   /* next element is value */
 915             { lpszPath[dwCopied] = '\\';
 916               lpszPath[dwCopied+1] = '\0';
 917               dwCopied++;
 918             }
 919           }
 920           else                                          /* only length */
 921           { if (pidlTemp->mkid.cb
 922                 && (pText[2] != '\\')
 923                 && (PT_VALUE != pData->type))
 924               dwCopied++;                               /* backslash between elements */
 925           }
 926         }
 927
 928         TRACE_(pidl)("-- (size=%lu path=%s)\n",dwCopied, debugstr_a(lpszPath));
 929         return dwCopied;
 930 }
 931
 932
 933 /**************************************************************************
 934  *  _ILGetValueText()
 935  *  Gets the text for the last item in the list
 936  */
 937 DWORD WINAPI _ILGetValueText(LPCITEMIDLIST pidl, LPSTR lpszValue, DWORD dwSize)
 938 {       LPITEMIDLIST  pidlTemp=pidl;
 939         CHAR          szText[MAX_PATH];
 940
 941         TRACE_(pidl)("(pidl=%p %p 0x%08lx)\n",pidl,lpszValue,dwSize);
 942
 943         if(!pidl)
 944         { return 0;
 945         }
 946
 947         while(pidlTemp->mkid.cb && !_ILIsValue(pidlTemp))
 948         { pidlTemp = ILGetNext(pidlTemp);
 949         }
 950
 951         if(!pidlTemp->mkid.cb)
 952         { return 0;
 953         }
 954
 955         _ILGetItemText( pidlTemp, szText, sizeof(szText));
 956
 957         if(!lpszValue)
 958         { return strlen(szText);
 959         }
 960
 961         strcpy(lpszValue, szText);
 962
 963         TRACE_(pidl)("-- (pidl=%p %p=%s 0x%08lx)\n",pidl,lpszValue,lpszValue,dwSize);
 964         return strlen(lpszValue);
 965 }
 966
 967 /**************************************************************************
 968  *  _ILGetPidlPath()
 969  *  Create a string that includes the Drive name, the folder text and
 970  *  the value text.
 971  *
 972  * RETURNS
 973  *  strlen(lpszOut)
 974  */
 975 DWORD WINAPI _ILGetPidlPath( LPCITEMIDLIST pidl, LPSTR lpszOut, DWORD dwOutSize)
 976 {       int     len = 0;
 977         LPSTR   lpszTemp = lpszOut;
 978
 979         TRACE_(pidl)("(%p,%lu)\n",lpszOut,dwOutSize);
 980
 981         if(!lpszOut)
 982         { return 0;
 983         }
 984
 985         *lpszOut = 0;
 986
 987         len = _ILGetFolderText(pidl, lpszOut, dwOutSize);
 988
 989         lpszOut += len;
 990         strcpy (lpszOut,"\\");
 991         len++; lpszOut++; dwOutSize -= len;
 992
 993         len += _ILGetValueText(pidl, lpszOut, dwOutSize );
 994
 995         /*remove the last backslash if necessary */
 996         if( lpszTemp[len-1]=='\\')
 997         { lpszTemp[len-1] = 0;
 998           len--;
 999         }
1000
1001         TRACE_(pidl)("-- (%p=%s,%u)\n",lpszTemp,lpszTemp,len);
1002
1003         return len;
1004 }
1005
1006 /**************************************************************************
1007  *  _ILCreate()
1008  *  Creates a new PIDL
1009  *  type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1010  *  pIn = data
1011  *  uInSize = size of data (raw)
1012  */
1013
1014 LPITEMIDLIST WINAPI _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
1015 {       LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
1016         LPPIDLDATA     pData;
1017         UINT16         uSize = 0;
1018         LPSTR   pszDest;
1019
1020         TRACE_(pidl)("(0x%02x %p %i)\n",type,pIn,uInSize);
1021
1022         switch (type)
1023         { case PT_DESKTOP:
1024             uSize = 0;
1025             pidlOut = SHAlloc(uSize + 2);
1026             pidlOut->mkid.cb = uSize;
1027             TRACE_(pidl)("- create Desktop\n");
1028             break;
1029
1030           case PT_MYCOMP:
1031             uSize = 2 + 2 + sizeof(GUID);
1032             pidlOut = SHAlloc(uSize + 2);
1033             pidlOut->mkid.cb = uSize;
1034             pData =_ILGetDataPointer(pidlOut);
1035             pData->type = type;
1036             memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
1037             TRACE_(pidl)("- create My Computer\n");
1038             break;
1039
1040           case PT_DRIVE:
1041             uSize = 2 + 23;
1042             pidlOut = SHAlloc(uSize + 2);
1043             pidlOut->mkid.cb = uSize;
1044             pData =_ILGetDataPointer(pidlOut);
1045             pData->type = type;
1046             pszDest =  _ILGetTextPointer(type, pData);
1047             memcpy(pszDest, pIn, uInSize);
1048             TRACE_(pidl)("- create Drive: %s\n",debugstr_a(pszDest));
1049             break;
1050
1051           case PT_FOLDER:
1052           case PT_VALUE:
1053             uSize = 2 + 12 + uInSize;
1054             pidlOut = SHAlloc(uSize + 2);
1055             pidlOut->mkid.cb = uSize;
1056             pData =_ILGetDataPointer(pidlOut);
1057             pData->type = type;
1058             pszDest =  _ILGetTextPointer(type, pData);
1059             memcpy(pszDest, pIn, uInSize);
1060             TRACE_(pidl)("- create Value: %s\n",debugstr_a(pszDest));
1061             break;
1062         }
1063
1064         pidlTemp = ILGetNext(pidlOut);
1065         if (pidlTemp)
1066           pidlTemp->mkid.cb = 0x00;
1067
1068         TRACE_(pidl)("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
1069         return pidlOut;
1070 }
1071 /**************************************************************************
1072  *  _ILGetData(PIDLTYPE, LPCITEMIDLIST, LPVOID, UINT16)
1073  *
1074  * RETURNS
1075  *  length of data (raw)
1076  */
1077 DWORD WINAPI _ILGetData(PIDLTYPE type, LPCITEMIDLIST pidl, LPVOID pOut, UINT uOutSize)
1078 {       LPPIDLDATA  pData;
1079         DWORD       dwReturn=0;
1080         LPSTR       pszSrc;
1081
1082         TRACE_(pidl)("(%x %p %p %x)\n",type,pidl,pOut,uOutSize);
1083
1084         if( (!pidl) || (!pOut) || (uOutSize < 1))
1085         {  return 0;
1086         }
1087
1088         *(LPSTR)pOut = 0;
1089
1090         pData = _ILGetDataPointer(pidl);
1091
1092         assert ( pData->type == type);
1093
1094         pszSrc = _ILGetTextPointer(pData->type, pData);
1095
1096         if (pszSrc)
1097         { strncpy((LPSTR)pOut, pszSrc, uOutSize);
1098           dwReturn = strlen((LPSTR)pOut)+1;
1099         }
1100         else
1101         { ERR_(pidl)("-- no data\n");
1102         }
1103
1104         TRACE_(pidl)("-- (%p=%s 0x%08lx)\n",pOut,(char*)pOut,dwReturn);
1105         return dwReturn;
1106 }
1107
1108
1109 /**************************************************************************
1110  *  _ILGetDataPointer()
1111  */
1112 LPPIDLDATA WINAPI _ILGetDataPointer(LPITEMIDLIST pidl)
1113 {       if(pidl && pidl->mkid.cb != 0x00)
1114           return (LPPIDLDATA)(&pidl->mkid.abID);
1115         return NULL;
1116 }
1117 /**************************************************************************
1118  *  _ILGetTextPointer()
1119  * gets a pointer to the long filename string stored in the pidl
1120  */
1121 LPSTR WINAPI _ILGetTextPointer(PIDLTYPE type, LPPIDLDATA pidldata)
1122 {/*     TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
1123
1124         if(!pidldata)
1125         { return NULL;
1126         }
1127
1128         switch (type)
1129         { case PT_DRIVE:
1130           case PT_DRIVE1:
1131             return (LPSTR)&(pidldata->u.drive.szDriveName);
1132
1133           case PT_MYCOMP:
1134             return szMyComp;
1135
1136           case PT_FOLDER:
1137           case PT_FOLDER1:
1138           case PT_VALUE:
1139             return (LPSTR)&(pidldata->u.file.szNames);
1140
1141           case PT_WORKGRP:
1142           case PT_COMP:
1143           case PT_NETWORK:
1144           case PT_SHARE:
1145             return (LPSTR)&(pidldata->u.network.szNames);
1146         }
1147         return NULL;
1148 }
1149 /**************************************************************************
1150  *  _ILGetSTextPointer()
1151  * gets a pointer to the long filename string stored in the pidl
1152  */
1153 LPSTR WINAPI _ILGetSTextPointer(PIDLTYPE type, LPPIDLDATA pidldata)
1154 {/*     TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
1155
1156         if(!pidldata)
1157         { return NULL;
1158         }
1159         switch (type)
1160         { case PT_FOLDER:
1161           case PT_VALUE:
1162             return (LPSTR)(pidldata->u.file.szNames + strlen (pidldata->u.file.szNames) + 1);
1163           case PT_WORKGRP:
1164             return (LPSTR)(pidldata->u.network.szNames + strlen (pidldata->u.network.szNames) + 1);
1165         }
1166         return NULL;
1167 }
1168 BOOL WINAPI _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1169 {       LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1170         FILETIME ft;
1171         SYSTEMTIME time;
1172
1173         switch (pdata->type)
1174         { case PT_FOLDER:
1175             DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, &ft);
1176             break;
1177           case PT_VALUE:
1178             DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, &ft);
1179             break;
1180           default:
1181             return FALSE;
1182         }
1183         FileTimeToSystemTime (&ft, &time);
1184         return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
1185 }
1186 BOOL WINAPI _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1187 {       LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1188         char stemp[20]; /* for filesize */
1189
1190         switch (pdata->type)
1191         { case PT_VALUE:
1192             break;
1193           default:
1194             return FALSE;
1195         }
1196         StrFormatByteSizeA(pdata->u.file.dwFileSize, stemp, 20);
1197         strncpy( pOut, stemp, 20);
1198         return TRUE;
1199 }
1200
1201 BOOL WINAPI _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1202 {       char pTemp[MAX_PATH];
1203         int i;
1204
1205         TRACE_(pidl)("pidl=%p\n",pidl);
1206
1207         if ( ! _ILGetValueText(pidl, pTemp, MAX_PATH))
1208         { return FALSE;
1209         }
1210
1211         for (i=0; pTemp[i]!='.' && pTemp[i];i++);
1212
1213         if (!pTemp[i])
1214           return FALSE;
1215
1216         strncpy(pOut, &pTemp[i], uOutSize);
1217         TRACE_(pidl)("%s\n",pOut);
1218
1219         return TRUE;
1220 }