source: trunk/src/shell32/sh.cpp@ 273

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

ChangeLog
File size: 49.5 KB
Line 
1/* $Id: sh.cpp,v 1.6 1999-07-05 13:49:23 phaller Exp $ */
2
3/*
4 * Win32 SHELL32 for OS/2
5 * Copyright 1999 Patrick Haller
6 * Project Odin Software License can be found in LICENSE.TXT
7 */
8
9
10/*****************************************************************************
11 * Includes *
12 *****************************************************************************/
13
14#include <os2win.h>
15#include <shellapi.h>
16#include <winreg.h>
17//#include <shlobj.h> @@@PH shlobj is yet to be ported
18#include "shell32.h"
19
20#include <stdarg.h>
21//#include <builtin.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include <misc.h>
27#include <nameid.h>
28#include <unicode.h>
29
30
31/*****************************************************************************
32 * Types & Defines *
33 *****************************************************************************/
34
35#define LPSHELLVIEWDATA LPVOID
36#define LPUNKNOWN LPVOID
37#define IDSTRUCT VOID
38#define LPSHELLFLAGSTATE LPVOID
39#define IDropTarget VOID
40
41static LPUNKNOWN SHELL32_IExplorerInterface=0;
42
43
44/*****************************************************************************
45 * Name : DWORD WIN32API SHChangeNotifyRegister
46 * Purpose :
47 * Parameters:
48 * Variables :
49 * Result :
50 * Remark : SHELL32.2
51 * Status : UNTESTED STUB
52 *
53 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
54 *
55 * NOTES
56 * Idlist is an array of structures and Count specifies how many items in the array
57 * (usually just one I think).
58 */
59
60DWORD WIN32API SHChangeNotifyRegister(HWND hwnd,
61 LONG events1,
62 LONG events2,
63 DWORD msg,
64 int count,
65 IDSTRUCT *idlist)
66{
67 dprintf(("SHELL32: SHChangeNotifyRegister(%08xh, %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
68 hwnd,
69 events1,
70 events2,
71 msg,
72 count,
73 idlist));
74
75 return 0;
76}
77
78
79/*****************************************************************************
80 * Name : DWORD WIN32API SHChangeNotifyDeregister
81 * Purpose :
82 * Parameters:
83 * Variables :
84 * Result :
85 * Remark : SHELL32.4
86 * Status : UNTESTED STUB
87 *
88 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
89 */
90
91DWORD WIN32API SHChangeNotifyDeregister(LONG x1)
92{
93 dprintf(("SHELL32: SHChangeNotifyDeregister(%08xh) not implemented.\n",
94 x1));
95
96 return 0;
97}
98
99
100/*****************************************************************************
101 * Name : void WIN32API SHGetSettings
102 * Purpose :
103 * Parameters:
104 * Variables :
105 * Result :
106 * Remark : SHELL32.68
107 * Status : UNTESTED STUB
108 *
109 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
110 *
111 * NOTES
112 * the registry path are for win98 (tested)
113 * and possibly are the same in nt40
114 */
115
116void WIN32API SHGetSettings(LPSHELLFLAGSTATE lpsfs,
117 DWORD dwMask,
118 DWORD dwx)
119{
120 HKEY hKey;
121 DWORD dwData;
122 DWORD dwDataSize = sizeof (DWORD);
123
124 dprintf(("SHELL32: SHGetSettings(%08xh, %08xh, %08xh)\n",
125 lpsfs,
126 dwMask,
127 dwx));
128
129 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
130 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
131 return;
132
133//@@@PH: todo
134#if 0
135 if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
136 lpsfs->fShowExtensions = ((dwData == 0) ? 0 : 1);
137
138 if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
139 lpsfs->fShowInfoTip = ((dwData == 0) ? 0 : 1);
140
141 if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
142 lpsfs->fDontPrettyPath = ((dwData == 0) ? 0 : 1);
143
144 if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
145 lpsfs->fHideIcons = ((dwData == 0) ? 0 : 1);
146
147 if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
148 lpsfs->fMapNetDrvBtn = ((dwData == 0) ? 0 : 1);
149
150 if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
151 lpsfs->fShowAttribCol = ((dwData == 0) ? 0 : 1);
152
153 if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
154 { if (dwData == 0)
155 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
156 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
157 }
158 else if (dwData == 1)
159 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 1;
160 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
161 }
162 else if (dwData == 2)
163 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
164 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 1;
165 }
166 }
167#endif
168
169 RegCloseKey (hKey);
170}
171
172
173/*****************************************************************************
174 * Name : int WIN32API SHShellFolderView_Message
175 * Purpose :
176 * Parameters:
177 * Variables :
178 * Result :
179 * Remark : SHELL32.73
180 * Status : UNTESTED STUB
181 *
182 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
183 *
184 * SHShellFolderView_Message [SHELL32.73]
185 *
186 * PARAMETERS
187 * hwndCabinet defines the explorer cabinet window that contains the
188 * shellview you need to communicate with
189 * uMsg identifying the SFVM enum to perform
190 * lParam
191 *
192 * NOTES
193 * Message SFVM_REARRANGE = 1
194 * This message gets sent when a column gets clicked to instruct the
195 * shell view to re-sort the item list. lParam identifies the column
196 * that was clicked.
197 */
198
199int WIN32API SHShellFolderView_Message(HWND hwndCabinet,
200 UINT uMsg,
201 LPARAM lParam)
202{
203 dprintf(("SHELL32: SHShellFolderView_Message(%08xh,%08xh,%08xh) not implemented.\n",
204 hwndCabinet,
205 uMsg,
206 lParam));
207
208 return 0;
209}
210
211
212
213
214/*****************************************************************************
215 * Name : DWORD WIN32API SHRegisterDragDrop
216 * Purpose :
217 * Parameters:
218 * Variables :
219 * Result :
220 * Remark : SHELL32.86
221 * Status : UNTESTED STUB
222 *
223 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
224 *
225 * NOTES
226 * exported by ordinal
227 */
228
229DWORD WIN32API SHRegisterDragDrop(HWND hWnd,
230 IDropTarget *pDropTarget)
231{
232 dprintf(("SHELL32: SHRegisterDragDrop(%08xh,%08xh)\n",
233 hWnd,
234 pDropTarget));
235
236 // return RegisterDragDrop(hWnd,
237 // pDropTarget);
238 return 0;
239}
240
241/*****************************************************************************
242 * Name : DWORD WIN32API SHRevokeDragDrop
243 * Purpose :
244 * Parameters:
245 * Variables :
246 * Result :
247 * Remark : SHELL32.87
248 * Status : UNTESTED STUB
249 *
250 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
251 *
252 * NOTES
253 * exported by ordinal
254 */
255
256DWORD WIN32API SHRevokeDragDrop(DWORD x)
257{
258 dprintf(("SHELL32: SHRevokeDragDrop(%08xh) not implemented.\n",
259 x));
260
261 return 0;
262}
263
264
265/*****************************************************************************
266 * Name : HRESULT SHWaitForFileToOpen
267 * Purpose :
268 * Parameters: DWORD x
269 * DWORD y
270 * DWORD z
271 * Variables :
272 * Result :
273 * Remark : SHELL32.97
274 * Status : UNTESTED STUB
275 *
276 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
277 *****************************************************************************/
278
279HRESULT WIN32API SHWaitForFileToOpen(DWORD u,
280 DWORD v,
281 DWORD w)
282{
283 dprintf(("SHELL32: SHWaitForFileToOpen(%08xh,%08xh,%08xh) not implemented.\n",
284 u,
285 v,
286 w));
287
288 return 0;
289}
290
291
292/*****************************************************************************
293 * Name : DWORD WIN32API SHRestricted
294 * Purpose :
295 * Parameters:
296 * Variables :
297 * Result :
298 * Remark : SHELL32.100
299 * Status : UNTESTED STUB
300 *
301 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
302 *
303 * walks through policy table, queries <app> key, <type> value, returns
304 * queried (DWORD) value.
305 * {0x00001,Explorer,NoRun}
306 * {0x00002,Explorer,NoClose}
307 * {0x00004,Explorer,NoSaveSettings}
308 * {0x00008,Explorer,NoFileMenu}
309 * {0x00010,Explorer,NoSetFolders}
310 * {0x00020,Explorer,NoSetTaskbar}
311 * {0x00040,Explorer,NoDesktop}
312 * {0x00080,Explorer,NoFind}
313 * {0x00100,Explorer,NoDrives}
314 * {0x00200,Explorer,NoDriveAutoRun}
315 * {0x00400,Explorer,NoDriveTypeAutoRun}
316 * {0x00800,Explorer,NoNetHood}
317 * {0x01000,Explorer,NoStartBanner}
318 * {0x02000,Explorer,RestrictRun}
319 * {0x04000,Explorer,NoPrinterTabs}
320 * {0x08000,Explorer,NoDeletePrinter}
321 * {0x10000,Explorer,NoAddPrinter}
322 * {0x20000,Explorer,NoStartMenuSubFolders}
323 * {0x40000,Explorer,MyDocsOnNet}
324 * {0x80000,WinOldApp,NoRealMode}
325 *
326 * NOTES
327 * exported by ordinal
328 */
329
330DWORD WIN32API SHRestricted (DWORD pol)
331{
332 HKEY xhkey;
333
334 dprintf(("SHELL32: SHRestricted(%08xh) not implemented.\n",
335 pol));
336
337 if (RegOpenKeyA(HKEY_CURRENT_USER,
338 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
339 &xhkey))
340 return 0;
341
342 /* FIXME: do nothing for now, just return 0 (== "allowed") */
343 RegCloseKey(xhkey);
344 return 0;
345}
346
347
348/*****************************************************************************
349 * Name : HRESULT SHFlushClipboard
350 * Purpose :
351 * Parameters:
352 * Variables :
353 * Result :
354 * Remark : SHELL32.121
355 * Status : UNTESTED STUB
356 *
357 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
358 *****************************************************************************/
359
360HRESULT WIN32API SHFlushClipboard(void)
361{
362 dprintf(("SHELL32: SHFlushClipboard() not implemented.\n"));
363
364 return 1;
365}
366
367
368/*****************************************************************************
369 * Name : HRESULT SHFreeUnusedLibraries
370 * Purpose :
371 * Parameters:
372 * Variables :
373 * Result :
374 * Remark : SHELL32.123
375 * Status : UNTESTED STUB
376 *
377 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
378 *****************************************************************************/
379
380HRESULT WIN32API SHFreeUnusedLibraries (void)
381{
382 dprintf(("SHELL32: SHFreeUnusedLibraries() not implemented.\n"));
383 return TRUE;
384}
385
386
387/*****************************************************************************
388 * Name : HRESULT SHWinHelp
389 * Purpose :
390 * Parameters:
391 * Variables :
392 * Result :
393 * Remark : SHELL32.127
394 * Status : UNTESTED STUB
395 *
396 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
397 *****************************************************************************/
398
399HRESULT WIN32API SHWinHelp (DWORD v,
400 DWORD w,
401 DWORD x,
402 DWORD z)
403{
404 dprintf(("SHELL32: SHWinHelp(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
405 v,
406 w,
407 x,
408 z));
409
410 return 0;
411}
412
413
414/*****************************************************************************
415 * Name : HRESULT SHOutOfMemoryMessageBox
416 * Purpose :
417 * Parameters:
418 * Variables :
419 * Result :
420 * Remark : SHELL32.126
421 * Status : UNTESTED STUB
422 *
423 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
424 *****************************************************************************/
425
426HRESULT WIN32API SHOutOfMemoryMessageBox(DWORD u,
427 DWORD v,
428 DWORD w)
429{
430 dprintf(("SHELL32: SHOutOfmemoryMessageBox(%08xh,%08xh,%08xh) not implemented.\n",
431 u,
432 v,
433 w));
434
435 return 0;
436}
437
438
439/*****************************************************************************
440 * Name : HRESULT SHLoadOLE
441 * Purpose :
442 * Parameters:
443 * Variables :
444 * Result :
445 * Remark : SHELL32.151
446 * Status : UNTESTED STUB
447 *
448 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
449 *****************************************************************************/
450
451HRESULT WIN32API SHLoadOLE(DWORD u)
452{
453 dprintf(("SHELL32: SHLoadOle(%08xh) not implemented.\n",
454 u));
455
456 return S_OK;
457}
458
459
460/*****************************************************************************
461 * Name : HRESULT SHRunControlPanel
462 * Purpose :
463 * Parameters:
464 * Variables :
465 * Result :
466 * Remark : SHELL32.161
467 * Status : UNTESTED STUB
468 *
469 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
470 *****************************************************************************/
471
472HRESULT WIN32API SHRunControlPanel (DWORD x,
473 DWORD z)
474{
475 dprintf(("SHELL32: SHRunControlPanel(%08xh, %08xh) not implemented.\n",
476 x,
477 z));
478
479 return 0;
480}
481
482
483/*****************************************************************************
484 * Name : DWORD WIN32API SHCreateDirectory
485 * Purpose :
486 * Parameters:
487 * Variables :
488 * Result :
489 * Remark : SHELL32.165
490 * Status : UNTESTED STUB
491 *
492 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
493 *
494 * NOTES
495 * exported by ordinal
496 * not sure about LPSECURITY_ATTRIBUTES
497 */
498
499DWORD WIN32API SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,
500 LPCSTR path)
501{
502 dprintf(("SHELL32: SHCreateDirectory(%08xh, %08xh) not implemented.\n",
503 sec,
504 path));
505
506 if (CreateDirectoryA(path,sec))
507 return TRUE;
508
509 /* SHChangeNotify(8,1,path,0); */
510 return FALSE;
511
512// if (SHELL32_79(path,(LPVOID)x))
513// return 0;
514// FIXME("(%08lx,%s):stub.\n",x,path);
515// return 0;
516}
517
518
519/*****************************************************************************
520 * Name : HRESULT SHValidateUNC
521 * Purpose : validating a UNC path ? so the parameters are not correct !
522 * Parameters: DWORD x
523 * DWORD y
524 * DWORD z
525 * Variables :
526 * Result :
527 * Remark : SHELL32.173
528 * Status : UNTESTED STUB
529 *
530 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
531 *****************************************************************************/
532
533HRESULT WIN32API SHValidateUNC (DWORD x,
534 DWORD y,
535 DWORD z)
536{
537 dprintf(("SHELL32: SHValidateUnc(%08x,%08xh,%08xh) not implemented.\n",
538 x,
539 y,
540 z));
541
542 return 0;
543}
544
545
546/*****************************************************************************
547 * Name : HRESULT SHCreateShellFolderViewEx
548 * Purpose :
549 * Parameters:
550 * Variables :
551 * Result :
552 * Remark : SHELL32.174
553 * Status : UNTESTED STUB
554 *
555 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
556 *****************************************************************************/
557
558
559HRESULT WIN32API SHCreateShellFolderViewEx(LPSHELLVIEWDATA psvcbi,
560 LPVOID* ppv)
561{
562 dprintf(("SHELL32: SHCreateShellFolderViewEx(%08xh,%08xh) not implemented.\n",
563 psvcbi,
564 ppv));
565
566 return 0;
567}
568
569
570/*****************************************************************************
571 * Name : HRESULT SHSetInstanceExplorer
572 * Purpose :
573 * Parameters:
574 * Variables :
575 * Result :
576 * Remark : SHELL32.176
577 * Status : UNTESTED STUB
578 *
579 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
580 *****************************************************************************/
581
582HRESULT WIN32API SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
583{
584 dprintf(("SHELL32: SHSetInstanceExplorer(%08xh)\n",
585 lpUnknown));
586
587 SHELL32_IExplorerInterface = lpUnknown;
588 return (HRESULT) lpUnknown;
589}
590
591
592/*****************************************************************************
593 * Name : DWORD WIN32API SHFree
594 * Purpose :
595 * Parameters:
596 * Variables :
597 * Result :
598 * Remark : SHELL32.195
599 * Status : UNTESTED STUB
600 *
601 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
602 *
603 * NOTES
604 * free_ptr() - frees memory using IMalloc
605 * exported by ordinal
606 */
607
608DWORD WIN32API SHFree(LPVOID x)
609{
610 dprintf(("SHELL32: SHFree(%08xh)\n",
611 x));
612
613 if (!HIWORD(x))
614 {
615 *(LPDWORD)0xdeaf0000 = 0;
616 }
617
618 return HeapFree(GetProcessHeap(),0,x);
619}
620
621
622/*****************************************************************************
623 * Name : LPVOID WIN32API SHAlloc
624 * Purpose :
625 * Parameters:
626 * Variables :
627 * Result :
628 * Remark : SHELL32.196
629 * Status : UNTESTED STUB
630 *
631 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
632 *
633 * NOTES
634 * void *task_alloc(DWORD len), uses SHMalloc allocator
635 * exported by ordinal
636 */
637
638LPVOID WIN32API SHAlloc(DWORD len)
639{
640 dprintf(("SHELL32: SHAlloc(%08xh)\n",
641 len));
642
643 return (LPVOID)HeapAlloc(GetProcessHeap(),0,len);
644}
645
646
647/*****************************************************************************
648 * Name : HRESULT SHAbortInvokeCommand
649 * Purpose :
650 * Parameters:
651 * Variables :
652 * Result :
653 * Remark : SHELL32.198
654 * Status : UNTESTED STUB
655 *
656 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
657 *****************************************************************************/
658
659HRESULT WIN32API SHAbortInvokeCommand(void)
660{
661 dprintf(("SHELL32: SHAbortInvokeCommand() not implemented.\n"));
662
663 return 1;
664}
665
666
667/*****************************************************************************
668 * Name : VOID SHAddToRecentDocs
669 * Purpose :
670 * Parameters: UINT uFlags
671 * LPCVOID pv
672 * Variables :
673 * Result :
674 * Remark : SHELL32.234
675 * Status : UNTESTED STUB
676 *
677 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
678 *****************************************************************************/
679
680VOID WIN32API SHAddToRecentDocs(UINT uFlags,
681 LPCVOID pv)
682{
683 dprintf(("SHELL32: SHAddToRecentDocs(%08xh,%08xh) not implemented.\n",
684 uFlags,
685 pv));
686}
687
688
689/*****************************************************************************
690 * Name : DWORD SHAppBarMessage
691 * Purpose : ... be the janitor
692 * Parameters:
693 * Variables :
694 * Result :
695 * Remark : SHELL32.235
696 * Status : UNTESTED STUB UNKNOWN
697 *
698 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
699 *****************************************************************************/
700
701DWORD WIN32API SHAppBarMessage(LONG x1,
702 LPVOID x2)
703{
704 dprintf(("SHELL32: SHAppBarMessage(%08xh,%08xh) not implemented.\n",
705 x1,
706 x2));
707
708 return 0;
709}
710
711
712/*****************************************************************************
713 * Name : LPITEMIDLIST SHBrowseForFolder
714 * Purpose :
715 * Parameters: LPBROWSEINFOA lpbi
716 * Variables :
717 * Result :
718 * Remark : SHELL32.236
719 * Status : UNTESTED STUB
720 *
721 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
722 *****************************************************************************/
723
724LPITEMIDLIST WIN32API SHBrowseForFolder(LPBROWSEINFOA lpbi)
725{
726 dprintf(("SHELL32: SHBrowseForFolder(%08xh) not implemented.\n",
727 lpbi));
728
729 //@@@PH automatically decide between A and W
730
731 return(NULL);
732}
733
734
735/*****************************************************************************
736 * Name : LPITEMIDLIST SHBrowseForFolderA
737 * Purpose :
738 * Parameters: LPBROWSEINFOA lpbi
739 * Variables :
740 * Result :
741 * Remark : SHELL32.237
742 * Status : UNTESTED STUB
743 *
744 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
745 *****************************************************************************/
746
747LPITEMIDLIST WIN32API SHBrowseForFolderA(LPBROWSEINFOA lpbi)
748{
749 dprintf(("SHELL32: SHBrowseForFolderA(%08xh) not implemented.\n",
750 lpbi));
751
752 return(NULL);
753}
754
755
756/*****************************************************************************
757 * Name : LPITEMIDLIST SHBrowseForFolderW
758 * Purpose :
759 * Parameters: LPBROWSEINFOW lpbi
760 * Variables :
761 * Result :
762 * Remark : SHELL32.238
763 * Status : UNTESTED STUB
764 *
765 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
766 *****************************************************************************/
767
768LPITEMIDLIST WIN32API SHBrowseForFolderW(LPBROWSEINFOA lpbi)
769{
770 dprintf(("SHELL32: SHBrowseForFolderW(%08xh) not implemented.\n",
771 lpbi));
772
773 return(NULL);
774}
775
776
777/*****************************************************************************
778 * Name : VOID SHChangeNotify
779 * Purpose :
780 * Parameters: LONG wEventId
781 * UINT uFlags
782 * LPCVOID dwItem1
783 * LPCVOID dwItem2
784 * Variables :
785 * Result :
786 * Remark : SHELL32.239
787 * Status : UNTESTED STUB
788 *
789 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
790 *****************************************************************************/
791
792VOID WIN32API SHChangeNotify(LONG wEventId,
793 UINT uFlags,
794 LPCVOID dwItem1,
795 LPCVOID dwItem2)
796{
797 dprintf(("SHELL32: SHChangeNotify(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
798 wEventId,
799 uFlags,
800 dwItem1,
801 dwItem2));
802
803}
804
805
806/*****************************************************************************
807 * Name : DWORD SHEmptyRecycleBinA
808 * Purpose : ... be the janitor
809 * Parameters:
810 * Variables :
811 * Result :
812 * Remark : SHELL32.240
813 * Status : UNTESTED STUB UNKNOWN
814 *
815 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
816 *****************************************************************************/
817
818DWORD WIN32API SHEmptyRecycleBinA(DWORD x1,
819 DWORD x2,
820 DWORD x3)
821{
822 dprintf(("SHELL32: SHEmptyRecycleBinA(%08xh,%08xh,%08xh) not implemented.\n",
823 x1,
824 x2,
825 x3));
826
827 return 0;
828}
829
830
831/*****************************************************************************
832 * Name : DWORD SHEmptyRecycleBinW
833 * Purpose : ... be the janitor
834 * Parameters:
835 * Variables :
836 * Result :
837 * Remark : SHELL32.241
838 * Status : UNTESTED STUB UNKNOWN
839 *
840 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
841 *****************************************************************************/
842
843DWORD WIN32API SHEmptyRecycleBinW(DWORD x1,
844 DWORD x2,
845 DWORD x3)
846{
847 dprintf(("SHELL32: SHEmptyRecycleBinW(%08xh,%08xh,%08xh) not implemented.\n",
848 x1,
849 x2,
850 x3));
851
852 return 0;
853}
854
855
856/*****************************************************************************
857 * Name : HRESULT SHFileOperation
858 * Purpose :
859 * Parameters:
860 * Variables :
861 * Result :
862 * Remark : SHELL32.242
863 * Status : UNTESTED STUB
864 *
865 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
866 *****************************************************************************/
867
868DWORD WIN32API SHFileOperationAW(LPVOID lpFileOp)
869{
870 dprintf(("SHELL32: SHFileOperationAW(%08xh) not implemented.\n",
871 lpFileOp));
872
873 // if OsIsUnicode()
874 // SHFileOperationA(lpFileOp);
875 // else
876 // SHFileOperationW(lpFileOp);
877
878 return 0;
879}
880
881
882/*****************************************************************************
883 * Name : HRESULT SHFileOperationA
884 * Purpose :
885 * Parameters:
886 * Variables :
887 * Result :
888 * Remark : SHELL32.243
889 * Status : UNTESTED STUB
890 *
891 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
892 *****************************************************************************/
893
894DWORD WIN32API SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp)
895{
896 dprintf(("SHELL32: SHFileOperationA(%08xh) not implemented.\n",
897 lpFileOp));
898
899 return 0;
900}
901
902
903/*****************************************************************************
904 * Name : HRESULT SHFileOperationW
905 * Purpose :
906 * Parameters:
907 * Variables :
908 * Result :
909 * Remark : SHELL32.244
910 * Status : UNTESTED STUB
911 *
912 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
913 *****************************************************************************/
914
915DWORD WIN32API SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp)
916{
917 dprintf(("SHELL32: SHFileOperationW(%08xh) not implemented.\n",
918 lpFileOp));
919
920 return 0;
921}
922
923
924/*****************************************************************************
925 * Name : DWORD SHFormatDrive
926 * Purpose : format a drive ? ;-)
927 * Parameters:
928 * Variables :
929 * Result :
930 * Remark : SHELL32.245
931 * Status : UNTESTED STUB UNKNOWN
932 *
933 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
934 *****************************************************************************/
935
936DWORD WIN32API SHFormatDrive(DWORD x1,
937 DWORD x2,
938 DWORD x3,
939 DWORD x4)
940{
941 dprintf(("SHELL32: SHFormatDrive(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
942 x1,
943 x2,
944 x3,
945 x4));
946
947 return 0;
948}
949
950
951/*****************************************************************************
952 * Name : DWORD SHFreeNameMappings
953 * Purpose :
954 * Parameters:
955 * Variables :
956 * Result :
957 * Remark : SHELL32.246
958 * Status : UNTESTED STUB UNKNOWN
959 *
960 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
961 *****************************************************************************/
962
963DWORD WIN32API SHFreeNameMappings(DWORD x1)
964{
965 dprintf(("SHELL32: SHFreeNameMappings(%08xh) not implemented.\n",
966 x1));
967
968 return 0;
969}
970
971
972/*****************************************************************************
973 * Name : DWORD SHGetDataFromIDListA
974 * Purpose :
975 * Parameters:
976 * Variables :
977 * Result :
978 * Remark : SHELL32.247
979 * Status : UNTESTED STUB UNKNOWN
980 *
981 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
982 *****************************************************************************/
983
984DWORD WIN32API SHGetDataFromIDListA(LPVOID x1,
985 LPVOID x2,
986 DWORD x3,
987 LPVOID x4,
988 DWORD x5)
989{
990 dprintf(("SHELL32: SHGetDataFromIDListA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
991 x1,
992 x2,
993 x3,
994 x4,
995 x5));
996
997 return 0;
998}
999
1000
1001/*****************************************************************************
1002 * Name : DWORD SHGetDataFromIDListW
1003 * Purpose :
1004 * Parameters:
1005 * Variables :
1006 * Result :
1007 * Remark : SHELL32.248
1008 * Status : UNTESTED STUB UNKNOWN
1009 *
1010 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1011 *****************************************************************************/
1012
1013DWORD WIN32API SHGetDataFromIDListW(LPVOID x1,
1014 LPVOID x2,
1015 DWORD x3,
1016 LPVOID x4,
1017 DWORD x5)
1018{
1019 dprintf(("SHELL32: SHGetDataFromIDListW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1020 x1,
1021 x2,
1022 x3,
1023 x4,
1024 x5));
1025
1026 return 0;
1027}
1028
1029
1030/*****************************************************************************
1031 * Name : HRESULT SHGetDesktopFolder
1032 * Purpose :
1033 * Parameters: LPSHELLFOLDER *ppshf
1034 * Variables :
1035 * Result :
1036 * Remark : SHELL32.252
1037 * Status : UNTESTED STUB
1038 *
1039 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1040 *****************************************************************************/
1041
1042HRESULT WIN32API SHGetDesktopFolder(LPSHELLFOLDER *ppshf)
1043{
1044 dprintf(("SHELL32: SHGetDesktopFolder(%08xh) not implemented.\n",
1045 ppshf));
1046
1047 return(1);
1048}
1049
1050
1051
1052/*****************************************************************************
1053 * Name : DWORD SHGetFileInfoA
1054 * Purpose :
1055 * Parameters: LPCSTR pszPath
1056 * DWORD dwFileAttributes
1057 * SHFILEINFOA *psfi
1058 * UINT cbFileInfo
1059 * UINT uFlags
1060 * Variables :
1061 * Result :
1062 * Remark : SHELL32.253 .254
1063 * Status : UNTESTED STUB
1064 *
1065 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1066 *****************************************************************************/
1067
1068DWORD WIN32API SHGetFileInfoA(LPCSTR pszPath,
1069 DWORD dwFileAttributes,
1070 SHFILEINFOA *psfi,
1071 UINT cbFileInfo,
1072 UINT uFlags)
1073{
1074 dprintf(("SHELL32: SHGetFileInfoA (%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1075 pszPath,
1076 dwFileAttributes,
1077 psfi,
1078 cbFileInfo,
1079 uFlags));
1080
1081 return(0);
1082}
1083
1084
1085/*****************************************************************************
1086 * Name : DWORD SHGetFileInfoW
1087 * Purpose :
1088 * Parameters: LPWSTR pszPath
1089 * DWORD dwFileAttributes
1090 * SHFILEINFOA *psfi
1091 * UINT cbFileInfo
1092 * UINT uFlags
1093 * Variables :
1094 * Result :
1095 * Remark : SHELL32.255
1096 * Status : UNTESTED STUB
1097 *
1098 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1099 *****************************************************************************/
1100
1101DWORD WIN32API SHGetFileInfoW(LPCWSTR pszPath,
1102 DWORD dwFileAttributes,
1103 SHFILEINFOW *psfi,
1104 UINT cbFileInfo,
1105 UINT uFlags)
1106{
1107 char *astring = UnicodeToAsciiString((LPWSTR)pszPath);
1108
1109 dprintf(("SHELL32: SHGetFileInfoW (%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1110 astring,
1111 dwFileAttributes,
1112 psfi,
1113 cbFileInfo,
1114 uFlags));
1115
1116 FreeAsciiString(astring);
1117 return(0);
1118}
1119
1120
1121/*****************************************************************************
1122 * Name : HRESULT SHGetInstanceExplorer
1123 * Purpose :
1124 * Parameters:
1125 * Variables :
1126 * Result :
1127 * Remark : SHELL32.256
1128 * Status : UNTESTED STUB
1129 *
1130 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1131 *****************************************************************************/
1132
1133HRESULT WIN32API SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
1134{
1135 dprintf(("SHELL32: SHGetInstanceExplorer(%08xh) not implemented.\n",
1136 lpUnknown));
1137
1138 *lpUnknown = SHELL32_IExplorerInterface;
1139
1140 if (!SHELL32_IExplorerInterface)
1141 return E_FAIL;
1142
1143 //@@@PH to do:
1144 //SHELL32_IExplorerInterface->lpvtbl->fnAddRef(SHELL32_IExplorerInterface);
1145 return NOERROR;
1146}
1147
1148
1149/*****************************************************************************
1150 * Name : HRESULT SHGetMalloc
1151 * Purpose :
1152 * Parameters: LPMALLOC *ppMalloc
1153 * Variables :
1154 * Result :
1155 * Remark : SHELL32.257
1156 * Status : UNTESTED STUB
1157 *
1158 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1159 *****************************************************************************/
1160
1161HRESULT WIN32API SHGetMalloc(LPMALLOC *ppMalloc)
1162{
1163 dprintf(("SHELL32: SHGetMalloc(%08xh) not implemented.\n",
1164 ppMalloc));
1165
1166 return(0);
1167}
1168
1169
1170/*****************************************************************************
1171 * Name : DWORD SHGetNewLinkInfo
1172 * Purpose :
1173 * Parameters:
1174 * Variables :
1175 * Result :
1176 * Remark : SHELL32.258
1177 * Status : UNTESTED STUB UNKNOWN
1178 *
1179 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1180 *****************************************************************************/
1181
1182DWORD WIN32API SHGetNewLinkInfo(DWORD x1,
1183 DWORD x2,
1184 DWORD x3,
1185 DWORD x4,
1186 DWORD x5)
1187{
1188 dprintf(("SHELL32: SHGetNewLinkInfo(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1189 x1,
1190 x2,
1191 x3,
1192 x4,
1193 x5));
1194
1195 return 0;
1196}
1197
1198
1199/*****************************************************************************
1200 * Name : BOOL SHGetPathFromIDListA
1201 * Purpose :
1202 * Parameters: LPCITEMIDLIST pidl
1203 * LPSTR pszPath
1204 * Variables :
1205 * Result :
1206 * Remark : SHELL32.259 .260
1207 * Status : UNTESTED STUB
1208 *
1209 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1210 *****************************************************************************/
1211
1212BOOL WIN32API SHGetPathFromIDListA(LPCITEMIDLIST pidl,
1213 LPSTR pszPath)
1214{
1215 dprintf(("SHELL32: SHGetPathFromIDListA(%08xh,%s) not implemented.\n",
1216 pidl,
1217 pszPath));
1218
1219 return(FALSE);
1220}
1221
1222
1223/*****************************************************************************
1224 * Name : BOOL SHGetPathFromIDListW
1225 * Purpose :
1226 * Parameters: LPCITEMIDLIST pidl
1227 * LPSTR pszPath
1228 * Variables :
1229 * Result :
1230 * Remark : SHELL32.261
1231 * Status : UNTESTED STUB
1232 *
1233 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1234 *****************************************************************************/
1235
1236BOOL WIN32API SHGetPathFromIDListW(LPCITEMIDLIST pidl,
1237 LPWSTR pszPath)
1238{
1239 dprintf(("SHELL32: SHGetPathFromIDListW(%08xh,%08xh) not implemented.\n",
1240 pidl,
1241 pszPath));
1242
1243 return(FALSE);
1244}
1245
1246
1247/*****************************************************************************
1248 * Name : HRESULT SHGetSpecialFolderLocation
1249 * Purpose :
1250 * Parameters: HWND hwndOwner
1251 * int nFolder
1252 * LPITEMIDLIST *ppidl
1253 * Variables :
1254 * Result :
1255 * Remark : SHELL32.262
1256 * Status : UNTESTED STUB
1257 *
1258 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1259 *****************************************************************************/
1260
1261HRESULT WIN32API SHGetSpecialFolderLocation(HWND hwndOwner,
1262 int nFolder,
1263 LPITEMIDLIST * ppidl)
1264{
1265 dprintf(("SHELL32: SHGetSpecialFolderLocation(%08xh,%08xh,%08xh) not implemented.\n",
1266 hwndOwner,
1267 nFolder,
1268 ppidl));
1269
1270 return(1);
1271}
1272
1273
1274/*****************************************************************************
1275 * Name : DWORD SHHelpShortcuts_RunDLL
1276 * Purpose :
1277 * Parameters:
1278 * Variables :
1279 * Result :
1280 * Remark : SHELL32.263
1281 * Status : UNTESTED STUB
1282 *
1283 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1284 *****************************************************************************/
1285
1286DWORD WIN32API SHHelpShortcuts_RunDLL(DWORD x1,
1287 DWORD x2,
1288 DWORD x3,
1289 DWORD x4)
1290{
1291 dprintf(("SHELL32: SHHelpShortcuts_RunDLL(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1292 x1,
1293 x2,
1294 x3,
1295 x4));
1296
1297 return(0);
1298}
1299
1300
1301/*****************************************************************************
1302 * Name : DWORD SHHelpShortcuts_RunDLLA
1303 * Purpose :
1304 * Parameters:
1305 * Variables :
1306 * Result :
1307 * Remark : SHELL32.264
1308 * Status : UNTESTED STUB
1309 *
1310 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1311 *****************************************************************************/
1312
1313DWORD WIN32API SHHelpShortcuts_RunDLLA(DWORD x1,
1314 DWORD x2,
1315 DWORD x3,
1316 DWORD x4)
1317{
1318 dprintf(("SHELL32: SHHelpShortcuts_RunDLLA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1319 x1,
1320 x2,
1321 x3,
1322 x4));
1323
1324 return(0);
1325}
1326
1327
1328/*****************************************************************************
1329 * Name : DWORD SHHelpShortcuts_RunDLLW
1330 * Purpose :
1331 * Parameters:
1332 * Variables :
1333 * Result :
1334 * Remark : SHELL32.265
1335 * Status : UNTESTED STUB
1336 *
1337 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1338 *****************************************************************************/
1339
1340DWORD WIN32API SHHelpShortcuts_RunDLLW(DWORD x1,
1341 DWORD x2,
1342 DWORD x3,
1343 DWORD x4)
1344{
1345 dprintf(("SHELL32: SHHelpShortcuts_RunDLLW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1346 x1,
1347 x2,
1348 x3,
1349 x4));
1350
1351 return(0);
1352}
1353
1354
1355/*****************************************************************************
1356 * Name : DWORD SHLoadInProc
1357 * Purpose :
1358 * Parameters:
1359 * Variables :
1360 * Result :
1361 * Remark : SHELL32.267
1362 * Status : UNTESTED STUB
1363 *
1364 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1365 *****************************************************************************/
1366
1367DWORD WIN32API SHLoadInProc(DWORD x1)
1368{
1369 dprintf(("SHELL32: SHLoadInProc(%08xh) not implemented.\n",
1370 x1));
1371
1372 return(0);
1373}
1374
1375
1376/*****************************************************************************
1377 * Name : DWORD SHQueryRecycleBinA
1378 * Purpose :
1379 * Parameters:
1380 * Variables :
1381 * Result :
1382 * Remark : SHELL32.268
1383 * Status : UNTESTED STUB
1384 *
1385 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1386 *****************************************************************************/
1387
1388DWORD WIN32API SHQueryRecycleBinA(DWORD x1,
1389 DWORD x2)
1390{
1391 dprintf(("SHELL32: SHQueryRecycleBinA(%08xh,%08xh) not implemented.\n",
1392 x1,
1393 x2));
1394
1395 return(0);
1396}
1397
1398
1399/*****************************************************************************
1400 * Name : DWORD SHQueryRecycleBinW
1401 * Purpose :
1402 * Parameters:
1403 * Variables :
1404 * Result :
1405 * Remark : SHELL32.269
1406 * Status : UNTESTED STUB
1407 *
1408 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1409 *****************************************************************************/
1410
1411DWORD WIN32API SHQueryRecycleBinW(DWORD x1,
1412 DWORD x2)
1413{
1414 dprintf(("SHELL32: SHQueryRecycleBinW(%08xh,%08xh) not implemented.\n",
1415 x1,
1416 x2));
1417
1418 return(0);
1419}
1420
1421
1422/*****************************************************************************
1423 * Name : DWORD SHUpdateRecycleBinIcon
1424 * Purpose :
1425 * Parameters:
1426 * Variables :
1427 * Result :
1428 * Remark : SHELL32.269
1429 * Status : UNTESTED STUB
1430 *
1431 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1432 *****************************************************************************/
1433
1434DWORD WIN32API SHUpdateRecycleBinIcon(void)
1435{
1436 dprintf(("SHELL32: SHUpdateRecycleBinIcon() not implemented.\n"));
1437
1438 return(0);
1439}
1440
1441
1442/*****************************************************************************
1443 * Name : HRESULT SHRegCloseKey
1444 * Purpose :
1445 * Parameters:
1446 * Variables :
1447 * Result :
1448 * Remark : SHELL32.505
1449 * Status : UNTESTED STUB
1450 *
1451 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1452 *****************************************************************************/
1453
1454HRESULT WIN32API SHRegCloseKey (HKEY hkey)
1455{
1456 dprintf(("SHELL32: SHRegCloseKey(%08xh)\n",
1457 hkey));
1458
1459 return RegCloseKey( hkey );
1460}
1461
1462
1463/*****************************************************************************
1464 * Name : HRESULT SHRegOpenKeyA
1465 * Purpose :
1466 * Parameters:
1467 * Variables :
1468 * Result :
1469 * Remark : SHELL32.506
1470 * Status : UNTESTED STUB
1471 *
1472 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1473 *****************************************************************************/
1474
1475HRESULT WIN32API SHRegOpenKeyA(HKEY hKey,
1476 LPSTR lpSubKey,
1477 LPHKEY phkResult)
1478{
1479 dprintf(("SHELL32: SHRegOpenKeyA(%08xh,%s,%08xh)\n",
1480 hKey,
1481 lpSubKey,
1482 phkResult));
1483
1484 return RegOpenKeyA(hKey,
1485 lpSubKey,
1486 phkResult);
1487}
1488
1489
1490/*****************************************************************************
1491 * Name : HRESULT SHRegOpenKeyW
1492 * Purpose :
1493 * Parameters:
1494 * Variables :
1495 * Result :
1496 * Remark : SHELL32.507
1497 * Status : UNTESTED STUB
1498 *
1499 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1500 *****************************************************************************/
1501
1502HRESULT WIN32API SHRegOpenKeyW (HKEY hKey,
1503 LPCWSTR lpszSubKey,
1504 LPHKEY phkResult)
1505{
1506 dprintf(("SHELL32: SHRegOpenKeyW(%08xh,%08xh,%08xh)\n",
1507 hKey,
1508 lpszSubKey,
1509 phkResult));
1510
1511 return RegOpenKeyW(hKey,
1512 lpszSubKey,
1513 phkResult);
1514}
1515
1516
1517/*****************************************************************************
1518 * Name : HRESULT SHRegQueryValueA
1519 * Purpose :
1520 * Parameters:
1521 * Variables :
1522 * Result :
1523 * Remark : SHELL32.508
1524 * Status : UNTESTED STUB
1525 *
1526 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1527 *****************************************************************************/
1528
1529HRESULT WIN32API SHRegQueryValueA(HKEY hKey,
1530 LPSTR lpszSubKey,
1531 LPSTR lpszData,
1532 LPLONG lpcbData)
1533{
1534 dprintf(("SHELL32: SHRegQueryValueW(%08xh,%s,%08xh,%08xh)\n",
1535 hKey,
1536 lpszSubKey,
1537 lpszData,
1538 lpcbData));
1539
1540 return (HRESULT)RegQueryValueA(hKey,
1541 lpszSubKey,
1542 lpszData,
1543 lpcbData);
1544}
1545
1546
1547/*****************************************************************************
1548 * Name : HRESULT SHRegQueryValueExA
1549 * Purpose :
1550 * Parameters:
1551 * Variables :
1552 * Result :
1553 * Remark : SHELL32.509
1554 * Status : UNTESTED STUB
1555 *
1556 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1557 *****************************************************************************/
1558
1559HRESULT WIN32API SHRegQueryValueExA(DWORD u,
1560 LPSTR v,
1561 LPDWORD w,
1562 LPDWORD x,
1563 LPBYTE y,
1564 LPDWORD z)
1565{
1566 dprintf(("SHELL32: SHRegQueryValueExA(%08xh,%s,%08xh,%08xh,%08xh,%08xh)\n",
1567 u,
1568 v,
1569 w,
1570 x,
1571 y,
1572 z));
1573
1574 return (HRESULT)RegQueryValueExA(u,
1575 v,
1576 w,
1577 x,
1578 y,
1579 z);
1580}
1581
1582
1583/*****************************************************************************
1584 * Name : HRESULT SHRegQueryValueExW
1585 * Purpose :
1586 * Parameters:
1587 * Variables :
1588 * Result :
1589 * Remark : SHELL32.510
1590 * Status : UNTESTED STUB
1591 *
1592 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1593 *****************************************************************************/
1594
1595HRESULT WIN32API SHRegQueryValueExW(DWORD u,
1596 LPWSTR v,
1597 LPDWORD w,
1598 LPDWORD x,
1599 LPBYTE y,
1600 LPDWORD z)
1601{
1602 dprintf(("SHELL32: SHRegQueryValueExW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1603 u,
1604 v,
1605 w,
1606 x,
1607 y,
1608 z));
1609
1610 return (HRESULT)RegQueryValueExW(u,
1611 v,
1612 w,
1613 x,
1614 y,
1615 z);
1616}
1617
1618
1619/*****************************************************************************
1620 * Name : HRESULT SHRegQueryValueW
1621 * Purpose :
1622 * Parameters:
1623 * Variables :
1624 * Result :
1625 * Remark : SHELL32.511
1626 * Status : UNTESTED STUB
1627 *
1628 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1629 *****************************************************************************/
1630
1631HRESULT WIN32API SHRegQueryValueW(HKEY hKey,
1632 LPWSTR lpszSubKey,
1633 LPWSTR lpszData,
1634 LPLONG lpcbData)
1635{
1636 dprintf(("SHELL32: SHRegQueryValueW(%08xh,%08xh,%08xh,%08xh)\n",
1637 hKey,
1638 lpszSubKey,
1639 lpszData,
1640 lpcbData));
1641
1642 return (HRESULT)RegQueryValueW(hKey,
1643 lpszSubKey,
1644 lpszData,
1645 lpcbData);
1646}
1647
1648
1649/*****************************************************************************
1650 * Name : HRESULT SHRegDeleteKeyW
1651 * Purpose :
1652 * Parameters:
1653 * Variables :
1654 * Result :
1655 * Remark : SHELL32.512
1656 * Status : UNTESTED STUB
1657 *
1658 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1659 *****************************************************************************/
1660
1661HRESULT WIN32API SHRegDeleteKeyW (HKEY hkey,
1662 LPWSTR lpszKey)
1663{
1664 dprintf(("SHELL32: SHRegDeleteKeyW(%08xh,%08xh)\n",
1665 hkey,
1666 lpszKey));
1667
1668 return RegDeleteKeyW(hkey,
1669 lpszKey);
1670}
1671
1672
1673/*****************************************************************************
1674 * Name : HRESULT SHRegDeleteKeyA
1675 * Purpose :
1676 * Parameters:
1677 * Variables :
1678 * Result :
1679 * Remark : SHELL32.513
1680 * Status : UNTESTED STUB
1681 *
1682 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1683 *****************************************************************************/
1684
1685HRESULT WIN32API SHRegDeleteKeyA (HKEY hkey,
1686 LPSTR lpszKey)
1687{
1688 dprintf(("SHELL32: SHRegDeleteKeyA(%08xh,%s)\n",
1689 hkey,
1690 lpszKey));
1691
1692 return RegDeleteKeyA(hkey,
1693 lpszKey);
1694}
1695
1696
1697/*****************************************************************************
1698 * Name : HGLOBAL SHAllocShared
1699 * Purpose : allocate shared memory ?
1700 * Parameters:
1701 * Variables :
1702 * Result :
1703 * Remark : SHELL32.520
1704 * Status : UNTESTED STUB
1705 *
1706 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1707 *
1708 * NOTES
1709 * parameter1 is return value from HeapAlloc
1710 * parameter2 is equal to the size allocated with HeapAlloc
1711 * parameter3 is return value from GetCurrentProcessId
1712 *
1713 * the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
1714 * WM_USER+2 could be the undocumented CWM_SETPATH
1715 * the allocated memory contains a pidl
1716 */
1717
1718HGLOBAL WIN32API SHAllocShared(LPVOID psrc,
1719 DWORD size,
1720 DWORD procID)
1721{
1722 HGLOBAL hmem;
1723 LPVOID pmem;
1724
1725 dprintf(("SHELL32: SHAllocShared(%08xh,%08xh,%08xh)\n",
1726 psrc,
1727 size,
1728 procID));
1729
1730 hmem = GlobalAlloc(GMEM_FIXED,
1731 size);
1732 if (!hmem)
1733 return 0;
1734
1735 pmem = GlobalLock (hmem);
1736 if (! pmem)
1737 return 0;
1738
1739 memcpy (pmem, psrc, size);
1740 GlobalUnlock(hmem);
1741 return hmem;
1742}
1743
1744
1745/*****************************************************************************
1746 * Name : LPVOID SHLockShared
1747 * Purpose :
1748 * Parameters:
1749 * Variables :
1750 * Result :
1751 * Remark : SHELL32.521
1752 * Status : UNTESTED STUB
1753 *
1754 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1755 *
1756 * NOTES
1757 * parameter1 is return value from SHAllocShared
1758 * parameter2 is return value from GetCurrentProcessId
1759 * the receiver of (WM_USER+2) trys to lock the HANDLE (?)
1760 * the returnvalue seems to be a memoryadress
1761 */
1762LPVOID WIN32API SHLockShared(HANDLE hmem,
1763 DWORD procID)
1764{
1765 dprintf(("SHELL32: SHLockShared(%08xh,%08xh).\n",
1766 hmem,
1767 procID));
1768
1769 return GlobalLock(hmem);
1770}
1771
1772
1773/*****************************************************************************
1774 * Name : LPVOID SHUnlockShared
1775 * Purpose :
1776 * Parameters:
1777 * Variables :
1778 * Result :
1779 * Remark : SHELL32.522
1780 * Status : UNTESTED STUB
1781 *
1782 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1783 *
1784 * NOTES
1785 * parameter1 is return value from SHLockShared
1786 */
1787
1788BOOL WIN32API SHUnlockShared(HANDLE pmem)
1789{
1790 dprintf(("SHELL32: SHUnlockShared(%08xh)\n",
1791 pmem));
1792
1793 return GlobalUnlock(pmem);
1794}
1795
1796
1797/*****************************************************************************
1798 * Name : LPVOID SHFreeShared
1799 * Purpose :
1800 * Parameters:
1801 * Variables :
1802 * Result :
1803 * Remark : SHELL32.523
1804 * Status : UNTESTED STUB
1805 *
1806 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1807 *
1808 * NOTES
1809 * parameter1 is return value from SHAllocShared
1810 * parameter2 is return value from GetCurrentProcessId
1811 */
1812
1813HANDLE WIN32API SHFreeShared(HANDLE hmem,
1814 DWORD procID)
1815{
1816 dprintf(("SHELL32: SHFreeShared(%08xh,%08xh)\n",
1817 hmem,
1818 procID));
1819
1820 return GlobalFree(hmem);
1821}
1822
1823
1824/*****************************************************************************
1825 * Name : DWORD WIN32API NTSHChangeNotifyRegister
1826 * Purpose :
1827 * Parameters:
1828 * Variables :
1829 * Result :
1830 * Remark : SHELL32.640
1831 * Status : UNTESTED STUB
1832 *
1833 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1834 *
1835 * NOTES
1836 * Idlist is an array of structures and Count specifies how many items in the array
1837 * (usually just one I think).
1838 */
1839
1840DWORD WIN32API NTSHChangeNotifyRegister(HWND hwnd,
1841 LONG events1,
1842 LONG events2,
1843 DWORD msg,
1844 int count,
1845 IDSTRUCT *idlist)
1846{
1847 dprintf(("SHELL32: NTSHChangeNotifyRegister(%08xh, %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1848 hwnd,
1849 events1,
1850 events2,
1851 msg,
1852 count,
1853 idlist));
1854
1855 return SHChangeNotifyRegister(hwnd,
1856 events1,
1857 events2,
1858 msg,
1859 count,
1860 idlist);
1861}
1862
1863
1864/*****************************************************************************
1865 * Name : DWORD WIN32API NTSHChangeNotifyDeregister
1866 * Purpose :
1867 * Parameters:
1868 * Variables :
1869 * Result :
1870 * Remark : SHELL32.641
1871 * Status : UNTESTED STUB
1872 *
1873 * Author : Patrick Haller [Tue, 1999/06/09 20:02]
1874 */
1875DWORD WIN32API NTSHChangeNotifyDeregister(LONG x1)
1876{
1877 dprintf(("SHELL32: NTSHChangeNotifyDeregister(%08xh) not implemented.\n",
1878 x1));
1879
1880 return SHChangeNotifyDeregister(x1);
1881}
1882
Note: See TracBrowser for help on using the repository browser.