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

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

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