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 "winerror.h"
  10 #include "winreg.h"
  11 #include "debugtools.h"
  12 #include "winnls.h"
  13 #include "winversion.h"
  14 #include "heap.h"
  15
  16 #include "shellapi.h"
  17 #include "shlobj.h"
  18 #include "shell32_main.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(shell)
  21
  22 /*************************************************************************
  23  * SHChangeNotifyRegister                       [SHELL32.2]
  24  *
  25  * NOTES
  26  *   Idlist is an array of structures and Count specifies how many items in the array
  27  *   (usually just one I think).
  28  */
  29 DWORD WINAPI
  30 SHChangeNotifyRegister(
  31     HWND hwnd,
  32     LONG events1,
  33     LONG events2,
  34     DWORD msg,
  35     int count,
  36     IDSTRUCT *idlist)
  37 {       FIXME("(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
  38                 hwnd,events1,events2,msg,count,idlist);
  39         return 0;
  40 }
  41 /*************************************************************************
  42  * SHChangeNotifyDeregister                     [SHELL32.4]
  43  */
  44 DWORD WINAPI
  45 SHChangeNotifyDeregister(LONG x1)
  46 {       FIXME("(0x%08lx):stub.\n",x1);
  47         return 0;
  48 }
  49 /*************************************************************************
  50  * NTSHChangeNotifyRegister                     [SHELL32.640]
  51  * NOTES
  52  *   Idlist is an array of structures and Count specifies how many items in the array
  53  *   (usually just one I think).
  54  */
  55 DWORD WINAPI NTSHChangeNotifyRegister(
  56     HWND hwnd,
  57     LONG events1,
  58     LONG events2,
  59     DWORD msg,
  60     int count,
  61     IDSTRUCT *idlist)
  62 {       FIXME("(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
  63                 hwnd,events1,events2,msg,count,idlist);
  64         return 0;
  65 }
  66 /*************************************************************************
  67  * NTSHChangeNotifyDeregister                   [SHELL32.641]
  68  */
  69 DWORD WINAPI NTSHChangeNotifyDeregister(LONG x1)
  70 {       FIXME("(0x%08lx):stub.\n",x1);
  71         return 0;
  72 }
  73
  74 /*************************************************************************
  75  * ParseField                                   [SHELL32.58]
  76  *
  77  */
  78 DWORD WINAPI ParseFieldA(LPCSTR src, DWORD field, LPSTR dst, DWORD len)
  79 {       WARN("('%s',0x%08lx,%p,%ld) semi-stub.\n",src,field,dst,len);
  80
  81         if (!src || !src[0] || !dst || !len)
  82           return 0;
  83
  84         if (field >1)
  85         { field--;
  86           while (field)
  87           { if (*src==0x0) return FALSE;
  88             if (*src==',') field--;
  89             src++;
  90           }
  91         }
  92
  93         while (*src!=0x00 && *src!=',' && len>0)
  94         { *dst=*src; dst++, src++; len--;
  95         }
  96         *dst=0x0;
  97
  98         return TRUE;
  99 }
 100
 101 /*************************************************************************
 102  * PickIconDlg                                  [SHELL32.62]
 103  *
 104  */
 105 DWORD WINAPI PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
 106 {       FIXME("(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
 107         return 0xffffffff;
 108 }
 109
 110 /*************************************************************************
 111  * GetFileNameFromBrowse                        [SHELL32.63]
 112  *
 113  */
 114 DWORD WINAPI GetFileNameFromBrowse(HWND howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd)
 115 {       FIXME("(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
 116             howner,targetbuf,len,x,suffix,y,cmd);
 117     /* puts up a Open Dialog and requests input into targetbuf */
 118     /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
 119     lstrcpyA(targetbuf,"x:\\dummy.exe");
 120     return 1;
 121 }
 122
 123 /*************************************************************************
 124  * SHGetSettings                                [SHELL32.68]
 125  *
 126  * NOTES
 127  *  the registry path are for win98 (tested)
 128  *  and possibly are the same in nt40
 129  */
 130 void WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask, DWORD dwx)
 131 {
 132         HKEY    hKey;
 133         DWORD   dwData;
 134         DWORD   dwDataSize = sizeof (DWORD);
 135
 136         TRACE("(%p 0x%08lx 0x%08lx)\n",lpsfs,dwMask, dwx);
 137
 138         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
 139                                  0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
 140           return;
 141
 142         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 143           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
 144
 145         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 146           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
 147
 148         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 149           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
 150
 151         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 152           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
 153
 154         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 155           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
 156
 157         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 158           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
 159
 160         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 161         { if (dwData == 0)
 162           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 163             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 164           }
 165           else if (dwData == 1)
 166           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
 167             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 168           }
 169           else if (dwData == 2)
 170           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 171             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
 172           }
 173         }
 174         RegCloseKey (hKey);
 175
 176         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
 177 }
 178
 179 /*************************************************************************
 180  * SHShellFolderView_Message                    [SHELL32.73]
 181  *
 182  * PARAMETERS
 183  *  hwndCabinet defines the explorer cabinet window that contains the
 184  *              shellview you need to communicate with
 185  *  uMsg        identifying the SFVM enum to perform
 186  *  lParam
 187  *
 188  * NOTES
 189  *  Message SFVM_REARRANGE = 1
 190  *    This message gets sent when a column gets clicked to instruct the
 191  *    shell view to re-sort the item list. lParam identifies the column
 192  *    that was clicked.
 193  */
 194 int WINAPI SHShellFolderView_Message(HWND hwndCabinet,UINT uMsg,LPARAM lParam)
 195 { FIXME("%04x %08ux %08lx stub\n",hwndCabinet,uMsg,lParam);
 196   return 0;
 197 }
 198
 199 /*************************************************************************
 200  * OleStrToStrN                                 [SHELL32.78]
 201  */
 202 BOOL WINAPI OleStrToStrN (LPSTR lpMulti, INT nMulti, LPCWSTR lpWide, INT nWide)
 203 {
 204         TRACE("%s %x %s %x\n", lpMulti, nMulti, debugstr_w(lpWide), nWide);
 205         return WideCharToMultiByte (0, 0, lpWide, nWide, lpMulti, nMulti, NULL, NULL);
 206 }
 207
 208 /*************************************************************************
 209  * StrToOleStrN                                 [SHELL32.79]
 210  *  lpMulti, nMulti, nWide [IN]
 211  *  lpWide [OUT]
 212  */
 213 BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
 214 {
 215         TRACE("%p %x %s %x\n", lpWide, nWide, lpStrA, nStr);
 216         return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
 217 }
 218 BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
 219 {
 220         TRACE("%p %x %s %x\n", lpWide, nWide, debugstr_w(lpStrW), nStr);
 221
 222         if (lstrcpynW (lpWide, lpStrW, nWide))
 223         { return lstrlenW (lpWide);
 224         }
 225         return 0;
 226 }
 227
 228 BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
 229 {
 230         if (VERSION_OsIsUnicode())
 231           return StrToOleStrNW (lpWide, nWide, lpStr, nStr);
 232         return StrToOleStrNA (lpWide, nWide, lpStr, nStr);
 233 }
 234
 235 /*************************************************************************
 236  * RegisterShellHook                            [SHELL32.181]
 237  *
 238  * PARAMS
 239  *      hwnd [I]  window handle
 240  *      y    [I]  flag ????
 241  *
 242  * NOTES
 243  *     exported by ordinal
 244  */
 245 void WINAPI RegisterShellHook(HWND hwnd, DWORD y) {
 246     FIXME("(0x%08x,0x%08lx):stub.\n",hwnd,y);
 247 }
 248 /*************************************************************************
 249  * ShellMessageBoxW                             [SHELL32.182]
 250  *
 251  * Format and output errormessage.
 252  *
 253  * idText       resource ID of title or LPSTR
 254  * idTitle      resource ID of title or LPSTR
 255  *
 256  * NOTES
 257  *     exported by ordinal
 258  */
 259 INT __cdecl
 260 ShellMessageBoxW(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 261 {       WCHAR   szText[100],szTitle[100],szTemp[256];
 262         LPWSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 263         LPVOID  args = &arglist;
 264
 265         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",(DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 266
 267         if (!HIWORD (idTitle))
 268           LoadStringW(hmod,idTitle,pszTitle,100);
 269         else
 270           pszTitle = (LPWSTR)idTitle;
 271
 272         if (! HIWORD (idText))
 273           LoadStringW(hmod,idText,pszText,100);
 274         else
 275           pszText = (LPWSTR)idText;
 276
 277         FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,szText,0,0,szTemp,256,args);
 278         return MessageBoxW(hwnd,szTemp,szTitle,uType);
 279 }
 280
 281 /*************************************************************************
 282  * ShellMessageBoxA                             [SHELL32.183]
 283  */
 284 INT __cdecl
 285 ShellMessageBoxA(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 286 {       char    szText[100],szTitle[100],szTemp[256];
 287         LPSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 288         LPVOID  args = &arglist;
 289
 290         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n", (DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 291
 292         if (!HIWORD (idTitle))
 293           LoadStringA(hmod,idTitle,pszTitle,100);
 294         else
 295           pszTitle = (LPSTR)idTitle;
 296
 297         if (! HIWORD (idText))
 298           LoadStringA(hmod,idText,pszText,100);
 299         else
 300           pszText = (LPSTR)idText;
 301
 302         FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,pszText,0,0,szTemp,256,args);
 303         return MessageBoxA(hwnd,szTemp,pszTitle,uType);
 304 }
 305
 306 /*************************************************************************
 307  * SHRestricted                         [SHELL32.100]
 308  *
 309  * walks through policy table, queries <app> key, <type> value, returns
 310  * queried (DWORD) value.
 311  * {0x00001,Explorer,NoRun}
 312  * {0x00002,Explorer,NoClose}
 313  * {0x00004,Explorer,NoSaveSettings}
 314  * {0x00008,Explorer,NoFileMenu}
 315  * {0x00010,Explorer,NoSetFolders}
 316  * {0x00020,Explorer,NoSetTaskbar}
 317  * {0x00040,Explorer,NoDesktop}
 318  * {0x00080,Explorer,NoFind}
 319  * {0x00100,Explorer,NoDrives}
 320  * {0x00200,Explorer,NoDriveAutoRun}
 321  * {0x00400,Explorer,NoDriveTypeAutoRun}
 322  * {0x00800,Explorer,NoNetHood}
 323  * {0x01000,Explorer,NoStartBanner}
 324  * {0x02000,Explorer,RestrictRun}
 325  * {0x04000,Explorer,NoPrinterTabs}
 326  * {0x08000,Explorer,NoDeletePrinter}
 327  * {0x10000,Explorer,NoAddPrinter}
 328  * {0x20000,Explorer,NoStartMenuSubFolders}
 329  * {0x40000,Explorer,MyDocsOnNet}
 330  * {0x80000,WinOldApp,NoRealMode}
 331  *
 332  * NOTES
 333  *     exported by ordinal
 334  */
 335 DWORD WINAPI SHRestricted (DWORD pol) {
 336         HKEY    xhkey;
 337
 338         FIXME("(%08lx):stub.\n",pol);
 339         if (RegOpenKeyA(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 340                 return 0;
 341         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 342         RegCloseKey(xhkey);
 343         return 0;
 344 }
 345
 346 /*************************************************************************
 347  * SHCreateDirectory                            [SHELL32.165]
 348  *
 349  * NOTES
 350  *  exported by ordinal
 351  *  not sure about LPSECURITY_ATTRIBUTES
 352  */
 353 DWORD WINAPI SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,LPCSTR path) {
 354         TRACE("(%p,%s):stub.\n",sec,path);
 355         if (CreateDirectoryA(path,sec))
 356                 return TRUE;
 357         /* SHChangeNotify(8,1,path,0); */
 358         return FALSE;
 359 #if 0
 360         if (SHELL32_79(path,(LPVOID)x))
 361                 return 0;
 362         FIXME("(%08lx,%s):stub.\n",x,path);
 363         return 0;
 364 #endif
 365 }
 366
 367 /*************************************************************************
 368  * SHFree                                       [SHELL32.195]
 369  *
 370  * NOTES
 371  *     free_ptr() - frees memory using IMalloc
 372  *     exported by ordinal
 373  */
 374 DWORD WINAPI SHFree(LPVOID x) {
 375   TRACE("%p\n",x);
 376   if (!HIWORD(x))
 377   { *(LPDWORD)0xdeaf0000 = 0;
 378   }
 379   return HeapFree(GetProcessHeap(),0,x);
 380 }
 381
 382 /*************************************************************************
 383  * SHAlloc                                      [SHELL32.196]
 384  *
 385  * NOTES
 386  *     void *task_alloc(DWORD len), uses SHMalloc allocator
 387  *     exported by ordinal
 388  */
 389 LPVOID WINAPI SHAlloc(DWORD len) {
 390  /* void * ret = (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT);*/ /* chrashes */
 391  void * ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
 392   TRACE("%lu bytes at %p\n",len, ret);
 393   return ret;
 394 }
 395
 396 /*************************************************************************
 397  * SHRegisterDragDrop                           [SHELL32.86]
 398  *
 399  * NOTES
 400  *     exported by ordinal
 401  */
 402 DWORD WINAPI SHRegisterDragDrop(HWND hWnd,IDropTarget * pDropTarget)
 403 {
 404         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
 405         return     RegisterDragDrop(hWnd, pDropTarget);
 406 }
 407
 408 /*************************************************************************
 409  * SHRevokeDragDrop                             [SHELL32.87]
 410  *
 411  * NOTES
 412  *     exported by ordinal
 413  */
 414 DWORD WINAPI SHRevokeDragDrop(DWORD x) {
 415     FIXME("(0x%08lx):stub.\n",x);
 416     return 0;
 417 }
 418
 419 /*************************************************************************
 420  * SHDoDragDrop                                 [SHELL32.88]
 421  *
 422  * NOTES
 423  *     exported by ordinal
 424  */
 425 DWORD WINAPI SHDoDragDrop(DWORD u, DWORD v, DWORD w, DWORD x, DWORD y, DWORD z) {
 426     FIXME("(0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx):stub.\n",u,v,w,x,y,z);
 427     return 0;
 428 }
 429
 430 /*************************************************************************
 431  * RunFileDlg                                   [SHELL32.61]
 432  *
 433  * NOTES
 434  *     Original name: RunFileDlg (exported by ordinal)
 435  */
 436 DWORD WINAPI
 437 RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
 438             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
 439 {
 440     FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
 441            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
 442     return 0;
 443 }
 444
 445 /*************************************************************************
 446  * ExitWindowsDialog                            [SHELL32.60]
 447  *
 448  * NOTES
 449  *     exported by ordinal
 450  */
 451 void WINAPI ExitWindowsDialog (HWND hWndOwner)
 452 {
 453         TRACE("(0x%08x)\n", hWndOwner);
 454         if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
 455         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
 456         }
 457 }
 458
 459 /*************************************************************************
 460  * ArrangeWindows                               [SHELL32.184]
 461  *
 462  */
 463 DWORD WINAPI
 464 ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
 465                 DWORD dwParam4, DWORD dwParam5)
 466 {
 467     FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
 468            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
 469     return 0;
 470 }
 471
 472 /*************************************************************************
 473  * SignalFileOpen                               [SHELL32.103]
 474  *
 475  * NOTES
 476  *     exported by ordinal
 477  */
 478 DWORD WINAPI
 479 SignalFileOpen (DWORD dwParam1)
 480 {
 481     FIXME("(0x%08lx):stub.\n", dwParam1);
 482
 483     return 0;
 484 }
 485
 486 /*************************************************************************
 487  * SHAddToRecentDocs                            [SHELL32.234]
 488  *
 489  * PARAMETERS
 490  *   uFlags  [IN] SHARD_PATH or SHARD_PIDL
 491  *   pv      [IN] string or pidl, NULL clears the list
 492  *
 493  * NOTES
 494  *     exported by name
 495  */
 496 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 497 { if (SHARD_PIDL==uFlags)
 498   { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
 499         }
 500         else
 501         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
 502         }
 503   return 0;
 504 }
 505 /*************************************************************************
 506  * SHFileOperation                              [SHELL32.242]
 507  *
 508  */
 509 DWORD WINAPI SHFileOperationAW(DWORD x)
 510 {       FIXME("0x%08lx stub\n",x);
 511         return 0;
 512
 513 }
 514
 515 /*************************************************************************
 516  * SHFileOperationA                             [SHELL32.243]
 517  *
 518  * NOTES
 519  *     exported by name
 520  */
 521 DWORD WINAPI SHFileOperationA (LPSHFILEOPSTRUCTA lpFileOp)
 522 { FIXME("(%p):stub.\n", lpFileOp);
 523   return 1;
 524 }
 525 /*************************************************************************
 526  * SHFileOperationW                             [SHELL32.244]
 527  *
 528  * NOTES
 529  *     exported by name
 530  */
 531 DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp)
 532 { FIXME("(%p):stub.\n", lpFileOp);
 533   return 1;
 534 }
 535
 536 /*************************************************************************
 537  * SHChangeNotify                               [SHELL32.239]
 538  *
 539  * NOTES
 540  *     exported by name
 541  */
 542 DWORD WINAPI SHChangeNotify (
 543     INT   wEventId,  /* [IN] flags that specifies the event*/
 544     UINT  uFlags,   /* [IN] the meaning of dwItem[1|2]*/
 545                 LPCVOID dwItem1,
 546                 LPCVOID dwItem2)
 547 { FIXME("(0x%08x,0x%08ux,%p,%p):stub.\n", wEventId,uFlags,dwItem1,dwItem2);
 548   return 0;
 549 }
 550 /*************************************************************************
 551  * SHCreateShellFolderViewEx                    [SHELL32.174]
 552  *
 553  * NOTES
 554  *  see IShellFolder::CreateViewObject
 555  */
 556 HRESULT WINAPI SHCreateShellFolderViewEx(
 557   LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/
 558   LPVOID* ppv)            /*[out] IShellView pointer*/
 559 { FIXME("(%p,%p):stub.\n", psvcbi,ppv);
 560   return 0;
 561 }
 562 /*************************************************************************
 563  *  SHWinHelp                                   [SHELL32.127]
 564  *
 565  */
 566 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
 567 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
 568         return 0;
 569 }
 570 /*************************************************************************
 571  *  SHRunControlPanel [SHELL32.161]
 572  *
 573  */
 574 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
 575 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
 576         return 0;
 577 }
 578 /*************************************************************************
 579  * ShellExecuteEx                               [SHELL32.291]
 580  *
 581  */
 582 BOOL WINAPI ShellExecuteExAW (LPVOID sei)
 583 {       if (VERSION_OsIsUnicode())
 584           return ShellExecuteExW (sei);
 585         return ShellExecuteExA (sei);
 586 }
 587 /*************************************************************************
 588  * ShellExecuteExA                              [SHELL32.292]
 589  *
 590  */
 591 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
 592 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
 593         LPSTR pos;
 594         int gap, len;
 595         STARTUPINFOA  startupinfo;
 596         PROCESS_INFORMATION processinformation;
 597
 598         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
 599                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
 600                 sei->lpParameters, sei->lpDirectory, sei->nShow,
 601                 (sei->fMask & SEE_MASK_CLASSNAME) ? sei->lpClass : "not used");
 602
 603         ZeroMemory(szApplicationName,MAX_PATH);
 604         if (sei->lpFile)
 605           strcpy(szApplicationName, sei->lpFile);
 606
 607         ZeroMemory(szCommandline,MAX_PATH);
 608         if (sei->lpParameters)
 609           strcpy(szCommandline, sei->lpParameters);
 610
 611         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
 612                           SEE_MASK_NOCLOSEPROCESS | SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
 613                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
 614                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
 615         { FIXME("flags ignored: 0x%08lx\n", sei->fMask);
 616         }
 617
 618         if (sei->fMask & SEE_MASK_CLASSNAME)
 619         { HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
 620         }
 621
 622         /* process the IDList */
 623         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
 624         { SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
 625           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
 626         }
 627         else
 628         { if (sei->fMask & SEE_MASK_IDLIST )
 629           { /* %I is the adress of a global item ID*/
 630             pos = strstr(szCommandline, "%I");
 631             if (pos)
 632             { HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
 633               sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
 634               SHUnlockShared(hmem);
 635
 636               gap = strlen(szPidl);
 637               len = strlen(pos)-2;
 638               memmove(pos+gap,pos+2,len);
 639               memcpy(pos,szPidl,gap);
 640
 641             }
 642           }
 643         }
 644
 645         pos = strstr(szCommandline, ",%L");     /* dunno what it means: kill it*/
 646         if (pos)
 647         { len = strlen(pos)-2;
 648           *pos=0x0;
 649           memmove(pos,pos+3,len);
 650         }
 651
 652         TRACE("execute: %s %s\n",szApplicationName, szCommandline);
 653
 654         ZeroMemory(&startupinfo,sizeof(STARTUPINFOA));
 655         startupinfo.cb = sizeof(STARTUPINFOA);
 656
 657         return CreateProcessA(szApplicationName[0] ? szApplicationName:NULL,
 658                          szCommandline[0] ? szCommandline : NULL,
 659                          NULL, NULL, FALSE, 0,
 660                          NULL, NULL, &startupinfo, &processinformation);
 661
 662
 663 }
 664 /*************************************************************************
 665  * ShellExecuteExW                              [SHELL32.293]
 666  *
 667  */
 668 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
 669 {       SHELLEXECUTEINFOA seiA;
 670         DWORD ret;
 671
 672         TRACE("%p\n", sei);
 673
 674         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
 675
 676         if (sei->lpVerb)
 677           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
 678
 679         if (sei->lpFile)
 680           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
 681
 682         if (sei->lpParameters)
 683           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
 684
 685         if (sei->lpDirectory)
 686           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
 687
 688         if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
 689           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
 690         else
 691           seiA.lpClass = NULL;
 692
 693         ret = ShellExecuteExA(&seiA);
 694
 695         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
 696         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
 697         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
 698         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
 699         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
 700
 701         return ret;
 702 }
 703
 704 static LPUNKNOWN SHELL32_IExplorerInterface=0;
 705 /*************************************************************************
 706  * SHSetInstanceExplorer                        [SHELL32.176]
 707  *
 708  * NOTES
 709  *  Sets the interface
 710  */
 711 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
 712 {       TRACE("%p\n", lpUnknown);
 713         SHELL32_IExplorerInterface = lpUnknown;
 714         return (HRESULT) lpUnknown;
 715 }
 716 /*************************************************************************
 717  * SHGetInstanceExplorer                        [SHELL32.256]
 718  *
 719  * NOTES
 720  *  gets the interface pointer of the explorer and a reference
 721  */
 722 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
 723 {       TRACE("%p\n", lpUnknown);
 724
 725         *lpUnknown = SHELL32_IExplorerInterface;
 726
 727         if (!SHELL32_IExplorerInterface)
 728           return E_FAIL;
 729
 730         SHELL32_IExplorerInterface->lpvtbl->fnAddRef(SHELL32_IExplorerInterface);
 731         return NOERROR;
 732 }
 733 /*************************************************************************
 734  * SHFreeUnusedLibraries                        [SHELL32.123]
 735  *
 736  * NOTES
 737  *  exported by name
 738  */
 739 HRESULT WINAPI SHFreeUnusedLibraries (void)
 740 {       FIXME("stub\n");
 741         return TRUE;
 742 }
 743 /*************************************************************************
 744  * DAD_ShowDragImage                            [SHELL32.137]
 745  *
 746  * NOTES
 747  *  exported by name
 748  */
 749 HRESULT WINAPI DAD_ShowDragImage (DWORD u)
 750 { FIXME("0x%08lx stub\n",u);
 751   return 0;
 752 }
 753 /*************************************************************************
 754  * SHRegCloseKey                        [NT4.0:SHELL32.505]
 755  *
 756  */
 757 HRESULT WINAPI SHRegCloseKey (HKEY hkey)
 758 {       TRACE("0x%04x\n",hkey);
 759         return RegCloseKey( hkey );
 760 }
 761 /*************************************************************************
 762  * SHRegOpenKeyA                                [SHELL32.506]
 763  *
 764  */
 765 HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
 766 {
 767         TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
 768         return RegOpenKeyA(hKey, lpSubKey, phkResult);
 769 }
 770
 771 /*************************************************************************
 772  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
 773  *
 774  */
 775 HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
 776 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
 777         return RegOpenKeyW( hkey, lpszSubKey, retkey );
 778 }
 779 /*************************************************************************
 780  * SHRegQueryValueExA                           [SHELL32.509]
 781  *
 782  */
 783 HRESULT WINAPI SHRegQueryValueExA(
 784         HKEY hkey,
 785         LPSTR lpValueName,
 786         LPDWORD lpReserved,
 787         LPDWORD lpType,
 788         LPBYTE lpData,
 789         LPDWORD lpcbData)
 790 {
 791         TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 792         return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 793 }
 794 /*************************************************************************
 795  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
 796  *
 797  */
 798 HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
 799                                  LPWSTR lpszData, LPDWORD lpcbData )
 800 {       WARN("0x%04x %s %p %p semi-stub\n",
 801                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
 802         return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
 803 }
 804
 805 /*************************************************************************
 806  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
 807  *
 808  * FIXME
 809  *  if the datatype REG_EXPAND_SZ then expand the string and change
 810  *  *pdwType to REG_SZ.
 811  */
 812 HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
 813                  LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
 814 {       DWORD ret;
 815         WARN("0x%04x %s %p %p %p %p semi-stub\n",
 816                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
 817         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
 818         return ret;
 819 }
 820
 821 /*************************************************************************
 822  * ReadCabinetState                             [NT 4.0:SHELL32.651]
 823  *
 824  */
 825 HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
 826 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
 827         return 0;
 828 }
 829 /*************************************************************************
 830  * WriteCabinetState                            [NT 4.0:SHELL32.652]
 831  *
 832  */
 833 HRESULT WINAPI WriteCabinetState(DWORD u)
 834 {       FIXME("0x%04lx stub\n",u);
 835         return 0;
 836 }
 837 /*************************************************************************
 838  * FileIconInit                                 [SHELL32.660]
 839  *
 840  */
 841 BOOL WINAPI FileIconInit(BOOL bFullInit)
 842 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
 843         return 0;
 844 }
 845 /*************************************************************************
 846  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
 847  *
 848  */
 849 HRESULT WINAPI IsUserAdmin(void)
 850 {       FIXME("stub\n");
 851         return TRUE;
 852 }
 853 /*************************************************************************
 854  * StrRetToStrN                                 [SHELL32.96]
 855  *
 856  * converts a STRRET to a normal string
 857  *
 858  * NOTES
 859  *  the pidl is for STRRET OFFSET
 860  */
 861 HRESULT WINAPI StrRetToStrN (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
 862 {       TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
 863
 864         switch (src->uType)
 865         { case STRRET_WSTR:
 866             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
 867             SHFree(src->u.pOleStr);
 868             break;
 869
 870           case STRRET_CSTRA:
 871             if (VERSION_OsIsUnicode())
 872               lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
 873             else
 874               strncpy((LPSTR)dest, src->u.cStr, len);
 875             break;
 876
 877           case STRRET_OFFSETA:
 878             if (pidl)
 879             { if(VERSION_OsIsUnicode())
 880                 lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 881               else
 882                 strncpy((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 883               break;
 884             }
 885
 886           default:
 887             FIXME("unknown type!\n");
 888             if (len)
 889             { *(LPSTR)dest = '\0';
 890             }
 891             return(FALSE);
 892         }
 893         return(TRUE);
 894 }
 895
 896 /*************************************************************************
 897  * StrChrW                                      [NT 4.0:SHELL32.651]
 898  *
 899  */
 900 LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
 901 {       LPWSTR ptr=str;
 902
 903         TRACE("%s 0x%04x\n",debugstr_w(str),x);
 904         do
 905         {  if (*ptr==x)
 906            { return ptr;
 907            }
 908            ptr++;
 909         } while (*ptr);
 910         return NULL;
 911 }
 912
 913 /*************************************************************************
 914  * StrCmpNIW                                    [NT 4.0:SHELL32.*]
 915  *
 916  */
 917 INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
 918 {       FIXME("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
 919         return 0;
 920 }
 921
 922 /*************************************************************************
 923  * SHAllocShared                                [SHELL32.520]
 924  *
 925  * NOTES
 926  *  parameter1 is return value from HeapAlloc
 927  *  parameter2 is equal to the size allocated with HeapAlloc
 928  *  parameter3 is return value from GetCurrentProcessId
 929  *
 930  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
 931  *  WM_USER+2 could be the undocumented CWM_SETPATH
 932  *  the allocated memory contains a pidl
 933  */
 934 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
 935 {       HGLOBAL hmem;
 936         LPVOID pmem;
 937
 938         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
 939         hmem = GlobalAlloc(GMEM_FIXED, size);
 940         if (!hmem)
 941           return 0;
 942
 943         pmem =  GlobalLock (hmem);
 944
 945         if (! pmem)
 946           return 0;
 947
 948         memcpy (pmem, psrc, size);
 949         GlobalUnlock(hmem);
 950         return hmem;
 951 }
 952 /*************************************************************************
 953  * SHLockShared                                 [SHELL32.521]
 954  *
 955  * NOTES
 956  *  parameter1 is return value from SHAllocShared
 957  *  parameter2 is return value from GetCurrentProcessId
 958  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
 959  *  the returnvalue seems to be a memoryadress
 960  */
 961 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
 962 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
 963         return GlobalLock(hmem);
 964 }
 965 /*************************************************************************
 966  * SHUnlockShared                               [SHELL32.522]
 967  *
 968  * NOTES
 969  *  parameter1 is return value from SHLockShared
 970  */
 971 BOOL WINAPI SHUnlockShared(HANDLE pmem)
 972 {       TRACE("handle=0x%04x\n",pmem);
 973         return GlobalUnlock(pmem);
 974 }
 975 /*************************************************************************
 976  * SHFreeShared                                 [SHELL32.523]
 977  *
 978  * NOTES
 979  *  parameter1 is return value from SHAllocShared
 980  *  parameter2 is return value from GetCurrentProcessId
 981  */
 982 HANDLE WINAPI SHFreeShared(HANDLE hmem, DWORD procID)
 983 {       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
 984         return GlobalFree(hmem);
 985 }
 986
 987 /*************************************************************************
 988  * SetAppStartingCursor                         [SHELL32.99]
 989  *
 990  */
 991 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
 992 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
 993         return 0;
 994 }
 995 /*************************************************************************
 996  * SHLoadOLE                                    [SHELL32.151]
 997  *
 998  */
 999 HRESULT WINAPI SHLoadOLE(DWORD u)
1000 {       FIXME("0x%04lx stub\n",u);
1001         return S_OK;
1002 }
1003 /*************************************************************************
1004  * DriveType                                    [SHELL32.64]
1005  *
1006  */
1007 HRESULT WINAPI DriveType(DWORD u)
1008 {       FIXME("0x%04lx stub\n",u);
1009         return 0;
1010 }
1011 /*************************************************************************
1012  * SHAbortInvokeCommand                         [SHELL32.198]
1013  *
1014  */
1015 HRESULT WINAPI SHAbortInvokeCommand(void)
1016 {       FIXME("stub\n");
1017         return 1;
1018 }
1019 /*************************************************************************
1020  * SHOutOfMemoryMessageBox                      [SHELL32.126]
1021  *
1022  */
1023 HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
1024 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1025         return 0;
1026 }
1027 /*************************************************************************
1028  * SHFlushClipboard                             [SHELL32.121]
1029  *
1030  */
1031 HRESULT WINAPI SHFlushClipboard(void)
1032 {       FIXME("stub\n");
1033         return 1;
1034 }
1035 /*************************************************************************
1036  * StrRChrW                                     [SHELL32.320]
1037  *
1038  */
1039 LPWSTR WINAPI StrRChrW(LPWSTR lpStart, LPWSTR lpEnd, DWORD wMatch)
1040 {       LPWSTR wptr=NULL;
1041         TRACE("%s %s 0x%04x\n",debugstr_w(lpStart),debugstr_w(lpEnd), (WCHAR)wMatch );
1042
1043         /* if the end not given, search*/
1044         if (!lpEnd)
1045         { lpEnd=lpStart;
1046           while (*lpEnd)
1047             lpEnd++;
1048         }
1049
1050         do
1051         { if (*lpStart==(WCHAR)wMatch)
1052             wptr = lpStart;
1053           lpStart++;
1054         } while ( lpStart<=lpEnd );
1055         return wptr;
1056 }
1057 /*************************************************************************
1058 * StrFormatByteSize                             [SHLWAPI]
1059 */
1060 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
1061 {       char buf[64];
1062         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1063         if ( dw<1024L )
1064         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1065         }
1066         else if ( dw<1048576L)
1067         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1068         }
1069         else if ( dw < 1073741824L)
1070         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1071         }
1072         else
1073         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1074         }
1075         strncpy (pszBuf, buf, cchBuf);
1076         return pszBuf;
1077 }
1078 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
1079 {       char buf[64];
1080         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1081         if ( dw<1024L )
1082         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1083         }
1084         else if ( dw<1048576L)
1085         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1086         }
1087         else if ( dw < 1073741824L)
1088         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1089         }
1090         else
1091         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1092         }
1093         lstrcpynAtoW (pszBuf, buf, cchBuf);
1094         return pszBuf;
1095 }
1096 /*************************************************************************
1097  * SHWaitForFileToOpen                          [SHELL32.97]
1098  *
1099  */
1100 HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
1101 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1102         return 0;
1103 }
1104 /*************************************************************************
1105  * Control_FillCache_RunDLL                     [SHELL32.8]
1106  *
1107  */
1108 HRESULT WINAPI Control_FillCache_RunDLL(HWND hWnd, HANDLE hModule, DWORD w, DWORD x)
1109 {       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
1110         return 0;
1111 }
1112 /*************************************************************************
1113  * RunDLL_CallEntry16                           [SHELL32.122]
1114  * the name is propably wrong
1115  */
1116 HRESULT WINAPI RunDLL_CallEntry16(DWORD v, DWORD w, DWORD x, DWORD y, DWORD z)
1117 {       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
1118         return 0;
1119 }
1120
1121 /************************************************************************
1122  *      shell32_654                             [SHELL32.654]
1123  *
1124  * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
1125  * second one could be a size (0x0c). The size is the same as the structure saved to
1126  * HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1127  * I'm (js) guessing: this one is just ReadCabinetState ;-)
1128  */
1129 HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
1130 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
1131         return 0;
1132 }
1133
1134 /************************************************************************
1135  *      RLBuildListOfPaths                      [SHELL32.146]
1136  *
1137  * NOTES
1138  *   builds a DPA
1139  */
1140 DWORD WINAPI RLBuildListOfPaths ()
1141 {       FIXME("stub\n");
1142         return 0;
1143 }
1144 /************************************************************************
1145  *      StrToOleStr                     [SHELL32.163]
1146  *
1147  */
1148 int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
1149 {
1150         TRACE("%p %p(%s)\n",
1151         lpWideCharStr, lpMultiByteString, lpMultiByteString);
1152
1153         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
1154
1155 }
1156 int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
1157 {
1158         TRACE("%p %p(%s)\n",
1159         lpWideCharStr, lpWString, debugstr_w(lpWString));
1160
1161         if (lstrcpyW (lpWideCharStr, lpWString ))
1162         { return lstrlenW (lpWideCharStr);
1163         }
1164         return 0;
1165 }
1166
1167 BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
1168 {
1169         if (VERSION_OsIsUnicode())
1170           return StrToOleStrW (lpWideCharStr, lpString);
1171         return StrToOleStrA (lpWideCharStr, lpString);
1172 }
1173
1174 /************************************************************************
1175  *      SHValidateUNC                           [SHELL32.173]
1176  *
1177  */
1178 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1179 {
1180         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1181         return 0;
1182 }
1183
1184 /************************************************************************
1185  *      DoEnvironmentSubstW                     [SHELL32.53]
1186  *
1187  */
1188 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
1189 {
1190         FIXME("%p(%s) %p(%s) stub\n", x, x, y, y);
1191         return 0;
1192 }
1193
1194 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
1195 {
1196         FIXME("%p(%s) %p(%s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
1197         return 0;
1198 }
1199
1200 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
1201 {
1202         if (VERSION_OsIsUnicode())
1203           return DoEnvironmentSubstW(x, y);
1204         return DoEnvironmentSubstA(x, y);
1205 }