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 "shell32_main.h"
  26
  27 #include "pidl.h"
  28
  29 void pdump (LPCITEMIDLIST pidl)
  30 {       DWORD type;
  31         CHAR * szData;
  32         LPITEMIDLIST pidltemp = pidl;
  33         if (! pidltemp)
  34         { TRACE(pidl,"-------- pidl = NULL (Root)\n");
  35           return;
  36         }
  37         TRACE(pidl,"-------- pidl=%p \n", pidl);
  38         if (pidltemp->mkid.cb)
  39         { do
  40           { type   = _ILGetDataPointer(pidltemp)->type;
  41             szData = _ILGetTextPointer(type, _ILGetDataPointer(pidltemp));
  42
  43             TRACE(pidl,"---- pidl=%p size=%u type=%lx %s\n",pidltemp, pidltemp->mkid.cb,type,debugstr_a(szData));
  44
  45             pidltemp = ILGetNext(pidltemp);
  46           } while (pidltemp->mkid.cb);
  47           return;
  48         }
  49         else
  50           TRACE(pidl,"empty pidl (Desktop)\n");
  51 }
  52 /*************************************************************************
  53  * ILGetDisplayName                     [SHELL32.15]
  54  */
  55 BOOL32 WINAPI ILGetDisplayName(LPCITEMIDLIST iil,LPSTR path)
  56 {       FIXME(pidl,"(%p,%p),stub, return e:!\n",iil,path);
  57         strcpy(path,"e:\\");
  58         return TRUE;
  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 BOOL32 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   TRACE(pidl,"%p\n",pidl);
 100
 101   pdump(pidl);
 102
 103   if (!pidl)
 104     return NULL;
 105
 106   len = ILGetSize(pidl);
 107   newpidl = (LPITEMIDLIST)SHAlloc(len);
 108   if (newpidl)
 109     memcpy(newpidl,pidl,len);
 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         TRACE(pidl,"pidl=%p\n",pidl);
 122
 123         if (pidl)
 124         { len = pidl->mkid.cb;
 125           newpidl = (LPITEMIDLIST) SHAlloc (len+2);
 126           if (newpidl)
 127           { memcpy(newpidl,pidl,len);
 128             ILGetNext(newpidl)->mkid.cb = 0x00;
 129           }
 130          }
 131
 132         return newpidl;
 133 }
 134 /*************************************************************************
 135  * ILIsEqual [SHELL32.21]
 136  *
 137  */
 138 BOOL32 WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 139 {       FIXME(pidl,"pidl1=%p pidl2=%p stub\n",pidl1, pidl2);
 140         pdump (pidl1);
 141         pdump (pidl2);
 142         return FALSE;
 143 }
 144 /*************************************************************************
 145  * ILFindChild [SHELL32.24]
 146  *
 147  */
 148 DWORD WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 149 {       FIXME(pidl,"%p %p stub\n",pidl1,pidl2);
 150         pdump (pidl1);
 151         pdump (pidl2);
 152         return 0;
 153 }
 154
 155 /*************************************************************************
 156  * ILCombine [SHELL32.25]
 157  *
 158  * NOTES
 159  *  Concatenates two complex idlists.
 160  *  The pidl is the first one, pidlsub the next one
 161  *  Does not destroy the passed in idlists!
 162  */
 163 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
 164 { DWORD    len1,len2;
 165   LPITEMIDLIST  pidlNew;
 166
 167   TRACE(pidl,"pidl=%p pidl=%p\n",pidl1,pidl2);
 168
 169   if(!pidl1 && !pidl2)
 170   {  return NULL;
 171   }
 172
 173   pdump (pidl1);
 174   pdump (pidl2);
 175
 176   if(!pidl1)
 177   { pidlNew = ILClone(pidl2);
 178     return pidlNew;
 179   }
 180
 181   if(!pidl2)
 182   { pidlNew = ILClone(pidl1);
 183     return pidlNew;
 184   }
 185
 186   len1  = ILGetSize(pidl1)-2;
 187   len2  = ILGetSize(pidl2);
 188   pidlNew  = SHAlloc(len1+len2);
 189
 190   if (pidlNew)
 191   { memcpy(pidlNew,pidl1,len1);
 192     memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
 193   }
 194
 195 /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
 196   return pidlNew;
 197 }
 198 /*************************************************************************
 199  *  SHLogILFromFSIL [SHELL32.95]
 200  *
 201  * NOTES
 202  *  might be the prepending of MyComputer to a filesystem pidl (?)
 203  */
 204 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
 205 {       FIXME(pidl,"(pidl=%p)\n",pidl);
 206         pdump(pidl);
 207         return ILClone(pidl);
 208 }
 209
 210 /*************************************************************************
 211  * ILGetSize [SHELL32.152]
 212  *  gets the byte size of an idlist including zero terminator (pidl)
 213  *
 214  * PARAMETERS
 215  *  pidl ITEMIDLIST
 216  *
 217  * RETURNS
 218  *  size of pidl
 219  *
 220  * NOTES
 221  *  exported by ordinal
 222  */
 223 DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
 224 {       LPSHITEMID si = &(pidl->mkid);
 225         DWORD  len=0;
 226
 227         /*TRACE(pidl,"pidl=%p\n",pidl);*/
 228
 229         if (pidl)
 230         { while (si->cb)
 231           { len += si->cb;
 232             si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
 233           }
 234           len += 2;
 235         }
 236         /*TRACE(pidl,"-- size=%lu\n",len);*/
 237         return len;
 238 }
 239 /*************************************************************************
 240  * ILGetNext [SHELL32.153]
 241  *  gets the next simple pidl of a complex pidl
 242  *
 243  * PARAMETERS
 244  *  pidl ITEMIDLIST
 245  *
 246  * RETURNS
 247  *  pointer to next element
 248  *
 249  */
 250 LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
 251 {       LPITEMIDLIST nextpidl;
 252
 253 /*      TRACE(pidl,"(pidl=%p)\n",pidl);*/
 254         if(pidl)
 255         { nextpidl = (LPITEMIDLIST)(LPBYTE)(((LPBYTE)pidl) + pidl->mkid.cb);
 256           return nextpidl;
 257         }
 258         else
 259         {  return (NULL);
 260         }
 261 }
 262 /*************************************************************************
 263  * ILAppend [SHELL32.154]
 264  *
 265  * NOTES
 266  *  Adds the single item to the idlist indicated by pidl.
 267  *  if bEnd is 0, adds the item to the front of the list,
 268  *  otherwise adds the item to the end.
 269  *  Destroys the passed in idlist!
 270  */
 271 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL32 bEnd)
 272 {       FIXME(pidl,"(pidl=%p,pidl=%p,%08u)stub\n",pidl,item,bEnd);
 273         return NULL;
 274 }
 275 /*************************************************************************
 276  * ILFree [SHELL32.155]
 277  *
 278  * NOTES
 279  *     free_check_ptr - frees memory (if not NULL)
 280  *     allocated by SHMalloc allocator
 281  *     exported by ordinal
 282  */
 283 DWORD WINAPI ILFree(LPVOID pidl)
 284 {       TRACE(pidl,"(pidl=0x%08lx)\n",(DWORD)pidl);
 285         if (!pidl)
 286           return 0;
 287         return SHFree(pidl);
 288 }
 289 /*************************************************************************
 290  * ILCreateFromPath [SHELL32.157]
 291  *
 292  */
 293 LPITEMIDLIST WINAPI ILCreateFromPath(LPSTR path)
 294 {       LPSHELLFOLDER shellfolder;
 295         LPITEMIDLIST pidlnew;
 296         CHAR pszTemp[MAX_PATH*2];
 297         LPWSTR lpszDisplayName = (LPWSTR)&pszTemp[0];
 298         DWORD pchEaten;
 299
 300         TRACE(pidl,"(path=%s)\n",path);
 301
 302         LocalToWideChar32(lpszDisplayName, path, MAX_PATH);
 303
 304         if (SHGetDesktopFolder(&shellfolder)==S_OK)
 305         { shellfolder->lpvtbl->fnParseDisplayName(shellfolder,0, NULL,lpszDisplayName,&pchEaten,&pidlnew,NULL);
 306           shellfolder->lpvtbl->fnRelease(shellfolder);
 307         }
 308         return pidlnew;
 309 }
 310
 311 /**************************************************************************
 312 * internal functions
 313 */
 314
 315 /**************************************************************************
 316  *  _ILCreateDesktop()
 317  *  _ILCreateMyComputer()
 318  *  _ILCreateDrive()
 319  *  _ILCreateFolder()
 320  *  _ILCreateValue()
 321  */
 322 LPITEMIDLIST WINAPI _ILCreateDesktop()
 323 {       TRACE(pidl,"()\n");
 324         return _ILCreate(PT_DESKTOP, NULL, 0);
 325 }
 326 LPITEMIDLIST WINAPI _ILCreateMyComputer()
 327 { TRACE(pidl,"()\n");
 328   return _ILCreate(PT_MYCOMP, (void *)"My Computer", strlen ("My Computer")+1);
 329 }
 330 LPITEMIDLIST WINAPI _ILCreateDrive( LPCSTR lpszNew)
 331 {       char sTemp[4];
 332         strncpy (sTemp,lpszNew,4);
 333         sTemp[2]='\\';
 334         sTemp[3]=0x00;
 335         TRACE(pidl,"(%s)\n",sTemp);
 336         return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
 337 }
 338 LPITEMIDLIST WINAPI _ILCreateFolder( LPCSTR lpszNew)
 339 { TRACE(pidl,"(%s)\n",lpszNew);
 340   return _ILCreate(PT_FOLDER, (LPVOID)lpszNew, strlen(lpszNew)+1);
 341 }
 342 LPITEMIDLIST WINAPI _ILCreateValue(LPCSTR lpszNew)
 343 { TRACE(pidl,"(%s)\n",lpszNew);
 344   return _ILCreate(PT_VALUE, (LPVOID)lpszNew, strlen(lpszNew)+1);
 345 }
 346
 347 /**************************************************************************
 348  *  _ILGetDrive()
 349  *
 350  *  FIXME: quick hack
 351  */
 352 BOOL32 WINAPI _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
 353 {       LPITEMIDLIST   pidlTemp=NULL;
 354
 355         TRACE(pidl,"(%p,%p,%u)\n",pidl,pOut,uSize);
 356         if(_ILIsMyComputer(pidl))
 357         { pidlTemp = ILGetNext(pidl);
 358         }
 359         else if (pidlTemp && _ILIsDrive(pidlTemp))
 360         { return (BOOL32)_ILGetData(PT_DRIVE, pidlTemp, (LPVOID)pOut, uSize);
 361         }
 362         return FALSE;
 363 }
 364 /**************************************************************************
 365  *  _ILGetItemText()
 366  *  Gets the text for only this item
 367  */
 368 DWORD WINAPI _ILGetItemText(LPCITEMIDLIST pidl, LPSTR lpszText, UINT16 uSize)
 369 {       TRACE(pidl,"(pidl=%p %p %x)\n",pidl,lpszText,uSize);
 370         if (_ILIsMyComputer(pidl))
 371         { return _ILGetData(PT_MYCOMP, pidl, (LPVOID)lpszText, uSize);
 372         }
 373         if (_ILIsDrive(pidl))
 374         { return _ILGetData(PT_DRIVE, pidl, (LPVOID)lpszText, uSize);
 375         }
 376         if (_ILIsFolder (pidl))
 377         { return _ILGetData(PT_FOLDER, pidl, (LPVOID)lpszText, uSize);
 378         }
 379         return _ILGetData(PT_VALUE, pidl, (LPVOID)lpszText, uSize);
 380 }
 381 /**************************************************************************
 382  *  _ILIsDesktop()
 383  *  _ILIsDrive()
 384  *  _ILIsFolder()
 385  *  _ILIsValue()
 386  */
 387 BOOL32 WINAPI _ILIsDesktop(LPCITEMIDLIST pidl)
 388 { TRACE(pidl,"(%p)\n",pidl);
 389
 390   if (! pidl)
 391     return TRUE;
 392
 393   return (  pidl->mkid.cb == 0x00 );
 394 }
 395
 396 BOOL32 WINAPI _ILIsMyComputer(LPCITEMIDLIST pidl)
 397 { LPPIDLDATA  pData;
 398   TRACE(pidl,"(%p)\n",pidl);
 399
 400   if (! pidl)
 401     return FALSE;
 402
 403   pData = _ILGetDataPointer(pidl);
 404   return (PT_MYCOMP == pData->type);
 405 }
 406
 407 BOOL32 WINAPI _ILIsDrive(LPCITEMIDLIST pidl)
 408 { LPPIDLDATA  pData;
 409   TRACE(pidl,"(%p)\n",pidl);
 410
 411   if (! pidl)
 412     return FALSE;
 413
 414   pData = _ILGetDataPointer(pidl);
 415   return (PT_DRIVE == pData->type);
 416 }
 417
 418 BOOL32 WINAPI _ILIsFolder(LPCITEMIDLIST pidl)
 419 { LPPIDLDATA  pData;
 420   TRACE(pidl,"(%p)\n",pidl);
 421
 422   if (! pidl)
 423     return FALSE;
 424
 425   pData = _ILGetDataPointer(pidl);
 426   return (PT_FOLDER == pData->type);
 427 }
 428
 429 BOOL32 WINAPI _ILIsValue(LPCITEMIDLIST pidl)
 430 { LPPIDLDATA  pData;
 431   TRACE(pidl,"(%p)\n",pidl);
 432
 433   if (! pidl)
 434     return FALSE;
 435
 436   pData = _ILGetDataPointer(pidl);
 437   return (PT_VALUE == pData->type);
 438 }
 439 /**************************************************************************
 440  * _ILHasFolders()
 441  * fixme: quick hack
 442  */
 443 BOOL32 WINAPI _ILHasFolders( LPSTR pszPath, LPCITEMIDLIST pidl)
 444 {       BOOL32 bResult= FALSE;
 445         WIN32_FIND_DATA32A stffile;
 446         HANDLE32 hFile;
 447
 448         TRACE(pidl,"%p %p\n", pszPath, pidl);
 449
 450         hFile = FindFirstFile32A(pszPath,&stffile);
 451         do
 452         { if (! (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
 453           {  bResult= TRUE;
 454           }
 455         } while( FindNextFile32A(hFile,&stffile));
 456         FindClose32 (hFile);
 457
 458         return bResult;
 459 }
 460
 461 /**************************************************************************
 462  *  _ILGetFolderText()
 463  *  Creates a Path string from a PIDL, filtering out the special Folders
 464  */
 465 DWORD WINAPI _ILGetFolderText(LPCITEMIDLIST pidl,LPSTR lpszPath, DWORD dwSize)
 466 {       LPITEMIDLIST    pidlTemp;
 467         DWORD           dwCopied = 0;
 468         LPSTR           pText;
 469
 470         TRACE(pidl,"(%p)\n",pidl);
 471
 472         if(!pidl)
 473         { return 0;
 474         }
 475
 476         if(_ILIsMyComputer(pidl))
 477         { pidlTemp = ILGetNext(pidl);
 478           TRACE(pidl,"-- skip My Computer\n");
 479         }
 480         else
 481         { pidlTemp = (LPITEMIDLIST)pidl;
 482         }
 483
 484         //if this is NULL, return the required size of the buffer
 485         if(!lpszPath)
 486         { while(pidlTemp->mkid.cb)
 487           { LPPIDLDATA  pData = _ILGetDataPointer(pidlTemp);
 488             pText = _ILGetTextPointer(pData->type,pData);
 489
 490             /*add the length of this item plus one for the backslash
 491             fixme: is one to much, drive has its own backslash*/
 492             dwCopied += strlen(pText) + 1;
 493             pidlTemp = ILGetNext(pidlTemp);
 494           }
 495
 496           //add one for the NULL terminator
 497           TRACE(pidl,"-- (size=%lu)\n",dwCopied);
 498           return dwCopied + 1;
 499         }
 500
 501         *lpszPath = 0;
 502
 503         while(pidlTemp->mkid.cb && (dwCopied < dwSize))
 504         { LPPIDLDATA  pData = _ILGetDataPointer(pidlTemp);
 505
 506           //if this item is a value, then skip it and finish
 507           if(PT_VALUE == pData->type)
 508           { break;
 509           }
 510           pText = _ILGetTextPointer(pData->type,pData);
 511           strcat(lpszPath, pText);
 512           PathAddBackslash(lpszPath);
 513           dwCopied += strlen(pText) + 1;
 514           pidlTemp = ILGetNext(pidlTemp);
 515
 516           TRACE(pidl,"-- (size=%lu,%s)\n",dwCopied,lpszPath);
 517         }
 518
 519         //remove the last backslash if necessary
 520         if(dwCopied)
 521         { if(*(lpszPath + strlen(lpszPath) - 1) == '\\')
 522           { *(lpszPath + strlen(lpszPath) - 1) = 0;
 523             dwCopied--;
 524           }
 525         }
 526         TRACE(pidl,"-- (path=%s)\n",lpszPath);
 527         return dwCopied;
 528 }
 529
 530
 531 /**************************************************************************
 532  *  _ILGetValueText()
 533  *  Gets the text for the last item in the list
 534  */
 535 DWORD WINAPI _ILGetValueText(
 536     LPCITEMIDLIST pidl, LPSTR lpszValue, DWORD dwSize)
 537 {       LPITEMIDLIST  pidlTemp=pidl;
 538         CHAR          szText[MAX_PATH];
 539
 540         TRACE(pidl,"(pidl=%p %p 0x%08lx)\n",pidl,lpszValue,dwSize);
 541
 542         if(!pidl)
 543         { return 0;
 544         }
 545
 546         while(pidlTemp->mkid.cb && !_ILIsValue(pidlTemp))
 547         { pidlTemp = ILGetNext(pidlTemp);
 548         }
 549
 550         if(!pidlTemp->mkid.cb)
 551         { return 0;
 552         }
 553
 554         _ILGetItemText( pidlTemp, szText, sizeof(szText));
 555
 556         if(!lpszValue)
 557         { return strlen(szText) + 1;
 558         }
 559         strcpy(lpszValue, szText);
 560         TRACE(pidl,"-- (pidl=%p %p=%s 0x%08lx)\n",pidl,lpszValue,lpszValue,dwSize);
 561         return strlen(lpszValue);
 562 }
 563 /**************************************************************************
 564  *  _ILGetDataText()
 565  * NOTES
 566  *  used from ShellView
 567  */
 568 DWORD WINAPI _ILGetDataText( LPCITEMIDLIST pidlPath, LPCITEMIDLIST pidlValue, LPSTR lpszOut, DWORD dwOutSize)
 569 { LPSTR    lpszFolder,
 570            lpszValueName;
 571   DWORD    dwNameSize;
 572
 573   FIXME(pidl,"(pidl=%p pidl=%p) stub\n",pidlPath,pidlValue);
 574
 575   if(!lpszOut || !pidlPath || !pidlValue)
 576   { return FALSE;
 577         }
 578
 579   /* fixme: get the driveletter*/
 580
 581   //assemble the Folder string
 582   dwNameSize = _ILGetFolderText(pidlPath, NULL, 0);
 583   lpszFolder = (LPSTR)HeapAlloc(GetProcessHeap(),0,dwNameSize);
 584   if(!lpszFolder)
 585   {  return FALSE;
 586         }
 587   _ILGetFolderText(pidlPath, lpszFolder, dwNameSize);
 588
 589   //assemble the value name
 590   dwNameSize = _ILGetValueText(pidlValue, NULL, 0);
 591   lpszValueName = (LPSTR)HeapAlloc(GetProcessHeap(),0,dwNameSize);
 592   if(!lpszValueName)
 593   { HeapFree(GetProcessHeap(),0,lpszFolder);
 594     return FALSE;
 595   }
 596   _ILGetValueText(pidlValue, lpszValueName, dwNameSize);
 597
 598   /* fixme: we've got the path now do something with it*/
 599
 600   HeapFree(GetProcessHeap(),0,lpszFolder);
 601   HeapFree(GetProcessHeap(),0,lpszValueName);
 602
 603   TRACE(pidl,"-- (%p=%s 0x%08lx)\n",lpszOut,lpszOut,dwOutSize);
 604
 605         return TRUE;
 606 }
 607
 608 /**************************************************************************
 609  *  _ILGetPidlPath()
 610  *  Create a string that includes the Drive name, the folder text and
 611  *  the value text.
 612  */
 613 DWORD WINAPI _ILGetPidlPath( LPCITEMIDLIST pidl, LPSTR lpszOut, DWORD dwOutSize)
 614 { LPSTR lpszTemp;
 615   WORD  len;
 616
 617   TRACE(pidl,"(%p,%lu)\n",lpszOut,dwOutSize);
 618
 619   if(!lpszOut)
 620   { return 0;
 621         }
 622
 623   *lpszOut = 0;
 624   lpszTemp = lpszOut;
 625
 626   dwOutSize -= _ILGetFolderText(pidl, lpszTemp, dwOutSize);
 627
 628   //add a backslash if necessary
 629   len = strlen(lpszTemp);
 630   if (len && lpszTemp[len-1]!='\\')
 631         { lpszTemp[len+0]='\\';
 632     lpszTemp[len+1]='\0';
 633                 dwOutSize--;
 634   }
 635
 636   lpszTemp = lpszOut + strlen(lpszOut);
 637
 638   //add the value string
 639   _ILGetValueText(pidl, lpszTemp, dwOutSize);
 640
 641   //remove the last backslash if necessary
 642   if(*(lpszOut + strlen(lpszOut) - 1) == '\\')
 643   { *(lpszOut + strlen(lpszOut) - 1) = 0;
 644   }
 645
 646   TRACE(pidl,"-- (%p=%s,%lu)\n",lpszOut,lpszOut,dwOutSize);
 647
 648   return strlen(lpszOut);
 649
 650 }
 651
 652 /**************************************************************************
 653  *  _ILCreate()
 654  *  Creates a new PIDL
 655  *  type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
 656  *  pIn = data
 657  *  uInSize = size of data
 658  */
 659
 660 LPITEMIDLIST WINAPI _ILCreate(PIDLTYPE type, LPVOID pIn, UINT16 uInSize)
 661 {       LPITEMIDLIST   pidlOut=NULL;
 662         UINT16         uSize;
 663         LPITEMIDLIST   pidlTemp=NULL;
 664         LPPIDLDATA     pData;
 665         LPSTR   pszDest;
 666
 667         TRACE(pidl,"(%x %p %x)\n",type,pIn,uInSize);
 668
 669         if ( type == PT_DESKTOP)
 670         { pidlOut = SHAlloc(2);
 671           pidlOut->mkid.cb=0x0000;
 672           return pidlOut;
 673         }
 674
 675         if (! pIn)
 676         { return NULL;
 677         }
 678
 679         /* the sizes of: cb(2), pidldata-1, szText+1, next cb(2) */
 680         switch (type)
 681         { case PT_DRIVE:
 682             uSize = 4 + 10;
 683             break;
 684           default:
 685             uSize = 4 + (sizeof(PIDLDATA)) + uInSize;
 686          }
 687         pidlOut = SHAlloc(uSize);
 688         pidlTemp = pidlOut;
 689         if(pidlOut)
 690         { pidlTemp->mkid.cb = uSize - 2;
 691           pData =_ILGetDataPointer(pidlTemp);
 692           pszDest =  _ILGetTextPointer(type, pData);
 693           pData->type = type;
 694           switch(type)
 695           { case PT_MYCOMP:
 696               memcpy(pszDest, pIn, uInSize);
 697               TRACE(pidl,"- create My Computer: %s\n",debugstr_a(pszDest));
 698               break;
 699             case PT_DRIVE:
 700               memcpy(pszDest, pIn, uInSize);
 701               TRACE(pidl,"- create Drive: %s\n",debugstr_a(pszDest));
 702               break;
 703             case PT_FOLDER:
 704             case PT_VALUE:
 705               memcpy(pszDest, pIn, uInSize);
 706               TRACE(pidl,"- create Value: %s\n",debugstr_a(pszDest));
 707               break;
 708             default:
 709               FIXME(pidl,"-- wrong argument\n");
 710               break;
 711           }
 712
 713           pidlTemp = ILGetNext(pidlTemp);
 714           pidlTemp->mkid.cb = 0x00;
 715         }
 716         TRACE(pidl,"-- (pidl=%p, size=%u)\n",pidlOut,uSize-2);
 717         return pidlOut;
 718 }
 719 /**************************************************************************
 720  *  _ILGetData(PIDLTYPE, LPCITEMIDLIST, LPVOID, UINT16)
 721  */
 722 DWORD WINAPI _ILGetData(PIDLTYPE type, LPCITEMIDLIST pidl, LPVOID pOut, UINT16 uOutSize)
 723 {       LPPIDLDATA  pData;
 724         DWORD       dwReturn=0;
 725         LPSTR       pszSrc;
 726
 727         TRACE(pidl,"(%x %p %p %x)\n",type,pidl,pOut,uOutSize);
 728
 729         if(!pidl)
 730         {  return 0;
 731         }
 732
 733         *(LPSTR)pOut = 0;
 734
 735         pData = _ILGetDataPointer(pidl);
 736         if ( pData->type != type)
 737         { ERR(pidl,"-- wrong type\n");
 738           return 0;
 739         }
 740         pszSrc = _ILGetTextPointer(pData->type, pData);
 741
 742         switch(type)
 743         { case PT_MYCOMP:
 744             if(uOutSize < 1)
 745               return 0;
 746             strncpy((LPSTR)pOut, "My Computer", uOutSize);
 747             dwReturn = strlen((LPSTR)pOut);
 748             break;
 749
 750           case PT_DRIVE:
 751             if(uOutSize < 1)
 752               return 0;
 753             strncpy((LPSTR)pOut, pszSrc, uOutSize);
 754             dwReturn = strlen((LPSTR)pOut);
 755             break;
 756
 757           case PT_FOLDER:
 758           case PT_VALUE:
 759              strncpy((LPSTR)pOut, pszSrc, uOutSize);
 760              dwReturn = strlen((LPSTR)pOut);
 761              break;
 762           default:
 763             ERR(pidl,"-- unknown type\n");
 764             break;
 765         }
 766         TRACE(pidl,"-- (%p=%s 0x%08lx)\n",pOut,(char*)pOut,dwReturn);
 767         return dwReturn;
 768 }
 769
 770
 771 /**************************************************************************
 772  *  _ILGetDataPointer()
 773  */
 774 LPPIDLDATA WINAPI _ILGetDataPointer(LPITEMIDLIST pidl)
 775 {       if(!pidl)
 776         { return NULL;
 777         }
 778 /*      TRACE(pidl,"(%p)\n",  pidl);*/
 779         return (LPPIDLDATA)(&pidl->mkid.abID);
 780 }
 781 /**************************************************************************
 782  *  _ILGetTextPointer()
 783  * gets a pointer to the string stored in the pidl
 784  */
 785 LPSTR WINAPI _ILGetTextPointer(PIDLTYPE type, LPPIDLDATA pidldata)
 786 {/*     TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
 787
 788         if(!pidldata)
 789         { return NULL;
 790         }
 791         switch (type)
 792         { case PT_DRIVE:
 793             return (LPSTR)&(pidldata->u.drive.szDriveName);
 794           case PT_MYCOMP:
 795           case PT_FOLDER:
 796           case PT_VALUE:
 797             return (LPSTR)&(pidldata->u.file.szText);
 798         }
 799         return NULL;
 800 }