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

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

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