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

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

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