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