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  * ParseFieldA                                  [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         if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
 465         return 0;
 466 }
 467
 468 /*************************************************************************
 469  * SHRevokeDragDrop                             [SHELL32.87]
 470  *
 471  * NOTES
 472  *     exported by ordinal
 473  */
 474 DWORD WINAPI SHRevokeDragDrop(DWORD x) {
 475     FIXME("(0x%08lx):stub.\n",x);
 476     return 0;
 477 }
 478
 479 /*************************************************************************
 480  * SHDoDragDrop                                 [SHELL32.88]
 481  *
 482  * NOTES
 483  *     exported by ordinal
 484  */
 485 DWORD WINAPI SHDoDragDrop(DWORD u, DWORD v, DWORD w, DWORD x, DWORD y, DWORD z) {
 486     FIXME("(0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx):stub.\n",u,v,w,x,y,z);
 487     return 0;
 488 }
 489
 490 /*************************************************************************
 491  * RunFileDlg                                   [SHELL32.61]
 492  *
 493  * NOTES
 494  *     Original name: RunFileDlg (exported by ordinal)
 495  */
 496 DWORD WINAPI
 497 RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
 498             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
 499 {
 500     FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
 501            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
 502     return 0;
 503 }
 504
 505 /*************************************************************************
 506  * ExitWindowsDialog                            [SHELL32.60]
 507  *
 508  * NOTES
 509  *     exported by ordinal
 510  */
 511 void WINAPI ExitWindowsDialog (HWND hWndOwner)
 512 {
 513         TRACE("(0x%08x)\n", hWndOwner);
 514         if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
 515         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
 516         }
 517 }
 518
 519 /*************************************************************************
 520  * ArrangeWindows                               [SHELL32.184]
 521  *
 522  */
 523 DWORD WINAPI
 524 ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
 525                 DWORD dwParam4, DWORD dwParam5)
 526 {
 527     FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
 528            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
 529     return 0;
 530 }
 531
 532 /*************************************************************************
 533  * SignalFileOpen                               [SHELL32.103]
 534  *
 535  * NOTES
 536  *     exported by ordinal
 537  */
 538 DWORD WINAPI
 539 SignalFileOpen (DWORD dwParam1)
 540 {
 541     FIXME("(0x%08lx):stub.\n", dwParam1);
 542
 543     return 0;
 544 }
 545
 546 /*************************************************************************
 547  * SHAddToRecentDocs                            [SHELL32.234]
 548  *
 549  * PARAMETERS
 550  *   uFlags  [IN] SHARD_PATH or SHARD_PIDL
 551  *   pv      [IN] string or pidl, NULL clears the list
 552  *
 553  * NOTES
 554  *     exported by name
 555  */
 556 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 557 { if (SHARD_PIDL==uFlags)
 558   { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
 559         }
 560         else
 561         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
 562         }
 563   return 0;
 564 }
 565 /*************************************************************************
 566  * SHCreateShellFolderViewEx                    [SHELL32.174]
 567  *
 568  * NOTES
 569  *  see IShellFolder::CreateViewObject
 570  */
 571 HRESULT WINAPI SHCreateShellFolderViewEx(
 572   LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/
 573   LPVOID* ppv)            /*[out] IShellView pointer*/
 574 {
 575         IShellView * psf;
 576         HRESULT hRes;
 577
 578         TRACE("sf=%p pidl=%p cb=%p mode=0x%08lx parm=0x%08lx\n",
 579           psvcbi->pShellFolder, psvcbi->pidl, psvcbi->pCallBack, psvcbi->viewmode, psvcbi->dwUserParam);
 580
 581         psf = IShellView_Constructor(psvcbi->pShellFolder);
 582
 583         if (!psf)
 584           return E_OUTOFMEMORY;
 585
 586         IShellView_AddRef(psf);
 587         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
 588         IShellView_Release(psf);
 589
 590         return hRes;
 591 }
 592 /*************************************************************************
 593  *  SHWinHelp                                   [SHELL32.127]
 594  *
 595  */
 596 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
 597 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
 598         return 0;
 599 }
 600 /*************************************************************************
 601  *  SHRunControlPanel [SHELL32.161]
 602  *
 603  */
 604 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
 605 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
 606         return 0;
 607 }
 608 /*************************************************************************
 609  * ShellExecuteEx                               [SHELL32.291]
 610  *
 611  */
 612 BOOL WINAPI ShellExecuteExAW (LPVOID sei)
 613 {       if (VERSION_OsIsUnicode())
 614           return ShellExecuteExW (sei);
 615         return ShellExecuteExA (sei);
 616 }
 617 /*************************************************************************
 618  * ShellExecuteExA                              [SHELL32.292]
 619  *
 620  * placeholder in the commandline:
 621  *      %1 file
 622  *      %2 printer
 623  *      %3 driver
 624  *      %4 port
 625  *      %I adress of a global item ID (explorer switch /idlist)
 626  *      %L ??? path/url/current file ???
 627  *      %S ???
 628  *      %* all following parameters (see batfile)
 629  */
 630 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
 631 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
 632         LPSTR pos;
 633         int gap, len;
 634         STARTUPINFOA  startup;
 635         PROCESS_INFORMATION info;
 636
 637         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
 638                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
 639                 sei->lpParameters, sei->lpDirectory, sei->nShow,
 640                 (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
 641
 642         ZeroMemory(szApplicationName,MAX_PATH);
 643         if (sei->lpFile)
 644           strcpy(szApplicationName, sei->lpFile);
 645
 646         ZeroMemory(szCommandline,MAX_PATH);
 647         if (sei->lpParameters)
 648           strcpy(szCommandline, sei->lpParameters);
 649
 650         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
 651                           SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
 652                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
 653                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
 654         {
 655           FIXME("flags ignored: 0x%08lx\n", sei->fMask);
 656         }
 657
 658         /* launch a document by fileclass like 'Wordpad.Document.1' */
 659         if (sei->fMask & SEE_MASK_CLASSNAME)
 660         {
 661           /* the commandline contains 'c:\Path\wordpad.exe "%1"' */
 662           HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
 663           /* fixme: get the extension of lpFile, check if it fits to the lpClass */
 664           TRACE("SEE_MASK_CLASSNAME->'%s'\n", szCommandline);
 665         }
 666
 667         /* process the IDList */
 668         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
 669         {
 670           SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
 671           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
 672         }
 673         else
 674         {
 675           if (sei->fMask & SEE_MASK_IDLIST )
 676           {
 677             pos = strstr(szCommandline, "%I");
 678             if (pos)
 679             {
 680               HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
 681               sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
 682               SHUnlockShared(hmem);
 683
 684               gap = strlen(szPidl);
 685               len = strlen(pos)-2;
 686               memmove(pos+gap,pos+2,len);
 687               memcpy(pos,szPidl,gap);
 688
 689             }
 690           }
 691         }
 692
 693         TRACE("execute:'%s','%s'\n",szApplicationName, szCommandline);
 694
 695         strcat(szApplicationName, " ");
 696         strcat(szApplicationName, szCommandline);
 697
 698         ZeroMemory(&startup,sizeof(STARTUPINFOA));
 699         startup.cb = sizeof(STARTUPINFOA);
 700
 701         if (! CreateProcessA(NULL, szApplicationName,
 702                          NULL, NULL, FALSE, 0,
 703                          NULL, NULL, &startup, &info))
 704         {
 705           sei->hInstApp = GetLastError();
 706           return FALSE;
 707         }
 708
 709         sei->hInstApp = 33;
 710
 711         /* Give 30 seconds to the app to come up */
 712         if ( WaitForInputIdle ( info.hProcess, 30000 ) ==  0xFFFFFFFF )
 713           ERR("WaitForInputIdle failed: Error %ld\n", GetLastError() );
 714
 715         if(sei->fMask & SEE_MASK_NOCLOSEPROCESS)
 716           sei->hProcess = info.hProcess;
 717         else
 718           CloseHandle( info.hProcess );
 719         CloseHandle( info.hThread );
 720         return TRUE;
 721 }
 722 /*************************************************************************
 723  * ShellExecuteExW                              [SHELL32.293]
 724  *
 725  */
 726 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
 727 {       SHELLEXECUTEINFOA seiA;
 728         DWORD ret;
 729
 730         TRACE("%p\n", sei);
 731
 732         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
 733
 734         if (sei->lpVerb)
 735           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
 736
 737         if (sei->lpFile)
 738           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
 739
 740         if (sei->lpParameters)
 741           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
 742
 743         if (sei->lpDirectory)
 744           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
 745
 746         if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
 747           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
 748         else
 749           seiA.lpClass = NULL;
 750
 751         ret = ShellExecuteExA(&seiA);
 752
 753         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
 754         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
 755         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
 756         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
 757         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
 758
 759         return ret;
 760 }
 761
 762 static LPUNKNOWN SHELL32_IExplorerInterface=0;
 763 /*************************************************************************
 764  * SHSetInstanceExplorer                        [SHELL32.176]
 765  *
 766  * NOTES
 767  *  Sets the interface
 768  */
 769 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
 770 {       TRACE("%p\n", lpUnknown);
 771         SHELL32_IExplorerInterface = lpUnknown;
 772         return (HRESULT) lpUnknown;
 773 }
 774 /*************************************************************************
 775  * SHGetInstanceExplorer                        [SHELL32.256]
 776  *
 777  * NOTES
 778  *  gets the interface pointer of the explorer and a reference
 779  */
 780 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
 781 {       TRACE("%p\n", lpUnknown);
 782
 783         *lpUnknown = SHELL32_IExplorerInterface;
 784
 785         if (!SHELL32_IExplorerInterface)
 786           return E_FAIL;
 787
 788         IUnknown_AddRef(SHELL32_IExplorerInterface);
 789         return NOERROR;
 790 }
 791 /*************************************************************************
 792  * SHFreeUnusedLibraries                        [SHELL32.123]
 793  *
 794  * NOTES
 795  *  exported by name
 796  */
 797 HRESULT WINAPI SHFreeUnusedLibraries (void)
 798 {       FIXME("stub\n");
 799         return TRUE;
 800 }
 801 /*************************************************************************
 802  * DAD_SetDragImage                             [SHELL32.136]
 803  *
 804  * NOTES
 805  *  exported by name
 806  */
 807 HRESULT WINAPI DAD_SetDragImage (DWORD u, DWORD v)
 808 { FIXME("0x%08lx 0x%08lx stub\n",u, v);
 809   return 0;
 810 }
 811 /*************************************************************************
 812  * DAD_ShowDragImage                            [SHELL32.137]
 813  *
 814  * NOTES
 815  *  exported by name
 816  */
 817 HRESULT WINAPI DAD_ShowDragImage (DWORD u)
 818 { FIXME("0x%08lx stub\n",u);
 819   return 0;
 820 }
 821 /*************************************************************************
 822  * SHRegCloseKey                        [NT4.0:SHELL32.505]
 823  *
 824  */
 825 HRESULT WINAPI SHRegCloseKey (HKEY hkey)
 826 {       TRACE("0x%04x\n",hkey);
 827         return RegCloseKey( hkey );
 828 }
 829 /*************************************************************************
 830  * SHRegOpenKeyA                                [SHELL32.506]
 831  *
 832  */
 833 HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
 834 {
 835         TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
 836         return RegOpenKeyA(hKey, lpSubKey, phkResult);
 837 }
 838
 839 /*************************************************************************
 840  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
 841  *
 842  */
 843 HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
 844 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
 845         return RegOpenKeyW( hkey, lpszSubKey, retkey );
 846 }
 847 /*************************************************************************
 848  * SHRegQueryValueExA                           [SHELL32.509]
 849  *
 850  */
 851 HRESULT WINAPI SHRegQueryValueExA(
 852         HKEY hkey,
 853         LPSTR lpValueName,
 854         LPDWORD lpReserved,
 855         LPDWORD lpType,
 856         LPBYTE lpData,
 857         LPDWORD lpcbData)
 858 {
 859         TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 860         return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 861 }
 862 /*************************************************************************
 863  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
 864  *
 865  */
 866 HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
 867                                  LPWSTR lpszData, LPDWORD lpcbData )
 868 {       WARN("0x%04x %s %p %p semi-stub\n",
 869                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
 870         return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
 871 }
 872
 873 /*************************************************************************
 874  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
 875  *
 876  * FIXME
 877  *  if the datatype REG_EXPAND_SZ then expand the string and change
 878  *  *pdwType to REG_SZ.
 879  */
 880 HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
 881                  LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
 882 {       DWORD ret;
 883         WARN("0x%04x %s %p %p %p %p semi-stub\n",
 884                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
 885         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
 886         return ret;
 887 }
 888
 889 /*************************************************************************
 890  * SHGetValueA
 891  *
 892  * Gets a value from the registry
 893  */
 894 DWORD WINAPI SHGetValueA(
 895     HKEY     hkey,
 896     LPCSTR   pSubKey,
 897     LPCSTR   pValue,
 898     LPDWORD  pwType,
 899     LPVOID   pvData,
 900     LPDWORD  pbData
 901     )
 902 {
 903     FIXME("(%p),stub!\n", pSubKey);
 904
 905         return ERROR_SUCCESS;  /* return success */
 906 }
 907
 908 /*************************************************************************
 909  * SHGetValueW
 910  *
 911  * Gets a value from the registry
 912  */
 913 DWORD WINAPI SHGetValueW(
 914     HKEY     hkey,
 915     LPCWSTR  pSubKey,
 916     LPCWSTR  pValue,
 917     LPDWORD  pwType,
 918     LPVOID   pvData,
 919     LPDWORD  pbData
 920     )
 921 {
 922     FIXME("(%p),stub!\n", pSubKey);
 923
 924         return ERROR_SUCCESS;  /* return success */
 925 }
 926
 927 /*************************************************************************
 928  * SHRegGetUSValueA
 929  *
 930  * Gets a user-specific registry value
 931  */
 932 LONG WINAPI SHRegGetUSValueA(
 933     LPCSTR   pSubKey,
 934     LPCSTR   pValue,
 935     LPDWORD  pwType,
 936     LPVOID   pvData,
 937     LPDWORD  pbData,
 938     BOOL     fIgnoreHKCU,
 939     LPVOID   pDefaultData,
 940     DWORD    wDefaultDataSize
 941     )
 942 {
 943     FIXME("(%p),stub!\n", pSubKey);
 944
 945         return ERROR_SUCCESS;  /* return success */
 946 }
 947
 948 /*************************************************************************
 949  * SHRegGetUSValueW
 950  *
 951  * Gets a user-specific registry value
 952  */
 953 LONG WINAPI SHRegGetUSValueW(
 954     LPCWSTR  pSubKey,
 955     LPCWSTR  pValue,
 956     LPDWORD  pwType,
 957     LPVOID   pvData,
 958     LPDWORD  pbData,
 959     BOOL     flagIgnoreHKCU,
 960     LPVOID   pDefaultData,
 961     DWORD    wDefaultDataSize
 962     )
 963 {
 964     FIXME("(%p),stub!\n", pSubKey);
 965
 966         return ERROR_SUCCESS;  /* return success */
 967 }
 968
 969 /*************************************************************************
 970  * SHRegDeleteKeyA and SHDeleteKeyA
 971  */
 972 HRESULT WINAPI SHRegDeleteKeyA(HKEY hkey, LPCSTR pszSubKey)
 973 {
 974         FIXME("hkey=0x%08x, %s\n", hkey, debugstr_a(pszSubKey));
 975         return 0;
 976 }
 977
 978 /*************************************************************************
 979  * SHRegDeleteKeyW and SHDeleteKeyA
 980  */
 981 HRESULT WINAPI SHRegDeleteKeyW(HKEY hkey, LPCWSTR pszSubKey)
 982 {
 983         FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
 984         return 0;
 985 }
 986 /*************************************************************************
 987  * ReadCabinetState                             [NT 4.0:SHELL32.651]
 988  *
 989  */
 990 HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
 991 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
 992         return 0;
 993 }
 994 /*************************************************************************
 995  * WriteCabinetState                            [NT 4.0:SHELL32.652]
 996  *
 997  */
 998 HRESULT WINAPI WriteCabinetState(DWORD u)
 999 {       FIXME("0x%04lx stub\n",u);
1000         return 0;
1001 }
1002 /*************************************************************************
1003  * FileIconInit                                 [SHELL32.660]
1004  *
1005  */
1006 BOOL WINAPI FileIconInit(BOOL bFullInit)
1007 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
1008         return 0;
1009 }
1010 /*************************************************************************
1011  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
1012  *
1013  */
1014 HRESULT WINAPI IsUserAdmin(void)
1015 {       FIXME("stub\n");
1016         return TRUE;
1017 }
1018
1019 /*************************************************************************
1020  * StrRetToBufA                                 [SHLWAPI.@]
1021  *
1022  * converts a STRRET to a normal string
1023  *
1024  * NOTES
1025  *  the pidl is for STRRET OFFSET
1026  */
1027 HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
1028 {
1029         return StrRetToStrNA(dest, len, src, pidl);
1030 }
1031
1032 /*************************************************************************
1033  * StrRetToBufW                                 [SHLWAPI.@]
1034  *
1035  * converts a STRRET to a normal string
1036  *
1037  * NOTES
1038  *  the pidl is for STRRET OFFSET
1039  */
1040 HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
1041 {
1042         return StrRetToStrNW(dest, len, src, pidl);
1043 }
1044
1045 /*************************************************************************
1046  * StrRetToStrN                                 [SHELL32.96]
1047  *
1048  * converts a STRRET to a normal string
1049  *
1050  * NOTES
1051  *  the pidl is for STRRET OFFSET
1052  */
1053 HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1054 {
1055         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
1056
1057         switch (src->uType)
1058         {
1059           case STRRET_WSTR:
1060             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
1061             SHFree(src->u.pOleStr);
1062             break;
1063
1064           case STRRET_CSTRA:
1065             lstrcpynA((LPSTR)dest, src->u.cStr, len);
1066             break;
1067
1068           case STRRET_OFFSETA:
1069             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1070             break;
1071
1072           default:
1073             FIXME("unknown type!\n");
1074             if (len)
1075             {
1076               *(LPSTR)dest = '\0';
1077             }
1078             return(FALSE);
1079         }
1080         return S_OK;
1081 }
1082
1083 HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1084 {
1085         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
1086
1087         switch (src->uType)
1088         {
1089           case STRRET_WSTR:
1090             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
1091             SHFree(src->u.pOleStr);
1092             break;
1093
1094           case STRRET_CSTRA:
1095             lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
1096             break;
1097
1098           case STRRET_OFFSETA:
1099             if (pidl)
1100             {
1101               lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1102             }
1103             break;
1104
1105           default:
1106             FIXME("unknown type!\n");
1107             if (len)
1108             { *(LPSTR)dest = '\0';
1109             }
1110             return(FALSE);
1111         }
1112         return S_OK;
1113 }
1114 HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
1115 {
1116         if(VERSION_OsIsUnicode())
1117           return StrRetToStrNW (dest, len, src, pidl);
1118         return StrRetToStrNA (dest, len, src, pidl);
1119 }
1120
1121 /*************************************************************************
1122  * StrChrW                                      [NT 4.0:SHELL32.651]
1123  *
1124  */
1125 LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
1126 {
1127         TRACE("%s 0x%04x\n",debugstr_w(str),x);
1128         return CRTDLL_wcschr(str, x);
1129 }
1130
1131 /*************************************************************************
1132  * StrCmpNIW                                    [NT 4.0:SHELL32.*]
1133  *
1134  */
1135 INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
1136 {
1137         TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
1138         return CRTDLL__wcsnicmp(wstr1, wstr2, len);
1139 }
1140
1141 /*************************************************************************
1142  * SHAllocShared                                [SHELL32.520]
1143  *
1144  * NOTES
1145  *  parameter1 is return value from HeapAlloc
1146  *  parameter2 is equal to the size allocated with HeapAlloc
1147  *  parameter3 is return value from GetCurrentProcessId
1148  *
1149  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
1150  *  WM_USER+2 could be the undocumented CWM_SETPATH
1151  *  the allocated memory contains a pidl
1152  */
1153 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
1154 {       HGLOBAL hmem;
1155         LPVOID pmem;
1156
1157         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
1158         hmem = GlobalAlloc(GMEM_FIXED, size);
1159         if (!hmem)
1160           return 0;
1161
1162         pmem =  GlobalLock (hmem);
1163
1164         if (! pmem)
1165           return 0;
1166
1167         memcpy (pmem, psrc, size);
1168         GlobalUnlock(hmem);
1169         return hmem;
1170 }
1171 /*************************************************************************
1172  * SHLockShared                                 [SHELL32.521]
1173  *
1174  * NOTES
1175  *  parameter1 is return value from SHAllocShared
1176  *  parameter2 is return value from GetCurrentProcessId
1177  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
1178  *  the returnvalue seems to be a memoryadress
1179  */
1180 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
1181 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
1182         return GlobalLock(hmem);
1183 }
1184 /*************************************************************************
1185  * SHUnlockShared                               [SHELL32.522]
1186  *
1187  * NOTES
1188  *  parameter1 is return value from SHLockShared
1189  */
1190 BOOL WINAPI SHUnlockShared(HANDLE pmem)
1191 {       TRACE("handle=0x%04x\n",pmem);
1192         return GlobalUnlock(pmem);
1193 }
1194 /*************************************************************************
1195  * SHFreeShared                                 [SHELL32.523]
1196  *
1197  * NOTES
1198  *  parameter1 is return value from SHAllocShared
1199  *  parameter2 is return value from GetCurrentProcessId
1200  */
1201 HANDLE WINAPI SHFreeShared(HANDLE hmem, DWORD procID)
1202 {       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
1203         return GlobalFree(hmem);
1204 }
1205
1206 /*************************************************************************
1207  * SetAppStartingCursor                         [SHELL32.99]
1208  *
1209  */
1210 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
1211 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
1212         return 0;
1213 }
1214 /*************************************************************************
1215  * SHLoadOLE                                    [SHELL32.151]
1216  *
1217  */
1218 HRESULT WINAPI SHLoadOLE(DWORD u)
1219 {       FIXME("0x%04lx stub\n",u);
1220         return S_OK;
1221 }
1222 /*************************************************************************
1223  * DriveType                                    [SHELL32.64]
1224  *
1225  */
1226 HRESULT WINAPI DriveType(DWORD u)
1227 {       FIXME("0x%04lx stub\n",u);
1228         return 0;
1229 }
1230 /*************************************************************************
1231  * SHAbortInvokeCommand                         [SHELL32.198]
1232  *
1233  */
1234 HRESULT WINAPI SHAbortInvokeCommand(void)
1235 {       FIXME("stub\n");
1236         return 1;
1237 }
1238 /*************************************************************************
1239  * SHOutOfMemoryMessageBox                      [SHELL32.126]
1240  *
1241  */
1242 HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
1243 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1244         return 0;
1245 }
1246 /*************************************************************************
1247  * SHFlushClipboard                             [SHELL32.121]
1248  *
1249  */
1250 HRESULT WINAPI SHFlushClipboard(void)
1251 {       FIXME("stub\n");
1252         return 1;
1253 }
1254
1255 /*************************************************************************
1256  * StrFormatByteSizeA                           [SHLWAPI]
1257  */
1258 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
1259 {       char buf[64];
1260         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1261         if ( dw<1024L )
1262         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1263         }
1264         else if ( dw<1048576L)
1265         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1266         }
1267         else if ( dw < 1073741824L)
1268         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1269         }
1270         else
1271         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1272         }
1273         lstrcpynA (pszBuf, buf, cchBuf);
1274         return pszBuf;
1275 }
1276
1277 /*************************************************************************
1278  * StrFormatByteSizeW                           [SHLWAPI]
1279  */
1280 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
1281 {       char buf[64];
1282         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1283         if ( dw<1024L )
1284         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1285         }
1286         else if ( dw<1048576L)
1287         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1288         }
1289         else if ( dw < 1073741824L)
1290         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1291         }
1292         else
1293         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1294         }
1295         lstrcpynAtoW (pszBuf, buf, cchBuf);
1296         return pszBuf;
1297 }
1298 /*************************************************************************
1299  * SHWaitForFileToOpen                          [SHELL32.97]
1300  *
1301  */
1302 HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
1303 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1304         return 0;
1305 }
1306 /*************************************************************************
1307  * Control_FillCache_RunDLL                     [SHELL32.8]
1308  *
1309  */
1310 HRESULT WINAPI Control_FillCache_RunDLL(HWND hWnd, HANDLE hModule, DWORD w, DWORD x)
1311 {       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
1312         return 0;
1313 }
1314 /*************************************************************************
1315  * RunDLL_CallEntry16                           [SHELL32.122]
1316  * the name is propably wrong
1317  */
1318 HRESULT WINAPI RunDLL_CallEntry16(DWORD v, DWORD w, DWORD x, DWORD y, DWORD z)
1319 {       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
1320         return 0;
1321 }
1322
1323 /************************************************************************
1324  *      shell32_654                             [SHELL32.654]
1325  *
1326  * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
1327  * second one could be a size (0x0c). The size is the same as the structure saved to
1328  * HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1329  * I'm (js) guessing: this one is just ReadCabinetState ;-)
1330  */
1331 HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
1332 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
1333         return 0;
1334 }
1335
1336 /************************************************************************
1337  *      RLBuildListOfPaths                      [SHELL32.146]
1338  *
1339  * NOTES
1340  *   builds a DPA
1341  */
1342 DWORD WINAPI RLBuildListOfPaths (void)
1343 {       FIXME("stub\n");
1344         return 0;
1345 }
1346 /************************************************************************
1347  *      StrToOleStr                     [SHELL32.163]
1348  *
1349  */
1350 int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
1351 {
1352         TRACE("(%p, %p %s)\n",
1353         lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
1354
1355         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
1356
1357 }
1358 int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
1359 {
1360         TRACE("(%p, %p %s)\n",
1361         lpWideCharStr, lpWString, debugstr_w(lpWString));
1362
1363         if (lstrcpyW (lpWideCharStr, lpWString ))
1364         { return lstrlenW (lpWideCharStr);
1365         }
1366         return 0;
1367 }
1368
1369 BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
1370 {
1371         if (VERSION_OsIsUnicode())
1372           return StrToOleStrW (lpWideCharStr, lpString);
1373         return StrToOleStrA (lpWideCharStr, lpString);
1374 }
1375
1376 /************************************************************************
1377  *      SHValidateUNC                           [SHELL32.173]
1378  *
1379  */
1380 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1381 {
1382         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1383         return 0;
1384 }
1385
1386 /************************************************************************
1387  *      DoEnvironmentSubstA                     [SHELL32.1222]
1388  *
1389  */
1390 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
1391 {
1392         FIXME("(%p %s, %p %s) stub\n", x, debugstr_a(x), y, debugstr_a(y));
1393         return 0;
1394 }
1395
1396 /************************************************************************
1397  *      DoEnvironmentSubstW                     [SHELL32.1223]
1398  *
1399  */
1400 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
1401 {
1402         FIXME("(%p %s, %p %s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
1403         return 0;
1404 }
1405
1406 /************************************************************************
1407  *      DoEnvironmentSubst                      [SHELL32.53]
1408  *
1409  */
1410 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
1411 {
1412         if (VERSION_OsIsUnicode())
1413           return DoEnvironmentSubstW(x, y);
1414         return DoEnvironmentSubstA(x, y);
1415 }
1416
1417 /*************************************************************************
1418  *      shell32_243                             [SHELL32.243]
1419  *
1420  * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
1421  * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
1422  *
1423  */
1424
1425 BOOL WINAPI shell32_243(DWORD a, DWORD b)
1426 {
1427   return FALSE;
1428 }
1429