source: trunk/src/shell32/ordinal.cpp@ 172

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

Add: ExtractAssociatedIconA/W added, source files split
File size: 22.9 KB
Line 
1/* $Id: ordinal.cpp,v 1.1 1999-06-23 22:17:52 phaller Exp $ */
2
3/*
4 * Win32 SHELL32 for OS/2
5 * Copyright 1997 Marcus Meissner
6 * Copyright 1988 Patrick Haller (adapted for win32os2)
7 * Project Odin Software License can be found in LICENSE.TXT
8 *
9 */
10
11
12/*****************************************************************************
13 * Includes *
14 *****************************************************************************/
15
16#include <os2win.h>
17#include <shellapi.h>
18#include <winreg.h>
19#include "shell32.h"
20
21#include <stdarg.h>
22//#include <builtin.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include <misc.h>
28#include <nameid.h>
29#include <unicode.h>
30
31
32/*****************************************************************************
33 * Types & Defines *
34 *****************************************************************************/
35
36
37/*************************************************************************
38 * SHELL32_2 [SHELL32.2]
39 */
40DWORD WIN32API SHELL32_2(HWND hwnd,
41 DWORD x2,
42 DWORD x3,
43 DWORD x4,
44 DWORD x5,
45 DWORD x6)
46{
47 dprintf(("SHELL32: .2 (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx) not implemented.\n",
48 hwnd,
49 x2,
50 x3,
51 x4,
52 x5,
53 x6));
54 return 0;
55}
56
57
58/*************************************************************************
59 * SHELL32_16 [SHELL32.16]
60 * find_lastitem_in_itemidlist()
61 */
62LPSHITEMID WIN32API SHELL32_16(LPITEMIDLIST iil)
63{
64 LPSHITEMID lastsii,
65 sii;
66
67 dprintf(("SHELL32: .16 (%08xh)\n",
68 iil));
69
70 if (!iil)
71 return NULL;
72
73 sii = &(iil->mkid);
74 lastsii = sii;
75
76 while (sii->cb)
77 {
78 lastsii = sii;
79 sii = (LPSHITEMID)(((char*)sii)+sii->cb);
80 }
81
82 return lastsii;
83}
84
85
86/*************************************************************************
87 * SHELL32_29 [SHELL32.29]
88 * is_rootdir(const char*path)
89 */
90BOOL WIN32API SHELL32_29(LPCSTR x)
91{
92 dprintf(("SHELL32: .29 (%s)\n",
93 x));
94
95
96 if (!lstrcmpA(x+1,":\\")) /* "X:\" */
97 return 1;
98
99 if (!lstrcmpA(x,"\\")) /* "\" */
100 return 1;
101
102 if (x[0]=='\\' && x[1]=='\\')
103 { /* UNC "\\<xx>\" */
104 int foundbackslash = 0;
105
106 x=x+2;
107 while (*x)
108 {
109 if (*x++=='\\')
110 foundbackslash++;
111 }
112
113 if (foundbackslash<=1) /* max 1 \ more ... */
114 return 1;
115 }
116 return 0;
117}
118
119
120/*************************************************************************
121 * SHELL32_30 [SHELL32.30]
122 * get_rootdir(char*path,int drive)
123 */
124LPSTR WIN32API SHELL32_30(LPSTR root,
125 BYTE drive)
126{
127 dprintf(("SHELL32: .30 (%s, %u)\n",
128 root,
129 drive));
130
131
132 strcpy(root,
133 "A:\\");
134 root[0]+=drive;
135
136 return root;
137}
138
139
140/*************************************************************************
141 * SHELL32_31 [SHELL32.31]
142 * returns pointer to last . in last pathcomponent or at \0.
143 */
144LPSTR WIN32API SHELL32_31(LPSTR path)
145{
146 LPSTR lastpoint = NULL;
147
148 dprintf(("SHELL32: .31 (%s)\n",
149 path));
150
151
152 while (*path)
153 {
154 if (*path=='\\'||*path==' ')
155 lastpoint=NULL;
156
157 if (*path=='.')
158 lastpoint=path;
159
160 path++;
161 }
162
163 return lastpoint ? lastpoint : path;
164}
165
166
167/*************************************************************************
168 * SHELL32_32 [SHELL32.32]
169 * append \ if there is none
170 */
171LPSTR WIN32API SHELL32_32(LPSTR path)
172{
173 int len;
174
175 dprintf(("SHELL32: .31 (%s)\n",
176 path));
177
178
179 len = lstrlenA(path);
180
181 if (len && path[len-1]!='\\')
182 {
183 path[len+0]='\\';
184 path[len+1]='\0';
185 return path+len+1;
186 }
187 else
188 return path+len;
189}
190
191
192/*************************************************************************
193 * SHELL32_33 [SHELL32.33]
194 * remove spaces from beginning and end of passed string
195 */
196LPSTR WIN32API SHELL32_33(LPSTR str)
197{
198 LPSTR x = str;
199
200 dprintf(("SHELL32: .33 (%s)\n",
201 str));
202
203
204 while (*x==' ')
205 x++;
206
207 if (x!=str)
208 lstrcpyA(str,
209 x);
210
211 if (!*str)
212 return str;
213
214 x=str+strlen(str)-1;
215
216 while (*x==' ')
217 x--;
218
219 if (*x==' ')
220 *x='\0';
221
222 return x;
223}
224
225
226/*************************************************************************
227 * SHELL32_34 [SHELL32.34]
228 * basename(char *fn);
229 */
230LPSTR WIN32API SHELL32_34(LPSTR fn)
231{
232 LPSTR basefn;
233
234 dprintf(("SHELL32: .34 (%s)\n",
235 fn));
236
237
238 basefn = fn;
239 while (fn[0])
240 {
241 if (( (fn[0]=='\\') ||
242 (fn[0]==':')) && fn[1] && fn[1]!='\\')
243 basefn = fn+1;
244
245 fn++;
246 }
247
248 return basefn;
249}
250
251/*************************************************************************
252 * SHELL32_35 [SHELL32.35]
253 * bool getpath(char *pathname); truncates passed argument to a valid path
254 * returns if the string was modified or not.
255 * "\foo\xx\foo"-> "\foo\xx"
256 * "\" -> "\"
257 * "a:\foo" -> "a:\"
258 */
259DWORD WIN32API SHELL32_35(LPSTR fn)
260{
261 LPSTR x,cutplace;
262
263 dprintf(("SHELL32: .35 (%s)\n",
264 fn));
265
266
267 if (!fn[0])
268 return 0;
269 x=fn;
270 cutplace = fn;
271 while (*x) {
272 if (*x=='\\') {
273 cutplace=x++;
274 continue;
275 }
276 if (*x==':') {
277 x++;
278 if (*x=='\\')
279 cutplace=++x;
280 continue; /* already x++ed */
281 }
282 x++;
283 }
284 if (!*cutplace)
285 return 0;
286 if (cutplace==fn) {
287 if (fn[0]=='\\') {
288 if (!fn[1])
289 return 0;
290 fn[0]='\0';
291 return 1;
292 }
293 }
294 *cutplace='\0';
295 return 1;
296}
297
298/*************************************************************************
299 * SHELL32_37 [SHELL32.37]
300 * concat_paths(char*target,const char*add);
301 * concats "target\\add" and writes them to target
302 */
303LPSTR WIN32API SHELL32_37(LPSTR target,
304 LPSTR x1,
305 LPSTR x2)
306{
307 char buf[260];
308
309 dprintf(("SHELL32: .37 (%s, %s, %s)\n",
310 target,
311 x1,
312 x2));
313
314
315 if (!x2 || !x2[0])
316 {
317 lstrcpyA(target,x1);
318
319 return target;
320 }
321
322 lstrcpyA(buf,x1);
323 SHELL32_32(buf); /* append \ if not there */
324 lstrcatA(buf,x2);
325 lstrcpyA(target,buf);
326
327 return target;
328}
329
330/*************************************************************************
331 * SHELL32_36 [SHELL32.36]
332 * concat_paths(char*target,const char*add);
333 * concats "target\\add" and writes them to target
334 */
335LPSTR WIN32API SHELL32_36(LPSTR x1,
336 LPSTR x2)
337{
338 dprintf(("SHELL32: .36 (%s, %s)\n",
339 x1,
340 x2));
341
342
343 while (x2[0]=='\\')
344 x2++;
345
346 return SHELL32_37(x1,
347 x1,
348 x2);
349}
350
351/*************************************************************************
352 * SHELL32_39 [SHELL32.39]
353 * isUNC(const char*path);
354 */
355BOOL WIN32API SHELL32_39(LPCSTR path)
356{
357 dprintf (("SHELL32: .39 (%s)\n",
358 path));
359
360
361 if ((path[0]=='\\') &&
362 (path[1]=='\\'))
363 return TRUE;
364
365 return FALSE;
366}
367
368
369/*************************************************************************
370 * SHELL32_45 [SHELL32.45]
371 * file_exists(char *fn);
372 */
373BOOL WIN32API SHELL32_45(LPSTR fn)
374{
375 dprintf(("SHELL32: .45 (%s)\n",
376 fn));
377
378
379 if (GetFileAttributesA(fn)==-1)
380 return FALSE;
381 else
382 return TRUE;
383}
384
385/*************************************************************************
386 * SHELL32_52 [SHELL32.52]
387 * look for next arg in string. handle "quoted" strings
388 * returns pointer to argument *AFTER* the space. Or to the \0.
389 */
390LPSTR WIN32API SHELL32_52(LPSTR cmdline)
391{
392 BOOL qflag = FALSE;
393
394 dprintf (("SHELL32: .52 (%s)\n",
395 cmdline));
396
397
398 while (*cmdline)
399 {
400 if ((*cmdline==' ') && !qflag)
401 return cmdline+1;
402
403 if (*cmdline=='"')
404 qflag=!qflag;
405
406 cmdline++;
407 }
408 return cmdline;
409}
410
411
412/*************************************************************************
413 * SHELL32_56 [SHELL32.56]
414 * unquote string (remove ")
415 */
416VOID WIN32API SHELL32_56(LPSTR str)
417{
418 DWORD len = lstrlenA(str);
419
420 dprintf (("SHELL32: .56 (%s)\n",
421 str));
422
423
424 if (*str!='"')
425 return;
426
427 if (str[len-1]!='"')
428 return;
429
430 str[len-1]='\0';
431 lstrcpyA(str,
432 str+1);
433 return;
434}
435
436
437/*************************************************************************
438 * SHELL32_58 [SHELL32.58]
439 */
440DWORD WIN32API SHELL32_58(LPCSTR src,
441 DWORD x2,
442 LPSTR target,
443 DWORD pathlen)
444{
445 dprintf (("SHELL32: .58 (%s, %08xh, %08xh, %08xh) not implemented\n",
446 src,
447 x2,
448 target,
449 pathlen));
450
451 return 0;
452}
453
454
455/*************************************************************************
456 * SHELL32_62 [SHELL32.62]
457 */
458DWORD WIN32API SHELL32_62(DWORD x,
459 DWORD y,
460 DWORD z,
461 DWORD a)
462{
463 dprintf(("SHELL32: .62 (%08xh, %08xh, %08xh, %08xh) not implemented.\n",
464 x,
465 y,
466 z,
467 a));
468
469 return 0xffffffff;
470}
471
472
473/*************************************************************************
474 * SHELL32_63 [SHELL32.63]
475 */
476DWORD WIN32API SHELL32_63(HWND howner,
477 LPSTR targetbuf,
478 DWORD len,
479 DWORD x,
480 LPCSTR suffix,
481 LPCSTR y,
482 LPCSTR cmd)
483{
484 dprintf (("SHELL32: .63 (%08xh, %08x, %08xh, %08xh, %08xh, %08xh, %s) not implemented.\n",
485 howner,
486 targetbuf,
487 len,
488 x,
489 suffix,
490 y,
491 cmd));
492
493 /* puts up a Open Dialog and requests input into targetbuf */
494 /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
495 lstrcpyA(targetbuf,"x:\\s3.exe");
496 return 1;
497}
498
499
500/*************************************************************************
501 * SHELL32_68 [SHELL32.68]
502 */
503DWORD WIN32API SHELL32_68(DWORD x,
504 DWORD y,
505 DWORD z)
506{
507 dprintf(("SHELL32: .68 (%08xh, %08xh, %08xh) not implemented.\n",
508 x,
509 y,
510 z));
511
512 return 0;
513}
514
515
516/*************************************************************************
517 * SHELL32_71 [SHELL32.71]
518 * returns internal shell values in the passed pointers
519 */
520BOOL WIN32API SHELL32_71(LPDWORD x,
521 LPDWORD y)
522{
523 dprintf(("SHELL32: .71 (%08xh, %08xh) not implemented.\n",
524 x,
525 y));
526
527 return TRUE;
528}
529
530
531/*************************************************************************
532 * SHELL32_72 [SHELL32.72]
533 * dunno. something with icons
534 */
535void WIN32API SHELL32_72(LPSTR x,
536 DWORD y,
537 DWORD z)
538{
539 dprintf (("SHELL32: .27 (%08xh, %08xh, %08xh) not implemented.\n",
540 x,
541 y,
542 z));
543}
544
545
546/*************************************************************************
547 * SHELL32_89 [SHELL32.89]
548 */
549DWORD WIN32API SHELL32_89(DWORD x1,
550 DWORD x2,
551 DWORD x3)
552{
553 dprintf(("SHELL32: .89 (%08xh, %08xh, %08xh) not implemented.\n",
554 x1,
555 x2,
556 x3));
557
558 return 0;
559}
560
561
562/*************************************************************************
563 * SHELL32_119 [SHELL32.119]
564 * unknown
565 */
566void WIN32API SHELL32_119(LPVOID x)
567{
568 dprintf(("SHELL32: .119 (%08xh) not implemented.\n",
569 x));
570}
571
572
573/*************************************************************************
574 * SHELL32_175 [SHELL32.175]
575 * unknown
576 */
577void WIN32API SHELL32_175(DWORD x1,
578 DWORD x2,
579 DWORD x3,
580 DWORD x4)
581{
582 dprintf (("SHELL32: .175 (%08x, %08xh, %08xh, %08xh not implemented.\n",
583 x1,
584 x2,
585 x3,
586 x4));
587}
588
589
590/*************************************************************************
591 * SHELL32_181 [SHELL32.181]
592 * unknown
593 */
594void WIN32API SHELL32_181(DWORD x,
595 DWORD y)
596{
597 dprintf(("SHELL32: .181 (%08xh, %08xh) not implemented.\n",
598 x,
599 y));
600}
601
602
603/*************************************************************************
604 * SHELL32_75 [SHELL32.75]
605 * unknown
606 */
607BOOL WIN32API SHELL32_75(LPDWORD x,
608 LPDWORD y)
609{
610 dprintf(("SHELL32: .75 (%08xh, %08xh) not implemented.\n",
611 x,
612 y));
613
614 return TRUE;
615}
616
617
618/*************************************************************************
619 * SHELL32_77 [SHELL32.77]
620 */
621DWORD WIN32API SHELL32_77(DWORD x,
622 DWORD y,
623 DWORD z)
624{
625 dprintf(("SHELL32: .77 (%08xh, %08xh, %08xh) not implemented.\n",
626 x,
627 y,
628 z));
629
630 return 0;
631}
632
633
634/*************************************************************************
635 * SHELL32_79 [SHELL32.79]
636 * create_directory_and_notify(...)
637 */
638DWORD WIN32API SHELL32_79(LPCSTR dir,
639 LPVOID xvoid)
640{
641 dprintf(("SHELL32: .79 (%s, %08xh)\n",
642 dir,
643 xvoid));
644
645 if (!CreateDirectoryA(dir,
646 (PSECURITY_ATTRIBUTES)xvoid))
647 return FALSE;
648
649 /* @@@PH: SHChangeNotify(8,1,dir,0); */
650 return TRUE;
651}
652
653
654/*************************************************************************
655 * SHELL32_100 [SHELL32.100]
656 * walks through policy table, queries <app> key, <type> value, returns
657 * queried (DWORD) value.
658 * {0x00001,Explorer,NoRun}
659 * {0x00002,Explorer,NoClose}
660 * {0x00004,Explorer,NoSaveSettings}
661 * {0x00008,Explorer,NoFileMenu}
662 * {0x00010,Explorer,NoSetFolders}
663 * {0x00020,Explorer,NoSetTaskbar}
664 * {0x00040,Explorer,NoDesktop}
665 * {0x00080,Explorer,NoFind}
666 * {0x00100,Explorer,NoDrives}
667 * {0x00200,Explorer,NoDriveAutoRun}
668 * {0x00400,Explorer,NoDriveTypeAutoRun}
669 * {0x00800,Explorer,NoNetHood}
670 * {0x01000,Explorer,NoStartBanner}
671 * {0x02000,Explorer,RestrictRun}
672 * {0x04000,Explorer,NoPrinterTabs}
673 * {0x08000,Explorer,NoDeletePrinter}
674 * {0x10000,Explorer,NoAddPrinter}
675 * {0x20000,Explorer,NoStartMenuSubFolders}
676 * {0x40000,Explorer,MyDocsOnNet}
677 * {0x80000,WinOldApp,NoRealMode}
678 */
679DWORD WIN32API SHELL32_100(DWORD pol)
680{
681 HKEY xhkey;
682
683 dprintf (("SHELL32: .100 (%08xh) not implemented.\n",
684 pol));
685
686 if (RegOpenKeyA((HKEY)HKEY_CURRENT_USER,
687 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
688 &xhkey))
689 return 0;
690
691 /* FIXME: do nothing for now, just return 0 (== "allowed") */
692 RegCloseKey(xhkey);
693
694 return 0;
695}
696
697
698/*************************************************************************
699 * SHELL32_152 [SHELL32.152]
700 * itemlist_length
701 */
702DWORD WIN32API SHELL32_152(LPITEMIDLIST iil)
703{
704 LPSHITEMID si;
705 DWORD len;
706
707 dprintf(("SHELL32: .152 (%08xh)\n",
708 iil));
709
710
711 si = &(iil->mkid);
712 len = 2;
713
714 while (si->cb)
715 {
716 len += si->cb;
717 si = (LPSHITEMID)(((char*)si)+si->cb);
718 }
719
720 return len;
721}
722
723
724/*************************************************************************
725 * SHELL32_158 [SHELL32.158]
726 */
727LPSTR WIN32API SHELL32_158(LPSTR path,
728 DWORD y,
729 DWORD z)
730{
731 dprintf(("SHELL32: .158 (%s, %08xh, %08xh)\n",
732 path,
733 y,
734 z));
735
736 path = SHELL32_31(path);
737
738 return *path ? (path+1) : path;
739}
740
741
742/*************************************************************************
743 * SHELL32_165 [SHELL32.165]
744 * create_path_and_notify(...)
745 */
746DWORD WIN32API SHELL32_165(DWORD x,
747 LPCSTR path)
748{
749 dprintf (("SHELL32 .165 (%08x, %08xh) not implemented.\n",
750 x,
751 path));
752
753 if (SHELL32_79(path,
754 (LPVOID)x))
755 return 0;
756
757 return 0;
758}
759
760
761/*************************************************************************
762 * SHELL32_195 [SHELL32.195]
763 * free_ptr() - frees memory using IMalloc
764 */
765DWORD WIN32API SHELL32_195(LPVOID x)
766{
767 dprintf (("SHELL32: .195 (%08xh) (LocalFree)\n",
768 x));
769
770 return (DWORD)LocalFree((HLOCAL)x);
771}
772
773
774/*************************************************************************
775 * SHELL32_196 [SHELL32.196]
776 * void *task_alloc(DWORD len), uses SHMalloc allocator
777 */
778LPVOID WIN32API SHELL32_196(DWORD len)
779{
780 dprintf(("SHELL32: .196 (%08xh) (LocalAlloc)\n",
781 len));
782
783 return (LPVOID)LocalAlloc(len,
784 LMEM_ZEROINIT); /* FIXME */
785}
786
787
788/*************************************************************************
789 * SHELL32_18 [SHELL32.18]
790 * copy_itemidlist()
791 */
792LPITEMIDLIST WIN32API SHELL32_18(LPITEMIDLIST iil)
793{
794 DWORD len;
795 LPITEMIDLIST newiil;
796
797 dprintf(("SHELL32: .18 (%08xh)\n",
798 iil));
799
800
801 len = SHELL32_152(iil);
802 newiil = (LPITEMIDLIST)SHELL32_196(len);
803 memcpy(newiil,
804 iil,
805 len);
806
807 return newiil;
808}
809
810
811/*************************************************************************
812 * SHELL32_25 [SHELL32.25]
813 * merge_itemidlist()
814 */
815LPITEMIDLIST WIN32API SHELL32_25(LPITEMIDLIST iil1,
816 LPITEMIDLIST iil2)
817{
818 DWORD len1,len2;
819 LPITEMIDLIST newiil;
820
821 dprintf(("SHELL32: .25 (%08xh, %08xh)\n",
822 iil1,
823 iil2));
824
825
826 len1 = SHELL32_152(iil1)-2;
827 len2 = SHELL32_152(iil2);
828 newiil = (LPITEMIDLIST)SHELL32_196(len1+len2);
829
830 memcpy(newiil,
831 iil1,
832 len1);
833
834 memcpy(((char*)newiil)+len1,
835 iil2,
836 len2);
837
838 return newiil;
839}
840
841
842/*************************************************************************
843 * SHELL32_155 [SHELL32.155]
844 * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
845 */
846DWORD WIN32API SHELL32_155(LPVOID x)
847{
848 dprintf(("SHELL32: .155 (%08xh)\n",
849 x));
850
851 if (!x)
852 return 0;
853
854 return SHELL32_195(x);
855}
856
857
858/*************************************************************************
859 * SHELL32_85 [SHELL32.85]
860 * unknown
861 */
862DWORD WIN32API SHELL32_85(DWORD x1,
863 DWORD x2,
864 DWORD x3,
865 DWORD x4)
866{
867 dprintf(("SHELL32: .85 (%08x, %08xh, %08xh, %08xh) not implemented.\n",
868 x1,
869 x2,
870 x3,
871 x4));
872
873 return 0;
874}
875
876
877/*****************************************************************************
878 * Name : .4
879 * Purpose :
880 * Parameters:
881 * Variables :
882 * Result :
883 * Remark : unknown
884 * Status : UNTESTED UNKNOWN STUB
885 *
886 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
887 *****************************************************************************/
888
889DWORD WIN32API SHELL32_4(DWORD x1)
890{
891 dprintf(("SHELL32: .4 (%08xh) not implemented.\n",
892 x1));
893
894 return (0);
895}
896
897
898/*****************************************************************************
899 * Name : .59
900 * Purpose :
901 * Parameters:
902 * Variables :
903 * Result :
904 * Remark : unknown
905 * Status : UNTESTED UNKNOWN STUB
906 *
907 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
908 *****************************************************************************/
909
910DWORD WIN32API SHELL32_59(void)
911{
912 dprintf(("SHELL32: .59 () not implemented.\n"));
913
914 return (0);
915}
916
917
918/*****************************************************************************
919 * Name : .162
920 * Purpose :
921 * Parameters:
922 * Variables :
923 * Result :
924 * Remark : unknown
925 * Status : UNTESTED UNKNOWN STUB
926 *
927 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
928 *****************************************************************************/
929
930DWORD WIN32API SHELL32_162(DWORD x1)
931{
932 dprintf(("SHELL32: .162 (%08xh) not implemented.\n",
933 x1));
934
935 return (0);
936}
937
938
939/*****************************************************************************
940 * Name : .145
941 * Purpose :
942 * Parameters:
943 * Variables :
944 * Result :
945 * Remark : unknown
946 * Status : UNTESTED UNKNOWN STUB
947 *
948 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
949 *****************************************************************************/
950
951DWORD WIN32API SHELL32_145(DWORD x1,
952 DWORD x2)
953{
954 dprintf(("SHELL32: .145 (%08xh, %08xh) not implemented.\n",
955 x1,
956 x2));
957
958 return (0);
959}
960
961
962/*****************************************************************************
963 * Name : .43
964 * Purpose :
965 * Parameters:
966 * Variables :
967 * Result :
968 * Remark : unknown
969 * Status : UNTESTED UNKNOWN STUB
970 *
971 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
972 *****************************************************************************/
973
974DWORD WIN32API SHELL32_43(DWORD x1)
975{
976 dprintf(("SHELL32: .43 (%08xh) not implemented.\n",
977 x1));
978
979 return (0);
980}
981
982
983/*****************************************************************************
984 * Name : .51
985 * Purpose :
986 * Parameters:
987 * Variables :
988 * Result :
989 * Remark : unknown
990 * Status : UNTESTED UNKNOWN STUB
991 *
992 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
993 *****************************************************************************/
994
995DWORD WIN32API SHELL32_51(DWORD x1,
996 DWORD x2,
997 DWORD x3)
998{
999 dprintf(("SHELL32: .51 (%08xh, %08xh, %08xh) not implemented.\n",
1000 x1,
1001 x2,
1002 x3));
1003
1004 return (0);
1005}
1006
1007
1008/*****************************************************************************
1009 * Name : .55
1010 * Purpose :
1011 * Parameters:
1012 * Variables :
1013 * Result :
1014 * Remark : unknown
1015 * Status : UNTESTED UNKNOWN STUB
1016 *
1017 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1018 *****************************************************************************/
1019
1020DWORD WIN32API SHELL32_55(DWORD x1)
1021{
1022 dprintf(("SHELL32: .55 (%08xh) not implemented.\n",
1023 x1));
1024
1025 return (0);
1026}
1027
1028
1029/*****************************************************************************
1030 * Name : .102
1031 * Purpose :
1032 * Parameters:
1033 * Variables :
1034 * Result :
1035 * Remark : unknown
1036 * Status : UNTESTED UNKNOWN STUB
1037 *
1038 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1039 *****************************************************************************/
1040
1041DWORD WIN32API SHELL32_102(DWORD x1,
1042 DWORD x2,
1043 DWORD x3,
1044 DWORD x4,
1045 DWORD x5)
1046{
1047 dprintf(("SHELL32: .102 (%08xh, %08xh, %08xh, %08xh, %08xh) not implemented.\n",
1048 x1,
1049 x2,
1050 x3,
1051 x4,
1052 x5));
1053
1054 return (0);
1055}
1056
Note: See TracBrowser for help on using the repository browser.