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