source: trunk/src/shell32/shellord.cpp@ 1214

Last change on this file since 1214 was 1214, checked in by sandervl, 26 years ago

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