2 * Shell Library Functions
22 #include "cursoricon.h"
23 #include "interfaces.h"
24 #include "sysmetrics.h"
28 #include "imagelist.h"
31 /* .ICO file ICONDIR definitions */
37 BYTE bWidth
; /* Width, in pixels, of the image */
38 BYTE bHeight
; /* Height, in pixels, of the image */
39 BYTE bColorCount
; /* Number of colors in image (0 if >=8bpp) */
40 BYTE bReserved
; /* Reserved ( must be 0) */
41 WORD wPlanes
; /* Color Planes */
42 WORD wBitCount
; /* Bits per pixel */
43 DWORD dwBytesInRes
; /* How many bytes in this resource? */
44 DWORD dwImageOffset
; /* Where in the file is this image? */
45 } icoICONDIRENTRY
, *LPicoICONDIRENTRY
;
49 WORD idReserved
; /* Reserved (must be 0) */
50 WORD idType
; /* Resource Type (1 for icons) */
51 WORD idCount
; /* How many images? */
52 icoICONDIRENTRY idEntries
[1]; /* An entry for each image (idCount of 'em) */
53 } icoICONDIR
, *LPicoICONDIR
;
57 static const char* lpstrMsgWndCreated
= "OTHERWINDOWCREATED";
58 static const char* lpstrMsgWndDestroyed
= "OTHERWINDOWDESTROYED";
59 static const char* lpstrMsgShellActivate
= "ACTIVATESHELLWINDOW";
61 static HWND16 SHELL_hWnd
= 0;
62 static HHOOK SHELL_hHook
= 0;
63 static UINT16 uMsgWndCreated
= 0;
64 static UINT16 uMsgWndDestroyed
= 0;
65 static UINT16 uMsgShellActivate
= 0;
67 /*************************************************************************
68 * DragAcceptFiles32 [SHELL32.54]
70 void WINAPI
DragAcceptFiles32(HWND32 hWnd
, BOOL32 b
)
72 WND
* wnd
= WIN_FindWndPtr(hWnd
);
75 wnd
->dwExStyle
= b
? wnd
->dwExStyle
| WS_EX_ACCEPTFILES
76 : wnd
->dwExStyle
& ~WS_EX_ACCEPTFILES
;
79 /*************************************************************************
80 * DragAcceptFiles16 [SHELL.9]
82 void WINAPI
DragAcceptFiles16(HWND16 hWnd
, BOOL16 b
)
84 DragAcceptFiles32(hWnd
, b
);
87 /*************************************************************************
88 * SHELL_DragQueryFile [internal]
91 static UINT32
SHELL_DragQueryFile(LPSTR lpDrop
, LPWSTR lpwDrop
, UINT32 lFile
,
92 LPSTR lpszFile
, LPWSTR lpszwFile
, UINT32 lLength
)
99 while (*lpDrop
++); /* skip filename */
101 return (lFile
== 0xFFFFFFFF) ? i
: 0;
105 while (i
++ < lFile
) {
106 while (*lpwDrop
++); /* skip filename */
108 return (lFile
== 0xFFFFFFFF) ? i
: 0;
112 if (lpDrop
) i
= lstrlen32A(lpDrop
);
113 if (lpwDrop
) i
= lstrlen32W(lpwDrop
);
115 if (!lpszFile
&& !lpszwFile
) {
116 return i
; /* needed buffer size */
118 i
= (lLength
> i
) ? i
: lLength
;
120 if (lpDrop
) lstrcpyn32A (lpszFile
, lpDrop
, i
);
121 else lstrcpynWtoA(lpszFile
, lpwDrop
, i
);
123 if (lpDrop
) lstrcpynAtoW(lpszwFile
, lpDrop
, i
);
124 else lstrcpyn32W (lpszwFile
, lpwDrop
, i
);
129 /*************************************************************************
130 * DragQueryFile32A [SHELL32.81] [shell32.82]
132 UINT32 WINAPI
DragQueryFile32A(HDROP32 hDrop
, UINT32 lFile
, LPSTR lpszFile
,
134 { /* hDrop is a global memory block allocated with GMEM_SHARE
135 * with DROPFILESTRUCT as a header and filenames following
136 * it, zero length filename is in the end */
138 LPDROPFILESTRUCT32 lpDropFileStruct
;
142 TRACE(shell
,"(%08x, %x, %p, %u)\n", hDrop
,lFile
,lpszFile
,lLength
);
144 lpDropFileStruct
= (LPDROPFILESTRUCT32
) GlobalLock32(hDrop
);
145 if(!lpDropFileStruct
)
148 lpCurrent
= (LPSTR
) lpDropFileStruct
+ lpDropFileStruct
->lSize
;
149 i
= SHELL_DragQueryFile(lpCurrent
, NULL
, lFile
, lpszFile
, NULL
, lLength
);
150 GlobalUnlock32(hDrop
);
154 /*************************************************************************
155 * DragQueryFile32W [shell32.133]
157 UINT32 WINAPI
DragQueryFile32W(HDROP32 hDrop
, UINT32 lFile
, LPWSTR lpszwFile
,
160 LPDROPFILESTRUCT32 lpDropFileStruct
;
164 TRACE(shell
,"(%08x, %x, %p, %u)\n", hDrop
,lFile
,lpszwFile
,lLength
);
166 lpDropFileStruct
= (LPDROPFILESTRUCT32
) GlobalLock32(hDrop
);
167 if(!lpDropFileStruct
)
170 lpwCurrent
= (LPWSTR
) lpDropFileStruct
+ lpDropFileStruct
->lSize
;
171 i
= SHELL_DragQueryFile(NULL
, lpwCurrent
, lFile
, NULL
, lpszwFile
,lLength
);
172 GlobalUnlock32(hDrop
);
175 /*************************************************************************
176 * DragQueryFile16 [SHELL.11]
178 UINT16 WINAPI
DragQueryFile16(HDROP16 hDrop
, WORD wFile
, LPSTR lpszFile
,
180 { /* hDrop is a global memory block allocated with GMEM_SHARE
181 * with DROPFILESTRUCT as a header and filenames following
182 * it, zero length filename is in the end */
184 LPDROPFILESTRUCT16 lpDropFileStruct
;
188 TRACE(shell
,"(%04x, %x, %p, %u)\n", hDrop
,wFile
,lpszFile
,wLength
);
190 lpDropFileStruct
= (LPDROPFILESTRUCT16
) GlobalLock16(hDrop
);
191 if(!lpDropFileStruct
)
194 lpCurrent
= (LPSTR
) lpDropFileStruct
+ lpDropFileStruct
->wSize
;
196 i
= (WORD
)SHELL_DragQueryFile(lpCurrent
, NULL
, wFile
==0xffff?0xffffffff:wFile
,
197 lpszFile
, NULL
, wLength
);
198 GlobalUnlock16(hDrop
);
204 /*************************************************************************
205 * DragFinish32 [SHELL32.80]
207 void WINAPI
DragFinish32(HDROP32 h
)
209 GlobalFree32((HGLOBAL32
)h
);
212 /*************************************************************************
213 * DragFinish16 [SHELL.12]
215 void WINAPI
DragFinish16(HDROP16 h
)
217 GlobalFree16((HGLOBAL16
)h
);
221 /*************************************************************************
222 * DragQueryPoint32 [SHELL32.135]
224 BOOL32 WINAPI
DragQueryPoint32(HDROP32 hDrop
, POINT32
*p
)
226 LPDROPFILESTRUCT32 lpDropFileStruct
;
229 lpDropFileStruct
= (LPDROPFILESTRUCT32
) GlobalLock32(hDrop
);
231 memcpy(p
,&lpDropFileStruct
->ptMousePos
,sizeof(POINT32
));
232 bRet
= lpDropFileStruct
->fInNonClientArea
;
234 GlobalUnlock32(hDrop
);
238 /*************************************************************************
239 * DragQueryPoint16 [SHELL.13]
241 BOOL16 WINAPI
DragQueryPoint16(HDROP16 hDrop
, POINT16
*p
)
243 LPDROPFILESTRUCT16 lpDropFileStruct
;
246 lpDropFileStruct
= (LPDROPFILESTRUCT16
) GlobalLock16(hDrop
);
248 memcpy(p
,&lpDropFileStruct
->ptMousePos
,sizeof(POINT16
));
249 bRet
= lpDropFileStruct
->fInNonClientArea
;
251 GlobalUnlock16(hDrop
);
255 /*************************************************************************
256 * SHELL_FindExecutable [Internal]
258 * Utility for code sharing between FindExecutable and ShellExecute
260 HINSTANCE32
SHELL_FindExecutable( LPCSTR lpFile
,
263 { char *extension
= NULL
; /* pointer to file extension */
264 char tmpext
[5]; /* local copy to mung as we please */
265 char filetype
[256]; /* registry name for this filetype */
266 LONG filetypelen
=256; /* length of above */
267 char command
[256]; /* command from registry */
268 LONG commandlen
=256; /* This is the most DOS can handle :) */
269 char buffer
[256]; /* Used to GetProfileString */
270 HINSTANCE32 retval
=31; /* default - 'No association was found' */
271 char *tok
; /* token pointer */
272 int i
; /* random counter */
273 char xlpFile
[256]; /* result of SearchPath */
275 TRACE(shell
, "%s\n", (lpFile
!= NULL
?lpFile
:"-") );
277 lpResult
[0]='\0'; /* Start off with an empty return string */
279 /* trap NULL parameters on entry */
280 if (( lpFile
== NULL
) || ( lpResult
== NULL
) || ( lpOperation
== NULL
))
281 { WARN(exec
, "(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
282 lpFile
, lpOperation
, lpResult
);
283 return 2; /* File not found. Close enough, I guess. */
286 if (SearchPath32A( NULL
, lpFile
,".exe",sizeof(xlpFile
),xlpFile
,NULL
))
287 { TRACE(shell
, "SearchPath32A returned non-zero\n");
291 /* First thing we need is the file's extension */
292 extension
= strrchr( xlpFile
, '.' ); /* Assume last "." is the one; */
293 /* File->Run in progman uses */
295 TRACE(shell
, "xlpFile=%s,extension=%s\n", xlpFile
, extension
);
297 if ((extension
== NULL
) || (extension
== &xlpFile
[strlen(xlpFile
)]))
298 { WARN(shell
, "Returning 31 - No association\n");
299 return 31; /* no association */
302 /* Make local copy & lowercase it for reg & 'programs=' lookup */
303 lstrcpyn32A( tmpext
, extension
, 5 );
304 CharLower32A( tmpext
);
305 TRACE(shell
, "%s file\n", tmpext
);
307 /* Three places to check: */
308 /* 1. win.ini, [windows], programs (NB no leading '.') */
309 /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
310 /* 3. win.ini, [extensions], extension (NB no leading '.' */
311 /* All I know of the order is that registry is checked before */
312 /* extensions; however, it'd make sense to check the programs */
313 /* section first, so that's what happens here. */
315 /* See if it's a program - if GetProfileString fails, we skip this
316 * section. Actually, if GetProfileString fails, we've probably
317 * got a lot more to worry about than running a program... */
318 if ( GetProfileString32A("windows", "programs", "exe pif bat com",
319 buffer
, sizeof(buffer
)) > 0 )
320 { for (i
=0;i
<strlen(buffer
); i
++) buffer
[i
]=tolower(buffer
[i
]);
322 tok
= strtok(buffer
, " \t"); /* ? */
325 if (strcmp(tok
, &tmpext
[1])==0) /* have to skip the leading "." */
327 strcpy(lpResult
, xlpFile
);
328 /* Need to perhaps check that the file has a path
330 TRACE(shell
, "found %s\n", lpResult
);
333 /* Greater than 32 to indicate success FIXME According to the
334 * docs, I should be returning a handle for the
335 * executable. Does this mean I'm supposed to open the
336 * executable file or something? More RTFM, I guess... */
338 tok
=strtok(NULL
, " \t");
343 if (RegQueryValue16( HKEY_CLASSES_ROOT
, tmpext
, filetype
,
344 &filetypelen
) == ERROR_SUCCESS
)
346 filetype
[filetypelen
]='\0';
347 TRACE(shell
, "File type: %s\n", filetype
);
349 /* Looking for ...buffer\shell\lpOperation\command */
350 strcat( filetype
, "\\shell\\" );
351 strcat( filetype
, lpOperation
);
352 strcat( filetype
, "\\command" );
354 if (RegQueryValue16( HKEY_CLASSES_ROOT
, filetype
, command
,
355 &commandlen
) == ERROR_SUCCESS
)
357 /* Is there a replace() function anywhere? */
358 command
[commandlen
]='\0';
359 strcpy( lpResult
, command
);
360 tok
=strstr( lpResult
, "%1" );
363 tok
[0]='\0'; /* truncate string at the percent */
364 strcat( lpResult
, xlpFile
); /* what if no dir in xlpFile? */
365 tok
=strstr( command
, "%1" );
366 if ((tok
!=NULL
) && (strlen(tok
)>2))
368 strcat( lpResult
, &tok
[2] );
371 retval
=33; /* FIXME see above */
374 else /* Check win.ini */
376 /* Toss the leading dot */
378 if ( GetProfileString32A( "extensions", extension
, "", command
,
379 sizeof(command
)) > 0)
381 if (strlen(command
)!=0)
383 strcpy( lpResult
, command
);
384 tok
=strstr( lpResult
, "^" ); /* should be ^.extension? */
388 strcat( lpResult
, xlpFile
); /* what if no dir in xlpFile? */
389 tok
=strstr( command
, "^" ); /* see above */
390 if ((tok
!= NULL
) && (strlen(tok
)>5))
392 strcat( lpResult
, &tok
[5]);
395 retval
=33; /* FIXME - see above */
400 TRACE(shell
, "returning %s\n", lpResult
);
404 /*************************************************************************
405 * ShellExecute16 [SHELL.20]
407 HINSTANCE16 WINAPI
ShellExecute16( HWND16 hWnd
, LPCSTR lpOperation
,
408 LPCSTR lpFile
, LPCSTR lpParameters
,
409 LPCSTR lpDirectory
, INT16 iShowCmd
)
410 { HINSTANCE16 retval
=31;
414 TRACE(shell
, "(%04x,'%s','%s','%s','%s',%x)\n",
415 hWnd
, lpOperation
? lpOperation
:"<null>", lpFile
? lpFile
:"<null>",
416 lpParameters
? lpParameters
: "<null>",
417 lpDirectory
? lpDirectory
: "<null>", iShowCmd
);
419 if (lpFile
==NULL
) return 0; /* should not happen */
420 if (lpOperation
==NULL
) /* default is open */
424 { GetCurrentDirectory32A( sizeof(old_dir
), old_dir
);
425 SetCurrentDirectory32A( lpDirectory
);
428 retval
= SHELL_FindExecutable( lpFile
, lpOperation
, cmd
);
430 if (retval
> 32) /* Found */
433 strcat(cmd
,lpParameters
);
436 TRACE(shell
,"starting %s\n",cmd
);
437 retval
= WinExec32( cmd
, iShowCmd
);
440 SetCurrentDirectory32A( old_dir
);
444 /*************************************************************************
445 * FindExecutable16 (SHELL.21)
447 HINSTANCE16 WINAPI
FindExecutable16( LPCSTR lpFile
, LPCSTR lpDirectory
,
449 { return (HINSTANCE16
)FindExecutable32A( lpFile
, lpDirectory
, lpResult
);
453 /*************************************************************************
454 * AboutDlgProc16 (SHELL.33)
456 LRESULT WINAPI
AboutDlgProc16( HWND16 hWnd
, UINT16 msg
, WPARAM16 wParam
,
458 { return AboutDlgProc32( hWnd
, msg
, wParam
, lParam
);
462 /*************************************************************************
463 * ShellAbout16 (SHELL.22)
465 BOOL16 WINAPI
ShellAbout16( HWND16 hWnd
, LPCSTR szApp
, LPCSTR szOtherStuff
,
467 { return ShellAbout32A( hWnd
, szApp
, szOtherStuff
, hIcon
);
470 /*************************************************************************
471 * SHELL_GetResourceTable
473 static DWORD
SHELL_GetResourceTable(HFILE32 hFile
,LPBYTE
*retptr
)
475 IMAGE_DOS_HEADER mz_header
;
480 _llseek32( hFile
, 0, SEEK_SET
);
481 if ( (_lread32(hFile
,&mz_header
,sizeof(mz_header
)) != sizeof(mz_header
)) ||
482 (mz_header
.e_magic
!= IMAGE_DOS_SIGNATURE
)
483 ) { /* .ICO file ? */
484 if (mz_header
.e_cblp
== 1) { /* ICONHEADER.idType, must be 1 */
485 *retptr
= (LPBYTE
)-1;
489 return 0; /* failed */
491 _llseek32( hFile
, mz_header
.e_lfanew
, SEEK_SET
);
492 if (_lread32( hFile
, magic
, sizeof(magic
) ) != sizeof(magic
))
494 _llseek32( hFile
, mz_header
.e_lfanew
, SEEK_SET
);
496 if (*(DWORD
*)magic
== IMAGE_NT_SIGNATURE
)
497 return IMAGE_NT_SIGNATURE
;
498 if (*(WORD
*)magic
== IMAGE_OS2_SIGNATURE
) {
499 IMAGE_OS2_HEADER ne_header
;
500 LPBYTE pTypeInfo
= (LPBYTE
)-1;
502 if (_lread32(hFile
,&ne_header
,sizeof(ne_header
))!=sizeof(ne_header
))
505 if (ne_header
.ne_magic
!= IMAGE_OS2_SIGNATURE
) return 0;
506 size
= ne_header
.rname_tab_offset
- ne_header
.resource_tab_offset
;
507 if( size
> sizeof(NE_TYPEINFO
) )
509 pTypeInfo
= (BYTE
*)HeapAlloc( GetProcessHeap(), 0, size
);
511 _llseek32(hFile
, mz_header
.e_lfanew
+ne_header
.resource_tab_offset
, SEEK_SET
);
512 if( _lread32( hFile
, (char*)pTypeInfo
, size
) != size
) {
513 HeapFree( GetProcessHeap(), 0, pTypeInfo
);
519 return IMAGE_OS2_SIGNATURE
;
521 return 0; /* failed */
524 /*************************************************************************
527 static HGLOBAL16
SHELL_LoadResource(HINSTANCE16 hInst
, HFILE32 hFile
, NE_NAMEINFO
* pNInfo
, WORD sizeShift
)
529 HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10, (DWORD
)pNInfo
->length
<< sizeShift
);
531 if( (ptr
= (BYTE
*)GlobalLock16( handle
)) )
532 { _llseek32( hFile
, (DWORD
)pNInfo
->offset
<< sizeShift
, SEEK_SET
);
533 _lread32( hFile
, (char*)ptr
, pNInfo
->length
<< sizeShift
);
539 /*************************************************************************
542 static HGLOBAL16
ICO_LoadIcon(HINSTANCE16 hInst
, HFILE32 hFile
, LPicoICONDIRENTRY lpiIDE
)
544 HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10, lpiIDE
->dwBytesInRes
);
546 if( (ptr
= (BYTE
*)GlobalLock16( handle
)) )
547 { _llseek32( hFile
, lpiIDE
->dwImageOffset
, SEEK_SET
);
548 _lread32( hFile
, (char*)ptr
, lpiIDE
->dwBytesInRes
);
554 /*************************************************************************
555 * ICO_GetIconDirectory
557 * Read .ico file and build phony ICONDIR struct for GetIconID
559 static HGLOBAL16
ICO_GetIconDirectory(HINSTANCE16 hInst
, HFILE32 hFile
, LPicoICONDIR
* lplpiID
)
560 { WORD id
[3]; /* idReserved, idType, idCount */
565 _llseek32( hFile
, 0, SEEK_SET
);
566 if( _lread32(hFile
,(char*)id
,sizeof(id
)) != sizeof(id
) ) return 0;
570 * - see http://www.microsoft.com/win32dev/ui/icons.htm
573 if( id
[0] || id
[1] != 1 || !id
[2] ) return 0;
575 i
= id
[2]*sizeof(icoICONDIRENTRY
) + sizeof(id
);
577 lpiID
= (LPicoICONDIR
)HeapAlloc( GetProcessHeap(), 0, i
);
579 if( _lread32(hFile
,(char*)lpiID
->idEntries
,i
) == i
)
580 { HGLOBAL16 handle
= DirectResAlloc( hInst
, 0x10,
581 id
[2]*sizeof(ICONDIRENTRY
) + sizeof(id
) );
583 { CURSORICONDIR
* lpID
= (CURSORICONDIR
*)GlobalLock16( handle
);
584 lpID
->idReserved
= lpiID
->idReserved
= id
[0];
585 lpID
->idType
= lpiID
->idType
= id
[1];
586 lpID
->idCount
= lpiID
->idCount
= id
[2];
587 for( i
=0; i
< lpiID
->idCount
; i
++ )
588 { memcpy((void*)(lpID
->idEntries
+ i
),
589 (void*)(lpiID
->idEntries
+ i
), sizeof(ICONDIRENTRY
) - 2);
590 lpID
->idEntries
[i
].icon
.wResId
= i
;
598 HeapFree( GetProcessHeap(), 0, lpiID
);
602 /*************************************************************************
603 * InternalExtractIcon [SHELL.39]
605 * This abortion is called directly by Progman
607 HGLOBAL16 WINAPI
InternalExtractIcon(HINSTANCE16 hInstance
,
608 LPCSTR lpszExeFileName
, UINT16 nIconIndex
,
612 HGLOBAL16
* RetPtr
= NULL
;
616 HFILE32 hFile
= OpenFile32( lpszExeFileName
, &ofs
, OF_READ
);
617 UINT16 iconDirCount
= 0,iconCount
= 0;
619 TRACE(shell
,"(%04x,file %s,start %d,extract %d\n",
620 hInstance
, lpszExeFileName
, nIconIndex
, n
);
622 if( hFile
== HFILE_ERROR32
|| !n
)
625 hRet
= GlobalAlloc16( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(HICON16
)*n
);
626 RetPtr
= (HICON16
*)GlobalLock16(hRet
);
628 *RetPtr
= (n
== 0xFFFF)? 0: 1; /* error return values */
630 sig
= SHELL_GetResourceTable(hFile
,&pData
);
632 if((sig
== IMAGE_OS2_SIGNATURE
)
633 || (sig
== 1)) /* .ICO file */
636 NE_TYPEINFO
* pTInfo
= (NE_TYPEINFO
*)(pData
+ 2);
637 NE_NAMEINFO
* pIconStorage
= NULL
;
638 NE_NAMEINFO
* pIconDir
= NULL
;
639 LPicoICONDIR lpiID
= NULL
;
641 if( pData
== (BYTE
*)-1 )
643 /* check for .ICO file */
645 hIcon
= ICO_GetIconDirectory(hInstance
, hFile
, &lpiID
);
646 if( hIcon
) { iconDirCount
= 1; iconCount
= lpiID
->idCount
; }
648 else while( pTInfo
->type_id
&& !(pIconStorage
&& pIconDir
) )
650 /* find icon directory and icon repository */
652 if( pTInfo
->type_id
== NE_RSCTYPE_GROUP_ICON
)
654 iconDirCount
= pTInfo
->count
;
655 pIconDir
= ((NE_NAMEINFO
*)(pTInfo
+ 1));
656 TRACE(shell
,"\tfound directory - %i icon families\n", iconDirCount
);
658 if( pTInfo
->type_id
== NE_RSCTYPE_ICON
)
660 iconCount
= pTInfo
->count
;
661 pIconStorage
= ((NE_NAMEINFO
*)(pTInfo
+ 1));
662 TRACE(shell
,"\ttotal icons - %i\n", iconCount
);
664 pTInfo
= (NE_TYPEINFO
*)((char*)(pTInfo
+1)+pTInfo
->count
*sizeof(NE_NAMEINFO
));
667 /* load resources and create icons */
669 if( (pIconStorage
&& pIconDir
) || lpiID
)
670 if( nIconIndex
== (UINT16
)-1 ) RetPtr
[0] = iconDirCount
;
671 else if( nIconIndex
< iconDirCount
)
675 if( n
> iconDirCount
- nIconIndex
) n
= iconDirCount
- nIconIndex
;
677 for( i
= nIconIndex
; i
< nIconIndex
+ n
; i
++ )
679 /* .ICO files have only one icon directory */
682 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconDir
+ i
,
684 RetPtr
[i
-nIconIndex
] = GetIconID( hIcon
, 3 );
688 for( icon
= nIconIndex
; icon
< nIconIndex
+ n
; icon
++ )
692 hIcon
= ICO_LoadIcon( hInstance
, hFile
,
693 lpiID
->idEntries
+ RetPtr
[icon
-nIconIndex
]);
695 for( i
= 0; i
< iconCount
; i
++ )
696 if( pIconStorage
[i
].id
== (RetPtr
[icon
-nIconIndex
] | 0x8000) )
697 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconStorage
+ i
,
701 RetPtr
[icon
-nIconIndex
] = LoadIconHandler( hIcon
, TRUE
);
702 FarSetOwner( RetPtr
[icon
-nIconIndex
], GetExePtr(hInstance
) );
705 RetPtr
[icon
-nIconIndex
] = 0;
708 if( lpiID
) HeapFree( GetProcessHeap(), 0, lpiID
);
709 else HeapFree( GetProcessHeap(), 0, pData
);
711 if( sig
== IMAGE_NT_SIGNATURE
)
713 LPBYTE peimage
,idata
,igdata
;
714 PIMAGE_DOS_HEADER dheader
;
715 PIMAGE_NT_HEADERS pe_header
;
716 PIMAGE_SECTION_HEADER pe_sections
;
717 PIMAGE_RESOURCE_DIRECTORY rootresdir
,iconresdir
,icongroupresdir
;
718 PIMAGE_RESOURCE_DATA_ENTRY idataent
,igdataent
;
721 PIMAGE_RESOURCE_DIRECTORY_ENTRY xresent
;
722 CURSORICONDIR
**cids
;
724 fmapping
= CreateFileMapping32A(hFile
,NULL
,PAGE_READONLY
|SEC_COMMIT
,0,0,NULL
);
725 if (fmapping
== 0) { /* FIXME, INVALID_HANDLE_VALUE? */
726 WARN(shell
,"failed to create filemap.\n");
730 peimage
= MapViewOfFile(fmapping
,FILE_MAP_READ
,0,0,0);
732 WARN(shell
,"failed to mmap filemap.\n");
733 CloseHandle(fmapping
);
737 dheader
= (PIMAGE_DOS_HEADER
)peimage
;
738 /* it is a pe header, SHELL_GetResourceTable checked that */
739 pe_header
= (PIMAGE_NT_HEADERS
)(peimage
+dheader
->e_lfanew
);
740 /* probably makes problems with short PE headers... but I haven't seen
743 pe_sections
= (PIMAGE_SECTION_HEADER
)(((char*)pe_header
)+sizeof(*pe_header
));
745 for (i
=0;i
<pe_header
->FileHeader
.NumberOfSections
;i
++) {
746 if (pe_sections
[i
].Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
748 /* FIXME: doesn't work when the resources are not in a seperate section */
749 if (pe_sections
[i
].VirtualAddress
== pe_header
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_RESOURCE
].VirtualAddress
) {
750 rootresdir
= (PIMAGE_RESOURCE_DIRECTORY
)((char*)peimage
+pe_sections
[i
].PointerToRawData
);
756 WARN(shell
,"haven't found section for resource directory.\n");
757 UnmapViewOfFile(peimage
);
758 CloseHandle(fmapping
);
762 icongroupresdir
= GetResDirEntryW(rootresdir
,RT_GROUP_ICON32W
,
763 (DWORD
)rootresdir
,FALSE
);
764 if (!icongroupresdir
) {
765 WARN(shell
,"No Icongroupresourcedirectory!\n");
766 UnmapViewOfFile(peimage
);
767 CloseHandle(fmapping
);
772 iconDirCount
= icongroupresdir
->NumberOfNamedEntries
+icongroupresdir
->NumberOfIdEntries
;
773 if( nIconIndex
== (UINT16
)-1 ) {
774 RetPtr
[0] = iconDirCount
;
775 UnmapViewOfFile(peimage
);
776 CloseHandle(fmapping
);
781 if (nIconIndex
>= iconDirCount
) {
782 WARN(shell
,"nIconIndex %d is larger than iconDirCount %d\n",
783 nIconIndex
,iconDirCount
);
784 UnmapViewOfFile(peimage
);
785 CloseHandle(fmapping
);
790 cids
= (CURSORICONDIR
**)HeapAlloc(GetProcessHeap(),0,n
*sizeof(CURSORICONDIR
*));
792 /* caller just wanted the number of entries */
794 xresent
= (PIMAGE_RESOURCE_DIRECTORY_ENTRY
)(icongroupresdir
+1);
795 /* assure we don't get too much ... */
796 if( n
> iconDirCount
- nIconIndex
) n
= iconDirCount
- nIconIndex
;
798 /* starting from specified index ... */
799 xresent
= xresent
+nIconIndex
;
801 for (i
=0;i
<n
;i
++,xresent
++) {
803 PIMAGE_RESOURCE_DIRECTORY resdir
;
805 /* go down this resource entry, name */
806 resdir
= (PIMAGE_RESOURCE_DIRECTORY
)((DWORD
)rootresdir
+(xresent
->u2
.s
.OffsetToDirectory
));
807 /* default language (0) */
808 resdir
= GetResDirEntryW(resdir
,(LPWSTR
)0,(DWORD
)rootresdir
,TRUE
);
809 igdataent
= (PIMAGE_RESOURCE_DATA_ENTRY
)resdir
;
811 /* lookup address in mapped image for virtual address */
813 for (j
=0;j
<pe_header
->FileHeader
.NumberOfSections
;j
++) {
814 if (igdataent
->OffsetToData
< pe_sections
[j
].VirtualAddress
)
816 if (igdataent
->OffsetToData
+igdataent
->Size
> pe_sections
[j
].VirtualAddress
+pe_sections
[j
].SizeOfRawData
)
818 igdata
= peimage
+(igdataent
->OffsetToData
-pe_sections
[j
].VirtualAddress
+pe_sections
[j
].PointerToRawData
);
821 WARN(shell
,"no matching real address for icongroup!\n");
822 UnmapViewOfFile(peimage
);
823 CloseHandle(fmapping
);
828 cid
= (CURSORICONDIR
*)igdata
;
830 RetPtr
[i
] = LookupIconIdFromDirectoryEx32(igdata
,TRUE
,SYSMETRICS_CXICON
,SYSMETRICS_CYICON
,0);
832 iconresdir
=GetResDirEntryW(rootresdir
,RT_ICON32W
,
833 (DWORD
)rootresdir
,FALSE
);
835 WARN(shell
,"No Iconresourcedirectory!\n");
836 UnmapViewOfFile(peimage
);
837 CloseHandle(fmapping
);
842 PIMAGE_RESOURCE_DIRECTORY xresdir
;
844 xresdir
= GetResDirEntryW(iconresdir
,(LPWSTR
)RetPtr
[i
],(DWORD
)rootresdir
,FALSE
);
845 xresdir
= GetResDirEntryW(xresdir
,(LPWSTR
)0,(DWORD
)rootresdir
,TRUE
);
847 idataent
= (PIMAGE_RESOURCE_DATA_ENTRY
)xresdir
;
850 /* map virtual to address in image */
851 for (j
=0;j
<pe_header
->FileHeader
.NumberOfSections
;j
++) {
852 if (idataent
->OffsetToData
< pe_sections
[j
].VirtualAddress
)
854 if (idataent
->OffsetToData
+idataent
->Size
> pe_sections
[j
].VirtualAddress
+pe_sections
[j
].SizeOfRawData
)
856 idata
= peimage
+(idataent
->OffsetToData
-pe_sections
[j
].VirtualAddress
+pe_sections
[j
].PointerToRawData
);
859 WARN(shell
,"no matching real address found for icondata!\n");
863 RetPtr
[i
] = CreateIconFromResourceEx32(idata
,idataent
->Size
,TRUE
,0x00030000,SYSMETRICS_CXICON
,SYSMETRICS_CYICON
,0);
865 UnmapViewOfFile(peimage
);
866 CloseHandle(fmapping
);
871 /* return array with icon handles */
876 /*************************************************************************
877 * ExtractIcon16 (SHELL.34)
879 HICON16 WINAPI
ExtractIcon16( HINSTANCE16 hInstance
, LPCSTR lpszExeFileName
,
882 return ExtractIcon32A( hInstance
, lpszExeFileName
, nIconIndex
);
887 /*************************************************************************
888 * ExtractAssociatedIcon [SHELL.36]
890 * Return icon for given file (either from file itself or from associated
891 * executable) and patch parameters if needed.
893 HICON32 WINAPI
ExtractAssociatedIcon32A(HINSTANCE32 hInst
,LPSTR lpIconPath
,
896 return ExtractAssociatedIcon16(hInst
,lpIconPath
,lpiIcon
);
899 HICON16 WINAPI
ExtractAssociatedIcon16(HINSTANCE16 hInst
,LPSTR lpIconPath
,
905 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
908 { if( hIcon
== 1 ) /* no icons found in given file */
909 { char tempPath
[0x80];
910 UINT16 uRet
= FindExecutable16(lpIconPath
,NULL
,tempPath
);
912 if( uRet
> 32 && tempPath
[0] )
913 { strcpy(lpIconPath
,tempPath
);
914 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
922 *lpiIcon
= 2; /* MSDOS icon - we found .exe but no icons in it */
924 *lpiIcon
= 6; /* generic icon - found nothing */
926 GetModuleFileName16(hInst
, lpIconPath
, 0x80);
927 hIcon
= LoadIcon16( hInst
, MAKEINTRESOURCE16(*lpiIcon
));
932 /*************************************************************************
933 * FindEnvironmentString [SHELL.38]
935 * Returns a pointer into the DOS environment... Ugh.
937 LPSTR
SHELL_FindString(LPSTR lpEnv
, LPCSTR entry
)
943 for( ; *lpEnv
; lpEnv
+=strlen(lpEnv
)+1 )
944 { if( lstrncmpi32A(lpEnv
, entry
, l
) )
947 return (lpEnv
+ l
); /* empty entry */
948 else if ( *(lpEnv
+l
)== '=' )
949 return (lpEnv
+ l
+ 1);
954 SEGPTR WINAPI
FindEnvironmentString(LPSTR str
)
956 LPSTR lpEnv
,lpString
;
959 spEnv
= GetDOSEnvironment();
961 lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(spEnv
);
962 lpString
= (spEnv
)?SHELL_FindString(lpEnv
, str
):NULL
;
964 if( lpString
) /* offset should be small enough */
965 return spEnv
+ (lpString
- lpEnv
);
969 /*************************************************************************
970 * DoEnvironmentSubst [SHELL.37]
972 * Replace %KEYWORD% in the str with the value of variable KEYWORD
973 * from "DOS" environment.
975 DWORD WINAPI
DoEnvironmentSubst(LPSTR str
,WORD length
)
977 LPSTR lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(GetDOSEnvironment());
978 LPSTR lpBuffer
= (LPSTR
)HeapAlloc( GetProcessHeap(), 0, length
);
980 LPSTR lpbstr
= lpBuffer
;
982 CharToOem32A(str
,str
);
984 TRACE(shell
,"accept %s\n", str
);
986 while( *lpstr
&& lpbstr
- lpBuffer
< length
)
992 do { lpend
++; } while( *lpend
&& *lpend
!= '%' );
993 if( *lpend
== '%' && lpend
- lpstr
> 1 ) /* found key */
997 lpKey
= SHELL_FindString(lpEnv
, lpstr
+1);
998 if( lpKey
) /* found key value */
1000 int l
= strlen(lpKey
);
1002 if( l
> length
- (lpbstr
- lpBuffer
) - 1 )
1004 WARN(shell
,"-- Env subst aborted - string too short\n");
1008 strcpy(lpbstr
, lpKey
);
1015 else break; /* back off and whine */
1020 *lpbstr
++ = *lpstr
++;
1024 if( lpstr
- str
== strlen(str
) )
1026 strncpy(str
, lpBuffer
, length
);
1032 TRACE(shell
,"-- return %s\n", str
);
1034 OemToChar32A(str
,str
);
1035 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1037 /* Return str length in the LOWORD
1038 * and 1 in HIWORD if subst was successful.
1040 return (DWORD
)MAKELONG(strlen(str
), length
);
1043 /*************************************************************************
1044 * ShellHookProc [SHELL.103]
1045 * System-wide WH_SHELL hook.
1047 LRESULT WINAPI
ShellHookProc(INT16 code
, WPARAM16 wParam
, LPARAM lParam
)
1049 TRACE(shell
,"%i, %04x, %08x\n", code
, wParam
,
1051 if( SHELL_hHook
&& SHELL_hWnd
)
1056 case HSHELL_WINDOWCREATED
: uMsg
= uMsgWndCreated
; break;
1057 case HSHELL_WINDOWDESTROYED
: uMsg
= uMsgWndDestroyed
; break;
1058 case HSHELL_ACTIVATESHELLWINDOW
: uMsg
= uMsgShellActivate
;
1060 PostMessage16( SHELL_hWnd
, uMsg
, wParam
, 0 );
1062 return CallNextHookEx16( WH_SHELL
, code
, wParam
, lParam
);
1065 /*************************************************************************
1066 * RegisterShellHook [SHELL.102]
1068 BOOL32 WINAPI
RegisterShellHook(HWND16 hWnd
, UINT16 uAction
)
1069 { TRACE(shell
,"%04x [%u]\n", hWnd
, uAction
);
1072 { case 2: /* register hWnd as a shell window */
1074 { HMODULE16 hShell
= GetModuleHandle16( "SHELL" );
1075 SHELL_hHook
= SetWindowsHookEx16( WH_SHELL
, ShellHookProc
, hShell
, 0 );
1077 { uMsgWndCreated
= RegisterWindowMessage32A( lpstrMsgWndCreated
);
1078 uMsgWndDestroyed
= RegisterWindowMessage32A( lpstrMsgWndDestroyed
);
1079 uMsgShellActivate
= RegisterWindowMessage32A( lpstrMsgShellActivate
);
1082 WARN(shell
,"-- unable to install ShellHookProc()!\n");
1086 return ((SHELL_hWnd
= hWnd
) != 0);
1090 WARN(shell
, "-- unknown code %i\n", uAction
);