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

Last change on this file since 2012 was 1551, checked in by phaller, 26 years ago

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