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  */
 211 BOOL WINAPI StrToOleStrN (LPWSTR lpWide, INT nWide, LPCSTR lpMulti, INT nMulti)
 212 {
 213         TRACE("%s %x %s %x\n", debugstr_w(lpWide), nWide, lpMulti, nMulti);
 214         return MultiByteToWideChar (0, 0, lpMulti, nMulti, lpWide, nWide);
 215 }
 216
 217 /*************************************************************************
 218  * RegisterShellHook                            [SHELL32.181]
 219  *
 220  * PARAMS
 221  *      hwnd [I]  window handle
 222  *      y    [I]  flag ????
 223  *
 224  * NOTES
 225  *     exported by ordinal
 226  */
 227 void WINAPI RegisterShellHook(HWND hwnd, DWORD y) {
 228     FIXME("(0x%08x,0x%08lx):stub.\n",hwnd,y);
 229 }
 230 /*************************************************************************
 231  * ShellMessageBoxW                             [SHELL32.182]
 232  *
 233  * Format and output errormessage.
 234  *
 235  * idText       resource ID of title or LPSTR
 236  * idTitle      resource ID of title or LPSTR
 237  *
 238  * NOTES
 239  *     exported by ordinal
 240  */
 241 INT __cdecl
 242 ShellMessageBoxW(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 243 {       WCHAR   szText[100],szTitle[100],szTemp[256];
 244         LPWSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 245         LPVOID  args = &arglist;
 246
 247         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",(DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 248
 249         if (!HIWORD (idTitle))
 250           LoadStringW(hmod,idTitle,pszTitle,100);
 251         else
 252           pszTitle = (LPWSTR)idTitle;
 253
 254         if (! HIWORD (idText))
 255           LoadStringW(hmod,idText,pszText,100);
 256         else
 257           pszText = (LPWSTR)idText;
 258
 259         FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,szText,0,0,szTemp,256,args);
 260         return MessageBoxW(hwnd,szTemp,szTitle,uType);
 261 }
 262
 263 /*************************************************************************
 264  * ShellMessageBoxA                             [SHELL32.183]
 265  */
 266 INT __cdecl
 267 ShellMessageBoxA(HMODULE hmod,HWND hwnd,DWORD idText,DWORD idTitle,DWORD uType,LPCVOID arglist)
 268 {       char    szText[100],szTitle[100],szTemp[256];
 269         LPSTR   pszText = &szText[0], pszTitle = &szTitle[0];
 270         LPVOID  args = &arglist;
 271
 272         TRACE("(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n", (DWORD)hmod,(DWORD)hwnd,idText,idTitle,uType,arglist);
 273
 274         if (!HIWORD (idTitle))
 275           LoadStringA(hmod,idTitle,pszTitle,100);
 276         else
 277           pszTitle = (LPSTR)idTitle;
 278
 279         if (! HIWORD (idText))
 280           LoadStringA(hmod,idText,pszText,100);
 281         else
 282           pszText = (LPSTR)idText;
 283
 284         FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY ,pszText,0,0,szTemp,256,args);
 285         return MessageBoxA(hwnd,szTemp,pszTitle,uType);
 286 }
 287
 288 /*************************************************************************
 289  * SHRestricted                         [SHELL32.100]
 290  *
 291  * walks through policy table, queries <app> key, <type> value, returns
 292  * queried (DWORD) value.
 293  * {0x00001,Explorer,NoRun}
 294  * {0x00002,Explorer,NoClose}
 295  * {0x00004,Explorer,NoSaveSettings}
 296  * {0x00008,Explorer,NoFileMenu}
 297  * {0x00010,Explorer,NoSetFolders}
 298  * {0x00020,Explorer,NoSetTaskbar}
 299  * {0x00040,Explorer,NoDesktop}
 300  * {0x00080,Explorer,NoFind}
 301  * {0x00100,Explorer,NoDrives}
 302  * {0x00200,Explorer,NoDriveAutoRun}
 303  * {0x00400,Explorer,NoDriveTypeAutoRun}
 304  * {0x00800,Explorer,NoNetHood}
 305  * {0x01000,Explorer,NoStartBanner}
 306  * {0x02000,Explorer,RestrictRun}
 307  * {0x04000,Explorer,NoPrinterTabs}
 308  * {0x08000,Explorer,NoDeletePrinter}
 309  * {0x10000,Explorer,NoAddPrinter}
 310  * {0x20000,Explorer,NoStartMenuSubFolders}
 311  * {0x40000,Explorer,MyDocsOnNet}
 312  * {0x80000,WinOldApp,NoRealMode}
 313  *
 314  * NOTES
 315  *     exported by ordinal
 316  */
 317 DWORD WINAPI SHRestricted (DWORD pol) {
 318         HKEY    xhkey;
 319
 320         FIXME("(%08lx):stub.\n",pol);
 321         if (RegOpenKeyA(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 322                 return 0;
 323         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 324         RegCloseKey(xhkey);
 325         return 0;
 326 }
 327
 328 /*************************************************************************
 329  * SHCreateDirectory                            [SHELL32.165]
 330  *
 331  * NOTES
 332  *  exported by ordinal
 333  *  not sure about LPSECURITY_ATTRIBUTES
 334  */
 335 DWORD WINAPI SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,LPCSTR path) {
 336         TRACE("(%p,%s):stub.\n",sec,path);
 337         if (CreateDirectoryA(path,sec))
 338                 return TRUE;
 339         /* SHChangeNotify(8,1,path,0); */
 340         return FALSE;
 341 #if 0
 342         if (SHELL32_79(path,(LPVOID)x))
 343                 return 0;
 344         FIXME("(%08lx,%s):stub.\n",x,path);
 345         return 0;
 346 #endif
 347 }
 348
 349 /*************************************************************************
 350  * SHFree                                       [SHELL32.195]
 351  *
 352  * NOTES
 353  *     free_ptr() - frees memory using IMalloc
 354  *     exported by ordinal
 355  */
 356 DWORD WINAPI SHFree(LPVOID x) {
 357   TRACE("%p\n",x);
 358   if (!HIWORD(x))
 359   { *(LPDWORD)0xdeaf0000 = 0;
 360   }
 361   return 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  /* void * ret = (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT);*/ /* chrashes */
 373  void * ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
 374   TRACE("%lu bytes at %p\n",len, ret);
 375   return ret;
 376 }
 377
 378 /*************************************************************************
 379  * SHRegisterDragDrop                           [SHELL32.86]
 380  *
 381  * NOTES
 382  *     exported by ordinal
 383  */
 384 DWORD WINAPI SHRegisterDragDrop(HWND hWnd,IDropTarget * pDropTarget)
 385 {
 386         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
 387         return     RegisterDragDrop(hWnd, pDropTarget);
 388 }
 389
 390 /*************************************************************************
 391  * SHRevokeDragDrop                             [SHELL32.87]
 392  *
 393  * NOTES
 394  *     exported by ordinal
 395  */
 396 DWORD WINAPI SHRevokeDragDrop(DWORD x) {
 397     FIXME("(0x%08lx):stub.\n",x);
 398     return 0;
 399 }
 400
 401 /*************************************************************************
 402  * RunFileDlg                                   [SHELL32.61]
 403  *
 404  * NOTES
 405  *     Original name: RunFileDlg (exported by ordinal)
 406  */
 407 DWORD WINAPI
 408 RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
 409             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
 410 {
 411     FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
 412            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
 413     return 0;
 414 }
 415
 416 /*************************************************************************
 417  * ExitWindowsDialog                            [SHELL32.60]
 418  *
 419  * NOTES
 420  *     exported by ordinal
 421  */
 422 void WINAPI ExitWindowsDialog (HWND hWndOwner)
 423 {
 424         TRACE("(0x%08x)\n", hWndOwner);
 425         if (MessageBoxA( hWndOwner, "Do you want to exit WINE?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDOK)
 426         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
 427         }
 428 }
 429
 430 /*************************************************************************
 431  * ArrangeWindows                               [SHELL32.184]
 432  *
 433  */
 434 DWORD WINAPI
 435 ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
 436                 DWORD dwParam4, DWORD dwParam5)
 437 {
 438     FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
 439            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
 440     return 0;
 441 }
 442
 443 /*************************************************************************
 444  * SignalFileOpen                               [SHELL32.103]
 445  *
 446  * NOTES
 447  *     exported by ordinal
 448  */
 449 DWORD WINAPI
 450 SignalFileOpen (DWORD dwParam1)
 451 {
 452     FIXME("(0x%08lx):stub.\n", dwParam1);
 453
 454     return 0;
 455 }
 456
 457 /*************************************************************************
 458  * SHAddToRecentDocs                            [SHELL32.234]
 459  *
 460  * PARAMETERS
 461  *   uFlags  [IN] SHARD_PATH or SHARD_PIDL
 462  *   pv      [IN] string or pidl, NULL clears the list
 463  *
 464  * NOTES
 465  *     exported by name
 466  */
 467 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 468 { if (SHARD_PIDL==uFlags)
 469   { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
 470         }
 471         else
 472         { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
 473         }
 474   return 0;
 475 }
 476 /*************************************************************************
 477  * SHFileOperation                              [SHELL32.242]
 478  *
 479  */
 480 DWORD WINAPI SHFileOperationAW(DWORD x)
 481 {       FIXME("0x%08lx stub\n",x);
 482         return 0;
 483
 484 }
 485
 486 /*************************************************************************
 487  * SHFileOperationA                             [SHELL32.243]
 488  *
 489  * NOTES
 490  *     exported by name
 491  */
 492 DWORD WINAPI SHFileOperationA (LPSHFILEOPSTRUCTA lpFileOp)
 493 { FIXME("(%p):stub.\n", lpFileOp);
 494   return 1;
 495 }
 496 /*************************************************************************
 497  * SHFileOperationW                             [SHELL32.244]
 498  *
 499  * NOTES
 500  *     exported by name
 501  */
 502 DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp)
 503 { FIXME("(%p):stub.\n", lpFileOp);
 504   return 1;
 505 }
 506
 507 /*************************************************************************
 508  * SHChangeNotify                               [SHELL32.239]
 509  *
 510  * NOTES
 511  *     exported by name
 512  */
 513 DWORD WINAPI SHChangeNotify (
 514     INT   wEventId,  /* [IN] flags that specifies the event*/
 515     UINT  uFlags,   /* [IN] the meaning of dwItem[1|2]*/
 516                 LPCVOID dwItem1,
 517                 LPCVOID dwItem2)
 518 { FIXME("(0x%08x,0x%08ux,%p,%p):stub.\n", wEventId,uFlags,dwItem1,dwItem2);
 519   return 0;
 520 }
 521 /*************************************************************************
 522  * SHCreateShellFolderViewEx                    [SHELL32.174]
 523  *
 524  * NOTES
 525  *  see IShellFolder::CreateViewObject
 526  */
 527 HRESULT WINAPI SHCreateShellFolderViewEx(
 528   LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/
 529   LPVOID* ppv)            /*[out] IShellView pointer*/
 530 { FIXME("(%p,%p):stub.\n", psvcbi,ppv);
 531   return 0;
 532 }
 533 /*************************************************************************
 534  *  SHWinHelp                                   [SHELL32.127]
 535  *
 536  */
 537 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
 538 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
 539         return 0;
 540 }
 541 /*************************************************************************
 542  *  SHRunControlPanel [SHELL32.161]
 543  *
 544  */
 545 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
 546 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
 547         return 0;
 548 }
 549 /*************************************************************************
 550  * ShellExecuteEx                               [SHELL32.291]
 551  *
 552  */
 553 BOOL WINAPI ShellExecuteExAW (LPVOID sei)
 554 {       if (VERSION_OsIsUnicode())
 555           return ShellExecuteExW (sei);
 556         return ShellExecuteExA (sei);
 557 }
 558 /*************************************************************************
 559  * ShellExecuteExA                              [SHELL32.292]
 560  *
 561  */
 562 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
 563 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
 564         LPSTR pos;
 565         int gap, len;
 566         STARTUPINFOA  startupinfo;
 567         PROCESS_INFORMATION processinformation;
 568
 569         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
 570                 sei->fMask, sei->hwnd, sei->lpVerb, sei->lpFile,
 571                 sei->lpParameters, sei->lpDirectory, sei->nShow, sei->lpClass);
 572
 573         ZeroMemory(szApplicationName,MAX_PATH);
 574         if (sei->lpFile)
 575           strcpy(szApplicationName, sei->lpFile);
 576
 577         ZeroMemory(szCommandline,MAX_PATH);
 578         if (sei->lpParameters)
 579           strcpy(szCommandline, sei->lpParameters);
 580
 581         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
 582                           SEE_MASK_NOCLOSEPROCESS | SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
 583                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
 584                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
 585         { FIXME("flags ignored: 0x%08lx\n", sei->fMask);
 586         }
 587
 588         if (sei->fMask & SEE_MASK_CLASSNAME)
 589         { HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, 256);
 590         }
 591
 592         /* process the IDList */
 593         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
 594         { SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
 595           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
 596         }
 597         else
 598         { if (sei->fMask & SEE_MASK_IDLIST )
 599           { /* %I is the adress of a global item ID*/
 600             pos = strstr(szCommandline, "%I");
 601             if (pos)
 602             { HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
 603               sprintf(szPidl,":%li",(DWORD)SHLockShared(hmem,0) );
 604               SHUnlockShared(hmem);
 605
 606               gap = strlen(szPidl);
 607               len = strlen(pos)-2;
 608               memmove(pos+gap,pos+2,len);
 609               memcpy(pos,szPidl,gap);
 610
 611             }
 612           }
 613         }
 614
 615         pos = strstr(szCommandline, ",%L");     /* dunno what it means: kill it*/
 616         if (pos)
 617         { len = strlen(pos)-2;
 618           *pos=0x0;
 619           memmove(pos,pos+3,len);
 620         }
 621
 622         TRACE("execute: %s %s\n",szApplicationName, szCommandline);
 623
 624         ZeroMemory(&startupinfo,sizeof(STARTUPINFOA));
 625         startupinfo.cb = sizeof(STARTUPINFOA);
 626
 627         return CreateProcessA(szApplicationName[0] ? szApplicationName:NULL,
 628                          szCommandline[0] ? szCommandline : NULL,
 629                          NULL, NULL, FALSE, 0,
 630                          NULL, NULL, &startupinfo, &processinformation);
 631
 632
 633 }
 634 /*************************************************************************
 635  * ShellExecuteExW                              [SHELL32.293]
 636  *
 637  */
 638 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
 639 {       SHELLEXECUTEINFOA seiA;
 640         DWORD ret;
 641
 642         TRACE("%p\n", sei);
 643
 644         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
 645
 646         if (sei->lpVerb)
 647           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
 648
 649         if (sei->lpFile)
 650           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
 651
 652         if (sei->lpParameters)
 653           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
 654
 655         if (sei->lpDirectory)
 656           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
 657
 658         if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
 659           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
 660         else
 661           seiA.lpClass = NULL;
 662
 663         ret = ShellExecuteExA(&seiA);
 664
 665         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
 666         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
 667         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
 668         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
 669         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
 670
 671         return ret;
 672 }
 673
 674 static LPUNKNOWN SHELL32_IExplorerInterface=0;
 675 /*************************************************************************
 676  * SHSetInstanceExplorer                        [SHELL32.176]
 677  *
 678  * NOTES
 679  *  Sets the interface
 680  */
 681 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
 682 {       TRACE("%p\n", lpUnknown);
 683         SHELL32_IExplorerInterface = lpUnknown;
 684         return (HRESULT) lpUnknown;
 685 }
 686 /*************************************************************************
 687  * SHGetInstanceExplorer                        [SHELL32.256]
 688  *
 689  * NOTES
 690  *  gets the interface pointer of the explorer and a reference
 691  */
 692 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
 693 {       TRACE("%p\n", lpUnknown);
 694
 695         *lpUnknown = SHELL32_IExplorerInterface;
 696
 697         if (!SHELL32_IExplorerInterface)
 698           return E_FAIL;
 699
 700         SHELL32_IExplorerInterface->lpvtbl->fnAddRef(SHELL32_IExplorerInterface);
 701         return NOERROR;
 702 }
 703 /*************************************************************************
 704  * SHFreeUnusedLibraries                        [SHELL32.123]
 705  *
 706  * NOTES
 707  *  exported by name
 708  */
 709 HRESULT WINAPI SHFreeUnusedLibraries (void)
 710 {       FIXME("stub\n");
 711         return TRUE;
 712 }
 713 /*************************************************************************
 714  * DAD_ShowDragImage                            [SHELL32.137]
 715  *
 716  * NOTES
 717  *  exported by name
 718  */
 719 HRESULT WINAPI DAD_ShowDragImage (DWORD u)
 720 { FIXME("0x%08lx stub\n",u);
 721   return 0;
 722 }
 723 /*************************************************************************
 724  * SHRegCloseKey                        [NT4.0:SHELL32.505]
 725  *
 726  */
 727 HRESULT WINAPI SHRegCloseKey (HKEY hkey)
 728 {       TRACE("0x%04x\n",hkey);
 729         return RegCloseKey( hkey );
 730 }
 731 /*************************************************************************
 732  * SHRegOpenKeyA                                [SHELL32.506]
 733  *
 734  */
 735 HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
 736 {       FIXME("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey),
 737               phkResult);
 738         return RegOpenKeyA(hKey, lpSubKey, phkResult);
 739 }
 740
 741 /*************************************************************************
 742  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
 743  *
 744  */
 745 HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
 746 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
 747         return RegOpenKeyW( hkey, lpszSubKey, retkey );
 748 }
 749 /*************************************************************************
 750  * SHRegQueryValueExA                           [SHELL32.509]
 751  *
 752  */
 753 HRESULT WINAPI SHRegQueryValueExA(DWORD u, LPSTR v, DWORD w, DWORD x,
 754                                   DWORD y, DWORD z)
 755 {       FIXME("0x%04lx %s 0x%04lx 0x%04lx 0x%04lx  0x%04lx stub\n",
 756                 u,debugstr_a(v),w,x,y,z);
 757         return 0;
 758 }
 759 /*************************************************************************
 760  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
 761  *
 762  */
 763 HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
 764                                  LPWSTR lpszData, LPDWORD lpcbData )
 765 {       WARN("0x%04x %s %p %p semi-stub\n",
 766                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
 767         return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
 768 }
 769
 770 /*************************************************************************
 771  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
 772  *
 773  * FIXME
 774  *  if the datatype REG_EXPAND_SZ then expand the string and change
 775  *  *pdwType to REG_SZ.
 776  */
 777 HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
 778                  LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
 779 {       DWORD ret;
 780         WARN("0x%04x %s %p %p %p %p semi-stub\n",
 781                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
 782         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
 783         return ret;
 784 }
 785
 786 /*************************************************************************
 787  * ReadCabinetState                             [NT 4.0:SHELL32.651]
 788  *
 789  */
 790 HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
 791 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
 792         return 0;
 793 }
 794 /*************************************************************************
 795  * WriteCabinetState                            [NT 4.0:SHELL32.652]
 796  *
 797  */
 798 HRESULT WINAPI WriteCabinetState(DWORD u)
 799 {       FIXME("0x%04lx stub\n",u);
 800         return 0;
 801 }
 802 /*************************************************************************
 803  * FileIconInit                                 [SHELL32.660]
 804  *
 805  */
 806 BOOL WINAPI FileIconInit(BOOL bFullInit)
 807 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
 808         return 0;
 809 }
 810 /*************************************************************************
 811  * IsUserAdmin                                  [NT 4.0:SHELL32.680]
 812  *
 813  */
 814 HRESULT WINAPI IsUserAdmin(void)
 815 {       FIXME("stub\n");
 816         return TRUE;
 817 }
 818 /*************************************************************************
 819  * StrRetToStrN                                 [SHELL32.96]
 820  *
 821  * converts a STRRET to a normal string
 822  *
 823  * NOTES
 824  *  the pidl is for STRRET OFFSET
 825  */
 826 HRESULT WINAPI StrRetToStrN (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
 827 {       TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
 828
 829         switch (src->uType)
 830         { case STRRET_WSTR:
 831             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
 832             SHFree(src->u.pOleStr);
 833             break;
 834
 835           case STRRET_CSTRA:
 836             if (VERSION_OsIsUnicode())
 837               lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
 838             else
 839               strncpy((LPSTR)dest, src->u.cStr, len);
 840             break;
 841
 842           case STRRET_OFFSETA:
 843             if (pidl)
 844             { if(VERSION_OsIsUnicode())
 845                 lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 846               else
 847                 strncpy((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
 848               break;
 849             }
 850
 851           default:
 852             FIXME("unknown type!\n");
 853             if (len)
 854             { *(LPSTR)dest = '\0';
 855             }
 856             return(FALSE);
 857         }
 858         return(TRUE);
 859 }
 860
 861 /*************************************************************************
 862  * StrChrW                                      [NT 4.0:SHELL32.651]
 863  *
 864  */
 865 LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
 866 {       LPWSTR ptr=str;
 867
 868         TRACE("%s 0x%04x\n",debugstr_w(str),x);
 869         do
 870         {  if (*ptr==x)
 871            { return ptr;
 872            }
 873            ptr++;
 874         } while (*ptr);
 875         return NULL;
 876 }
 877
 878 /*************************************************************************
 879  * StrCmpNIW                                    [NT 4.0:SHELL32.*]
 880  *
 881  */
 882 INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
 883 {       FIXME("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
 884         return 0;
 885 }
 886
 887 /*************************************************************************
 888  * SHAllocShared                                [SHELL32.520]
 889  *
 890  * NOTES
 891  *  parameter1 is return value from HeapAlloc
 892  *  parameter2 is equal to the size allocated with HeapAlloc
 893  *  parameter3 is return value from GetCurrentProcessId
 894  *
 895  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
 896  *  WM_USER+2 could be the undocumented CWM_SETPATH
 897  *  the allocated memory contains a pidl
 898  */
 899 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
 900 {       HGLOBAL hmem;
 901         LPVOID pmem;
 902
 903         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
 904         hmem = GlobalAlloc(GMEM_FIXED, size);
 905         if (!hmem)
 906           return 0;
 907
 908         pmem =  GlobalLock (hmem);
 909
 910         if (! pmem)
 911           return 0;
 912
 913         memcpy (pmem, psrc, size);
 914         GlobalUnlock(hmem);
 915         return hmem;
 916 }
 917 /*************************************************************************
 918  * SHLockShared                                 [SHELL32.521]
 919  *
 920  * NOTES
 921  *  parameter1 is return value from SHAllocShared
 922  *  parameter2 is return value from GetCurrentProcessId
 923  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
 924  *  the returnvalue seems to be a memoryadress
 925  */
 926 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
 927 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
 928         return GlobalLock(hmem);
 929 }
 930 /*************************************************************************
 931  * SHUnlockShared                               [SHELL32.522]
 932  *
 933  * NOTES
 934  *  parameter1 is return value from SHLockShared
 935  */
 936 BOOL WINAPI SHUnlockShared(HANDLE pmem)
 937 {       TRACE("handle=0x%04x\n",pmem);
 938         return GlobalUnlock(pmem);
 939 }
 940 /*************************************************************************
 941  * SHFreeShared                                 [SHELL32.523]
 942  *
 943  * NOTES
 944  *  parameter1 is return value from SHAllocShared
 945  *  parameter2 is return value from GetCurrentProcessId
 946  */
 947 HANDLE WINAPI SHFreeShared(HANDLE hmem, DWORD procID)
 948 {       TRACE("handle=0x%04x 0x%04lx\n",hmem,procID);
 949         return GlobalFree(hmem);
 950 }
 951
 952 /*************************************************************************
 953  * SetAppStartingCursor                         [SHELL32.99]
 954  *
 955  */
 956 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
 957 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
 958         return 0;
 959 }
 960 /*************************************************************************
 961  * SHLoadOLE                                    [SHELL32.151]
 962  *
 963  */
 964 HRESULT WINAPI SHLoadOLE(DWORD u)
 965 {       FIXME("0x%04lx stub\n",u);
 966         return S_OK;
 967 }
 968 /*************************************************************************
 969  * DriveType                                    [SHELL32.64]
 970  *
 971  */
 972 HRESULT WINAPI DriveType(DWORD u)
 973 {       FIXME("0x%04lx stub\n",u);
 974         return 0;
 975 }
 976 /*************************************************************************
 977  * SHAbortInvokeCommand                         [SHELL32.198]
 978  *
 979  */
 980 HRESULT WINAPI SHAbortInvokeCommand(void)
 981 {       FIXME("stub\n");
 982         return 1;
 983 }
 984 /*************************************************************************
 985  * SHOutOfMemoryMessageBox                      [SHELL32.126]
 986  *
 987  */
 988 HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
 989 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
 990         return 0;
 991 }
 992 /*************************************************************************
 993  * SHFlushClipboard                             [SHELL32.121]
 994  *
 995  */
 996 HRESULT WINAPI SHFlushClipboard(void)
 997 {       FIXME("stub\n");
 998         return 1;
 999 }
1000 /*************************************************************************
1001  * StrRChrW                                     [SHELL32.320]
1002  *
1003  */
1004 LPWSTR WINAPI StrRChrW(LPWSTR lpStart, LPWSTR lpEnd, DWORD wMatch)
1005 {       LPWSTR wptr=NULL;
1006         TRACE("%s %s 0x%04x\n",debugstr_w(lpStart),debugstr_w(lpEnd), (WCHAR)wMatch );
1007
1008         /* if the end not given, search*/
1009         if (!lpEnd)
1010         { lpEnd=lpStart;
1011           while (*lpEnd)
1012             lpEnd++;
1013         }
1014
1015         do
1016         { if (*lpStart==(WCHAR)wMatch)
1017             wptr = lpStart;
1018           lpStart++;
1019         } while ( lpStart<=lpEnd );
1020         return wptr;
1021 }
1022 /*************************************************************************
1023 * StrFormatByteSize                             [SHLWAPI]
1024 */
1025 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
1026 {       char buf[64];
1027         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1028         if ( dw<1024L )
1029         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1030         }
1031         else if ( dw<1048576L)
1032         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1033         }
1034         else if ( dw < 1073741824L)
1035         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1036         }
1037         else
1038         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1039         }
1040         strncpy (pszBuf, buf, cchBuf);
1041         return pszBuf;
1042 }
1043 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
1044 {       char buf[64];
1045         TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
1046         if ( dw<1024L )
1047         { sprintf (buf,"%3.1f bytes", (FLOAT)dw);
1048         }
1049         else if ( dw<1048576L)
1050         { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
1051         }
1052         else if ( dw < 1073741824L)
1053         { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
1054         }
1055         else
1056         { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
1057         }
1058         lstrcpynAtoW (pszBuf, buf, cchBuf);
1059         return pszBuf;
1060 }
1061 /*************************************************************************
1062  * SHWaitForFileToOpen                          [SHELL32.97]
1063  *
1064  */
1065 HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
1066 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
1067         return 0;
1068 }
1069 /*************************************************************************
1070  * Control_FillCache_RunDLL                     [SHELL32.8]
1071  *
1072  */
1073 HRESULT WINAPI Control_FillCache_RunDLL(HWND hWnd, HANDLE hModule, DWORD w, DWORD x)
1074 {       FIXME("0x%04x 0x%04x 0x%04lx 0x%04lx stub\n",hWnd, hModule,w,x);
1075         return 0;
1076 }
1077 /*************************************************************************
1078  * RunDLL_CallEntry16                           [SHELL32.122]
1079  * the name is propably wrong
1080  */
1081 HRESULT WINAPI RunDLL_CallEntry16(DWORD v, DWORD w, DWORD x, DWORD y, DWORD z)
1082 {       FIXME("0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",v,w,x,y,z);
1083         return 0;
1084 }
1085
1086 /************************************************************************
1087  *      shell32_654                             [SHELL32.654]
1088  *
1089  */
1090 HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
1091 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
1092         return 0;
1093 }
1094
1095 /************************************************************************
1096  *      RLBuildListOfPaths                      [SHELL32.146]
1097  *
1098  * NOTES
1099  *   builds a DPA
1100  */
1101 DWORD WINAPI RLBuildListOfPaths ()
1102 {       FIXME("stub\n");
1103         return 0;
1104 }
1105 /************************************************************************
1106  *      StrToOleStr                     [SHELL32.163]
1107  *
1108  */
1109 int WINAPI StrToOleStr (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
1110 {
1111         TRACE("%p %p(%s)\n",
1112         lpWideCharStr, lpMultiByteString, lpMultiByteString);
1113
1114         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
1115
1116 }
1117 /************************************************************************
1118  *      SHValidateUNC                           [SHELL32.173]
1119  *
1120  */
1121 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1122 {       FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1123         return 0;
1124 }