source: trunk/src/shlwapi/ordinal.cpp@ 4808

Last change on this file since 4808 was 4081, checked in by sandervl, 25 years ago

resync with Wine 20000801
File size: 40.5 KB
Line 
1/* $Id: ordinal.cpp,v 1.5 2000-08-24 09:32:42 sandervl Exp $ */
2
3/*
4 * Win32 Lightweight SHELL32 for OS/2
5 *
6 * Copyright 2000 Patrick Haller (phaller@gmx.net)
7 * Project Odin Software License can be found in LICENSE.TXT
8 *
9 * Ordinally Exported Functions
10 *
11 */
12
13/*****************************************************************************
14 * Remark *
15 *****************************************************************************
16
17 */
18
19
20/*****************************************************************************
21 * Includes *
22 *****************************************************************************/
23
24#include <odin.h>
25#include <odinwrap.h>
26#include <os2sel.h>
27
28#include <string.h>
29#include <ctype.h>
30#include <wctype.h>
31#include <wcstr.h>
32#define HAVE_WCTYPE_H
33
34#include "debugtools.h"
35
36#include <winreg.h>
37
38#include <heapstring.h>
39#include <misc.h>
40#include <win\shell.h>
41#include <win\winerror.h>
42#include <winversion.h>
43#include <winuser.h>
44
45
46#define ICOM_CINTERFACE 1
47#define CINTERFACE 1
48
49#include "winerror.h"
50#include "winnls.h"
51#include "winversion.h"
52#include "heap.h"
53
54#include "win/wine/obj_base.h"
55#include "shellapi.h"
56#include "shlobj.h"
57#include "wine/undocshell.h"
58
59#include "shlwapi.h"
60#include "shlwapi_odin.h"
61
62
63/*****************************************************************************
64 * Local Variables *
65 *****************************************************************************/
66
67ODINDEBUGCHANNEL(SHLWAPI-ORDINAL)
68
69
70/*****************************************************************************
71 * Prototypes *
72 *****************************************************************************/
73
74HANDLE WIN32API SHLWAPI_11(HANDLE, DWORD, DWORD, DWORD, DWORD);
75
76
77#define debugstr_guid(a) a
78
79
80/*****************************************************************************
81 * Name : ???
82 * Purpose : Unknown (used by explorer.exe)
83 * Parameters: Unknown (wrong)
84 * Variables :
85 * Result : Unknown
86 * Remark :
87 * Status : UNTESTED STUB
88 *
89 * Author : Christoph Bratschi [Wed, 2000/03/29 19:47]
90 *****************************************************************************/
91
92ODINFUNCTION2(DWORD,SHLWAPI_1,
93 DWORD,arg0,
94 DWORD,arg1)
95{
96 dprintf(("not implemented"));
97
98 return 0;
99}
100
101
102/*****************************************************************************
103 * Name : ???
104 * Purpose : Unknown (used by explorer.exe)
105 * Parameters: Unknown (wrong)
106 * Variables :
107 * Result : Unknown
108 * Remark :
109 * Status : UNTESTED STUB
110 *
111 * Author : Christoph Bratschi [Wed, 2000/03/29 19:47]
112 *****************************************************************************/
113
114ODINFUNCTION2(DWORD,SHLWAPI_2,
115 DWORD,arg0,
116 DWORD,arg1)
117{
118 dprintf(("not implemented"));
119
120 return 0;
121}
122
123
124/*****************************************************************************
125 * Name : SHLWAPI_3
126 * Purpose :
127 * Parameters:
128 * Variables :
129 * Result :
130 * Remark :
131 * Status : STUB UNTESTED
132 *
133 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
134 *****************************************************************************/
135
136ODINFUNCTION2(BOOL, SHLWAPI_3,
137 LPSTR, lpPath,
138 LPSTR, lpFile)
139{
140 dprintf(("not properly implemented"));
141
142 return TRUE;
143
144#if 0
145 if (lpPath == NULL) return FALSE;
146 if (PathIsUNCServerA(lpPath)) return FALSE;
147 if (PathIsUNCServerShareA(lpPath)) return FALSE;
148
149 if (lpFile == NULL)
150 return PathFileExistsA(lpPath);
151 else
152 {
153 // PathFindExtensionA
154 // lstrlenA
155 // lstrcpyA
156 // PathFileExistsA
157 return FALSE;
158 }
159
160 return FALSE;
161#endif
162}
163
164
165/*****************************************************************************
166 * Name : SHLWAPI_4
167 * Purpose :
168 * Parameters:
169 * Variables :
170 * Result :
171 * Remark :
172 * Status : STUB UNTESTED
173 *
174 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
175 *****************************************************************************/
176
177ODINFUNCTION2(BOOL, SHLWAPI_4,
178 LPWSTR, lpPath,
179 LPWSTR, lpFile)
180{
181 dprintf(("not properly implemented"));
182
183 return TRUE;
184
185#if 0
186 if (lpPath == NULL) return FALSE;
187 if (PathIsUNCServerW(lpPath)) return FALSE;
188 if (PathIsUNCServerShareW(lpPath)) return FALSE;
189
190 if (lpFile == NULL)
191 return PathFileExtensionW(lpPath);
192 else
193 {
194 // PathFindExtensionW
195 // lstrlenW
196 // lstrcpyW
197 // PathFileExistsW
198 return FALSE;
199 }
200
201 return FALSE;
202#endif
203}
204
205
206/*****************************************************************************
207 * Name : ???
208 * Purpose : extended version of PathFindOnPathA
209 * Parameters: Unknown (wrong)
210 * Variables :
211 * Result : Unknown
212 * Remark :
213 * Status : UNTESTED STUB
214 *
215 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
216 *****************************************************************************/
217
218ODINFUNCTION3(DWORD, SHLWAPI_5,
219 LPSTR, lpFile,
220 LPSTR, lpDirectories,
221 DWORD, dwUnknown)
222
223{
224 dprintf(("not implemented"));
225
226 return 0;
227}
228
229
230/*****************************************************************************
231 * Name : ???
232 * Purpose : extended version of PathFindOnPathA
233 * Parameters: Unknown (wrong)
234 * Variables :
235 * Result : Unknown
236 * Remark :
237 * Status : UNTESTED STUB
238 *
239 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
240 *****************************************************************************/
241
242ODINFUNCTION3(DWORD, SHLWAPI_6,
243 DWORD, arg0,
244 DWORD, arg1,
245 DWORD, arg2)
246
247{
248 dprintf(("not implemented"));
249
250 return 0;
251}
252
253/*****************************************************************************
254 * Name : ???
255 * Purpose : Unknown (used by explorer.exe)
256 * Parameters: Unknown (wrong)
257 * Variables :
258 * Result : Unknown
259 * Remark :
260 * Status : UNTESTED STUB
261 *
262 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
263 *****************************************************************************/
264
265ODINFUNCTION3(DWORD,SHLWAPI_7,
266 DWORD, arg0,
267 DWORD, arg1,
268 DWORD, arg2)
269{
270 HANDLE hMap;
271 LPVOID lpMap;
272 DWORD dwResult;
273
274 dprintf(("not implemented"));
275
276 // create mapping
277 hMap = CreateFileMappingA(-1,
278 NULL,
279 PAGE_READWRITE,
280 0,
281 arg1,
282 0);
283 if (hMap == NULL)
284 return FALSE;
285
286 // now map the thing
287 lpMap = MapViewOfFile(hMap,
288 FILE_MAP_READ | FILE_MAP_WRITE,
289 0,
290 0,
291 0);
292 if (lpMap == NULL)
293 {
294 CloseHandle(hMap);
295 return FALSE;
296 }
297
298 /* @@@PH copy someting into the shared segment */
299
300 UnmapViewOfFile(lpMap);
301 dwResult = SHLWAPI_11(hMap,
302 GetCurrentProcessId(),
303 arg2,
304 FILE_MAP_ALL_ACCESS,
305 2);
306 CloseHandle(hMap);
307
308 return dwResult;
309}
310
311
312/*****************************************************************************
313 * Name : ???
314 * Purpose : Unknown (used by explorer.exe)
315 * Parameters: Unknown (wrong)
316 * Variables :
317 * Result : Unknown
318 * Remark :
319 * Status : UNTESTED STUB
320 *
321 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
322 *****************************************************************************/
323
324ODINFUNCTION2(DWORD, SHLWAPI_8,
325 HANDLE, hMap,
326 DWORD, arg1)
327{
328 HANDLE hHandle;
329 LPVOID lpBase;
330
331 hHandle = SHLWAPI_11(hMap,
332 arg1,
333 GetCurrentProcessId(),
334 FILE_MAP_ALL_ACCESS,
335 0);
336 lpBase = MapViewOfFile(hHandle,
337 FILE_MAP_READ | FILE_MAP_WRITE,
338 0,
339 0,
340 0);
341 CloseHandle(hHandle);
342
343 if (lpBase == NULL)
344 return NULL;
345 else
346 return (DWORD)lpBase+4; // lea eax, [ebx + 4]
347}
348
349
350/*****************************************************************************
351 * Name :
352 * Purpose :
353 * Parameters:
354 * Variables :
355 * Result :
356 * Remark :
357 * Status : COMPLETELY IMPLEMENTED UNTESTED
358 *
359 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
360 *****************************************************************************/
361
362ODINFUNCTION1(DWORD, SHLWAPI_9,
363 LPBYTE, lpBase)
364{
365 return (UnmapViewOfFile( (LPVOID) ((DWORD)lpBase & 0xFFFFFFFC)) );
366}
367
368
369/*****************************************************************************
370 * Name : ???
371 * Purpose :
372 * Parameters:
373 * Variables :
374 * Result :
375 * Remark :
376 * Status : COMPLETELY IMPLEMENTED UNTESTED
377 *
378 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
379 *****************************************************************************/
380
381ODINFUNCTION2(DWORD, SHLWAPI_10,
382 HANDLE, hMap,
383 DWORD, arg1)
384{
385 HANDLE hHandle;
386
387 hHandle = SHLWAPI_11(hMap,
388 arg1,
389 GetCurrentProcessId(),
390 FILE_MAP_ALL_ACCESS,
391 1);
392 return CloseHandle(hHandle);
393}
394
395
396/*****************************************************************************
397 * Name :
398 * Purpose : Duplicate the handle to the shell shared segment
399 * Parameters:
400 * Variables :
401 * Result :
402 * Remark : SHLWAPI.11 - wrong implementation, check again
403 * Status : UNTESTED STUB
404 *
405 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
406 *****************************************************************************/
407
408ODINFUNCTION5(HANDLE, SHLWAPI_11,
409 HANDLE, hMap,
410 DWORD, dwProcessDest,
411 DWORD, dwCurrentPID,
412 DWORD, dwAccess,
413 DWORD, dwFlag)
414{
415 dprintf(("not implemented, explorer.exe will trap now"));
416
417 DWORD dwMyPID = GetCurrentProcessId();
418 HANDLE hProcess;
419 HANDLE hTargetHandle;
420 HANDLE hTargetProcessHandle = dwProcessDest;
421 BOOL fResult;
422
423 // open desired process
424 if (dwMyPID == dwProcessDest)
425 hProcess == GetCurrentProcess();
426 else
427 hProcess == OpenProcess(PROCESS_DUP_HANDLE,
428 FALSE,
429 dwProcessDest);
430
431 // verify result
432 if (hProcess == NULL)
433 return 0;
434
435 // duplicate handle
436 fResult = DuplicateHandle(hProcess,
437 hMap,
438 hTargetProcessHandle,
439 &hTargetHandle,
440 dwAccess,
441 0,
442 dwFlag | 0x02);
443 //CloseHandle()
444
445 return fResult;
446}
447
448
449/*****************************************************************************
450 * Name : ???
451 * Purpose : Looks like a strdup()
452 * Parameters: Unknown (wrong)
453 * Variables :
454 * Result : Unknown
455 * Remark :
456 * Status : UNTESTED STUB
457 *
458 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
459 *****************************************************************************/
460
461ODINFUNCTION2(DWORD,SHLWAPI_12,
462 DWORD,arg0,
463 DWORD,arg1)
464{
465 dprintf(("not implemented, explorer.exe will trap now"));
466
467 return 0;
468}
469
470
471/*****************************************************************************
472 * Name : ???
473 * Purpose : Unknown (used by explorer.exe)
474 * Parameters:
475 * Variables :
476 * Result : Unknown
477 * Remark :
478 * Status : UNTESTED STUB
479 *
480 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
481 *****************************************************************************/
482
483ODINFUNCTION2(DWORD,SHLWAPI_13,
484 DWORD, arg0,
485 DWORD, arg1)
486{
487 dprintf(("not implemented, explorer.exe will trap now"));
488
489 return 0;
490}
491
492
493/*****************************************************************************
494 * Name : ???
495 * Purpose : Unknown (used by explorer.exe)
496 * Parameters: Unknown (wrong)
497 * Variables :
498 * Result : Unknown
499 * Remark :
500 * Status : UNTESTED STUB
501 *
502 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
503 *****************************************************************************/
504
505ODINFUNCTION2(DWORD,SHLWAPI_14,
506 DWORD, arg0,
507 DWORD, arg1)
508{
509 dprintf(("not implemented, explorer.exe will trap now"));
510
511 return 0;
512}
513
514
515/*****************************************************************************
516 * Name : ???
517 * Purpose : Unknown (used by explorer.exe)
518 * Parameters: Unknown (wrong)
519 * Variables :
520 * Result : Unknown
521 * Remark :
522 * Status : UNTESTED STUB
523 *
524 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
525 *****************************************************************************/
526
527ODINFUNCTION2(DWORD,SHLWAPI_15,
528 DWORD, arg0,
529 DWORD, arg1)
530{
531 dprintf(("not implemented, explorer.exe will trap now"));
532
533 return 0;
534}
535
536
537/*****************************************************************************
538 * Name : ???
539 * Purpose : Unknown (used by explorer.exe)
540 * Parameters: Unknown (wrong)
541 * Variables :
542 * Result : Unknown
543 * Remark : SHLWAPI.16
544 * Status : UNTESTED STUB
545 *
546 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
547 *****************************************************************************/
548
549ODINFUNCTION4(HANDLE,SHCreateThread,
550 DWORD, arg0,
551 DWORD, arg1,
552 DWORD, arg2,
553 DWORD, arg3)
554{
555 dprintf(("not implemented, explorer.exe will trap now"));
556
557 return 0;
558}
559
560
561/*****************************************************************************
562 * Name : ???
563 * Purpose : Unknown (used by explorer.exe)
564 * Parameters: Unknown (wrong)
565 * Variables :
566 * Result : Unknown
567 * Remark :
568 * Status : UNTESTED STUB
569 *
570 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
571 *****************************************************************************/
572
573ODINFUNCTION2(DWORD,SHLWAPI_17,
574 DWORD, arg0,
575 DWORD, arg1)
576{
577 dprintf(("not implemented, explorer.exe will trap now"));
578
579 return 0;
580}
581
582
583/*****************************************************************************
584 * Name : ???
585 * Purpose : Unknown (used by explorer.exe)
586 * Parameters: Unknown (wrong)
587 * Variables :
588 * Result : Unknown
589 * Remark :
590 * Status : UNTESTED STUB
591 *
592 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
593 *****************************************************************************/
594
595ODINFUNCTION2(DWORD,SHLWAPI_18,
596 DWORD, arg0,
597 DWORD, arg1)
598{
599 dprintf(("not implemented, explorer.exe will trap now"));
600
601 return 0;
602}
603
604
605/*****************************************************************************
606 * Name : SHLWAPI_19
607 * Purpose : Free memory
608 * Parameters: LPVOID lpMem
609 * Variables :
610 * Result :
611 * Remark : SHLWAPI.19
612 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
613 *
614 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
615 *****************************************************************************/
616
617ODINPROCEDURE1(SHLWAPI_19,
618 HLOCAL, hMem)
619{
620 if (hMem != NULL)
621 LocalFree(hMem);
622}
623
624
625/*****************************************************************************
626 * Name : ???
627 * Purpose : Unknown (used by explorer.exe)
628 * Parameters: Unknown (wrong)
629 * Variables :
630 * Result : Unknown
631 * Remark :
632 * Status : UNTESTED STUB
633 *
634 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
635 *****************************************************************************/
636
637ODINFUNCTION2(DWORD,SHLWAPI_20,
638 DWORD, arg0,
639 DWORD, arg1)
640{
641 dprintf(("not implemented, explorer.exe will trap now"));
642
643 return 0;
644}
645
646
647/*****************************************************************************
648 * Name : ???
649 * Purpose : Unknown (used by explorer.exe)
650 * Parameters: Unknown (wrong)
651 * Variables :
652 * Result : Unknown
653 * Remark :
654 * Status : UNTESTED STUB
655 *
656 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
657 *****************************************************************************/
658
659ODINFUNCTION2(DWORD,SHLWAPI_21,
660 DWORD, arg0,
661 DWORD, arg1)
662{
663 dprintf(("not implemented, explorer.exe will trap now"));
664
665 return 0;
666}
667
668
669/*****************************************************************************
670 * Name : ???
671 * Purpose : Unknown (used by explorer.exe)
672 * Parameters: Unknown (wrong)
673 * Variables :
674 * Result : Unknown
675 * Remark :
676 * Status : UNTESTED STUB
677 *
678 * Author : Patrick Haller [Sun, 2000/06/09 04:47]
679 *****************************************************************************/
680
681ODINFUNCTION2(DWORD,SHLWAPI_22,
682 DWORD, arg0,
683 DWORD, arg1)
684{
685 dprintf(("not implemented, explorer.exe will trap now"));
686
687 return 0;
688}
689
690
691/*****************************************************************************
692 * Name : SHLWAPI_23
693 * Purpose :
694 * Parameters:
695 * Variables :
696 * Result : returns strlen(str)
697 * Remark : converts a guid to a string
698 * Status : UNTESTED STUB
699 *
700 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
701 *****************************************************************************/
702
703ODINFUNCTION3(DWORD, SHLWAPI_23,
704 REFGUID,guid, /* [in] clsid */
705 LPSTR, str, /* [out] buffer */
706 INT, cmax) /* [in] size of buffer */
707{
708 char xguid[80];
709
710 TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
711
712 if (WINE_StringFromCLSID(guid,xguid)) return 0;
713 if (strlen(xguid)>=cmax) return 0;
714 strcpy(str,xguid);
715 return strlen(xguid) + 1;
716}
717
718
719/*************************************************************************
720* SHLWAPI_24 [SHLWAPI.24]
721*
722* NOTES
723* converts a guid to a string
724* returns strlen(str)
725*/
726ODINFUNCTION3(DWORD, SHLWAPI_24,
727 REFGUID, guid, /* [in] clsid */
728 LPWSTR, str, /* [out] buffer */
729 INT, cmax) /* [in] size of buffer */
730{
731 TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
732 return StringFromGUID2(guid, str, cmax);
733}
734
735
736/*****************************************************************************
737 * Name : SHLWAPI_28
738 * Purpose :
739 * Parameters:
740 * Variables :
741 * Result :
742 * Remark :
743 * Status : UNTESTED STUB
744 *
745 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
746 *****************************************************************************/
747
748ODINFUNCTION1(DWORD,SHLWAPI_28,
749 DWORD,arg0)
750{
751 dprintf(("not yet implemented"));
752
753 return 0;
754}
755
756
757/*****************************************************************************
758 * Name : SHLWAPI_30
759 * Purpose : Check for whitespace in ascii and unicode ?
760 * Parameters:
761 * Variables :
762 * Result :
763 * Remark :
764 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
765 *
766 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
767 *****************************************************************************/
768
769ODINFUNCTION1(DWORD,SHLWAPI_30,
770 WORD, ch)
771{
772 if ( (ch == 0x09) || // tab
773 (ch == 0x20) || // space
774 (ch == 0x3000) ||
775 (ch == 0xFEFF) )
776 return 1;
777 else
778 return 0;
779}
780
781
782
783/*****************************************************************************
784 * Name : DWORD SHLWAPI_156
785 * Purpose : Case-sensitive wide string compare
786 * Parameters: LPSTR lpStr1
787 * LPSTR lpStr2
788 * Variables :
789 * Result : case-sensitive comparsion result between the two strings
790 * Remark : SHLWAPI.158
791 * Status : COMPLETELY IMPLEMENTED UNTESTED
792 *
793 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
794 *****************************************************************************/
795
796ODINFUNCTION2(DWORD, SHLWAPI_156,
797 LPWSTR, str1, /* "shell32.dll" */
798 LPWSTR, str2) /* "shell32.dll" */
799{
800 return lstrcmpW(str1,str2);
801}
802
803
804/*****************************************************************************
805 * Name : DWORD SHLWAPI_158
806 * Purpose : Case-ignoring wide string compare
807 * Parameters: LPSTR lpStr1
808 * LPSTR lpStr2
809 * Variables :
810 * Result : case-insensitive comparsion result between the two strings
811 * Remark : SHLWAPI.158
812 * Status : COMPLETELY IMPLEMENTED UNTESTED
813 *
814 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
815 *****************************************************************************/
816
817ODINFUNCTION2(int, SHLWAPI_158,
818 LPWSTR, lpStr1,
819 LPWSTR, lpStr2)
820{
821 WCHAR ch1;
822 WCHAR ch2;
823 int res;
824
825 for (;
826
827 *lpStr1 != 0;
828
829 lpStr1++,
830 lpStr2++)
831 {
832 ch1 = *lpStr1;
833 ch2 = *lpStr2;
834
835 /* ignore case of characters */
836 if ( (ch1 >= 'A') && (ch1 <= 'Z')) ch1 += 0x20;
837 if ( (ch2 >= 'A') && (ch2 <= 'Z')) ch1 += 0x20;
838
839 /* compare characters */
840 res = ch1 - ch2;
841 if (res)
842 return res;
843 }
844
845 /* OK, strings compared til end of string1 */
846 return 0;
847}
848
849
850/*****************************************************************************
851 * Name : DWORD SHLWAPI_160
852 * Purpose :
853 * Parameters:
854 * Variables :
855 * Result :
856 * Remark : SHLWAPI.160
857 * Status : UNTESTED STUB
858 *
859 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
860 *****************************************************************************/
861
862ODINFUNCTION2(DWORD, SHLWAPI_160,
863 DWORD, arg0,
864 DWORD, arg1)
865{
866 dprintf(("not implemented.\n"));
867 return 0;
868}
869
870
871
872/*************************************************************************
873* SHLWAPI_169 [SHLWAPI]
874*/
875ODINFUNCTION1(DWORD, SHLWAPI_169,
876 IUnknown **, lplpUnknown)
877{
878 IUnknown *lpUnknown;
879
880 if (lplpUnknown == NULL)
881 return 0;
882
883 lpUnknown = *lplpUnknown;
884 if (lpUnknown == NULL)
885 return 0;
886
887 *lplpUnknown = NULL; // kill object pointer
888
889 // and still call the object's release method
890 return IUnknown_Release(lpUnknown);
891}
892
893
894/*****************************************************************************
895 * Name : LPSTR SHLWAPI_170
896 * Purpose : verify if current string position is "//" or not
897 * skip "//" ...
898 * Parameters: LPSTR lpStr
899 * Variables :
900 * Result : lpStr + 2 or NULL
901 * Remark : SHLWAPI.170
902 * Status : COMPLETELY IMPLEMENTED UNTESTED
903 *
904 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
905 *****************************************************************************/
906
907ODINFUNCTION1(LPSTR, SHLWAPI_170,
908 LPSTR, lpStr)
909{
910 if ( (lpStr != NULL) &&
911 (*lpStr == '/' ) &&
912 (*(lpStr+1) == '/' ) )
913 return lpStr+2;
914 else
915 return lpStr;
916}
917
918
919/*****************************************************************************
920 * Name : SHLWAPI_185
921 * Purpose : some M$ nag screen ?
922 * Parameters:
923 * Variables :
924 * Result :
925 * Remark : SHLWAPI.185
926 * Status : COMPLETELY IMPLEMENTED UNTESTED
927 *
928 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
929 *****************************************************************************/
930
931ODINFUNCTION6(DWORD, SHLWAPI_185,
932 DWORD, arg0,
933 LPSTR, lpStr1,
934 LPSTR, lpStr2,
935 DWORD, arg3,
936 DWORD, dwDefault,
937 LPSTR, lpstrValueName)
938{
939 BOOL fDontShow;
940 WCHAR szValueNameW[256];
941
942 fDontShow = SHRegGetBoolUSValueA("Software\\Microsoft\\Windows\\CurrentVersion\\"
943 "Explorer\\DontShowMeThisDialogAgain",
944 lpstrValueName,
945 0,
946 1);
947 if (fDontShow == FALSE)
948 return dwDefault;
949
950 int iLength1 = lstrlenA(lpStr1)+1;
951 HLOCAL hLocal1 = LocalAlloc(LMEM_ZEROINIT,
952 iLength1 << 1);
953 if (hLocal1 == NULL)
954 return dwDefault;
955
956 int iLength2 = lstrlenA(lpStr2)+1;
957 HLOCAL hLocal2 = LocalAlloc(LMEM_ZEROINIT,
958 iLength2 << 1);
959 if (hLocal2 == NULL)
960 {
961 LocalFree(hLocal1);
962 return dwDefault;
963 }
964
965#if 0
966 // convert all ascii values to Unicode
967 SHLWAPI_215(lpStr1, (LPWSTR)hLocal1, iLength1);
968 SHLWAPI_215(lpStr2, (LPWSTR)hLocal2, iLength2);
969 SHLWAPI_215(lpstrValueName, szValueNameW, 256);
970
971 // do something
972 dwDefault = SHLWAPI_191(arg0,
973 (LPWSTR)hLocal1,
974 arg3,
975 dwDefault,
976 szValueNameW);
977#endif
978
979 if (hLocal1)
980 LocalFree(hLocal1);
981
982 if (hLocal2)
983 LocalFree(hLocal2);
984
985 return dwDefault;
986}
987
988
989/*****************************************************************************
990 * Name : SHLWAPI_191
991 * Purpose : display some M$ nag screen if enabled
992 * Parameters:
993 * Variables :
994 * Result :
995 * Remark : SHLWAPI.191
996 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
997 *
998 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
999 *****************************************************************************/
1000
1001ODINFUNCTION6(DWORD, SHLWAPI_191,
1002 HWND, hwndParent,
1003 DWORD, arg1,
1004 DWORD, arg2,
1005 DWORD, arg3,
1006 DWORD, dwDefault,
1007 LPWSTR, lpstrDialog)
1008{
1009 BOOL rc = SHRegGetBoolUSValueW((LPCWSTR)L"Software\\Microsoft\\Windows\\CurrentVersion"
1010 L"\\Explorer\\DontShowMeThisDialogAgain",
1011 lpstrDialog,
1012 0,
1013 1);
1014 if (rc == FALSE)
1015 return dwDefault;
1016
1017 static HINSTANCE hShellInstance; // @@@PH where to put / initialize?
1018
1019#if 0
1020 struct
1021 {
1022 DWORD s1;
1023 DWORD s2;
1024 DWORD s3;
1025 DWORD s4;
1026 } sInit;
1027
1028 sInit.s1 = "software...";
1029 sInit.s2 = arg1;
1030 sInit.s3 = arg2;
1031 sInit.s4 = arg3;
1032
1033 return DialogBoxParamW(hShellInstance,
1034 0x1200, // some template
1035 hwndParent,
1036 i_DialogProc,
1037 &sInit);
1038#endif
1039
1040 return dwDefault;
1041}
1042
1043
1044
1045/*************************************************************************
1046* SHLWAPI_193 [SHLWAPI]
1047* query current color depth
1048*/
1049ODINFUNCTION0(DWORD, SHLWAPI_193)
1050{
1051 HDC hdc;
1052 DWORD ret;
1053
1054 hdc = GetDC(0);
1055 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1056 ReleaseDC(0, hdc);
1057 return ret;
1058}
1059
1060
1061/*****************************************************************************
1062 * Name : BOOL SHLWAPI_197
1063 * Purpose : Set text background?
1064 * Parameters:
1065 * Variables :
1066 * Result :
1067 * Remark : SHLWAPI.197
1068 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1069 *
1070 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1071 *****************************************************************************/
1072
1073ODINFUNCTION3(BOOL, SHLWAPI_197,
1074 HDC, hdc,
1075 CONST RECT*, lprc,
1076 COLORREF, crColor)
1077{
1078 COLORREF crOld;
1079 BOOL res;
1080
1081 crOld = SetBkColor(hdc, crColor);
1082 res = ExtTextOutA(hdc,
1083 0,
1084 0,
1085 ETO_OPAQUE,
1086 lprc,
1087 0,
1088 0,
1089 0);
1090 SetBkColor(hdc, crOld);
1091
1092 return res;
1093}
1094
1095
1096/*************************************************************************
1097* SHLWAPI_219 [SHLWAPI]
1098*/
1099ODINFUNCTION4(HRESULT, SHLWAPI_219,
1100 LPVOID, w, /* returned by LocalAlloc */
1101 LPVOID, x,
1102 LPVOID, y,
1103 LPWSTR, z) /* OUT: path */
1104{
1105 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1106 return 0xabba1252;
1107}
1108
1109
1110/*************************************************************************
1111* SHLWAPI_222 [SHLWAPI]
1112*
1113* NOTES
1114* securityattributes missing
1115*/
1116ODINFUNCTION1(HANDLE, SHLWAPI_222,
1117 LPCLSID, guid)
1118{
1119 char lpstrName[80];
1120 strcpy( lpstrName,"shell.");
1121 WINE_StringFromCLSID(guid, lpstrName + strlen(lpstrName));
1122
1123 FIXME("(%s) stub\n", lpstrName);
1124 return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
1125}
1126
1127
1128/*************************************************************************
1129* SHLWAPI_223 [SHLWAPI]
1130*
1131* NOTES
1132* function guessed
1133*/
1134ODINFUNCTION1(DWORD, SHLWAPI_223,
1135 HANDLE, handle)
1136{
1137 LONG oldCount;
1138
1139 FIXME("(0x%08x) stub\n",handle);
1140
1141 ReleaseSemaphore( handle, 1, &oldCount);
1142 WaitForSingleObject( handle, 0 );
1143 return 0;
1144}
1145
1146
1147/*************************************************************************
1148* SHLWAPI_237 [SHLWAPI]
1149* Purpose: verify a WNDCLASSW structure
1150*/
1151ODINFUNCTION1(DWORD, SHLWAPI_237,
1152 LPWNDCLASSW, lpWndClass)
1153{
1154 WNDCLASSW wndClass;
1155
1156 if (GetClassInfoW(lpWndClass->hInstance,
1157 (LPWSTR)lpWndClass->lpszClassName,
1158 &wndClass) == TRUE)
1159 return 1;
1160 else
1161 return 0;
1162}
1163
1164
1165/*****************************************************************************
1166 * Name : SHLWAPI_240
1167 * Purpose : universal window procedure
1168 * Parameters:
1169 * Variables :
1170 * Result :
1171 * Remark : SHLWAPI.240
1172 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1173 *
1174 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1175 *****************************************************************************/
1176
1177ODINFUNCTION4(DWORD, SHLWAPI_240,
1178 HWND, hwnd,
1179 UINT, Msg,
1180 WPARAM, wParam,
1181 LPARAM, lParam)
1182{
1183 if (IsWindowUnicode(hwnd))
1184 return DefWindowProcW(hwnd, Msg, wParam, lParam);
1185 else
1186 return DefWindowProcA(hwnd, Msg, wParam, lParam);
1187}
1188
1189
1190/*************************************************************************
1191* SHLWAPI_241 [SHLWAPI]
1192*
1193*/
1194ODINFUNCTION0(DWORD, SHLWAPI_241)
1195{
1196 FIXME("()stub\n");
1197 return 0xabba1243;
1198}
1199
1200
1201/*****************************************************************************
1202 * Name : SHLWAPI_243
1203 * Purpose : does something critical, even with performance counters
1204 * Parameters:
1205 * Variables :
1206 * Result :
1207 * Remark : SHLWAPI.243
1208 * Status : STUB UNTESTED
1209 *
1210 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1211 *****************************************************************************/
1212
1213ODINFUNCTION5(DWORD, SHLWAPI_243,
1214 DWORD, arg0,
1215 DWORD, arg1,
1216 DWORD, arg2,
1217 DWORD, arg3,
1218 DWORD, arg4)
1219{
1220 dprintf(("not implementes.\n"));
1221 return 0;
1222}
1223
1224
1225/*************************************************************************
1226* SHLWAPI_266 [SHLWAPI]
1227*/
1228ODINFUNCTION4(DWORD, SHLWAPI_266,
1229 LPVOID, w,
1230 LPVOID, x,
1231 LPVOID, y,
1232 LPVOID, z)
1233{
1234 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1235 return 0xabba1248;
1236}
1237
1238/*************************************************************************
1239* SHLWAPI_267 [SHLWAPI]
1240*/
1241ODINFUNCTION4(HRESULT, SHLWAPI_267,
1242 LPVOID, w, /* same as 1th parameter of SHLWAPI_219 */
1243 LPVOID, x, /* same as 2nd parameter of SHLWAPI_219 */
1244 LPVOID, y,
1245 LPVOID, z)
1246{
1247 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1248 *((LPDWORD)z) = 0xabba1200;
1249 return 0xabba1254;
1250}
1251
1252/*************************************************************************
1253* SHLWAPI_268 [SHLWAPI]
1254*/
1255ODINFUNCTION2(DWORD, SHLWAPI_268,
1256 LPVOID, w,
1257 LPVOID, x)
1258{
1259 FIXME("(%p %p)\n",w,x);
1260 return 0xabba1251; /* 0 = failure */
1261}
1262
1263/*************************************************************************
1264* SHLWAPI_276 [SHLWAPI]
1265
1266* dynamically load SHELL32.DllGetVersion
1267*
1268*/
1269ODINFUNCTION0(DWORD, SHLWAPI_276)
1270{
1271 FIXME("()stub\n");
1272 return 0xabba1244;
1273}
1274
1275
1276/*************************************************************************
1277* SHLWAPI_309 [SHLWAPI]
1278*
1279*/
1280ODINFUNCTION1(DWORD, SHLWAPI_309,
1281 LPVOID, x)
1282{
1283 FIXME("(%p)stub\n",x);
1284 return 0xabba1245;
1285}
1286
1287/*************************************************************************
1288* SHLWAPI_342 [SHLWAPI]
1289*
1290*/
1291ODINFUNCTION4(DWORD, SHLWAPI_342,
1292 LPVOID, w,
1293 LPVOID, x,
1294 LPVOID, y,
1295 LPVOID, z)
1296{
1297 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1298 return 0xabba1249;
1299}
1300
1301/*************************************************************************
1302* SHLWAPI_346 [SHLWAPI]
1303*/
1304ODINFUNCTION3(DWORD, SHLWAPI_346,
1305 LPCWSTR, src,
1306 LPWSTR, dest,
1307 int, len)
1308{
1309 FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
1310 lstrcpynW(dest, src, len);
1311 return lstrlenW(dest)+1;
1312}
1313
1314
1315/*****************************************************************************
1316 * Name : SHLWAPI_364
1317 * Purpose : call lstrcpynA
1318 * Parameters:
1319 * Variables :
1320 * Result :
1321 * Remark : SHLWAPI.364
1322 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1323 *
1324 * Author :
1325 *****************************************************************************/
1326
1327ODINFUNCTION3(INT, SHLWAPI_364,
1328 LPSTR, lpStr1,
1329 LPSTR, lpStr2,
1330 INT, nLength)
1331{
1332 // @@@PH is there some parameter twisting ?
1333 lstrcpynA(lpStr2,
1334 lpStr1,
1335 nLength);
1336
1337 return 1;
1338}
1339
1340
1341/*****************************************************************************
1342 * Name : DWORD SHLWAPI_376
1343 * Purpose : Try to determine user interface language
1344 * Parameters:
1345 * Variables :
1346 * Result :
1347 * Remark : SHLWAPI.366
1348 * Status : PARTIALLY IMPLEMENTED UNTESTED
1349 *
1350 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1351 *****************************************************************************/
1352
1353ODINFUNCTION0(DWORD, SHLWAPI_376)
1354{
1355 /* Microsoft does a hell of a job here: looks for
1356 * - Internet Explorer
1357 * - Office
1358 * - Lpk ?
1359 * - Resource Locales
1360 * - etc.
1361 */
1362
1363 return 0x0409; // @@@PH maybe this is 'nuf for now.
1364}
1365
1366
1367
1368/*************************************************************************
1369* SHLWAPI_377 [SHLWAPI]
1370*/
1371ODINFUNCTION3(DWORD, SHLWAPI_377,
1372 LPSTR, lpstrModule,
1373 HMODULE, hModule,
1374 LPVOID, z)
1375{
1376 static BOOL flagSHLWAPI_377Initialized = FALSE;
1377 static BOOL flagInternetExplorerCheckVersion = FALSE;
1378
1379 dprintf(("not (properly) implemented.\n"));
1380
1381 char szModuleName[260]; // MAXPATHLEN
1382 HMODULE hModLanguage;
1383
1384 // initialize this subsystem
1385 if (flagSHLWAPI_377Initialized == FALSE)
1386 {
1387 flagSHLWAPI_377Initialized = TRUE;
1388
1389 flagInternetExplorerCheckVersion =
1390 SHRegGetBoolUSValueA("Software\\Microsoft\\Internet Explorer\\International",
1391 "CheckVersion",
1392 1,
1393 1);
1394 }
1395
1396 if (lpstrModule == NULL) // Garbage in - garbage out
1397 return 0;
1398
1399 if (0 == GetModuleFileNameA(hModule,
1400 szModuleName,
1401 sizeof(szModuleName)))
1402 {
1403 // treat error
1404 }
1405 else
1406 {
1407 PathRemoveFileSpecA(szModuleName);
1408 PathAppendA(szModuleName,
1409 lpstrModule);
1410 // @@@PH twiddle around with the current IE codepage
1411 hModLanguage = LoadLibraryA(szModuleName);
1412 }
1413
1414
1415 return hModLanguage;
1416}
1417
1418
1419/*****************************************************************************
1420 * Name : DWORD SHLWAPI_437
1421 * Purpose : Determine product version and options
1422 * Parameters:
1423 * Variables :
1424 * Result :
1425 * Remark : SHLWAPI.437
1426 * Status : UNTESTED
1427 *
1428 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1429 *****************************************************************************/
1430
1431#define REG_PRODUCTOPTIONS "System\\CurrentControlSet\\Control\\ProductOptions"
1432#define REG_OPTIONS_PRODUCTTYPE "ProductType"
1433#define REG_OPTIONS_ENTERPRISE "Enterprise"
1434#define REG_OPTIONS_DATACENTER "DataCenter"
1435
1436ODINFUNCTION1(DWORD, SHLWAPI_437,
1437 DWORD, nFunction)
1438{
1439 static BOOL flagProductOptionsInitialized = FALSE;
1440 static BOOL flagIsProductEnterprise = FALSE;
1441 static BOOL flagIsProductDatacenter = FALSE;
1442 static OSVERSIONINFOA osVersionInfo;
1443
1444 HKEY hKeyOptions;
1445 DWORD dwKeyType;
1446 char szBuffer[260]; // MAX_PATH_LEN
1447 DWORD dwDataLength;
1448
1449 dprintf(("not (properly) implemented.\n"));
1450
1451 if (flagProductOptionsInitialized == FALSE)
1452 {
1453 // set to TRUE regardless of subsequent errors
1454 flagProductOptionsInitialized = TRUE;
1455
1456 // initialize required structures
1457 osVersionInfo.dwOSVersionInfoSize = 0x9c;
1458 if (GetVersionExA(&osVersionInfo) == FALSE)
1459 {
1460 osVersionInfo.dwOSVersionInfoSize = 0x94;
1461 GetVersionExA(&osVersionInfo);
1462 }
1463
1464 LONG rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1465 REG_PRODUCTOPTIONS,
1466 0,
1467 KEY_READ,
1468 &hKeyOptions);
1469 if (rc == ERROR_SUCCESS)
1470 {
1471 dwDataLength = sizeof(szBuffer);
1472 rc = RegQueryValueExA(hKeyOptions,
1473 REG_OPTIONS_PRODUCTTYPE,
1474 0,
1475 &dwKeyType,
1476 (LPBYTE)szBuffer,
1477 &dwDataLength);
1478 if (StrStrIA(szBuffer, REG_OPTIONS_ENTERPRISE) != 0)
1479 flagIsProductEnterprise = TRUE;
1480 else
1481 if (StrStrIA(szBuffer, REG_OPTIONS_DATACENTER) != 0)
1482 flagIsProductDatacenter = TRUE;
1483
1484 RegCloseKey(hKeyOptions);
1485 }
1486 }
1487
1488 // OK, now to the usual work ...
1489 switch (nFunction)
1490 {
1491 // is platform WINDOWS
1492 case 0:
1493 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
1494 return 1;
1495 else
1496 return 0;
1497
1498 // is platform NT
1499 case 1:
1500 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
1501 return 1;
1502 else
1503 return 0;
1504
1505 // is platform Windows 95/98/xx ?
1506 case 2:
1507 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1508 return 0;
1509 if (osVersionInfo.dwMajorVersion >= 4)
1510 return 1;
1511 else
1512 return 0;
1513
1514 // is platform NT4 or better?
1515 case 3:
1516 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1517 return 0;
1518 if (osVersionInfo.dwMajorVersion >= 4)
1519 return 1;
1520 else
1521 return 0;
1522
1523 // is platform Win2000 or better?
1524 case 4:
1525 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1526 return 0;
1527 if (osVersionInfo.dwMajorVersion >= 5)
1528 return 1;
1529 else
1530 return 0;
1531
1532 // at least Windows 4.10 ?
1533 case 5:
1534 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1535 return 0;
1536 if (osVersionInfo.dwMajorVersion > 4)
1537 return 1;
1538 else
1539 if (osVersionInfo.dwMajorVersion == 4)
1540 if (osVersionInfo.dwMinorVersion >= 10)
1541 return 1;
1542
1543 return 0;
1544
1545 // is platform Windows98 GA ?
1546 case 6:
1547 if ( (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) &&
1548 (osVersionInfo.dwMajorVersion == 4) &&
1549 (osVersionInfo.dwMinorVersion == 10) &&
1550 (osVersionInfo.dwBuildNumber == 1998) ) // 0x7ce
1551 return 1;
1552 else
1553 return 0;
1554
1555 // is platform some specific CSD ?
1556 case 7:
1557 case 8:
1558 //@@@PH incorrect
1559 if (osVersionInfo.dwMajorVersion >= 5)
1560 return 1;
1561 else
1562 return 0;
1563
1564 case 9:
1565 //@@@PH incorrect
1566 if (osVersionInfo.dwMajorVersion >= 5 ||
1567 flagIsProductEnterprise ||
1568 flagIsProductDatacenter)
1569 return 1;
1570 else
1571 return 0;
1572
1573 case 10:
1574 //@@@PH incorrect
1575 if (osVersionInfo.dwMajorVersion >= 5)
1576 return flagIsProductEnterprise;
1577 else
1578 return 0;
1579
1580 case 11:
1581 //@@@PH incorrect
1582 if (osVersionInfo.dwMajorVersion >= 5)
1583 return flagIsProductDatacenter;
1584 else
1585 return 0;
1586
1587 // @@@PH: Oops, wazzup there ?
1588 case 12:
1589 return GetSystemMetrics(4096);
1590 }
1591
1592 return 0;
1593}
1594
1595
1596/*****************************************************************************
1597 * Name : SHIsLowMemoryMachine
1598 * Purpose :
1599 * Parameters: BOOL fRetest - TRUE if testing shall be repeated
1600 * - FALSE if cached result is to be used
1601 * Variables :
1602 * Result : 0 - machine is not memory-constrained
1603 * 1 - machine is memory-constrained
1604 * Remark : SHLWAPI.584
1605 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1606 *
1607 * Author : Patrick Haller [Mon, 2000/06/11 02:02]
1608 *****************************************************************************/
1609
1610ODINFUNCTION1(int, SHIsLowMemoryMachine,
1611 BOOL, fRetest)
1612{
1613 MEMORYSTATUS memBuffer;
1614 static int flagIsLowMemoryMachine = -1;
1615 ULONG ulMem;
1616
1617 // use cached result?
1618 if ( (fRetest == TRUE) ||
1619 (flagIsLowMemoryMachine == -1) )
1620 {
1621 // determine and store result
1622 GlobalMemoryStatus(&memBuffer);
1623 if (VERSION_OsIsUnicode())
1624 ulMem = 0x1000000; // unicode operation mode
1625 else
1626 ulMem = 0x0800000; // ascii operation mode
1627
1628 // enough memory?
1629 if (memBuffer.dwTotalPhys <= ulMem)
1630 flagIsLowMemoryMachine = 1;
1631 else
1632 flagIsLowMemoryMachine = 0;
1633 }
1634
1635 return flagIsLowMemoryMachine;
1636}
1637
1638/*************************************************************************
1639 * SHCreateShellPalette [SHLWAPI.@]
1640 */
1641HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
1642{
1643 FIXME("stub\n");
1644 return CreateHalftonePalette(hdc);
1645}
Note: See TracBrowser for help on using the repository browser.