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

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

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