source: trunk/src/shell32/shell32.cpp@ 77

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

Fix: source splitup
File size: 36.3 KB
Line 
1/* $Id: shell32.cpp,v 1.4 1999-06-09 15:22:27 phaller Exp $ */
2
3/*
4 * Win32 SHELL32 for OS/2
5 *
6 * 1998/06/15 Patrick Haller (haller@zebra.fh-weingarten.de)
7 *
8 * @(#) shell32.c 1.0.0 1998/06/15 PH Merge WINE/SHELLORD.C
9 *
10 *
11 * Copyright 1997 Marcus Meissner
12 * Copyright 1988 Patrick Haller (adapted for win32os2)
13 *
14 * Project Odin Software License can be found in LICENSE.TXT
15 *
16 */
17
18
19/*****************************************************************************
20 * Includes *
21 *****************************************************************************/
22
23#include <os2win.h>
24#include <shellapi.h>
25#include <winreg.h>
26#include "shell32.h"
27
28#include <stdarg.h>
29//#include <builtin.h>
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33
34#include <misc.h>
35#include <nameid.h>
36#include <unicode.h>
37
38
39//static const char* lpstrMsgWndCreated = "OTHERWINDOWCREATED";
40//static const char* lpstrMsgWndDestroyed = "OTHERWINDOWDESTROYED";
41//static const char* lpstrMsgShellActivate = "ACTIVATESHELLWINDOW";
42
43//static HWND SHELL_hWnd = 0;
44//static HHOOK SHELL_hHook = 0;
45//static USHORT uMsgWndCreated = 0;
46//static USHORT uMsgWndDestroyed = 0;
47//static USHORT uMsgShellActivate = 0;
48
49
50
51/*****************************************************************************
52 * Types & Defines *
53 *****************************************************************************/
54
55
56//******************************************************************************
57//******************************************************************************
58HINSTANCE WIN32API ShellExecuteA(HWND hwnd,
59 LPCTSTR lpOperation,
60 LPCTSTR lpFile,
61 LPCTSTR lpParameters,
62 LPCTSTR lpDirectory,
63 INT nShowCmd)
64{
65 dprintf (("SHELL32: ShellExecuteA(%08xh,%s,%s,%s,%s,%08xh) not implemented.\n",
66 hwnd,
67 lpOperation,
68 lpFile,
69 lpParameters,
70 lpDirectory,
71 nShowCmd));
72
73 return(0); //out of memory
74}
75//******************************************************************************
76//TODO: Make nice dialog window
77//******************************************************************************
78int WIN32API ShellAboutA(HWND hwnd,
79 LPCTSTR szApp,
80 LPCTSTR szOtherStuff,
81 HICON hIcon)
82{
83 dprintf(("SHELL32: ShellAboutA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
84 hwnd,
85 szApp,
86 szOtherStuff,
87 hIcon));
88
89 /* @@@PH 98/06/07 */
90 if (szOtherStuff == NULL) szOtherStuff = "";
91 if (szApp == NULL) szApp = "";
92
93 MessageBoxA(NULL,
94 szOtherStuff,
95 szApp,
96 MB_OK); /*PLF Sun 97-11-23 22:58:49*/
97
98 return(TRUE);
99}
100//******************************************************************************
101//******************************************************************************
102int WIN32API ShellAboutW(HWND hwnd,
103 LPCWSTR szApp,
104 LPCWSTR szOtherStuff,
105 HICON hIcon)
106{
107 dprintf(("SHELL32: ShellAboutW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
108 hwnd,
109 szApp,
110 szOtherStuff,
111 hIcon));
112
113 return(TRUE);
114}
115//******************************************************************************
116//Borrowed from Wine
117//******************************************************************************
118LPWSTR * WIN32API CommandLineToArgvW(LPCWSTR lpCmdLine,
119 int *pNumArgs)
120{
121 LPWSTR *argv, s, t;
122 int i;
123
124 dprintf(("SHELL32: CommandLineToArgvW(%s,%08xh)\n",
125 lpCmdLine,
126 pNumArgs));
127
128 s = (LPWSTR)lpCmdLine;
129 i = 0;
130 while (*s) {
131 /* space */
132 if (*s==0x0020) {
133 i++;
134 s++;
135 while (*s && *s==0x0020)
136 s++;
137 continue;
138 }
139 s++;
140 }
141 argv = (LPWSTR *)LocalAlloc(LPTR, sizeof(LPWSTR)*(i+1));
142 s = t = (LPWSTR)lpCmdLine;
143 i = 0;
144 while(*s) {
145 if (*s==0x0020) {
146 *s=0;
147 argv[i++] = t;
148 *s=0x0020;
149 while (*s && *s==0x0020)
150 s++;
151 if(*s)
152 t=s+1;
153 else t=s;
154 continue;
155 }
156 s++;
157 }
158 if(*t)
159 argv[i++] = t;
160
161 argv[i]=NULL;
162 *pNumArgs = i;
163 return argv;
164}
165//******************************************************************************
166//******************************************************************************
167HICON WIN32API ExtractIconA(HINSTANCE hInst,
168 LPCSTR lpszExeFileName,
169 UINT nIconIndex)
170{
171 dprintf(("SHELL32: ExtractIconA(%08xh,%s,%08xh) not implemented.\n",
172 hInst,
173 lpszExeFileName,
174 nIconIndex));
175
176 return(NULL);
177}
178//******************************************************************************
179//******************************************************************************
180HICON WIN32API ExtractIconW(HINSTANCE hInst,
181 LPCWSTR lpszExeFileName,
182 UINT nIconIndex)
183{
184 HICON hicon = NULL;
185 char *astring = UnicodeToAsciiString((LPWSTR)lpszExeFileName);
186
187 dprintf(("SHELL32: ExtractIconW(%08xh,%s,%08xh) not implemented.\n",
188 hInst,
189 lpszExeFileName,
190 nIconIndex));
191
192
193 FreeAsciiString(astring);
194 return(hicon);
195}
196/*****************************************************************************
197 * Name : UINT WIN32API ExtractIconExA
198 * Purpose :
199 * Parameters:
200 * Variables :
201 * Result :
202 * Remark :
203 * Status : UNTESTED STUB
204 *
205 * Author : Patrick Haller [Sat, 1998/07/11 11:55]
206 *****************************************************************************/
207
208DWORD WIN32API ExtractIconExA(LPCSTR lpszFile,
209 int nIconIndex,
210 HICON *phiconLarge,
211 HICON *phiconSmall,
212 UINT nIcons)
213{
214 dprintf(("SHELL32: ExtractIconExA(%s,%08xh,%08xh,%08xh,%u) not implemented.\n",
215 lpszFile,
216 nIconIndex,
217 phiconLarge,
218 phiconSmall,
219 nIcons));
220
221 return (0);
222}
223
224
225/*****************************************************************************
226 * Name : UINT WIN32API ExtractIconExW
227 * Purpose :
228 * Parameters:
229 * Variables :
230 * Result :
231 * Remark :
232 * Status : UNTESTED STUB
233 *
234 * Author : Patrick Haller [Sat, 1998/07/11 11:55]
235 *****************************************************************************/
236
237DWORD WIN32API ExtractIconExW(LPCWSTR lpszFile,
238 int nIconIndex,
239 HICON *phiconLarge,
240 HICON *phiconSmall,
241 UINT nIcons)
242{
243 dprintf(("SHELL32: ExtractIconExW(%s,%08xh,%08xh,%08xh,%u) not implemented.\n",
244 lpszFile,
245 nIconIndex,
246 phiconLarge,
247 phiconSmall,
248 nIcons));
249
250 return (0);
251}
252
253
254//******************************************************************************
255HINSTANCE WIN32API FindExecutableA(LPCSTR lpszFile,
256 LPCSTR lpszDir,
257 LPTSTR lpszResult)
258{
259 dprintf(("SHELL32: FindExecutableA (%s,%s,%s) not implemented.\n",
260 lpszFile,
261 lpszDir,
262 lpszResult));
263
264 return(NULL);
265}
266//******************************************************************************
267//******************************************************************************
268HINSTANCE WIN32API FindExecutableW(LPCWSTR lpszFile,
269 LPCWSTR lpszDir,
270 LPWSTR lpszResult)
271{
272 dprintf(("SHELL32: FindExecutableW (%s,%s,%s) not implemented.\n",
273 lpszFile,
274 lpszDir,
275 lpszResult));
276
277 return(NULL);
278}
279//******************************************************************************
280
281
282/*************************************************************************
283 * Shell_NotifyIcon [SHELL32.240]
284 * FIXME
285 * This function is supposed to deal with the systray.
286 * Any ideas on how this is to be implimented?
287 */
288BOOL WIN32API Shell_NotifyIconA(DWORD dwMessage,
289 PNOTIFYICONDATAA pnid )
290{
291 dprintf(("SHELL32: Shell_NotifyIconA(%08xh,%08xh) not implemented.\n",
292 dwMessage,
293 pnid));
294
295 return FALSE;
296}
297
298
299/*************************************************************************
300 * Shell_NotifyIcon [SHELL32.240]
301 * FIXME
302 * This function is supposed to deal with the systray.
303 * Any ideas on how this is to be implimented?
304 */
305BOOL WIN32API Shell_NotifyIconW(DWORD dwMessage,
306 PNOTIFYICONDATAW pnid )
307{
308 dprintf(("SHELL32: Shell_NotifyIconW(%08xh,%08xh) not implemented.\n",
309 dwMessage,
310 pnid));
311
312 return FALSE;
313}
314
315
316/*****************************************************************************
317 *
318 * Code merged from WINE
319 *
320 * Patrick Haller 98/06/15
321 *
322 *****************************************************************************/
323
324
325/*************************************************************************
326 * SHELL32_2 [SHELL32.2]
327 */
328DWORD WIN32API SHELL32_2(HWND hwnd,
329 DWORD x2,
330 DWORD x3,
331 DWORD x4,
332 DWORD x5,
333 DWORD x6)
334{
335 dprintf(("SHELL32: .2 (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx) not implemented.\n",
336 hwnd,
337 x2,
338 x3,
339 x4,
340 x5,
341 x6));
342 return 0;
343}
344
345
346/*************************************************************************
347 * SHELL32_16 [SHELL32.16]
348 * find_lastitem_in_itemidlist()
349 */
350LPSHITEMID WIN32API SHELL32_16(LPITEMIDLIST iil)
351{
352 LPSHITEMID lastsii,
353 sii;
354
355 dprintf(("SHELL32: .16 (%08xh)\n",
356 iil));
357
358 if (!iil)
359 return NULL;
360
361 sii = &(iil->mkid);
362 lastsii = sii;
363
364 while (sii->cb)
365 {
366 lastsii = sii;
367 sii = (LPSHITEMID)(((char*)sii)+sii->cb);
368 }
369
370 return lastsii;
371}
372
373
374/*************************************************************************
375 * SHELL32_29 [SHELL32.29]
376 * is_rootdir(const char*path)
377 */
378BOOL WIN32API SHELL32_29(LPCSTR x)
379{
380 dprintf(("SHELL32: .29 (%s)\n",
381 x));
382
383
384 if (!lstrcmpA(x+1,":\\")) /* "X:\" */
385 return 1;
386
387 if (!lstrcmpA(x,"\\")) /* "\" */
388 return 1;
389
390 if (x[0]=='\\' && x[1]=='\\')
391 { /* UNC "\\<xx>\" */
392 int foundbackslash = 0;
393
394 x=x+2;
395 while (*x)
396 {
397 if (*x++=='\\')
398 foundbackslash++;
399 }
400
401 if (foundbackslash<=1) /* max 1 \ more ... */
402 return 1;
403 }
404 return 0;
405}
406
407
408/*************************************************************************
409 * SHELL32_30 [SHELL32.30]
410 * get_rootdir(char*path,int drive)
411 */
412LPSTR WIN32API SHELL32_30(LPSTR root,
413 BYTE drive)
414{
415 dprintf(("SHELL32: .30 (%s, %u)\n",
416 root,
417 drive));
418
419
420 strcpy(root,
421 "A:\\");
422 root[0]+=drive;
423
424 return root;
425}
426
427
428/*************************************************************************
429 * SHELL32_31 [SHELL32.31]
430 * returns pointer to last . in last pathcomponent or at \0.
431 */
432LPSTR WIN32API SHELL32_31(LPSTR path)
433{
434 LPSTR lastpoint = NULL;
435
436 dprintf(("SHELL32: .31 (%s)\n",
437 path));
438
439
440 while (*path)
441 {
442 if (*path=='\\'||*path==' ')
443 lastpoint=NULL;
444
445 if (*path=='.')
446 lastpoint=path;
447
448 path++;
449 }
450
451 return lastpoint ? lastpoint : path;
452}
453
454
455/*************************************************************************
456 * SHELL32_32 [SHELL32.32]
457 * append \ if there is none
458 */
459LPSTR WIN32API SHELL32_32(LPSTR path)
460{
461 int len;
462
463 dprintf(("SHELL32: .31 (%s)\n",
464 path));
465
466
467 len = lstrlenA(path);
468
469 if (len && path[len-1]!='\\')
470 {
471 path[len+0]='\\';
472 path[len+1]='\0';
473 return path+len+1;
474 }
475 else
476 return path+len;
477}
478
479
480/*************************************************************************
481 * SHELL32_33 [SHELL32.33]
482 * remove spaces from beginning and end of passed string
483 */
484LPSTR WIN32API SHELL32_33(LPSTR str)
485{
486 LPSTR x = str;
487
488 dprintf(("SHELL32: .33 (%s)\n",
489 str));
490
491
492 while (*x==' ')
493 x++;
494
495 if (x!=str)
496 lstrcpyA(str,
497 x);
498
499 if (!*str)
500 return str;
501
502 x=str+strlen(str)-1;
503
504 while (*x==' ')
505 x--;
506
507 if (*x==' ')
508 *x='\0';
509
510 return x;
511}
512
513
514/*************************************************************************
515 * SHELL32_34 [SHELL32.34]
516 * basename(char *fn);
517 */
518LPSTR WIN32API SHELL32_34(LPSTR fn)
519{
520 LPSTR basefn;
521
522 dprintf(("SHELL32: .34 (%s)\n",
523 fn));
524
525
526 basefn = fn;
527 while (fn[0])
528 {
529 if (( (fn[0]=='\\') ||
530 (fn[0]==':')) && fn[1] && fn[1]!='\\')
531 basefn = fn+1;
532
533 fn++;
534 }
535
536 return basefn;
537}
538
539/*************************************************************************
540 * SHELL32_35 [SHELL32.35]
541 * bool getpath(char *pathname); truncates passed argument to a valid path
542 * returns if the string was modified or not.
543 * "\foo\xx\foo"-> "\foo\xx"
544 * "\" -> "\"
545 * "a:\foo" -> "a:\"
546 */
547DWORD WIN32API SHELL32_35(LPSTR fn)
548{
549 LPSTR x,cutplace;
550
551 dprintf(("SHELL32: .35 (%s)\n",
552 fn));
553
554
555 if (!fn[0])
556 return 0;
557 x=fn;
558 cutplace = fn;
559 while (*x) {
560 if (*x=='\\') {
561 cutplace=x++;
562 continue;
563 }
564 if (*x==':') {
565 x++;
566 if (*x=='\\')
567 cutplace=++x;
568 continue; /* already x++ed */
569 }
570 x++;
571 }
572 if (!*cutplace)
573 return 0;
574 if (cutplace==fn) {
575 if (fn[0]=='\\') {
576 if (!fn[1])
577 return 0;
578 fn[0]='\0';
579 return 1;
580 }
581 }
582 *cutplace='\0';
583 return 1;
584}
585
586/*************************************************************************
587 * SHELL32_37 [SHELL32.37]
588 * concat_paths(char*target,const char*add);
589 * concats "target\\add" and writes them to target
590 */
591LPSTR WIN32API SHELL32_37(LPSTR target,
592 LPSTR x1,
593 LPSTR x2)
594{
595 char buf[260];
596
597 dprintf(("SHELL32: .37 (%s, %s, %s)\n",
598 target,
599 x1,
600 x2));
601
602
603 if (!x2 || !x2[0])
604 {
605 lstrcpyA(target,x1);
606
607 return target;
608 }
609
610 lstrcpyA(buf,x1);
611 SHELL32_32(buf); /* append \ if not there */
612 lstrcatA(buf,x2);
613 lstrcpyA(target,buf);
614
615 return target;
616}
617
618/*************************************************************************
619 * SHELL32_36 [SHELL32.36]
620 * concat_paths(char*target,const char*add);
621 * concats "target\\add" and writes them to target
622 */
623LPSTR WIN32API SHELL32_36(LPSTR x1,
624 LPSTR x2)
625{
626 dprintf(("SHELL32: .36 (%s, %s)\n",
627 x1,
628 x2));
629
630
631 while (x2[0]=='\\')
632 x2++;
633
634 return SHELL32_37(x1,
635 x1,
636 x2);
637}
638
639/*************************************************************************
640 * SHELL32_39 [SHELL32.39]
641 * isUNC(const char*path);
642 */
643BOOL WIN32API SHELL32_39(LPCSTR path)
644{
645 dprintf (("SHELL32: .39 (%s)\n",
646 path));
647
648
649 if ((path[0]=='\\') &&
650 (path[1]=='\\'))
651 return TRUE;
652
653 return FALSE;
654}
655
656
657/*************************************************************************
658 * SHELL32_45 [SHELL32.45]
659 * file_exists(char *fn);
660 */
661BOOL WIN32API SHELL32_45(LPSTR fn)
662{
663 dprintf(("SHELL32: .45 (%s)\n",
664 fn));
665
666
667 if (GetFileAttributesA(fn)==-1)
668 return FALSE;
669 else
670 return TRUE;
671}
672
673/*************************************************************************
674 * SHELL32_52 [SHELL32.52]
675 * look for next arg in string. handle "quoted" strings
676 * returns pointer to argument *AFTER* the space. Or to the \0.
677 */
678LPSTR WIN32API SHELL32_52(LPSTR cmdline)
679{
680 BOOL qflag = FALSE;
681
682 dprintf (("SHELL32: .52 (%s)\n",
683 cmdline));
684
685
686 while (*cmdline)
687 {
688 if ((*cmdline==' ') && !qflag)
689 return cmdline+1;
690
691 if (*cmdline=='"')
692 qflag=!qflag;
693
694 cmdline++;
695 }
696 return cmdline;
697}
698
699
700/*************************************************************************
701 * SHELL32_56 [SHELL32.56]
702 * unquote string (remove ")
703 */
704VOID WIN32API SHELL32_56(LPSTR str)
705{
706 DWORD len = lstrlenA(str);
707
708 dprintf (("SHELL32: .56 (%s)\n",
709 str));
710
711
712 if (*str!='"')
713 return;
714
715 if (str[len-1]!='"')
716 return;
717
718 str[len-1]='\0';
719 lstrcpyA(str,
720 str+1);
721 return;
722}
723
724
725/*************************************************************************
726 * SHELL32_58 [SHELL32.58]
727 */
728DWORD WIN32API SHELL32_58(LPCSTR src,
729 DWORD x2,
730 LPSTR target,
731 DWORD pathlen)
732{
733 dprintf (("SHELL32: .58 (%s, %08xh, %08xh, %08xh) not implemented\n",
734 src,
735 x2,
736 target,
737 pathlen));
738
739 return 0;
740}
741
742
743/*************************************************************************
744 * SHELL32_62 [SHELL32.62]
745 */
746DWORD WIN32API SHELL32_62(DWORD x,
747 DWORD y,
748 DWORD z,
749 DWORD a)
750{
751 dprintf(("SHELL32: .62 (%08xh, %08xh, %08xh, %08xh) not implemented.\n",
752 x,
753 y,
754 z,
755 a));
756
757 return 0xffffffff;
758}
759
760
761/*************************************************************************
762 * SHELL32_63 [SHELL32.63]
763 */
764DWORD WIN32API SHELL32_63(HWND howner,
765 LPSTR targetbuf,
766 DWORD len,
767 DWORD x,
768 LPCSTR suffix,
769 LPCSTR y,
770 LPCSTR cmd)
771{
772 dprintf (("SHELL32: .63 (%08xh, %08x, %08xh, %08xh, %08xh, %08xh, %s) not implemented.\n",
773 howner,
774 targetbuf,
775 len,
776 x,
777 suffix,
778 y,
779 cmd));
780
781 /* puts up a Open Dialog and requests input into targetbuf */
782 /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
783 lstrcpyA(targetbuf,"x:\\s3.exe");
784 return 1;
785}
786
787
788/*************************************************************************
789 * SHELL32_68 [SHELL32.68]
790 */
791DWORD WIN32API SHELL32_68(DWORD x,
792 DWORD y,
793 DWORD z)
794{
795 dprintf(("SHELL32: .68 (%08xh, %08xh, %08xh) not implemented.\n",
796 x,
797 y,
798 z));
799
800 return 0;
801}
802
803
804/*************************************************************************
805 * SHELL32_71 [SHELL32.71]
806 * returns internal shell values in the passed pointers
807 */
808BOOL WIN32API SHELL32_71(LPDWORD x,
809 LPDWORD y)
810{
811 dprintf(("SHELL32: .71 (%08xh, %08xh) not implemented.\n",
812 x,
813 y));
814
815 return TRUE;
816}
817
818
819/*************************************************************************
820 * SHELL32_72 [SHELL32.72]
821 * dunno. something with icons
822 */
823void WIN32API SHELL32_72(LPSTR x,
824 DWORD y,
825 DWORD z)
826{
827 dprintf (("SHELL32: .27 (%08xh, %08xh, %08xh) not implemented.\n",
828 x,
829 y,
830 z));
831}
832
833
834/*************************************************************************
835 * SHELL32_89 [SHELL32.89]
836 */
837DWORD WIN32API SHELL32_89(DWORD x1,
838 DWORD x2,
839 DWORD x3)
840{
841 dprintf(("SHELL32: .89 (%08xh, %08xh, %08xh) not implemented.\n",
842 x1,
843 x2,
844 x3));
845
846 return 0;
847}
848
849
850/*************************************************************************
851 * SHELL32_119 [SHELL32.119]
852 * unknown
853 */
854void WIN32API SHELL32_119(LPVOID x)
855{
856 dprintf(("SHELL32: .119 (%08xh) not implemented.\n",
857 x));
858}
859
860
861/*************************************************************************
862 * SHELL32_175 [SHELL32.175]
863 * unknown
864 */
865void WIN32API SHELL32_175(DWORD x1,
866 DWORD x2,
867 DWORD x3,
868 DWORD x4)
869{
870 dprintf (("SHELL32: .175 (%08x, %08xh, %08xh, %08xh not implemented.\n",
871 x1,
872 x2,
873 x3,
874 x4));
875}
876
877
878/*************************************************************************
879 * SHELL32_181 [SHELL32.181]
880 * unknown
881 */
882void WIN32API SHELL32_181(DWORD x,
883 DWORD y)
884{
885 dprintf(("SHELL32: .181 (%08xh, %08xh) not implemented.\n",
886 x,
887 y));
888}
889
890
891/*************************************************************************
892 * SHELL32_75 [SHELL32.75]
893 * unknown
894 */
895BOOL WIN32API SHELL32_75(LPDWORD x,
896 LPDWORD y)
897{
898 dprintf(("SHELL32: .75 (%08xh, %08xh) not implemented.\n",
899 x,
900 y));
901
902 return TRUE;
903}
904
905
906/*************************************************************************
907 * SHELL32_77 [SHELL32.77]
908 */
909DWORD WIN32API SHELL32_77(DWORD x,
910 DWORD y,
911 DWORD z)
912{
913 dprintf(("SHELL32: .77 (%08xh, %08xh, %08xh) not implemented.\n",
914 x,
915 y,
916 z));
917
918 return 0;
919}
920
921
922/*************************************************************************
923 * SHELL32_79 [SHELL32.79]
924 * create_directory_and_notify(...)
925 */
926DWORD WIN32API SHELL32_79(LPCSTR dir,
927 LPVOID xvoid)
928{
929 dprintf(("SHELL32: .79 (%s, %08xh)\n",
930 dir,
931 xvoid));
932
933 if (!CreateDirectoryA(dir,
934 (PSECURITY_ATTRIBUTES)xvoid))
935 return FALSE;
936
937 /* @@@PH: SHChangeNotify(8,1,dir,0); */
938 return TRUE;
939}
940
941
942/*************************************************************************
943 * SHELL32_100 [SHELL32.100]
944 * walks through policy table, queries <app> key, <type> value, returns
945 * queried (DWORD) value.
946 * {0x00001,Explorer,NoRun}
947 * {0x00002,Explorer,NoClose}
948 * {0x00004,Explorer,NoSaveSettings}
949 * {0x00008,Explorer,NoFileMenu}
950 * {0x00010,Explorer,NoSetFolders}
951 * {0x00020,Explorer,NoSetTaskbar}
952 * {0x00040,Explorer,NoDesktop}
953 * {0x00080,Explorer,NoFind}
954 * {0x00100,Explorer,NoDrives}
955 * {0x00200,Explorer,NoDriveAutoRun}
956 * {0x00400,Explorer,NoDriveTypeAutoRun}
957 * {0x00800,Explorer,NoNetHood}
958 * {0x01000,Explorer,NoStartBanner}
959 * {0x02000,Explorer,RestrictRun}
960 * {0x04000,Explorer,NoPrinterTabs}
961 * {0x08000,Explorer,NoDeletePrinter}
962 * {0x10000,Explorer,NoAddPrinter}
963 * {0x20000,Explorer,NoStartMenuSubFolders}
964 * {0x40000,Explorer,MyDocsOnNet}
965 * {0x80000,WinOldApp,NoRealMode}
966 */
967DWORD WIN32API SHELL32_100(DWORD pol)
968{
969 HKEY xhkey;
970
971 dprintf (("SHELL32: .100 (%08xh) not implemented.\n",
972 pol));
973
974 if (RegOpenKeyA((HKEY)HKEY_CURRENT_USER,
975 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
976 &xhkey))
977 return 0;
978
979 /* FIXME: do nothing for now, just return 0 (== "allowed") */
980 RegCloseKey(xhkey);
981
982 return 0;
983}
984
985
986/*************************************************************************
987 * SHELL32_152 [SHELL32.152]
988 * itemlist_length
989 */
990DWORD WIN32API SHELL32_152(LPITEMIDLIST iil)
991{
992 LPSHITEMID si;
993 DWORD len;
994
995 dprintf(("SHELL32: .152 (%08xh)\n",
996 iil));
997
998
999 si = &(iil->mkid);
1000 len = 2;
1001
1002 while (si->cb)
1003 {
1004 len += si->cb;
1005 si = (LPSHITEMID)(((char*)si)+si->cb);
1006 }
1007
1008 return len;
1009}
1010
1011
1012/*************************************************************************
1013 * SHELL32_158 [SHELL32.158]
1014 */
1015LPSTR WIN32API SHELL32_158(LPSTR path,
1016 DWORD y,
1017 DWORD z)
1018{
1019 dprintf(("SHELL32: .158 (%s, %08xh, %08xh)\n",
1020 path,
1021 y,
1022 z));
1023
1024 path = SHELL32_31(path);
1025
1026 return *path ? (path+1) : path;
1027}
1028
1029
1030/*************************************************************************
1031 * SHELL32_165 [SHELL32.165]
1032 * create_path_and_notify(...)
1033 */
1034DWORD WIN32API SHELL32_165(DWORD x,
1035 LPCSTR path)
1036{
1037 dprintf (("SHELL32 .165 (%08x, %08xh) not implemented.\n",
1038 x,
1039 path));
1040
1041 if (SHELL32_79(path,
1042 (LPVOID)x))
1043 return 0;
1044
1045 return 0;
1046}
1047
1048
1049/*************************************************************************
1050 * SHELL32_195 [SHELL32.195]
1051 * free_ptr() - frees memory using IMalloc
1052 */
1053DWORD WIN32API SHELL32_195(LPVOID x)
1054{
1055 dprintf (("SHELL32: .195 (%08xh) (LocalFree)\n",
1056 x));
1057
1058 return (DWORD)LocalFree((HLOCAL)x);
1059}
1060
1061
1062/*************************************************************************
1063 * SHELL32_196 [SHELL32.196]
1064 * void *task_alloc(DWORD len), uses SHMalloc allocator
1065 */
1066LPVOID WIN32API SHELL32_196(DWORD len)
1067{
1068 dprintf(("SHELL32: .196 (%08xh) (LocalAlloc)\n",
1069 len));
1070
1071 return (LPVOID)LocalAlloc(len,
1072 LMEM_ZEROINIT); /* FIXME */
1073}
1074
1075
1076/*************************************************************************
1077 * SHELL32_18 [SHELL32.18]
1078 * copy_itemidlist()
1079 */
1080LPITEMIDLIST WIN32API SHELL32_18(LPITEMIDLIST iil)
1081{
1082 DWORD len;
1083 LPITEMIDLIST newiil;
1084
1085 dprintf(("SHELL32: .18 (%08xh)\n",
1086 iil));
1087
1088
1089 len = SHELL32_152(iil);
1090 newiil = (LPITEMIDLIST)SHELL32_196(len);
1091 memcpy(newiil,
1092 iil,
1093 len);
1094
1095 return newiil;
1096}
1097
1098
1099/*************************************************************************
1100 * SHELL32_25 [SHELL32.25]
1101 * merge_itemidlist()
1102 */
1103LPITEMIDLIST WIN32API SHELL32_25(LPITEMIDLIST iil1,
1104 LPITEMIDLIST iil2)
1105{
1106 DWORD len1,len2;
1107 LPITEMIDLIST newiil;
1108
1109 dprintf(("SHELL32: .25 (%08xh, %08xh)\n",
1110 iil1,
1111 iil2));
1112
1113
1114 len1 = SHELL32_152(iil1)-2;
1115 len2 = SHELL32_152(iil2);
1116 newiil = (LPITEMIDLIST)SHELL32_196(len1+len2);
1117
1118 memcpy(newiil,
1119 iil1,
1120 len1);
1121
1122 memcpy(((char*)newiil)+len1,
1123 iil2,
1124 len2);
1125
1126 return newiil;
1127}
1128
1129
1130/*************************************************************************
1131 * SHELL32_155 [SHELL32.155]
1132 * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
1133 */
1134DWORD WIN32API SHELL32_155(LPVOID x)
1135{
1136 dprintf(("SHELL32: .155 (%08xh)\n",
1137 x));
1138
1139 if (!x)
1140 return 0;
1141
1142 return SHELL32_195(x);
1143}
1144
1145
1146/*************************************************************************
1147 * SHELL32_85 [SHELL32.85]
1148 * unknown
1149 */
1150DWORD WIN32API SHELL32_85(DWORD x1,
1151 DWORD x2,
1152 DWORD x3,
1153 DWORD x4)
1154{
1155 dprintf(("SHELL32: .85 (%08x, %08xh, %08xh, %08xh) not implemented.\n",
1156 x1,
1157 x2,
1158 x3,
1159 x4));
1160
1161 return 0;
1162}
1163
1164
1165/*****************************************************************************
1166 * Name : .4
1167 * Purpose :
1168 * Parameters:
1169 * Variables :
1170 * Result :
1171 * Remark : unknown
1172 * Status : UNTESTED UNKNOWN STUB
1173 *
1174 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1175 *****************************************************************************/
1176
1177DWORD WIN32API SHELL32_4(DWORD x1)
1178{
1179 dprintf(("SHELL32: .4 (%08xh) not implemented.\n",
1180 x1));
1181
1182 return (0);
1183}
1184
1185
1186/*****************************************************************************
1187 * Name : .59
1188 * Purpose :
1189 * Parameters:
1190 * Variables :
1191 * Result :
1192 * Remark : unknown
1193 * Status : UNTESTED UNKNOWN STUB
1194 *
1195 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1196 *****************************************************************************/
1197
1198DWORD WIN32API SHELL32_59(void)
1199{
1200 dprintf(("SHELL32: .59 () not implemented.\n"));
1201
1202 return (0);
1203}
1204
1205
1206/*****************************************************************************
1207 * Name : .162
1208 * Purpose :
1209 * Parameters:
1210 * Variables :
1211 * Result :
1212 * Remark : unknown
1213 * Status : UNTESTED UNKNOWN STUB
1214 *
1215 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1216 *****************************************************************************/
1217
1218DWORD WIN32API SHELL32_162(DWORD x1)
1219{
1220 dprintf(("SHELL32: .162 (%08xh) not implemented.\n",
1221 x1));
1222
1223 return (0);
1224}
1225
1226
1227/*****************************************************************************
1228 * Name : .145
1229 * Purpose :
1230 * Parameters:
1231 * Variables :
1232 * Result :
1233 * Remark : unknown
1234 * Status : UNTESTED UNKNOWN STUB
1235 *
1236 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1237 *****************************************************************************/
1238
1239DWORD WIN32API SHELL32_145(DWORD x1,
1240 DWORD x2)
1241{
1242 dprintf(("SHELL32: .145 (%08xh, %08xh) not implemented.\n",
1243 x1,
1244 x2));
1245
1246 return (0);
1247}
1248
1249
1250/*****************************************************************************
1251 * Name : .43
1252 * Purpose :
1253 * Parameters:
1254 * Variables :
1255 * Result :
1256 * Remark : unknown
1257 * Status : UNTESTED UNKNOWN STUB
1258 *
1259 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1260 *****************************************************************************/
1261
1262DWORD WIN32API SHELL32_43(DWORD x1)
1263{
1264 dprintf(("SHELL32: .43 (%08xh) not implemented.\n",
1265 x1));
1266
1267 return (0);
1268}
1269
1270
1271/*****************************************************************************
1272 * Name : .51
1273 * Purpose :
1274 * Parameters:
1275 * Variables :
1276 * Result :
1277 * Remark : unknown
1278 * Status : UNTESTED UNKNOWN STUB
1279 *
1280 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1281 *****************************************************************************/
1282
1283DWORD WIN32API SHELL32_51(DWORD x1,
1284 DWORD x2,
1285 DWORD x3)
1286{
1287 dprintf(("SHELL32: .51 (%08xh, %08xh, %08xh) not implemented.\n",
1288 x1,
1289 x2,
1290 x3));
1291
1292 return (0);
1293}
1294
1295
1296/*****************************************************************************
1297 * Name : .55
1298 * Purpose :
1299 * Parameters:
1300 * Variables :
1301 * Result :
1302 * Remark : unknown
1303 * Status : UNTESTED UNKNOWN STUB
1304 *
1305 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1306 *****************************************************************************/
1307
1308DWORD WIN32API SHELL32_55(DWORD x1)
1309{
1310 dprintf(("SHELL32: .55 (%08xh) not implemented.\n",
1311 x1));
1312
1313 return (0);
1314}
1315
1316
1317/*****************************************************************************
1318 * Name : .102
1319 * Purpose :
1320 * Parameters:
1321 * Variables :
1322 * Result :
1323 * Remark : unknown
1324 * Status : UNTESTED UNKNOWN STUB
1325 *
1326 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1327 *****************************************************************************/
1328
1329DWORD WIN32API SHELL32_102(DWORD x1,
1330 DWORD x2,
1331 DWORD x3,
1332 DWORD x4,
1333 DWORD x5)
1334{
1335 dprintf(("SHELL32: .102 (%08xh, %08xh, %08xh, %08xh, %08xh) not implemented.\n",
1336 x1,
1337 x2,
1338 x3,
1339 x4,
1340 x5));
1341
1342 return (0);
1343}
1344
1345
1346/*****************************************************************************
1347 * Name : BOOL ShellExecuteEx
1348 * Purpose :
1349 * Parameters:
1350 * Variables :
1351 * Result :
1352 * Remark :
1353 * Status : UNTESTED STUB
1354 *
1355 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1356 *****************************************************************************/
1357
1358BOOL WIN32API ShellExecuteEx(LPSHELLEXECUTEINFOA lpExecInfo)
1359{
1360 dprintf(("SHELL32: ShellExecuteEx (%08xh) not implemented.\n",
1361 lpExecInfo));
1362
1363 return (0);
1364}
1365
1366
1367
1368/*****************************************************************************
1369 * Name : BOOL ShellExecuteExA
1370 * Purpose :
1371 * Parameters:
1372 * Variables :
1373 * Result :
1374 * Remark :
1375 * Status : UNTESTED STUB
1376 *
1377 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1378 *****************************************************************************/
1379
1380BOOL WIN32API ShellExecuteExA(LPSHELLEXECUTEINFOA lpExecInfo)
1381{
1382 dprintf(("SHELL32: ShellExecuteExA (%08xh) not implemented.\n",
1383 lpExecInfo));
1384
1385 return (0);
1386}
1387
1388
1389/*****************************************************************************
1390 * Name : BOOL ShellExecuteExW
1391 * Purpose :
1392 * Parameters:
1393 * Variables :
1394 * Result :
1395 * Remark :
1396 * Status : UNTESTED STUB
1397 *
1398 * Author : Patrick Haller [Tue, 1998/06/15 03:00]
1399 *****************************************************************************/
1400
1401BOOL WIN32API ShellExecuteExW(LPSHELLEXECUTEINFOW lpExecInfo)
1402{
1403 dprintf(("SHELL32: ShellExecuteExW (%08xh) not implemented.\n",
1404 lpExecInfo));
1405
1406 return (0);
1407}
1408
1409
1410/*****************************************************************************
1411 * Name : DWORD ShellMessageBoxW
1412 * Purpose : display a messagebox, retrieve message text from resources
1413 * Parameters: HMODULE hmod
1414 * HWND hwnd
1415 * DWORD idText
1416 * DWORD idTitle
1417 * DWORD uType
1418 * LPCVOID arglist
1419 * Variables :
1420 * Result :
1421 * Remark : SHELL32.182
1422 * Status : UNTESTED STUB
1423 *
1424 * Author : Patrick Haller [Tue, 1999/06/01 09:00]
1425 *****************************************************************************/
1426
1427DWORD WIN32API ShellMessageBoxW(HMODULE hmod,
1428 HWND hwnd,
1429 DWORD idText,
1430 DWORD idTitle,
1431 DWORD uType,
1432 LPCVOID arglist)
1433{
1434 WCHAR szText[100],
1435 szTitle[100],
1436 szTemp[256];
1437 LPWSTR pszText = &szText[0],
1438 pszTitle = &szTitle[0];
1439 LPVOID args = &arglist;
1440
1441 dprintf(("SHELL32: ShellMessageBoxW(%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",
1442 hmod,
1443 hwnd,
1444 idText,
1445 idTitle,
1446 uType,
1447 arglist));
1448
1449 if (!HIWORD (idTitle))
1450 LoadStringW(hmod,
1451 idTitle,
1452 pszTitle,
1453 100);
1454 else
1455 pszTitle = (LPWSTR)idTitle;
1456
1457 if (! HIWORD (idText))
1458 LoadStringW(hmod,idText,pszText,100);
1459 else
1460 pszText = (LPWSTR)idText;
1461
1462 FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1463 szText,
1464 0,
1465 0,
1466 szTemp,
1467 256,
1468 (LPDWORD)args);
1469
1470 return MessageBoxW(hwnd,
1471 szTemp,
1472 szTitle,
1473 uType);
1474}
1475
1476/*****************************************************************************
1477 * Name : DWORD ShellMessageBoxA
1478 * Purpose : display a messagebox, retrieve message text from resources
1479 * Parameters: HMODULE hmod
1480 * HWND hwnd
1481 * DWORD idText
1482 * DWORD idTitle
1483 * DWORD uType
1484 * LPCVOID arglist
1485 * Variables :
1486 * Result :
1487 * Remark : SHELL32.183
1488 * Status : UNTESTED STUB
1489 *
1490 * Author : Patrick Haller [Tue, 1999/06/01 09:00]
1491 *****************************************************************************/
1492
1493DWORD WIN32API ShellMessageBoxA(HMODULE hmod,
1494 HWND hwnd,
1495 DWORD idText,
1496 DWORD idTitle,
1497 DWORD uType,
1498 LPCVOID arglist)
1499{
1500 char szText[100],
1501 szTitle[100],
1502 szTemp[256];
1503 LPSTR pszText = &szText[0],
1504 pszTitle = &szTitle[0];
1505 LPVOID args = &arglist;
1506
1507 dprintf(("SHELL32: ShellMessageBoxA (%08lx,%08lx,%08lx,%08lx,%08lx,%p)\n",
1508 hmod,
1509 hwnd,
1510 idText,
1511 idTitle,
1512 uType,
1513 arglist));
1514
1515 if (!HIWORD (idTitle))
1516 LoadStringA(hmod,idTitle,pszTitle,100);
1517 else
1518 pszTitle = (LPSTR)idTitle;
1519
1520 if (! HIWORD (idText))
1521 LoadStringA(hmod,idText,pszText,100);
1522 else
1523 pszText = (LPSTR)idText;
1524
1525 FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1526 pszText,
1527 0,
1528 0,
1529 szTemp,
1530 256,
1531 (LPDWORD)args);
1532
1533 return MessageBoxA(hwnd,
1534 szTemp,
1535 pszTitle,
1536 uType);
1537}
1538
1539
Note: See TracBrowser for help on using the repository browser.