2 * Shell Library Functions
18 #include "cursoricon.h"
24 /* .ICO file ICONDIR definitions */
30 BYTE bWidth
; /* Width, in pixels, of the image */
31 BYTE bHeight
; /* Height, in pixels, of the image */
32 BYTE bColorCount
; /* Number of colors in image (0 if >=8bpp) */
33 BYTE bReserved
; /* Reserved ( must be 0) */
34 WORD wPlanes
; /* Color Planes */
35 WORD wBitCount
; /* Bits per pixel */
36 DWORD dwBytesInRes
; /* How many bytes in this resource? */
37 DWORD dwImageOffset
; /* Where in the file is this image? */
38 } icoICONDIRENTRY
, *LPicoICONDIRENTRY
;
42 WORD idReserved
; /* Reserved (must be 0) */
43 WORD idType
; /* Resource Type (1 for icons) */
44 WORD idCount
; /* How many images? */
45 icoICONDIRENTRY idEntries
[1]; /* An entry for each image (idCount of 'em) */
46 } icoICONDIR
, *LPicoICONDIR
;
50 extern HGLOBAL16
CURSORICON_LoadHandler( HGLOBAL16
, HINSTANCE16
, BOOL32
);
51 extern WORD
GetIconID( HGLOBAL16 hResource
, DWORD resType
);
53 /*************************************************************************
54 * DragAcceptFiles [SHELL.9]
56 void DragAcceptFiles(HWND16 hWnd
, BOOL16 b
)
58 WND
* wnd
= WIN_FindWndPtr(hWnd
);
61 wnd
->dwExStyle
= b
? wnd
->dwExStyle
| WS_EX_ACCEPTFILES
62 : wnd
->dwExStyle
& ~WS_EX_ACCEPTFILES
;
66 /*************************************************************************
67 * DragQueryFile [SHELL.11]
69 UINT16
DragQueryFile(HDROP16 hDrop
, WORD wFile
, LPSTR lpszFile
, WORD wLength
)
71 /* hDrop is a global memory block allocated with GMEM_SHARE
72 * with DROPFILESTRUCT as a header and filenames following
73 * it, zero length filename is in the end */
75 LPDROPFILESTRUCT lpDropFileStruct
;
79 dprintf_reg(stddeb
,"DragQueryFile(%04x, %i, %p, %u)\n",
80 hDrop
,wFile
,lpszFile
,wLength
);
82 lpDropFileStruct
= (LPDROPFILESTRUCT
) GlobalLock16(hDrop
);
83 if(!lpDropFileStruct
) return 0;
85 lpCurrent
= (LPSTR
) lpDropFileStruct
+ lpDropFileStruct
->wSize
;
90 while (*lpCurrent
++); /* skip filename */
92 return (wFile
== 0xFFFF) ? i
: 0;
95 i
= strlen(lpCurrent
);
96 if (!lpszFile
) return i
+1; /* needed buffer size */
98 i
= (wLength
> i
) ? i
: wLength
-1;
99 strncpy(lpszFile
, lpCurrent
, i
);
102 GlobalUnlock16(hDrop
);
107 /*************************************************************************
108 * DragFinish [SHELL.12]
110 void DragFinish(HDROP16 h
)
112 GlobalFree16((HGLOBAL16
)h
);
116 /*************************************************************************
117 * DragQueryPoint [SHELL.13]
119 BOOL16
DragQueryPoint(HDROP16 hDrop
, POINT16
*p
)
121 LPDROPFILESTRUCT lpDropFileStruct
;
124 lpDropFileStruct
= (LPDROPFILESTRUCT
) GlobalLock16(hDrop
);
126 memcpy(p
,&lpDropFileStruct
->ptMousePos
,sizeof(POINT16
));
127 bRet
= lpDropFileStruct
->fInNonClientArea
;
129 GlobalUnlock16(hDrop
);
133 /*************************************************************************
134 * SHELL_FindExecutable
135 * Utility for code sharing between FindExecutable and ShellExecute
137 static HINSTANCE16
SHELL_FindExecutable( LPCSTR lpFile
,
142 char *extension
= NULL
; /* pointer to file extension */
143 char tmpext
[5]; /* local copy to mung as we please */
144 char filetype
[256]; /* registry name for this filetype */
145 LONG filetypelen
=256; /* length of above */
146 char command
[256]; /* command from registry */
147 LONG commandlen
=256; /* This is the most DOS can handle :) */
148 char buffer
[256]; /* Used to GetProfileString */
149 HINSTANCE16 retval
=31; /* default - 'No association was found' */
150 char *tok
; /* token pointer */
151 int i
; /* random counter */
152 char xlpFile
[256]; /* result of SearchPath */
154 dprintf_exec(stddeb
, "SHELL_FindExecutable: File %s, Dir %s\n",
155 (lpFile
!= NULL
?lpFile
:"-"),
156 (lpDirectory
!= NULL
?lpDirectory
:"-"));
158 lpResult
[0]='\0'; /* Start off with an empty return string */
160 /* trap NULL parameters on entry */
161 if (( lpFile
== NULL
) || ( lpResult
== NULL
) || ( lpOperation
== NULL
))
163 /* FIXME - should throw a warning, perhaps! */
164 return 2; /* File not found. Close enough, I guess. */
166 if (SearchPath32A(lpDirectory
,lpFile
,".exe",sizeof(xlpFile
),xlpFile
,NULL
))
169 /* First thing we need is the file's extension */
170 extension
= strrchr( xlpFile
, '.' ); /* Assume last "." is the one; */
171 /* File->Run in progman uses */
173 if ((extension
== NULL
) || (extension
== &xlpFile
[strlen(xlpFile
)]))
175 return 31; /* no association */
178 /* Make local copy & lowercase it for reg & 'programs=' lookup */
179 lstrcpyn32A( tmpext
, extension
, 5 );
180 CharLower32A( tmpext
);
181 dprintf_exec(stddeb
, "SHELL_FindExecutable: %s file\n", tmpext
);
183 /* Three places to check: */
184 /* 1. win.ini, [windows], programs (NB no leading '.') */
185 /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
186 /* 3. win.ini, [extensions], extension (NB no leading '.' */
187 /* All I know of the order is that registry is checked before */
188 /* extensions; however, it'd make sense to check the programs */
189 /* section first, so that's what happens here. */
191 /* See if it's a program - if GetProfileString fails, we skip this
192 * section. Actually, if GetProfileString fails, we've probably
193 * got a lot more to worry about than running a program... */
194 if ( GetProfileString32A("windows", "programs", "exe pif bat com",
195 buffer
, sizeof(buffer
)) > 0 )
197 for (i
=0;i
<strlen(buffer
); i
++) buffer
[i
]=tolower(buffer
[i
]);
199 tok
= strtok(buffer
, " \t"); /* ? */
202 if (strcmp(tok
, &tmpext
[1])==0) /* have to skip the leading "." */
204 strcpy(lpResult
, xlpFile
);
205 /* Need to perhaps check that the file has a path
207 dprintf_exec(stddeb
, "SHELL_FindExecutable: found %s\n",
211 /* Greater than 32 to indicate success FIXME According to the
212 * docs, I should be returning a handle for the
213 * executable. Does this mean I'm supposed to open the
214 * executable file or something? More RTFM, I guess... */
216 tok
=strtok(NULL
, " \t");
221 if (RegQueryValue16( (HKEY
)HKEY_CLASSES_ROOT
, tmpext
, filetype
,
222 &filetypelen
) == SHELL_ERROR_SUCCESS
)
224 filetype
[filetypelen
]='\0';
225 dprintf_exec(stddeb
, "SHELL_FindExecutable: File type: %s\n",
228 /* Looking for ...buffer\shell\lpOperation\command */
229 strcat( filetype
, "\\shell\\" );
230 strcat( filetype
, lpOperation
);
231 strcat( filetype
, "\\command" );
233 if (RegQueryValue16( (HKEY
)HKEY_CLASSES_ROOT
, filetype
, command
,
234 &commandlen
) == SHELL_ERROR_SUCCESS
)
236 /* Is there a replace() function anywhere? */
237 command
[commandlen
]='\0';
238 strcpy( lpResult
, command
);
239 tok
=strstr( lpResult
, "%1" );
242 tok
[0]='\0'; /* truncate string at the percent */
243 strcat( lpResult
, xlpFile
); /* what if no dir in xlpFile? */
244 tok
=strstr( command
, "%1" );
245 if ((tok
!=NULL
) && (strlen(tok
)>2))
247 strcat( lpResult
, &tok
[2] );
250 retval
=33; /* FIXME see above */
253 else /* Check win.ini */
255 /* Toss the leading dot */
257 if ( GetProfileString32A( "extensions", extension
, "", command
,
258 sizeof(command
)) > 0)
260 if (strlen(command
)!=0)
262 strcpy( lpResult
, command
);
263 tok
=strstr( lpResult
, "^" ); /* should be ^.extension? */
267 strcat( lpResult
, xlpFile
); /* what if no dir in xlpFile? */
268 tok
=strstr( command
, "^" ); /* see above */
269 if ((tok
!= NULL
) && (strlen(tok
)>5))
271 strcat( lpResult
, &tok
[5]);
274 retval
=33; /* FIXME - see above */
279 dprintf_exec(stddeb
, "SHELL_FindExecutable: returning %s\n", lpResult
);
283 /*************************************************************************
284 * ShellExecute16 [SHELL.20]
286 HINSTANCE16
ShellExecute16( HWND16 hWnd
, LPCSTR lpOperation
, LPCSTR lpFile
,
287 LPCSTR lpParameters
, LPCSTR lpDirectory
,
290 HINSTANCE16 retval
=31;
293 dprintf_exec(stddeb
, "ShellExecute(%04x,'%s','%s','%s','%s',%x)\n",
294 hWnd
, lpOperation
? lpOperation
:"<null>", lpFile
? lpFile
:"<null>",
295 lpParameters
? lpParameters
: "<null>",
296 lpDirectory
? lpDirectory
: "<null>", iShowCmd
);
298 if (lpFile
==NULL
) return 0; /* should not happen */
299 if (lpOperation
==NULL
) /* default is open */
302 retval
= SHELL_FindExecutable( lpFile
, lpDirectory
, lpOperation
, cmd
);
312 strcat(cmd
,lpParameters
);
315 dprintf_exec(stddeb
,"ShellExecute:starting %s\n",cmd
);
316 return WinExec32(cmd
,iShowCmd
);
320 /*************************************************************************
321 * ShellExecute32A (SHELL32.84)
323 HINSTANCE32
ShellExecute32A( HWND32 hWnd
, LPCSTR lpOperation
, LPCSTR lpFile
,
324 LPCSTR lpParameters
, LPCSTR lpDirectory
,
327 return ShellExecute16( hWnd
, lpOperation
, lpFile
, lpParameters
,
328 lpDirectory
, iShowCmd
);
332 /*************************************************************************
333 * FindExecutable16 (SHELL.21)
335 HINSTANCE16
FindExecutable16( LPCSTR lpFile
, LPCSTR lpDirectory
,
338 HINSTANCE16 retval
=31; /* default - 'No association was found' */
340 dprintf_exec(stddeb
, "FindExecutable: File %s, Dir %s\n",
341 (lpFile
!= NULL
?lpFile
:"-"),
342 (lpDirectory
!= NULL
?lpDirectory
:"-"));
344 lpResult
[0]='\0'; /* Start off with an empty return string */
346 /* trap NULL parameters on entry */
347 if (( lpFile
== NULL
) || ( lpResult
== NULL
))
349 /* FIXME - should throw a warning, perhaps! */
350 return 2; /* File not found. Close enough, I guess. */
353 retval
= SHELL_FindExecutable( lpFile
, lpDirectory
, "open",
356 dprintf_exec(stddeb
, "FindExecutable: returning %s\n", lpResult
);
368 /*************************************************************************
369 * AboutDlgProc32 (not an exported API function)
371 LRESULT
AboutDlgProc32( HWND32 hWnd
, UINT32 msg
, WPARAM32 wParam
,
374 char Template
[512], AppTitle
[512];
380 ABOUT_INFO
*info
= (ABOUT_INFO
*)lParam
;
383 SendDlgItemMessage32A(hWnd
, stc1
, STM_SETICON
, info
->hIcon
, 0);
384 GetWindowText32A( hWnd
, Template
, sizeof(Template
) );
385 sprintf( AppTitle
, Template
, info
->szApp
);
386 SetWindowText32A( hWnd
, AppTitle
);
387 SetWindowText32A( GetDlgItem32(hWnd
,100), info
->szOtherStuff
);
395 EndDialog32(hWnd
, TRUE
);
404 /*************************************************************************
405 * AboutDlgProc16 (SHELL.33)
407 LRESULT
AboutDlgProc16( HWND16 hWnd
, UINT16 msg
, WPARAM16 wParam
,
410 return AboutDlgProc32( hWnd
, msg
, wParam
, lParam
);
414 /*************************************************************************
415 * ShellAbout16 (SHELL.22)
417 BOOL16
ShellAbout16( HWND16 hWnd
, LPCSTR szApp
, LPCSTR szOtherStuff
,
420 return ShellAbout32A( hWnd
, szApp
, szOtherStuff
, hIcon
);
423 /*************************************************************************
424 * ShellAbout32A (SHELL32.82)
426 BOOL32
ShellAbout32A( HWND32 hWnd
, LPCSTR szApp
, LPCSTR szOtherStuff
,
431 info
.szOtherStuff
= szOtherStuff
;
433 if (!hIcon
) info
.hIcon
= LoadIcon16( 0, MAKEINTRESOURCE(OIC_WINEICON
) );
434 return DialogBoxIndirectParam32A( WIN_GetWindowInstance( hWnd
),
435 SYSRES_GetResPtr( SYSRES_DIALOG_SHELL_ABOUT_MSGBOX
),
436 hWnd
, AboutDlgProc32
, (LPARAM
)&info
);
440 /*************************************************************************
441 * ShellAbout32W (SHELL32.83)
443 BOOL32
ShellAbout32W( HWND32 hWnd
, LPCWSTR szApp
, LPCWSTR szOtherStuff
,
449 info
.szApp
= HEAP_strdupWtoA( GetProcessHeap(), 0, szApp
);
450 info
.szOtherStuff
= HEAP_strdupWtoA( GetProcessHeap(), 0, szOtherStuff
);
452 if (!hIcon
) info
.hIcon
= LoadIcon16( 0, MAKEINTRESOURCE(OIC_WINEICON
) );
453 ret
= DialogBoxIndirectParam32A( WIN_GetWindowInstance( hWnd
),
454 SYSRES_GetResPtr( SYSRES_DIALOG_SHELL_ABOUT_MSGBOX
),
455 hWnd
, AboutDlgProc32
, (LPARAM
)&info
);
456 HeapFree( GetProcessHeap(), 0, (LPSTR
)info
.szApp
);
457 HeapFree( GetProcessHeap(), 0, (LPSTR
)info
.szOtherStuff
);
462 /*************************************************************************
463 * SHELL_GetResourceTable
465 * FIXME: Implement GetPEResourceTable in w32sys.c and call it here.
467 static BYTE
* SHELL_GetResourceTable(HFILE32 hFile
)
469 struct mz_header_s mz_header
;
470 struct ne_header_s ne_header
;
473 _llseek32( hFile
, 0, SEEK_SET
);
474 if ((_lread32(hFile
,&mz_header
,sizeof(mz_header
)) != sizeof(mz_header
)) ||
475 (mz_header
.mz_magic
!= MZ_SIGNATURE
)) return (BYTE
*)-1;
477 _llseek32( hFile
, mz_header
.ne_offset
, SEEK_SET
);
478 if (_lread32( hFile
, &ne_header
, sizeof(ne_header
) ) != sizeof(ne_header
))
481 if (ne_header
.ne_magic
== PE_SIGNATURE
)
482 { fprintf(stdnimp
,"Win32s FIXME: file %s line %i\n", __FILE__
, __LINE__
);
485 if (ne_header
.ne_magic
!= NE_SIGNATURE
) return NULL
;
487 size
= ne_header
.rname_tab_offset
- ne_header
.resource_tab_offset
;
489 if( size
> sizeof(NE_TYPEINFO
) )
491 BYTE
* pTypeInfo
= (BYTE
*)xmalloc(size
);
493 if( !pTypeInfo
) return NULL
;
495 _llseek32(hFile
, mz_header
.ne_offset
+ne_header
.resource_tab_offset
, SEEK_SET
);
496 if( _lread32( hFile
, (char*)pTypeInfo
, size
) != size
)
497 { free(pTypeInfo
); return NULL
; }
505 /*************************************************************************
508 static HGLOBAL16
SHELL_LoadResource(HINSTANCE16 hInst
, HFILE32 hFile
, NE_NAMEINFO
* pNInfo
, WORD sizeShift
)
511 HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10, (DWORD
)pNInfo
->length
<< sizeShift
);
513 if( (ptr
= (BYTE
*)GlobalLock16( handle
)) )
515 _llseek32( hFile
, (DWORD
)pNInfo
->offset
<< sizeShift
, SEEK_SET
);
516 _lread32( hFile
, (char*)ptr
, pNInfo
->length
<< sizeShift
);
522 /*************************************************************************
525 static HGLOBAL16
ICO_LoadIcon(HINSTANCE16 hInst
, HFILE32 hFile
, LPicoICONDIRENTRY lpiIDE
)
528 HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10, lpiIDE
->dwBytesInRes
);
530 if( (ptr
= (BYTE
*)GlobalLock16( handle
)) )
532 _llseek32( hFile
, lpiIDE
->dwImageOffset
, SEEK_SET
);
533 _lread32( hFile
, (char*)ptr
, lpiIDE
->dwBytesInRes
);
539 /*************************************************************************
540 * ICO_GetIconDirectory
542 * Read .ico file and build phony ICONDIR struct for GetIconID
544 static HGLOBAL16
ICO_GetIconDirectory(HINSTANCE16 hInst
, HFILE32 hFile
, LPicoICONDIR
* lplpiID
)
546 WORD id
[3]; /* idReserved, idType, idCount */
550 _llseek32( hFile
, 0, SEEK_SET
);
551 if( _lread32(hFile
,(char*)id
,sizeof(id
)) != sizeof(id
) ) return 0;
555 * - see http://www.microsoft.com/win32dev/ui/icons.htm
558 if( id
[0] || id
[1] != 1 || !id
[2] ) return 0;
560 i
= id
[2]*sizeof(icoICONDIRENTRY
) + sizeof(id
);
562 lpiID
= (LPicoICONDIR
)xmalloc(i
);
564 if( _lread32(hFile
,(char*)lpiID
->idEntries
,i
) == i
)
566 HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10,
567 id
[2]*sizeof(ICONDIRENTRY
) + sizeof(id
) );
570 CURSORICONDIR
* lpID
= (CURSORICONDIR
*)GlobalLock16( handle
);
571 lpID
->idReserved
= lpiID
->idReserved
= id
[0];
572 lpID
->idType
= lpiID
->idType
= id
[1];
573 lpID
->idCount
= lpiID
->idCount
= id
[2];
574 for( i
=0; i
< lpiID
->idCount
; i
++ )
576 memcpy((void*)(lpID
->idEntries
+ i
),
577 (void*)(lpiID
->idEntries
+ i
), sizeof(ICONDIRENTRY
) - 2);
578 lpID
->idEntries
[i
].icon
.wResId
= i
;
590 /*************************************************************************
591 * InternalExtractIcon [SHELL.39]
593 * This abortion is called directly by Progman
595 HGLOBAL16
InternalExtractIcon(HINSTANCE16 hInstance
, LPCSTR lpszExeFileName
, UINT16 nIconIndex
, WORD n
)
598 HGLOBAL16
* RetPtr
= NULL
;
601 HFILE32 hFile
= OpenFile32( lpszExeFileName
, &ofs
, OF_READ
);
603 dprintf_reg(stddeb
, "InternalExtractIcon(%04x, file '%s', start from %d, extract %d\n",
604 hInstance
, lpszExeFileName
, nIconIndex
, n
);
606 if( hFile
== HFILE_ERROR32
|| !n
) return 0;
608 hRet
= GlobalAlloc16( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(HICON16
)*n
);
609 RetPtr
= (HICON16
*)GlobalLock16(hRet
);
611 *RetPtr
= (n
== 0xFFFF)? 0: 1; /* error return values */
613 pData
= SHELL_GetResourceTable(hFile
);
617 BOOL32 icoFile
= FALSE
;
618 UINT16 iconDirCount
= 0;
619 UINT16 iconCount
= 0;
620 NE_TYPEINFO
* pTInfo
= (NE_TYPEINFO
*)(pData
+ 2);
621 NE_NAMEINFO
* pIconStorage
= NULL
;
622 NE_NAMEINFO
* pIconDir
= NULL
;
623 LPicoICONDIR lpiID
= NULL
;
625 if( pData
== (BYTE
*)-1 )
627 /* check for .ICO file */
629 hIcon
= ICO_GetIconDirectory(hInstance
, hFile
, &lpiID
);
631 { icoFile
= TRUE
; iconDirCount
= 1; iconCount
= lpiID
->idCount
; }
633 else while( pTInfo
->type_id
&& !(pIconStorage
&& pIconDir
) )
635 /* find icon directory and icon repository */
637 if( pTInfo
->type_id
== NE_RSCTYPE_GROUP_ICON
)
639 iconDirCount
= pTInfo
->count
;
640 pIconDir
= ((NE_NAMEINFO
*)(pTInfo
+ 1));
641 dprintf_reg(stddeb
,"\tfound directory - %i icon families\n", iconDirCount
);
643 if( pTInfo
->type_id
== NE_RSCTYPE_ICON
)
645 iconCount
= pTInfo
->count
;
646 pIconStorage
= ((NE_NAMEINFO
*)(pTInfo
+ 1));
647 dprintf_reg(stddeb
,"\ttotal icons - %i\n", iconCount
);
649 pTInfo
= (NE_TYPEINFO
*)((char*)(pTInfo
+1)+pTInfo
->count
*sizeof(NE_NAMEINFO
));
652 /* load resources and create icons */
654 if( (pIconStorage
&& pIconDir
) || icoFile
)
655 if( nIconIndex
== (UINT16
)-1 ) RetPtr
[0] = iconDirCount
;
656 else if( nIconIndex
< iconDirCount
)
660 if( n
> iconDirCount
- nIconIndex
) n
= iconDirCount
- nIconIndex
;
662 for( i
= nIconIndex
; i
< nIconIndex
+ n
; i
++ )
664 /* .ICO files have only one icon directory */
667 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconDir
+ i
,
669 RetPtr
[i
-nIconIndex
] = GetIconID( hIcon
, 3 );
673 for( icon
= nIconIndex
; icon
< nIconIndex
+ n
; icon
++ )
677 hIcon
= ICO_LoadIcon( hInstance
, hFile
, lpiID
->idEntries
+ RetPtr
[icon
-nIconIndex
]);
679 for( i
= 0; i
< iconCount
; i
++ )
680 if( pIconStorage
[i
].id
== (RetPtr
[icon
-nIconIndex
] | 0x8000) )
681 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconStorage
+ i
,
683 RetPtr
[icon
-nIconIndex
] = (hIcon
)?CURSORICON_LoadHandler( hIcon
, hInstance
, FALSE
):0;
686 if( icoFile
) free(lpiID
);
691 /* return array with icon handles */
696 /*************************************************************************
697 * ExtractIcon16 (SHELL.34)
699 HICON16
ExtractIcon16( HINSTANCE16 hInstance
, LPCSTR lpszExeFileName
,
702 HGLOBAL16 handle
= InternalExtractIcon(hInstance
,lpszExeFileName
,nIconIndex
, 1);
706 HICON16
* ptr
= (HICON16
*)GlobalLock16(handle
);
707 HICON16 hIcon
= *ptr
;
709 GlobalFree16(handle
);
716 /*************************************************************************
717 * ExtractIcon32A (SHELL32.20)
719 HICON32
ExtractIcon32A( HINSTANCE32 hInstance
, LPCSTR lpszExeFileName
,
723 return ExtractIcon16( hInstance
, lpszExeFileName
, nIconIndex
);
727 /*************************************************************************
728 * ExtractAssociatedIcon [SHELL.36]
730 * Return icon for given file (either from file itself or from associated
731 * executable) and patch parameters if needed.
733 HICON16
ExtractAssociatedIcon(HINSTANCE16 hInst
,LPSTR lpIconPath
,LPWORD lpiIcon
)
735 HICON16 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
740 if( hIcon
== 1 ) /* no icons found in given file */
743 UINT16 uRet
= FindExecutable16(lpIconPath
,NULL
,tempPath
);
745 if( uRet
> 32 && tempPath
[0] )
747 strcpy(lpIconPath
,tempPath
);
748 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
750 if( hIcon
> 2 ) return hIcon
;
756 *lpiIcon
= 2; /* MSDOS icon - we found .exe but no icons in it */
758 *lpiIcon
= 6; /* generic icon - found nothing */
760 GetModuleFileName16(hInst
, lpIconPath
, 0x80);
761 hIcon
= LoadIcon16( hInst
, MAKEINTRESOURCE(*lpiIcon
));
767 /*************************************************************************
768 * FindEnvironmentString [SHELL.38]
770 * Returns a pointer into the DOS environment... Ugh.
772 LPSTR
SHELL_FindString(LPSTR lpEnv
, LPCSTR entry
)
774 UINT16 l
= strlen(entry
);
775 for( ; *lpEnv
; lpEnv
+=strlen(lpEnv
)+1 )
777 if( lstrncmpi32A(lpEnv
, entry
, l
) ) continue;
780 return (lpEnv
+ l
); /* empty entry */
781 else if ( *(lpEnv
+l
)== '=' )
782 return (lpEnv
+ l
+ 1);
787 SEGPTR
FindEnvironmentString(LPSTR str
)
789 SEGPTR spEnv
= GetDOSEnvironment();
790 LPSTR lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(spEnv
);
792 LPSTR lpString
= (spEnv
)?SHELL_FindString(lpEnv
, str
):NULL
;
794 if( lpString
) /* offset should be small enough */
795 return spEnv
+ (lpString
- lpEnv
);
800 /*************************************************************************
801 * DoEnvironmentSubst [SHELL.37]
803 * Replace %KEYWORD% in the str with the value of variable KEYWORD
804 * from "DOS" environment.
806 DWORD
DoEnvironmentSubst(LPSTR str
,WORD length
)
808 LPSTR lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(GetDOSEnvironment());
809 LPSTR lpBuffer
= (LPSTR
)xmalloc(length
);
811 LPSTR lpbstr
= lpBuffer
;
813 CharToOem32A(str
,str
);
815 dprintf_reg(stddeb
,"DoEnvSubst: accept %s", str
);
817 while( *lpstr
&& lpbstr
- lpBuffer
< length
)
823 do { lpend
++; } while( *lpend
&& *lpend
!= '%' );
824 if( *lpend
== '%' && lpend
- lpstr
> 1 ) /* found key */
828 lpKey
= SHELL_FindString(lpEnv
, lpstr
+1);
829 if( lpKey
) /* found key value */
831 int l
= strlen(lpKey
);
833 if( l
> length
- (lpbstr
- lpBuffer
) - 1 )
835 fprintf(stdnimp
,"File %s, line %i: Env subst aborted - string too short\n",
840 strcpy(lpbstr
, lpKey
);
847 else break; /* back off and whine */
852 *lpbstr
++ = *lpstr
++;
856 if( lpstr
- str
== strlen(str
) )
858 strncpy(str
, lpBuffer
, length
);
864 dprintf_reg(stddeb
," return %s\n", str
);
866 OemToChar32A(str
,str
);
869 /* Return str length in the LOWORD
870 * and 1 in HIWORD if subst was successful.
872 return (DWORD
)MAKELONG(strlen(str
), length
);
875 /*************************************************************************
876 * RegisterShellHook [SHELL.102]
878 int RegisterShellHook(void *ptr
)
880 fprintf(stdnimp
, "RegisterShellHook( %p ) : Empty Stub !!!\n", ptr
);
885 /*************************************************************************
886 * ShellHookProc [SHELL.103]
888 int ShellHookProc(void)
890 fprintf(stdnimp
, "ShellHookProc : Empty Stub !!!\n");
894 /*************************************************************************
895 * SHGetFileInfoA [SHELL32.54]
898 SHGetFileInfo32A(LPCSTR path
,DWORD dwFileAttributes
,SHFILEINFO32A
*psfi
,
899 UINT32 sizeofpsfi
,UINT32 flags
901 fprintf(stdnimp
,"SHGetFileInfo32A(%s,0x%08lx,%p,%d,0x%08x)\n",
902 path
,dwFileAttributes
,psfi
,sizeofpsfi
,flags
907 /*************************************************************************
908 * CommandLineToArgvW [SHELL32.2]
911 CommandLineToArgvW(LPWSTR cmdline
,LPDWORD numargs
) {
915 /* to get writeable copy */
916 cmdline
= HEAP_strdupW( GetProcessHeap(), 0, cmdline
);
923 while (*s
&& *s
==0x0020)
929 argv
=(LPWSTR
*)HeapAlloc( GetProcessHeap(), 0, sizeof(LPWSTR
)*(i
+1) );
935 argv
[i
++]=HEAP_strdupW( GetProcessHeap(), 0, t
);
937 while (*s
&& *s
==0x0020)
948 argv
[i
++]=(LPWSTR
)HEAP_strdupW( GetProcessHeap(), 0, t
);
949 HeapFree( GetProcessHeap(), 0, cmdline
);