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

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

.
File size: 34.8 KB
Line 
1/* $Id: ordinal.cpp,v 1.2 2000-06-12 08:09:37 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* SHLWAPI_193 [SHLWAPI]
920* query current color depth
921*/
922ODINFUNCTION0(DWORD, SHLWAPI_193)
923{
924 HDC hdc;
925 DWORD ret;
926
927 hdc = GetDC(0);
928 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
929 ReleaseDC(0, hdc);
930 return ret;
931}
932
933
934/*****************************************************************************
935 * Name : BOOL SHLWAPI_197
936 * Purpose : Set text background?
937 * Parameters:
938 * Variables :
939 * Result :
940 * Remark : SHLWAPI.197
941 * Status : UNTESTED
942 *
943 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
944 *****************************************************************************/
945
946ODINFUNCTION3(BOOL, SHLWAPI_197,
947 HDC, hdc,
948 CONST RECT*, lprc,
949 COLORREF, crColor)
950{
951 COLORREF crOld;
952 BOOL res;
953
954 crOld = SetBkColor(hdc, crColor);
955 res = ExtTextOutA(hdc,
956 0,
957 0,
958 ETO_OPAQUE,
959 lprc,
960 0,
961 0,
962 0);
963 SetBkColor(hdc, crOld);
964
965 return res;
966}
967
968
969/*************************************************************************
970* SHLWAPI_219 [SHLWAPI]
971*/
972ODINFUNCTION4(HRESULT, SHLWAPI_219,
973 LPVOID, w, /* returned by LocalAlloc */
974 LPVOID, x,
975 LPVOID, y,
976 LPWSTR, z) /* OUT: path */
977{
978 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
979 return 0xabba1252;
980}
981
982
983/*************************************************************************
984* SHLWAPI_222 [SHLWAPI]
985*
986* NOTES
987* securityattributes missing
988*/
989ODINFUNCTION1(HANDLE, SHLWAPI_222,
990 LPCLSID, guid)
991{
992 char lpstrName[80];
993 strcpy( lpstrName,"shell.");
994 WINE_StringFromCLSID(guid, lpstrName + strlen(lpstrName));
995
996 FIXME("(%s) stub\n", lpstrName);
997 return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
998}
999
1000
1001/*************************************************************************
1002* SHLWAPI_223 [SHLWAPI]
1003*
1004* NOTES
1005* function guessed
1006*/
1007ODINFUNCTION1(DWORD, SHLWAPI_223,
1008 HANDLE, handle)
1009{
1010 LONG oldCount;
1011
1012 FIXME("(0x%08x) stub\n",handle);
1013
1014 ReleaseSemaphore( handle, 1, &oldCount);
1015 WaitForSingleObject( handle, 0 );
1016 return 0;
1017}
1018
1019
1020/*************************************************************************
1021* SHLWAPI_237 [SHLWAPI]
1022* Purpose: verify a WNDCLASSW structure
1023*/
1024ODINFUNCTION1(DWORD, SHLWAPI_237,
1025 LPWNDCLASSW, lpWndClass)
1026{
1027 WNDCLASSW wndClass;
1028
1029 if (GetClassInfoW(lpWndClass->hInstance,
1030 (LPWSTR)lpWndClass->lpszClassName,
1031 &wndClass) == TRUE)
1032 return 1;
1033 else
1034 return 0;
1035}
1036
1037
1038/*****************************************************************************
1039 * Name : LRESULT DefWindowProcAW
1040 * Purpose :
1041 * Parameters:
1042 * Variables :
1043 * Result :
1044 * Remark : SHLWAPI.240 - this version has dynamic unicode behaviour
1045 * Status : UNTESTED
1046 *
1047 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1048 *****************************************************************************/
1049
1050ODINFUNCTION4(LRESULT, DefWindowProcAW,
1051 HWND, hWnd,
1052 UINT, Msg,
1053 WPARAM, wParam,
1054 LPARAM, lParam)
1055{
1056 if (IsWindowUnicode(hWnd))
1057 return DefWindowProcW(hWnd, Msg, wParam, lParam);
1058 else
1059 return DefWindowProcA(hWnd, Msg, wParam, lParam);
1060}
1061
1062
1063/*************************************************************************
1064* SHLWAPI_241 [SHLWAPI]
1065*
1066*/
1067ODINFUNCTION0(DWORD, SHLWAPI_241)
1068{
1069 FIXME("()stub\n");
1070 return 0xabba1243;
1071}
1072
1073/*************************************************************************
1074* SHLWAPI_266 [SHLWAPI]
1075*/
1076ODINFUNCTION4(DWORD, SHLWAPI_266,
1077 LPVOID, w,
1078 LPVOID, x,
1079 LPVOID, y,
1080 LPVOID, z)
1081{
1082 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1083 return 0xabba1248;
1084}
1085
1086/*************************************************************************
1087* SHLWAPI_267 [SHLWAPI]
1088*/
1089ODINFUNCTION4(HRESULT, SHLWAPI_267,
1090 LPVOID, w, /* same as 1th parameter of SHLWAPI_219 */
1091 LPVOID, x, /* same as 2nd parameter of SHLWAPI_219 */
1092 LPVOID, y,
1093 LPVOID, z)
1094{
1095 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1096 *((LPDWORD)z) = 0xabba1200;
1097 return 0xabba1254;
1098}
1099
1100/*************************************************************************
1101* SHLWAPI_268 [SHLWAPI]
1102*/
1103ODINFUNCTION2(DWORD, SHLWAPI_268,
1104 LPVOID, w,
1105 LPVOID, x)
1106{
1107 FIXME("(%p %p)\n",w,x);
1108 return 0xabba1251; /* 0 = failure */
1109}
1110
1111/*************************************************************************
1112* SHLWAPI_276 [SHLWAPI]
1113* dynamically load SHELL32.DllGetVersion
1114*
1115*/
1116ODINFUNCTION0(DWORD, SHLWAPI_276)
1117{
1118 FIXME("()stub\n");
1119 return 0xabba1244;
1120}
1121
1122
1123/*************************************************************************
1124* SHLWAPI_309 [SHLWAPI]
1125*
1126*/
1127ODINFUNCTION1(DWORD, SHLWAPI_309,
1128 LPVOID, x)
1129{
1130 FIXME("(%p)stub\n",x);
1131 return 0xabba1245;
1132}
1133
1134/*************************************************************************
1135* SHLWAPI_342 [SHLWAPI]
1136*
1137*/
1138ODINFUNCTION4(DWORD, SHLWAPI_342,
1139 LPVOID, w,
1140 LPVOID, x,
1141 LPVOID, y,
1142 LPVOID, z)
1143{
1144 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1145 return 0xabba1249;
1146}
1147
1148/*************************************************************************
1149* SHLWAPI_346 [SHLWAPI]
1150*/
1151ODINFUNCTION3(DWORD, SHLWAPI_346,
1152 LPCWSTR, src,
1153 LPWSTR, dest,
1154 int, len)
1155{
1156 FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
1157 lstrcpynW(dest, src, len);
1158 return lstrlenW(dest)+1;
1159}
1160
1161
1162/*****************************************************************************
1163 * Name : SHLWAPI_364
1164 * Purpose : call lstrcpynA
1165 * Parameters:
1166 * Variables :
1167 * Result :
1168 * Remark : SHLWAPI.364
1169 * Status : UNTESTED
1170 *
1171 * Author :
1172 *****************************************************************************/
1173
1174ODINFUNCTION3(INT, SHLWAPI_364,
1175 LPSTR, lpStr1,
1176 LPSTR, lpStr2,
1177 INT, nLength)
1178{
1179 // @@@PH is there some parameter twisting ?
1180 lstrcpynA(lpStr2,
1181 lpStr1,
1182 nLength);
1183
1184 return 1;
1185}
1186
1187
1188
1189/*************************************************************************
1190* SHLWAPI_377 [SHLWAPI]
1191*/
1192ODINFUNCTION3(DWORD, SHLWAPI_377,
1193 LPVOID, x,
1194 LPVOID, y,
1195 LPVOID, z)
1196{
1197 FIXME("(%p %p %p)stub\n", x,y,z);
1198 return 0xabba1246;
1199}
1200
1201
1202/*****************************************************************************
1203 * Name : DWORD SHLWAPI_437
1204 * Purpose : Determine product version and options
1205 * Parameters:
1206 * Variables :
1207 * Result :
1208 * Remark : SHLWAPI.437
1209 * Status : UNTESTED
1210 *
1211 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1212 *****************************************************************************/
1213
1214#define REG_PRODUCTOPTIONS "System\\CurrentControlSet\\Control\\ProductOptions"
1215#define REG_OPTIONS_PRODUCTTYPE "ProductType"
1216#define REG_OPTIONS_ENTERPRISE "Enterprise"
1217#define REG_OPTIONS_DATACENTER "DataCenter"
1218
1219ODINFUNCTION1(DWORD, SHLWAPI_437,
1220 DWORD, nFunction)
1221{
1222 static BOOL flagProductOptionsInitialized = FALSE;
1223 static BOOL flagIsProductEnterprise = FALSE;
1224 static BOOL flagIsProductDatacenter = FALSE;
1225 static OSVERSIONINFOA osVersionInfo;
1226
1227 HKEY hKeyOptions;
1228 DWORD dwKeyType;
1229 char szBuffer[260]; // MAX_PATH_LEN
1230 DWORD dwDataLength;
1231
1232 dprintf(("not (properly) implemented.\n"));
1233
1234 if (flagProductOptionsInitialized == FALSE)
1235 {
1236 // set to TRUE regardless of subsequent errors
1237 flagProductOptionsInitialized = TRUE;
1238
1239 // initialize required structures
1240 osVersionInfo.dwOSVersionInfoSize = 0x9c;
1241 if (GetVersionExA(&osVersionInfo) == FALSE)
1242 {
1243 osVersionInfo.dwOSVersionInfoSize = 0x94;
1244 GetVersionExA(&osVersionInfo);
1245 }
1246
1247 LONG rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1248 REG_PRODUCTOPTIONS,
1249 0,
1250 KEY_READ,
1251 &hKeyOptions);
1252 if (rc == ERROR_SUCCESS)
1253 {
1254 dwDataLength = sizeof(szBuffer);
1255 rc = RegQueryValueExA(hKeyOptions,
1256 REG_OPTIONS_PRODUCTTYPE,
1257 0,
1258 &dwKeyType,
1259 (LPBYTE)szBuffer,
1260 &dwDataLength);
1261 if (StrStrIA(szBuffer, REG_OPTIONS_ENTERPRISE) != 0)
1262 flagIsProductEnterprise = TRUE;
1263 else
1264 if (StrStrIA(szBuffer, REG_OPTIONS_DATACENTER) != 0)
1265 flagIsProductDatacenter = TRUE;
1266
1267 RegCloseKey(hKeyOptions);
1268 }
1269 }
1270
1271 // OK, now to the usual work ...
1272 switch (nFunction)
1273 {
1274 // is platform WINDOWS
1275 case 0:
1276 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
1277 return 1;
1278 else
1279 return 0;
1280
1281 // is platform NT
1282 case 1:
1283 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
1284 return 1;
1285 else
1286 return 0;
1287
1288 // is platform Windows 95/98/xx ?
1289 case 2:
1290 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1291 return 0;
1292 if (osVersionInfo.dwMajorVersion >= 4)
1293 return 1;
1294 else
1295 return 0;
1296
1297 // is platform NT4 or better?
1298 case 3:
1299 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1300 return 0;
1301 if (osVersionInfo.dwMajorVersion >= 4)
1302 return 1;
1303 else
1304 return 0;
1305
1306 // is platform Win2000 or better?
1307 case 4:
1308 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1309 return 0;
1310 if (osVersionInfo.dwMajorVersion >= 5)
1311 return 1;
1312 else
1313 return 0;
1314
1315 // at least Windows 4.10 ?
1316 case 5:
1317 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1318 return 0;
1319 if (osVersionInfo.dwMajorVersion > 4)
1320 return 1;
1321 else
1322 if (osVersionInfo.dwMajorVersion == 4)
1323 if (osVersionInfo.dwMinorVersion >= 10)
1324 return 1;
1325
1326 return 0;
1327
1328 // is platform Windows98 GA ?
1329 case 6:
1330 if ( (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) &&
1331 (osVersionInfo.dwMajorVersion == 4) &&
1332 (osVersionInfo.dwMinorVersion == 10) &&
1333 (osVersionInfo.dwBuildNumber == 1998) ) // 0x7ce
1334 return 1;
1335 else
1336 return 0;
1337
1338 // is platform some specific CSD ?
1339 case 7:
1340 case 8:
1341 //@@@PH incorrect
1342 if (osVersionInfo.dwMajorVersion >= 5)
1343 return 1;
1344 else
1345 return 0;
1346
1347 case 9:
1348 //@@@PH incorrect
1349 if (osVersionInfo.dwMajorVersion >= 5 ||
1350 flagIsProductEnterprise ||
1351 flagIsProductDatacenter)
1352 return 1;
1353 else
1354 return 0;
1355
1356 case 10:
1357 //@@@PH incorrect
1358 if (osVersionInfo.dwMajorVersion >= 5)
1359 return flagIsProductEnterprise;
1360 else
1361 return 0;
1362
1363 case 11:
1364 //@@@PH incorrect
1365 if (osVersionInfo.dwMajorVersion >= 5)
1366 return flagIsProductDatacenter;
1367 else
1368 return 0;
1369
1370 // @@@PH: Oops, wazzup there ?
1371 case 12:
1372 return GetSystemMetrics(4096);
1373 }
1374
1375 return 0;
1376}
1377
1378
1379/*****************************************************************************
1380 * Name : SHIsLowMemoryMachine
1381 * Purpose :
1382 * Parameters: BOOL fRetest - TRUE if testing shall be repeated
1383 * - FALSE if cached result is to be used
1384 * Variables :
1385 * Result : 0 - machine is not memory-constrained
1386 * 1 - machine is memory-constrained
1387 * Remark : SHLWAPI.584
1388 * Status : UNTESTED
1389 *
1390 * Author : Patrick Haller [Mon, 2000/06/11 02:02]
1391 *****************************************************************************/
1392
1393ODINFUNCTION1(int, SHIsLowMemoryMachine,
1394 BOOL, fRetest)
1395{
1396 MEMORYSTATUS memBuffer;
1397 static int flagIsLowMemoryMachine = -1;
1398 ULONG ulMem;
1399
1400 // use cached result?
1401 if ( (fRetest == TRUE) ||
1402 (flagIsLowMemoryMachine == -1) )
1403 {
1404 // determine and store result
1405 GlobalMemoryStatus(&memBuffer);
1406 if (VERSION_OsIsUnicode())
1407 ulMem = 0x1000000; // unicode operation mode
1408 else
1409 ulMem = 0x0800000; // ascii operation mode
1410
1411 // enough memory?
1412 if (memBuffer.dwTotalPhys <= ulMem)
1413 flagIsLowMemoryMachine = 1;
1414 else
1415 flagIsLowMemoryMachine = 0;
1416 }
1417
1418 return flagIsLowMemoryMachine;
1419}
Note: See TracBrowser for help on using the repository browser.