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

Last change on this file since 3688 was 3688, checked in by phaller, 25 years ago

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