Changeset 1469 for trunk/src


Ignore:
Timestamp:
Oct 27, 1999, 11:03:31 AM (26 years ago)
Author:
phaller
Message:

Fix: debug info

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/pidl.cpp

    r1215 r1469  
    1 /* $Id: pidl.cpp,v 1.2 1999-10-09 11:17:00 sandervl Exp $ */
     1/* $Id: pidl.cpp,v 1.3 1999-10-27 09:03:31 phaller Exp $ */
     2
    23/*
    3  *      pidl Handling
    4  *
    5  *      Copyright 1998  Juergen Schmied
     4 * Win32 SHELL32 for OS/2
     5 *
     6 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     7 * Project Odin Software License can be found in LICENSE.TXT
     8 *
     9 * pidl Handling
     10 *
     11 * Copyright 1998 Juergen Schmied
    612 *
    713 * NOTES
    … …  
    915 *
    1016 */
     17
     18/*****************************************************************************
     19 * Includes                                                                  *
     20 *****************************************************************************/
     21
     22#include <odin.h>
     23#include <odinwrap.h>
     24#include <os2sel.h>
    1125
    1226#include <ctype.h>
    … …  
    1428#include <string.h>
    1529#include <assert.h>
    16 #include <odin.h>
    1730
    1831#define ICOM_CINTERFACE 1
    … …  
    3346#include <misc.h>
    3447
    35 DECLARE_DEBUG_CHANNEL(pidl)
    36 DECLARE_DEBUG_CHANNEL(shell)
     48
     49ODINDEBUGCHANNEL(SHELL32-PIDL)
    3750
    3851void pdump (LPCITEMIDLIST pidl)
    39 {       DWORD type;
    40         char * szData;
    41         char * szShortName;
    42         char szName[MAX_PATH];
    43         BOOL bIsShellDebug;
    44        
    45         LPITEMIDLIST pidltemp = pidl;
    46         if (!TRACE_ON(pidl))
    47           return;
    48 
    49         /* silence the sub-functions */
    50         bIsShellDebug = TRACE_ON(shell);
    51         __SET_DEBUGGING(__DBCL_TRACE, dbch_shell, FALSE);
    52         __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
    53 
    54         if (! pidltemp)
    55         {
    56           MESSAGE ("-------- pidl=NULL (Desktop)\n");
    57         }
    58         else
    59         {
    60           MESSAGE ("-------- pidl=%p\n", pidl);
    61           if (pidltemp->mkid.cb)
    62           {
    63             do
    64             {
    65               type   = _ILGetDataPointer(pidltemp)->type;
    66               szData = _ILGetTextPointer(type, _ILGetDataPointer(pidltemp));
    67               szShortName = _ILGetSTextPointer(type, _ILGetDataPointer(pidltemp));
    68               _ILSimpleGetText(pidltemp, szName, MAX_PATH);
    69 
    70               MESSAGE ("-- pidl=%p size=%u type=%lx name=%s (%s,%s)\n",
    71                        pidltemp, pidltemp->mkid.cb,type,szName,debugstr_a(szData), debugstr_a(szShortName));
    72 
    73               pidltemp = ILGetNext(pidltemp);
    74 
    75             } while (pidltemp->mkid.cb);
    76           }
    77           else
    78           {
    79             MESSAGE ("empty pidl (Desktop)\n");
    80           }
    81         }
    82 
    83         __SET_DEBUGGING(__DBCL_TRACE, dbch_shell, bIsShellDebug);
    84         __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, TRUE);
     52{  DWORD type;
     53   char * szData;
     54   char * szShortName;
     55   char szName[MAX_PATH];
     56   BOOL bIsShellDebug;
     57
     58   LPITEMIDLIST pidltemp = pidl;
     59   if (!TRACE_ON(pidl))
     60     return;
     61
     62   /* silence the sub-functions */
     63   bIsShellDebug = TRACE_ON(shell);
     64   __SET_DEBUGGING(__DBCL_TRACE, dbch_shell, FALSE);
     65   __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
     66
     67   if (! pidltemp)
     68   {
     69     MESSAGE ("-------- pidl=NULL (Desktop)\n");
     70   }
     71   else
     72   {
     73     MESSAGE ("-------- pidl=%p\n", pidl);
     74     if (pidltemp->mkid.cb)
     75     {
     76       do
     77       {
     78         type   = _ILGetDataPointer(pidltemp)->type;
     79         szData = _ILGetTextPointer(type, _ILGetDataPointer(pidltemp));
     80         szShortName = _ILGetSTextPointer(type, _ILGetDataPointer(pidltemp));
     81         _ILSimpleGetText(pidltemp, szName, MAX_PATH);
     82
     83         MESSAGE ("-- pidl=%p size=%u type=%lx name=%s (%s,%s)\n",
     84                  pidltemp, pidltemp->mkid.cb,type,szName,debugstr_a(szData), debugstr_a(szShortName));
     85
     86         pidltemp = ILGetNext(pidltemp);
     87
     88       } while (pidltemp->mkid.cb);
     89     }
     90     else
     91     {
     92       MESSAGE ("empty pidl (Desktop)\n");
     93     }
     94   }
     95
     96   __SET_DEBUGGING(__DBCL_TRACE, dbch_shell, bIsShellDebug);
     97   __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, TRUE);
    8598
    8699}
    … …  
    88101BOOL pcheck (LPCITEMIDLIST pidl)
    89102{       DWORD type, ret=TRUE;
    90         BOOL bIsPidlDebug;
     103   BOOL bIsPidlDebug;
    91104
    92105        LPITEMIDLIST pidltemp = pidl;
    93106
    94         bIsPidlDebug = TRACE_ON(shell);
    95         __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
     107   bIsPidlDebug = TRACE_ON(shell);
     108   __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
    96109
    97110        if (pidltemp && pidltemp->mkid.cb)
    … …  
    99112          { type   = _ILGetDataPointer(pidltemp)->type;
    100113            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_SHARE:
    115               case PT_IESPECIAL:
    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_(pidl)("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, dbch_pidl, bIsPidlDebug);
    142         return ret;
    143 }
    144 
    145 /*************************************************************************
    146  * ILGetDisplayName                     [SHELL32.15]
    147  */
    148 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl,LPSTR path)
    149 {
    150         TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
    151         return SHGetPathFromIDListA(pidl, path);
    152 }
     114       { case PT_DESKTOP:
     115         case PT_MYCOMP:
     116         case PT_SPECIAL:
     117         case PT_DRIVE:
     118         case PT_DRIVE1:
     119         case PT_DRIVE2:
     120         case PT_DRIVE3:
     121         case PT_FOLDER:
     122         case PT_VALUE:
     123         case PT_FOLDER1:
     124         case PT_WORKGRP:
     125         case PT_COMP:
     126         case PT_NETWORK:
     127         case PT_SHARE:
     128         case PT_IESPECIAL:
     129      break;
     130         default:
     131         {
     132      char szTemp[BYTES_PRINTED*4 + 1];
     133      int i;
     134      unsigned char c;
     135
     136      memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
     137      for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
     138      {
     139        c = ((unsigned char *)pidltemp)[i];
     140
     141        szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
     142        szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
     143        szTemp[i*3+2] = ' ';
     144        szTemp[i+BYTES_PRINTED*3]  =  (c>=0x20 && c <=0x80) ? c : '.';
     145      }
     146      szTemp[BYTES_PRINTED*4] = 0x00;
     147      ERR_(pidl)("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
     148      ret = FALSE;
     149         }
     150       }
     151       pidltemp = ILGetNext(pidltemp);
     152     } while (pidltemp->mkid.cb);
     153   }
     154   __SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, bIsPidlDebug);
     155   return ret;
     156}
     157
     158/*************************************************************************
     159 * ILGetDisplayName                            [SHELL32.15]
     160 */
     161
     162ODINFUNCTION2(BOOL,ILGetDisplayName,LPCITEMIDLIST, pidl,
     163                                    LPSTR,         path)
     164{
     165   TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
     166   return SHGetPathFromIDListA(pidl, path);
     167}
     168
     169
    153170/*************************************************************************
    154171 * ILFindLastID [SHELL32.16]
    … …  
    157174 *   observed: pidl=Desktop return=pidl
    158175 */
    159 LPITEMIDLIST WINAPI ILFindLastID(LPITEMIDLIST pidl)
    160 {       LPITEMIDLIST   pidlLast = pidl;
    161 
    162         TRACE_(pidl)("(pidl=%p)\n",pidl);
    163 
    164         while (pidl->mkid.cb)
    165         {
    166           pidlLast = pidl;
    167           pidl = ILGetNext(pidl);
    168         }
    169         return pidlLast;               
     176
     177ODINFUNCTION1(LPITEMIDLIST,ILFindLastID,LPITEMIDLIST, pidl)
     178{  LPITEMIDLIST   pidlLast = pidl;
     179
     180   while (pidl->mkid.cb)
     181   {
     182     pidlLast = pidl;
     183     pidl = ILGetNext(pidl);
     184   }
     185   return pidlLast;
    170186}
    171187/*************************************************************************
    … …  
    175191 *   when pidl=Desktop return=FALSE
    176192 */
    177 BOOL WINAPI ILRemoveLastID(LPCITEMIDLIST pidl)
    178 {
    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;
     193
     194ODINFUNCTION1(BOOL,ILRemoveLastID,LPCITEMIDLIST, pidl)
     195{
     196   if (!pidl || !pidl->mkid.cb)
     197     return 0;
     198   ILFindLastID(pidl)->mkid.cb = 0;
     199   return 1;
    185200}
    186201
    … …  
    191206 *    dupicate an idlist
    192207 */
    193 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
     208
     209ODINFUNCTION1(LPITEMIDLIST,ILClone,LPCITEMIDLIST,pidl)
    194210{ DWORD    len;
    195211  LPITEMIDLIST  newpidl;
    … …  
    208224  return newpidl;
    209225}
     226
     227
    210228/*************************************************************************
    211229 * ILCloneFirst [SHELL32.19]
    … …  
    214232 *  duplicates the first idlist of a complex pidl
    215233 */
    216 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
    217 {       DWORD len;
    218         LPITEMIDLIST pidlNew = NULL;
    219        
    220         TRACE_(pidl)("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_(pidl)("-- newpidl=%p\n",pidlNew);
    236 
    237         return pidlNew;
     234
     235ODINFUNCTION1(LPITEMIDLIST,ILCloneFirst,LPCITEMIDLIST,pidl)
     236{  DWORD len;
     237   LPITEMIDLIST pidlNew = NULL;
     238
     239   pdump(pidl);
     240
     241   if (pidl)
     242   {
     243     len = pidl->mkid.cb;
     244     pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
     245     if (pidlNew)
     246     {
     247       memcpy(pidlNew,pidl,len+2);          /* 2 -> mind a desktop pidl */
     248
     249       if (len)
     250         ILGetNext(pidlNew)->mkid.cb = 0x00;
     251     }
     252   }
     253   TRACE_(pidl)("-- newpidl=%p\n",pidlNew);
     254
     255   return pidlNew;
    238256}
    239257/*************************************************************************
    … …  
    243261 *   the first two bytes are the len, the pidl is following then
    244262 */
    245 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
    246 {       WORD            wLen = 0;
    247         DWORD           dwBytesRead;
    248         HRESULT         ret = E_FAIL;
    249        
    250 
    251         TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
    252 
    253         if (*ppPidl)
    254         { SHFree(*ppPidl);
    255           *ppPidl = NULL;
    256         }
    257        
    258         IStream_AddRef (pStream);
    259 
    260         if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
    261         { *ppPidl = (ITEMIDLIST*)SHAlloc (wLen);
    262           if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
    263           { ret = S_OK;
    264           }
    265           else
    266           { SHFree(*ppPidl);
    267             *ppPidl = NULL;
    268           }
    269         }
    270        
    271         /* we are not jet fully compatible */
    272         if (!pcheck(*ppPidl))
    273         { SHFree(*ppPidl);
    274           *ppPidl = NULL;
    275         }
    276        
    277 
    278         IStream_Release (pStream);
    279 
    280         return ret;
    281 }
    282 /*************************************************************************
    283  * SHILCreateFromPath   [SHELL32.28]
     263
     264ODINFUNCTION2(HRESULT,ILLoadFromStream,IStream*,      pStream,
     265                                       LPITEMIDLIST*, ppPidl)
     266{  WORD     wLen = 0;
     267   DWORD    dwBytesRead;
     268   HRESULT     ret = E_FAIL;
     269
     270   if (*ppPidl)
     271   { SHFree(*ppPidl);
     272     *ppPidl = NULL;
     273   }
     274
     275   IStream_AddRef (pStream);
     276
     277   if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
     278   { *ppPidl = (ITEMIDLIST*)SHAlloc (wLen);
     279     if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
     280     { ret = S_OK;
     281     }
     282     else
     283     { SHFree(*ppPidl);
     284       *ppPidl = NULL;
     285     }
     286   }
     287
     288   /* we are not jet fully compatible */
     289   if (!pcheck(*ppPidl))
     290   { SHFree(*ppPidl);
     291     *ppPidl = NULL;
     292   }
     293
     294
     295   IStream_Release (pStream);
     296
     297   return ret;
     298}
     299/*************************************************************************
     300 * SHILCreateFromPath                    [SHELL32.28]
    284301 *
    285302 * NOTES
    286303 *   wraper for IShellFolder::ParseDisplayName()
    287304 */
    288 HRESULT WINAPI SHILCreateFromPathA (LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
    289 {       LPSHELLFOLDER sf;
    290         WCHAR lpszDisplayName[MAX_PATH];
    291         DWORD pchEaten;
    292         HRESULT ret = E_FAIL;
    293        
    294         TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes?*attributes:0);
    295 
    296         LocalToWideChar(lpszDisplayName, (LPSTR)path, MAX_PATH);
    297 
    298         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
    299         {
    300           ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
    301           IShellFolder_Release(sf);
    302         }
    303         return ret;
    304 }
    305 HRESULT WINAPI SHILCreateFromPathW (LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
    306 {       LPSHELLFOLDER sf;
    307         DWORD pchEaten;
    308         HRESULT ret = E_FAIL;
    309        
    310         TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes?*attributes:0);
    311 
    312         if (SUCCEEDED (SHGetDesktopFolder(&sf)))
    313         {
    314           ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPOLESTR)path, &pchEaten, ppidl, attributes);
    315           IShellFolder_Release(sf);
    316         }
    317         return ret;
    318 }
    319 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
    320 {
    321         if ( VERSION_OsIsUnicode())
    322           return SHILCreateFromPathW ((LPCWSTR)path, ppidl, attributes);
    323         return SHILCreateFromPathA ((LPCSTR)path, ppidl, attributes);
     305
     306ODINFUNCTION3(HRESULT,SHILCreateFromPathA,LPCSTR,        path,
     307                                          LPITEMIDLIST*, ppidl,
     308                                          DWORD*,        attributes)
     309{  LPSHELLFOLDER sf;
     310   WCHAR lpszDisplayName[MAX_PATH];
     311   DWORD pchEaten;
     312   HRESULT ret = E_FAIL;
     313
     314   LocalToWideChar(lpszDisplayName, (LPSTR)path, MAX_PATH);
     315
     316   if (SUCCEEDED (SHGetDesktopFolder(&sf)))
     317   {
     318     ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
     319     IShellFolder_Release(sf);
     320   }
     321   return ret;
     322}
     323
     324ODINFUNCTION3(HRESULT,SHILCreateFromPathW,LPCWSTR,       path,
     325                                          LPITEMIDLIST*, ppidl,
     326                                          DWORD*,        attributes)
     327{  LPSHELLFOLDER sf;
     328   DWORD pchEaten;
     329   HRESULT ret = E_FAIL;
     330
     331   if (SUCCEEDED (SHGetDesktopFolder(&sf)))
     332   {
     333     ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPOLESTR)path, &pchEaten, ppidl, attributes);
     334     IShellFolder_Release(sf);
     335   }
     336   return ret;
     337}
     338
     339ODINFUNCTION3(HRESULT,SHILCreateFromPathAW,LPCVOID,       path,
     340                                           LPITEMIDLIST*, ppidl,
     341                                           DWORD*,        attributes)
     342{
     343   if ( VERSION_OsIsUnicode())
     344     return SHILCreateFromPathW ((LPCWSTR)path, ppidl, attributes);
     345   return SHILCreateFromPathA ((LPCSTR)path, ppidl, attributes);
    324346}
    325347
    … …  
    328350 *
    329351 * PARAMETERS
    330  *  hwndOwner   [in]
    331  *  nFolder     [in]    CSIDL_xxxxx ??
     352 *  hwndOwner  [in]
     353 *  nFolder    [in]                      CSIDL_xxxxx ??
    332354 *
    333355 * RETURNS
    … …  
    336358 *     exported by ordinal
    337359 */
    338 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner,DWORD nFolder,DWORD x3)
    339 {       LPITEMIDLIST ppidl;
    340         WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
    341                                          hwndOwner,nFolder,x3);
    342 
    343         SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
    344 
    345         return ppidl;
     360
     361ODINFUNCTION3(LPITEMIDLIST,SHCloneSpecialIDList,HWND,  hwndOwner,
     362                                                DWORD, nFolder,
     363                                                DWORD, x3)
     364{  LPITEMIDLIST ppidl;
     365   WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
     366                hwndOwner,nFolder,x3);
     367
     368   SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
     369
     370   return ppidl;
    346371}
    347372
    … …  
    350375 *
    351376 */
    352 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
    353 {       DWORD    len;
    354         LPITEMIDLIST  newpidl;
    355 
    356         if (!pidl)
    357           return NULL;
    358 
    359         len = ILGetSize(pidl);
    360         newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
    361         if (newpidl)
    362           memcpy(newpidl,pidl,len);
    363 
    364         TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
    365         pdump(pidl);
    366 
    367         return newpidl;
     377
     378ODINFUNCTION1(LPITEMIDLIST,ILGlobalClone,LPCITEMIDLIST, pidl)
     379{  DWORD    len;
     380   LPITEMIDLIST  newpidl;
     381
     382   if (!pidl)
     383     return NULL;
     384
     385   len = ILGetSize(pidl);
     386   newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
     387   if (newpidl)
     388     memcpy(newpidl,pidl,len);
     389
     390   TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
     391   pdump(pidl);
     392
     393   return newpidl;
    368394}
    369395
    … …  
    372398 *
    373399 */
    374 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
    375 {
    376         char    szData1[MAX_PATH];
    377         char    szData2[MAX_PATH];
    378 
    379         LPITEMIDLIST pidltemp1 = pidl1;
    380         LPITEMIDLIST pidltemp2 = pidl2;
    381 
    382         TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
    383 
    384         /* explorer reads from registry directly (StreamMRU),
    385            so we can only check here */
    386         if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
    387 
    388         pdump (pidl1);
    389         pdump (pidl2);
    390 
    391         if ( (!pidl1) || (!pidl2) ) return FALSE;
    392        
    393         while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
    394         {
    395             _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
    396             _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
    397 
    398             if (strcmp ( szData1, szData2 )!=0 )
    399               return FALSE;
    400 
    401             pidltemp1 = ILGetNext(pidltemp1);
    402             pidltemp2 = ILGetNext(pidltemp2);
    403         }       
    404 
    405         if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
    406         {
    407           return TRUE;
    408         }
    409 
    410         return FALSE;
     400
     401ODINFUNCTION2(BOOL,ILIsEqual,LPCITEMIDLIST, pidl1,
     402                             LPCITEMIDLIST, pidl2)
     403{
     404   char  szData1[MAX_PATH];
     405   char  szData2[MAX_PATH];
     406
     407   LPITEMIDLIST pidltemp1 = pidl1;
     408   LPITEMIDLIST pidltemp2 = pidl2;
     409
     410   /* explorer reads from registry directly (StreamMRU),
     411      so we can only check here */
     412   if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
     413
     414   pdump (pidl1);
     415   pdump (pidl2);
     416
     417   if ( (!pidl1) || (!pidl2) ) return FALSE;
     418
     419   while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
     420   {
     421       _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
     422       _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
     423
     424       if (strcmp ( szData1, szData2 )!=0 )
     425         return FALSE;
     426
     427       pidltemp1 = ILGetNext(pidltemp1);
     428       pidltemp2 = ILGetNext(pidltemp2);
     429   }
     430
     431   if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
     432   {
     433     return TRUE;
     434   }
     435
     436   return FALSE;
    411437}
    412438/*************************************************************************
    413439 * ILIsParent [SHELL32.23]
    414440 *
    415  * parent=a/b   child=a/b/c -> true, c is in folder a/b
    416  *              child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
    417  *              child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
    418  */
    419 BOOL WINAPI ILIsParent( LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
    420 {
    421         char    szData1[MAX_PATH];
    422         char    szData2[MAX_PATH];
    423 
    424         LPITEMIDLIST pParent = pidlParent;
    425         LPITEMIDLIST pChild = pidlChild;
    426        
    427         TRACE_(pidl)("%p %p %x\n", pidlParent, pidlChild, bImmediate);
    428 
    429         while (pParent->mkid.cb && pChild->mkid.cb)
    430         {
    431           _ILSimpleGetText(pParent, szData1, MAX_PATH);
    432           _ILSimpleGetText(pChild, szData2, MAX_PATH);
    433 
    434           if (strcmp ( szData1, szData2 )!=0 )
    435             return FALSE;
    436 
    437           pParent = ILGetNext(pParent);
    438           pChild = ILGetNext(pChild);
    439         }       
    440        
    441         if ( pParent->mkid.cb || ! pChild->mkid.cb)     /* child shorter or has equal length to parent */
    442           return FALSE;
    443        
    444         if ( ILGetNext(pChild)->mkid.cb && bImmediate)  /* not immediate descent */
    445           return FALSE;
    446        
    447         return TRUE;
     441 * parent=a/b  child=a/b/c -> true, c is in folder a/b
     442 *    child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
     443 *    child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
     444 */
     445
     446ODINFUNCTION3(BOOL,ILIsParent,LPCITEMIDLIST, pidlParent,
     447                              LPCITEMIDLIST, pidlChild,
     448                              BOOL,          bImmediate)
     449{
     450   char  szData1[MAX_PATH];
     451   char  szData2[MAX_PATH];
     452
     453   LPITEMIDLIST pParent = pidlParent;
     454   LPITEMIDLIST pChild = pidlChild;
     455
     456   while (pParent->mkid.cb && pChild->mkid.cb)
     457   {
     458     _ILSimpleGetText(pParent, szData1, MAX_PATH);
     459     _ILSimpleGetText(pChild, szData2, MAX_PATH);
     460
     461     if (strcmp ( szData1, szData2 )!=0 )
     462       return FALSE;
     463
     464     pParent = ILGetNext(pParent);
     465     pChild = ILGetNext(pChild);
     466   }
     467
     468   if ( pParent->mkid.cb || ! pChild->mkid.cb) /* child shorter or has equal length to parent */
     469     return FALSE;
     470
     471   if ( ILGetNext(pChild)->mkid.cb && bImmediate) /* not immediate descent */
     472     return FALSE;
     473
     474   return TRUE;
    448475}
    449476
    … …  
    454481 *  Compares elements from pidl1 and pidl2.
    455482 *
    456  *  pidl1 is desktop            pidl2
    457  *  pidl1 shorter pidl2         pointer to first different element of pidl2
    458  *                              if there was at least one equal element
    459  *  pidl2 shorter pidl1         0
    460  *  pidl2 equal pidl1           pointer to last 0x00-element of pidl2
    461  */
    462 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
    463 {
    464         char    szData1[MAX_PATH];
    465         char    szData2[MAX_PATH];
    466 
    467         LPITEMIDLIST pidltemp1 = pidl1;
    468         LPITEMIDLIST pidltemp2 = pidl2;
    469         LPITEMIDLIST ret=NULL;
    470 
    471         TRACE_(pidl)("pidl1=%p pidl2=%p\n",pidl1, pidl2);
    472 
    473         /* explorer reads from registry directly (StreamMRU),
    474            so we can only check here */
    475         if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
    476           return FALSE;
    477 
    478         pdump (pidl1);
    479         pdump (pidl2);
    480 
    481         if ( _ILIsDesktop(pidl1) )
    482         {
    483           ret = pidl2;
    484         }
    485         else
    486         {
    487           while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
    488           {
    489             _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
    490             _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
    491 
    492             if (strcmp(szData1,szData2))
    493               break;
    494 
    495             pidltemp1 = ILGetNext(pidltemp1);
    496             pidltemp2 = ILGetNext(pidltemp2);
    497             ret = pidltemp2;   
    498           }
    499 
    500           if (pidltemp1->mkid.cb)
    501           {
    502             ret = NULL; /* elements of pidl1 left*/
    503           }
    504         }
    505         TRACE_(shell)("--- %p\n", ret);
    506         return ret; /* pidl 1 is shorter */
     483 *  pidl1 is desktop                        pidl2
     484 *  pidl1 shorter pidl2                     pointer to first different element of pidl2
     485 *          if there was at least one equal element
     486 *  pidl2 shorter pidl1                     0
     487 *  pidl2 equal pidl1                       pointer to last 0x00-element of pidl2
     488 */
     489
     490ODINFUNCTION2(LPITEMIDLIST,ILFindChild,LPCITEMIDLIST, pidl1,
     491                                       LPCITEMIDLIST, pidl2)
     492{
     493   char  szData1[MAX_PATH];
     494   char  szData2[MAX_PATH];
     495
     496   LPITEMIDLIST pidltemp1 = pidl1;
     497   LPITEMIDLIST pidltemp2 = pidl2;
     498   LPITEMIDLIST ret=NULL;
     499
     500   /* explorer reads from registry directly (StreamMRU),
     501      so we can only check here */
     502   if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
     503     return FALSE;
     504
     505   pdump (pidl1);
     506   pdump (pidl2);
     507
     508   if ( _ILIsDesktop(pidl1) )
     509   {
     510     ret = pidl2;
     511   }
     512   else
     513   {
     514     while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
     515     {
     516       _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
     517       _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
     518
     519       if (strcmp(szData1,szData2))
     520         break;
     521
     522       pidltemp1 = ILGetNext(pidltemp1);
     523       pidltemp2 = ILGetNext(pidltemp2);
     524       ret = pidltemp2;
     525     }
     526
     527     if (pidltemp1->mkid.cb)
     528     {
     529       ret = NULL; /* elements of pidl1 left*/
     530     }
     531   }
     532   TRACE_(shell)("--- %p\n", ret);
     533   return ret; /* pidl 1 is shorter */
    507534}
    508535
    … …  
    515542 *  Does not destroy the passed in idlists!
    516543 */
    517 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1,LPCITEMIDLIST pidl2)
    518 {
    519         DWORD    len1,len2;
    520         LPITEMIDLIST  pidlNew;
    521        
    522         TRACE_(pidl)("pidl=%p pidl=%p\n",pidl1,pidl2);
    523 
    524         if(!pidl1 && !pidl2) return NULL;
    525 
    526         pdump (pidl1);
    527         pdump (pidl2);
    528 
    529         if(!pidl1)
    530         {
    531           pidlNew = ILClone(pidl2);
    532           return pidlNew;
    533         }
    534 
    535         if(!pidl2)
    536         {
    537           pidlNew = ILClone(pidl1);
    538           return pidlNew;
    539         }
    540 
    541         len1  = ILGetSize(pidl1)-2;
    542         len2  = ILGetSize(pidl2);
    543         pidlNew  = (ITEMIDLIST*)SHAlloc(len1+len2);
    544 
    545         if (pidlNew)
    546         {
    547           memcpy(pidlNew,pidl1,len1);
    548           memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
    549         }
    550 
    551         /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
    552         return pidlNew;
     544
     545ODINFUNCTION2(LPITEMIDLIST, ILCombine, LPCITEMIDLIST, pidl1,
     546                                       LPCITEMIDLIST, pidl2)
     547{
     548   DWORD    len1,len2;
     549   LPITEMIDLIST  pidlNew;
     550
     551   if(!pidl1 && !pidl2) return NULL;
     552
     553   pdump (pidl1);
     554   pdump (pidl2);
     555
     556   if(!pidl1)
     557   {
     558     pidlNew = ILClone(pidl2);
     559     return pidlNew;
     560   }
     561
     562   if(!pidl2)
     563   {
     564     pidlNew = ILClone(pidl1);
     565     return pidlNew;
     566   }
     567
     568   len1  = ILGetSize(pidl1)-2;
     569   len2  = ILGetSize(pidl2);
     570   pidlNew  = (ITEMIDLIST*)SHAlloc(len1+len2);
     571
     572   if (pidlNew)
     573   {
     574     memcpy(pidlNew,pidl1,len1);
     575     memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
     576   }
     577
     578   /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
     579   return pidlNew;
    553580}
    554581/*************************************************************************
    … …  
    557584 * NOTES
    558585 */
    559 LPITEMIDLIST WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl, DWORD z)
    560 {
    561         FIXME_(pidl)("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
    562 
    563         pdump (pidl);
    564         return 0;
     586
     587ODINFUNCTION3(LPITEMIDLIST, SHGetRealIDL, LPSHELLFOLDER, lpsf,
     588                                          LPITEMIDLIST,  pidl,
     589                                          DWORD,         z)
     590{
     591   FIXME_(pidl)("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
     592
     593   pdump (pidl);
     594   return 0;
    565595}
    566596
    … …  
    569599 *
    570600 * NOTES
    571  *  pild = CSIDL_DESKTOP        ret = 0
    572  *  pild = CSIDL_DRIVES         ret = 0
    573  */
    574 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
    575 {
    576         FIXME_(pidl)("(pidl=%p)\n",pidl);
    577 
    578         pdump(pidl);
    579 
    580         return 0;
     601 *  pild = CSIDL_DESKTOP                 ret = 0
     602 *  pild = CSIDL_DRIVES                     ret = 0
     603 */
     604
     605ODINFUNCTION1(LPITEMIDLIST,SHLogILFromFSIL,LPITEMIDLIST,pidl)
     606{
     607   FIXME_(pidl)("(pidl=%p)\n",pidl);
     608
     609   pdump(pidl);
     610
     611   return 0;
    581612}
    582613
    … …  
    594625 *  exported by ordinal
    595626 */
    596 DWORD WINAPI ILGetSize(LPITEMIDLIST pidl)
    597 {
    598         LPSHITEMID si = &(pidl->mkid);
    599         DWORD  len=0;
    600 
    601         if (pidl)
    602         { while (si->cb)
    603           { len += si->cb;
    604             si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
    605           }
    606           len += 2;
    607         }
    608         TRACE_(pidl)("pidl=%p size=%lu\n",pidl, len);
    609         return len;
     627
     628ODINFUNCTION1(DWORD,ILGetSize,LPITEMIDLIST,pidl)
     629{
     630   LPSHITEMID si = &(pidl->mkid);
     631   DWORD  len=0;
     632
     633   if (pidl)
     634   { while (si->cb)
     635     { len += si->cb;
     636       si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
     637     }
     638     len += 2;
     639   }
     640   TRACE_(pidl)("pidl=%p size=%lu\n",pidl, len);
     641   return len;
    610642}
    611643
    … …  
    620652 *
    621653 */
    622 LPITEMIDLIST WINAPI ILGetNext(LPITEMIDLIST pidl)
    623 {
    624         WORD len;
    625        
    626         TRACE_(pidl)("(pidl=%p)\n",pidl);
    627 
    628         if(pidl)
    629         {
    630           len =  pidl->mkid.cb;
    631           if (len)
    632           {
    633             pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
    634             return pidl;
    635           }
    636         }
    637         return NULL;
     654
     655ODINFUNCTION1(LPITEMIDLIST,ILGetNext,LPITEMIDLIST,pidl)
     656{
     657   WORD len;
     658
     659   if(pidl)
     660   {
     661     len =  pidl->mkid.cb;
     662     if (len)
     663     {
     664       pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
     665       return pidl;
     666     }
     667   }
     668   return NULL;
    638669}
    639670/*************************************************************************
    … …  
    646677 *  Destroys the passed in idlist! (???)
    647678 */
    648 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl,LPCITEMIDLIST item,BOOL bEnd)
    649 {
    650         LPITEMIDLIST idlRet;
    651 
    652         WARN_(pidl)("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
    653 
    654         pdump (pidl);
    655         pdump (item);
    656        
    657         if (_ILIsDesktop(pidl))
    658         {
    659            idlRet = ILClone(item);
    660            if (pidl)
    661              SHFree (pidl);
    662            return idlRet;
    663         }
    664 
    665         if (bEnd)
    666         {
    667           idlRet=ILCombine(pidl,item);
    668         }
    669         else
    670         {
    671           idlRet=ILCombine(item,pidl);
    672         }
    673 
    674         SHFree(pidl);
    675         return idlRet;
     679
     680ODINFUNCTION3(LPITEMIDLIST,ILAppend,LPITEMIDLIST,  pidl,
     681                                    LPCITEMIDLIST, item,
     682                                    BOOL,          bEnd)
     683{
     684   LPITEMIDLIST idlRet;
     685
     686   WARN_(pidl)("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
     687
     688   pdump (pidl);
     689   pdump (item);
     690
     691   if (_ILIsDesktop(pidl))
     692   {
     693      idlRet = ILClone(item);
     694      if (pidl)
     695        SHFree (pidl);
     696      return idlRet;
     697   }
     698
     699   if (bEnd)
     700   {
     701     idlRet=ILCombine(pidl,item);
     702   }
     703   else
     704   {
     705     idlRet=ILCombine(item,pidl);
     706   }
     707
     708   SHFree(pidl);
     709   return idlRet;
    676710}
    677711/*************************************************************************
    … …  
    683717 *     exported by ordinal
    684718 */
    685 DWORD WINAPI ILFree(LPITEMIDLIST pidl)
    686 {       TRACE_(pidl)("(pidl=0x%08lx)\n",(DWORD)pidl);
    687 
    688         if (!pidl)
    689           return FALSE;
    690 
    691         return SHFree(pidl);
     719
     720ODINFUNCTION1(DWORD,ILFree,LPITEMIDLIST, pidl)
     721{  TRACE_(pidl)("(pidl=0x%08lx)\n",(DWORD)pidl);
     722
     723   if (!pidl)
     724     return FALSE;
     725
     726   return SHFree(pidl);
    692727}
    693728/*************************************************************************
    … …  
    695730 *
    696731 */
    697 DWORD WINAPI ILGlobalFree( LPITEMIDLIST pidl)
    698 {
    699         TRACE_(pidl)("%p\n",pidl);
    700 
    701         if (!pidl)
    702           return FALSE;
    703 
    704         return pCOMCTL32_Free (pidl);
     732
     733ODINFUNCTION1(DWORD,ILGlobalFree,LPITEMIDLIST, pidl)
     734{
     735   TRACE_(pidl)("%p\n",pidl);
     736
     737   if (!pidl)
     738     return FALSE;
     739
     740   return pCOMCTL32_Free (pidl);
    705741}
    706742/*************************************************************************
    … …  
    708744 *
    709745 */
    710 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
    711 {
    712         LPITEMIDLIST pidlnew;
    713         DWORD attributes = 0;
    714 
    715         TRACE_(shell)("%s\n",path);
    716 
    717         if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, &attributes)))
    718           return pidlnew;
    719         return FALSE;
    720 }
    721 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
    722 {
    723         LPITEMIDLIST pidlnew;
    724         DWORD attributes = 0;
    725 
    726         TRACE_(shell)("%s\n",debugstr_w(path));
    727 
    728         if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, &attributes)))
    729           return pidlnew;
    730         return FALSE;
    731 }
    732 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
    733 {
    734         if ( VERSION_OsIsUnicode())
    735           return ILCreateFromPathW ((LPCWSTR)path);
    736         return ILCreateFromPathA ((LPCSTR)path);
     746
     747ODINFUNCTION1(LPITEMIDLIST,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}
     758
     759ODINFUNCTION1(LPITEMIDLIST,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
     771ODINFUNCTION1(LPITEMIDLIST,ILCreateFromPathAW,LPCVOID,path)
     772{
     773   if ( VERSION_OsIsUnicode())
     774     return ILCreateFromPathW ((LPCWSTR)path);
     775   return ILCreateFromPathA ((LPCSTR)path);
    737776}
    738777/*************************************************************************
    739778 *  SHSimpleIDListFromPath [SHELL32.162]
    740779 */
    741 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPSTR lpszPath)
    742 {
    743         LPITEMIDLIST    pidl=NULL;
    744         HANDLE  hFile;
    745         WIN32_FIND_DATAA        stffile;
    746 
    747         TRACE_(pidl)("path=%s\n", lpszPath);
    748 
    749         if (!lpszPath) return NULL;
    750 
    751         hFile = FindFirstFileA(lpszPath, &stffile);
    752 
    753         if ( hFile != INVALID_HANDLE_VALUE )
    754         {
    755           if (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    756           {
    757             pidl = _ILCreateFolder (&stffile);
    758           }
    759           else
    760           {
    761             pidl = _ILCreateValue (&stffile);
    762           }
    763           FindClose (hFile);
    764         }
    765         return pidl;
    766 }
    767 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW (LPWSTR lpszPath)
    768 {
    769         char    lpszTemp[MAX_PATH];
    770         TRACE_(pidl)("path=L%s\n",debugstr_w(lpszPath));
    771 
    772         WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
    773 
    774         return SHSimpleIDListFromPathA (lpszTemp);
    775 }
    776 
    777 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW (LPVOID lpszPath)
    778 {
    779         if ( VERSION_OsIsUnicode())
    780           return SHSimpleIDListFromPathW ((LPWSTR)lpszPath);
    781         return SHSimpleIDListFromPathA ((LPSTR)lpszPath);
    782 }
    783 
    784 /*************************************************************************
    785  * SHGetSpecialFolderLocation           [SHELL32.223]
     780
     781ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathA,LPSTR, lpszPath)
     782{
     783   LPITEMIDLIST   pidl=NULL;
     784   HANDLE   hFile;
     785   WIN32_FIND_DATAA                      stffile;
     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;
     804}
     805
     806ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathW,LPWSTR, lpszPath)
     807{
     808   char  lpszTemp[MAX_PATH];
     809
     810   WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
     811
     812   return SHSimpleIDListFromPathA (lpszTemp);
     813}
     814
     815ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathAW,LPVOID, lpszPath)
     816{
     817   if ( VERSION_OsIsUnicode())
     818     return SHSimpleIDListFromPathW ((LPWSTR)lpszPath);
     819   return SHSimpleIDListFromPathA ((LPSTR)lpszPath);
     820}
     821
     822/*************************************************************************
     823 * SHGetSpecialFolderLocation               [SHELL32.223]
    786824 *
    787825 * gets the folder locations from the registry and creates a pidl
    … …  
    794832 *
    795833 */
    796 HRESULT WINAPI SHGetSpecialFolderLocation(
    797         HWND hwndOwner,
    798         INT nFolder,
    799         LPITEMIDLIST * ppidl)
    800 {
    801         CHAR            szPath[256];
    802         HRESULT         hr = E_INVALIDARG;
    803 
    804         TRACE_(shell)("(%04x,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
    805 
    806         *ppidl = NULL;
    807 
    808         if (ppidl)
    809         {
    810           switch (nFolder)
    811           {
    812             case CSIDL_DESKTOP:
    813               *ppidl = _ILCreateDesktop();
    814               hr = NOERROR;
    815               break;
    816 
    817             case CSIDL_DRIVES:
    818               *ppidl = _ILCreateMyComputer();
    819               hr = NOERROR;
    820               break;
    821 
    822             default:
    823               if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
    824               {
    825                 DWORD attributes=0;
    826                 TRACE_(shell)("Value=%s\n",szPath);
    827                 hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
    828               }
    829           }
    830         }
    831 
    832         TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
    833         return hr;
     834ODINFUNCTION3(HRESULT,SHGetSpecialFolderLocation,HWND,          hwndOwner,
     835                                                 INT,           nFolder,
     836                                                 LPITEMIDLIST*, ppidl)
     837{
     838   CHAR     szPath[256];
     839   HRESULT     hr = E_INVALIDARG;
     840
     841   *ppidl = NULL;
     842
     843   if (ppidl)
     844   {
     845     switch (nFolder)
     846     {
     847       case CSIDL_DESKTOP:
     848         *ppidl = _ILCreateDesktop();
     849         hr = NOERROR;
     850         break;
     851
     852       case CSIDL_DRIVES:
     853         *ppidl = _ILCreateMyComputer();
     854         hr = NOERROR;
     855         break;
     856
     857       default:
     858         if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
     859         {
     860      DWORD attributes=0;
     861      TRACE_(shell)("Value=%s\n",szPath);
     862      hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
     863         }
     864     }
     865   }
     866
     867   TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
     868   return hr;
    834869}
    835870
    … …  
    838873 *
    839874 */
    840 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
    841 {
    842         TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
    843        
    844         if (! psf || !dest )  return E_INVALIDARG;
    845 
    846         switch (nFormat)
    847         {
    848           case SHGDFIL_FINDDATA:
    849             {
    850                WIN32_FIND_DATAA * pfd = (WIN32_FIND_DATAA*)dest;
    851                CHAR     pszPath[MAX_PATH];
    852                HANDLE   handle;
    853 
    854                if ( len < sizeof (WIN32_FIND_DATAA)) {
    855                  ERR_(shell)("%d does not find sizeof(finddata)\n",len);
    856                  return E_INVALIDARG;
    857                }
    858 
    859                SHGetPathFromIDListA(pidl, pszPath);
    860 
    861                if ((handle  = FindFirstFileA ( pszPath, pfd)))
    862                  FindClose (handle);
    863             }
    864             return NOERROR;
    865 
    866           case SHGDFIL_NETRESOURCE:
    867           case SHGDFIL_DESCRIPTIONID:
    868             FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
    869             break;
    870 
    871           default:
    872             ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
    873         }
    874 
    875         return E_INVALIDARG;
     875
     876ODINFUNCTION5(HRESULT,SHGetDataFromIDListA,LPSHELLFOLDER, psf,
     877                                           LPCITEMIDLIST, pidl,
     878                                           int,           nFormat,
     879                                           LPVOID,        dest,
     880                                           int,           len)
     881{
     882   TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
     883
     884   if (! psf || !dest )  return E_INVALIDARG;
     885
     886   switch (nFormat)
     887   {
     888     case SHGDFIL_FINDDATA:
     889       {
     890          WIN32_FIND_DATAA * pfd = (WIN32_FIND_DATAA*)dest;
     891          CHAR pszPath[MAX_PATH];
     892          HANDLE  handle;
     893
     894          if ( len < sizeof (WIN32_FIND_DATAA)) {
     895       ERR_(shell)("%d does not find sizeof(finddata)\n",len);
     896            return E_INVALIDARG;
     897          }
     898
     899          SHGetPathFromIDListA(pidl, pszPath);
     900
     901          if ((handle  = FindFirstFileA ( pszPath, pfd)))
     902            FindClose (handle);
     903       }
     904       return NOERROR;
     905
     906     case SHGDFIL_NETRESOURCE:
     907     case SHGDFIL_DESCRIPTIONID:
     908       FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
     909       break;
     910
     911     default:
     912       ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
     913   }
     914
     915   return E_INVALIDARG;
    876916}
    877917/*************************************************************************
    … …  
    879919 *
    880920 */
    881 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
    882 {
    883         if (! psf || !dest )  return E_INVALIDARG;
    884 
    885         switch (nFormat)
    886         {
    887           case SHGDFIL_FINDDATA:
    888             {
    889                WIN32_FIND_DATAW * pfd = (WIN32_FIND_DATAW*)dest;
    890                WCHAR    pszPath[MAX_PATH];
    891                HANDLE   handle;
    892 
    893                if ( len < sizeof (WIN32_FIND_DATAW)) {
    894                  ERR_(shell)("%d does not find sizeof(finddata)\n",len);
    895                  return E_INVALIDARG;
    896                }
    897                SHGetPathFromIDListW(pidl, pszPath);
    898                if ((handle  = FindFirstFileW ( pszPath, pfd)))
    899                  FindClose (handle);
    900             }
    901             return NOERROR;
    902           default: /* fallthrough */
    903             break;
    904         }
    905         FIXME_(shell)("(sf=%p pidl=%p nFormat=0x%04x %p 0x%04x), unhandled.\n",psf,pidl,nFormat,dest,len);
    906         return SHGetDataFromIDListA( psf, pidl, nFormat, dest, len);
    907 }
    908 
    909 /*************************************************************************
    910  * SHGetPathFromIDListA         [SHELL32.261][NT 4.0: SHELL32.220]
     921
     922ODINFUNCTION5(HRESULT,SHGetDataFromIDListW,LPSHELLFOLDER, psf,
     923                                           LPCITEMIDLIST, pidl,
     924                                           int,           nFormat,
     925                                           LPVOID,        dest,
     926                                           int,           len)
     927{
     928   if (! psf || !dest )  return E_INVALIDARG;
     929
     930   switch (nFormat)
     931   {
     932     case SHGDFIL_FINDDATA:
     933       {
     934          WIN32_FIND_DATAW * pfd = (WIN32_FIND_DATAW*)dest;
     935          WCHAR   pszPath[MAX_PATH];
     936          HANDLE  handle;
     937
     938          if ( len < sizeof (WIN32_FIND_DATAW)) {
     939       ERR_(shell)("%d does not find sizeof(finddata)\n",len);
     940            return E_INVALIDARG;
     941          }
     942          SHGetPathFromIDListW(pidl, pszPath);
     943          if ((handle  = FindFirstFileW ( pszPath, pfd)))
     944            FindClose (handle);
     945       }
     946       return NOERROR;
     947     default: /* fallthrough */
     948       break;
     949   }
     950   FIXME_(shell)("(sf=%p pidl=%p nFormat=0x%04x %p 0x%04x), unhandled.\n",psf,pidl,nFormat,dest,len);
     951   return SHGetDataFromIDListA( psf, pidl, nFormat, dest, len);
     952}
     953
     954/*************************************************************************
     955 * SHGetPathFromIDListA                     [SHELL32.261][NT 4.0: SHELL32.220]
    911956 *
    912957 * PARAMETERS
    … …  
    918963 *
    919964 * NOTES
    920  *      NULL returns FALSE
    921  *      desktop pidl gives path to desktopdirectory back
    922  *      special pidls returning FALSE
     965 * NULL returns FALSE
     966 * desktop pidl gives path to desktopdirectory back
     967 * special pidls returning FALSE
    923968 *
    924969 * FIXME
    925970 *  fnGetDisplayNameOf can return different types of OLEString
    926971 */
    927 BOOL WINAPI SHGetPathFromIDListA (LPCITEMIDLIST pidl,LPSTR pszPath)
    928 {       STRRET str;
    929         LPSHELLFOLDER shellfolder;
    930 
    931         TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
    932 
    933         if (!pidl) return FALSE;
    934 
    935         pdump(pidl);
    936 
    937         if(_ILIsDesktop(pidl))
    938         {
    939            SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE); 
    940         }
    941         else
    942         {
    943           if (SHGetDesktopFolder(&shellfolder)==S_OK)
    944           {
    945             IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
    946             StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
    947             IShellFolder_Release(shellfolder);
    948           }
    949         }
    950         TRACE_(shell)("-- (%s)\n",pszPath);
    951 
    952         return TRUE;
    953 }
    954 /*************************************************************************
    955  * SHGetPathFromIDListW                         [SHELL32.262]
    956  */
    957 BOOL WINAPI SHGetPathFromIDListW (LPCITEMIDLIST pidl,LPWSTR pszPath)
    958 {       char sTemp[MAX_PATH];
    959 
    960         TRACE_(shell)("(pidl=%p)\n", pidl);
    961 
    962         SHGetPathFromIDListA (pidl, sTemp);
    963         lstrcpyAtoW(pszPath, sTemp);
    964 
    965         TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
    966 
    967         return TRUE;
    968 }
    969 
    970 /*************************************************************************
    971  *      SHBindToParent          [shell version 5.0]
    972  */
    973 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
    974 {
    975         IShellFolder    * psf;
    976         LPITEMIDLIST    pidlChild, pidlParent;
    977         HRESULT         hr=E_FAIL;
    978        
    979         TRACE_(shell)("pidl=%p\n", pidl);
    980         pdump(pidl);
    981        
    982         *ppv = NULL;
    983         if (ppidlLast) *ppidlLast = NULL;
    984 
    985         if (_ILIsPidlSimple(pidl))
    986         {
    987           /* we are on desktop level */
    988           if (ppidlLast)
    989             *ppidlLast = ILClone(pidl);
    990           hr = SHGetDesktopFolder((IShellFolder**)ppv);
    991         }
    992         else
    993         {
    994           pidlChild =  ILClone(ILFindLastID(pidl));
    995           pidlParent = ILClone(pidl);
    996           ILRemoveLastID(pidlParent);
    997 
    998           hr = SHGetDesktopFolder(&psf);
    999 
    1000           if (SUCCEEDED(hr))
    1001             hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
    1002 
    1003           if (SUCCEEDED(hr) && ppidlLast)
    1004             *ppidlLast = pidlChild;
    1005           else
    1006             ILFree (pidlChild);
    1007 
    1008           SHFree (pidlParent);
    1009         }
    1010 
    1011 
    1012         TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
    1013         return hr;
    1014 }
    1015 
    1016 /*************************************************************************
    1017  * SHGetPathFromIDListAW                [SHELL32.221][NT 4.0: SHELL32.219]
    1018  */
    1019 BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath)
    1020 {
    1021         TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
    1022 
    1023         if (VERSION_OsIsUnicode())
    1024           return SHGetPathFromIDListW(pidl,(LPWSTR)pszPath);
    1025         return SHGetPathFromIDListA(pidl,(LPSTR)pszPath);
     972
     973ODINFUNCTION2(BOOL,SHGetPathFromIDListA,LPCITEMIDLIST, pidl,
     974                                        LPSTR,         pszPath)
     975{  STRRET str;
     976   LPSHELLFOLDER shellfolder;
     977
     978   if (!pidl) return FALSE;
     979
     980   pdump(pidl);
     981
     982   if(_ILIsDesktop(pidl))
     983   {
     984      SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
     985   }
     986   else
     987   {
     988     if (SHGetDesktopFolder(&shellfolder)==S_OK)
     989     {
     990       IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
     991       StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
     992       IShellFolder_Release(shellfolder);
     993     }
     994   }
     995   TRACE_(shell)("-- (%s)\n",pszPath);
     996
     997   return TRUE;
     998}
     999/*************************************************************************
     1000 * SHGetPathFromIDListW                        [SHELL32.262]
     1001 */
     1002
     1003ODINFUNCTION2(BOOL,SHGetPathFromIDListW,LPCITEMIDLIST, pidl,
     1004                                        LPWSTR,        pszPath)
     1005{  char sTemp[MAX_PATH];
     1006
     1007   SHGetPathFromIDListA (pidl, sTemp);
     1008   lstrcpyAtoW(pszPath, sTemp);
     1009
     1010   TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
     1011
     1012   return TRUE;
     1013}
     1014
     1015/*************************************************************************
     1016 * SHBindToParent                        [shell version 5.0]
     1017 */
     1018
     1019ODINFUNCTION4(HRESULT,SHBindToParent,LPCITEMIDLIST, pidl,
     1020                                     REFIID,        riid,
     1021                                     LPVOID*,       ppv,
     1022                                     LPCITEMIDLIST*,ppidlLast)
     1023{
     1024   IShellFolder   * psf;
     1025   LPITEMIDLIST   pidlChild, pidlParent;
     1026   HRESULT     hr=E_FAIL;
     1027
     1028   pdump(pidl);
     1029
     1030   *ppv = NULL;
     1031   if (ppidlLast) *ppidlLast = NULL;
     1032
     1033   if (_ILIsPidlSimple(pidl))
     1034   {
     1035     /* we are on desktop level */
     1036     if (ppidlLast)
     1037       *ppidlLast = ILClone(pidl);
     1038     hr = SHGetDesktopFolder((IShellFolder**)ppv);
     1039   }
     1040   else
     1041   {
     1042     pidlChild =  ILClone(ILFindLastID(pidl));
     1043     pidlParent = ILClone(pidl);
     1044     ILRemoveLastID(pidlParent);
     1045
     1046     hr = SHGetDesktopFolder(&psf);
     1047
     1048     if (SUCCEEDED(hr))
     1049       hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
     1050
     1051     if (SUCCEEDED(hr) && ppidlLast)
     1052       *ppidlLast = pidlChild;
     1053     else
     1054       ILFree (pidlChild);
     1055
     1056     SHFree (pidlParent);
     1057   }
     1058
     1059
     1060   TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
     1061   return hr;
     1062}
     1063
     1064/*************************************************************************
     1065 * SHGetPathFromIDListAW                    [SHELL32.221][NT 4.0: SHELL32.219]
     1066 */
     1067
     1068ODINFUNCTION2(BOOL,SHGetPathFromIDListAW,LPCITEMIDLIST, pidl,
     1069                                         LPVOID,        pszPath)
     1070{
     1071   if (VERSION_OsIsUnicode())
     1072     return SHGetPathFromIDListW(pidl,(LPWSTR)pszPath);
     1073   return SHGetPathFromIDListA(pidl,(LPSTR)pszPath);
    10261074}
    10271075
    10281076/**************************************************************************
    10291077 *
    1030  *              internal functions
    1031  *
    1032  *      ### 1. section creating pidls ###
     1078 *    internal functions
     1079 *
     1080 * ### 1. section creating pidls ###
    10331081 *
    10341082 *************************************************************************
    … …  
    10401088 *  _ILCreateValue()
    10411089 */
    1042 LPITEMIDLIST WINAPI _ILCreateDesktop()
    1043 {       TRACE_(pidl)("()\n");
    1044         return _ILCreate(PT_DESKTOP, NULL, 0);
    1045 }
    1046 
    1047 LPITEMIDLIST WINAPI _ILCreateMyComputer()
    1048 {       TRACE_(pidl)("()\n");
    1049         return _ILCreate(PT_MYCOMP, &IID_MyComputer, sizeof(GUID));
    1050 }
    1051 
    1052 LPITEMIDLIST WINAPI _ILCreateIExplore()
    1053 {       TRACE_(pidl)("()\n");
    1054         return _ILCreate(PT_MYCOMP, &IID_IExplore, sizeof(GUID));
    1055 }
    1056 
    1057 LPITEMIDLIST WINAPI _ILCreateDrive( LPCSTR lpszNew)
    1058 {       char sTemp[4];
    1059         lstrcpynA (sTemp,lpszNew,4);
    1060         sTemp[2]='\\';
    1061         sTemp[3]=0x00;
    1062         TRACE_(pidl)("(%s)\n",sTemp);
    1063         return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
    1064 }
    1065 
    1066 LPITEMIDLIST WINAPI _ILCreateFolder( WIN32_FIND_DATAA * stffile )
    1067 {
    1068         char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
    1069         char *  pbuff = buff;
    1070         ULONG   len, len1;
    1071         LPITEMIDLIST pidl;
    1072        
    1073         TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    1074 
    1075         /* prepare buffer with both names */
    1076         len = strlen (stffile->cFileName) + 1;
    1077         memcpy (pbuff, stffile->cFileName, len);
    1078         pbuff += len;
    1079 
    1080         if (stffile->cAlternateFileName)
    1081         {
    1082           len1 = strlen (stffile->cAlternateFileName)+1;
    1083           memcpy (pbuff, stffile->cAlternateFileName, len1);
    1084         }
    1085         else
    1086         {
    1087           len1 = 1;
    1088           *pbuff = 0x00;
    1089         }
    1090 
    1091         pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
    1092        
    1093         /* set attributes */
    1094         if (pidl)
    1095         {
    1096           LPPIDLDATA pData;
    1097           pData = _ILGetDataPointer(pidl);
    1098           FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
    1099           pData->u.folder.dwFileSize = stffile->nFileSizeLow;
    1100           pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
    1101         }
    1102 
    1103         return pidl;
    1104 }
    1105 
    1106 LPITEMIDLIST WINAPI _ILCreateValue(WIN32_FIND_DATAA * stffile)
    1107 {
    1108         char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
    1109         char *  pbuff = buff;
    1110         ULONG   len, len1;
    1111         LPITEMIDLIST pidl;
    1112        
    1113         TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    1114 
    1115         /* prepare buffer with both names */
    1116         len = strlen (stffile->cFileName) + 1;
    1117         memcpy (pbuff, stffile->cFileName, len);
    1118         pbuff += len;
    1119 
    1120         if (stffile->cAlternateFileName)
    1121         {
    1122           len1 = strlen (stffile->cAlternateFileName)+1;
    1123           memcpy (pbuff, stffile->cAlternateFileName, len1);
    1124         }
    1125         else
    1126         {
    1127           len1 = 1;
    1128           *pbuff = 0x00;
    1129         }
    1130 
    1131         pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
    1132        
    1133         /* set attributes */
    1134         if (pidl)
    1135         {
    1136           LPPIDLDATA pData;
    1137           pData = _ILGetDataPointer(pidl);
    1138           FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
    1139           pData->u.folder.dwFileSize = stffile->nFileSizeLow;
    1140           pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
    1141         }
    1142 
    1143         return pidl;
    1144 }
    1145 
    1146 LPITEMIDLIST WINAPI _ILCreateSpecial(LPCSTR szGUID)
    1147 {
    1148         IID     iid;
    1149         CLSIDFromStringA(szGUID,&iid);
    1150         return _ILCreate(PT_MYCOMP, &iid, sizeof(IID));
     1090
     1091ODINFUNCTION0(LPITEMIDLIST,_ILCreateDesktop)
     1092{
     1093  return _ILCreate(PT_DESKTOP, NULL, 0);
     1094}
     1095
     1096ODINFUNCTION0(LPITEMIDLIST,_ILCreateMyComputer)
     1097{
     1098  return _ILCreate(PT_MYCOMP, &IID_MyComputer, sizeof(GUID));
     1099}
     1100
     1101ODINFUNCTION0(LPITEMIDLIST,_ILCreateIExplore)
     1102{
     1103   return _ILCreate(PT_MYCOMP, &IID_IExplore, sizeof(GUID));
     1104}
     1105
     1106ODINFUNCTION1(LPITEMIDLIST,_ILCreateDrive,LPCSTR,lpszNew)
     1107{  char sTemp[4];
     1108   lstrcpynA (sTemp,lpszNew,4);
     1109   sTemp[2]='\\';
     1110   sTemp[3]=0x00;
     1111   TRACE_(pidl)("(%s)\n",sTemp);
     1112   return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
     1113}
     1114
     1115ODINFUNCTION1(LPITEMIDLIST,_ILCreateFolder,WIN32_FIND_DATAA*, stffile )
     1116{
     1117   char  buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
     1118   char *   pbuff = buff;
     1119   ULONG len, len1;
     1120   LPITEMIDLIST pidl;
     1121
     1122   TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
     1123
     1124   /* prepare buffer with both names */
     1125   len = strlen (stffile->cFileName) + 1;
     1126   memcpy (pbuff, stffile->cFileName, len);
     1127   pbuff += len;
     1128
     1129   if (stffile->cAlternateFileName)
     1130   {
     1131     len1 = strlen (stffile->cAlternateFileName)+1;
     1132     memcpy (pbuff, stffile->cAlternateFileName, len1);
     1133   }
     1134   else
     1135   {
     1136     len1 = 1;
     1137     *pbuff = 0x00;
     1138   }
     1139
     1140   pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
     1141
     1142   /* set attributes */
     1143   if (pidl)
     1144   {
     1145     LPPIDLDATA pData;
     1146     pData = _ILGetDataPointer(pidl);
     1147     FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
     1148     pData->u.folder.dwFileSize = stffile->nFileSizeLow;
     1149     pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
     1150   }
     1151
     1152   return pidl;
     1153}
     1154
     1155ODINFUNCTION1(LPITEMIDLIST,_ILCreateValue,WIN32_FIND_DATAA*, stffile)
     1156{
     1157   char  buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
     1158   char *   pbuff = buff;
     1159   ULONG len, len1;
     1160   LPITEMIDLIST pidl;
     1161
     1162   TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
     1163
     1164   /* prepare buffer with both names */
     1165   len = strlen (stffile->cFileName) + 1;
     1166   memcpy (pbuff, stffile->cFileName, len);
     1167   pbuff += len;
     1168
     1169   if (stffile->cAlternateFileName)
     1170   {
     1171     len1 = strlen (stffile->cAlternateFileName)+1;
     1172     memcpy (pbuff, stffile->cAlternateFileName, len1);
     1173   }
     1174   else
     1175   {
     1176     len1 = 1;
     1177     *pbuff = 0x00;
     1178   }
     1179
     1180   pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
     1181
     1182   /* set attributes */
     1183   if (pidl)
     1184   {
     1185     LPPIDLDATA pData;
     1186     pData = _ILGetDataPointer(pidl);
     1187     FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
     1188     pData->u.folder.dwFileSize = stffile->nFileSizeLow;
     1189     pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
     1190   }
     1191
     1192   return pidl;
     1193}
     1194
     1195ODINFUNCTION1(LPITEMIDLIST,_ILCreateSpecial,LPCSTR,szGUID)
     1196{
     1197   IID   iid;
     1198   CLSIDFromStringA(szGUID,&iid);
     1199   return _ILCreate(PT_MYCOMP, &iid, sizeof(IID));
    11511200}
    11521201
    … …  
    11591208 */
    11601209
    1161 LPITEMIDLIST WINAPI _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
    1162 {       LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
    1163         LPPIDLDATA     pData;
    1164         UINT16         uSize = 0;
    1165         LPSTR   pszDest;
    1166        
    1167         TRACE_(pidl)("(0x%02x %p %i)\n",type,pIn,uInSize);
    1168 
    1169         switch (type)
    1170         { case PT_DESKTOP:
    1171             uSize = 0;
    1172             pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
    1173             pidlOut->mkid.cb = uSize;
    1174             TRACE_(pidl)("- create Desktop\n");
    1175             break;
    1176 
    1177           case PT_MYCOMP:
    1178             uSize = 2 + 2 + sizeof(GUID);
    1179             pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
    1180             ZeroMemory(pidlOut, uSize + 2);
    1181             pidlOut->mkid.cb = uSize;
    1182             pData =_ILGetDataPointer(pidlOut);
    1183             pData->type = type;
    1184             memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
    1185             TRACE_(pidl)("- create GUID-pidl\n");
    1186             break;
    1187 
    1188           case PT_DRIVE:
    1189             uSize = 2 + 23;
    1190             pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
    1191             ZeroMemory(pidlOut, uSize + 2);
    1192             pidlOut->mkid.cb = uSize;
    1193             pData =_ILGetDataPointer(pidlOut);
    1194             pData->type = type;
    1195             pszDest =  _ILGetTextPointer(type, pData);
    1196             memcpy(pszDest, pIn, uInSize);
    1197             TRACE_(pidl)("- create Drive: %s\n",debugstr_a(pszDest));
    1198             break;
    1199 
    1200           case PT_FOLDER:
    1201           case PT_VALUE:
    1202             uSize = 2 + 12 + uInSize;
    1203             pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
    1204             ZeroMemory(pidlOut, uSize + 2);
    1205             pidlOut->mkid.cb = uSize;
    1206             pData =_ILGetDataPointer(pidlOut);
    1207             pData->type = type;
    1208             pszDest =  _ILGetTextPointer(type, pData);
    1209             memcpy(pszDest, pIn, uInSize);
    1210             TRACE_(pidl)("- create Value: %s\n",debugstr_a(pszDest));
    1211             break;
    1212         }
    1213        
    1214         pidlTemp = ILGetNext(pidlOut);
    1215         if (pidlTemp)
    1216           pidlTemp->mkid.cb = 0x00;
    1217 
    1218         TRACE_(pidl)("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
    1219         return pidlOut;
     1210ODINFUNCTION3(LPITEMIDLIST,_ILCreate,PIDLTYPE,type,
     1211                                     LPCVOID, pIn,
     1212                                     UINT16,  uInSize)
     1213{  LPITEMIDLIST   pidlOut = NULL, pidlTemp = NULL;
     1214   LPPIDLDATA     pData;
     1215   UINT16         uSize = 0;
     1216   LPSTR pszDest;
     1217
     1218   switch (type)
     1219   { case PT_DESKTOP:
     1220       uSize = 0;
     1221       pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
     1222       pidlOut->mkid.cb = uSize;
     1223       TRACE_(pidl)("- create Desktop\n");
     1224       break;
     1225
     1226     case PT_MYCOMP:
     1227       uSize = 2 + 2 + sizeof(GUID);
     1228       pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
     1229       ZeroMemory(pidlOut, uSize + 2);
     1230       pidlOut->mkid.cb = uSize;
     1231       pData =_ILGetDataPointer(pidlOut);
     1232       pData->type = type;
     1233       memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
     1234       TRACE_(pidl)("- create GUID-pidl\n");
     1235       break;
     1236
     1237     case PT_DRIVE:
     1238       uSize = 2 + 23;
     1239       pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
     1240       ZeroMemory(pidlOut, uSize + 2);
     1241       pidlOut->mkid.cb = uSize;
     1242       pData =_ILGetDataPointer(pidlOut);
     1243       pData->type = type;
     1244       pszDest =  _ILGetTextPointer(type, pData);
     1245       memcpy(pszDest, pIn, uInSize);
     1246       TRACE_(pidl)("- create Drive: %s\n",debugstr_a(pszDest));
     1247       break;
     1248
     1249     case PT_FOLDER:
     1250     case PT_VALUE:
     1251       uSize = 2 + 12 + uInSize;
     1252       pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
     1253       ZeroMemory(pidlOut, uSize + 2);
     1254       pidlOut->mkid.cb = uSize;
     1255       pData =_ILGetDataPointer(pidlOut);
     1256       pData->type = type;
     1257       pszDest =  _ILGetTextPointer(type, pData);
     1258       memcpy(pszDest, pIn, uInSize);
     1259       TRACE_(pidl)("- create Value: %s\n",debugstr_a(pszDest));
     1260       break;
     1261   }
     1262
     1263   pidlTemp = ILGetNext(pidlOut);
     1264   if (pidlTemp)
     1265     pidlTemp->mkid.cb = 0x00;
     1266
     1267   TRACE_(pidl)("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
     1268   return pidlOut;
    12201269}
    12211270
    … …  
    12281277 *  strlen (lpszText)
    12291278 */
    1230 DWORD WINAPI _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
    1231 {       TRACE_(pidl)("(%p,%p,%u)\n",pidl,pOut,uSize);
    1232 
    1233         if(_ILIsMyComputer(pidl))
    1234           pidl = ILGetNext(pidl);
    1235 
    1236         if (pidl && _ILIsDrive(pidl))
    1237           return _ILSimpleGetText(pidl, pOut, uSize);
    1238 
    1239         return 0;
     1279
     1280ODINFUNCTION3(DWORD,_ILGetDrive,LPCITEMIDLIST, pidl,
     1281                                LPSTR,         pOut,
     1282                                UINT16,        uSize)
     1283{
     1284   if(_ILIsMyComputer(pidl))
     1285     pidl = ILGetNext(pidl);
     1286
     1287   if (pidl && _ILIsDrive(pidl))
     1288     return _ILSimpleGetText(pidl, pOut, uSize);
     1289
     1290   return 0;
    12401291}
    12411292
    12421293/**************************************************************************
    12431294 *
    1244  *      ### 2. section testing pidls ###
     1295 * ### 2. section testing pidls ###
    12451296 *
    12461297 **************************************************************************
    … …  
    12531304 *  _ILIsPidlSimple()
    12541305 */
    1255 BOOL WINAPI _ILIsDesktop(LPCITEMIDLIST pidl)
    1256 {       TRACE_(pidl)("(%p)\n",pidl);
    1257         return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
    1258 }
    1259 
    1260 BOOL WINAPI _ILIsMyComputer(LPCITEMIDLIST pidl)
    1261 {
    1262         REFIID iid = _ILGetGUIDPointer(pidl);
    1263 
    1264         TRACE_(pidl)("(%p)\n",pidl);
    1265 
    1266         if (iid)
    1267           return IsEqualIID(iid, &IID_MyComputer);
    1268         return FALSE;
    1269 }
    1270 
    1271 BOOL WINAPI _ILIsSpecialFolder (LPCITEMIDLIST pidl)
    1272 {
    1273         LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1274         TRACE_(pidl)("(%p)\n",pidl);
    1275         return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
    1276                           (pidl && pidl->mkid.cb == 0x00)
    1277                         ));
    1278 }
    1279 
    1280 BOOL WINAPI _ILIsDrive(LPCITEMIDLIST pidl)
    1281 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1282         TRACE_(pidl)("(%p)\n",pidl);
    1283         return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
    1284                                     PT_DRIVE1 == lpPData->type ||
    1285                                     PT_DRIVE2 == lpPData->type ||
    1286                                     PT_DRIVE3 == lpPData->type));
    1287 }
    1288 
    1289 BOOL WINAPI _ILIsFolder(LPCITEMIDLIST pidl)
    1290 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1291         TRACE_(pidl)("(%p)\n",pidl);
    1292         return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
    1293 }
    1294 
    1295 BOOL WINAPI _ILIsValue(LPCITEMIDLIST pidl)
    1296 {       LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    1297         TRACE_(pidl)("(%p)\n",pidl);
    1298         return (pidl && lpPData && PT_VALUE == lpPData->type);
     1306
     1307ODINFUNCTION1(BOOL,_ILIsDesktop,LPCITEMIDLIST, pidl)
     1308{
     1309   return ( !pidl || (pidl && pidl->mkid.cb == 0x00) );
     1310}
     1311
     1312ODINFUNCTION1(BOOL,_ILIsMyComputer,LPCITEMIDLIST, pidl)
     1313{
     1314   REFIID iid = _ILGetGUIDPointer(pidl);
     1315
     1316   TRACE_(pidl)("(%p)\n",pidl);
     1317
     1318   if (iid)
     1319     return IsEqualIID(iid, &IID_MyComputer);
     1320   return FALSE;
     1321}
     1322
     1323ODINFUNCTION1(BOOL,_ILIsSpecialFolder,LPCITEMIDLIST, pidl)
     1324{
     1325   LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1326   TRACE_(pidl)("(%p)\n",pidl);
     1327   return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
     1328           (pidl && pidl->mkid.cb == 0x00)
     1329         ));
     1330}
     1331
     1332ODINFUNCTION1(BOOL,_ILIsDrive,LPCITEMIDLIST, pidl)
     1333{  LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1334   TRACE_(pidl)("(%p)\n",pidl);
     1335   return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
     1336                PT_DRIVE1 == lpPData->type ||
     1337                PT_DRIVE2 == lpPData->type ||
     1338                PT_DRIVE3 == lpPData->type));
     1339}
     1340
     1341ODINFUNCTION1(BOOL,_ILIsFolder,LPCITEMIDLIST, pidl)
     1342{  LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1343   TRACE_(pidl)("(%p)\n",pidl);
     1344   return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
     1345}
     1346
     1347ODINFUNCTION1(BOOL,_ILIsValue,LPCITEMIDLIST, pidl)
     1348{  LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
     1349   TRACE_(pidl)("(%p)\n",pidl);
     1350   return (pidl && lpPData && PT_VALUE == lpPData->type);
    12991351}
    13001352
    13011353/**************************************************************************
    1302  *      _ILIsPidlSimple
    1303  */
    1304 BOOL WINAPI _ILIsPidlSimple ( LPCITEMIDLIST pidl)
    1305 {
    1306         BOOL ret = TRUE;
    1307 
    1308         if(! _ILIsDesktop(pidl))        /* pidl=NULL or mkid.cb=0 */
    1309         {
    1310           WORD len = pidl->mkid.cb;
    1311           LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
    1312           if (pidlnext->mkid.cb)
    1313             ret = FALSE;
    1314         }
    1315 
    1316         TRACE_(pidl)("%s\n", ret ? "Yes" : "No");
    1317         return ret;
     1354 * _ILIsPidlSimple
     1355 */
     1356ODINFUNCTION1(BOOL,_ILIsPidlSimple,LPCITEMIDLIST, pidl)
     1357{
     1358   BOOL ret = TRUE;
     1359
     1360   if(! _ILIsDesktop(pidl))              /* pidl=NULL or mkid.cb=0 */
     1361   {
     1362     WORD len = pidl->mkid.cb;
     1363     LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
     1364     if (pidlnext->mkid.cb)
     1365       ret = FALSE;
     1366   }
     1367
     1368   TRACE_(pidl)("%s\n", ret ? "Yes" : "No");
     1369   return ret;
    13181370}
    13191371
    13201372/**************************************************************************
    13211373 *
    1322  *      ### 3. section getting values from pidls ###
     1374 * ### 3. section getting values from pidls ###
    13231375 */
    13241376
    … …  
    13301382 * returns the lenght of the string
    13311383 */
    1332 DWORD WINAPI _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
    1333 {
    1334         LPPIDLDATA      pData;
    1335         DWORD           dwReturn=0;
    1336         LPSTR           szSrc;
    1337         GUID const *    riid;
    1338         char szTemp[MAX_PATH];
    1339        
    1340         TRACE_(pidl)("(%p %p %x)\n",pidl,szOut,uOutSize);
    1341        
    1342         if (!pidl) return 0;
    1343 
    1344         if (szOut)
    1345           *szOut = 0;
    1346 
    1347         pData = _ILGetDataPointer(pidl);
    1348 
    1349         if (!pData)                                     
    1350         {
    1351          /* desktop */
    1352           if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
    1353           {
    1354             if (szOut)
    1355               lstrcpynA(szOut, szTemp, uOutSize);
    1356 
    1357             dwReturn = strlen (szTemp);
    1358           }
    1359         }
    1360         else if (( szSrc = _ILGetTextPointer(pData->type, pData) ))
    1361         {
    1362           /* filesystem */
    1363           if (szOut)
    1364             lstrcpynA(szOut, szSrc, MAX_PATH);
    1365 
    1366           dwReturn = strlen(szSrc);
    1367         }
    1368         else if (( riid = _ILGetGUIDPointer(pidl) ))
    1369         {
    1370           /* special folder */
    1371           if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
    1372           {
    1373             if (szOut)
    1374               lstrcpynA(szOut, szTemp, uOutSize);
    1375 
    1376             dwReturn = strlen (szTemp);
    1377           }
    1378         }
    1379         else
    1380         {
    1381           ERR_(pidl)("-- no text\n");
    1382         }
    1383 
    1384         TRACE_(pidl)("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
    1385         return dwReturn;
     1384
     1385ODINFUNCTION3(DWORD, _ILSimpleGetText, LPCITEMIDLIST, pidl,
     1386                                       LPSTR,         szOut,
     1387                                       UINT,          uOutSize)
     1388{
     1389   LPPIDLDATA  pData;
     1390   DWORD    dwReturn=0;
     1391   LPSTR    szSrc;
     1392   GUID const *   riid;
     1393   char szTemp[MAX_PATH];
     1394
     1395   if (!pidl) return 0;
     1396
     1397   if (szOut)
     1398     *szOut = 0;
     1399
     1400   pData = _ILGetDataPointer(pidl);
     1401
     1402   if (!pData)
     1403   {
     1404    /* desktop */
     1405     if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
     1406     {
     1407       if (szOut)
     1408         lstrcpynA(szOut, szTemp, uOutSize);
     1409
     1410       dwReturn = strlen (szTemp);
     1411     }
     1412   }
     1413   else if (( szSrc = _ILGetTextPointer(pData->type, pData) ))
     1414   {
     1415     /* filesystem */
     1416     if (szOut)
     1417       lstrcpynA(szOut, szSrc, MAX_PATH);
     1418
     1419     dwReturn = strlen(szSrc);
     1420   }
     1421   else if (( riid = _ILGetGUIDPointer(pidl) ))
     1422   {
     1423     /* special folder */
     1424     if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
     1425     {
     1426       if (szOut)
     1427         lstrcpynA(szOut, szTemp, uOutSize);
     1428
     1429       dwReturn = strlen (szTemp);
     1430     }
     1431   }
     1432   else
     1433   {
     1434     ERR_(pidl)("-- no text\n");
     1435   }
     1436
     1437   TRACE_(pidl)("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
     1438   return dwReturn;
    13861439}
    13871440
    13881441/**************************************************************************
    13891442 *
    1390  *      ### 4. getting pointers to parts of pidls ###
     1443 * ### 4. getting pointers to parts of pidls ###
    13911444 *
    13921445 **************************************************************************
    13931446 *  _ILGetDataPointer()
    13941447 */
    1395 LPPIDLDATA WINAPI _ILGetDataPointer(LPITEMIDLIST pidl)
    1396 {
    1397         if(pidl && pidl->mkid.cb != 0x00)
    1398           return (LPPIDLDATA) &(pidl->mkid.abID);
    1399         return NULL;
     1448
     1449ODINFUNCTION1(LPPIDLDATA,_ILGetDataPointer,LPITEMIDLIST, pidl)
     1450{
     1451   if(pidl && pidl->mkid.cb != 0x00)
     1452     return (LPPIDLDATA) &(pidl->mkid.abID);
     1453   return NULL;
    14001454}
    14011455
    … …  
    14041458 * gets a pointer to the long filename string stored in the pidl
    14051459 */
    1406 LPSTR WINAPI _ILGetTextPointer(PIDLTYPE type, LPPIDLDATA pidldata)
    1407 {/*     TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
    1408 
    1409         if(!pidldata)
    1410         { return NULL;
    1411         }
    1412 
    1413         switch (type)
    1414         {
    1415           case PT_MYCOMP:
    1416           case PT_SPECIAL:
    1417             return NULL;
    1418 
    1419           case PT_DRIVE:
    1420           case PT_DRIVE1:
    1421           case PT_DRIVE2:
    1422           case PT_DRIVE3:
    1423             return (LPSTR)&(pidldata->u.drive.szDriveName);
    1424 
    1425           case PT_FOLDER:
    1426           case PT_FOLDER1:
    1427           case PT_VALUE:
    1428           case PT_IESPECIAL:
    1429             return (LPSTR)&(pidldata->u.file.szNames);
    1430 
    1431           case PT_WORKGRP:
    1432           case PT_COMP:
    1433           case PT_NETWORK:
    1434           case PT_SHARE:
    1435             return (LPSTR)&(pidldata->u.network.szNames);
    1436         }
    1437         return NULL;
     1460
     1461ODINFUNCTION2(LPSTR,_ILGetTextPointer,PIDLTYPE,   type,
     1462                                      LPPIDLDATA, pidldata)
     1463{/*   TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
     1464
     1465   if(!pidldata)
     1466   { return NULL;
     1467   }
     1468
     1469   switch (type)
     1470   {
     1471     case PT_MYCOMP:
     1472     case PT_SPECIAL:
     1473       return NULL;
     1474
     1475     case PT_DRIVE:
     1476     case PT_DRIVE1:
     1477     case PT_DRIVE2:
     1478     case PT_DRIVE3:
     1479       return (LPSTR)&(pidldata->u.drive.szDriveName);
     1480
     1481     case PT_FOLDER:
     1482     case PT_FOLDER1:
     1483     case PT_VALUE:
     1484     case PT_IESPECIAL:
     1485       return (LPSTR)&(pidldata->u.file.szNames);
     1486
     1487     case PT_WORKGRP:
     1488     case PT_COMP:
     1489     case PT_NETWORK:
     1490     case PT_SHARE:
     1491       return (LPSTR)&(pidldata->u.network.szNames);
     1492   }
     1493   return NULL;
    14381494}
    14391495
    … …  
    14421498 * gets a pointer to the short filename string stored in the pidl
    14431499 */
    1444 LPSTR WINAPI _ILGetSTextPointer(PIDLTYPE type, LPPIDLDATA pidldata)
    1445 {/*     TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
    1446 
    1447         if(!pidldata)
    1448           return NULL;
    1449 
    1450         switch (type)
    1451         {
    1452           case PT_FOLDER:
    1453           case PT_VALUE:
    1454           case PT_IESPECIAL:
    1455             return (LPSTR)(pidldata->u.file.szNames + strlen (pidldata->u.file.szNames) + 1);
    1456 
    1457           case PT_WORKGRP:
    1458             return (LPSTR)(pidldata->u.network.szNames + strlen (pidldata->u.network.szNames) + 1);
    1459         }
    1460         return NULL;
     1500
     1501ODINFUNCTION2(LPSTR,_ILGetSTextPointer,PIDLTYPE,   type,
     1502                                       LPPIDLDATA, pidldata)
     1503{/*   TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
     1504
     1505   if(!pidldata)
     1506     return NULL;
     1507
     1508   switch (type)
     1509   {
     1510     case PT_FOLDER:
     1511     case PT_VALUE:
     1512     case PT_IESPECIAL:
     1513       return (LPSTR)(pidldata->u.file.szNames + strlen (pidldata->u.file.szNames) + 1);
     1514
     1515     case PT_WORKGRP:
     1516       return (LPSTR)(pidldata->u.network.szNames + strlen (pidldata->u.network.szNames) + 1);
     1517   }
     1518   return NULL;
    14611519}
    14621520
    … …  
    14661524 * returns reference to guid stored in some pidls
    14671525 */
    1468 REFIID WINAPI _ILGetGUIDPointer(LPCITEMIDLIST pidl)
    1469 {
    1470         LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1471 
    1472         if (pdata)
    1473         {
    1474           switch (pdata->type)
    1475           {
    1476             case PT_SPECIAL:
    1477             case PT_MYCOMP:
    1478               return (REFIID) &(pdata->u.mycomp.guid);
    1479           }
    1480         }
    1481         return NULL;
    1482 }
    1483 
    1484 BOOL WINAPI _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    1485 {       LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1486         FILETIME ft;
    1487         SYSTEMTIME time;
    1488 
    1489         switch (pdata->type)
    1490         { case PT_FOLDER:
    1491             DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, &ft);
    1492             break;     
    1493           case PT_VALUE:
    1494             DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, &ft);
    1495             break;
    1496           default:
    1497             return FALSE;
    1498         }
    1499         FileTimeToSystemTime (&ft, &time);
    1500         return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
    1501 }
    1502 
    1503 BOOL WINAPI _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    1504 {       LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    1505        
    1506         switch (pdata->type)
    1507         { case PT_VALUE:
    1508             break;
    1509           default:
    1510             return FALSE;
    1511         }
    1512         StrFormatByteSizeA(pdata->u.file.dwFileSize, pOut, uOutSize);
    1513         return TRUE;
    1514 }
    1515 
    1516 BOOL WINAPI _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    1517 {
    1518         char szTemp[MAX_PATH];
    1519         const char * pPoint;
    1520         LPITEMIDLIST  pidlTemp=pidl;
    1521        
    1522         TRACE_(pidl)("pidl=%p\n",pidl);
    1523 
    1524         if (!pidl) return FALSE;
    1525        
    1526         pidlTemp = ILFindLastID(pidl);
    1527        
    1528         if (!_ILIsValue(pidlTemp)) return FALSE;
    1529         if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
    1530 
    1531         pPoint = PathFindExtensionA(szTemp);
    1532 
    1533         if (! *pPoint) return FALSE;
    1534 
    1535         pPoint++;
    1536         lstrcpynA(pOut, pPoint, uOutSize);
    1537         TRACE_(pidl)("%s\n",pOut);
    1538 
    1539         return TRUE;
    1540 }
    1541 
     1526
     1527ODINFUNCTION1(REFIID,_ILGetGUIDPointer,LPCITEMIDLIST, pidl)
     1528{
     1529   LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1530
     1531   if (pdata)
     1532   {
     1533     switch (pdata->type)
     1534     {
     1535       case PT_SPECIAL:
     1536       case PT_MYCOMP:
     1537         return (REFIID) &(pdata->u.mycomp.guid);
     1538     }
     1539   }
     1540   return NULL;
     1541}
     1542
     1543ODINFUNCTION3(BOOL, _ILGetFileDate, LPCITEMIDLIST, pidl,
     1544                                    LPSTR,         pOut,
     1545                                    UINT,          uOutSize)
     1546{  LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1547   FILETIME ft;
     1548   SYSTEMTIME time;
     1549
     1550   switch (pdata->type)
     1551   { case PT_FOLDER:
     1552       DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, &ft);
     1553       break;
     1554     case PT_VALUE:
     1555       DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, &ft);
     1556       break;
     1557     default:
     1558       return FALSE;
     1559   }
     1560   FileTimeToSystemTime (&ft, &time);
     1561   return GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
     1562}
     1563
     1564
     1565ODINFUNCTION3(BOOL,_ILGetFileSize,LPCITEMIDLIST, pidl,
     1566                                  LPSTR,         pOut,
     1567                                  UINT,          uOutSize)
     1568{  LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1569
     1570   switch (pdata->type)
     1571   { case PT_VALUE:
     1572       break;
     1573     default:
     1574       return FALSE;
     1575   }
     1576   StrFormatByteSizeA(pdata->u.file.dwFileSize, pOut, uOutSize);
     1577   return TRUE;
     1578}
     1579
     1580
     1581ODINFUNCTION3(BOOL,_ILGetExtension,LPCITEMIDLIST, pidl,
     1582                                   LPSTR,         pOut,
     1583                                   UINT,          uOutSize)
     1584{
     1585   char szTemp[MAX_PATH];
     1586   const char * pPoint;
     1587   LPITEMIDLIST  pidlTemp=pidl;
     1588
     1589   if (!pidl) return FALSE;
     1590
     1591   pidlTemp = ILFindLastID(pidl);
     1592
     1593   if (!_ILIsValue(pidlTemp)) return FALSE;
     1594   if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
     1595
     1596   pPoint = PathFindExtensionA(szTemp);
     1597
     1598   if (! *pPoint) return FALSE;
     1599
     1600   pPoint++;
     1601   lstrcpynA(pOut, pPoint, uOutSize);
     1602   TRACE_(pidl)("%s\n",pOut);
     1603
     1604   return TRUE;
     1605}
     1606
Note: See TracChangeset for help on using the changeset viewer.