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

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellord.c

    r6650 r6709  
    1 /* $Id: shellord.c,v 1.4 2001-09-05 13:46:57 bird Exp $ */
    21/*
    32 * The parameters of many functions changes between different OS versions
    43 * (NT uses Unicode strings, 95 uses ASCII strings)
    5  *
     4 * 
    65 * Copyright 1997 Marcus Meissner
    76 *           1998 Jürgen Schmied
    … …  
    2423
    2524/*************************************************************************
    26  * ParseFieldA                  [internal]
     25 * ParseFieldA                                  [internal]
    2726 *
    2827 * copys a field from a ',' delimited string
    29  *
     28 * 
    3029 * first field is nField = 1
    3130 */
    3231DWORD WINAPI ParseFieldA(
    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]
     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]
    6160 *
    6261 * copys a field from a ',' delimited string
    63  *
     62 * 
    6463 * first field is nField = 1
    6564 */
    66 DWORD 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  */
    76 DWORD 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  *
     65DWORD 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 */
     75DWORD 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 * 
    8685 */
    8786BOOL WINAPI GetFileNameFromBrowse(
    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);
     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);
    9998
    10099    /* puts up a Open Dialog and requests input into targetbuf */
    … …  
    105104
    106105/*************************************************************************
    107  * SHGetSetSettings             [SHELL32.68]
     106 * SHGetSetSettings                             [SHELL32.68]
    108107 */
    109108VOID WINAPI SHGetSetSettings(DWORD x, DWORD y, DWORD z)
    110109{
    111     FIXME("0x%08lx 0x%08lx 0x%08lx\n", x, y, z);
    112 }
    113 
    114 /*************************************************************************
    115  * SHGetSettings                [SHELL32.@]
    116  *
     110        FIXME("0x%08lx 0x%08lx 0x%08lx\n", x, y, z);
     111}
     112
     113/*************************************************************************
     114 * SHGetSettings                                [SHELL32.@]
     115 * 
    117116 * NOTES
    118117 *  the registry path are for win98 (tested)
    … …  
    122121VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
    123122{
    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]
     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]
    173172 *
    174173 * PARAMETERS
    175  *  hwndCabinet defines the explorer cabinet window that contains the
     174 *  hwndCabinet defines the explorer cabinet window that contains the 
    176175 *              shellview you need to communicate with
    177176 *  uMsg        identifying the SFVM enum to perform
    … …  
    185184 */
    186185int WINAPI SHShellFolderView_Message(
    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]
     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]
    197196 *
    198197 * PARAMS
    199198 *      hwnd [I]  window handle
    200199 *      y    [I]  flag ????
    201  *
     200 * 
    202201 * NOTES
    203202 *     exported by ordinal
    204203 */
    205204BOOL WINAPI RegisterShellHook(
    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]
     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]
    214213 *
    215214 * Format and output errormessage.
    216215 *
    217  * idText   resource ID of title or LPSTR
    218  * idTitle  resource ID of title or LPSTR
     216 * idText       resource ID of title or LPSTR
     217 * idTitle      resource ID of title or LPSTR
    219218 *
    220219 * NOTES
    … …  
    222221 */
    223222int WINAPIV ShellMessageBoxW(
    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]
     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]
    264263 */
    265264int WINAPIV ShellMessageBoxA(
    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]
     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]
    306305 *
    307306 * NOTES
    … …  
    310309 */
    311310#define MEM_DEBUG 0
    312 void WINAPI SHFree(LPVOID x)
     311void WINAPI SHFree(LPVOID x) 
    313312{
    314313#if MEM_DEBUG
    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;
     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;
    328327#else
    329     TRACE("%p\n",x);
     328        TRACE("%p\n",x);
    330329#endif
    331     HeapFree(GetProcessHeap(), 0, x);
    332 }
    333 
    334 /*************************************************************************
    335  * SHAlloc                  [SHELL32.196]
     330        HeapFree(GetProcessHeap(), 0, x);
     331}
     332
     333/*************************************************************************
     334 * SHAlloc                                      [SHELL32.196]
    336335 *
    337336 * NOTES
    … …  
    339338 *     exported by ordinal
    340339 */
    341 LPVOID WINAPI SHAlloc(DWORD len)
    342 {
    343     LPBYTE ret;
     340LPVOID WINAPI SHAlloc(DWORD len) 
     341{
     342        LPBYTE ret;
    344343
    345344#if MEM_DEBUG
    346     ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
     345        ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
    347346#else
    348     ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
     347        ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
    349348#endif
    350349
    351350#if MEM_DEBUG
    352     *(LPWORD)(ret) = 0x8271;
    353     *(LPWORD)(ret+2) = (WORD)len;
    354     *(LPWORD)(ret+4+len) = 0x7384;
    355     ret += 4;
    356     memset(ret, 0xdf, len);
     351        *(LPWORD)(ret) = 0x8271;
     352        *(LPWORD)(ret+2) = (WORD)len;
     353        *(LPWORD)(ret+4+len) = 0x7384;
     354        ret += 4;
     355        memset(ret, 0xdf, len);
    357356#endif
    358     TRACE("%lu bytes at %p\n",len, ret);
    359     return (LPVOID)ret;
    360 }
    361 
    362 /*************************************************************************
    363  * SHRegisterDragDrop               [SHELL32.86]
     357        TRACE("%lu bytes at %p\n",len, ret);
     358        return (LPVOID)ret;
     359}
     360
     361/*************************************************************************
     362 * SHRegisterDragDrop                           [SHELL32.86]
    364363 *
    365364 * NOTES
    … …  
    367366 */
    368367HRESULT WINAPI SHRegisterDragDrop(
    369     HWND hWnd,
    370     LPDROPTARGET pDropTarget)
    371 {
    372     FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
    373     if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
     368        HWND hWnd,
     369        LPDROPTARGET pDropTarget)
     370{
     371        FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
     372        if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
    374373        return 0;
    375374}
    376375
    377376/*************************************************************************
    378  * SHRevokeDragDrop             [SHELL32.87]
     377 * SHRevokeDragDrop                             [SHELL32.87]
    379378 *
    380379 * NOTES
    … …  
    388387
    389388/*************************************************************************
    390  * SHDoDragDrop                 [SHELL32.88]
     389 * SHDoDragDrop                                 [SHELL32.88]
    391390 *
    392391 * NOTES
    … …  
    394393 */
    395394HRESULT WINAPI SHDoDragDrop(
    396     HWND hWnd,
    397     LPDATAOBJECT lpDataObject,
    398     LPDROPSOURCE lpDropSource,
    399     DWORD dwOKEffect,
    400     LPDWORD pdwEffect)
     395        HWND hWnd,
     396        LPDATAOBJECT lpDataObject,
     397        LPDROPSOURCE lpDropSource,
     398        DWORD dwOKEffect,
     399        LPDWORD pdwEffect)
    401400{
    402401    FIXME("(0x%04x %p %p 0x%08lx %p):stub.\n",
    … …  
    406405
    407406/*************************************************************************
    408  * ArrangeWindows               [SHELL32.184]
    409  *
     407 * ArrangeWindows                               [SHELL32.184]
     408 * 
    410409 */
    411410WORD WINAPI ArrangeWindows(
    412     HWND hwndParent,
    413     DWORD dwReserved,
    414     LPCRECT lpRect,
    415     WORD cKids,
    416     CONST HWND * lpKids)
     411        HWND hwndParent,
     412        DWORD dwReserved,
     413        LPCRECT lpRect,
     414        WORD cKids,
     415        CONST HWND * lpKids)
    417416{
    418417    FIXME("(0x%08x 0x%08lx %p 0x%04x %p):stub.\n",
    419        hwndParent, dwReserved, lpRect, cKids, lpKids);
     418           hwndParent, dwReserved, lpRect, cKids, lpKids);
    420419    return 0;
    421420}
    422421
    423422/*************************************************************************
    424  * SignalFileOpen               [SHELL32.103]
     423 * SignalFileOpen                               [SHELL32.103]
    425424 *
    426425 * NOTES
    … …  
    436435
    437436/*************************************************************************
    438  * SHAddToRecentDocs                [SHELL32.234]
     437 * SHAddToRecentDocs                            [SHELL32.234]
    439438 *
    440439 * PARAMETERS
    … …  
    445444 *     exported by name
    446445 */
    447 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
     446DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)   
    448447{ if (SHARD_PIDL==uFlags)
    449448  { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
    450     }
    451     else
    452     { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
    453     }
     449        }
     450        else
     451        { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
     452        }
    454453  return 0;
    455454}
    456455/*************************************************************************
    457  * SHCreateShellFolderViewEx            [SHELL32.174]
     456 * SHCreateShellFolderViewEx                    [SHELL32.174]
    458457 *
    459458 * NOTES
    … …  
    461460 */
    462461HRESULT WINAPI SHCreateShellFolderViewEx(
    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]
     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]
    486485 *
    487486 */
    488487HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
    489 {   FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
    490     return 0;
     488{       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
     489        return 0;
    491490}
    492491/*************************************************************************
    … …  
    495494 */
    496495HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
    497 {   FIXME("0x%08lx 0x%08lx stub\n",x,z);
    498     return 0;
    499 }
    500 /*************************************************************************
    501  * ShellExecuteEx               [SHELL32.291]
     496{       FIXME("0x%08lx 0x%08lx stub\n",x,z);
     497        return 0;
     498}
     499/*************************************************************************
     500 * ShellExecuteEx                               [SHELL32.291]
    502501 *
    503502 */
    504503BOOL WINAPI ShellExecuteExAW (LPVOID sei)
    505 {   if (SHELL_OsIsUnicode())
    506       return ShellExecuteExW (sei);
    507     return ShellExecuteExA (sei);
    508 }
    509 /*************************************************************************
    510  * ShellExecuteExA              [SHELL32.292]
     504{       if (SHELL_OsIsUnicode())
     505          return ShellExecuteExW (sei);
     506        return ShellExecuteExA (sei);
     507}
     508/*************************************************************************
     509 * ShellExecuteExA                              [SHELL32.292]
    511510 *
    512511 * placeholder in the commandline:
    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)
     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)
    521520 */
    522521BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
    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     }
     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        }
    602601
    603602        sei->hInstApp = 33;
    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;
     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;         
    611610        else
    612611          CloseHandle( info.hProcess );
    613612        CloseHandle( info.hThread );
    614     return TRUE;
    615 }
    616 /*************************************************************************
    617  * ShellExecuteExW              [SHELL32.293]
     613        return TRUE;
     614}
     615/*************************************************************************
     616 * ShellExecuteExW                              [SHELL32.293]
    618617 *
    619618 */
    620619BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
    621 {   SHELLEXECUTEINFOA seiA;
    622     DWORD ret;
    623 
    624     TRACE("%p\n", sei);
    625 
    626     memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
    627 
     620{       SHELLEXECUTEINFOA seiA;
     621        DWORD ret;
     622
     623        TRACE("%p\n", sei);
     624
     625        memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
     626       
    628627        if (sei->lpVerb)
    629       seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
     628          seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
    630629
    631630        if (sei->lpFile)
    632       seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
     631          seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
    633632
    634633        if (sei->lpParameters)
    635       seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
    636 
    637     if (sei->lpDirectory)
    638       seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
     634          seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
     635
     636        if (sei->lpDirectory)
     637          seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
    639638
    640639        if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
    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;
     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;
    654653}
    655654
    656655static LPUNKNOWN SHELL32_IExplorerInterface=0;
    657656/*************************************************************************
    658  * SHSetInstanceExplorer            [SHELL32.176]
     657 * SHSetInstanceExplorer                        [SHELL32.176]
    659658 *
    660659 * NOTES
    … …  
    662661 */
    663662HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
    664 {   TRACE("%p\n", lpUnknown);
    665     SHELL32_IExplorerInterface = lpUnknown;
    666     return (HRESULT) lpUnknown;
    667 }
    668 /*************************************************************************
    669  * SHGetInstanceExplorer            [SHELL32.256]
     663{       TRACE("%p\n", lpUnknown);
     664        SHELL32_IExplorerInterface = lpUnknown;
     665        return (HRESULT) lpUnknown;
     666}
     667/*************************************************************************
     668 * SHGetInstanceExplorer                        [SHELL32.256]
    670669 *
    671670 * NOTES
    … …  
    673672 */
    674673HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
    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]
     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]
    687686 *
    688687 * NOTES
    … …  
    691690void WINAPI SHFreeUnusedLibraries (void)
    692691{
    693     FIXME("stub\n");
    694 }
    695 /*************************************************************************
    696  * DAD_SetDragImage             [SHELL32.136]
     692        FIXME("stub\n");
     693}
     694/*************************************************************************
     695 * DAD_SetDragImage                             [SHELL32.136]
    697696 *
    698697 * NOTES
    … …  
    700699 */
    701700BOOL WINAPI DAD_SetDragImage(
    702     HIMAGELIST himlTrack,
    703     LPPOINT lppt)
    704 {
    705     FIXME("%p %p stub\n",himlTrack, lppt);
     701        HIMAGELIST himlTrack,
     702        LPPOINT lppt)
     703{
     704        FIXME("%p %p stub\n",himlTrack, lppt);
    706705  return 0;
    707706}
    708707/*************************************************************************
    709  * DAD_ShowDragImage                [SHELL32.137]
     708 * DAD_ShowDragImage                            [SHELL32.137]
    710709 *
    711710 * NOTES
    … …  
    714713BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
    715714{
    716     FIXME("0x%08x stub\n",bShow);
    717     return 0;
    718 }
    719 /*************************************************************************
    720  * ReadCabinetState             [NT 4.0:SHELL32.651]
     715        FIXME("0x%08x stub\n",bShow);
     716        return 0;
     717}
     718/*************************************************************************
     719 * ReadCabinetState                             [NT 4.0:SHELL32.651]
    721720 *
    722721 */
    723722HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
    724 {   FIXME("0x%04lx 0x%04lx stub\n",u,v);
    725     return 0;
    726 }
    727 /*************************************************************************
    728  * WriteCabinetState                [NT 4.0:SHELL32.652]
     723{       FIXME("0x%04lx 0x%04lx stub\n",u,v);
     724        return 0;
     725}
     726/*************************************************************************
     727 * WriteCabinetState                            [NT 4.0:SHELL32.652]
    729728 *
    730729 */
    731730HRESULT WINAPI WriteCabinetState(DWORD u)
    732 {   FIXME("0x%04lx stub\n",u);
    733     return 0;
    734 }
    735 /*************************************************************************
    736  * FileIconInit                 [SHELL32.660]
     731{       FIXME("0x%04lx stub\n",u);
     732        return 0;
     733}
     734/*************************************************************************
     735 * FileIconInit                                 [SHELL32.660]
    737736 *
    738737 */
    739738BOOL WINAPI FileIconInit(BOOL bFullInit)
    740 {   FIXME("(%s)\n", bFullInit ? "true" : "false");
    741     return 0;
    742 }
    743 /*************************************************************************
    744  * IsUserAdmin                  [NT 4.0:SHELL32.680]
     739{       FIXME("(%s)\n", bFullInit ? "true" : "false");
     740        return 0;
     741}
     742/*************************************************************************
     743 * IsUserAdmin                                  [NT 4.0:SHELL32.680]
    745744 *
    746745 */
    747746HRESULT WINAPI IsUserAdmin(void)
    748 {   FIXME("stub\n");
    749     return TRUE;
    750 }
    751 
    752 /*************************************************************************
    753  * SHAllocShared                [SHELL32.520]
     747{       FIXME("stub\n");
     748        return TRUE;
     749}
     750
     751/*************************************************************************
     752 * SHAllocShared                                [SHELL32.520]
    754753 *
    755754 * NOTES
    … …  
    763762 */
    764763HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
    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]
     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]
    784783 *
    785784 * NOTES
    786785 *  parameter1 is return value from SHAllocShared
    787786 *  parameter2 is return value from GetCurrentProcessId
    788  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
     787 *  the receiver of (WM_USER+2) trys to lock the HANDLE (?) 
    789788 *  the returnvalue seems to be a memoryadress
    790789 */
    791790LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
    792 {   TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
    793     return GlobalLock(hmem);
    794 }
    795 /*************************************************************************
    796  * SHUnlockShared               [SHELL32.522]
     791{       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
     792        return GlobalLock(hmem);
     793}
     794/*************************************************************************
     795 * SHUnlockShared                               [SHELL32.522]
    797796 *
    798797 * NOTES
    … …  
    801800BOOL WINAPI SHUnlockShared(LPVOID pv)
    802801{
    803     TRACE("%p\n",pv);
    804     return GlobalUnlock((HANDLE)pv);
    805 }
    806 /*************************************************************************
    807  * SHFreeShared                 [SHELL32.523]
     802        TRACE("%p\n",pv);
     803        return GlobalUnlock((HANDLE)pv);
     804}
     805/*************************************************************************
     806 * SHFreeShared                                 [SHELL32.523]
    808807 *
    809808 * NOTES
    … …  
    812811 */
    813812BOOL WINAPI SHFreeShared(
    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]
     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]
    823822 */
    824823HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
    825 {   FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
    826     return 0;
    827 }
    828 /*************************************************************************
    829  * SHLoadOLE                    [SHELL32.151]
     824{       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
     825        return 0;
     826}
     827/*************************************************************************
     828 * SHLoadOLE                                    [SHELL32.151]
    830829 *
    831830 */
    832831HRESULT WINAPI SHLoadOLE(DWORD u)
    833 {   FIXME("0x%04lx stub\n",u);
    834     return S_OK;
    835 }
    836 /*************************************************************************
    837  * DriveType                    [SHELL32.64]
     832{       FIXME("0x%04lx stub\n",u);
     833        return S_OK;
     834}
     835/*************************************************************************
     836 * DriveType                                    [SHELL32.64]
    838837 *
    839838 */
    840839HRESULT WINAPI DriveType(DWORD u)
    841 {   FIXME("0x%04lx stub\n",u);
    842     return 0;
    843 }
    844 /*************************************************************************
    845  * SHAbortInvokeCommand             [SHELL32.198]
     840{       FIXME("0x%04lx stub\n",u);
     841        return 0;
     842}
     843/*************************************************************************
     844 * SHAbortInvokeCommand                         [SHELL32.198]
    846845 *
    847846 */
    848847HRESULT WINAPI SHAbortInvokeCommand(void)
    849 {   FIXME("stub\n");
    850     return 1;
    851 }
    852 /*************************************************************************
    853  * SHOutOfMemoryMessageBox          [SHELL32.126]
     848{       FIXME("stub\n");
     849        return 1;
     850}
     851/*************************************************************************
     852 * SHOutOfMemoryMessageBox                      [SHELL32.126]
    854853 *
    855854 */
    856855int WINAPI SHOutOfMemoryMessageBox(
    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]
     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]
    866865 *
    867866 */
    868867HRESULT WINAPI SHFlushClipboard(void)
    869 {   FIXME("stub\n");
    870     return 1;
    871 }
    872 
    873 /*************************************************************************
    874  * SHWaitForFileToOpen              [SHELL32.97]
     868{       FIXME("stub\n");
     869        return 1;
     870}
     871
     872/*************************************************************************
     873 * SHWaitForFileToOpen                          [SHELL32.97]
    875874 *
    876875 */
    877876BOOL WINAPI SHWaitForFileToOpen(
    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;
     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;
    884883}
    885884
    886885/************************************************************************
    887  *  shell32_654             [SHELL32.654]
     886 *      shell32_654                             [SHELL32.654]
    888887 *
    889888 * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
    … …  
    893892 */
    894893HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
    895 {   FIXME("0x%08lx 0x%08lx stub\n",x,y);
    896     return 0;
     894{       FIXME("0x%08lx 0x%08lx stub\n",x,y);
     895        return 0;
    897896}
    898897
    899898/************************************************************************
    900  *  RLBuildListOfPaths          [SHELL32.146]
     899 *      RLBuildListOfPaths                      [SHELL32.146]
    901900 *
    902901 * NOTES
    … …  
    904903 */
    905904DWORD WINAPI RLBuildListOfPaths (void)
    906 {   FIXME("stub\n");
    907     return 0;
     905{       FIXME("stub\n");
     906        return 0;
    908907}
    909908/************************************************************************
    910  *  SHValidateUNC               [SHELL32.173]
     909 *      SHValidateUNC                           [SHELL32.173]
    911910 *
    912911 */
    913912HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
    914913{
    915     FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
    916     return 0;
     914        FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
     915        return 0;
    917916}
    918917
    919918/************************************************************************
    920  *  DoEnvironmentSubstA         [SHELL32.1222]
     919 *      DoEnvironmentSubstA                     [SHELL32.1222]
    921920 *
    922921 */
    923922HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
    924923{
    925     FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
    926     return 0;
     924        FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
     925        return 0;
    927926}
    928927
    929928/************************************************************************
    930  *  DoEnvironmentSubstW         [SHELL32.1223]
     929 *      DoEnvironmentSubstW                     [SHELL32.1223]
    931930 *
    932931 */
    933932HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
    934933{
    935     FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
    936     return 0;
     934        FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
     935        return 0;
    937936}
    938937
    939938/************************************************************************
    940  *  DoEnvironmentSubst          [SHELL32.53]
     939 *      DoEnvironmentSubst                      [SHELL32.53]
    941940 *
    942941 */
    943942HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
    944943{
    945     if (SHELL_OsIsUnicode())
    946       return DoEnvironmentSubstW(x, y);
    947     return DoEnvironmentSubstA(x, y);
     944        if (SHELL_OsIsUnicode())
     945          return DoEnvironmentSubstW(x, y);
     946        return DoEnvironmentSubstA(x, y);
    948947}
    949948
    950949/*************************************************************************
    951950 *      shell32_243                             [SHELL32.243]
    952  *
     951 * 
    953952 * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
    954953 * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
    … …  
    956955 */
    957956
    958 BOOL WINAPI shell32_243(DWORD a, DWORD b)
    959 {
    960   return FALSE;
    961 }
    962 
    963 /*************************************************************************
    964  *      SHELL32_714 [SHELL32]
     957BOOL WINAPI shell32_243(DWORD a, DWORD b) 
     958{ 
     959  return FALSE; 
     960}
     961
     962/*************************************************************************
     963 *      SHELL32_714     [SHELL32]
    965964 */
    966965DWORD WINAPI SHELL32_714(LPVOID x)
    967966{
    968     FIXME("(%s)stub\n", debugstr_w(x));
    969     return 0;
    970 }
    971 
    972 /*************************************************************************
    973  *      SHAddFromPropSheetExtArray  [SHELL32]
     967        FIXME("(%s)stub\n", debugstr_w(x));
     968        return 0;
     969}
     970
     971/*************************************************************************
     972 *      SHAddFromPropSheetExtArray      [SHELL32]
    974973 */
    975974DWORD WINAPI SHAddFromPropSheetExtArray(DWORD a, DWORD b, DWORD c)
    976975{
    977     FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
    978     return 0;
    979 }
    980 
    981 /*************************************************************************
    982  *      SHCreatePropSheetExtArray   [SHELL32]
     976        FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
     977        return 0;
     978}
     979
     980/*************************************************************************
     981 *      SHCreatePropSheetExtArray       [SHELL32]
    983982 */
    984983DWORD WINAPI SHCreatePropSheetExtArray(DWORD a, LPCSTR b, DWORD c)
    985984{
    986     FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
    987     return 0;
    988 }
    989 
    990 /*************************************************************************
    991  *      SHReplaceFromPropSheetExtArray  [SHELL]
     985        FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
     986        return 0;
     987}
     988
     989/*************************************************************************
     990 *      SHReplaceFromPropSheetExtArray  [SHELL]
    992991 */
    993992DWORD WINAPI SHReplaceFromPropSheetExtArray(DWORD a, DWORD b, DWORD c, DWORD d)
    994993{
    995     FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
    996     return 0;
    997 }
    998 
    999 /*************************************************************************
    1000  *      SHDestroyPropSheetExtArray  [SHELL32]
     994        FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
     995        return 0;
     996}
     997
     998/*************************************************************************
     999 *      SHDestroyPropSheetExtArray      [SHELL32]
    10011000 */
    10021001DWORD WINAPI SHDestroyPropSheetExtArray(DWORD a)
    10031002{
    1004     FIXME("(%08lx)stub\n", a);
    1005     return 0;
    1006 }
     1003        FIXME("(%08lx)stub\n", a);
     1004        return 0;
     1005}
Note: See TracChangeset for help on using the changeset viewer.