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

Last change on this file since 3942 was 3942, checked in by bird, 25 years ago

Function status corrections.
File size: 40.2 KB
Line 
1/* $Id: ordinal.cpp,v 1.4 2000-08-02 20:18:23 bird 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 : STUB 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 : STUB 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED ? 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 : COMPLETELY IMPLEMENTED ? 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED 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 : COMPLETELY IMPLEMENTED ? 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 : COMPLETELY IMPLEMENTED ? 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 : COMPLETELY IMPLEMENTED ? 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 : STUB 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
1265* dynamically load SHELL32.DllGetVersion
1266*
1267*/
1268ODINFUNCTION0(DWORD, SHLWAPI_276)
1269{
1270 FIXME("()stub\n");
1271 return 0xabba1244;
1272}
1273
1274
1275/*************************************************************************
1276* SHLWAPI_309 [SHLWAPI]
1277*
1278*/
1279ODINFUNCTION1(DWORD, SHLWAPI_309,
1280 LPVOID, x)
1281{
1282 FIXME("(%p)stub\n",x);
1283 return 0xabba1245;
1284}
1285
1286/*************************************************************************
1287* SHLWAPI_342 [SHLWAPI]
1288*
1289*/
1290ODINFUNCTION4(DWORD, SHLWAPI_342,
1291 LPVOID, w,
1292 LPVOID, x,
1293 LPVOID, y,
1294 LPVOID, z)
1295{
1296 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
1297 return 0xabba1249;
1298}
1299
1300/*************************************************************************
1301* SHLWAPI_346 [SHLWAPI]
1302*/
1303ODINFUNCTION3(DWORD, SHLWAPI_346,
1304 LPCWSTR, src,
1305 LPWSTR, dest,
1306 int, len)
1307{
1308 FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
1309 lstrcpynW(dest, src, len);
1310 return lstrlenW(dest)+1;
1311}
1312
1313
1314/*****************************************************************************
1315 * Name : SHLWAPI_364
1316 * Purpose : call lstrcpynA
1317 * Parameters:
1318 * Variables :
1319 * Result :
1320 * Remark : SHLWAPI.364
1321 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1322 *
1323 * Author :
1324 *****************************************************************************/
1325
1326ODINFUNCTION3(INT, SHLWAPI_364,
1327 LPSTR, lpStr1,
1328 LPSTR, lpStr2,
1329 INT, nLength)
1330{
1331 // @@@PH is there some parameter twisting ?
1332 lstrcpynA(lpStr2,
1333 lpStr1,
1334 nLength);
1335
1336 return 1;
1337}
1338
1339
1340/*****************************************************************************
1341 * Name : DWORD SHLWAPI_376
1342 * Purpose : Try to determine user interface language
1343 * Parameters:
1344 * Variables :
1345 * Result :
1346 * Remark : SHLWAPI.366
1347 * Status : PARTIALLY IMPLEMENTED UNTESTED
1348 *
1349 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1350 *****************************************************************************/
1351
1352ODINFUNCTION0(DWORD, SHLWAPI_376)
1353{
1354 /* Microsoft does a hell of a job here: looks for
1355 * - Internet Explorer
1356 * - Office
1357 * - Lpk ?
1358 * - Resource Locales
1359 * - etc.
1360 */
1361
1362 return 0x0409; // @@@PH maybe this is 'nuf for now.
1363}
1364
1365
1366
1367/*************************************************************************
1368* SHLWAPI_377 [SHLWAPI]
1369*/
1370ODINFUNCTION3(DWORD, SHLWAPI_377,
1371 LPSTR, lpstrModule,
1372 HMODULE, hModule,
1373 LPVOID, z)
1374{
1375 static BOOL flagSHLWAPI_377Initialized = FALSE;
1376 static BOOL flagInternetExplorerCheckVersion = FALSE;
1377
1378 dprintf(("not (properly) implemented.\n"));
1379
1380 char szModuleName[260]; // MAXPATHLEN
1381 HMODULE hModLanguage;
1382
1383 // initialize this subsystem
1384 if (flagSHLWAPI_377Initialized == FALSE)
1385 {
1386 flagSHLWAPI_377Initialized = TRUE;
1387
1388 flagInternetExplorerCheckVersion =
1389 SHRegGetBoolUSValueA("Software\\Microsoft\\Internet Explorer\\International",
1390 "CheckVersion",
1391 1,
1392 1);
1393 }
1394
1395 if (lpstrModule == NULL) // Garbage in - garbage out
1396 return 0;
1397
1398 if (0 == GetModuleFileNameA(hModule,
1399 szModuleName,
1400 sizeof(szModuleName)))
1401 {
1402 // treat error
1403 }
1404 else
1405 {
1406 PathRemoveFileSpecA(szModuleName);
1407 PathAppendA(szModuleName,
1408 lpstrModule);
1409 // @@@PH twiddle around with the current IE codepage
1410 hModLanguage = LoadLibraryA(szModuleName);
1411 }
1412
1413
1414 return hModLanguage;
1415}
1416
1417
1418/*****************************************************************************
1419 * Name : DWORD SHLWAPI_437
1420 * Purpose : Determine product version and options
1421 * Parameters:
1422 * Variables :
1423 * Result :
1424 * Remark : SHLWAPI.437
1425 * Status : UNTESTED
1426 *
1427 * Author : Patrick Haller [Sun, 2000/06/10 04:02]
1428 *****************************************************************************/
1429
1430#define REG_PRODUCTOPTIONS "System\\CurrentControlSet\\Control\\ProductOptions"
1431#define REG_OPTIONS_PRODUCTTYPE "ProductType"
1432#define REG_OPTIONS_ENTERPRISE "Enterprise"
1433#define REG_OPTIONS_DATACENTER "DataCenter"
1434
1435ODINFUNCTION1(DWORD, SHLWAPI_437,
1436 DWORD, nFunction)
1437{
1438 static BOOL flagProductOptionsInitialized = FALSE;
1439 static BOOL flagIsProductEnterprise = FALSE;
1440 static BOOL flagIsProductDatacenter = FALSE;
1441 static OSVERSIONINFOA osVersionInfo;
1442
1443 HKEY hKeyOptions;
1444 DWORD dwKeyType;
1445 char szBuffer[260]; // MAX_PATH_LEN
1446 DWORD dwDataLength;
1447
1448 dprintf(("not (properly) implemented.\n"));
1449
1450 if (flagProductOptionsInitialized == FALSE)
1451 {
1452 // set to TRUE regardless of subsequent errors
1453 flagProductOptionsInitialized = TRUE;
1454
1455 // initialize required structures
1456 osVersionInfo.dwOSVersionInfoSize = 0x9c;
1457 if (GetVersionExA(&osVersionInfo) == FALSE)
1458 {
1459 osVersionInfo.dwOSVersionInfoSize = 0x94;
1460 GetVersionExA(&osVersionInfo);
1461 }
1462
1463 LONG rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1464 REG_PRODUCTOPTIONS,
1465 0,
1466 KEY_READ,
1467 &hKeyOptions);
1468 if (rc == ERROR_SUCCESS)
1469 {
1470 dwDataLength = sizeof(szBuffer);
1471 rc = RegQueryValueExA(hKeyOptions,
1472 REG_OPTIONS_PRODUCTTYPE,
1473 0,
1474 &dwKeyType,
1475 (LPBYTE)szBuffer,
1476 &dwDataLength);
1477 if (StrStrIA(szBuffer, REG_OPTIONS_ENTERPRISE) != 0)
1478 flagIsProductEnterprise = TRUE;
1479 else
1480 if (StrStrIA(szBuffer, REG_OPTIONS_DATACENTER) != 0)
1481 flagIsProductDatacenter = TRUE;
1482
1483 RegCloseKey(hKeyOptions);
1484 }
1485 }
1486
1487 // OK, now to the usual work ...
1488 switch (nFunction)
1489 {
1490 // is platform WINDOWS
1491 case 0:
1492 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
1493 return 1;
1494 else
1495 return 0;
1496
1497 // is platform NT
1498 case 1:
1499 if (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
1500 return 1;
1501 else
1502 return 0;
1503
1504 // is platform Windows 95/98/xx ?
1505 case 2:
1506 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1507 return 0;
1508 if (osVersionInfo.dwMajorVersion >= 4)
1509 return 1;
1510 else
1511 return 0;
1512
1513 // is platform NT4 or better?
1514 case 3:
1515 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1516 return 0;
1517 if (osVersionInfo.dwMajorVersion >= 4)
1518 return 1;
1519 else
1520 return 0;
1521
1522 // is platform Win2000 or better?
1523 case 4:
1524 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
1525 return 0;
1526 if (osVersionInfo.dwMajorVersion >= 5)
1527 return 1;
1528 else
1529 return 0;
1530
1531 // at least Windows 4.10 ?
1532 case 5:
1533 if (osVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
1534 return 0;
1535 if (osVersionInfo.dwMajorVersion > 4)
1536 return 1;
1537 else
1538 if (osVersionInfo.dwMajorVersion == 4)
1539 if (osVersionInfo.dwMinorVersion >= 10)
1540 return 1;
1541
1542 return 0;
1543
1544 // is platform Windows98 GA ?
1545 case 6:
1546 if ( (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) &&
1547 (osVersionInfo.dwMajorVersion == 4) &&
1548 (osVersionInfo.dwMinorVersion == 10) &&
1549 (osVersionInfo.dwBuildNumber == 1998) ) // 0x7ce
1550 return 1;
1551 else
1552 return 0;
1553
1554 // is platform some specific CSD ?
1555 case 7:
1556 case 8:
1557 //@@@PH incorrect
1558 if (osVersionInfo.dwMajorVersion >= 5)
1559 return 1;
1560 else
1561 return 0;
1562
1563 case 9:
1564 //@@@PH incorrect
1565 if (osVersionInfo.dwMajorVersion >= 5 ||
1566 flagIsProductEnterprise ||
1567 flagIsProductDatacenter)
1568 return 1;
1569 else
1570 return 0;
1571
1572 case 10:
1573 //@@@PH incorrect
1574 if (osVersionInfo.dwMajorVersion >= 5)
1575 return flagIsProductEnterprise;
1576 else
1577 return 0;
1578
1579 case 11:
1580 //@@@PH incorrect
1581 if (osVersionInfo.dwMajorVersion >= 5)
1582 return flagIsProductDatacenter;
1583 else
1584 return 0;
1585
1586 // @@@PH: Oops, wazzup there ?
1587 case 12:
1588 return GetSystemMetrics(4096);
1589 }
1590
1591 return 0;
1592}
1593
1594
1595/*****************************************************************************
1596 * Name : SHIsLowMemoryMachine
1597 * Purpose :
1598 * Parameters: BOOL fRetest - TRUE if testing shall be repeated
1599 * - FALSE if cached result is to be used
1600 * Variables :
1601 * Result : 0 - machine is not memory-constrained
1602 * 1 - machine is memory-constrained
1603 * Remark : SHLWAPI.584
1604 * Status : COMPLETELY IMPLEMENTED ? UNTESTED
1605 *
1606 * Author : Patrick Haller [Mon, 2000/06/11 02:02]
1607 *****************************************************************************/
1608
1609ODINFUNCTION1(int, SHIsLowMemoryMachine,
1610 BOOL, fRetest)
1611{
1612 MEMORYSTATUS memBuffer;
1613 static int flagIsLowMemoryMachine = -1;
1614 ULONG ulMem;
1615
1616 // use cached result?
1617 if ( (fRetest == TRUE) ||
1618 (flagIsLowMemoryMachine == -1) )
1619 {
1620 // determine and store result
1621 GlobalMemoryStatus(&memBuffer);
1622 if (VERSION_OsIsUnicode())
1623 ulMem = 0x1000000; // unicode operation mode
1624 else
1625 ulMem = 0x0800000; // ascii operation mode
1626
1627 // enough memory?
1628 if (memBuffer.dwTotalPhys <= ulMem)
1629 flagIsLowMemoryMachine = 1;
1630 else
1631 flagIsLowMemoryMachine = 0;
1632 }
1633
1634 return flagIsLowMemoryMachine;
1635}
Note: See TracBrowser for help on using the repository browser.