Ignore:
Timestamp:
Sep 15, 2001, 11:26:26 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/pidl.c

    r6650 r6709  
    1 /* $Id: pidl.c,v 1.4 2001-09-05 13:46:56 bird Exp $ */
    21/*
    3  *  pidl Handling
    4  *
    5  *  Copyright 1998  Juergen Schmied
     2 *      pidl Handling
     3 *
     4 *      Copyright 1998  Juergen Schmied
    65 *
    76 * NOTES
    … …  
    3130void pdump (LPCITEMIDLIST pidl)
    3231{
    33     BOOL bIsShellDebug;
    34 
    35     LPITEMIDLIST pidltemp = pidl;
    36     if (!TRACE_ON(pidl))
    37       return;
    38 
    39     /* silence the sub-functions */
    40     bIsShellDebug = TRACE_ON(shell);
    41     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, FALSE);
    42     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
    43 
    44     if (! pidltemp)
    45     {
    46       MESSAGE ("-------- pidl=NULL (Desktop)\n");
    47     }
    48     else
    49     {
    50       MESSAGE ("-------- pidl=%p\n", pidl);
    51       if (pidltemp->mkid.cb)
    52       {
    53         do
    54         {
    55           DWORD dwAttrib = 0;
    56           LPPIDLDATA pData   = _ILGetDataPointer(pidltemp);
    57           DWORD type         = pData->type;
    58           LPSTR szLongName   = _ILGetTextPointer(pidltemp);
    59           LPSTR szShortName  = _ILGetSTextPointer(pidltemp);
    60           char szName[MAX_PATH];
    61 
    62           _ILSimpleGetText(pidltemp, szName, MAX_PATH);
    63           if( PT_FOLDER == type)
    64             dwAttrib = pData->u.folder.uFileAttribs;
    65           else if( PT_VALUE == type)
    66             dwAttrib = pData->u.file.uFileAttribs;
    67 
    68           MESSAGE ("-- pidl=%p size=%u type=%lx attr=0x%08lx name=%s (%s,%s)\n",
    69                    pidltemp, pidltemp->mkid.cb,type,dwAttrib,szName,debugstr_a(szLongName), debugstr_a(szShortName));
    70 
    71           pidltemp = ILGetNext(pidltemp);
    72 
    73         } while (pidltemp->mkid.cb);
    74       }
    75       else
    76       {
    77         MESSAGE ("empty pidl (Desktop)\n");
    78       }
    79       pcheck(pidl);
    80     }
    81 
    82     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, bIsShellDebug);
    83     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, TRUE);
     32        BOOL bIsShellDebug;
     33       
     34        LPITEMIDLIST pidltemp = pidl;
     35        if (!TRACE_ON(pidl))
     36          return;
     37
     38        /* silence the sub-functions */
     39        bIsShellDebug = TRACE_ON(shell);
     40        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, FALSE);
     41        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
     42
     43        if (! pidltemp)
     44        {
     45          MESSAGE ("-------- pidl=NULL (Desktop)\n");
     46        }
     47        else
     48        {
     49          MESSAGE ("-------- pidl=%p\n", pidl);
     50          if (pidltemp->mkid.cb)
     51          {
     52            do
     53            {
     54              DWORD dwAttrib = 0;
     55              LPPIDLDATA pData   = _ILGetDataPointer(pidltemp);
     56              DWORD type         = pData->type;
     57              LPSTR szLongName   = _ILGetTextPointer(pidltemp);
     58              LPSTR szShortName  = _ILGetSTextPointer(pidltemp);
     59              char szName[MAX_PATH];
     60
     61              _ILSimpleGetText(pidltemp, szName, MAX_PATH);
     62              if( PT_FOLDER == type)
     63                dwAttrib = pData->u.folder.uFileAttribs;
     64              else if( PT_VALUE == type)
     65                dwAttrib = pData->u.file.uFileAttribs;
     66
     67              MESSAGE ("-- pidl=%p size=%u type=%lx attr=0x%08lx name=%s (%s,%s)\n",
     68                       pidltemp, pidltemp->mkid.cb,type,dwAttrib,szName,debugstr_a(szLongName), debugstr_a(szShortName));
     69
     70              pidltemp = ILGetNext(pidltemp);
     71
     72            } while (pidltemp->mkid.cb);
     73          }
     74          else
     75          {
     76            MESSAGE ("empty pidl (Desktop)\n");
     77          }
     78          pcheck(pidl);
     79        }
     80
     81        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_shell, bIsShellDebug);
     82        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, TRUE);
    8483
    8584}
    … …  
    8887BOOL pcheck (LPCITEMIDLIST pidl)
    8988{       DWORD type, ret=TRUE;
    90     BOOL bIsPidlDebug;
     89        BOOL bIsPidlDebug;
    9190
    9291        LPITEMIDLIST pidltemp = pidl;
    9392
    94     bIsPidlDebug = TRACE_ON(shell);
    95     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
     93        bIsPidlDebug = TRACE_ON(shell);
     94        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, FALSE);
    9695
    9796        if (pidltemp && pidltemp->mkid.cb)
    … …  
    9998          { type   = _ILGetDataPointer(pidltemp)->type;
    10099            switch (type)
    101         { case PT_DESKTOP:
    102           case PT_MYCOMP:
    103           case PT_SPECIAL:
    104           case PT_DRIVE:
    105           case PT_DRIVE1:
    106           case PT_DRIVE2:
    107           case PT_DRIVE3:
    108           case PT_FOLDER:
    109           case PT_VALUE:
    110           case PT_FOLDER1:
    111           case PT_WORKGRP:
    112           case PT_COMP:
    113           case PT_NETWORK:
    114           case PT_IESPECIAL1:
    115           case PT_IESPECIAL2:
    116           case PT_SHARE:
    117         break;
    118           default:
    119           {
    120         char szTemp[BYTES_PRINTED*4 + 1];
    121         int i;
    122         unsigned char c;
    123 
    124         memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
    125         for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
    126         {
    127           c = ((unsigned char *)pidltemp)[i];
    128 
    129           szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
    130           szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
    131           szTemp[i*3+2] = ' ';
    132           szTemp[i+BYTES_PRINTED*3]  =  (c>=0x20 && c <=0x80) ? c : '.';
    133         }
    134         szTemp[BYTES_PRINTED*4] = 0x00;
    135         ERR("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
    136         ret = FALSE;
    137           }
    138         }
    139         pidltemp = ILGetNext(pidltemp);
    140       } while (pidltemp->mkid.cb);
    141     }
    142     __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, bIsPidlDebug);
    143     return ret;
    144 }
    145 
    146 /*************************************************************************
    147  * ILGetDisplayName         [SHELL32.15]
     100            { case PT_DESKTOP:
     101              case PT_MYCOMP:
     102              case PT_SPECIAL:
     103              case PT_DRIVE:
     104              case PT_DRIVE1:
     105              case PT_DRIVE2:
     106              case PT_DRIVE3:
     107              case PT_FOLDER:
     108              case PT_VALUE:
     109              case PT_FOLDER1:
     110              case PT_WORKGRP:
     111              case PT_COMP:
     112              case PT_NETWORK:
     113              case PT_IESPECIAL1:
     114              case PT_IESPECIAL2:
     115              case PT_SHARE:
     116                break;
     117              default:
     118              {
     119                char szTemp[BYTES_PRINTED*4 + 1];
     120                int i;
     121                unsigned char c;
     122
     123                memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
     124                for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
     125                {
     126                  c = ((unsigned char *)pidltemp)[i];
     127
     128                  szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
     129                  szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
     130                  szTemp[i*3+2] = ' ';
     131                  szTemp[i+BYTES_PRINTED*3]  =  (c>=0x20 && c <=0x80) ? c : '.';
     132                }
     133                szTemp[BYTES_PRINTED*4] = 0x00;
     134                ERR("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
     135                ret = FALSE;
     136              }
     137            }
     138            pidltemp = ILGetNext(pidltemp);
     139          } while (pidltemp->mkid.cb);
     140        }
     141        __SET_DEBUGGING(__DBCL_TRACE, __wine_dbch_pidl, bIsPidlDebug);
     142        return ret;
     143}
     144
     145/*************************************************************************
     146 * ILGetDisplayName                     [SHELL32.15]
    148147 */
    149148BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl,LPSTR path)
    150149{
    151     TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
    152     return SHGetPathFromIDListA(pidl, path);
     150        TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
     151        return SHGetPathFromIDListA(pidl, path);
    153152}
    154153/*************************************************************************
    … …  
    158157 *   observed: pidl=Desktop return=pidl
    159158 */
    160 LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl)
    161 {   LPITEMIDLIST   pidlLast = pidl;
    162 
    163     TRACE("(pidl=%p)\n",pidl);
    164 
    165     while (pidl->mkid.cb)
    166     {
    167       pidlLast = pidl;
    168       pidl = ILGetNext(pidl);
    169     }
    170     return pidlLast;
     159LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl) 
     160{       LPITEMIDLIST   pidlLast = pidl;
     161
     162        TRACE("(pidl=%p)\n",pidl);
     163
     164        while (pidl->mkid.cb)
     165        {
     166          pidlLast = pidl;
     167          pidl = ILGetNext(pidl);
     168        }
     169        return pidlLast;               
    171170}
    172171/*************************************************************************
    … …  
    178177BOOL WINAPI ILRemoveLastID(LPCITEMIDLIST pidl)
    179178{
    180     TRACE_(shell)("pidl=%p\n",pidl);
    181 
    182     if (!pidl || !pidl->mkid.cb)
    183       return 0;
    184     ILFindLastID(pidl)->mkid.cb = 0;
    185     return 1;
     179        TRACE_(shell)("pidl=%p\n",pidl);
     180
     181        if (!pidl || !pidl->mkid.cb)
     182          return 0;
     183        ILFindLastID(pidl)->mkid.cb = 0;
     184        return 1;
    186185}
    187186
    … …  
    198197  if (!pidl)
    199198    return NULL;
    200 
     199   
    201200  len = ILGetSize(pidl);
    202201  newpidl = (LPITEMIDLIST)SHAlloc(len);
    … …  
    216215 */
    217216LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
    218 {   DWORD len;
    219     LPITEMIDLIST pidlNew = NULL;
    220 
    221     TRACE("pidl=%p \n",pidl);
    222     pdump(pidl);
    223 
    224     if (pidl)
    225     {
    226       len = pidl->mkid.cb;
    227       pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
    228       if (pidlNew)
    229       {
    230         memcpy(pidlNew,pidl,len+2);     /* 2 -> mind a desktop pidl */
    231 
    232         if (len)
    233           ILGetNext(pidlNew)->mkid.cb = 0x00;
    234       }
    235     }
    236     TRACE("-- newpidl=%p\n",pidlNew);
    237 
    238     return pidlNew;
     217{       DWORD len;
     218        LPITEMIDLIST pidlNew = NULL;
     219       
     220        TRACE("pidl=%p \n",pidl);
     221        pdump(pidl);
     222       
     223        if (pidl)
     224        {
     225          len = pidl->mkid.cb; 
     226          pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
     227          if (pidlNew)
     228          {
     229            memcpy(pidlNew,pidl,len+2);         /* 2 -> mind a desktop pidl */
     230
     231            if (len)
     232              ILGetNext(pidlNew)->mkid.cb = 0x00;
     233          }
     234        }
     235        TRACE("-- newpidl=%p\n",pidlNew);
     236
     237        return pidlNew;
    239238}
    240239
    … …  
    246245 */
    247246HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
    248 {   WORD        wLen = 0;
    249     DWORD       dwBytesRead;
    250     HRESULT     ret = E_FAIL;
    251 
    252 
    253     TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
    254 
    255     if (*ppPidl)
    256     { SHFree(*ppPidl);
    257       *ppPidl = NULL;
    258     }
    259 
    260     IStream_AddRef (pStream);
    261 
    262     if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
    263     { *ppPidl = SHAlloc (wLen);
    264       if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
    265       { ret = S_OK;
    266       }
    267       else
    268       { SHFree(*ppPidl);
    269         *ppPidl = NULL;
    270       }
    271     }
    272 
    273     /* we are not yet fully compatible */
    274     if (!pcheck(*ppPidl))
    275     { SHFree(*ppPidl);
    276       *ppPidl = NULL;
    277     }
    278 
    279 
    280     IStream_Release (pStream);
    281 
    282     return ret;
     247{       WORD            wLen = 0;
     248        DWORD           dwBytesRead;
     249        HRESULT         ret = E_FAIL;
     250       
     251
     252        TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
     253
     254        if (*ppPidl)
     255        { SHFree(*ppPidl);
     256          *ppPidl = NULL;
     257        }
     258       
     259        IStream_AddRef (pStream);
     260
     261        if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
     262        { *ppPidl = SHAlloc (wLen);
     263          if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
     264          { ret = S_OK;
     265          }
     266          else
     267          { SHFree(*ppPidl);
     268            *ppPidl = NULL;
     269          }
     270        }
     271       
     272        /* we are not yet fully compatible */
     273        if (!pcheck(*ppPidl))
     274        { SHFree(*ppPidl);
     275          *ppPidl = NULL;
     276        }
     277       
     278
     279        IStream_Release (pStream);
     280
     281        return ret;
    283282}
    284283
    … …  
    291290HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
    292291{
    293     LPITEMIDLIST    pidl;
    294     WORD        wLen = 0;
    295     HRESULT     ret = E_FAIL;
    296 
    297     TRACE_(shell)("%p %p\n", pStream, pPidl);
    298 
    299     IStream_AddRef (pStream);
    300 
    301     pidl = pPidl;
     292        LPITEMIDLIST    pidl;
     293        WORD            wLen = 0;
     294        HRESULT         ret = E_FAIL;
     295       
     296        TRACE_(shell)("%p %p\n", pStream, pPidl);
     297
     298        IStream_AddRef (pStream);
     299
     300        pidl = pPidl;
    302301        while (pidl->mkid.cb)
    303302        {
    … …  
    306305        }
    307306
    308     if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
    309     {
    310       if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
    311       { ret = S_OK;
    312       }
    313     }
    314 
    315 
    316     IStream_Release (pStream);
    317 
    318     return ret;
    319 }
    320 
    321 /*************************************************************************
    322  * SHILCreateFromPath   [SHELL32.28]
     307        if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
     308        {
     309          if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
     310          { ret = S_OK;
     311          }
     312        }
     313       
     314
     315        IStream_Release (pStream);
     316
     317        return ret;
     318}
     319
     320/*************************************************************************
     321 * SHILCreateFromPath   [SHELL32.28]
    323322 *
    324323 * NOTES
    … …  
    326325 */
    327326HRESULT WINAPI SHILCreateFromPathA (LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
    328 {   LPSHELLFOLDER sf;
    329     WCHAR lpszDisplayName[MAX_PATH];
    330     DWORD pchEaten;
    331     HRESULT ret = E_FAIL;
    332 
    333     TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes?*attributes:0);
     327{       LPSHELLFOLDER sf;
     328        WCHAR lpszDisplayName[MAX_PATH];
     329        DWORD pchEaten;
     330        HRESULT ret = E_FAIL;
     331       
     332        TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes?*attributes:0);
    334333
    335334        if (!MultiByteToWideChar( CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH ))
    336335            lpszDisplayName[MAX_PATH-1] = 0;
    337336
    338     if (SUCCEEDED (SHGetDesktopFolder(&sf)))
    339     {
    340       ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
    341       IShellFolder_Release(sf);
    342     }
    343     return ret;
     337        if (SUCCEEDED (SHGetDesktopFolder(&sf)))
     338        {
     339          ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
     340          IShellFolder_Release(sf);
     341        }
     342        return ret;
    344343}
    345344HRESULT WINAPI SHILCreateFromPathW (LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
    346 {   LPSHELLFOLDER sf;
    347     DWORD pchEaten;
    348     HRESULT ret = E_FAIL;
    349 
    350     TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes?*attributes:0);
    351 
    352     if (SUCCEEDED (SHGetDesktopFolder(&sf)))
    353     {
    354       ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPWSTR) path, &pchEaten, ppidl, attributes);
    355       IShellFolder_Release(sf);
    356     }
    357     return ret;
     345{       LPSHELLFOLDER sf;
     346        DWORD pchEaten;
     347        HRESULT ret = E_FAIL;
     348       
     349        TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes?*attributes:0);
     350
     351        if (SUCCEEDED (SHGetDesktopFolder(&sf)))
     352        {
     353          ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPWSTR) path, &pchEaten, ppidl, attributes);
     354          IShellFolder_Release(sf);
     355        }
     356        return ret;
    358357}
    359358HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
    360359{
    361     if ( SHELL_OsIsUnicode())
    362       return SHILCreateFromPathW (path, ppidl, attributes);
    363     return SHILCreateFromPathA (path, ppidl, attributes);
     360        if ( SHELL_OsIsUnicode())
     361          return SHILCreateFromPathW (path, ppidl, attributes);
     362        return SHILCreateFromPathA (path, ppidl, attributes);
    364363}
    365364
    366365/*************************************************************************
    367366 * SHCloneSpecialIDList [SHELL32.89]
    368  *
     367 * 
    369368 * PARAMETERS
    370  *  hwndOwner   [in]
    371  *  nFolder     [in]    CSIDL_xxxxx ??
     369 *  hwndOwner   [in]
     370 *  nFolder     [in]    CSIDL_xxxxx ??
    372371 *
    373372 * RETURNS
    … …  
    377376 */
    378377LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner,DWORD nFolder,DWORD x3)
    379 {   LPITEMIDLIST ppidl;
    380     WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
    381                     hwndOwner,nFolder,x3);
    382 
    383     SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
    384 
    385     return ppidl;
     378{       LPITEMIDLIST ppidl;
     379        WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
     380                                        hwndOwner,nFolder,x3);
     381
     382        SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
     383
     384        return ppidl;
    386385}
    387386
    … …  
    391390 */
    392391LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
    393 {   DWORD    len;
    394     LPITEMIDLIST  newpidl;
    395 
    396     if (!pidl)
    397       return NULL;
    398 
    399     len = ILGetSize(pidl);
    400     newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
    401     if (newpidl)
    402       memcpy(newpidl,pidl,len);
    403 
    404     TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
    405     pdump(pidl);
    406 
    407     return newpidl;
     392{       DWORD    len;
     393        LPITEMIDLIST  newpidl;
     394
     395        if (!pidl)
     396          return NULL;
     397   
     398        len = ILGetSize(pidl);
     399        newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
     400        if (newpidl)
     401          memcpy(newpidl,pidl,len);
     402
     403        TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
     404        pdump(pidl);
     405
     406        return newpidl;
    408407}
    409408
    … …  
    414413BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
    415414{
    416     char    szData1[MAX_PATH];
    417     char    szData2[MAX_PATH];
    418 
    419     LPITEMIDLIST pidltemp1 = pidl1;
    420     LPITEMIDLIST pidltemp2 = pidl2;
    421 
    422     TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
    423 
    424     /* explorer reads from registry directly (StreamMRU),
    425        so we can only check here */
    426     if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
    427 
    428     pdump (pidl1);
    429     pdump (pidl2);
    430 
    431     if ( (!pidl1) || (!pidl2) ) return FALSE;
    432 
    433     while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
    434     {
    435         _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
    436         _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
    437 
    438         if (strcasecmp ( szData1, szData2 )!=0 )
    439           return FALSE;
    440 
    441         pidltemp1 = ILGetNext(pidltemp1);
    442         pidltemp2 = ILGetNext(pidltemp2);
    443     }
    444 
    445     if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
    446     {
    447       return TRUE;
    448     }
    449 
    450     return FALSE;
     415        char    szData1[MAX_PATH];
     416        char    szData2[MAX_PATH];
     417
     418        LPITEMIDLIST pidltemp1 = pidl1;
     419        LPITEMIDLIST pidltemp2 = pidl2;
     420
     421        TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
     422
     423        /* explorer reads from registry directly (StreamMRU),
     424           so we can only check here */
     425        if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
     426
     427        pdump (pidl1);
     428        pdump (pidl2);
     429
     430        if ( (!pidl1) || (!pidl2) ) return FALSE;
     431       
     432        while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
     433        {
     434            _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
     435            _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
     436
     437            if (strcasecmp ( szData1, szData2 )!=0 )
     438              return FALSE;
     439
     440            pidltemp1 = ILGetNext(pidltemp1);
     441            pidltemp2 = ILGetNext(pidltemp2);
     442        }       
     443
     444        if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
     445        {
     446          return TRUE;
     447        }
     448
     449        return FALSE;
    451450}
    452451/*************************************************************************
    453452 * ILIsParent [SHELL32.23]
    454453 *
    455  * parent=a/b   child=a/b/c -> true, c is in folder a/b
    456  *      child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
    457  *      child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
     454 * parent=a/b   child=a/b/c -> true, c is in folder a/b
     455 *              child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
     456 *              child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
    458457 */
    459458BOOL WINAPI ILIsParent( LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
    460459{
    461     char    szData1[MAX_PATH];
    462     char    szData2[MAX_PATH];
    463 
    464     LPITEMIDLIST pParent = pidlParent;
    465     LPITEMIDLIST pChild = pidlChild;
    466 
    467     TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
    468 
    469     while (pParent->mkid.cb && pChild->mkid.cb)
    470     {
    471       _ILSimpleGetText(pParent, szData1, MAX_PATH);
    472       _ILSimpleGetText(pChild, szData2, MAX_PATH);
    473 
    474       if (strcasecmp ( szData1, szData2 )!=0 )
    475         return FALSE;
    476 
    477       pParent = ILGetNext(pParent);
    478       pChild = ILGetNext(pChild);
    479     }
    480 
    481     if ( pParent->mkid.cb || ! pChild->mkid.cb) /* child shorter or has equal length to parent */
    482       return FALSE;
    483 
    484     if ( ILGetNext(pChild)->mkid.cb && bImmediate)  /* not immediate descent */
    485       return FALSE;
    486 
    487     return TRUE;
     460        char    szData1[MAX_PATH];
     461        char    szData2[MAX_PATH];
     462
     463        LPITEMIDLIST pParent = pidlParent;
     464        LPITEMIDLIST pChild = pidlChild;
     465       
     466        TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
     467
     468        while (pParent->mkid.cb && pChild->mkid.cb)
     469        {
     470          _ILSimpleGetText(pParent, szData1, MAX_PATH);
     471          _ILSimpleGetText(pChild, szData2, MAX_PATH);
     472
     473          if (strcasecmp ( szData1, szData2 )!=0 )
     474            return FALSE;
     475
     476          pParent = ILGetNext(pParent);
     477          pChild = ILGetNext(pChild);
     478        }       
     479       
     480        if ( pParent->mkid.cb || ! pChild->mkid.cb)     /* child shorter or has equal length to parent */
     481          return FALSE;
     482       
     483        if ( ILGetNext(pChild)->mkid.cb && bImmediate)  /* not immediate descent */
     484          return FALSE;
     485       
     486        return TRUE;
    488487}
    489488
    … …  
    494493 *  Compares elements from pidl1 and pidl2.
    495494 *
    496  *  pidl1 is desktop        pidl2
    497  *  pidl1 shorter pidl2     pointer to first different element of pidl2
    498  *              if there was at least one equal element
    499  *  pidl2 shorter pidl1     0
    500  *  pidl2 equal pidl1       pointer to last 0x00-element of pidl2
     495 *  pidl1 is desktop            pidl2
     496 *  pidl1 shorter pidl2         pointer to first different element of pidl2
     497 *                              if there was at least one equal element
     498 *  pidl2 shorter pidl1         0
     499 *  pidl2 equal pidl1           pointer to last 0x00-element of pidl2
    501500 */
    502501LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
    503502{
    504     char    szData1[MAX_PATH];
    505     char    szData2[MAX_PATH];
    506 
    507     LPITEMIDLIST pidltemp1 = pidl1;
    508     LPITEMIDLIST pidltemp2 = pidl2;
    509     LPITEMIDLIST ret=NULL;
    510 
    511     TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
    512 
    513     /* explorer reads from registry directly (StreamMRU),
    514        so we can only check here */
    515     if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
    516       return FALSE;
    517 
    518     pdump (pidl1);
    519     pdump (pidl2);
    520 
    521     if ( _ILIsDesktop(pidl1) )
    522     {
    523       ret = pidl2;
    524     }
    525     else
    526     {
    527       while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
    528       {
    529         _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
    530         _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
    531 
    532         if (strcasecmp(szData1,szData2))
    533           break;
    534 
    535         pidltemp1 = ILGetNext(pidltemp1);
    536         pidltemp2 = ILGetNext(pidltemp2);
    537         ret = pidltemp2;
    538       }
    539 
    540       if (pidltemp1->mkid.cb)
    541       {
    542         ret = NULL; /* elements of pidl1 left*/
    543       }
    544     }
    545     TRACE_(shell)("--- %p\n", ret);
    546     return ret; /* pidl 1 is shorter */
     503        char    szData1[MAX_PATH];
     504        char    szData2[MAX_PATH];
     505
     506        LPITEMIDLIST pidltemp1 = pidl1;
     507        LPITEMIDLIST pidltemp2 = pidl2;
     508        LPITEMIDLIST ret=NULL;
     509
     510        TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
     511
     512        /* explorer reads from registry directly (StreamMRU),
     513           so we can only check here */
     514        if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
     515          return FALSE;
     516
     517        pdump (pidl1);
     518        pdump (pidl2);
     519
     520        if ( _ILIsDesktop(pidl1) )
     521        {
     522          ret = pidl2;
     523        }
     524        else
     525        {
     526          while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
     527          {
     528            _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
     529            _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
     530
     531            if (strcasecmp(szData1,szData2))
     532              break;
     533
     534            pidltemp1 = ILGetNext(pidltemp1);
     535            pidltemp2 = ILGetNext(pidltemp2);
     536            ret = pidltemp2;   
     537          }
     538
     539          if (pidltemp1->mkid.cb)
     540          {
     541            ret = NULL; /* elements of pidl1 left*/
     542          }
     543        }
     544        TRACE_(shell)("--- %p\n", ret);
     545        return ret; /* pidl 1 is shorter */
    547546}
    548547
    … …  
    557556LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
    558557{
    559     DWORD    len1,len2;
    560     LPITEMIDLIST  pidlNew;
    561 
    562     TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
    563 
    564     if(!pidl1 && !pidl2) return NULL;
    565 
    566     pdump (pidl1);
    567     pdump (pidl2);
    568 
    569     if(!pidl1)
    570     {
    571       pidlNew = ILClone(pidl2);
    572       return pidlNew;
    573     }
    574 
    575     if(!pidl2)
    576     {
    577       pidlNew = ILClone(pidl1);
    578       return pidlNew;
    579     }
    580 
    581     len1  = ILGetSize(pidl1)-2;
    582     len2  = ILGetSize(pidl2);
    583     pidlNew  = SHAlloc(len1+len2);
    584 
    585     if (pidlNew)
    586     {
    587       memcpy(pidlNew,pidl1,len1);
    588       memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
    589     }
    590 
    591     /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
    592     return pidlNew;
     558        DWORD    len1,len2;
     559        LPITEMIDLIST  pidlNew;
     560       
     561        TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
     562
     563        if(!pidl1 && !pidl2) return NULL;
     564
     565        pdump (pidl1);
     566        pdump (pidl2);
     567
     568        if(!pidl1)
     569        {
     570          pidlNew = ILClone(pidl2);
     571          return pidlNew;
     572        }
     573
     574        if(!pidl2)
     575        {
     576          pidlNew = ILClone(pidl1);
     577          return pidlNew;
     578        }
     579
     580        len1  = ILGetSize(pidl1)-2;
     581        len2  = ILGetSize(pidl2);
     582        pidlNew  = SHAlloc(len1+len2);
     583
     584        if (pidlNew)
     585        {
     586          memcpy(pidlNew,pidl1,len1);
     587          memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
     588        }
     589
     590        /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
     591        return pidlNew;
    593592}
    594593/*************************************************************************
    … …  
    599598LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
    600599{
    601     FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
    602 
    603     pdump (pidl);
    604     return 0;
     600        FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
     601
     602        pdump (pidl);
     603        return 0;
    605604}
    606605
    … …  
    609608 *
    610609 * NOTES
    611  *  pild = CSIDL_DESKTOP    ret = 0
    612  *  pild = CSIDL_DRIVES     ret = 0
     610 *  pild = CSIDL_DESKTOP        ret = 0
     611 *  pild = CSIDL_DRIVES         ret = 0
    613612 */
    614613LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
    615614{
    616     FIXME("(pidl=%p)\n",pidl);
    617 
    618     pdump(pidl);
    619 
    620     return 0;
     615        FIXME("(pidl=%p)\n",pidl);
     616
     617        pdump(pidl);
     618
     619        return 0;
    621620}
    622621
    … …  
    636635DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
    637636{
    638     LPSHITEMID si = &(pidl->mkid);
    639     DWORD  len=0;
    640 
    641     if (pidl)
    642     { while (si->cb)
    643       { len += si->cb;
    644         si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
    645       }
    646       len += 2;
    647     }
    648     TRACE("pidl=%p size=%lu\n",pidl, len);
    649     return len;
     637        LPSHITEMID si = &(pidl->mkid);
     638        DWORD  len=0;
     639
     640        if (pidl)
     641        { while (si->cb)
     642          { len += si->cb;
     643            si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
     644          }
     645          len += 2;
     646        }
     647        TRACE("pidl=%p size=%lu\n",pidl, len);
     648        return len;
    650649}
    651650
    … …  
    662661LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
    663662{
    664     WORD len;
    665 
    666     TRACE("(pidl=%p)\n",pidl);
    667 
    668     if(pidl)
    669     {
    670       len =  pidl->mkid.cb;
    671       if (len)
    672       {
    673         pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
    674         return pidl;
    675       }
    676     }
    677     return NULL;
     663        WORD len;
     664       
     665        TRACE("(pidl=%p)\n",pidl);
     666
     667        if(pidl)
     668        {
     669          len =  pidl->mkid.cb;
     670          if (len)
     671          {
     672            pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
     673            return pidl;
     674          }
     675        }
     676        return NULL;
    678677}
    679678/*************************************************************************
    … …  
    688687LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
    689688{
    690     LPITEMIDLIST idlRet;
    691 
    692     WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
    693 
    694     pdump (pidl);
    695     pdump (item);
    696 
    697     if (_ILIsDesktop(pidl))
    698     {
    699        idlRet = ILClone(item);
    700        if (pidl)
    701          SHFree (pidl);
    702        return idlRet;
    703     }
    704 
    705     if (bEnd)
    706     {
    707       idlRet=ILCombine(pidl,item);
    708     }
    709     else
    710     {
    711       idlRet=ILCombine(item,pidl);
    712     }
    713 
    714     SHFree(pidl);
    715     return idlRet;
     689        LPITEMIDLIST idlRet;
     690
     691        WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
     692
     693        pdump (pidl);
     694        pdump (item);
     695       
     696        if (_ILIsDesktop(pidl))
     697        {
     698           idlRet = ILClone(item);
     699           if (pidl)
     700             SHFree (pidl);
     701           return idlRet;
     702        }
     703
     704        if (bEnd)
     705        {
     706          idlRet=ILCombine(pidl,item);
     707        }
     708        else
     709        {
     710          idlRet=ILCombine(item,pidl);
     711        }
     712
     713        SHFree(pidl);
     714        return idlRet;
    716715}
    717716/*************************************************************************
    … …  
    723722 *     exported by ordinal
    724723 */
    725 DWORD WINAPI ILFree(LPITEMIDLIST pidl)
    726 {
    727     TRACE("(pidl=0x%08lx)\n",(DWORD)pidl);
    728 
    729     if(!pidl) return FALSE;
    730     SHFree(pidl);
    731     return TRUE;
     724DWORD WINAPI ILFree(LPITEMIDLIST pidl) 
     725{
     726        TRACE("(pidl=0x%08lx)\n",(DWORD)pidl);
     727
     728        if(!pidl) return FALSE;
     729        SHFree(pidl);
     730        return TRUE;
    732731}
    733732/*************************************************************************
    … …  
    737736void WINAPI ILGlobalFree( LPCITEMIDLIST pidl)
    738737{
    739     TRACE("%p\n",pidl);
    740 
    741     if(!pidl) return;
    742     pCOMCTL32_Free(pidl);
     738        TRACE("%p\n",pidl);
     739
     740        if(!pidl) return;
     741        pCOMCTL32_Free(pidl);
    743742}
    744743/*************************************************************************
    … …  
    746745 *
    747746 */
    748 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
    749 {
    750     LPITEMIDLIST pidlnew;
    751     DWORD attributes = 0;
    752 
    753     TRACE_(shell)("%s\n",path);
    754 
    755     if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, &attributes)))
    756       return pidlnew;
    757     return FALSE;
    758 }
    759 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
    760 {
    761     LPITEMIDLIST pidlnew;
    762     DWORD attributes = 0;
    763 
    764     TRACE_(shell)("%s\n",debugstr_w(path));
    765 
    766     if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, &attributes)))
    767       return pidlnew;
    768     return FALSE;
    769 }
    770 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
    771 {
    772     if ( SHELL_OsIsUnicode())
    773       return ILCreateFromPathW (path);
    774     return ILCreateFromPathA (path);
     747LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path) 
     748{
     749        LPITEMIDLIST pidlnew;
     750        DWORD attributes = 0;
     751
     752        TRACE_(shell)("%s\n",path);
     753
     754        if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, &attributes)))
     755          return pidlnew;
     756        return FALSE;
     757}
     758LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path) 
     759{
     760        LPITEMIDLIST pidlnew;
     761        DWORD attributes = 0;
     762
     763        TRACE_(shell)("%s\n",debugstr_w(path));
     764
     765        if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, &attributes)))
     766          return pidlnew;
     767        return FALSE;
     768}
     769LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path) 
     770{
     771        if ( SHELL_OsIsUnicode())
     772          return ILCreateFromPathW (path);
     773        return ILCreateFromPathA (path);
    775774}
    776775/*************************************************************************
    … …  
    779778LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPCSTR lpszPath)
    780779{
    781     LPITEMIDLIST    pidl=NULL;
    782     HANDLE  hFile;
    783     WIN32_FIND_DATAA    stffile;
    784 
    785     TRACE("path=%s\n", lpszPath);
    786 
    787     if (!lpszPath) return NULL;
    788 
    789     hFile = FindFirstFileA(lpszPath, &stffile);
    790 
    791     if ( hFile != INVALID_HANDLE_VALUE )
    792     {
    793       if (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    794       {
    795         pidl = _ILCreateFolder (&stffile);
    796       }
    797       else
    798       {
    799         pidl = _ILCreateValue (&stffile);
    800       }
    801       FindClose (hFile);
    802     }
    803     return pidl;
     780        LPITEMIDLIST    pidl=NULL;
     781        HANDLE  hFile;
     782        WIN32_FIND_DATAA        stffile;
     783
     784        TRACE("path=%s\n", lpszPath);
     785
     786        if (!lpszPath) return NULL;
     787
     788        hFile = FindFirstFileA(lpszPath, &stffile);
     789
     790        if ( hFile != INVALID_HANDLE_VALUE )
     791        {
     792          if (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
     793          {
     794            pidl = _ILCreateFolder (&stffile);
     795          }
     796          else
     797          {
     798            pidl = _ILCreateValue (&stffile);
     799          }
     800          FindClose (hFile);
     801        }
     802        return pidl;
    804803}
    805804LPITEMIDLIST WINAPI SHSimpleIDListFromPathW (LPCWSTR lpszPath)
    806805{
    807     char    lpszTemp[MAX_PATH];
    808     TRACE("path=%s\n",debugstr_w(lpszPath));
     806        char    lpszTemp[MAX_PATH];
     807        TRACE("path=%s\n",debugstr_w(lpszPath));
    809808
    810809        if (!WideCharToMultiByte( CP_ACP, 0, lpszPath, -1, lpszTemp, sizeof(lpszTemp), NULL, NULL ))
    811810            lpszTemp[sizeof(lpszTemp)-1] = 0;
    812811
    813     return SHSimpleIDListFromPathA (lpszTemp);
     812        return SHSimpleIDListFromPathA (lpszTemp);
    814813}
    815814
    816815LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW (LPCVOID lpszPath)
    817816{
    818     if ( SHELL_OsIsUnicode())
    819       return SHSimpleIDListFromPathW (lpszPath);
    820     return SHSimpleIDListFromPathA (lpszPath);
    821 }
    822 
    823 /*************************************************************************
    824  * SHGetSpecialFolderLocation       [SHELL32.223]
     817        if ( SHELL_OsIsUnicode())
     818          return SHSimpleIDListFromPathW (lpszPath);
     819        return SHSimpleIDListFromPathA (lpszPath);
     820}
     821
     822/*************************************************************************
     823 * SHGetSpecialFolderLocation           [SHELL32.223]
    825824 *
    826825 * gets the folder locations from the registry and creates a pidl
    827826 * creates missing reg keys and directorys
    828  *
     827 * 
    829828 * PARAMS
    830829 *   hwndOwner [I]
    … …  
    834833 */
    835834HRESULT WINAPI SHGetSpecialFolderLocation(
    836     HWND hwndOwner,
    837     INT nFolder,
    838     LPITEMIDLIST * ppidl)
    839 {
    840     CHAR        szPath[MAX_PATH];
    841     HRESULT     hr = E_INVALIDARG;
    842 
    843     TRACE_(shell)("(%04x,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
    844 
    845     if (ppidl)
    846     {
    847       *ppidl = NULL;
    848       switch (nFolder)
    849       {
    850         case CSIDL_DESKTOP:
    851           *ppidl = _ILCreateDesktop();
    852           break;
    853 
    854         case CSIDL_DRIVES:
    855           *ppidl = _ILCreateMyComputer();
    856           break;
    857 
    858         case CSIDL_NETWORK:
    859           *ppidl = _ILCreateNetwork ();
    860           break;
    861 
    862         case CSIDL_CONTROLS:
    863           *ppidl = _ILCreateControl ();
    864           break;
    865 
    866         case CSIDL_PRINTERS:
    867           *ppidl = _ILCreatePrinter ();
    868           break;
    869 
    870         case CSIDL_BITBUCKET:
    871           *ppidl = _ILCreateBitBucket ();
    872           break;
    873 
    874         default:
    875           if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
    876           {
    877         DWORD attributes=0;
    878         TRACE_(shell)("Value=%s\n",szPath);
    879         hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
    880           }
    881       }
    882       if(*ppidl) hr = NOERROR;
    883     }
    884 
    885     TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
    886     return hr;
     835        HWND hwndOwner,
     836        INT nFolder,
     837        LPITEMIDLIST * ppidl)
     838{
     839        CHAR            szPath[MAX_PATH];
     840        HRESULT         hr = E_INVALIDARG;
     841
     842        TRACE_(shell)("(%04x,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
     843
     844        if (ppidl)
     845        {
     846          *ppidl = NULL;
     847          switch (nFolder)
     848          {
     849            case CSIDL_DESKTOP:
     850              *ppidl = _ILCreateDesktop();
     851              break;
     852
     853            case CSIDL_DRIVES:
     854              *ppidl = _ILCreateMyComputer();
     855              break;
     856
     857            case CSIDL_NETWORK:
     858              *ppidl = _ILCreateNetwork ();
     859              break;
     860
     861            case CSIDL_CONTROLS:
     862              *ppidl = _ILCreateControl ();
     863              break;
     864
     865            case CSIDL_PRINTERS:
     866              *ppidl = _ILCreatePrinter ();
     867              break;
     868
     869            case CSIDL_BITBUCKET:
     870              *ppidl = _ILCreateBitBucket ();
     871              break;
     872
     873            default:
     874              if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
     875              {
     876                DWORD attributes=0;
     877                TRACE_(shell)("Value=%s\n",szPath);
     878                hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
     879              }
     880          }
     881          if(*ppidl) hr = NOERROR;
     882        }
     883
     884        TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
     885        return hr;
    887886}
    888887
    … …  
    895894 */
    896895HRESULT WINAPI SHGetFolderLocation(
    897     HWND hwnd,
    898     int csidl,
    899     HANDLE hToken,
    900     DWORD dwFlags,
    901     LPITEMIDLIST *ppidl)
    902 {
    903     FIXME("0x%04x 0x%08x 0x%08x 0x%08lx %p\n",
    904     hwnd, csidl, hToken, dwFlags, ppidl);
    905     return SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
     896        HWND hwnd,
     897        int csidl,
     898        HANDLE hToken,
     899        DWORD dwFlags,
     900        LPITEMIDLIST *ppidl)
     901{
     902        FIXME("0x%04x 0x%08x 0x%08x 0x%08lx %p\n",
     903        hwnd, csidl, hToken, dwFlags, ppidl);
     904        return SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
    906905}
    907906
    … …  
    915914HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
    916915{
    917     TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
    918 
    919     pdump(pidl);
    920     if (!psf || !dest )  return E_INVALIDARG;
    921 
    922     switch (nFormat)
    923     {
    924       case SHGDFIL_FINDDATA:
    925         {
    926            WIN32_FIND_DATAA * pfd = dest;
    927 
    928            if ( len < sizeof (WIN32_FIND_DATAA)) return E_INVALIDARG;
    929 
    930            ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
    931            _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
    932            pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
    933            pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
    934            lstrcpynA(pfd->cFileName,_ILGetTextPointer(pidl), MAX_PATH);
    935            lstrcpynA(pfd->cAlternateFileName,_ILGetSTextPointer(pidl), 14);
    936         }
    937         return NOERROR;
    938 
    939       case SHGDFIL_NETRESOURCE:
    940       case SHGDFIL_DESCRIPTIONID:
    941         FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
    942         break;
    943 
    944       default:
    945         ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
    946     }
    947 
    948     return E_INVALIDARG;
     916        TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
     917       
     918        pdump(pidl);
     919        if (!psf || !dest )  return E_INVALIDARG;
     920
     921        switch (nFormat)
     922        {
     923          case SHGDFIL_FINDDATA:
     924            {
     925               WIN32_FIND_DATAA * pfd = dest;
     926
     927               if ( len < sizeof (WIN32_FIND_DATAA)) return E_INVALIDARG;
     928
     929               ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
     930               _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
     931               pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
     932               pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
     933               lstrcpynA(pfd->cFileName,_ILGetTextPointer(pidl), MAX_PATH);
     934               lstrcpynA(pfd->cAlternateFileName,_ILGetSTextPointer(pidl), 14);
     935            }
     936            return NOERROR;
     937
     938          case SHGDFIL_NETRESOURCE:
     939          case SHGDFIL_DESCRIPTIONID:
     940            FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
     941            break;
     942
     943          default:
     944            ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
     945        }
     946
     947        return E_INVALIDARG;
    949948}
    950949/*************************************************************************
    … …  
    954953HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
    955954{
    956     TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
    957 
    958     pdump(pidl);
    959 
    960     if (! psf || !dest )  return E_INVALIDARG;
    961 
    962     switch (nFormat)
    963     {
    964       case SHGDFIL_FINDDATA:
    965         {
    966            WIN32_FIND_DATAW * pfd = dest;
    967 
    968            if ( len < sizeof (WIN32_FIND_DATAW)) return E_INVALIDARG;
    969 
    970            ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
    971            _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
    972            pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
    973            pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
     955        TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
     956
     957        pdump(pidl);
     958
     959        if (! psf || !dest )  return E_INVALIDARG;
     960
     961        switch (nFormat)
     962        {
     963          case SHGDFIL_FINDDATA:
     964            {
     965               WIN32_FIND_DATAW * pfd = dest;
     966
     967               if ( len < sizeof (WIN32_FIND_DATAW)) return E_INVALIDARG;
     968
     969               ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
     970               _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
     971               pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
     972               pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
    974973               if (!MultiByteToWideChar( CP_ACP, 0, _ILGetTextPointer(pidl), -1,
    975974                                         pfd->cFileName, MAX_PATH ))
    … …  
    978977                                         pfd->cAlternateFileName, 14 ))
    979978                   pfd->cFileName[13] = 0;
    980         }
    981         return NOERROR;
    982       case SHGDFIL_NETRESOURCE:
    983       case SHGDFIL_DESCRIPTIONID:
    984         FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
    985         break;
    986 
    987       default:
    988         ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
    989     }
    990 
    991     return E_INVALIDARG;
    992 }
    993 
    994 /*************************************************************************
    995  * SHGetPathFromIDListA     [SHELL32.261][NT 4.0: SHELL32.220]
     979            }
     980            return NOERROR;
     981          case SHGDFIL_NETRESOURCE:
     982          case SHGDFIL_DESCRIPTIONID:
     983            FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
     984            break;
     985
     986          default:
     987            ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
     988        }
     989
     990        return E_INVALIDARG;
     991}
     992
     993/*************************************************************************
     994 * SHGetPathFromIDListA         [SHELL32.261][NT 4.0: SHELL32.220]
    996995 *
    997996 * PARAMETERS
    998  *  pidl,   [IN] pidl
     997 *  pidl,   [IN] pidl 
    999998 *  pszPath [OUT] path
    1000999 *
    1001  * RETURNS
     1000 * RETURNS 
    10021001 *  path from a passed PIDL.
    10031002 *
    10041003 * NOTES
    1005  *  NULL returns FALSE
    1006  *  desktop pidl gives path to desktopdirectory back
    1007  *  special pidls returning FALSE
     1004 *      NULL returns FALSE
     1005 *      desktop pidl gives path to desktopdirectory back
     1006 *      special pidls returning FALSE
    10081007 *
    10091008 * FIXME
    … …  
    10111010 */
    10121011BOOL WINAPI SHGetPathFromIDListA (LPCITEMIDLIST pidl,LPSTR pszPath)
    1013 {   STRRET str;
    1014     LPSHELLFOLDER shellfolder;
    1015 
    1016     TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
    1017 
    1018     if (!pidl) return FALSE;
    1019 
    1020     pdump(pidl);
    1021 
    1022     if(_ILIsDesktop(pidl))
    1023     {
    1024        SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
    1025     }
    1026     else if (_ILIsSpecialFolder(ILFindLastID(pidl)))
    1027     {
    1028       /* we are somewhere in a special folder */
    1029       return FALSE;
    1030     }
    1031     else
    1032     {
    1033       if (SHGetDesktopFolder(&shellfolder)==S_OK)
    1034       {
    1035         IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
    1036         StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
    1037         IShellFolder_Release(shellfolder);
    1038       }
    1039     }
    1040     TRACE_(shell)("-- (%s)\n",pszPath);
    1041 
    1042     return TRUE;
    1043 }
    1044 /*************************************************************************
    1045  * SHGetPathFromIDListW             [SHELL32.262]
     1012{       STRRET str;
     1013        LPSHELLFOLDER shellfolder;
     1014
     1015        TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
     1016
     1017        if (!pidl) return FALSE;
     1018
     1019        pdump(pidl);
     1020
     1021        if(_ILIsDesktop(pidl))
     1022        {
     1023           SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE); 
     1024        }
     1025        else if (_ILIsSpecialFolder(ILFindLastID(pidl)))
     1026        {
     1027          /* we are somewhere in a special folder */
     1028          return FALSE;
     1029        }
     1030        else
     1031        {
     1032          if (SHGetDesktopFolder(&shellfolder)==S_OK)
     1033          {
     1034            IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
     1035            StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
     1036            IShellFolder_Release(shellfolder);
     1037          }
     1038        }
     1039        TRACE_(shell)("-- (%s)\n",pszPath);
     1040
     1041        return TRUE;
     1042}
     1043/*************************************************************************
     1044 * SHGetPathFromIDListW                         [SHELL32.262]
    10461045 */
    10471046BOOL WINAPI SHGetPathFromIDListW (LPCITEMIDLIST pidl,LPWSTR pszPath)
    1048 {   char sTemp[MAX_PATH];
    1049 
    1050     TRACE_(shell)("(pidl=%p)\n", pidl);
    1051 
    1052     SHGetPathFromIDListA (pidl, sTemp);
     1047{       char sTemp[MAX_PATH];
     1048
     1049        TRACE_(shell)("(pidl=%p)\n", pidl);
     1050
     1051        SHGetPathFromIDListA (pidl, sTemp);
    10531052        MultiByteToWideChar( CP_ACP, 0, sTemp, -1, pszPath, MAX_PATH );
    10541053
    1055     TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
    1056 
    1057     return TRUE;
    1058 }
    1059 
    1060 /*************************************************************************
    1061  *  SHBindToParent      [shell version 5.0]
     1054        TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
     1055
     1056        return TRUE;
     1057}
     1058
     1059/*************************************************************************
     1060 *      SHBindToParent          [shell version 5.0]
    10621061 */
    10631062HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
    10641063{
    1065     IShellFolder    * psf;
    1066     LPITEMIDLIST    pidlChild, pidlParent;
    1067     HRESULT     hr=E_FAIL;
    1068 
    1069     TRACE_(shell)("pidl=%p\n", pidl);
    1070     pdump(pidl);
    1071 
    1072     *ppv = NULL;
    1073     if (ppidlLast) *ppidlLast = NULL;
    1074 
    1075     if (_ILIsPidlSimple(pidl))
    1076     {
    1077       /* we are on desktop level */
    1078       if (ppidlLast)
    1079         *ppidlLast = ILClone(pidl);
    1080       hr = SHGetDesktopFolder((IShellFolder**)ppv);
    1081     }
    1082     else
    1083     {
    1084       pidlChild =  ILClone(ILFindLastID(pidl));
    1085       pidlParent = ILClone(pidl);
    1086       ILRemoveLastID(pidlParent);
    1087 
    1088       hr = SHGetDesktopFolder(&psf);
    1089 
    1090       if (SUCCEEDED(hr))
    1091         hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
    1092 
    1093       if (SUCCEEDED(hr) && ppidlLast)
    1094         *ppidlLast = pidlChild;
    1095       else
    1096         ILFree (pidlChild);
    1097 
    1098       SHFree (pidlParent);
    1099       if (psf) IShellFolder_Release(psf);
    1100     }
    1101 
    1102 
    1103     TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
    1104     return hr;
    1105 }
    1106 
    1107 /*************************************************************************
    1108  * SHGetPathFromIDListAW        [SHELL32.221][NT 4.0: SHELL32.219]
     1064        IShellFolder    * psf;
     1065        LPITEMIDLIST    pidlChild, pidlParent;
     1066        HRESULT         hr=E_FAIL;
     1067       
     1068        TRACE_(shell)("pidl=%p\n", pidl);
     1069        pdump(pidl);
     1070       
     1071        *ppv = NULL;
     1072        if (ppidlLast) *ppidlLast = NULL;
     1073
     1074        if (_ILIsPidlSimple(pidl))
     1075        {
     1076          /* we are on desktop level */
     1077          if (ppidlLast)
     1078            *ppidlLast = ILClone(pidl);
     1079          hr = SHGetDesktopFolder((IShellFolder**)ppv);
     1080        }
     1081        else
     1082        {
     1083          pidlChild =  ILClone(ILFindLastID(pidl));
     1084          pidlParent = ILClone(pidl);
     1085          ILRemoveLastID(pidlParent);
     1086
     1087          hr = SHGetDesktopFolder(&psf);
     1088
     1089          if (SUCCEEDED(hr))
     1090            hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
     1091
     1092          if (SUCCEEDED(hr) && ppidlLast)
     1093            *ppidlLast = pidlChild;
     1094          else
     1095            ILFree (pidlChild);
     1096
     1097          SHFree (pidlParent);
     1098          if (psf) IShellFolder_Release(psf);
     1099        }
     1100
     1101
     1102        TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
     1103        return hr;
     1104}
     1105
     1106/*************************************************************************
     1107 * SHGetPathFromIDListAW                [SHELL32.221][NT 4.0: SHELL32.219]
    11091108 */
    11101109BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath)
    11111110{
    1112     TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
    1113 
    1114     if (SHELL_OsIsUnicode())
    1115       return SHGetPathFromIDListW(pidl,pszPath);
    1116     return SHGetPathFromIDListA(pidl,pszPath);
     1111        TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
     1112
     1113        if (SHELL_OsIsUnicode())
     1114          return SHGetPathFromIDListW(pidl,pszPath);
     1115        return SHGetPathFromIDListA(pidl,pszPath);
    11171116}
    11181117
    11191118/**************************************************************************
    11201119 *
    1121  *      internal functions
    1122  *
    1123  *  ### 1. section creating pidls ###
     1120 *              internal functions
     1121 *
     1122 *      ### 1. section creating pidls ###
    11241123 *
    11251124 *************************************************************************
    … …  
    11281127 *  _ILCreateMyComputer()
    11291128 *  _ILCreateDrive()
    1130  *  _ILCreateFolder()
     1129 *  _ILCreateFolder() 
    11311130 *  _ILCreateValue()
    11321131 */
    11331132LPITEMIDLIST _ILCreateDesktop()
    1134 {   TRACE("()\n");
    1135     return _ILCreate(PT_DESKTOP, NULL, 0);
     1133{       TRACE("()\n");
     1134        return _ILCreate(PT_DESKTOP, NULL, 0);
    11361135}
    11371136
    11381137LPITEMIDLIST _ILCreateMyComputer()
    1139 {   TRACE("()\n");
    1140     return _ILCreate(PT_MYCOMP, &CLSID_MyComputer, sizeof(GUID));
     1138{       TRACE("()\n");
     1139        return _ILCreate(PT_MYCOMP, &CLSID_MyComputer, sizeof(GUID));
    11411140}
    11421141
    11431142LPITEMIDLIST _ILCreateIExplore()
    1144 {   TRACE("()\n");
    1145     return _ILCreate(PT_MYCOMP, &CLSID_Internet, sizeof(GUID));
     1143{       TRACE("()\n");
     1144        return _ILCreate(PT_MYCOMP, &CLSID_Internet, sizeof(GUID));
    11461145}
    11471146
    11481147LPITEMIDLIST _ILCreateControl()
    1149 {   TRACE("()\n");
    1150     return _ILCreate(PT_SPECIAL, &CLSID_ControlPanel, sizeof(GUID));
     1148{       TRACE("()\n");
     1149        return _ILCreate(PT_SPECIAL, &CLSID_ControlPanel, sizeof(GUID));
    11511150}
    11521151
    11531152LPITEMIDLIST _ILCreatePrinter()
    1154 {   TRACE("()\n");
    1155     return _ILCreate(PT_SPECIAL, &CLSID_Printers, sizeof(GUID));
     1153{       TRACE("()\n");
     1154        return _ILCreate(PT_SPECIAL, &CLSID_Printers, sizeof(GUID));
    11561155}
    11571156
    11581157LPITEMIDLIST _ILCreateNetwork()
    1159 {   TRACE("()\n");
    1160     return _ILCreate(PT_MYCOMP, &CLSID_NetworkPlaces, sizeof(GUID));
     1158{       TRACE("()\n");
     1159        return _ILCreate(PT_MYCOMP, &CLSID_NetworkPlaces, sizeof(GUID));
    11611160}
    11621161
    11631162LPITEMIDLIST _ILCreateBitBucket()
    1164 {   TRACE("()\n");
    1165     return _ILCreate(PT_MYCOMP, &CLSID_RecycleBin, sizeof(GUID));
     1163{       TRACE("()\n");
     1164        return _ILCreate(PT_MYCOMP, &CLSID_RecycleBin, sizeof(GUID));
    11661165}
    11671166
    11681167LPITEMIDLIST _ILCreateDrive( LPCSTR lpszNew)
    1169 {   char sTemp[4];
    1170     lstrcpynA (sTemp,lpszNew,4);
    1171     sTemp[2]='\\';
    1172     sTemp[3]=0x00;
    1173     TRACE("(%s)\n",sTemp);
    1174     return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
     1168{       char sTemp[4];
     1169        lstrcpynA (sTemp,lpszNew,4);
     1170        sTemp[2]='\\';
     1171        sTemp[3]=0x00;
     1172        TRACE("(%s)\n",sTemp);
     1173        return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
    11751174}
    11761175
    11771176LPITEMIDLIST _ILCreateFolder( WIN32_FIND_DATAA * stffile )
    11781177{
    1179     char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
    1180     char *  pbuff = buff;
    1181     ULONG   len, len1;
    1182     LPITEMIDLIST pidl;
    1183 
    1184     TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    1185 
    1186     /* prepare buffer with both names */
    1187     len = strlen (stffile->cFileName) + 1;
    1188     memcpy (pbuff, stffile->cFileName, len);
    1189     pbuff += len;
    1190 
    1191     if (stffile->cAlternateFileName)
    1192     {
    1193       len1 = strlen (stffile->cAlternateFileName)+1;
    1194       memcpy (pbuff, stffile->cAlternateFileName, len1);
    1195     }
    1196     else
    1197     {
    1198       len1 = 1;
    1199       *pbuff = 0x00;
    1200     }
    1201 
    1202     pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
    1203 
    1204     /* set attributes */
    1205     if (pidl)
    1206     {
    1207       LPPIDLDATA pData;
    1208       pData = _ILGetDataPointer(pidl);
    1209       FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
    1210       pData->u.folder.dwFileSize = stffile->nFileSizeLow;
    1211       pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
    1212     }
    1213 
    1214     return pidl;
     1178        char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
     1179        char *  pbuff = buff;
     1180        ULONG   len, len1;
     1181        LPITEMIDLIST pidl;
     1182       
     1183        TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
     1184
     1185        /* prepare buffer with both names */
     1186        len = strlen (stffile->cFileName) + 1;
     1187        memcpy (pbuff, stffile->cFileName, len);
     1188        pbuff += len;
     1189
     1190        if (stffile->cAlternateFileName)
     1191        {
     1192          len1 = strlen (stffile->cAlternateFileName)+1;
     1193          memcpy (pbuff, stffile->cAlternateFileName, len1);
     1194        }
     1195        else
     1196        {
     1197          len1 = 1;
     1198          *pbuff = 0x00;
     1199        }
     1200
     1201        pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
     1202       
     1203        /* set attributes */
     1204        if (pidl)
     1205        {
     1206          LPPIDLDATA pData;
     1207          pData = _ILGetDataPointer(pidl);
     1208          FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
     1209          pData->u.folder.dwFileSize = stffile->nFileSizeLow;
     1210          pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
     1211        }
     1212
     1213        return pidl;
    12151214}
    12161215
    12171216LPITEMIDLIST _ILCreateValue(WIN32_FIND_DATAA * stffile)
    12181217{
    1219     char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
    1220     char *  pbuff = buff;
    1221     ULONG   len, len1;
    1222     LPITEMIDLIST pidl;
    1223 
    1224     TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    1225 
    1226     /* prepare buffer with both names */
    1227     len = strlen (stffile->cFileName) + 1;
    1228     memcpy (pbuff, stffile->cFileName, len);
    1229     pbuff += len;
    1230 
    1231     if (stffile->cAlternateFileName)
    1232     {
    1233       len1 = strlen (stffile->cAlternateFileName)+1;
    1234       memcpy (pbuff, stffile->cAlternateFileName, len1);
    1235     }
    1236     else
    1237     {
    1238       len1 = 1;
    1239       *pbuff = 0x00;
    1240     }
    1241 
    1242     pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
    1243 
    1244     /* set attributes */
    1245     if (pidl)
    1246     {
    1247       LPPIDLDATA pData;
    1248       pData = _ILGetDataPointer(pidl);
    1249       FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
    1250       pData->u.folder.dwFileSize = stffile->nFileSizeLow;
    1251       pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
    1252     }
    1253 
    1254     return pidl;
     1218        char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
     1219        char *  pbuff = buff;
     1220        ULONG   len, len1;
     1221        LPITEMIDLIST pidl;
     1222       
     1223        TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
     1224
     1225        /* prepare buffer with both names */
     1226        len = strlen (stffile->cFileName) + 1;
     1227        memcpy (pbuff, stffile->cFileName, len);
     1228        pbuff += len;
     1229
     1230        if (stffile->cAlternateFileName)
     1231        {
     1232          len1 = strlen (stffile->cAlternateFileName)+1;
     1233          memcpy (pbuff, stffile->cAlternateFileName, len1);
     1234        }
     1235        else
     1236        {
     1237          len1 = 1;
     1238          *pbuff = 0x00;
     1239        }
     1240
     1241        pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
     1242       
     1243        /* set attributes */
     1244        if (pidl)
     1245        {
     1246          LPPIDLDATA pData;
     1247          pData = _ILGetDataPointer(pidl);
     1248          FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
     1249          pData->u.folder.dwFileSize = stffile->nFileSizeLow;
     1250          pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
     1251        }
     1252
     1253        return pidl;
    12551254}
    12561255
    … …  
    12761275LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT uInSize)
    12771276{
    1278     LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
    1279     LPPIDLDATA     pData;
    1280     UINT           uSize = 0;
    1281     LPSTR   pszDest;
    1282 
    1283     TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
    1284 
    1285     switch (type)
    1286     {
    1287       case PT_DESKTOP:
    1288         uSize = 0;
    1289         break;
    1290       case PT_SPECIAL:
    1291       case PT_MYCOMP:
    1292         uSize = 2 + 2 + sizeof(GUID);
    1293         break;
    1294       case PT_DRIVE:
    1295         uSize = 2 + 23;
    1296         break;
    1297       case PT_FOLDER:
    1298       case PT_VALUE:
    1299         uSize = 2 + 12 + uInSize;
    1300         break;
    1301       default:
    1302         FIXME("can't create type: 0x%08x\n",type);
    1303         return NULL;
    1304     }
    1305 
    1306     if(!(pidlOut = SHAlloc(uSize + 2))) return NULL;
    1307     ZeroMemory(pidlOut, uSize + 2);
    1308     pidlOut->mkid.cb = uSize;
    1309 
    1310     switch (type)
    1311     {
    1312       case PT_DESKTOP:
    1313         TRACE("- create Desktop\n");
    1314         break;
    1315 
    1316       case PT_SPECIAL:
    1317       case PT_MYCOMP:
    1318         pData =_ILGetDataPointer(pidlOut);
    1319         pData->type = type;
    1320         memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
    1321         TRACE("- create GUID-pidl\n");
    1322         break;
    1323 
    1324       case PT_DRIVE:
    1325         pData =_ILGetDataPointer(pidlOut);
    1326         pData->type = type;
    1327         pszDest = _ILGetTextPointer(pidlOut);
    1328         memcpy(pszDest, pIn, uInSize);
    1329         TRACE("- create Drive: %s\n",debugstr_a(pszDest));
    1330         break;
    1331 
    1332       case PT_FOLDER:
    1333       case PT_VALUE:
    1334         pData =_ILGetDataPointer(pidlOut);
    1335         pData->type = type;
    1336         pszDest =  _ILGetTextPointer(pidlOut);
    1337         memcpy(pszDest, pIn, uInSize);
    1338         TRACE("- create Value: %s\n",debugstr_a(pszDest));
    1339         break;
    1340     }
    1341 
    1342     pidlTemp = ILGetNext(pidlOut);
    1343     if (pidlTemp)
    1344       pidlTemp->mkid.cb = 0x00;
    1345 
    1346     TRACE("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
    1347     return pidlOut;
     1277        LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
     1278        LPPIDLDATA     pData;
     1279        UINT           uSize = 0;
     1280        LPSTR   pszDest;
     1281       
     1282        TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
     1283
     1284        switch (type)
     1285        {
     1286          case PT_DESKTOP:
     1287            uSize = 0;
     1288            break;
     1289          case PT_SPECIAL:
     1290          case PT_MYCOMP:
     1291            uSize = 2 + 2 + sizeof(GUID);
     1292            break;
     1293          case PT_DRIVE:
     1294            uSize = 2 + 23;
     1295            break;
     1296          case PT_FOLDER:
     1297          case PT_VALUE:   
     1298            uSize = 2 + 12 + uInSize;
     1299            break;
     1300          default:
     1301            FIXME("can't create type: 0x%08x\n",type);
     1302            return NULL;
     1303        }
     1304
     1305        if(!(pidlOut = SHAlloc(uSize + 2))) return NULL;
     1306        ZeroMemory(pidlOut, uSize + 2);
     1307        pidlOut->mkid.cb = uSize;
     1308
     1309        switch (type)
     1310        {
     1311          case PT_DESKTOP:
     1312            TRACE("- create Desktop\n");
     1313            break;
     1314
     1315          case PT_SPECIAL:
     1316          case PT_MYCOMP:
     1317            pData =_ILGetDataPointer(pidlOut);
     1318            pData->type = type;
     1319            memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
     1320            TRACE("- create GUID-pidl\n");
     1321            break;
     1322
     1323          case PT_DRIVE:
     1324            pData =_ILGetDataPointer(pidlOut);
     1325            pData->type = type;
     1326            pszDest = _ILGetTextPointer(pidlOut);
     1327            memcpy(pszDest, pIn, uInSize);
     1328            TRACE("- create Drive: %s\n",debugstr_a(pszDest));
     1329            break;
     1330
     1331          case PT_FOLDER:
     1332          case PT_VALUE:   
     1333            pData =_ILGetDataPointer(pidlOut);
     1334            pData->type = type;
     1335            pszDest =  _ILGetTextPointer(pidlOut);
     1336            memcpy(pszDest, pIn, uInSize);
     1337            TRACE("- create Value: %s\n",debugstr_a(pszDest));
     1338            break;
     1339        }
     1340       
     1341        pidlTemp = ILGetNext(pidlOut);
     1342        if (pidlTemp)
     1343          pidlTemp->mkid.cb = 0x00;
     1344
     1345        TRACE("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
     1346        return pidlOut;
    13481347}
    13491348
    … …  
    13571356 */
    13581357DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
    1359 {   TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
    1360 
    1361     if(_ILIsMyComputer(pidl))
    1362       pidl = ILGetNext(pidl);
    1363 
    1364     if (pidl && _ILIsDrive(pidl))
    1365       return _ILSimpleGetText(pidl, pOut, uSize);
    1366 
    1367     return 0;
     1358{       TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
     1359
     1360        if(_ILIsMyComputer(pidl))
     1361          pidl = ILGetNext(pidl);
     1362
     1363        if (pidl && _ILIsDrive(pidl))
     1364          return _ILSimpleGetText(pidl, pOut, uSize);
     1365
     1366        return 0;
    13681367}
    13691368
    13701369/**************************************************************************
    13711370 *
    1372  *  ### 2. section testing pidls ###
     1371 *      ### 2. section testing pidls ###
    13731372 *
    13741373 **************************************************************************
    … …  
    13821381 */
    13831382BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
    1384 {   TRACE("(%p)\n",pidl);
    1385     return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
     1383{       TRACE("(%p)\n",pidl);
     1384        return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
    13861385}
    13871386
    13881387BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
    13891388{
    1390     REFIID iid = _ILGetGUIDPointer(pidl);
    1391 
    1392     TRACE("(%p)\n",pidl);
    1393 
    1394     if (iid)
    1395       return IsEqualIID(iid, &CLSID_MyComputer);
    1396     return FALSE;
     1389        REFIID iid = _ILGetGUIDPointer(pidl);
     1390
     1391        TRACE("(%p)\n",pidl);
     1392
     1393        if (iid)
     1394          return IsEqualIID(iid, &CLSID_MyComputer);
     1395        return FALSE;
    13971396}
    13981397
    13991398BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
    14001399{
    1401     LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1402     TRACE("(%p)\n",pidl);
    1403     return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
    1404               (pidl && pidl->mkid.cb == 0x00)
    1405             ));
     1400        LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1401        TRACE("(%p)\n",pidl);
     1402        return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
     1403                          (pidl && pidl->mkid.cb == 0x00)
     1404                        ));
    14061405}
    14071406
    14081407BOOL _ILIsDrive(LPCITEMIDLIST pidl)
    1409 {   LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1410     TRACE("(%p)\n",pidl);
    1411     return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
    1412                     PT_DRIVE1 == lpPData->type ||
    1413                     PT_DRIVE2 == lpPData->type ||
    1414                     PT_DRIVE3 == lpPData->type));
     1408{       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1409        TRACE("(%p)\n",pidl);
     1410        return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
     1411                                    PT_DRIVE1 == lpPData->type ||
     1412                                    PT_DRIVE2 == lpPData->type ||
     1413                                    PT_DRIVE3 == lpPData->type));
    14151414}
    14161415
    14171416BOOL _ILIsFolder(LPCITEMIDLIST pidl)
    1418 {   LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1419     TRACE("(%p)\n",pidl);
    1420     return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
     1417{       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1418        TRACE("(%p)\n",pidl);
     1419        return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
    14211420}
    14221421
    14231422BOOL _ILIsValue(LPCITEMIDLIST pidl)
    1424 {   LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1425     TRACE("(%p)\n",pidl);
    1426     return (pidl && lpPData && PT_VALUE == lpPData->type);
     1423{       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1424        TRACE("(%p)\n",pidl);
     1425        return (pidl && lpPData && PT_VALUE == lpPData->type);
    14271426}
    14281427
    14291428/**************************************************************************
    1430  *  _ILIsPidlSimple
     1429 *      _ILIsPidlSimple
    14311430 */
    14321431BOOL _ILIsPidlSimple ( LPCITEMIDLIST pidl)
    14331432{
    1434     BOOL ret = TRUE;
    1435 
    1436     if(! _ILIsDesktop(pidl))    /* pidl=NULL or mkid.cb=0 */
    1437     {
    1438       WORD len = pidl->mkid.cb;
    1439       LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
    1440       if (pidlnext->mkid.cb)
    1441         ret = FALSE;
    1442     }
    1443 
    1444     TRACE("%s\n", ret ? "Yes" : "No");
    1445     return ret;
     1433        BOOL ret = TRUE;
     1434
     1435        if(! _ILIsDesktop(pidl))        /* pidl=NULL or mkid.cb=0 */
     1436        {
     1437          WORD len = pidl->mkid.cb;
     1438          LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
     1439          if (pidlnext->mkid.cb)
     1440            ret = FALSE;
     1441        }
     1442
     1443        TRACE("%s\n", ret ? "Yes" : "No");
     1444        return ret;
    14461445}
    14471446
    14481447/**************************************************************************
    14491448 *
    1450  *  ### 3. section getting values from pidls ###
     1449 *      ### 3. section getting values from pidls ###
    14511450 */
    14521451
    … …  
    14601459DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
    14611460{
    1462     DWORD       dwReturn=0;
    1463     LPSTR       szSrc;
    1464     GUID const *    riid;
    1465     char szTemp[MAX_PATH];
    1466 
    1467     TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
    1468 
    1469     if (!pidl) return 0;
    1470 
    1471     if (szOut)
    1472       *szOut = 0;
    1473 
    1474     if (_ILIsDesktop(pidl))
    1475     {
    1476     /* desktop */
    1477       if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
    1478       {
    1479         if (szOut)
    1480           lstrcpynA(szOut, szTemp, uOutSize);
    1481 
    1482         dwReturn = strlen (szTemp);
    1483       }
    1484     }
    1485     else if (( szSrc = _ILGetTextPointer(pidl) ))
    1486     {
    1487       /* filesystem */
    1488       if (szOut)
    1489         lstrcpynA(szOut, szSrc, uOutSize);
    1490 
    1491       dwReturn = strlen(szSrc);
    1492     }
    1493     else if (( riid = _ILGetGUIDPointer(pidl) ))
    1494     {
    1495       /* special folder */
    1496       if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
    1497       {
    1498         if (szOut)
    1499           lstrcpynA(szOut, szTemp, uOutSize);
    1500 
    1501         dwReturn = strlen (szTemp);
    1502       }
    1503     }
    1504     else
    1505     {
    1506       ERR("-- no text\n");
    1507     }
    1508 
    1509     TRACE("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
    1510     return dwReturn;
     1461        DWORD           dwReturn=0;
     1462        LPSTR           szSrc;
     1463        GUID const *    riid;
     1464        char szTemp[MAX_PATH];
     1465       
     1466        TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
     1467       
     1468        if (!pidl) return 0;
     1469
     1470        if (szOut)
     1471          *szOut = 0;
     1472
     1473        if (_ILIsDesktop(pidl))                                 
     1474        {
     1475        /* desktop */
     1476          if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
     1477          {
     1478            if (szOut)
     1479              lstrcpynA(szOut, szTemp, uOutSize);
     1480
     1481            dwReturn = strlen (szTemp);
     1482          }
     1483        }
     1484        else if (( szSrc = _ILGetTextPointer(pidl) ))
     1485        {
     1486          /* filesystem */
     1487          if (szOut)
     1488            lstrcpynA(szOut, szSrc, uOutSize);
     1489
     1490          dwReturn = strlen(szSrc);
     1491        }
     1492        else if (( riid = _ILGetGUIDPointer(pidl) ))
     1493        {
     1494          /* special folder */
     1495          if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
     1496          {
     1497            if (szOut)
     1498              lstrcpynA(szOut, szTemp, uOutSize);
     1499
     1500            dwReturn = strlen (szTemp);
     1501          }
     1502        }
     1503        else
     1504        {
     1505          ERR("-- no text\n");
     1506        }
     1507
     1508        TRACE("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
     1509        return dwReturn;
    15111510}
    15121511
    15131512/**************************************************************************
    15141513 *
    1515  *  ### 4. getting pointers to parts of pidls ###
     1514 *      ### 4. getting pointers to parts of pidls ###
    15161515 *
    15171516 **************************************************************************
    … …  
    15201519LPPIDLDATA _ILGetDataPointer(LPITEMIDLIST pidl)
    15211520{
    1522     if(pidl && pidl->mkid.cb != 0x00)
    1523       return (LPPIDLDATA) &(pidl->mkid.abID);
    1524     return NULL;
     1521        if(pidl && pidl->mkid.cb != 0x00)
     1522          return (LPPIDLDATA) &(pidl->mkid.abID);
     1523        return NULL;
    15251524}
    15261525
    … …  
    15301529 */
    15311530LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
    1532 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
    1533 
    1534     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1535 
    1536     if (pdata)
    1537     {
    1538       switch (pdata->type)
    1539       {
    1540         case PT_MYCOMP:
    1541         case PT_SPECIAL:
    1542           return NULL;
    1543 
    1544         case PT_DRIVE:
    1545         case PT_DRIVE1:
    1546         case PT_DRIVE2:
    1547         case PT_DRIVE3:
    1548           return (LPSTR)&(pdata->u.drive.szDriveName);
    1549 
    1550         case PT_FOLDER:
    1551         case PT_FOLDER1:
    1552         case PT_VALUE:
    1553         case PT_IESPECIAL1:
    1554         case PT_IESPECIAL2:
    1555           return (LPSTR)&(pdata->u.file.szNames);
    1556 
    1557         case PT_WORKGRP:
    1558         case PT_COMP:
    1559         case PT_NETWORK:
    1560         case PT_SHARE:
    1561           return (LPSTR)&(pdata->u.network.szNames);
    1562       }
    1563     }
    1564     return NULL;
     1531{/*     TRACE(pidl,"(pidl%p)\n", pidl);*/
     1532
     1533        LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1534
     1535        if (pdata)
     1536        {
     1537          switch (pdata->type)
     1538          {
     1539            case PT_MYCOMP:
     1540            case PT_SPECIAL:
     1541              return NULL;
     1542
     1543            case PT_DRIVE:
     1544            case PT_DRIVE1:
     1545            case PT_DRIVE2:
     1546            case PT_DRIVE3:
     1547              return (LPSTR)&(pdata->u.drive.szDriveName);
     1548
     1549            case PT_FOLDER:
     1550            case PT_FOLDER1:
     1551            case PT_VALUE:
     1552            case PT_IESPECIAL1:
     1553            case PT_IESPECIAL2:
     1554              return (LPSTR)&(pdata->u.file.szNames);
     1555
     1556            case PT_WORKGRP:
     1557            case PT_COMP:
     1558            case PT_NETWORK:
     1559            case PT_SHARE:
     1560              return (LPSTR)&(pdata->u.network.szNames);
     1561          }
     1562        }
     1563        return NULL;
    15651564}
    15661565
    … …  
    15701569 */
    15711570LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
    1572 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
    1573 
    1574     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1575 
    1576     if (pdata)
    1577     {
    1578       switch (pdata->type)
    1579       {
    1580         case PT_FOLDER:
    1581         case PT_VALUE:
    1582         case PT_IESPECIAL1:
    1583         case PT_IESPECIAL2:
    1584           return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
    1585 
    1586         case PT_WORKGRP:
    1587           return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
    1588       }
    1589     }
    1590     return NULL;
     1571{/*     TRACE(pidl,"(pidl%p)\n", pidl);*/
     1572
     1573        LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1574
     1575        if (pdata)
     1576        {
     1577          switch (pdata->type)
     1578          {
     1579            case PT_FOLDER:
     1580            case PT_VALUE:
     1581            case PT_IESPECIAL1:
     1582            case PT_IESPECIAL2:
     1583              return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
     1584
     1585            case PT_WORKGRP:
     1586              return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
     1587          }
     1588        }
     1589        return NULL;
    15911590}
    15921591
    … …  
    15981597REFIID _ILGetGUIDPointer(LPCITEMIDLIST pidl)
    15991598{
    1600     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1601 
    1602     if (pdata)
    1603     {
    1604       switch (pdata->type)
    1605       {
    1606         case PT_SPECIAL:
    1607         case PT_MYCOMP:
    1608           return (REFIID) &(pdata->u.mycomp.guid);
    1609       }
    1610     }
    1611     return NULL;
     1599        LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1600
     1601        if (pdata)
     1602        {
     1603          switch (pdata->type)
     1604          {
     1605            case PT_SPECIAL:
     1606            case PT_MYCOMP:
     1607              return (REFIID) &(pdata->u.mycomp.guid);
     1608          }
     1609        }
     1610        return NULL;
    16121611}
    16131612
    … …  
    16251624 *
    16261625 * NOTES
    1627  *
     1626 *     
    16281627 */
    16291628BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
    … …  
    16341633
    16351634    switch (pdata->type)
    1636     {
     1635    { 
    16371636        case PT_FOLDER:
    16381637            DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, pFt);
    1639             break;
     1638            break;         
    16401639        case PT_VALUE:
    16411640            DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
    … …  
    16481647
    16491648BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    1650 {
    1651     FILETIME ft,lft;
    1652     SYSTEMTIME time;
    1653 
    1654     if (! _ILGetFileDateTime( pidl, &ft )) return FALSE;
    1655 
    1656     FileTimeToLocalFileTime(&ft, &lft);
    1657     FileTimeToSystemTime (&lft, &time);
    1658     return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
     1649{       
     1650        FILETIME ft,lft;
     1651        SYSTEMTIME time;
     1652
     1653        if (! _ILGetFileDateTime( pidl, &ft )) return FALSE;
     1654       
     1655        FileTimeToLocalFileTime(&ft, &lft);
     1656        FileTimeToSystemTime (&lft, &time);
     1657        return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
    16591658}
    16601659
    … …  
    16661665 * PARAMS
    16671666 *      pidl    [I] The ItemIDList
    1668  *  pOut    [I] The buffer to save the result
     1667 *      pOut    [I] The buffer to save the result
    16691668 *      uOutsize [I] The size of the buffer
    16701669 *
    … …  
    16731672 *
    16741673 * NOTES
    1675  *  pOut can be null when no string is needed
    1676  *
     1674 *      pOut can be null when no string is needed
     1675 *     
    16771676 */
    16781677DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    16791678{
    1680     LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1681     DWORD dwSize;
    1682 
    1683     if(! pdata) return 0;
    1684 
    1685     switch (pdata->type)
    1686     {
    1687       case PT_VALUE:
    1688         dwSize = pdata->u.file.dwFileSize;
    1689         if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
    1690         return dwSize;
    1691     }
    1692     if (pOut) *pOut = 0x00;
    1693     return 0;
     1679        LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1680        DWORD dwSize;
     1681       
     1682        if(! pdata) return 0;
     1683
     1684        switch (pdata->type)
     1685        {
     1686          case PT_VALUE:
     1687            dwSize = pdata->u.file.dwFileSize;
     1688            if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
     1689            return dwSize;
     1690        }
     1691        if (pOut) *pOut = 0x00;
     1692        return 0;
    16941693}
    16951694
    16961695BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    16971696{
    1698     char szTemp[MAX_PATH];
    1699     const char * pPoint;
    1700     LPITEMIDLIST  pidlTemp=pidl;
    1701 
    1702     TRACE("pidl=%p\n",pidl);
    1703 
    1704     if (!pidl) return FALSE;
    1705 
    1706     pidlTemp = ILFindLastID(pidl);
    1707 
    1708     if (!_ILIsValue(pidlTemp)) return FALSE;
    1709     if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
    1710 
    1711     pPoint = PathFindExtensionA(szTemp);
    1712 
    1713     if (! *pPoint) return FALSE;
    1714 
    1715     pPoint++;
    1716     lstrcpynA(pOut, pPoint, uOutSize);
    1717     TRACE("%s\n",pOut);
    1718 
    1719     return TRUE;
     1697        char szTemp[MAX_PATH];
     1698        const char * pPoint;
     1699        LPITEMIDLIST  pidlTemp=pidl;
     1700       
     1701        TRACE("pidl=%p\n",pidl);
     1702
     1703        if (!pidl) return FALSE;
     1704       
     1705        pidlTemp = ILFindLastID(pidl);
     1706       
     1707        if (!_ILIsValue(pidlTemp)) return FALSE;
     1708        if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
     1709
     1710        pPoint = PathFindExtensionA(szTemp);
     1711
     1712        if (! *pPoint) return FALSE;
     1713
     1714        pPoint++;
     1715        lstrcpynA(pOut, pPoint, uOutSize);
     1716        TRACE("%s\n",pOut);
     1717
     1718        return TRUE;
    17201719}
    17211720
    … …  
    17311730 *
    17321731 * RETURNS
    1733  *  nothing
    1734  *
    1735  * NOTES
    1736  *  This function copies as much as possible into the buffer.
     1732 *      nothing
     1733 *
     1734 * NOTES
     1735 *      This function copies as much as possible into the buffer.
    17371736 */
    17381737void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    17391738{
    1740     if(_ILIsValue(pidl))
    1741     {
    1742       char sTemp[64];
     1739        if(_ILIsValue(pidl))
     1740        {
     1741          char sTemp[64];
    17431742          if(uOutSize > 0)
    17441743          {
    17451744            pOut[0] = 0;
    17461745          }
    1747       if (_ILGetExtension (pidl, sTemp, 64))
    1748       {
    1749         if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
    1750             && HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
    1751         {
    1752           lstrcpynA (pOut, sTemp, uOutSize - 6);
    1753           strcat (pOut, "-file");
    1754         }
    1755       }
    1756     }
    1757     else
    1758     {
    1759       lstrcpynA(pOut, "Folder", uOutSize);
    1760     }
     1746          if (_ILGetExtension (pidl, sTemp, 64))
     1747          {
     1748            if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
     1749                && HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
     1750            {
     1751              lstrcpynA (pOut, sTemp, uOutSize - 6);
     1752              strcat (pOut, "-file");
     1753            }
     1754          }
     1755        }
     1756        else
     1757        {
     1758          lstrcpynA(pOut, "Folder", uOutSize);
     1759        }
    17611760}
    17621761
    … …  
    17761775 * FIXME
    17771776 *  return value 0 in case of error is a valid return value
    1778  *
     1777 *     
    17791778 */
    17801779DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    17811780{
    1782     LPPIDLDATA pData =_ILGetDataPointer(pidl);
    1783     WORD wAttrib = 0;
    1784     int i;
    1785 
    1786     if(! pData) return 0;
    1787 
    1788     switch(pData->type)
    1789     {
    1790       case PT_FOLDER:
    1791         wAttrib = pData->u.folder.uFileAttribs;
    1792         break;
    1793       case PT_VALUE:
    1794         wAttrib = pData->u.file.uFileAttribs;
    1795         break;
    1796     }
    1797 
    1798     if(uOutSize >= 6)
    1799     {
    1800       i=0;
    1801       if(wAttrib & FILE_ATTRIBUTE_READONLY)
    1802       {
    1803         pOut[i++] = 'R';
    1804       }
    1805       if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
    1806       {
    1807         pOut[i++] = 'H';
    1808       }
    1809       if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
    1810       {
    1811         pOut[i++] = 'S';
    1812       }
    1813       if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
    1814       {
    1815         pOut[i++] = 'A';
    1816       }
    1817       if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
    1818       {
    1819         pOut[i++] = 'C';
    1820       }
    1821       pOut[i] = 0x00;
    1822     }
    1823     return wAttrib;
     1781        LPPIDLDATA pData =_ILGetDataPointer(pidl);
     1782        WORD wAttrib = 0;
     1783        int i;
     1784
     1785        if(! pData) return 0;
     1786
     1787        switch(pData->type)
     1788        {
     1789          case PT_FOLDER:
     1790            wAttrib = pData->u.folder.uFileAttribs;
     1791            break;
     1792          case PT_VALUE:
     1793            wAttrib = pData->u.file.uFileAttribs;
     1794            break;
     1795        }
     1796       
     1797        if(uOutSize >= 6)
     1798        {
     1799          i=0;
     1800          if(wAttrib & FILE_ATTRIBUTE_READONLY)
     1801          {
     1802            pOut[i++] = 'R';
     1803          }
     1804          if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
     1805          {
     1806            pOut[i++] = 'H';
     1807          }
     1808          if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
     1809          {
     1810            pOut[i++] = 'S';
     1811          }
     1812          if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
     1813          {
     1814            pOut[i++] = 'A';
     1815          }
     1816          if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
     1817          {
     1818            pOut[i++] = 'C';
     1819          }
     1820          pOut[i] = 0x00;
     1821        }
     1822        return wAttrib;
    18241823}
    18251824
    … …  
    18311830void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
    18321831{
    1833     int   i;
    1834 
    1835     if(apidl)
    1836     {
    1837       for(i = 0; i < cidl; i++) SHFree(apidl[i]);
    1838       SHFree(apidl);
    1839     }
     1832        int   i;
     1833
     1834        if(apidl)
     1835        {
     1836          for(i = 0; i < cidl; i++) SHFree(apidl[i]);
     1837          SHFree(apidl);
     1838        }
    18401839}
    18411840
    … …  
    18471846LPITEMIDLIST *  _ILCopyaPidl(LPITEMIDLIST * apidlsrc, UINT cidl)
    18481847{
    1849     int i;
    1850     LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
    1851     if(!apidlsrc) return NULL;
    1852 
    1853     for(i = 0; i < cidl; i++)
    1854       apidldest[i] = ILClone(apidlsrc[i]);
    1855 
    1856     return apidldest;
     1848        int i;
     1849        LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
     1850        if(!apidlsrc) return NULL;
     1851
     1852        for(i = 0; i < cidl; i++)
     1853          apidldest[i] = ILClone(apidlsrc[i]);
     1854
     1855        return apidldest;
    18571856}
    18581857
    … …  
    18641863LPITEMIDLIST * _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPCIDA cida)
    18651864{
    1866     int i;
    1867     LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
    1868 
    1869     if(!dst) return NULL;
    1870 
    1871     if (pidl)
    1872       *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
    1873 
    1874     for(i = 0; i < cida->cidl; i++)
    1875       dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
    1876 
    1877     return dst;
    1878 }
     1865        int i;
     1866        LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
     1867
     1868        if(!dst) return NULL;
     1869
     1870        if (pidl)
     1871          *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
     1872
     1873        for(i = 0; i < cida->cidl; i++)
     1874          dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
     1875
     1876        return dst;
     1877}
Note: See TracChangeset for help on using the changeset viewer.