Ignore:
Timestamp:
Mar 26, 2000, 6:34:57 PM (25 years ago)
Author:
cbratschi
Message:

merged with Corel WINE 20000324

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellord.cpp

    r2258 r3243  
    1 /* $Id: shellord.cpp,v 1.5 1999-12-30 00:21:33 phaller Exp $ */
     1/* $Id: shellord.cpp,v 1.6 2000-03-26 16:34:51 cbratschi Exp $ */
    22/*
    33 * The parameters of many functions changes between different OS versions
    … …  
    66 * Copyright 1997 Marcus Meissner
    77 *           1998 Jürgen Schmied
     8 *
     9 * Corel WINE 20000324 level
    810 */
    911
    … …  
    4951
    5052/*************************************************************************
    51  * SHChangeNotifyRegister                       [SHELL32.2]
     53 * SHChangeNotifyRegister                       [SHELL32.2]
    5254 *
    5355 * NOTES
    … …  
    6365    int count,
    6466    IDSTRUCT *idlist)
    65 {       
    66         FIXME("SHChangeNotifyRegister: (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
    67                 hwnd,events1,events2,msg,count,idlist);
    68         return 0;
    69 }
    70 /*************************************************************************
    71  * SHChangeNotifyDeregister                     [SHELL32.4]
     67{
     68        FIXME("SHChangeNotifyRegister: (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
     69                hwnd,events1,events2,msg,count,idlist);
     70        return 0;
     71}
     72/*************************************************************************
     73 * SHChangeNotifyDeregister                     [SHELL32.4]
    7274 */
    7375DWORD WINAPI
    7476SHChangeNotifyDeregister(LONG x1)
    75 {       FIXME("(0x%08lx):stub.\n",x1);
    76         return 0;
    77 }
    78 /*************************************************************************
    79  * NTSHChangeNotifyRegister                     [SHELL32.640]
     77{       FIXME("(0x%08lx):stub.\n",x1);
     78        return 0;
     79}
     80/*************************************************************************
     81 * NTSHChangeNotifyRegister                     [SHELL32.640]
    8082 * NOTES
    8183 *   Idlist is an array of structures and Count specifies how many items in the array
    … …  
    8991    int count,
    9092    IDSTRUCT *idlist)
    91 {       FIXME("(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
    92                 hwnd,events1,events2,msg,count,idlist);
    93         return 0;
    94 }
    95 /*************************************************************************
    96  * NTSHChangeNotifyDeregister                   [SHELL32.641]
     93{       FIXME("(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
     94                hwnd,events1,events2,msg,count,idlist);
     95        return 0;
     96}
     97/*************************************************************************
     98 * NTSHChangeNotifyDeregister                   [SHELL32.641]
    9799 */
    98100DWORD WINAPI NTSHChangeNotifyDeregister(LONG x1)
    99 {       FIXME("(0x%08lx):stub.\n",x1);
    100         return 0;
    101 }
    102 
    103 /*************************************************************************
    104  * ParseField                                   [SHELL32.58]
     101{       FIXME("(0x%08lx):stub.\n",x1);
     102        return 0;
     103}
     104
     105/*************************************************************************
     106 * ParseField                                   [SHELL32.58]
    105107 *
    106108 */
    107109DWORD WINAPI ParseFieldA(LPCSTR src, DWORD field, LPSTR dst, DWORD len)
    108 {       WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,field,dst,len);
    109 
    110         if (!src || !src[0] || !dst || !len)
    111           return 0;
    112 
    113         if (field >1)
    114         { field--;     
    115           while (field)
    116           { if (*src==0x0) return FALSE;
    117             if (*src==',') field--;
    118             src++;
    119           }
    120         }
    121 
    122         while (*src!=0x00 && *src!=',' && len>0)
    123         { *dst=*src; dst++, src++; len--;
    124         }
    125         *dst=0x0;
    126        
    127         return TRUE;
    128 }
    129 
    130 /*************************************************************************
    131  * PickIconDlg                                  [SHELL32.62]
     110{       WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,field,dst,len);
     111
     112        if (!src || !src[0] || !dst || !len)
     113          return 0;
     114
     115        if (field >1)
     116        { field--;
     117          while (field)
     118          { if (*src==0x0) return FALSE;
     119            if (*src==',') field--;
     120            src++;
     121          }
     122        }
     123
     124        while (*src!=0x00 && *src!=',' && len>0)
     125        { *dst=*src; dst++, src++; len--;
     126        }
     127        *dst=0x0;
     128
     129        return TRUE;
     130}
     131
     132/*************************************************************************
     133 * PickIconDlg                                  [SHELL32.62]
    132134 *
    133135 */
    134136DWORD WINAPI PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
    135 {       FIXME("PickIconDlg(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
    136         return 0xffffffff;
    137 }
    138 
    139 /*************************************************************************
    140  * GetFileNameFromBrowse                        [SHELL32.63]
     137{       FIXME("PickIconDlg(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
     138        return 0xffffffff;
     139}
     140
     141/*************************************************************************
     142 * GetFileNameFromBrowse                        [SHELL32.63]
    141143 *
    142144 */
    143145DWORD WINAPI GetFileNameFromBrowse(HWND howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd)
    144 {       FIXME("(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
    145             howner,targetbuf,len,x,suffix,y,cmd);
     146{       FIXME("(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
     147            howner,targetbuf,len,x,suffix,y,cmd);
    146148    /* puts up a Open Dialog and requests input into targetbuf */
    147149    /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
    … …  
    151153
    152154/*************************************************************************
    153  * SHGetSettings                                [SHELL32.68]
     155 * SHGetSettings                                [SHELL32.68]
    154156 *
    155157 * NOTES
    … …  
    159161void WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask, DWORD dwx)
    160162{
    161         HKEY    hKey;
    162         DWORD   dwData;
    163         DWORD   dwDataSize = sizeof (DWORD);
    164 
    165         TRACE("(%p 0x%08lx 0x%08lx)\n",lpsfs,dwMask, dwx);
    166        
    167         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
    168                                 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
    169           return;
    170        
    171         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    172           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
    173 
    174         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    175           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
    176 
    177         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    178           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
    179 
    180         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    181           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
    182 
    183         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    184           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
    185 
    186         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    187           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
    188 
    189         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    190         { if (dwData == 0)
    191           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
    192             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
    193           }
    194           else if (dwData == 1)
    195           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
    196             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
    197           }
    198           else if (dwData == 2)
    199           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
    200             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
    201           }
    202         }
    203         RegCloseKey (hKey);
    204 
    205         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
    206 }
    207 
    208 /*************************************************************************
    209  * SHShellFolderView_Message                    [SHELL32.73]
     163        HKEY    hKey;
     164        DWORD   dwData;
     165        DWORD   dwDataSize = sizeof (DWORD);
     166
     167        TRACE("(%p 0x%08lx 0x%08lx)\n",lpsfs,dwMask, dwx);
     168
     169        if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
     170                                0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
     171          return;
     172
     173        if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     174          lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
     175
     176        if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     177          lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
     178
     179        if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     180          lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
     181
     182        if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     183          lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
     184
     185        if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     186          lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
     187
     188        if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     189          lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
     190
     191        if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     192        { if (dwData == 0)
     193          { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
     194            if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
     195          }
     196          else if (dwData == 1)
     197          { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
     198            if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
     199          }
     200          else if (dwData == 2)
     201          { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
     202            if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
     203          }
     204        }
     205        RegCloseKey (hKey);
     206
     207        TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
     208}
     209
     210/*************************************************************************
     211 * SHShellFolderView_Message                    [SHELL32.73]
    210212 *
    211213 * PARAMETERS
    … …  
    227229
    228230/*************************************************************************
    229  * OleStrToStrN                                 [SHELL32.78]
     231 * OleStrToStrN                                 [SHELL32.78]
    230232 */
    231233BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
    232234{
    233         TRACE("%p %x %s %x\n", lpStr, nStr, debugstr_w(lpOle), nOle);
    234         return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
     235        TRACE("%p %x %s %x\n", lpStr, nStr, debugstr_w(lpOle), nOle);
     236        return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
    235237}
    236238
    237239BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
    238240{
    239         TRACE("%p %x %s %x\n", lpwStr, nwStr, debugstr_w(lpOle), nOle);
    240 
    241         if (lstrcpynW ( lpwStr, lpOle, nwStr))
    242         { return lstrlenW (lpwStr);
    243         }
    244         return 0;
     241        TRACE("%p %x %s %x\n", lpwStr, nwStr, debugstr_w(lpOle), nOle);
     242
     243        if (lstrcpynW ( lpwStr, lpOle, nwStr))
     244        { return lstrlenW (lpwStr);
     245        }
     246        return 0;
    245247}
    246248
    247249BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
    248250{
    249         if (VERSION_OsIsUnicode())
    250           return OleStrToStrNW ((LPWSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
    251         return OleStrToStrNA ((LPSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
    252 }
    253 
    254 /*************************************************************************
    255  * StrToOleStrN                                 [SHELL32.79]
     251        if (VERSION_OsIsUnicode())
     252          return OleStrToStrNW ((LPWSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
     253        return OleStrToStrNA ((LPSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
     254}
     255
     256/*************************************************************************
     257 * StrToOleStrN                                 [SHELL32.79]
    256258 *  lpMulti, nMulti, nWide [IN]
    257259 *  lpWide [OUT]
    … …  
    259261BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
    260262{
    261         TRACE("%p %x %s %x\n", lpWide, nWide, lpStrA, nStr);
    262         return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
     263        TRACE("%p %x %s %x\n", lpWide, nWide, lpStrA, nStr);
     264        return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
    263265}
    264266BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
    265267{
    266         TRACE("%p %x %s %x\n", lpWide, nWide, debugstr_w(lpStrW), nStr);
    267 
    268         if (lstrcpynW (lpWide, lpStrW, nWide))
    269         { return lstrlenW (lpWide);
    270         }
    271         return 0;
     268        TRACE("%p %x %s %x\n", lpWide, nWide, debugstr_w(lpStrW), nStr);
     269
     270        if (lstrcpynW (lpWide, lpStrW, nWide))
     271        { return lstrlenW (lpWide);
     272        }
     273        return 0;
    272274}
    273275
    274276BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
    275277{
    276         if (VERSION_OsIsUnicode())
    277           return StrToOleStrNW (lpWide, nWide, (LPWSTR)lpStr, nStr);
    278         return StrToOleStrNA (lpWide, nWide, (LPSTR)lpStr, nStr);
    279 }
    280 
    281 /*************************************************************************
    282  * RegisterShellHook                            [SHELL32.181]
     278        if (VERSION_OsIsUnicode())
     279          return StrToOleStrNW (lpWide, nWide, (LPWSTR)lpStr, nStr);
     280        return StrToOleStrNA (lpWide, nWide, (LPSTR)lpStr, nStr);
     281}
     282
     283/*************************************************************************
     284 * RegisterShellHook                            [SHELL32.181]
    283285 *
    284286 * PARAMS
    … …  
    293295}
    294296/*************************************************************************
    295  * ShellMessageBoxW                             [SHELL32.182]
     297 * ShellMessageBoxW                             [SHELL32.182]
    296298 *
    297299 * Format and output errormessage.
    298300 *
    299  * idText       resource ID of title or LPSTR
    300  * idTitle      resource ID of title or LPSTR
     301 * idText       resource ID of title or LPSTR
     302 * idTitle      resource ID of title or LPSTR
    301303 *
    302304 * NOTES
    … …  
    305307INT __cdecl
    306308ShellMessageBoxW(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
    307 {       WCHAR   szText[100],szTitle[100],szTemp[256];
    308         LPWSTR   pszText = &szText[0], pszTitle = &szTitle[0];
    309         LPVOID  args = &arglist;
    310 
    311         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",(DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
    312 
    313         if (!HIWORD (idTitle))
    314           LoadStringW(hmod,idTitle,pszTitle,100);
    315         else
    316           pszTitle = (LPWSTR)idTitle;
    317 
    318         if (! HIWORD (idText))
    319           LoadStringW(hmod,idText,pszText,100);
    320         else
    321           pszText = (LPWSTR)idText;
    322 
    323         FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
     309{       WCHAR   szText[100],szTitle[100],szTemp[256];
     310        LPWSTR   pszText = &szText[0], pszTitle = &szTitle[0];
     311        LPVOID  args = &arglist;
     312
     313        TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",(DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
     314
     315        if (!HIWORD (idTitle))
     316          LoadStringW(hmod,idTitle,pszTitle,100);
     317        else
     318          pszTitle = (LPWSTR)idTitle;
     319
     320        if (! HIWORD (idText))
     321          LoadStringW(hmod,idText,pszText,100);
     322        else
     323          pszText = (LPWSTR)idText;
     324
     325        FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
    324326                szText,
    325327                0,
    … …  
    328330                256,
    329331                (LPDWORD)args);
    330         return MessageBoxW(hwnd,szTemp,szTitle,uType);
    331 }
    332 
    333 /*************************************************************************
    334  * ShellMessageBoxA                             [SHELL32.183]
     332        return MessageBoxW(hwnd,szTemp,szTitle,uType);
     333}
     334
     335/*************************************************************************
     336 * ShellMessageBoxA                             [SHELL32.183]
    335337 */
    336338INT __cdecl
    337339ShellMessageBoxA(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
    338 {       char    szText[100],szTitle[100],szTemp[256];
    339         LPSTR   pszText = &szText[0], pszTitle = &szTitle[0];
    340         LPVOID  args = &arglist;
    341 
    342         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n", (DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
    343 
    344         if (!HIWORD (idTitle))
    345           LoadStringA(hmod,idTitle,pszTitle,100);
    346         else
    347           pszTitle = (LPSTR)idTitle;
    348 
    349         if (! HIWORD (idText))
    350           LoadStringA(hmod,idText,pszText,100);
    351         else
    352           pszText = (LPSTR)idText;
    353 
    354         FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,pszText,0,0,szTemp,256,(LPDWORD)args);
    355         return MessageBoxA(hwnd,szTemp,pszTitle,uType);
    356 }
    357 
    358 /*************************************************************************
    359  * SHRestricted                         [SHELL32.100]
     340{       char    szText[100],szTitle[100],szTemp[256];
     341        LPSTR   pszText = &szText[0], pszTitle = &szTitle[0];
     342        LPVOID  args = &arglist;
     343
     344        TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n", (DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
     345
     346        if (!HIWORD (idTitle))
     347          LoadStringA(hmod,idTitle,pszTitle,100);
     348        else
     349          pszTitle = (LPSTR)idTitle;
     350
     351        if (! HIWORD (idText))
     352          LoadStringA(hmod,idText,pszText,100);
     353        else
     354          pszText = (LPSTR)idText;
     355
     356        FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,pszText,0,0,szTemp,256,(LPDWORD)args);
     357        return MessageBoxA(hwnd,szTemp,pszTitle,uType);
     358}
     359
     360/*************************************************************************
     361 * SHRestricted                         [SHELL32.100]
    360362 *
    361363 * walks through policy table, queries <app> key, <type> value, returns
    … …  
    373375DWORD WINAPI SHRestricted (DWORD pol) {
    374376        char regstr[256];
    375         HKEY    xhkey;
    376         DWORD   retval, polidx, i, datsize = 4;
    377 
    378         TRACE("(%08lx)\n",pol);
    379 
    380         polidx = -1;
    381 
    382         /* scan to see if we know this policy ID */
    383         for (i = 0; i < SHELL_MAX_POLICIES; i++)
    384         {
    385              if (pol == sh32_policy_table[i].polflags)
    386              {
    387                  polidx = i;
    388                 break;
    389              }
    390         }
    391 
    392         if (polidx == -1)
    393         {
    394             /* we don't know this policy, return 0 */
    395             TRACE("unknown policy: (%08lx)\n", pol);
    396                 return 0;
    397         }
    398 
    399         /* we have a known policy */
    400         lstrcpyA(regstr, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\");
    401         lstrcatA(regstr, sh32_policy_table[polidx].appstr);
    402 
    403         /* first check if this policy has been cached, return it if so */
    404         if (sh32_policy_table[polidx].cache != SHELL_NO_POLICY)
    405         {
    406             return sh32_policy_table[polidx].cache;
    407         }
    408 
    409         /* return 0 and don't set the cache if any registry errors occur */
    410         retval = 0;
    411         if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
    412         {
    413             if (RegQueryValueExA(xhkey, sh32_policy_table[polidx].keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
    414             {
    415                 sh32_policy_table[polidx].cache = retval;
    416             }
    417 
    418         RegCloseKey(xhkey);
    419 }
    420 
    421         return retval;
     377        HKEY    xhkey;
     378        DWORD   retval, polidx, i, datsize = 4;
     379
     380        TRACE("(%08lx)\n",pol);
     381
     382        polidx = -1;
     383
     384        /* scan to see if we know this policy ID */
     385        for (i = 0; i < SHELL_MAX_POLICIES; i++)
     386        {
     387             if (pol == sh32_policy_table[i].polflags)
     388             {
     389                 polidx = i;
     390                break;
     391             }
     392        }
     393
     394        if (polidx == -1)
     395        {
     396            /* we don't know this policy, return 0 */
     397            TRACE("unknown policy: (%08lx)\n", pol);
     398                return 0;
     399        }
     400
     401        /* we have a known policy */
     402        lstrcpyA(regstr, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\");
     403        lstrcatA(regstr, sh32_policy_table[polidx].appstr);
     404
     405        /* first check if this policy has been cached, return it if so */
     406        if (sh32_policy_table[polidx].cache != SHELL_NO_POLICY)
     407        {
     408            return sh32_policy_table[polidx].cache;
     409        }
     410
     411        /* return 0 and don't set the cache if any registry errors occur */
     412        retval = 0;
     413        if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
     414        {
     415            if (RegQueryValueExA(xhkey, sh32_policy_table[polidx].keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
     416            {
     417                sh32_policy_table[polidx].cache = retval;
     418            }
     419
     420        RegCloseKey(xhkey);
     421}
     422
     423        return retval;
    422424}
    423425
    … …  
    460462     {
    461463         if (lstrcmpiA(inpRegKey, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies"))
    462         {
    463              /* doesn't match, fail */
    464              return 0;
    465         }
     464        {
     465             /* doesn't match, fail */
     466             return 0;
     467        }
    466468     }
    467469
    … …  
    476478
    477479/*************************************************************************
    478  * SHCreateDirectory                            [SHELL32.165]
     480 * SHCreateDirectory                            [SHELL32.165]
    479481 *
    480482 * NOTES
    … …  
    483485 */
    484486DWORD WINAPI SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,LPCSTR path) {
    485         TRACE("(%p,%s):stub.\n",sec,path);
    486         if (CreateDirectoryA(path,sec))
    487                 return TRUE;
    488         /* SHChangeNotify(8,1,path,0); */
    489         return FALSE;
     487        TRACE("(%p,%s):stub.\n",sec,path);
     488        if (CreateDirectoryA(path,sec))
     489                return TRUE;
     490        /* SHChangeNotify(8,1,path,0); */
     491        return FALSE;
    490492#if 0
    491         if (SHELL32_79(path,(LPVOID)x))
    492                 return 0;
    493         FIXME("(%08lx,%s):stub.\n",x,path);
    494         return 0;
     493        if (SHELL32_79(path,(LPVOID)x))
     494                return 0;
     495        FIXME("(%08lx,%s):stub.\n",x,path);
     496        return 0;
    495497#endif
    496498}
    497499
    498500/*************************************************************************
    499  * SHFree                                       [SHELL32.195]
     501 * SHFree                                       [SHELL32.195]
    500502 *
    501503 * NOTES
    … …  
    503505 *     exported by ordinal
    504506 */
    505 /*#define MEM_DEBUG 1*/
     507#define MEM_DEBUG 0
    506508DWORD WINAPI SHFree(LPVOID x)
    507509{
    508 #ifdef MEM_DEBUG
    509         WORD len = *(LPWORD)(x-2);
    510 
    511         if ( *(LPWORD)(x+len) != 0x7384)
    512           ERR("MAGIC2!\n");
    513 
    514         if ( (*(LPWORD)(x-4)) != 0x8271)
    515           ERR("MAGIC1!\n");
    516         else
    517           memset(x-4, 0xde, len+6);
    518 
    519         TRACE("%p len=%u\n",x, len);
    520 
    521         x -= 4;
     510#if MEM_DEBUG
     511        WORD len = *(LPWORD)(x-2);
     512
     513        if ( *(LPWORD)(x+len) != 0x7384)
     514          ERR("MAGIC2!\n");
     515
     516        if ( (*(LPWORD)(x-4)) != 0x8271)
     517          ERR("MAGIC1!\n");
     518        else
     519          memset(x-4, 0xde, len+6);
     520
     521        TRACE("%p len=%u\n",x, len);
     522
     523        x -= 4;
    522524#else
    523         TRACE("%p\n",x);
     525        TRACE("%p\n",x);
    524526#endif
    525         return HeapFree(GetProcessHeap(), 0, x);
    526 }
    527 
    528 /*************************************************************************
    529  * SHAlloc                                      [SHELL32.196]
     527        return HeapFree(GetProcessHeap(), 0, x);
     528}
     529
     530/*************************************************************************
     531 * SHAlloc                                      [SHELL32.196]
    530532 *
    531533 * NOTES
    … …  
    535537LPVOID WINAPI SHAlloc(DWORD len)
    536538{
    537         LPBYTE ret;
    538 
    539 #ifdef MEM_DEBUG
    540         ret = (LPBYTE) HeapAlloc(GetProcessHeap(),0,len+6);
     539        LPBYTE ret;
     540
     541#if MEM_DEBUG
     542        ret = (LPBYTE) HeapAlloc(GetProcessHeap(),0,len+6);
    541543#else
    542         ret = (LPBYTE) HeapAlloc(GetProcessHeap(),0,len);
     544        ret = (LPBYTE) HeapAlloc(GetProcessHeap(),0,len);
    543545#endif
    544546
    545 #ifdef MEM_DEBUG
    546         *(LPWORD)(ret) = 0x8271;
    547         *(LPWORD)(ret+2) = (WORD)len;
    548         *(LPWORD)(ret+4+len) = 0x7384;
    549         ret += 4;
    550         memset(ret, 0xdf, len);
     547#if MEM_DEBUG
     548        *(LPWORD)(ret) = 0x8271;
     549        *(LPWORD)(ret+2) = (WORD)len;
     550        *(LPWORD)(ret+4+len) = 0x7384;
     551        ret += 4;
     552        memset(ret, 0xdf, len);
    551553#endif
    552         TRACE("%lu bytes at %p\n",len, ret);
    553         return (LPVOID)ret;
    554 }
    555 
    556 /*************************************************************************
    557  * SHRegisterDragDrop                           [SHELL32.86]
     554        TRACE("%lu bytes at %p\n",len, ret);
     555        return (LPVOID)ret;
     556}
     557
     558/*************************************************************************
     559 * SHRegisterDragDrop                           [SHELL32.86]
    558560 *
    559561 * NOTES
    … …  
    562564DWORD WINAPI SHRegisterDragDrop(HWND hWnd,IDropTarget * pDropTarget)
    563565{
    564         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
    565         return     RegisterDragDrop(hWnd, pDropTarget);
    566 }
    567 
    568 /*************************************************************************
    569  * SHRevokeDragDrop                             [SHELL32.87]
     566        FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
     567        return     RegisterDragDrop(hWnd, pDropTarget);
     568}
     569
     570/*************************************************************************
     571 * SHRevokeDragDrop                             [SHELL32.87]
    570572 *
    571573 * NOTES
    … …  
    578580
    579581/*************************************************************************
    580  * SHDoDragDrop                                 [SHELL32.88]
     582 * SHDoDragDrop                                 [SHELL32.88]
    581583 *
    582584 * NOTES
    … …  
    589591
    590592/*************************************************************************
    591  * RunFileDlg                                   [SHELL32.61]
     593 * RunFileDlg                                   [SHELL32.61]
    592594 *
    593595 * NOTES
    … …  
    596598DWORD WINAPI
    597599RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
    598             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
     600            LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
    599601{
    600602    FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
    601            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
     603           hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
    602604    return 0;
    603605}
    604606
    605607/*************************************************************************
    606  * ExitWindowsDialog                            [SHELL32.60]
     608 * ExitWindowsDialog                            [SHELL32.60]
    607609 *
    608610 * NOTES
    … …  
    611613void WINAPI ExitWindowsDialog (HWND hWndOwner)
    612614{
    613         TRACE("(0x%08x)\n", hWndOwner);
    614         if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
    615         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
    616         }
    617 }
    618 
    619 /*************************************************************************
    620  * ArrangeWindows                               [SHELL32.184]
     615        TRACE("(0x%08x)\n", hWndOwner);
     616        if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
     617        { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
     618        }
     619}
     620
     621/*************************************************************************
     622 * ArrangeWindows                               [SHELL32.184]
    621623 *
    622624 */
    623625DWORD WINAPI
    624626ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
    625                 DWORD dwParam4, DWORD dwParam5)
     627                DWORD dwParam4, DWORD dwParam5)
    626628{
    627629    FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
    628            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
     630           dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
    629631    return 0;
    630632}
    631633
    632634/*************************************************************************
    633  * SignalFileOpen                               [SHELL32.103]
     635 * SignalFileOpen                               [SHELL32.103]
    634636 *
    635637 * NOTES
    … …  
    645647
    646648/*************************************************************************
    647  * SHAddToRecentDocs                            [SHELL32.234]
     649 * SHAddToRecentDocs                            [SHELL32.234]
    648650 *
    649651 * PARAMETERS
    … …  
    657659{ if (SHARD_PIDL==uFlags)
    658660  { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
    659         }
    660         else
    661         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
    662         }
     661        }
     662        else
     663        { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
     664        }
    663665  return 0;
    664666}
    665667/*************************************************************************
    666  * SHFileOperation                              [SHELL32.242]
     668 * SHFileOperation                              [SHELL32.242]
    667669 *
    668670 */
    669671DWORD WINAPI SHFileOperationAW(DWORD x)
    670 {       FIXME("0x%08lx stub\n",x);
    671         return 0;
    672 
    673 }
    674 
    675 /*************************************************************************
    676  * SHFileOperationA                             [SHELL32.243]
     672{       FIXME("0x%08lx stub\n",x);
     673        return 0;
     674
     675}
     676
     677/*************************************************************************
     678 * SHFileOperationA                             [SHELL32.243]
    677679 *
    678680 * NOTES
    … …  
    684686}
    685687/*************************************************************************
    686  * SHFileOperationW                             [SHELL32.244]
     688 * SHFileOperationW                             [SHELL32.244]
    687689 *
    688690 * NOTES
    … …  
    695697
    696698/*************************************************************************
    697  * SHChangeNotify                               [SHELL32.239]
     699 * SHChangeNotify                               [SHELL32.239]
    698700 *
    699701 * NOTES
    … …  
    703705    INT   wEventId,  /* [IN] flags that specifies the event*/
    704706    UINT  uFlags,   /* [IN] the meaning of dwItem[1|2]*/
    705                 LPCVOID dwItem1,
    706                 LPCVOID dwItem2)
     707                LPCVOID dwItem1,
     708                LPCVOID dwItem2)
    707709{ FIXME("(0x%08x,0x%08ux,%p,%p):stub.\n", wEventId,uFlags,dwItem1,dwItem2);
    708710  return 0;
    709711}
    710712/*************************************************************************
    711  * SHCreateShellFolderViewEx                    [SHELL32.174]
     713 * SHCreateShellFolderViewEx                    [SHELL32.174]
    712714 *
    713715 * NOTES
    … …  
    718720  LPVOID* ppv)            /*[out] IShellView pointer*/
    719721{
    720         IShellView * psf;
    721         HRESULT hRes;
    722        
    723         TRACE("sf=%p pidl=%p cb=%p mode=0x%08lx parm=0x%08lx\n",
    724           psvcbi->pShellFolder, psvcbi->pidl, psvcbi->pCallBack, psvcbi->viewmode, psvcbi->dwUserParam);
    725 
    726         psf = IShellView_Constructor(psvcbi->pShellFolder);
    727        
    728         if (!psf)
    729           return E_OUTOFMEMORY;
    730 
    731         IShellView_AddRef(psf);
    732         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
    733         IShellView_Release(psf);
    734 
    735         return hRes;
    736 }
    737 /*************************************************************************
    738  *  SHWinHelp                                   [SHELL32.127]
     722        IShellView * psf;
     723        HRESULT hRes;
     724
     725        TRACE("sf=%p pidl=%p cb=%p mode=0x%08lx parm=0x%08lx\n",
     726          psvcbi->pShellFolder, psvcbi->pidl, psvcbi->pCallBack, psvcbi->viewmode, psvcbi->dwUserParam);
     727
     728        psf = IShellView_Constructor(psvcbi->pShellFolder);
     729
     730        if (!psf)
     731          return E_OUTOFMEMORY;
     732
     733        IShellView_AddRef(psf);
     734        hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
     735        IShellView_Release(psf);
     736
     737        return hRes;
     738}
     739/*************************************************************************
     740 *  SHWinHelp                                   [SHELL32.127]
    739741 *
    740742 */
    741743HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
    742 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
    743         return 0;
     744{       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
     745        return 0;
    744746}
    745747/*************************************************************************
    … …  
    748750 */
    749751HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
    750 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
    751         return 0;
    752 }
    753 /*************************************************************************
    754  * ShellExecuteEx                               [SHELL32.291]
     752{       FIXME("0x%08lx 0x%08lx stub\n",x,z);
     753        return 0;
     754}
     755/*************************************************************************
     756 * ShellExecuteEx                               [SHELL32.291]
    755757 *
    756758 */
    757759BOOL WINAPI ShellExecuteExAW (LPVOID sei)
    758 {       if (VERSION_OsIsUnicode())
    759           return ShellExecuteExW ((LPSHELLEXECUTEINFOW)sei);
    760         return ShellExecuteExA ((LPSHELLEXECUTEINFOA)sei);
    761 }
    762 /*************************************************************************
    763  * ShellExecuteExA                              [SHELL32.292]
     760{       if (VERSION_OsIsUnicode())
     761          return ShellExecuteExW ((LPSHELLEXECUTEINFOW)sei);
     762        return ShellExecuteExA ((LPSHELLEXECUTEINFOA)sei);
     763}
     764/*************************************************************************
     765 * ShellExecuteExA                              [SHELL32.292]
    764766 *
    765767 */
    766768BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
    767 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
    768         LPSTR pos;
    769         int gap, len;
    770         STARTUPINFOA  startupinfo;
    771         PROCESS_INFORMATION processinformation;
    772                        
    773         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
    774                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
    775                 sei->lpParameters, sei->lpDirectory, sei->nShow,
    776                 (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
    777 
    778         ZeroMemory(szApplicationName,MAX_PATH);
    779         if (sei->lpFile)
    780           strcpy(szApplicationName, sei->lpFile);
    781        
    782         ZeroMemory(szCommandline,MAX_PATH);
    783         if (sei->lpParameters)
    784           strcpy(szCommandline, sei->lpParameters);
    785                        
    786         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
    787                           SEE_MASK_NOCLOSEPROCESS | SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
    788                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
    789                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
    790         { FIXME("flags ignored: 0x%08lx\n", sei->fMask);
    791         }
    792 
    793         if (sei->fMask & SEE_MASK_CLASSNAME)
    794         { HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);       
    795         }
    796 
    797         /* process the IDList */
    798         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
    799         { SHGetPathFromIDListA ((LPCITEMIDLIST)sei->lpIDList,szApplicationName);
    800           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
    801         }
    802         else
    803         { if (sei->fMask & SEE_MASK_IDLIST )
    804           { /* %I is the adress of a global item ID*/
    805             pos = strstr(szCommandline, "%I");
    806             if (pos)
    807             { HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize((LPCITEMIDLIST)sei->lpIDList), 0);
    808               sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
    809               SHUnlockShared(hmem);
    810        
    811               gap = strlen(szPidl);
    812               len = strlen(pos)-2;
    813               memmove(pos+gap,pos+2,len);
    814               memcpy(pos,szPidl,gap);
    815 
    816             }
    817           }
    818         }
    819 
    820         pos = strstr(szCommandline, ",%L");     /* dunno what it means: kill it*/
    821         if (pos)
    822         { len = strlen(pos)-2;
    823           *pos=0x0;
    824           memmove(pos,pos+3,len);
    825         }
    826 
    827         TRACE("execute: %s %s\n",szApplicationName, szCommandline);
    828 
    829         ZeroMemory(&startupinfo,sizeof(STARTUPINFOA));
    830         startupinfo.cb = sizeof(STARTUPINFOA);
    831 
    832         return CreateProcessA(szApplicationName[0] ? szApplicationName:NULL,
    833                         szCommandline[0] ? szCommandline : NULL,
    834                         NULL, NULL, FALSE, 0,
    835                         NULL, NULL, &startupinfo, &processinformation);
    836        
    837        
    838 }
    839 /*************************************************************************
    840  * ShellExecuteExW                              [SHELL32.293]
     769{       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
     770        LPSTR pos;
     771        int gap, len;
     772        STARTUPINFOA  startupinfo;
     773        PROCESS_INFORMATION processinformation;
     774
     775        WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
     776                sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
     777                sei->lpParameters, sei->lpDirectory, sei->nShow,
     778                (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
     779
     780        ZeroMemory(szApplicationName,MAX_PATH);
     781        if (sei->lpFile)
     782          strcpy(szApplicationName, sei->lpFile);
     783
     784        ZeroMemory(szCommandline,MAX_PATH);
     785        if (sei->lpParameters)
     786          strcpy(szCommandline, sei->lpParameters);
     787
     788        if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
     789                          SEE_MASK_NOCLOSEPROCESS | SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
     790                          SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
     791                          SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
     792        { FIXME("flags ignored: 0x%08lx\n", sei->fMask);
     793        }
     794
     795        if (sei->fMask & SEE_MASK_CLASSNAME)
     796        { HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
     797        }
     798
     799        /* process the IDList */
     800        if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
     801        { SHGetPathFromIDListA ((LPCITEMIDLIST)sei->lpIDList,szApplicationName);
     802          TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
     803        }
     804        else
     805        { if (sei->fMask & SEE_MASK_IDLIST )
     806          { /* %I is the adress of a global item ID*/
     807            pos = strstr(szCommandline, "%I");
     808            if (pos)
     809            { HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize((LPCITEMIDLIST)sei->lpIDList), 0);
     810              sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
     811              SHUnlockShared(hmem);
     812
     813              gap = strlen(szPidl);
     814              len = strlen(pos)-2;
     815              memmove(pos+gap,pos+2,len);
     816              memcpy(pos,szPidl,gap);
     817
     818            }
     819          }
     820        }
     821
     822        pos = strstr(szCommandline, ",%L");     /* dunno what it means: kill it*/
     823        if (pos)
     824        { len = strlen(pos)-2;
     825          *pos=0x0;
     826          memmove(pos,pos+3,len);
     827        }
     828
     829        TRACE("execute: %s %s\n",szApplicationName, szCommandline);
     830
     831        ZeroMemory(&startupinfo,sizeof(STARTUPINFOA));
     832        startupinfo.cb = sizeof(STARTUPINFOA);
     833
     834        return CreateProcessA(szApplicationName[0] ? szApplicationName:NULL,
     835                        szCommandline[0] ? szCommandline : NULL,
     836                        NULL, NULL, FALSE, 0,
     837                        NULL, NULL, &startupinfo, &processinformation);
     838
     839
     840}
     841/*************************************************************************
     842 * ShellExecuteExW                              [SHELL32.293]
    841843 *
    842844 */
    843845BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
    844 {       SHELLEXECUTEINFOA seiA;
    845         DWORD ret;
    846 
    847         TRACE("%p\n", sei);
    848 
    849         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
    850        
     846{       SHELLEXECUTEINFOA seiA;
     847        DWORD ret;
     848
     849        TRACE("%p\n", sei);
     850
     851        memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
     852
    851853        if (sei->lpVerb)
    852           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
     854          seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
    853855
    854856        if (sei->lpFile)
    855           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
     857          seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
    856858
    857859        if (sei->lpParameters)
    858           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
    859 
    860         if (sei->lpDirectory)
    861           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
     860          seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
     861
     862        if (sei->lpDirectory)
     863          seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
    862864
    863865        if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
    864           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
    865         else
    866           seiA.lpClass = NULL;
    867                
    868         ret = ShellExecuteExA(&seiA);
    869 
    870         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
    871         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
    872         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
    873         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
    874         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
    875 
    876         return ret;
     866          seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
     867        else
     868          seiA.lpClass = NULL;
     869
     870        ret = ShellExecuteExA(&seiA);
     871
     872        if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
     873        if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
     874        if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
     875        if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
     876        if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
     877
     878        return ret;
    877879}
    878880
    879881static LPUNKNOWN SHELL32_IExplorerInterface=0;
    880882/*************************************************************************
    881  * SHSetInstanceExplorer                        [SHELL32.176]
     883 * SHSetInstanceExplorer                        [SHELL32.176]
    882884 *
    883885 * NOTES
    … …  
    885887 */
    886888HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
    887 {       TRACE("%p\n", lpUnknown);
    888         SHELL32_IExplorerInterface = lpUnknown;
    889         return (HRESULT) lpUnknown;
    890 }
    891 /*************************************************************************
    892  * SHGetInstanceExplorer                        [SHELL32.256]
     889{       TRACE("%p\n", lpUnknown);
     890        SHELL32_IExplorerInterface = lpUnknown;
     891        return (HRESULT) lpUnknown;
     892}
     893/*************************************************************************
     894 * SHGetInstanceExplorer                        [SHELL32.256]
    893895 *
    894896 * NOTES
    … …  
    896898 */
    897899HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
    898 {       TRACE("%p\n", lpUnknown);
    899 
    900         *lpUnknown = SHELL32_IExplorerInterface;
    901 
    902         if (!SHELL32_IExplorerInterface)
    903           return E_FAIL;
    904 
    905         IUnknown_AddRef(SHELL32_IExplorerInterface);
    906         return NOERROR;
    907 }
    908 /*************************************************************************
    909  * SHFreeUnusedLibraries                        [SHELL32.123]
     900{       TRACE("%p\n", lpUnknown);
     901
     902        *lpUnknown = SHELL32_IExplorerInterface;
     903
     904        if (!SHELL32_IExplorerInterface)
     905          return E_FAIL;
     906
     907        IUnknown_AddRef(SHELL32_IExplorerInterface);
     908        return NOERROR;
     909}
     910/*************************************************************************
     911 * SHFreeUnusedLibraries                        [SHELL32.123]
    910912 *
    911913 * NOTES
    … …  
    913915 */
    914916HRESULT WINAPI SHFreeUnusedLibraries (void)
    915 {       FIXME("stub\n");
    916         return TRUE;
    917 }
    918 /*************************************************************************
    919  * DAD_SetDragImage                             [SHELL32.136]
     917{       FIXME("stub\n");
     918        return TRUE;
     919}
     920/*************************************************************************
     921 * DAD_SetDragImage                             [SHELL32.136]
    920922 *
    921923 * NOTES
    … …  
    927929}
    928930/*************************************************************************
    929  * DAD_ShowDragImage                            [SHELL32.137]
     931 * DAD_ShowDragImage                            [SHELL32.137]
    930932 *
    931933 * NOTES
    … …  
    937939}
    938940/*************************************************************************
    939  * SHRegCloseKey                        [NT4.0:SHELL32.505]
     941 * SHRegCloseKey                        [NT4.0:SHELL32.505]
    940942 *
    941943 */
    942944HRESULT WINAPI SHRegCloseKey (HKEY hkey)
    943 {       TRACE("0x%04x\n",hkey);
    944         return RegCloseKey( hkey );
    945 }
    946 /*************************************************************************
    947  * SHRegOpenKeyA                                [SHELL32.506]
     945{       TRACE("0x%04x\n",hkey);
     946        return RegCloseKey( hkey );
     947}
     948/*************************************************************************
     949 * SHRegOpenKeyA                                [SHELL32.506]
    948950 *
    949951 */
    950952HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
    951953{
    952         TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
    953         return RegOpenKeyA(hKey, lpSubKey, phkResult);
    954 }
    955 
    956 /*************************************************************************
    957  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
     954        TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
     955        return RegOpenKeyA(hKey, lpSubKey, phkResult);
     956}
     957
     958/*************************************************************************
     959 * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
    958960 *
    959961 */
    960962HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
    961 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
    962         return RegOpenKeyW( hkey, lpszSubKey, retkey );
    963 }
    964 /*************************************************************************
    965  * SHRegQueryValueExA                           [SHELL32.509]
     963{       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
     964        return RegOpenKeyW( hkey, lpszSubKey, retkey );
     965}
     966/*************************************************************************
     967 * SHRegQueryValueExA                           [SHELL32.509]
    966968 *
    967969 */
    968970HRESULT WINAPI SHRegQueryValueExA(
    969         HKEY hkey,
    970         LPSTR lpValueName,
    971         LPDWORD lpReserved,
    972         LPDWORD lpType,
    973         LPBYTE lpData,
    974         LPDWORD lpcbData)
    975 {
    976         TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
    977         return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
    978 }
    979 /*************************************************************************
    980  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
     971        HKEY hkey,
     972        LPSTR lpValueName,
     973        LPDWORD lpReserved,
     974        LPDWORD lpType,
     975        LPBYTE lpData,
     976        LPDWORD lpcbData)
     977{
     978        TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
     979        return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
     980}
     981/*************************************************************************
     982 * SHRegQueryValueW                             [NT4.0:SHELL32.510]
    981983 *
    982984 */
    983985HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
    984                                 LPWSTR lpszData, LPDWORD lpcbData )
    985 {       WARN("0x%04x %s %p %p semi-stub\n",
    986                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
    987         return RegQueryValueW( hkey, lpszSubKey, lpszData, (LPLONG)lpcbData );
    988 }
    989 
    990 /*************************************************************************
    991  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
     986                                LPWSTR lpszData, LPDWORD lpcbData )
     987{       WARN("0x%04x %s %p %p semi-stub\n",
     988                hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
     989        return RegQueryValueW( hkey, lpszSubKey, lpszData, (LPLONG)lpcbData );
     990}
     991
     992/*************************************************************************
     993 * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
    992994 *
    993995 * FIXME
    … …  
    996998 */
    997999HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
    998                 LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
    999 {       DWORD ret;
    1000         WARN("0x%04x %s %p %p %p %p semi-stub\n",
    1001                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
    1002         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, (LPBYTE)pvData, pcbData);
    1003         return ret;
    1004 }
    1005 
    1006 /*************************************************************************
    1007  * ReadCabinetState                             [NT 4.0:SHELL32.651]
     1000                LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
     1001{       DWORD ret;
     1002        WARN("0x%04x %s %p %p %p %p semi-stub\n",
     1003                hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
     1004        ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, (LPBYTE)pvData, pcbData);
     1005        return ret;
     1006}
     1007
     1008/*************************************************************************
     1009 * ReadCabinetState                             [NT 4.0:SHELL32.651]
    10081010 *
    10091011 */
    10101012HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
    1011 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
    1012         return 0;
    1013 }
    1014 /*************************************************************************
    1015  * WriteCabinetState                            [NT 4.0:SHELL32.652]
     1013{       FIXME("0x%04lx 0x%04lx stub\n",u,v);
     1014        return 0;
     1015}
     1016/*************************************************************************
     1017 * WriteCabinetState                            [NT 4.0:SHELL32.652]
    10161018 *
    10171019 */
    10181020HRESULT WINAPI WriteCabinetState(DWORD u)
    1019 {       FIXME("0x%04lx stub\n",u);
    1020         return 0;
    1021 }
    1022 /*************************************************************************
    1023  * FileIconInit                                 [SHELL32.660]
     1021{       FIXME("0x%04lx stub\n",u);
     1022        return 0;
     1023}
     1024/*************************************************************************
     1025 * FileIconInit                                 [SHELL32.660]
    10241026 *
    10251027 */
    10261028BOOL WINAPI FileIconInit(BOOL bFullInit)
    1027 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
    1028         return 0;
    1029 }
    1030 /*************************************************************************
    1031  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
     1029{       FIXME("(%s)\n", bFullInit ? "true" : "false");
     1030        return 0;
     1031}
     1032/*************************************************************************
     1033 * IsUserAdmin                                  [NT 4.0:SHELL32.680]
    10321034 *
    10331035 */
    10341036HRESULT WINAPI IsUserAdmin(void)
    1035 {       FIXME("stub\n");
    1036         return TRUE;
    1037 }
    1038 /*************************************************************************
    1039  * StrRetToStrN                                 [SHELL32.96]
     1037{       FIXME("stub\n");
     1038        return TRUE;
     1039}
     1040/*************************************************************************
     1041 * StrRetToStrN                                 [SHELL32.96]
    10401042 *
    10411043 * converts a STRRET to a normal string
    … …  
    10461048HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
    10471049{
    1048         return StrRetToStrNA(dest, len, src, pidl);
     1050        return StrRetToStrNA(dest, len, src, pidl);
    10491051}
    10501052
    10511053HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    10521054{
    1053         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    1054 
    1055         switch (src->uType)
    1056         {
    1057           case STRRET_WSTR:
    1058             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
    1059             SHFree(src->u.pOleStr);
    1060             break;
    1061 
    1062           case STRRET_CSTRA:
    1063             lstrcpynA((LPSTR)dest, src->u.cStr, len);
    1064             break;
    1065 
    1066           case STRRET_OFFSETA:
    1067             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
    1068             break;
    1069 
    1070           default:
    1071             FIXME("unknown type!\n");
    1072             if (len)
    1073             {
    1074               *(LPSTR)dest = '\0';
    1075             }
    1076             return(FALSE);
    1077         }
    1078         return S_OK;
     1055        TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
     1056
     1057        switch (src->uType)
     1058        {
     1059          case STRRET_WSTR:
     1060            WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
     1061            SHFree(src->u.pOleStr);
     1062            break;
     1063
     1064          case STRRET_CSTRA:
     1065            lstrcpynA((LPSTR)dest, src->u.cStr, len);
     1066            break;
     1067
     1068          case STRRET_OFFSETA:
     1069            lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
     1070            break;
     1071
     1072          default:
     1073            FIXME("unknown type!\n");
     1074            if (len)
     1075            {
     1076              *(LPSTR)dest = '\0';
     1077            }
     1078            return(FALSE);
     1079        }
     1080        return S_OK;
    10791081}
    10801082
    10811083HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
    10821084{
    1083         return StrRetToStrNW(dest, len, src, pidl);
     1085        return StrRetToStrNW(dest, len, src, pidl);
    10841086}
    10851087
    10861088HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    10871089{
    1088         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    1089 
    1090         switch (src->uType)
    1091         {
    1092           case STRRET_WSTR:
    1093             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
    1094             SHFree(src->u.pOleStr);
    1095             break;
    1096 
    1097           case STRRET_CSTRA:
    1098             lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
    1099             break;
    1100 
    1101           case STRRET_OFFSETA:
    1102             if (pidl)
    1103             {
    1104               lstrcpynAtoW((LPWSTR)dest, ((LPSTR)&pidl->mkid)+src->u.uOffset, len);
    1105             }
    1106             break;
    1107 
    1108           default:
    1109             FIXME("unknown type!\n");
    1110             if (len)
    1111             { *(LPSTR)dest = '\0';
    1112             }
    1113             return(FALSE);
    1114         }
    1115         return S_OK;
     1090        TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
     1091
     1092        switch (src->uType)
     1093        {
     1094          case STRRET_WSTR:
     1095            lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
     1096            SHFree(src->u.pOleStr);
     1097            break;
     1098
     1099          case STRRET_CSTRA:
     1100            lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
     1101            break;
     1102
     1103          case STRRET_OFFSETA:
     1104            if (pidl)
     1105            {
     1106              lstrcpynAtoW((LPWSTR)dest, ((LPSTR)&pidl->mkid)+src->u.uOffset, len);
     1107            }
     1108            break;
     1109
     1110          default:
     1111            FIXME("unknown type!\n");
     1112            if (len)
     1113            { *(LPSTR)dest = '\0';
     1114            }
     1115            return(FALSE);
     1116        }
     1117        return S_OK;
    11161118}
    11171119HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    11181120{
    1119         if(VERSION_OsIsUnicode())
    1120           return StrRetToStrNW (dest, len, src, pidl);
    1121         return StrRetToStrNA (dest, len, src, pidl);
    1122 }
    1123 
    1124 /*************************************************************************
    1125  * StrChrA                                      [NT 4.0:SHELL32.651]
     1121        if(VERSION_OsIsUnicode())
     1122          return StrRetToStrNW (dest, len, src, pidl);
     1123        return StrRetToStrNA (dest, len, src, pidl);
     1124}
     1125
     1126/*************************************************************************
     1127 * StrChrA                                      [NT 4.0:SHELL32.651]
    11261128 *
    11271129 */
    11281130LPSTR WINAPI StrChrA (LPSTR str, CHAR x )
    1129 {       LPSTR ptr=str;
    1130        
    1131         do
    1132         {  if (*ptr==x)
    1133            { return ptr;
    1134            }
    1135            ptr++;
    1136         } while (*ptr);
    1137         return NULL;
    1138 }
    1139 
    1140 /*************************************************************************
    1141  * StrChrW                                      [NT 4.0:SHELL32.651]
     1131{       LPSTR ptr=str;
     1132
     1133        do
     1134        {  if (*ptr==x)
     1135           { return ptr;
     1136           }
     1137           ptr++;
     1138        } while (*ptr);
     1139        return NULL;
     1140}
     1141
     1142/*************************************************************************
     1143 * StrChrW                                      [NT 4.0:SHELL32.651]
    11421144 *
    11431145 */
    11441146LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
    1145 {       LPWSTR ptr=str;
    1146        
    1147         TRACE("%s 0x%04x\n",debugstr_w(str),x);
    1148         do
    1149         {  if (*ptr==x)
    1150            { return ptr;
    1151            }
    1152            ptr++;
    1153         } while (*ptr);
    1154         return NULL;
    1155 }
    1156 
    1157 /*************************************************************************
    1158  * StrCmpNIW                                    [NT 4.0:SHELL32.*]
     1147{       LPWSTR ptr=str;
     1148
     1149        TRACE("%s 0x%04x\n",debugstr_w(str),x);
     1150        do
     1151        {  if (*ptr==x)
     1152           { return ptr;
     1153           }
     1154           ptr++;
     1155        } while (*ptr);
     1156        return NULL;
     1157}
     1158
     1159/*************************************************************************
     1160 * StrCmpNIW                                    [NT 4.0:SHELL32.*]
    11591161 *
    11601162 */
    11611163INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
    1162 {       FIXME("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
    1163         return 0;
    1164 }
    1165 
    1166 /*************************************************************************
    1167  * StrCmpNIA                                    [NT 4.0:SHELL32.*]
     1164{       FIXME("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
     1165        return 0;
     1166}
     1167
     1168/*************************************************************************
     1169 * StrCmpNIA                                    [NT 4.0:SHELL32.*]
    11681170 *
    11691171 */
    11701172INT WINAPI StrCmpNIA ( LPSTR wstr1, LPSTR wstr2, INT len)
    1171 {       FIXME("%s %s %i stub\n", wstr1,wstr2,len);
    1172         return 0;
    1173 }
    1174 
    1175 /*************************************************************************
    1176  * SHAllocShared                                [SHELL32.520]
     1173{       FIXME("%s %s %i stub\n", wstr1,wstr2,len);
     1174        return 0;
     1175}
     1176
     1177/*************************************************************************
     1178 * SHAllocShared                                [SHELL32.520]
    11771179 *
    11781180 * NOTES
    … …  
    11861188 */
    11871189HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
    1188 {       HGLOBAL hmem;
    1189         LPVOID pmem;
    1190        
    1191         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
    1192         hmem = GlobalAlloc(GMEM_FIXED, size);
    1193         if (!hmem)
    1194           return 0;
    1195        
    1196         pmem =  GlobalLock (hmem);
    1197 
    1198         if (! pmem)
    1199           return 0;
    1200        
    1201         memcpy (pmem, psrc, size);
    1202         GlobalUnlock(hmem);
    1203         return hmem;
    1204 }
    1205 /*************************************************************************
    1206  * SHLockShared                                 [SHELL32.521]
     1190{       HGLOBAL hmem;
     1191        LPVOID pmem;
     1192
     1193        TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
     1194        hmem = GlobalAlloc(GMEM_FIXED, size);
     1195        if (!hmem)
     1196          return 0;
     1197
     1198        pmem =  GlobalLock (hmem);
     1199
     1200        if (! pmem)
     1201          return 0;
     1202
     1203        memcpy (pmem, psrc, size);
     1204        GlobalUnlock(hmem);
     1205        return hmem;
     1206}
     1207/*************************************************************************
     1208 * SHLockShared                                 [SHELL32.521]
    12071209 *
    12081210 * NOTES
    … …  
    12131215 */
    12141216LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
    1215 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
    1216         return GlobalLock(hmem);
    1217 }
    1218 /*************************************************************************
    1219  * SHUnlockShared                               [SHELL32.522]
     1217{       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
     1218        return GlobalLock(hmem);
     1219}
     1220/*************************************************************************
     1221 * SHUnlockShared                               [SHELL32.522]
    12201222 *
    12211223 * NOTES
    … …  
    12231225 */
    12241226BOOL WINAPI SHUnlockShared(HANDLE pmem)
    1225 {       TRACE("handle=0x%04x\n",pmem);
    1226         return GlobalUnlock(pmem);
    1227 }
    1228 /*************************************************************************
    1229  * SHFreeShared                                 [SHELL32.523]
     1227{       TRACE("handle=0x%04x\n",pmem);
     1228        return GlobalUnlock(pmem);
     1229}
     1230/*************************************************************************
     1231 * SHFreeShared                                 [SHELL32.523]
    12301232 *
    12311233 * NOTES
    … …  
    12341236 */
    12351237HANDLE WINAPI SHFreeShared(HANDLE hmem, DWORD procID)
    1236 {       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
    1237         return GlobalFree(hmem);
    1238 }
    1239 
    1240 /*************************************************************************
    1241  * SetAppStartingCursor                         [SHELL32.99]
     1238{       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
     1239        return GlobalFree(hmem);
     1240}
     1241
     1242/*************************************************************************
     1243 * SetAppStartingCursor                         [SHELL32.99]
    12421244 *
    12431245 */
    12441246HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
    1245 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
    1246         return 0;
    1247 }
    1248 /*************************************************************************
    1249  * SHLoadOLE                                    [SHELL32.151]
     1247{       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
     1248        return 0;
     1249}
     1250/*************************************************************************
     1251 * SHLoadOLE                                    [SHELL32.151]
    12501252 *
    12511253 */
    12521254HRESULT WINAPI SHLoadOLE(DWORD u)
    1253 {       FIXME("0x%04lx stub\n",u);
    1254         return S_OK;
    1255 }
    1256 /*************************************************************************
    1257  * DriveType                                    [SHELL32.64]
     1255{       FIXME("0x%04lx stub\n",u);
     1256        return S_OK;
     1257}
     1258/*************************************************************************
     1259 * DriveType                                    [SHELL32.64]
    12581260 *
    12591261 */
    12601262HRESULT WINAPI DriveType(DWORD u)
    1261 {       FIXME("0x%04lx stub\n",u);
    1262         return 0;
    1263 }
    1264 /*************************************************************************
    1265  * SHAbortInvokeCommand                         [SHELL32.198]
     1263{       FIXME("0x%04lx stub\n",u);
     1264        return 0;
     1265}
     1266/*************************************************************************
     1267 * SHAbortInvokeCommand                         [SHELL32.198]
    12661268 *
    12671269 */
    12681270HRESULT WINAPI SHAbortInvokeCommand(void)
    1269 {       FIXME("stub\n");
    1270         return 1;
    1271 }
    1272 /*************************************************************************
    1273  * SHOutOfMemoryMessageBox                      [SHELL32.126]
     1271{       FIXME("stub\n");
     1272        return 1;
     1273}
     1274/*************************************************************************
     1275 * SHOutOfMemoryMessageBox                      [SHELL32.126]
    12741276 *
    12751277 */
    12761278HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
    1277 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
    1278         return 0;
    1279 }
    1280 /*************************************************************************
    1281  * SHFlushClipboard                             [SHELL32.121]
     1279{       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
     1280        return 0;
     1281}
     1282/*************************************************************************
     1283 * SHFlushClipboard                             [SHELL32.121]
    12821284 *
    12831285 */
    12841286HRESULT WINAPI SHFlushClipboard(void)
    1285 {       FIXME("stub\n");
    1286         return 1;
    1287 }
    1288 /*************************************************************************
    1289  * StrRChrA                                     [SHELL32.346]
     1287{       FIXME("stub\n");
     1288        return 1;
     1289}
     1290/*************************************************************************
     1291 * StrRChrA                                     [SHELL32.346]
    12901292 *
    12911293 */
    12921294LPSTR WINAPI StrRChrA(LPCSTR lpStart, LPCSTR lpEnd, DWORD wMatch)
    12931295{
    1294         if (!lpStart)
    1295             return NULL;
    1296 
    1297         /* if the end not given, search*/
    1298         if (!lpEnd)
    1299         { lpEnd=lpStart;
    1300           while (*lpEnd)
    1301             lpEnd++;
    1302         }
    1303 
    1304         for (--lpEnd;lpStart <= lpEnd; lpEnd--)
    1305             if (*lpEnd==(char)wMatch)
    1306                 return (LPSTR)lpEnd;
    1307 
    1308         return NULL;
    1309 }
    1310 /*************************************************************************
    1311  * StrRChrW                                     [SHELL32.320]
     1296        if (!lpStart)
     1297            return NULL;
     1298
     1299        /* if the end not given, search*/
     1300        if (!lpEnd)
     1301        { lpEnd=lpStart;
     1302          while (*lpEnd)
     1303            lpEnd++;
     1304        }
     1305
     1306        for (--lpEnd;lpStart <= lpEnd; lpEnd--)
     1307            if (*lpEnd==(char)wMatch)
     1308                return (LPSTR)lpEnd;
     1309
     1310        return NULL;
     1311}
     1312/*************************************************************************
     1313 * StrRChrW                                     [SHELL32.320]
    13121314 *
    13131315 */
    13141316LPWSTR WINAPI StrRChrW(LPWSTR lpStart, LPWSTR lpEnd, DWORD wMatch)
    1315 {       LPWSTR wptr=NULL;
    1316         TRACE("%s %s 0x%04x\n",debugstr_w(lpStart),debugstr_w(lpEnd), (WCHAR)wMatch );
    1317 
    1318         /* if the end not given, search*/
    1319         if (!lpEnd)
    1320         { lpEnd=lpStart;
    1321           while (*lpEnd)
    1322             lpEnd++;
    1323         }
    1324 
    1325         do
    1326         { if (*lpStart==(WCHAR)wMatch)
    1327             wptr = lpStart;
    1328           lpStart++;
    1329         } while ( lpStart<=lpEnd );
    1330         return wptr;
    1331 }
    1332 /*************************************************************************
    1333 * StrFormatByteSize                             [SHLWAPI]
     1317{       LPWSTR wptr=NULL;
     1318        TRACE("%s %s 0x%04x\n",debugstr_w(lpStart),debugstr_w(lpEnd), (WCHAR)wMatch );
     1319
     1320        /* if the end not given, search*/
     1321        if (!lpEnd)
     1322        { lpEnd=lpStart;
     1323          while (*lpEnd)
     1324            lpEnd++;
     1325        }
     1326
     1327        do
     1328        { if (*lpStart==(WCHAR)wMatch)
     1329            wptr = lpStart;
     1330          lpStart++;
     1331        } while ( lpStart<=lpEnd );
     1332        return wptr;
     1333}
     1334/*************************************************************************
     1335* StrFormatByteSize                             [SHLWAPI]
    13341336*/
    13351337LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
    1336 {       char buf[64];
    1337         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
    1338         if ( dw<1024L )
    1339         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
    1340         }
    1341         else if ( dw<1048576L)
    1342         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
    1343         }
    1344         else if ( dw < 1073741824L)
    1345         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
    1346         }
    1347         else
    1348         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
    1349         }
    1350         lstrcpynA (pszBuf, buf, cchBuf);
    1351         return pszBuf; 
     1338{       char buf[64];
     1339        TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
     1340        if ( dw<1024L )
     1341        { sprintf (buf,"%3.0f bytes", (FLOAT)dw);
     1342        }
     1343        else if ( dw<1048576L)
     1344        { sprintf (buf,"%3.2f KB", (FLOAT)dw/1024);
     1345        }
     1346        else if ( dw < 1073741824L)
     1347        { sprintf (buf,"%3.2f MB", (FLOAT)dw/1048576L);
     1348        }
     1349        else
     1350        { sprintf (buf,"%3.2f GB", (FLOAT)dw/1073741824L);
     1351        }
     1352        lstrcpynA (pszBuf, buf, cchBuf);
     1353        return pszBuf;
    13521354}
    13531355LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
    1354 {       char buf[64];
    1355         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
    1356         if ( dw<1024L )
    1357         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
    1358         }
    1359         else if ( dw<1048576L)
    1360         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
    1361         }
    1362         else if ( dw < 1073741824L)
    1363         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
    1364         }
    1365         else
    1366         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
    1367         }
    1368         lstrcpynAtoW (pszBuf, buf, cchBuf);
    1369         return pszBuf; 
    1370 }
    1371 /*************************************************************************
    1372  * SHWaitForFileToOpen                          [SHELL32.97]
     1356{       char buf[64];
     1357        TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
     1358        if ( dw<1024L )
     1359        { sprintf (buf,"%3.0f bytes", (FLOAT)dw);
     1360        }
     1361        else if ( dw<1048576L)
     1362        { sprintf (buf,"%3.2f KB", (FLOAT)dw/1024);
     1363        }
     1364        else if ( dw < 1073741824L)
     1365        { sprintf (buf,"%3.2f MB", (FLOAT)dw/1048576L);
     1366        }
     1367        else
     1368        { sprintf (buf,"%3.2f GB", (FLOAT)dw/1073741824L);
     1369        }
     1370        lstrcpynAtoW (pszBuf, buf, cchBuf);
     1371        return pszBuf;
     1372}
     1373/*************************************************************************
     1374 * SHWaitForFileToOpen                          [SHELL32.97]
    13731375 *
    13741376 */
    13751377HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
    1376 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
    1377         return 0;
    1378 }
    1379 /*************************************************************************
    1380  * Control_FillCache_RunDLL                     [SHELL32.8]
     1378{       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
     1379        return 0;
     1380}
     1381/*************************************************************************
     1382 * Control_FillCache_RunDLL                     [SHELL32.8]
    13811383 *
    13821384 */
    13831385HRESULT WINAPI Control_FillCache_RunDLL(HWND hWnd, HANDLE hModule, DWORD w, DWORD x)
    1384 {       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
    1385         return 0;
    1386 }
    1387 /*************************************************************************
    1388  * RunDLL_CallEntry16                           [SHELL32.122]
     1386{       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
     1387        return 0;
     1388}
     1389/*************************************************************************
     1390 * RunDLL_CallEntry16                           [SHELL32.122]
    13891391 * the name is propably wrong
    13901392 */
    13911393HRESULT WINAPI RunDLL_CallEntry16(DWORD v, DWORD w, DWORD x, DWORD y, DWORD z)
    1392 {       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
    1393         return 0;
     1394{       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
     1395        return 0;
    13941396}
    13951397
    13961398/************************************************************************
    1397  *      shell32_654                             [SHELL32.654]
     1399 *      shell32_654                             [SHELL32.654]
    13981400 *
    13991401 * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
    … …  
    14031405 */
    14041406HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
    1405 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
    1406         return 0;
     1407{       FIXME("0x%08lx 0x%08lx stub\n",x,y);
     1408        return 0;
    14071409}
    14081410
    14091411/************************************************************************
    1410  *      RLBuildListOfPaths                      [SHELL32.146]
     1412 *      RLBuildListOfPaths                      [SHELL32.146]
    14111413 *
    14121414 * NOTES
    … …  
    14141416 */
    14151417DWORD WINAPI RLBuildListOfPaths (void)
    1416 {       FIXME("stub\n");
    1417         return 0;
     1418{       FIXME("stub\n");
     1419        return 0;
    14181420}
    14191421/************************************************************************
    1420  *      StrToOleStr                     [SHELL32.163]
     1422 *      StrToOleStr                     [SHELL32.163]
    14211423 *
    14221424 */
    14231425int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
    14241426{
    1425         TRACE("%p %p(%s)\n",
    1426         lpWideCharStr, lpMultiByteString, lpMultiByteString);
    1427 
    1428         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
     1427        TRACE("%p %p(%s)\n",
     1428        lpWideCharStr, lpMultiByteString, lpMultiByteString);
     1429
     1430        return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
    14291431
    14301432}
    14311433int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
    14321434{
    1433         TRACE("%p %p(%s)\n",
    1434         lpWideCharStr, lpWString, debugstr_w(lpWString));
    1435 
    1436         if (lstrcpyW (lpWideCharStr, lpWString ))
    1437         { return lstrlenW (lpWideCharStr);
    1438         }
    1439         return 0;
     1435        TRACE("%p %p(%s)\n",
     1436        lpWideCharStr, lpWString, debugstr_w(lpWString));
     1437
     1438        if (lstrcpyW (lpWideCharStr, lpWString ))
     1439        { return lstrlenW (lpWideCharStr);
     1440        }
     1441        return 0;
    14401442}
    14411443
    14421444BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
    14431445{
    1444         if (VERSION_OsIsUnicode())
    1445           return StrToOleStrW (lpWideCharStr, (LPCWSTR)lpString);
    1446         return StrToOleStrA (lpWideCharStr, (LPCSTR)lpString);
     1446        if (VERSION_OsIsUnicode())
     1447          return StrToOleStrW (lpWideCharStr, (LPCWSTR)lpString);
     1448        return StrToOleStrA (lpWideCharStr, (LPCSTR)lpString);
    14471449}
    14481450
    14491451/************************************************************************
    1450  *      SHValidateUNC                           [SHELL32.173]
     1452 *      SHValidateUNC                           [SHELL32.173]
    14511453 *
    14521454 */
    14531455HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
    14541456{
    1455         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
    1456         return 0;
     1457        FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
     1458        return 0;
    14571459}
    14581460
    14591461/************************************************************************
    1460  *      DoEnvironmentSubstW                     [SHELL32.53]
     1462 *      DoEnvironmentSubstW                     [SHELL32.53]
    14611463 *
    14621464 */
    14631465HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
    14641466{
    1465         FIXME("%p(%s) %p(%s) stub\n", x, x, y, y);
    1466         return 0;
     1467        FIXME("%p(%s) %p(%s) stub\n", x, x, y, y);
     1468        return 0;
    14671469}
    14681470
    14691471HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
    14701472{
    1471         FIXME("%p(%s) %p(%s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
    1472         return 0;
     1473        FIXME("%p(%s) %p(%s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
     1474        return 0;
    14731475}
    14741476
    14751477HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
    14761478{
    1477         if (VERSION_OsIsUnicode())
    1478           return DoEnvironmentSubstW((LPWSTR)x, (LPWSTR)y);
    1479         return DoEnvironmentSubstA((LPSTR)x, (LPSTR)y);
     1479        if (VERSION_OsIsUnicode())
     1480          return DoEnvironmentSubstW((LPWSTR)x, (LPWSTR)y);
     1481        return DoEnvironmentSubstA((LPSTR)x, (LPSTR)y);
    14801482}
    14811483
Note: See TracChangeset for help on using the changeset viewer.