git.oblomov.eu Git - wine/blob - dlls/shell32/shellord.c

   1 /*
   2  * The parameters of many functions changes between different OS versions
   3  * (NT uses Unicode strings, 95 uses ASCII strings)
   4  *
   5  * Copyright 1997 Marcus Meissner
   6  *           1998 Jürgen Schmied
   7  */
   8 #include <string.h>
   9 #include <stdio.h>
  10 #include "winerror.h"
  11 #include "winreg.h"
  12 #include "debugtools.h"
  13 #include "winnls.h"
  14 #include "winversion.h"
  15 #include "heap.h"
  16 #include "crtdll.h"
  17
  18 #include "shellapi.h"
  19 #include "shlobj.h"
  20 #include "shell32_main.h"
  21 #include "wine/undocshell.h"
  22 #include "shpolicy.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(shell);
  25
  26 /*************************************************************************
  27  * ParseField                                   [SHELL32.58]
  28  *
  29  * copys a field from a ',' delimited string
  30  *
  31  * first field is nField = 1
  32  */
  33 DWORD WINAPI ParseFieldA(LPCSTR src, DWORD nField, LPSTR dst, DWORD len)
  34 {
  35         WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,nField,dst,len);
  36
  37         if (!src || !src[0] || !dst || !len)
  38           return 0;
  39
  40         /* skip n fields delimited by ',' */
  41         while (nField > 1)
  42         {
  43           if (*src=='\0') return FALSE;
  44           if (*(src++)==',') nField--;
  45         }
  46
  47         /* copy part till the next ',' to dst */
  48         while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
  49
  50         /* finalize the string */
  51         *dst=0x0;
  52
  53         return TRUE;
  54 }
  55
  56 /*************************************************************************
  57  * PickIconDlg                                  [SHELL32.62]
  58  *
  59  */
  60 DWORD WINAPI PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
  61 {       FIXME("(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
  62         return 0xffffffff;
  63 }
  64
  65 /*************************************************************************
  66  * GetFileNameFromBrowse                        [SHELL32.63]
  67  *
  68  */
  69 DWORD WINAPI GetFileNameFromBrowse(HWND howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd)
  70 {       FIXME("(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
  71             howner,targetbuf,len,x,suffix,y,cmd);
  72     /* puts up a Open Dialog and requests input into targetbuf */
  73     /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
  74     lstrcpyA(targetbuf,"x:\\dummy.exe");
  75     return 1;
  76 }
  77
  78 /*************************************************************************
  79  * SHGetSettings                                [SHELL32.68]
  80  *
  81  * NOTES
  82  *  the registry path are for win98 (tested)
  83  *  and possibly are the same in nt40
  84  */
  85 void WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask, DWORD dwx)
  86 {
  87         HKEY    hKey;
  88         DWORD   dwData;
  89         DWORD   dwDataSize = sizeof (DWORD);
  90
  91         TRACE("(%p 0x%08lx 0x%08lx)\n",lpsfs,dwMask, dwx);
  92
  93         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
  94                                  0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
  95           return;
  96
  97         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
  98           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
  99
 100         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 101           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
 102
 103         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 104           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
 105
 106         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 107           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
 108
 109         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 110           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
 111
 112         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 113           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
 114
 115         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 116         { if (dwData == 0)
 117           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 118             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 119           }
 120           else if (dwData == 1)
 121           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
 122             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 123           }
 124           else if (dwData == 2)
 125           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 126             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
 127           }
 128         }
 129         RegCloseKey (hKey);
 130
 131         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
 132 }
 133
 134 /*************************************************************************
 135  * SHShellFolderView_Message                    [SHELL32.73]
 136  *
 137  * PARAMETERS
 138  *  hwndCabinet defines the explorer cabinet window that contains the
 139  *              shellview you need to communicate with
 140  *  uMsg        identifying the SFVM enum to perform
 141  *  lParam
 142  *
 143  * NOTES
 144  *  Message SFVM_REARRANGE = 1
 145  *    This message gets sent when a column gets clicked to instruct the
 146  *    shell view to re-sort the item list. lParam identifies the column
 147  *    that was clicked.
 148  */
 149 int WINAPI SHShellFolderView_Message(HWND hwndCabinet,UINT uMsg,LPARAM lParam)
 150 { FIXME("%04x %08ux %08lx stub\n",hwndCabinet,uMsg,lParam);
 151   return 0;
 152 }
 153
 154 /*************************************************************************
 155  * OleStrToStrN                                 [SHELL32.78]
 156  */
 157 BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
 158 {
 159         TRACE("(%p, %x, %s, %x)\n", lpStr, nStr, debugstr_wn(lpOle,nOle), nOle);
 160         return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
 161 }
 162
 163 BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
 164 {
 165         TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle);
 166
 167         if (lstrcpynW ( lpwStr, lpOle, nwStr))
 168         { return lstrlenW (lpwStr);
 169         }
 170         return 0;
 171 }
 172
 173 BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
 174 {
 175         if (VERSION_OsIsUnicode())
 176           return OleStrToStrNW (lpOut, nOut, lpIn, nIn);
 177         return OleStrToStrNA (lpOut, nOut, lpIn, nIn);
 178 }
 179
 180 /*************************************************************************
 181  * StrToOleStrN                                 [SHELL32.79]
 182  *  lpMulti, nMulti, nWide [IN]
 183  *  lpWide [OUT]
 184  */
 185 BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
 186 {
 187         TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_an(lpStrA,nStr), nStr);
 188         return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
 189 }
 190 BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
 191 {
 192         TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr);
 193
 194         if (lstrcpynW (lpWide, lpStrW, nWide))
 195         { return lstrlenW (lpWide);
 196         }
 197         return 0;
 198 }
 199
 200 BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
 201 {
 202         if (VERSION_OsIsUnicode())
 203           return StrToOleStrNW (lpWide, nWide, lpStr, nStr);
 204         return StrToOleStrNA (lpWide, nWide, lpStr, nStr);
 205 }
 206
 207 /*************************************************************************
 208  * RegisterShellHook                            [SHELL32.181]
 209  *
 210  * PARAMS
 211  *      hwnd [I]  window handle
 212  *      y    [I]  flag ????
 213  *
 214  * NOTES
 215  *     exported by ordinal
 216  */
 217 void WINAPI RegisterShellHook(HWND hwnd, DWORD y) {
 218     FIXME("(0x%08x,0x%08lx):stub.\n",hwnd,y);
 219 }
 220 /*************************************************************************
 221  * ShellMessageBoxW                             [SHELL32.182]
 222  *
 223  * Format and output errormessage.
 224  *
 225  * idText       resource ID of title or LPSTR
 226  * idTitle      resource ID of title or LPSTR
 227  *
 228  * NOTES
 229  *     exported by ordinal
 230  */
 231 INT __cdecl
 232 ShellMessageBoxW(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 233 {       WCHAR   szText[100],szTitle[100],szTemp[256];
 234         LPWSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 235         LPVOID  args = &arglist;
 236
 237         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",(DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 238
 239         if (!HIWORD (idTitle))
 240           LoadStringW(hmod,idTitle,pszTitle,100);
 241         else
 242           pszTitle = (LPWSTR)idTitle;
 243
 244         if (! HIWORD (idText))
 245           LoadStringW(hmod,idText,pszText,100);
 246         else
 247           pszText = (LPWSTR)idText;
 248
 249         FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,szText,0,0,szTemp,256,args);
 250         return MessageBoxW(hwnd,szTemp,szTitle,uType);
 251 }
 252
 253 /*************************************************************************
 254  * ShellMessageBoxA                             [SHELL32.183]
 255  */
 256 INT __cdecl
 257 ShellMessageBoxA(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 258 {       char    szText[100],szTitle[100],szTemp[256];
 259         LPSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 260         LPVOID  args = &arglist;
 261
 262         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n", (DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 263
 264         if (!HIWORD (idTitle))
 265           LoadStringA(hmod,idTitle,pszTitle,100);
 266         else
 267           pszTitle = (LPSTR)idTitle;
 268
 269         if (! HIWORD (idText))
 270           LoadStringA(hmod,idText,pszText,100);
 271         else
 272           pszText = (LPSTR)idText;
 273
 274         FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,pszText,0,0,szTemp,256,args);
 275         return MessageBoxA(hwnd,szTemp,pszTitle,uType);
 276 }
 277
 278 /*************************************************************************
 279  * SHRestricted                         [SHELL32.100]
 280  *
 281  * walks through policy table, queries <app> key, <type> value, returns
 282  * queried (DWORD) value, and caches it between called to SHInitRestricted
 283  * to prevent unnecessary registry access.
 284  *
 285  * NOTES
 286  *     exported by ordinal
 287  *
 288  * REFERENCES:
 289  *     MS System Policy Editor
 290  *     98Lite 2.0 (which uses many of these policy keys) http://www.98lite.net/
 291  *     "The Windows 95 Registry", by John Woram, 1996 MIS: Press
 292  */
 293 DWORD WINAPI SHRestricted (DWORD pol) {
 294         char regstr[256];
 295         HKEY    xhkey;
 296         DWORD   retval, polidx, i, datsize = 4;
 297
 298         TRACE("(%08lx)\n",pol);
 299
 300         polidx = -1;
 301
 302         /* scan to see if we know this policy ID */
 303         for (i = 0; i < SHELL_MAX_POLICIES; i++)
 304         {
 305              if (pol == sh32_policy_table[i].polflags)
 306              {
 307                  polidx = i;
 308                  break;
 309              }
 310         }
 311
 312         if (polidx == -1)
 313         {
 314             /* we don't know this policy, return 0 */
 315             TRACE("unknown policy: (%08lx)\n", pol);
 316                 return 0;
 317         }
 318
 319         /* we have a known policy */
 320         lstrcpyA(regstr, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\");
 321         lstrcatA(regstr, sh32_policy_table[polidx].appstr);
 322
 323         /* first check if this policy has been cached, return it if so */
 324         if (sh32_policy_table[polidx].cache != SHELL_NO_POLICY)
 325         {
 326             return sh32_policy_table[polidx].cache;
 327         }
 328
 329         /* return 0 and don't set the cache if any registry errors occur */
 330         retval = 0;
 331         if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
 332         {
 333             if (RegQueryValueExA(xhkey, sh32_policy_table[polidx].keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
 334             {
 335                 sh32_policy_table[polidx].cache = retval;
 336             }
 337
 338         RegCloseKey(xhkey);
 339 }
 340
 341         return retval;
 342 }
 343
 344 /*************************************************************************
 345  *      SHInitRestricted                         [SHELL32.244]
 346  *
 347  * Win98+ by-ordinal only routine called by Explorer and MSIE 4 and 5.
 348  * Inits the policy cache used by SHRestricted to avoid excess
 349  * registry access.
 350  *
 351  * INPUTS
 352  * Two inputs: one is a string or NULL.  If non-NULL the pointer
 353  * should point to a string containing the following exact text:
 354  * "Software\Microsoft\Windows\CurrentVersion\Policies".
 355  * The other input is unused.
 356  *
 357  * NOTES
 358  * If the input is non-NULL and does not point to a string containing
 359  * that exact text the routine will do nothing.
 360  *
 361  * If the text does match or the pointer is NULL, then the routine
 362  * will init SHRestricted()'s policy cache to all 0xffffffff and
 363  * returns 0xffffffff as well.
 364  *
 365  * I haven't yet run into anything calling this with inputs other than
 366  * (NULL, NULL), so I may have the inputs reversed.
 367  */
 368
 369 BOOL WINAPI SHInitRestricted(LPSTR inpRegKey, LPSTR parm2)
 370 {
 371      int i;
 372
 373      TRACE("(%p, %p)\n", inpRegKey, parm2);
 374
 375      /* first check - if input is non-NULL and points to the secret
 376         key string, then pass.  Otherwise return 0.
 377      */
 378
 379      if (inpRegKey != (LPSTR)NULL)
 380      {
 381          if (lstrcmpiA(inpRegKey, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies"))
 382          {
 383              /* doesn't match, fail */
 384              return 0;
 385          }
 386      }
 387
 388      /* check passed, init all policy cache entries with SHELL_NO_POLICY */
 389      for (i = 0; i < SHELL_MAX_POLICIES; i++)
 390      {
 391           sh32_policy_table[i].cache = SHELL_NO_POLICY;
 392      }
 393
 394      return SHELL_NO_POLICY;
 395 }
 396
 397 /*************************************************************************
 398  * SHFree                                       [SHELL32.195]
 399  *
 400  * NOTES
 401  *     free_ptr() - frees memory using IMalloc
 402  *     exported by ordinal
 403  */
 404 #define MEM_DEBUG 1
 405 DWORD WINAPI SHFree(LPVOID x)
 406 {
 407 #if MEM_DEBUG
 408         WORD len = *(LPWORD)((LPBYTE)x-2);
 409
 410         if ( *(LPWORD)((LPBYTE)x+len) != 0x7384)
 411           ERR("MAGIC2!\n");
 412
 413         if ( (*(LPWORD)((LPBYTE)x-4)) != 0x8271)
 414           ERR("MAGIC1!\n");
 415         else
 416           memset((LPBYTE)x-4, 0xde, len+6);
 417
 418         TRACE("%p len=%u\n",x, len);
 419
 420         x = (LPBYTE) x - 4;
 421 #else
 422         TRACE("%p\n",x);
 423 #endif
 424         return HeapFree(GetProcessHeap(), 0, x);
 425 }
 426
 427 /*************************************************************************
 428  * SHAlloc                                      [SHELL32.196]
 429  *
 430  * NOTES
 431  *     void *task_alloc(DWORD len), uses SHMalloc allocator
 432  *     exported by ordinal
 433  */
 434 LPVOID WINAPI SHAlloc(DWORD len)
 435 {
 436         LPBYTE ret;
 437
 438 #if MEM_DEBUG
 439         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
 440 #else
 441         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
 442 #endif
 443
 444 #if MEM_DEBUG
 445         *(LPWORD)(ret) = 0x8271;
 446         *(LPWORD)(ret+2) = (WORD)len;
 447         *(LPWORD)(ret+4+len) = 0x7384;
 448         ret += 4;
 449         memset(ret, 0xdf, len);
 450 #endif
 451         TRACE("%lu bytes at %p\n",len, ret);
 452         return (LPVOID)ret;
 453 }
 454
 455 /*************************************************************************
 456  * SHRegisterDragDrop                           [SHELL32.86]
 457  *
 458  * NOTES
 459  *     exported by ordinal
 460  */
 461 DWORD WINAPI SHRegisterDragDrop(HWND hWnd,IDropTarget * pDropTarget)
 462 {
 463         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
 464         return     RegisterDragDrop(hWnd, pDropTarget);
 465 }
 466
 467 /*************************************************************************
 468  * SHRevokeDragDrop                             [SHELL32.87]
 469  *
 470  * NOTES
 471  *     exported by ordinal
 472  */
 473 DWORD WINAPI SHRevokeDragDrop(DWORD x) {
 474     FIXME("(0x%08lx):stub.\n",x);
 475     return 0;
 476 }
 477
 478 /*************************************************************************
 479  * SHDoDragDrop                                 [SHELL32.88]
 480  *
 481  * NOTES
 482  *     exported by ordinal
 483  */
 484 DWORD WINAPI SHDoDragDrop(DWORD u, DWORD v, DWORD w, DWORD x, DWORD y, DWORD z) {
 485     FIXME("(0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx):stub.\n",u,v,w,x,y,z);
 486     return 0;
 487 }
 488
 489 /*************************************************************************
 490  * RunFileDlg                                   [SHELL32.61]
 491  *
 492  * NOTES
 493  *     Original name: RunFileDlg (exported by ordinal)
 494  */
 495 DWORD WINAPI
 496 RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
 497             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
 498 {
 499     FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
 500            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
 501     return 0;
 502 }
 503
 504 /*************************************************************************
 505  * ExitWindowsDialog                            [SHELL32.60]
 506  *
 507  * NOTES
 508  *     exported by ordinal
 509  */
 510 void WINAPI ExitWindowsDialog (HWND hWndOwner)
 511 {
 512         TRACE("(0x%08x)\n", hWndOwner);
 513         if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
 514         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
 515         }
 516 }
 517
 518 /*************************************************************************
 519  * ArrangeWindows                               [SHELL32.184]
 520  *
 521  */
 522 DWORD WINAPI
 523 ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
 524                 DWORD dwParam4, DWORD dwParam5)
 525 {
 526     FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
 527            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
 528     return 0;
 529 }
 530
 531 /*************************************************************************
 532  * SignalFileOpen                               [SHELL32.103]
 533  *
 534  * NOTES
 535  *     exported by ordinal
 536  */
 537 DWORD WINAPI
 538 SignalFileOpen (DWORD dwParam1)
 539 {
 540     FIXME("(0x%08lx):stub.\n", dwParam1);
 541
 542     return 0;
 543 }
 544
 545 /*************************************************************************
 546  * SHAddToRecentDocs                            [SHELL32.234]
 547  *
 548  * PARAMETERS
 549  *   uFlags  [IN] SHARD_PATH or SHARD_PIDL
 550  *   pv      [IN] string or pidl, NULL clears the list
 551  *
 552  * NOTES
 553  *     exported by name
 554  */
 555 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 556 { if (SHARD_PIDL==uFlags)
 557   { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
 558         }
 559         else
 560         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
 561         }
 562   return 0;
 563 }
 564 /*************************************************************************
 565  * SHCreateShellFolderViewEx                    [SHELL32.174]
 566  *
 567  * NOTES
 568  *  see IShellFolder::CreateViewObject
 569  */
 570 HRESULT WINAPI SHCreateShellFolderViewEx(
 571   LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/
 572   LPVOID* ppv)            /*[out] IShellView pointer*/
 573 {
 574         IShellView * psf;
 575         HRESULT hRes;
 576
 577         TRACE("sf=%p pidl=%p cb=%p mode=0x%08lx parm=0x%08lx\n",
 578           psvcbi->pShellFolder, psvcbi->pidl, psvcbi->pCallBack, psvcbi->viewmode, psvcbi->dwUserParam);
 579
 580         psf = IShellView_Constructor(psvcbi->pShellFolder);
 581
 582         if (!psf)
 583           return E_OUTOFMEMORY;
 584
 585         IShellView_AddRef(psf);
 586         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
 587         IShellView_Release(psf);
 588
 589         return hRes;
 590 }
 591 /*************************************************************************
 592  *  SHWinHelp                                   [SHELL32.127]
 593  *
 594  */
 595 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
 596 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
 597         return 0;
 598 }
 599 /*************************************************************************
 600  *  SHRunControlPanel [SHELL32.161]
 601  *
 602  */
 603 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
 604 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
 605         return 0;
 606 }
 607 /*************************************************************************
 608  * ShellExecuteEx                               [SHELL32.291]
 609  *
 610  */
 611 BOOL WINAPI ShellExecuteExAW (LPVOID sei)
 612 {       if (VERSION_OsIsUnicode())
 613           return ShellExecuteExW (sei);
 614         return ShellExecuteExA (sei);
 615 }
 616 /*************************************************************************
 617  * ShellExecuteExA                              [SHELL32.292]
 618  *
 619  * placeholder in the commandline:
 620  *      %1 file
 621  *      %2 printer
 622  *      %3 driver
 623  *      %4 port
 624  *      %I adress of a global item ID (explorer switch /idlist)
 625  *      %L ??? path/url/current file ???
 626  *      %S ???
 627  *      %* all following parameters (see batfile)
 628  */
 629 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
 630 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
 631         LPSTR pos;
 632         int gap, len;
 633         STARTUPINFOA  startup;
 634         PROCESS_INFORMATION info;
 635
 636         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
 637                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
 638                 sei->lpParameters, sei->lpDirectory, sei->nShow,
 639                 (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
 640
 641         ZeroMemory(szApplicationName,MAX_PATH);
 642         if (sei->lpFile)
 643           strcpy(szApplicationName, sei->lpFile);
 644
 645         ZeroMemory(szCommandline,MAX_PATH);
 646         if (sei->lpParameters)
 647           strcpy(szCommandline, sei->lpParameters);
 648
 649         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
 650                           SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
 651                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
 652                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
 653         {
 654           FIXME("flags ignored: 0x%08lx\n", sei->fMask);
 655         }
 656
 657         /* launch a document by fileclass like 'Wordpad.Document.1' */
 658         if (sei->fMask & SEE_MASK_CLASSNAME)
 659         {
 660           /* the commandline contains 'c:\Path\wordpad.exe "%1"' */
 661           HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
 662           /* fixme: get the extension of lpFile, check if it fits to the lpClass */
 663           TRACE("SEE_MASK_CLASSNAME->'%s'\n", szCommandline);
 664         }
 665
 666         /* process the IDList */
 667         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
 668         {
 669           SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
 670           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
 671         }
 672         else
 673         {
 674           if (sei->fMask & SEE_MASK_IDLIST )
 675           {
 676             pos = strstr(szCommandline, "%I");
 677             if (pos)
 678             {
 679               HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
 680               sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
 681               SHUnlockShared(hmem);
 682
 683               gap = strlen(szPidl);
 684               len = strlen(pos)-2;
 685               memmove(pos+gap,pos+2,len);
 686               memcpy(pos,szPidl,gap);
 687
 688             }
 689           }
 690         }
 691
 692         TRACE("execute:'%s','%s'\n",szApplicationName, szCommandline);
 693
 694         strcat(szApplicationName, " ");
 695         strcat(szApplicationName, szCommandline);
 696
 697         ZeroMemory(&startup,sizeof(STARTUPINFOA));
 698         startup.cb = sizeof(STARTUPINFOA);
 699
 700         if (! CreateProcessA(NULL, szApplicationName,
 701                          NULL, NULL, FALSE, 0,
 702                          NULL, NULL, &startup, &info))
 703         {
 704           sei->hInstApp = GetLastError();
 705           return FALSE;
 706         }
 707
 708         sei->hInstApp = 33;
 709
 710         /* Give 30 seconds to the app to come up */
 711         if ( WaitForInputIdle ( info.hProcess, 30000 ) ==  0xFFFFFFFF )
 712           ERR("WaitForInputIdle failed: Error %ld\n", GetLastError() );
 713
 714         if(sei->fMask & SEE_MASK_NOCLOSEPROCESS)
 715           sei->hProcess = info.hProcess;
 716         else
 717           CloseHandle( info.hProcess );
 718         CloseHandle( info.hThread );
 719         return TRUE;
 720 }
 721 /*************************************************************************
 722  * ShellExecuteExW                              [SHELL32.293]
 723  *
 724  */
 725 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
 726 {       SHELLEXECUTEINFOA seiA;
 727         DWORD ret;
 728
 729         TRACE("%p\n", sei);
 730
 731         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
 732
 733         if (sei->lpVerb)
 734           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
 735
 736         if (sei->lpFile)
 737           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
 738
 739         if (sei->lpParameters)
 740           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
 741
 742         if (sei->lpDirectory)
 743           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
 744
 745         if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
 746           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
 747         else
 748           seiA.lpClass = NULL;
 749
 750         ret = ShellExecuteExA(&seiA);
 751
 752         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
 753         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
 754         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
 755         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
 756         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
 757
 758         return ret;
 759 }
 760
 761 static LPUNKNOWN SHELL32_IExplorerInterface=0;
 762 /*************************************************************************
 763  * SHSetInstanceExplorer                        [SHELL32.176]
 764  *
 765  * NOTES
 766  *  Sets the interface
 767  */
 768 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
 769 {       TRACE("%p\n", lpUnknown);
 770         SHELL32_IExplorerInterface = lpUnknown;
 771         return (HRESULT) lpUnknown;
 772 }
 773 /*************************************************************************
 774  * SHGetInstanceExplorer                        [SHELL32.256]
 775  *
 776  * NOTES
 777  *  gets the interface pointer of the explorer and a reference
 778  */
 779 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
 780 {       TRACE("%p\n", lpUnknown);
 781
 782         *lpUnknown = SHELL32_IExplorerInterface;
 783
 784         if (!SHELL32_IExplorerInterface)
 785           return E_FAIL;
 786
 787         IUnknown_AddRef(SHELL32_IExplorerInterface);
 788         return NOERROR;
 789 }
 790 /*************************************************************************
 791  * SHFreeUnusedLibraries                        [SHELL32.123]
 792  *
 793  * NOTES
 794  *  exported by name
 795  */
 796 HRESULT WINAPI SHFreeUnusedLibraries (void)
 797 {       FIXME("stub\n");
 798         return TRUE;
 799 }
 800 /*************************************************************************
 801  * DAD_SetDragImage                             [SHELL32.136]
 802  *
 803  * NOTES
 804  *  exported by name
 805  */
 806 HRESULT WINAPI DAD_SetDragImage (DWORD u, DWORD v)
 807 { FIXME("0x%08lx 0x%08lx stub\n",u, v);
 808   return 0;
 809 }
 810 /*************************************************************************
 811  * DAD_ShowDragImage                            [SHELL32.137]
 812  *
 813  * NOTES
 814  *  exported by name
 815  */
 816 HRESULT WINAPI DAD_ShowDragImage (DWORD u)
 817 { FIXME("0x%08lx stub\n",u);
 818   return 0;
 819 }
 820 /*************************************************************************
 821  * SHRegCloseKey                        [NT4.0:SHELL32.505]
 822  *
 823  */
 824 HRESULT WINAPI SHRegCloseKey (HKEY hkey)
 825 {       TRACE("0x%04x\n",hkey);
 826         return RegCloseKey( hkey );
 827 }
 828 /*************************************************************************
 829  * SHRegOpenKeyA                                [SHELL32.506]
 830  *
 831  */
 832 HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
 833 {
 834         TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
 835         return RegOpenKeyA(hKey, lpSubKey, phkResult);
 836 }
 837
 838 /*************************************************************************
 839  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
 840  *
 841  */
 842 HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
 843 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
 844         return RegOpenKeyW( hkey, lpszSubKey, retkey );
 845 }
 846 /*************************************************************************
 847  * SHRegQueryValueExA                           [SHELL32.509]
 848  *
 849  */
 850 HRESULT WINAPI SHRegQueryValueExA(
 851         HKEY hkey,
 852         LPSTR lpValueName,
 853         LPDWORD lpReserved,
 854         LPDWORD lpType,
 855         LPBYTE lpData,
 856         LPDWORD lpcbData)
 857 {
 858         TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 859         return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 860 }
 861 /*************************************************************************
 862  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
 863  *
 864  */
 865 HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
 866                                  LPWSTR lpszData, LPDWORD lpcbData )
 867 {       WARN("0x%04x %s %p %p semi-stub\n",
 868                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
 869         return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
 870 }
 871
 872 /*************************************************************************
 873  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
 874  *
 875  * FIXME
 876  *  if the datatype REG_EXPAND_SZ then expand the string and change
 877  *  *pdwType to REG_SZ.
 878  */
 879 HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
 880                  LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
 881 {       DWORD ret;
 882         WARN("0x%04x %s %p %p %p %p semi-stub\n",
 883                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
 884         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
 885         return ret;
 886 }
 887
 888  /* SHGetValue: Gets a value from the registry */
 889
 890 DWORD WINAPI SHGetValueA(
 891     HKEY     hkey,
 892     LPCSTR   pSubKey,
 893     LPCSTR   pValue,
 894     LPDWORD  pwType,
 895     LPVOID   pvData,
 896     LPDWORD  pbData
 897     )
 898 {
 899     FIXME("(%p),stub!\n", pSubKey);
 900
 901         return ERROR_SUCCESS;  /* return success */
 902 }
 903
 904 DWORD WINAPI SHGetValueW(
 905     HKEY     hkey,
 906     LPCWSTR  pSubKey,
 907     LPCWSTR  pValue,
 908     LPDWORD  pwType,
 909     LPVOID   pvData,
 910     LPDWORD  pbData
 911     )
 912 {
 913     FIXME("(%p),stub!\n", pSubKey);
 914
 915         return ERROR_SUCCESS;  /* return success */
 916 }
 917
 918 /* gets a user-specific registry value. */
 919
 920 LONG WINAPI SHRegGetUSValueA(
 921     LPCSTR   pSubKey,
 922     LPCSTR   pValue,
 923     LPDWORD  pwType,
 924     LPVOID   pvData,
 925     LPDWORD  pbData,
 926     BOOL     fIgnoreHKCU,
 927     LPVOID   pDefaultData,
 928     DWORD    wDefaultDataSize
 929     )
 930 {
 931     FIXME("(%p),stub!\n", pSubKey);
 932
 933         return ERROR_SUCCESS;  /* return success */
 934 }
 935
 936 LONG WINAPI SHRegGetUSValueW(
 937     LPCWSTR  pSubKey,
 938     LPCWSTR  pValue,
 939     LPDWORD  pwType,
 940     LPVOID   pvData,
 941     LPDWORD  pbData,
 942     BOOL     flagIgnoreHKCU,
 943     LPVOID   pDefaultData,
 944     DWORD    wDefaultDataSize
 945     )
 946 {
 947     FIXME("(%p),stub!\n", pSubKey);
 948
 949         return ERROR_SUCCESS;  /* return success */
 950 }
 951
 952 /*************************************************************************
 953  * SHRegDeleteKeyA and SHDeleteKeyA
 954  */
 955 HRESULT WINAPI SHRegDeleteKeyA(HKEY hkey, LPCSTR pszSubKey)
 956 {
 957         FIXME("hkey=0x%08x, %s\n", hkey, debugstr_a(pszSubKey));
 958         return 0;
 959 }
 960
 961 /*************************************************************************
 962  * SHRegDeleteKeyW and SHDeleteKeyA
 963  */
 964 HRESULT WINAPI SHRegDeleteKeyW(HKEY hkey, LPCWSTR pszSubKey)
 965 {
 966         FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
 967         return 0;
 968 }
 969 /*************************************************************************
 970  * ReadCabinetState                             [NT 4.0:SHELL32.651]
 971  *
 972  */
 973 HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
 974 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
 975         return 0;
 976 }
 977 /*************************************************************************
 978  * WriteCabinetState                            [NT 4.0:SHELL32.652]
 979  *
 980  */
 981 HRESULT WINAPI WriteCabinetState(DWORD u)
 982 {       FIXME("0x%04lx stub\n",u);
 983         return 0;
 984 }
 985 /*************************************************************************
 986  * FileIconInit                                 [SHELL32.660]
 987  *
 988  */
 989 BOOL WINAPI FileIconInit(BOOL bFullInit)
 990 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
 991         return 0;
 992 }
 993 /*************************************************************************
 994  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
 995  *
 996  */
 997 HRESULT WINAPI IsUserAdmin(void)
 998 {       FIXME("stub\n");
 999         return TRUE;
1000 }
1001 /*************************************************************************
1002  * StrRetToStrN                                 [SHELL32.96]
1003  *
1004  * converts a STRRET to a normal string
1005  *
1006  * NOTES
1007  *  the pidl is for STRRET OFFSET
1008  */
1009 HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
1010 {
1011         return StrRetToStrNA(dest, len, src, pidl);
1012 }
1013
1014 HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1015 {
1016         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
1017
1018         switch (src->uType)
1019         {
1020           case STRRET_WSTR:
1021             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
1022             SHFree(src->u.pOleStr);
1023             break;
1024
1025           case STRRET_CSTRA:
1026             lstrcpynA((LPSTR)dest, src->u.cStr, len);
1027             break;
1028
1029           case STRRET_OFFSETA:
1030             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1031             break;
1032
1033           default:
1034             FIXME("unknown type!\n");
1035             if (len)
1036             {
1037               *(LPSTR)dest = '\0';
1038             }
1039             return(FALSE);
1040         }
1041         return S_OK;
1042 }
1043
1044 HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
1045 {
1046         return StrRetToStrNW(dest, len, src, pidl);
1047 }
1048
1049 HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1050 {
1051         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
1052
1053         switch (src->uType)
1054         {
1055           case STRRET_WSTR:
1056             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
1057             SHFree(src->u.pOleStr);
1058             break;
1059
1060           case STRRET_CSTRA:
1061             lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
1062             break;
1063
1064           case STRRET_OFFSETA:
1065             if (pidl)
1066             {
1067               lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1068             }
1069             break;
1070
1071           default:
1072             FIXME("unknown type!\n");
1073             if (len)
1074             { *(LPSTR)dest = '\0';
1075             }
1076             return(FALSE);
1077         }
1078         return S_OK;
1079 }
1080 HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1081 {
1082         if(VERSION_OsIsUnicode())
1083           return StrRetToStrNW (dest, len, src, pidl);
1084         return StrRetToStrNA (dest, len, src, pidl);
1085 }
1086
1087 /*************************************************************************
1088  * StrChrW                                      [NT 4.0:SHELL32.651]
1089  *
1090  */
1091 LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
1092 {
1093         TRACE("%s 0x%04x\n",debugstr_w(str),x);
1094         return CRTDLL_wcschr(str, x);
1095 }
1096
1097 /*************************************************************************
1098  * StrCmpNIW                                    [NT 4.0:SHELL32.*]
1099  *
1100  */
1101 INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
1102 {
1103         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
1104         return CRTDLL__wcsnicmp(wstr1, wstr2, len);
1105 }
1106
1107 /*************************************************************************
1108  * SHAllocShared                                [SHELL32.520]
1109  *
1110  * NOTES
1111  *  parameter1 is return value from HeapAlloc
1112  *  parameter2 is equal to the size allocated with HeapAlloc
1113  *  parameter3 is return value from GetCurrentProcessId
1114  *
1115  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
1116  *  WM_USER+2 could be the undocumented CWM_SETPATH
1117  *  the allocated memory contains a pidl
1118  */
1119 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
1120 {       HGLOBAL hmem;
1121         LPVOID pmem;
1122
1123         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
1124         hmem = GlobalAlloc(GMEM_FIXED, size);
1125         if (!hmem)
1126           return 0;
1127
1128         pmem =  GlobalLock (hmem);
1129
1130         if (! pmem)
1131           return 0;
1132
1133         memcpy (pmem, psrc, size);
1134         GlobalUnlock(hmem);
1135         return hmem;
1136 }
1137 /*************************************************************************
1138  * SHLockShared                                 [SHELL32.521]
1139  *
1140  * NOTES
1141  *  parameter1 is return value from SHAllocShared
1142  *  parameter2 is return value from GetCurrentProcessId
1143  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
1144  *  the returnvalue seems to be a memoryadress
1145  */
1146 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
1147 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
1148         return GlobalLock(hmem);
1149 }
1150 /*************************************************************************
1151  * SHUnlockShared                               [SHELL32.522]
1152  *
1153  * NOTES
1154  *  parameter1 is return value from SHLockShared
1155  */
1156 BOOL WINAPI SHUnlockShared(HANDLE pmem)
1157 {       TRACE("handle=0x%04x\n",pmem);
1158         return GlobalUnlock(pmem);
1159 }
1160 /*************************************************************************
1161  * SHFreeShared                                 [SHELL32.523]
1162  *
1163  * NOTES
1164  *  parameter1 is return value from SHAllocShared
1165  *  parameter2 is return value from GetCurrentProcessId
1166  */
1167 HANDLE WINAPI SHFreeShared(HANDLE hmem, DWORD procID)
1168 {       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
1169         return GlobalFree(hmem);
1170 }
1171
1172 /*************************************************************************
1173  * SetAppStartingCursor                         [SHELL32.99]
1174  *
1175  */
1176 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
1177 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
1178         return 0;
1179 }
1180 /*************************************************************************
1181  * SHLoadOLE                                    [SHELL32.151]
1182  *
1183  */
1184 HRESULT WINAPI SHLoadOLE(DWORD u)
1185 {       FIXME("0x%04lx stub\n",u);
1186         return S_OK;
1187 }
1188 /*************************************************************************
1189  * DriveType                                    [SHELL32.64]
1190  *
1191  */
1192 HRESULT WINAPI DriveType(DWORD u)
1193 {       FIXME("0x%04lx stub\n",u);
1194         return 0;
1195 }
1196 /*************************************************************************
1197  * SHAbortInvokeCommand                         [SHELL32.198]
1198  *
1199  */
1200 HRESULT WINAPI SHAbortInvokeCommand(void)
1201 {       FIXME("stub\n");
1202         return 1;
1203 }
1204 /*************************************************************************
1205  * SHOutOfMemoryMessageBox                      [SHELL32.126]
1206  *
1207  */
1208 HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
1209 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1210         return 0;
1211 }
1212 /*************************************************************************
1213  * SHFlushClipboard                             [SHELL32.121]
1214  *
1215  */
1216 HRESULT WINAPI SHFlushClipboard(void)
1217 {       FIXME("stub\n");
1218         return 1;
1219 }
1220
1221 /*************************************************************************
1222 * StrFormatByteSize                             [SHLWAPI]
1223 */
1224 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
1225 {       char buf[64];
1226         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1227         if ( dw<1024L )
1228         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1229         }
1230         else if ( dw<1048576L)
1231         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1232         }
1233         else if ( dw < 1073741824L)
1234         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1235         }
1236         else
1237         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1238         }
1239         lstrcpynA (pszBuf, buf, cchBuf);
1240         return pszBuf;
1241 }
1242 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
1243 {       char buf[64];
1244         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1245         if ( dw<1024L )
1246         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1247         }
1248         else if ( dw<1048576L)
1249         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1250         }
1251         else if ( dw < 1073741824L)
1252         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1253         }
1254         else
1255         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1256         }
1257         lstrcpynAtoW (pszBuf, buf, cchBuf);
1258         return pszBuf;
1259 }
1260 /*************************************************************************
1261  * SHWaitForFileToOpen                          [SHELL32.97]
1262  *
1263  */
1264 HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
1265 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1266         return 0;
1267 }
1268 /*************************************************************************
1269  * Control_FillCache_RunDLL                     [SHELL32.8]
1270  *
1271  */
1272 HRESULT WINAPI Control_FillCache_RunDLL(HWND hWnd, HANDLE hModule, DWORD w, DWORD x)
1273 {       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
1274         return 0;
1275 }
1276 /*************************************************************************
1277  * RunDLL_CallEntry16                           [SHELL32.122]
1278  * the name is propably wrong
1279  */
1280 HRESULT WINAPI RunDLL_CallEntry16(DWORD v, DWORD w, DWORD x, DWORD y, DWORD z)
1281 {       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
1282         return 0;
1283 }
1284
1285 /************************************************************************
1286  *      shell32_654                             [SHELL32.654]
1287  *
1288  * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
1289  * second one could be a size (0x0c). The size is the same as the structure saved to
1290  * HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1291  * I'm (js) guessing: this one is just ReadCabinetState ;-)
1292  */
1293 HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
1294 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
1295         return 0;
1296 }
1297
1298 /************************************************************************
1299  *      RLBuildListOfPaths                      [SHELL32.146]
1300  *
1301  * NOTES
1302  *   builds a DPA
1303  */
1304 DWORD WINAPI RLBuildListOfPaths (void)
1305 {       FIXME("stub\n");
1306         return 0;
1307 }
1308 /************************************************************************
1309  *      StrToOleStr                     [SHELL32.163]
1310  *
1311  */
1312 int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
1313 {
1314         TRACE("(%p, %p %s)\n",
1315         lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
1316
1317         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
1318
1319 }
1320 int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
1321 {
1322         TRACE("(%p, %p %s)\n",
1323         lpWideCharStr, lpWString, debugstr_w(lpWString));
1324
1325         if (lstrcpyW (lpWideCharStr, lpWString ))
1326         { return lstrlenW (lpWideCharStr);
1327         }
1328         return 0;
1329 }
1330
1331 BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
1332 {
1333         if (VERSION_OsIsUnicode())
1334           return StrToOleStrW (lpWideCharStr, lpString);
1335         return StrToOleStrA (lpWideCharStr, lpString);
1336 }
1337
1338 /************************************************************************
1339  *      SHValidateUNC                           [SHELL32.173]
1340  *
1341  */
1342 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1343 {
1344         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1345         return 0;
1346 }
1347
1348 /************************************************************************
1349  *      DoEnvironmentSubstW                     [SHELL32.53]
1350  *
1351  */
1352 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
1353 {
1354         FIXME("(%p %s, %p %s) stub\n", x, debugstr_a(x), y, debugstr_a(y));
1355         return 0;
1356 }
1357
1358 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
1359 {
1360         FIXME("(%p %s, %p %s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
1361         return 0;
1362 }
1363
1364 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
1365 {
1366         if (VERSION_OsIsUnicode())
1367           return DoEnvironmentSubstW(x, y);
1368         return DoEnvironmentSubstA(x, y);
1369 }
1370
1371 /*************************************************************************
1372  *      shell32_243                             [SHELL32.243]
1373  *
1374  * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
1375  * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
1376  *
1377  */
1378
1379 BOOL WINAPI shell32_243(DWORD a, DWORD b)
1380 {
1381   return FALSE;
1382 }
1383