Ignore:
Timestamp:
Sep 5, 2001, 3:54:53 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellord.c

    r5618 r6650  
     1/* $Id: shellord.c,v 1.4 2001-09-05 13:46:57 bird Exp $ */
    12/*
    23 * The parameters of many functions changes between different OS versions
    34 * (NT uses Unicode strings, 95 uses ASCII strings)
    4  * 
     5 *
    56 * Copyright 1997 Marcus Meissner
    67 *           1998 Jürgen Schmied
    … …  
    2324
    2425/*************************************************************************
    25  * ParseFieldA                                  [internal]
     26 * ParseFieldA                  [internal]
    2627 *
    2728 * copys a field from a ',' delimited string
    28  * 
     29 *
    2930 * first field is nField = 1
    3031 */
    3132DWORD WINAPI ParseFieldA(
    32         LPCSTR src,
    33         DWORD nField,
    34         LPSTR dst,
    35         DWORD len)
    36 {
    37         WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,nField,dst,len);
    38 
    39         if (!src || !src[0] || !dst || !len)
    40           return 0;
    41 
    42         /* skip n fields delimited by ',' */
    43         while (nField > 1)
    44         {
    45           if (*src=='\0') return FALSE;
    46           if (*(src++)==',') nField--;
    47         }
    48 
    49         /* copy part till the next ',' to dst */
    50         while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
    51        
    52         /* finalize the string */
    53         *dst=0x0;
    54        
    55         return TRUE;
    56 }
    57 
    58 /*************************************************************************
    59  * ParseFieldW                  [internal]
     33    LPCSTR src,
     34    DWORD nField,
     35    LPSTR dst,
     36    DWORD len)
     37{
     38    WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,nField,dst,len);
     39
     40    if (!src || !src[0] || !dst || !len)
     41      return 0;
     42
     43    /* skip n fields delimited by ',' */
     44    while (nField > 1)
     45    {
     46      if (*src=='\0') return FALSE;
     47      if (*(src++)==',') nField--;
     48    }
     49
     50    /* copy part till the next ',' to dst */
     51    while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
     52
     53    /* finalize the string */
     54    *dst=0x0;
     55
     56    return TRUE;
     57}
     58
     59/*************************************************************************
     60 * ParseFieldW          [internal]
    6061 *
    6162 * copys a field from a ',' delimited string
    62  * 
     63 *
    6364 * first field is nField = 1
    6465 */
    65 DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len) 
    66 {
    67         FIXME("('%s',0x%08lx,%p,%ld) stub.\n",
    68           debugstr_w(src), nField, dst, len);
    69         return FALSE;
    70 }
    71 
    72 /*************************************************************************
    73  * ParseFieldAW                 [SHELL32.58]
    74  */
    75 DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len) 
    76 {
    77         if (SHELL_OsIsUnicode())
    78           return ParseFieldW(src, nField, dst, len);
    79         return ParseFieldA(src, nField, dst, len);
    80 }
    81 
    82 /*************************************************************************
    83  * GetFileNameFromBrowse                        [SHELL32.63]
    84  * 
     66DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
     67{
     68    FIXME("('%s',0x%08lx,%p,%ld) stub.\n",
     69      debugstr_w(src), nField, dst, len);
     70    return FALSE;
     71}
     72
     73/*************************************************************************
     74 * ParseFieldAW         [SHELL32.58]
     75 */
     76DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
     77{
     78    if (SHELL_OsIsUnicode())
     79      return ParseFieldW(src, nField, dst, len);
     80    return ParseFieldA(src, nField, dst, len);
     81}
     82
     83/*************************************************************************
     84 * GetFileNameFromBrowse            [SHELL32.63]
     85 *
    8586 */
    8687BOOL WINAPI GetFileNameFromBrowse(
    87         HWND hwndOwner,
    88         LPSTR lpstrFile,
    89         DWORD nMaxFile,
    90         LPCSTR lpstrInitialDir,
    91         LPCSTR lpstrDefExt,
    92         LPCSTR lpstrFilter,
    93         LPCSTR lpstrTitle)
    94 {
    95         FIXME("(%04x,%s,%ld,%s,%s,%s,%s):stub.\n",
    96           hwndOwner, lpstrFile, nMaxFile, lpstrInitialDir, lpstrDefExt,
    97           lpstrFilter, lpstrTitle);
     88    HWND hwndOwner,
     89    LPSTR lpstrFile,
     90    DWORD nMaxFile,
     91    LPCSTR lpstrInitialDir,
     92    LPCSTR lpstrDefExt,
     93    LPCSTR lpstrFilter,
     94    LPCSTR lpstrTitle)
     95{
     96    FIXME("(%04x,%s,%ld,%s,%s,%s,%s):stub.\n",
     97      hwndOwner, lpstrFile, nMaxFile, lpstrInitialDir, lpstrDefExt,
     98      lpstrFilter, lpstrTitle);
    9899
    99100    /* puts up a Open Dialog and requests input into targetbuf */
    … …  
    104105
    105106/*************************************************************************
    106  * SHGetSetSettings                             [SHELL32.68]
     107 * SHGetSetSettings             [SHELL32.68]
    107108 */
    108109VOID WINAPI SHGetSetSettings(DWORD x, DWORD y, DWORD z)
    109110{
    110         FIXME("0x%08lx 0x%08lx 0x%08lx\n", x, y, z);
    111 }
    112 
    113 /*************************************************************************
    114  * SHGetSettings                                [SHELL32.@]
    115  * 
     111    FIXME("0x%08lx 0x%08lx 0x%08lx\n", x, y, z);
     112}
     113
     114/*************************************************************************
     115 * SHGetSettings                [SHELL32.@]
     116 *
    116117 * NOTES
    117118 *  the registry path are for win98 (tested)
    … …  
    121122VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
    122123{
    123         HKEY    hKey;
    124         DWORD   dwData;
    125         DWORD   dwDataSize = sizeof (DWORD);
    126 
    127         TRACE("(%p 0x%08lx)\n",lpsfs,dwMask);
    128        
    129         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
    130                                 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
    131           return;
    132        
    133         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    134           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
    135 
    136         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    137           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
    138 
    139         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    140           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
    141 
    142         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    143           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
    144 
    145         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    146           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
    147 
    148         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    149           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
    150 
    151         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    152         { if (dwData == 0)
    153           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
    154             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
    155           }
    156           else if (dwData == 1)
    157           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
    158             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
    159           }
    160           else if (dwData == 2)
    161           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
    162             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
    163           }
    164         }
    165         RegCloseKey (hKey);
    166 
    167         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
    168 }
    169 
    170 /*************************************************************************
    171  * SHShellFolderView_Message                    [SHELL32.73]
     124    HKEY    hKey;
     125    DWORD   dwData;
     126    DWORD   dwDataSize = sizeof (DWORD);
     127
     128    TRACE("(%p 0x%08lx)\n",lpsfs,dwMask);
     129
     130    if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
     131                0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
     132      return;
     133
     134    if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     135      lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
     136
     137    if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     138      lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
     139
     140    if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     141      lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
     142
     143    if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     144      lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
     145
     146    if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     147      lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
     148
     149    if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     150      lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
     151
     152    if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     153    { if (dwData == 0)
     154      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
     155        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 0;
     156      }
     157      else if (dwData == 1)
     158      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
     159        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 0;
     160      }
     161      else if (dwData == 2)
     162      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
     163        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 1;
     164      }
     165    }
     166    RegCloseKey (hKey);
     167
     168    TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
     169}
     170
     171/*************************************************************************
     172 * SHShellFolderView_Message            [SHELL32.73]
    172173 *
    173174 * PARAMETERS
    174  *  hwndCabinet defines the explorer cabinet window that contains the 
     175 *  hwndCabinet defines the explorer cabinet window that contains the
    175176 *              shellview you need to communicate with
    176177 *  uMsg        identifying the SFVM enum to perform
    … …  
    184185 */
    185186int WINAPI SHShellFolderView_Message(
    186         HWND hwndCabinet,
    187         DWORD dwMessage,
    188         DWORD dwParam)
    189 {
    190         FIXME("%04x %08lx %08lx stub\n",hwndCabinet, dwMessage, dwParam);
    191         return 0;
    192 }
    193 
    194 /*************************************************************************
    195  * RegisterShellHook                            [SHELL32.181]
     187    HWND hwndCabinet,
     188    DWORD dwMessage,
     189    DWORD dwParam)
     190{
     191    FIXME("%04x %08lx %08lx stub\n",hwndCabinet, dwMessage, dwParam);
     192    return 0;
     193}
     194
     195/*************************************************************************
     196 * RegisterShellHook                [SHELL32.181]
    196197 *
    197198 * PARAMS
    198199 *      hwnd [I]  window handle
    199200 *      y    [I]  flag ????
    200  * 
     201 *
    201202 * NOTES
    202203 *     exported by ordinal
    203204 */
    204205BOOL WINAPI RegisterShellHook(
    205         HWND hWnd,
    206         DWORD dwType)
    207 {
    208         FIXME("(0x%08x,0x%08lx):stub.\n",hWnd, dwType);
    209         return TRUE;
    210 }
    211 /*************************************************************************
    212  * ShellMessageBoxW                             [SHELL32.182]
     206    HWND hWnd,
     207    DWORD dwType)
     208{
     209    FIXME("(0x%08x,0x%08lx):stub.\n",hWnd, dwType);
     210    return TRUE;
     211}
     212/*************************************************************************
     213 * ShellMessageBoxW             [SHELL32.182]
    213214 *
    214215 * Format and output errormessage.
    215216 *
    216  * idText       resource ID of title or LPSTR
    217  * idTitle      resource ID of title or LPSTR
     217 * idText   resource ID of title or LPSTR
     218 * idTitle  resource ID of title or LPSTR
    218219 *
    219220 * NOTES
    … …  
    221222 */
    222223int WINAPIV ShellMessageBoxW(
    223         HINSTANCE hInstance,
    224         HWND hWnd,
    225         LPCWSTR lpText,
    226         LPCWSTR lpCaption,
    227         UINT uType,
    228         ...)
    229 {
    230         WCHAR   szText[100],szTitle[100];
    231         LPCWSTR pszText = szText, pszTitle = szTitle, pszTemp;
    232         va_list args;
    233         int     ret;
    234 
    235         va_start(args, uType);
    236         /* wvsprintfA(buf,fmt, args); */
    237 
    238         TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
    239         (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
    240 
    241         if (!HIWORD(lpCaption))
    242           LoadStringW(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
    243         else
    244           pszTitle = lpCaption;
    245 
    246         if (!HIWORD(lpText))
    247           LoadStringW(hInstance, (DWORD)lpText, szText, sizeof(szText)/sizeof(szText[0]));
    248         else
    249           pszText = lpText;
    250 
    251         FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
    252                        pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
    253 
    254         va_end(args);
    255 
    256         ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
    257         LocalFree((HLOCAL)pszTemp);
    258         return ret;
    259 }
    260 
    261 /*************************************************************************
    262  * ShellMessageBoxA                             [SHELL32.183]
     224    HINSTANCE hInstance,
     225    HWND hWnd,
     226    LPCWSTR lpText,
     227    LPCWSTR lpCaption,
     228    UINT uType,
     229    ...)
     230{
     231    WCHAR   szText[100],szTitle[100];
     232    LPCWSTR pszText = szText, pszTitle = szTitle, pszTemp;
     233    va_list args;
     234    int ret;
     235
     236    va_start(args, uType);
     237    /* wvsprintfA(buf,fmt, args); */
     238
     239    TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
     240    (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
     241
     242    if (!HIWORD(lpCaption))
     243      LoadStringW(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
     244    else
     245      pszTitle = lpCaption;
     246
     247    if (!HIWORD(lpText))
     248      LoadStringW(hInstance, (DWORD)lpText, szText, sizeof(szText)/sizeof(szText[0]));
     249    else
     250      pszText = lpText;
     251
     252    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
     253               pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
     254
     255    va_end(args);
     256
     257    ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
     258    LocalFree((HLOCAL)pszTemp);
     259    return ret;
     260}
     261
     262/*************************************************************************
     263 * ShellMessageBoxA             [SHELL32.183]
    263264 */
    264265int WINAPIV ShellMessageBoxA(
    265         HINSTANCE hInstance,
    266         HWND hWnd,
    267         LPCSTR lpText,
    268         LPCSTR lpCaption,
    269         UINT uType,
    270         ...)
    271 {
    272         char    szText[100],szTitle[100];
    273         LPCSTR  pszText = szText, pszTitle = szTitle, pszTemp;
    274         va_list args;
    275         int     ret;
    276 
    277         va_start(args, uType);
    278         /* wvsprintfA(buf,fmt, args); */
    279 
    280         TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
    281         (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
    282 
    283         if (!HIWORD(lpCaption))
    284           LoadStringA(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle));
    285         else
    286           pszTitle = lpCaption;
    287 
    288         if (!HIWORD(lpText))
    289           LoadStringA(hInstance, (DWORD)lpText, szText, sizeof(szText));
    290         else
    291           pszText = lpText;
    292 
    293         FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
    294                        pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
    295 
    296         va_end(args);
    297 
    298         ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
    299         LocalFree((HLOCAL)pszTemp);
    300         return ret;
    301 }
    302 
    303 /*************************************************************************
    304  * SHFree                                       [SHELL32.195]
     266    HINSTANCE hInstance,
     267    HWND hWnd,
     268    LPCSTR lpText,
     269    LPCSTR lpCaption,
     270    UINT uType,
     271    ...)
     272{
     273    char    szText[100],szTitle[100];
     274    LPCSTR  pszText = szText, pszTitle = szTitle, pszTemp;
     275    va_list args;
     276    int ret;
     277
     278    va_start(args, uType);
     279    /* wvsprintfA(buf,fmt, args); */
     280
     281    TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
     282    (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
     283
     284    if (!HIWORD(lpCaption))
     285      LoadStringA(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle));
     286    else
     287      pszTitle = lpCaption;
     288
     289    if (!HIWORD(lpText))
     290      LoadStringA(hInstance, (DWORD)lpText, szText, sizeof(szText));
     291    else
     292      pszText = lpText;
     293
     294    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
     295               pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
     296
     297    va_end(args);
     298
     299    ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
     300    LocalFree((HLOCAL)pszTemp);
     301    return ret;
     302}
     303
     304/*************************************************************************
     305 * SHFree                   [SHELL32.195]
    305306 *
    306307 * NOTES
    … …  
    309310 */
    310311#define MEM_DEBUG 0
    311 void WINAPI SHFree(LPVOID x) 
     312void WINAPI SHFree(LPVOID x)
    312313{
    313314#if MEM_DEBUG
    314         WORD len = *(LPWORD)((LPBYTE)x-2);
    315 
    316         if ( *(LPWORD)((LPBYTE)x+len) != 0x7384)
    317           ERR("MAGIC2!\n");
    318 
    319         if ( (*(LPWORD)((LPBYTE)x-4)) != 0x8271)
    320           ERR("MAGIC1!\n");
    321         else
    322           memset((LPBYTE)x-4, 0xde, len+6);
    323 
    324         TRACE("%p len=%u\n",x, len);
    325 
    326         x = (LPBYTE) x - 4;
     315    WORD len = *(LPWORD)((LPBYTE)x-2);
     316
     317    if ( *(LPWORD)((LPBYTE)x+len) != 0x7384)
     318      ERR("MAGIC2!\n");
     319
     320    if ( (*(LPWORD)((LPBYTE)x-4)) != 0x8271)
     321      ERR("MAGIC1!\n");
     322    else
     323      memset((LPBYTE)x-4, 0xde, len+6);
     324
     325    TRACE("%p len=%u\n",x, len);
     326
     327    x = (LPBYTE) x - 4;
    327328#else
    328         TRACE("%p\n",x);
     329    TRACE("%p\n",x);
    329330#endif
    330         HeapFree(GetProcessHeap(), 0, x);
    331 }
    332 
    333 /*************************************************************************
    334  * SHAlloc                                      [SHELL32.196]
     331    HeapFree(GetProcessHeap(), 0, x);
     332}
     333
     334/*************************************************************************
     335 * SHAlloc                  [SHELL32.196]
    335336 *
    336337 * NOTES
    … …  
    338339 *     exported by ordinal
    339340 */
    340 LPVOID WINAPI SHAlloc(DWORD len) 
    341 {
    342         LPBYTE ret;
     341LPVOID WINAPI SHAlloc(DWORD len)
     342{
     343    LPBYTE ret;
    343344
    344345#if MEM_DEBUG
    345         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
     346    ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
    346347#else
    347         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
     348    ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
    348349#endif
    349350
    350351#if MEM_DEBUG
    351         *(LPWORD)(ret) = 0x8271;
    352         *(LPWORD)(ret+2) = (WORD)len;
    353         *(LPWORD)(ret+4+len) = 0x7384;
    354         ret += 4;
    355         memset(ret, 0xdf, len);
     352    *(LPWORD)(ret) = 0x8271;
     353    *(LPWORD)(ret+2) = (WORD)len;
     354    *(LPWORD)(ret+4+len) = 0x7384;
     355    ret += 4;
     356    memset(ret, 0xdf, len);
    356357#endif
    357         TRACE("%lu bytes at %p\n",len, ret);
    358         return (LPVOID)ret;
    359 }
    360 
    361 /*************************************************************************
    362  * SHRegisterDragDrop                           [SHELL32.86]
     358    TRACE("%lu bytes at %p\n",len, ret);
     359    return (LPVOID)ret;
     360}
     361
     362/*************************************************************************
     363 * SHRegisterDragDrop               [SHELL32.86]
    363364 *
    364365 * NOTES
    … …  
    366367 */
    367368HRESULT WINAPI SHRegisterDragDrop(
    368         HWND hWnd,
    369         LPDROPTARGET pDropTarget)
    370 {
    371         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
    372         if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
     369    HWND hWnd,
     370    LPDROPTARGET pDropTarget)
     371{
     372    FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
     373    if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
    373374        return 0;
    374375}
    375376
    376377/*************************************************************************
    377  * SHRevokeDragDrop                             [SHELL32.87]
     378 * SHRevokeDragDrop             [SHELL32.87]
    378379 *
    379380 * NOTES
    … …  
    387388
    388389/*************************************************************************
    389  * SHDoDragDrop                                 [SHELL32.88]
     390 * SHDoDragDrop                 [SHELL32.88]
    390391 *
    391392 * NOTES
    … …  
    393394 */
    394395HRESULT WINAPI SHDoDragDrop(
    395         HWND hWnd,
    396         LPDATAOBJECT lpDataObject,
    397         LPDROPSOURCE lpDropSource,
    398         DWORD dwOKEffect,
    399         LPDWORD pdwEffect)
     396    HWND hWnd,
     397    LPDATAOBJECT lpDataObject,
     398    LPDROPSOURCE lpDropSource,
     399    DWORD dwOKEffect,
     400    LPDWORD pdwEffect)
    400401{
    401402    FIXME("(0x%04x %p %p 0x%08lx %p):stub.\n",
    … …  
    405406
    406407/*************************************************************************
    407  * ArrangeWindows                               [SHELL32.184]
    408  * 
     408 * ArrangeWindows               [SHELL32.184]
     409 *
    409410 */
    410411WORD WINAPI ArrangeWindows(
    411         HWND hwndParent,
    412         DWORD dwReserved,
    413         LPCRECT lpRect,
    414         WORD cKids,
    415         CONST HWND * lpKids)
     412    HWND hwndParent,
     413    DWORD dwReserved,
     414    LPCRECT lpRect,
     415    WORD cKids,
     416    CONST HWND * lpKids)
    416417{
    417418    FIXME("(0x%08x 0x%08lx %p 0x%04x %p):stub.\n",
    418            hwndParent, dwReserved, lpRect, cKids, lpKids);
    419     return 0;
    420 }
    421 
    422 /*************************************************************************
    423  * SignalFileOpen                               [SHELL32.103]
     419       hwndParent, dwReserved, lpRect, cKids, lpKids);
     420    return 0;
     421}
     422
     423/*************************************************************************
     424 * SignalFileOpen               [SHELL32.103]
    424425 *
    425426 * NOTES
    … …  
    435436
    436437/*************************************************************************
    437  * SHAddToRecentDocs                            [SHELL32.234]
     438 * SHAddToRecentDocs                [SHELL32.234]
    438439 *
    439440 * PARAMETERS
    … …  
    444445 *     exported by name
    445446 */
    446 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)   
     447DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
    447448{ if (SHARD_PIDL==uFlags)
    448449  { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
    449         }
    450         else
    451         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
    452         }
     450    }
     451    else
     452    { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
     453    }
    453454  return 0;
    454455}
    455456/*************************************************************************
    456  * SHCreateShellFolderViewEx                    [SHELL32.174]
     457 * SHCreateShellFolderViewEx            [SHELL32.174]
    457458 *
    458459 * NOTES
    … …  
    460461 */
    461462HRESULT WINAPI SHCreateShellFolderViewEx(
    462         LPCSHELLFOLDERVIEWINFO psvcbi, /* [in] shelltemplate struct */
    463         LPSHELLVIEW* ppv)              /* [out] IShellView pointer */
    464 {
    465         IShellView * psf;
    466         HRESULT hRes;
    467        
    468         TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=0x%08lx\n",
    469           psvcbi->pshf, psvcbi->pidlFolder, psvcbi->lpfnCallback,
    470           psvcbi->uViewMode, psvcbi->dwUser);
    471 
    472         psf = IShellView_Constructor(psvcbi->pshf);
    473        
    474         if (!psf)
    475           return E_OUTOFMEMORY;
    476 
    477         IShellView_AddRef(psf);
    478         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
    479         IShellView_Release(psf);
    480 
    481         return hRes;
    482 }
    483 /*************************************************************************
    484  *  SHWinHelp                                   [SHELL32.127]
     463    LPCSHELLFOLDERVIEWINFO psvcbi, /* [in] shelltemplate struct */
     464    LPSHELLVIEW* ppv)              /* [out] IShellView pointer */
     465{
     466    IShellView * psf;
     467    HRESULT hRes;
     468
     469    TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=0x%08lx\n",
     470      psvcbi->pshf, psvcbi->pidlFolder, psvcbi->lpfnCallback,
     471      psvcbi->uViewMode, psvcbi->dwUser);
     472
     473    psf = IShellView_Constructor(psvcbi->pshf);
     474
     475    if (!psf)
     476      return E_OUTOFMEMORY;
     477
     478    IShellView_AddRef(psf);
     479    hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
     480    IShellView_Release(psf);
     481
     482    return hRes;
     483}
     484/*************************************************************************
     485 *  SHWinHelp                   [SHELL32.127]
    485486 *
    486487 */
    487488HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
    488 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
    489         return 0;
     489{   FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
     490    return 0;
    490491}
    491492/*************************************************************************
    … …  
    494495 */
    495496HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
    496 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
    497         return 0;
    498 }
    499 /*************************************************************************
    500  * ShellExecuteEx                               [SHELL32.291]
     497{   FIXME("0x%08lx 0x%08lx stub\n",x,z);
     498    return 0;
     499}
     500/*************************************************************************
     501 * ShellExecuteEx               [SHELL32.291]
    501502 *
    502503 */
    503504BOOL WINAPI ShellExecuteExAW (LPVOID sei)
    504 {       if (SHELL_OsIsUnicode())
    505           return ShellExecuteExW (sei);
    506         return ShellExecuteExA (sei);
    507 }
    508 /*************************************************************************
    509  * ShellExecuteExA                              [SHELL32.292]
     505{   if (SHELL_OsIsUnicode())
     506      return ShellExecuteExW (sei);
     507    return ShellExecuteExA (sei);
     508}
     509/*************************************************************************
     510 * ShellExecuteExA              [SHELL32.292]
    510511 *
    511512 * placeholder in the commandline:
    512  *      %1 file
    513  *      %2 printer
    514  *      %3 driver
    515  *      %4 port
    516  *      %I adress of a global item ID (explorer switch /idlist)
    517  *      %L ??? path/url/current file ???
    518  *      %S ???
    519  *      %* all following parameters (see batfile)
     513 *  %1 file
     514 *  %2 printer
     515 *  %3 driver
     516 *  %4 port
     517 *  %I adress of a global item ID (explorer switch /idlist)
     518 *  %L ??? path/url/current file ???
     519 *  %S ???
     520 *  %* all following parameters (see batfile)
    520521 */
    521522BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
    522 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
    523         LPSTR pos;
    524         int gap, len;
    525         STARTUPINFOA  startup;
    526         PROCESS_INFORMATION info;
    527                        
    528         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
    529                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
    530                 sei->lpParameters, sei->lpDirectory, sei->nShow,
    531                 (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
    532 
    533         ZeroMemory(szApplicationName,MAX_PATH);
    534         if (sei->lpFile)
    535           strcpy(szApplicationName, sei->lpFile);
    536        
    537         ZeroMemory(szCommandline,MAX_PATH);
    538         if (sei->lpParameters)
    539           strcpy(szCommandline, sei->lpParameters);
    540                        
    541         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
    542                           SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
    543                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
    544                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
    545         {
    546           FIXME("flags ignored: 0x%08lx\n", sei->fMask);
    547         }
    548        
    549         /* launch a document by fileclass like 'Wordpad.Document.1' */
    550         if (sei->fMask & SEE_MASK_CLASSNAME)
    551         {
    552           /* the commandline contains 'c:\Path\wordpad.exe "%1"' */
    553           HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
    554           /* fixme: get the extension of lpFile, check if it fits to the lpClass */
    555           TRACE("SEE_MASK_CLASSNAME->'%s'\n", szCommandline);
    556         }
    557 
    558         /* process the IDList */
    559         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
    560         {
    561           SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
    562           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
    563         }
    564         else
    565         {
    566           if (sei->fMask & SEE_MASK_IDLIST )
    567           {
    568             pos = strstr(szCommandline, "%I");
    569             if (pos)
    570             {
    571               LPVOID pv;
    572               HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
    573               pv = SHLockShared(hmem,0);
    574               sprintf(szPidl,":%p",pv );
    575               SHUnlockShared(pv);
    576            
    577               gap = strlen(szPidl);
    578               len = strlen(pos)-2;
    579               memmove(pos+gap,pos+2,len);
    580               memcpy(pos,szPidl,gap);
    581 
    582             }
    583           }
    584         }
    585 
    586         TRACE("execute:'%s','%s'\n",szApplicationName, szCommandline);
    587 
    588         strcat(szApplicationName, " ");
    589         strcat(szApplicationName, szCommandline);
    590 
    591         ZeroMemory(&startup,sizeof(STARTUPINFOA));
    592         startup.cb = sizeof(STARTUPINFOA);
    593 
    594         if (! CreateProcessA(NULL, szApplicationName,
    595                          NULL, NULL, FALSE, 0,
    596                         NULL, NULL, &startup, &info))
    597         {
    598           sei->hInstApp = GetLastError();
    599           return FALSE;
    600         }
     523{   CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
     524    LPSTR pos;
     525    int gap, len;
     526    STARTUPINFOA  startup;
     527    PROCESS_INFORMATION info;
     528
     529    WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
     530        sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
     531        sei->lpParameters, sei->lpDirectory, sei->nShow,
     532        (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
     533
     534    ZeroMemory(szApplicationName,MAX_PATH);
     535    if (sei->lpFile)
     536      strcpy(szApplicationName, sei->lpFile);
     537
     538    ZeroMemory(szCommandline,MAX_PATH);
     539    if (sei->lpParameters)
     540      strcpy(szCommandline, sei->lpParameters);
     541
     542    if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
     543              SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
     544              SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
     545              SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
     546    {
     547      FIXME("flags ignored: 0x%08lx\n", sei->fMask);
     548    }
     549
     550    /* launch a document by fileclass like 'Wordpad.Document.1' */
     551    if (sei->fMask & SEE_MASK_CLASSNAME)
     552    {
     553      /* the commandline contains 'c:\Path\wordpad.exe "%1"' */
     554      HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
     555      /* fixme: get the extension of lpFile, check if it fits to the lpClass */
     556      TRACE("SEE_MASK_CLASSNAME->'%s'\n", szCommandline);
     557    }
     558
     559    /* process the IDList */
     560    if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
     561    {
     562      SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
     563      TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
     564    }
     565    else
     566    {
     567      if (sei->fMask & SEE_MASK_IDLIST )
     568      {
     569        pos = strstr(szCommandline, "%I");
     570        if (pos)
     571        {
     572          LPVOID pv;
     573          HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
     574          pv = SHLockShared(hmem,0);
     575          sprintf(szPidl,":%p",pv );
     576          SHUnlockShared(pv);
     577
     578          gap = strlen(szPidl);
     579          len = strlen(pos)-2;
     580          memmove(pos+gap,pos+2,len);
     581          memcpy(pos,szPidl,gap);
     582
     583        }
     584      }
     585    }
     586
     587    TRACE("execute:'%s','%s'\n",szApplicationName, szCommandline);
     588
     589    strcat(szApplicationName, " ");
     590    strcat(szApplicationName, szCommandline);
     591
     592    ZeroMemory(&startup,sizeof(STARTUPINFOA));
     593    startup.cb = sizeof(STARTUPINFOA);
     594
     595    if (! CreateProcessA(NULL, szApplicationName,
     596             NULL, NULL, FALSE, 0,
     597            NULL, NULL, &startup, &info))
     598    {
     599      sei->hInstApp = GetLastError();
     600      return FALSE;
     601    }
    601602
    602603        sei->hInstApp = 33;
    603        
    604         /* Give 30 seconds to the app to come up */
    605         if ( WaitForInputIdle ( info.hProcess, 30000 ) ==  0xFFFFFFFF )
    606           ERR("WaitForInputIdle failed: Error %ld\n", GetLastError() );
    607  
    608         if(sei->fMask & SEE_MASK_NOCLOSEPROCESS)
    609           sei->hProcess = info.hProcess;         
     604
     605        /* Give 30 seconds to the app to come up */
     606    if ( WaitForInputIdle ( info.hProcess, 30000 ) ==  0xFFFFFFFF )
     607      ERR("WaitForInputIdle failed: Error %ld\n", GetLastError() );
     608
     609    if(sei->fMask & SEE_MASK_NOCLOSEPROCESS)
     610      sei->hProcess = info.hProcess;
    610611        else
    611612          CloseHandle( info.hProcess );
    612613        CloseHandle( info.hThread );
    613         return TRUE;
    614 }
    615 /*************************************************************************
    616  * ShellExecuteExW                              [SHELL32.293]
     614    return TRUE;
     615}
     616/*************************************************************************
     617 * ShellExecuteExW              [SHELL32.293]
    617618 *
    618619 */
    619620BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
    620 {       SHELLEXECUTEINFOA seiA;
    621         DWORD ret;
    622 
    623         TRACE("%p\n", sei);
    624 
    625         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
    626        
     621{   SHELLEXECUTEINFOA seiA;
     622    DWORD ret;
     623
     624    TRACE("%p\n", sei);
     625
     626    memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
     627
    627628        if (sei->lpVerb)
    628           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
     629      seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
    629630
    630631        if (sei->lpFile)
    631           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
     632      seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
    632633
    633634        if (sei->lpParameters)
    634           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
    635 
    636         if (sei->lpDirectory)
    637           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
     635      seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
     636
     637    if (sei->lpDirectory)
     638      seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
    638639
    639640        if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
    640           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
    641         else
    642           seiA.lpClass = NULL;
    643                  
    644         ret = ShellExecuteExA(&seiA);
    645 
    646         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
    647         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
    648         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
    649         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
    650         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
    651 
    652         return ret;
     641      seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
     642    else
     643      seiA.lpClass = NULL;
     644
     645    ret = ShellExecuteExA(&seiA);
     646
     647        if (seiA.lpVerb)    HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
     648    if (seiA.lpFile)    HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
     649    if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
     650    if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
     651    if (seiA.lpClass)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
     652
     653    return ret;
    653654}
    654655
    655656static LPUNKNOWN SHELL32_IExplorerInterface=0;
    656657/*************************************************************************
    657  * SHSetInstanceExplorer                        [SHELL32.176]
     658 * SHSetInstanceExplorer            [SHELL32.176]
    658659 *
    659660 * NOTES
    … …  
    661662 */
    662663HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
    663 {       TRACE("%p\n", lpUnknown);
    664         SHELL32_IExplorerInterface = lpUnknown;
    665         return (HRESULT) lpUnknown;
    666 }
    667 /*************************************************************************
    668  * SHGetInstanceExplorer                        [SHELL32.256]
     664{   TRACE("%p\n", lpUnknown);
     665    SHELL32_IExplorerInterface = lpUnknown;
     666    return (HRESULT) lpUnknown;
     667}
     668/*************************************************************************
     669 * SHGetInstanceExplorer            [SHELL32.256]
    669670 *
    670671 * NOTES
    … …  
    672673 */
    673674HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
    674 {       TRACE("%p\n", lpUnknown);
    675 
    676         *lpUnknown = SHELL32_IExplorerInterface;
    677 
    678         if (!SHELL32_IExplorerInterface)
    679           return E_FAIL;
    680 
    681         IUnknown_AddRef(SHELL32_IExplorerInterface);
    682         return NOERROR;
    683 }
    684 /*************************************************************************
    685  * SHFreeUnusedLibraries                        [SHELL32.123]
     675{   TRACE("%p\n", lpUnknown);
     676
     677    *lpUnknown = SHELL32_IExplorerInterface;
     678
     679    if (!SHELL32_IExplorerInterface)
     680      return E_FAIL;
     681
     682    IUnknown_AddRef(SHELL32_IExplorerInterface);
     683    return NOERROR;
     684}
     685/*************************************************************************
     686 * SHFreeUnusedLibraries            [SHELL32.123]
    686687 *
    687688 * NOTES
    … …  
    690691void WINAPI SHFreeUnusedLibraries (void)
    691692{
    692         FIXME("stub\n");
    693 }
    694 /*************************************************************************
    695  * DAD_SetDragImage                             [SHELL32.136]
     693    FIXME("stub\n");
     694}
     695/*************************************************************************
     696 * DAD_SetDragImage             [SHELL32.136]
    696697 *
    697698 * NOTES
    … …  
    699700 */
    700701BOOL WINAPI DAD_SetDragImage(
    701         HIMAGELIST himlTrack,
    702         LPPOINT lppt)
    703 {
    704         FIXME("%p %p stub\n",himlTrack, lppt);
     702    HIMAGELIST himlTrack,
     703    LPPOINT lppt)
     704{
     705    FIXME("%p %p stub\n",himlTrack, lppt);
    705706  return 0;
    706707}
    707708/*************************************************************************
    708  * DAD_ShowDragImage                            [SHELL32.137]
     709 * DAD_ShowDragImage                [SHELL32.137]
    709710 *
    710711 * NOTES
    … …  
    713714BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
    714715{
    715         FIXME("0x%08x stub\n",bShow);
    716         return 0;
    717 }
    718 /*************************************************************************
    719  * ReadCabinetState                             [NT 4.0:SHELL32.651]
     716    FIXME("0x%08x stub\n",bShow);
     717    return 0;
     718}
     719/*************************************************************************
     720 * ReadCabinetState             [NT 4.0:SHELL32.651]
    720721 *
    721722 */
    722723HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
    723 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
    724         return 0;
    725 }
    726 /*************************************************************************
    727  * WriteCabinetState                            [NT 4.0:SHELL32.652]
     724{   FIXME("0x%04lx 0x%04lx stub\n",u,v);
     725    return 0;
     726}
     727/*************************************************************************
     728 * WriteCabinetState                [NT 4.0:SHELL32.652]
    728729 *
    729730 */
    730731HRESULT WINAPI WriteCabinetState(DWORD u)
    731 {       FIXME("0x%04lx stub\n",u);
    732         return 0;
    733 }
    734 /*************************************************************************
    735  * FileIconInit                                 [SHELL32.660]
     732{   FIXME("0x%04lx stub\n",u);
     733    return 0;
     734}
     735/*************************************************************************
     736 * FileIconInit                 [SHELL32.660]
    736737 *
    737738 */
    738739BOOL WINAPI FileIconInit(BOOL bFullInit)
    739 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
    740         return 0;
    741 }
    742 /*************************************************************************
    743  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
     740{   FIXME("(%s)\n", bFullInit ? "true" : "false");
     741    return 0;
     742}
     743/*************************************************************************
     744 * IsUserAdmin                  [NT 4.0:SHELL32.680]
    744745 *
    745746 */
    746747HRESULT WINAPI IsUserAdmin(void)
    747 {       FIXME("stub\n");
    748         return TRUE;
    749 }
    750 
    751 /*************************************************************************
    752  * SHAllocShared                                [SHELL32.520]
     748{   FIXME("stub\n");
     749    return TRUE;
     750}
     751
     752/*************************************************************************
     753 * SHAllocShared                [SHELL32.520]
    753754 *
    754755 * NOTES
    … …  
    762763 */
    763764HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
    764 {       HGLOBAL hmem;
    765         LPVOID pmem;
    766        
    767         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
    768         hmem = GlobalAlloc(GMEM_FIXED, size);
    769         if (!hmem)
    770           return 0;
    771        
    772         pmem =  GlobalLock (hmem);
    773 
    774         if (! pmem)
    775           return 0;
    776          
    777         memcpy (pmem, psrc, size);
    778         GlobalUnlock(hmem);
    779         return hmem;
    780 }
    781 /*************************************************************************
    782  * SHLockShared                                 [SHELL32.521]
     765{   HGLOBAL hmem;
     766    LPVOID pmem;
     767
     768    TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
     769    hmem = GlobalAlloc(GMEM_FIXED, size);
     770    if (!hmem)
     771      return 0;
     772
     773    pmem =  GlobalLock (hmem);
     774
     775    if (! pmem)
     776      return 0;
     777
     778    memcpy (pmem, psrc, size);
     779    GlobalUnlock(hmem);
     780    return hmem;
     781}
     782/*************************************************************************
     783 * SHLockShared                 [SHELL32.521]
    783784 *
    784785 * NOTES
    785786 *  parameter1 is return value from SHAllocShared
    786787 *  parameter2 is return value from GetCurrentProcessId
    787  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?) 
     788 *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
    788789 *  the returnvalue seems to be a memoryadress
    789790 */
    790791LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
    791 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
    792         return GlobalLock(hmem);
    793 }
    794 /*************************************************************************
    795  * SHUnlockShared                               [SHELL32.522]
     792{   TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
     793    return GlobalLock(hmem);
     794}
     795/*************************************************************************
     796 * SHUnlockShared               [SHELL32.522]
    796797 *
    797798 * NOTES
    … …  
    800801BOOL WINAPI SHUnlockShared(LPVOID pv)
    801802{
    802         TRACE("%p\n",pv);
    803         return GlobalUnlock((HANDLE)pv);
    804 }
    805 /*************************************************************************
    806  * SHFreeShared                                 [SHELL32.523]
     803    TRACE("%p\n",pv);
     804    return GlobalUnlock((HANDLE)pv);
     805}
     806/*************************************************************************
     807 * SHFreeShared                 [SHELL32.523]
    807808 *
    808809 * NOTES
    … …  
    811812 */
    812813BOOL WINAPI SHFreeShared(
    813         HANDLE hMem,
    814         DWORD pid)
    815 {
    816         TRACE("handle=0x%04x 0x%04lx\n",hMem,pid);
    817         return GlobalFree(hMem);
    818 }
    819 
    820 /*************************************************************************
    821  * SetAppStartingCursor                         [SHELL32.99]
     814    HANDLE hMem,
     815    DWORD pid)
     816{
     817    TRACE("handle=0x%04x 0x%04lx\n",hMem,pid);
     818    return GlobalFree(hMem);
     819}
     820
     821/*************************************************************************
     822 * SetAppStartingCursor             [SHELL32.99]
    822823 */
    823824HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
    824 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
    825         return 0;
    826 }
    827 /*************************************************************************
    828  * SHLoadOLE                                    [SHELL32.151]
     825{   FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
     826    return 0;
     827}
     828/*************************************************************************
     829 * SHLoadOLE                    [SHELL32.151]
    829830 *
    830831 */
    831832HRESULT WINAPI SHLoadOLE(DWORD u)
    832 {       FIXME("0x%04lx stub\n",u);
    833         return S_OK;
    834 }
    835 /*************************************************************************
    836  * DriveType                                    [SHELL32.64]
     833{   FIXME("0x%04lx stub\n",u);
     834    return S_OK;
     835}
     836/*************************************************************************
     837 * DriveType                    [SHELL32.64]
    837838 *
    838839 */
    839840HRESULT WINAPI DriveType(DWORD u)
    840 {       FIXME("0x%04lx stub\n",u);
    841         return 0;
    842 }
    843 /*************************************************************************
    844  * SHAbortInvokeCommand                         [SHELL32.198]
     841{   FIXME("0x%04lx stub\n",u);
     842    return 0;
     843}
     844/*************************************************************************
     845 * SHAbortInvokeCommand             [SHELL32.198]
    845846 *
    846847 */
    847848HRESULT WINAPI SHAbortInvokeCommand(void)
    848 {       FIXME("stub\n");
    849         return 1;
    850 }
    851 /*************************************************************************
    852  * SHOutOfMemoryMessageBox                      [SHELL32.126]
     849{   FIXME("stub\n");
     850    return 1;
     851}
     852/*************************************************************************
     853 * SHOutOfMemoryMessageBox          [SHELL32.126]
    853854 *
    854855 */
    855856int WINAPI SHOutOfMemoryMessageBox(
    856         HWND hwndOwner,
    857         LPCSTR lpCaption,
    858         UINT uType)
    859 {
    860         FIXME("0x%04x %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
    861         return 0;
    862 }
    863 /*************************************************************************
    864  * SHFlushClipboard                             [SHELL32.121]
     857    HWND hwndOwner,
     858    LPCSTR lpCaption,
     859    UINT uType)
     860{
     861    FIXME("0x%04x %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
     862    return 0;
     863}
     864/*************************************************************************
     865 * SHFlushClipboard             [SHELL32.121]
    865866 *
    866867 */
    867868HRESULT WINAPI SHFlushClipboard(void)
    868 {       FIXME("stub\n");
    869         return 1;
    870 }
    871 
    872 /*************************************************************************
    873  * SHWaitForFileToOpen                          [SHELL32.97]
     869{   FIXME("stub\n");
     870    return 1;
     871}
     872
     873/*************************************************************************
     874 * SHWaitForFileToOpen              [SHELL32.97]
    874875 *
    875876 */
    876877BOOL WINAPI SHWaitForFileToOpen(
    877         LPCITEMIDLIST pidl,
    878         DWORD dwFlags,
    879         DWORD dwTimeout)
    880 {
    881         FIXME("%p 0x%08lx 0x%08lx stub\n", pidl, dwFlags, dwTimeout);
    882         return 0;
     878    LPCITEMIDLIST pidl,
     879    DWORD dwFlags,
     880    DWORD dwTimeout)
     881{
     882    FIXME("%p 0x%08lx 0x%08lx stub\n", pidl, dwFlags, dwTimeout);
     883    return 0;
    883884}
    884885
    885886/************************************************************************
    886  *      shell32_654                             [SHELL32.654]
     887 *  shell32_654             [SHELL32.654]
    887888 *
    888889 * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
    … …  
    892893 */
    893894HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
    894 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
    895         return 0;
     895{   FIXME("0x%08lx 0x%08lx stub\n",x,y);
     896    return 0;
    896897}
    897898
    898899/************************************************************************
    899  *      RLBuildListOfPaths                      [SHELL32.146]
     900 *  RLBuildListOfPaths          [SHELL32.146]
    900901 *
    901902 * NOTES
    … …  
    903904 */
    904905DWORD WINAPI RLBuildListOfPaths (void)
    905 {       FIXME("stub\n");
    906         return 0;
     906{   FIXME("stub\n");
     907    return 0;
    907908}
    908909/************************************************************************
    909  *      SHValidateUNC                           [SHELL32.173]
     910 *  SHValidateUNC               [SHELL32.173]
    910911 *
    911912 */
    912913HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
    913914{
    914         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
    915         return 0;
     915    FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
     916    return 0;
    916917}
    917918
    918919/************************************************************************
    919  *      DoEnvironmentSubstA                     [SHELL32.1222]
     920 *  DoEnvironmentSubstA         [SHELL32.1222]
    920921 *
    921922 */
    922923HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
    923924{
    924         FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
    925         return 0;
     925    FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
     926    return 0;
    926927}
    927928
    928929/************************************************************************
    929  *      DoEnvironmentSubstW                     [SHELL32.1223]
     930 *  DoEnvironmentSubstW         [SHELL32.1223]
    930931 *
    931932 */
    932933HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
    933934{
    934         FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
    935         return 0;
     935    FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
     936    return 0;
    936937}
    937938
    938939/************************************************************************
    939  *      DoEnvironmentSubst                      [SHELL32.53]
     940 *  DoEnvironmentSubst          [SHELL32.53]
    940941 *
    941942 */
    942943HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
    943944{
    944         if (SHELL_OsIsUnicode())
    945           return DoEnvironmentSubstW(x, y);
    946         return DoEnvironmentSubstA(x, y);
     945    if (SHELL_OsIsUnicode())
     946      return DoEnvironmentSubstW(x, y);
     947    return DoEnvironmentSubstA(x, y);
    947948}
    948949
    949950/*************************************************************************
    950951 *      shell32_243                             [SHELL32.243]
    951  * 
     952 *
    952953 * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
    953954 * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
    … …  
    955956 */
    956957
    957 BOOL WINAPI shell32_243(DWORD a, DWORD b) 
    958 { 
    959   return FALSE; 
    960 }
    961 
    962 /*************************************************************************
    963  *      SHELL32_714     [SHELL32]
     958BOOL WINAPI shell32_243(DWORD a, DWORD b)
     959{
     960  return FALSE;
     961}
     962
     963/*************************************************************************
     964 *      SHELL32_714 [SHELL32]
    964965 */
    965966DWORD WINAPI SHELL32_714(LPVOID x)
    966967{
    967         FIXME("(%s)stub\n", debugstr_w(x));
    968         return 0;
    969 }
    970 
    971 /*************************************************************************
    972  *      SHAddFromPropSheetExtArray      [SHELL32]
     968    FIXME("(%s)stub\n", debugstr_w(x));
     969    return 0;
     970}
     971
     972/*************************************************************************
     973 *      SHAddFromPropSheetExtArray  [SHELL32]
    973974 */
    974975DWORD WINAPI SHAddFromPropSheetExtArray(DWORD a, DWORD b, DWORD c)
    975976{
    976         FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
    977         return 0;
    978 }
    979 
    980 /*************************************************************************
    981  *      SHCreatePropSheetExtArray       [SHELL32]
     977    FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
     978    return 0;
     979}
     980
     981/*************************************************************************
     982 *      SHCreatePropSheetExtArray   [SHELL32]
    982983 */
    983984DWORD WINAPI SHCreatePropSheetExtArray(DWORD a, LPCSTR b, DWORD c)
    984985{
    985         FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
    986         return 0;
    987 }
    988 
    989 /*************************************************************************
    990  *      SHReplaceFromPropSheetExtArray  [SHELL]
     986    FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
     987    return 0;
     988}
     989
     990/*************************************************************************
     991 *      SHReplaceFromPropSheetExtArray  [SHELL]
    991992 */
    992993DWORD WINAPI SHReplaceFromPropSheetExtArray(DWORD a, DWORD b, DWORD c, DWORD d)
    993994{
    994         FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
    995         return 0;
    996 }
    997 
    998 /*************************************************************************
    999  *      SHDestroyPropSheetExtArray      [SHELL32]
     995    FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
     996    return 0;
     997}
     998
     999/*************************************************************************
     1000 *      SHDestroyPropSheetExtArray  [SHELL32]
    10001001 */
    10011002DWORD WINAPI SHDestroyPropSheetExtArray(DWORD a)
    10021003{
    1003         FIXME("(%08lx)stub\n", a);
    1004         return 0;
    1005 }
     1004    FIXME("(%08lx)stub\n", a);
     1005    return 0;
     1006}
Note: See TracChangeset for help on using the changeset viewer.