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