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