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
)
671 if( nIconIndex
== (UINT16
)-1 ) RetPtr
[0] = iconDirCount
;
672 else if( nIconIndex
< iconDirCount
)
676 if( n
> iconDirCount
- nIconIndex
) n
= iconDirCount
- nIconIndex
;
678 for( i
= nIconIndex
; i
< nIconIndex
+ n
; i
++ )
680 /* .ICO files have only one icon directory */
683 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconDir
+ i
,
685 RetPtr
[i
-nIconIndex
] = GetIconID( hIcon
, 3 );
689 for( icon
= nIconIndex
; icon
< nIconIndex
+ n
; icon
++ )
693 hIcon
= ICO_LoadIcon( hInstance
, hFile
,
694 lpiID
->idEntries
+ RetPtr
[icon
-nIconIndex
]);
696 for( i
= 0; i
< iconCount
; i
++ )
697 if( pIconStorage
[i
].id
== (RetPtr
[icon
-nIconIndex
] | 0x8000) )
698 hIcon
= SHELL_LoadResource( hInstance
, hFile
, pIconStorage
+ i
,
702 RetPtr
[icon
-nIconIndex
] = LoadIconHandler( hIcon
, TRUE
);
703 FarSetOwner( RetPtr
[icon
-nIconIndex
], GetExePtr(hInstance
) );
706 RetPtr
[icon
-nIconIndex
] = 0;
710 if( lpiID
) HeapFree( GetProcessHeap(), 0, lpiID
);
711 else HeapFree( GetProcessHeap(), 0, pData
);
713 if( sig
== IMAGE_NT_SIGNATURE
)
715 LPBYTE peimage
,idata
,igdata
;
716 PIMAGE_DOS_HEADER dheader
;
717 PIMAGE_NT_HEADERS pe_header
;
718 PIMAGE_SECTION_HEADER pe_sections
;
719 PIMAGE_RESOURCE_DIRECTORY rootresdir
,iconresdir
,icongroupresdir
;
720 PIMAGE_RESOURCE_DATA_ENTRY idataent
,igdataent
;
723 PIMAGE_RESOURCE_DIRECTORY_ENTRY xresent
;
724 CURSORICONDIR
**cids
;
726 fmapping
= CreateFileMapping32A(hFile
,NULL
,PAGE_READONLY
|SEC_COMMIT
,0,0,NULL
);
727 if (fmapping
== 0) { /* FIXME, INVALID_HANDLE_VALUE? */
728 WARN(shell
,"failed to create filemap.\n");
732 peimage
= MapViewOfFile(fmapping
,FILE_MAP_READ
,0,0,0);
734 WARN(shell
,"failed to mmap filemap.\n");
735 CloseHandle(fmapping
);
739 dheader
= (PIMAGE_DOS_HEADER
)peimage
;
740 /* it is a pe header, SHELL_GetResourceTable checked that */
741 pe_header
= (PIMAGE_NT_HEADERS
)(peimage
+dheader
->e_lfanew
);
742 /* probably makes problems with short PE headers... but I haven't seen
745 pe_sections
= (PIMAGE_SECTION_HEADER
)(((char*)pe_header
)+sizeof(*pe_header
));
747 for (i
=0;i
<pe_header
->FileHeader
.NumberOfSections
;i
++) {
748 if (pe_sections
[i
].Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
750 /* FIXME: doesn't work when the resources are not in a seperate section */
751 if (pe_sections
[i
].VirtualAddress
== pe_header
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_RESOURCE
].VirtualAddress
) {
752 rootresdir
= (PIMAGE_RESOURCE_DIRECTORY
)((char*)peimage
+pe_sections
[i
].PointerToRawData
);
758 WARN(shell
,"haven't found section for resource directory.\n");
759 UnmapViewOfFile(peimage
);
760 CloseHandle(fmapping
);
764 icongroupresdir
= GetResDirEntryW(rootresdir
,RT_GROUP_ICON32W
,
765 (DWORD
)rootresdir
,FALSE
);
766 if (!icongroupresdir
) {
767 WARN(shell
,"No Icongroupresourcedirectory!\n");
768 UnmapViewOfFile(peimage
);
769 CloseHandle(fmapping
);
774 iconDirCount
= icongroupresdir
->NumberOfNamedEntries
+icongroupresdir
->NumberOfIdEntries
;
775 if( nIconIndex
== (UINT16
)-1 ) {
776 RetPtr
[0] = iconDirCount
;
777 UnmapViewOfFile(peimage
);
778 CloseHandle(fmapping
);
783 if (nIconIndex
>= iconDirCount
) {
784 WARN(shell
,"nIconIndex %d is larger than iconDirCount %d\n",
785 nIconIndex
,iconDirCount
);
786 UnmapViewOfFile(peimage
);
787 CloseHandle(fmapping
);
792 cids
= (CURSORICONDIR
**)HeapAlloc(GetProcessHeap(),0,n
*sizeof(CURSORICONDIR
*));
794 /* caller just wanted the number of entries */
796 xresent
= (PIMAGE_RESOURCE_DIRECTORY_ENTRY
)(icongroupresdir
+1);
797 /* assure we don't get too much ... */
798 if( n
> iconDirCount
- nIconIndex
) n
= iconDirCount
- nIconIndex
;
800 /* starting from specified index ... */
801 xresent
= xresent
+nIconIndex
;
803 for (i
=0;i
<n
;i
++,xresent
++) {
805 PIMAGE_RESOURCE_DIRECTORY resdir
;
807 /* go down this resource entry, name */
808 resdir
= (PIMAGE_RESOURCE_DIRECTORY
)((DWORD
)rootresdir
+(xresent
->u2
.s
.OffsetToDirectory
));
809 /* default language (0) */
810 resdir
= GetResDirEntryW(resdir
,(LPWSTR
)0,(DWORD
)rootresdir
,TRUE
);
811 igdataent
= (PIMAGE_RESOURCE_DATA_ENTRY
)resdir
;
813 /* lookup address in mapped image for virtual address */
815 for (j
=0;j
<pe_header
->FileHeader
.NumberOfSections
;j
++) {
816 if (igdataent
->OffsetToData
< pe_sections
[j
].VirtualAddress
)
818 if (igdataent
->OffsetToData
+igdataent
->Size
> pe_sections
[j
].VirtualAddress
+pe_sections
[j
].SizeOfRawData
)
820 igdata
= peimage
+(igdataent
->OffsetToData
-pe_sections
[j
].VirtualAddress
+pe_sections
[j
].PointerToRawData
);
823 WARN(shell
,"no matching real address for icongroup!\n");
824 UnmapViewOfFile(peimage
);
825 CloseHandle(fmapping
);
830 cid
= (CURSORICONDIR
*)igdata
;
832 RetPtr
[i
] = LookupIconIdFromDirectoryEx32(igdata
,TRUE
,SYSMETRICS_CXICON
,SYSMETRICS_CYICON
,0);
834 iconresdir
=GetResDirEntryW(rootresdir
,RT_ICON32W
,
835 (DWORD
)rootresdir
,FALSE
);
837 WARN(shell
,"No Iconresourcedirectory!\n");
838 UnmapViewOfFile(peimage
);
839 CloseHandle(fmapping
);
844 PIMAGE_RESOURCE_DIRECTORY xresdir
;
846 xresdir
= GetResDirEntryW(iconresdir
,(LPWSTR
)RetPtr
[i
],(DWORD
)rootresdir
,FALSE
);
847 xresdir
= GetResDirEntryW(xresdir
,(LPWSTR
)0,(DWORD
)rootresdir
,TRUE
);
849 idataent
= (PIMAGE_RESOURCE_DATA_ENTRY
)xresdir
;
852 /* map virtual to address in image */
853 for (j
=0;j
<pe_header
->FileHeader
.NumberOfSections
;j
++) {
854 if (idataent
->OffsetToData
< pe_sections
[j
].VirtualAddress
)
856 if (idataent
->OffsetToData
+idataent
->Size
> pe_sections
[j
].VirtualAddress
+pe_sections
[j
].SizeOfRawData
)
858 idata
= peimage
+(idataent
->OffsetToData
-pe_sections
[j
].VirtualAddress
+pe_sections
[j
].PointerToRawData
);
861 WARN(shell
,"no matching real address found for icondata!\n");
865 RetPtr
[i
] = CreateIconFromResourceEx32(idata
,idataent
->Size
,TRUE
,0x00030000,SYSMETRICS_CXICON
,SYSMETRICS_CYICON
,0);
867 UnmapViewOfFile(peimage
);
868 CloseHandle(fmapping
);
873 /* return array with icon handles */
878 /*************************************************************************
879 * ExtractIcon16 (SHELL.34)
881 HICON16 WINAPI
ExtractIcon16( HINSTANCE16 hInstance
, LPCSTR lpszExeFileName
,
884 return ExtractIcon32A( hInstance
, lpszExeFileName
, nIconIndex
);
889 /*************************************************************************
890 * ExtractAssociatedIcon [SHELL.36]
892 * Return icon for given file (either from file itself or from associated
893 * executable) and patch parameters if needed.
895 HICON32 WINAPI
ExtractAssociatedIcon32A(HINSTANCE32 hInst
,LPSTR lpIconPath
,
898 return ExtractAssociatedIcon16(hInst
,lpIconPath
,lpiIcon
);
901 HICON16 WINAPI
ExtractAssociatedIcon16(HINSTANCE16 hInst
,LPSTR lpIconPath
,
907 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
910 { if( hIcon
== 1 ) /* no icons found in given file */
911 { char tempPath
[0x80];
912 UINT16 uRet
= FindExecutable16(lpIconPath
,NULL
,tempPath
);
914 if( uRet
> 32 && tempPath
[0] )
915 { strcpy(lpIconPath
,tempPath
);
916 hIcon
= ExtractIcon16(hInst
, lpIconPath
, *lpiIcon
);
924 *lpiIcon
= 2; /* MSDOS icon - we found .exe but no icons in it */
926 *lpiIcon
= 6; /* generic icon - found nothing */
928 GetModuleFileName16(hInst
, lpIconPath
, 0x80);
929 hIcon
= LoadIcon16( hInst
, MAKEINTRESOURCE16(*lpiIcon
));
934 /*************************************************************************
935 * FindEnvironmentString [SHELL.38]
937 * Returns a pointer into the DOS environment... Ugh.
939 LPSTR
SHELL_FindString(LPSTR lpEnv
, LPCSTR entry
)
945 for( ; *lpEnv
; lpEnv
+=strlen(lpEnv
)+1 )
946 { if( lstrncmpi32A(lpEnv
, entry
, l
) )
949 return (lpEnv
+ l
); /* empty entry */
950 else if ( *(lpEnv
+l
)== '=' )
951 return (lpEnv
+ l
+ 1);
956 SEGPTR WINAPI
FindEnvironmentString(LPSTR str
)
958 LPSTR lpEnv
,lpString
;
961 spEnv
= GetDOSEnvironment();
963 lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(spEnv
);
964 lpString
= (spEnv
)?SHELL_FindString(lpEnv
, str
):NULL
;
966 if( lpString
) /* offset should be small enough */
967 return spEnv
+ (lpString
- lpEnv
);
971 /*************************************************************************
972 * DoEnvironmentSubst [SHELL.37]
974 * Replace %KEYWORD% in the str with the value of variable KEYWORD
975 * from "DOS" environment.
977 DWORD WINAPI
DoEnvironmentSubst(LPSTR str
,WORD length
)
979 LPSTR lpEnv
= (LPSTR
)PTR_SEG_TO_LIN(GetDOSEnvironment());
980 LPSTR lpBuffer
= (LPSTR
)HeapAlloc( GetProcessHeap(), 0, length
);
982 LPSTR lpbstr
= lpBuffer
;
984 CharToOem32A(str
,str
);
986 TRACE(shell
,"accept %s\n", str
);
988 while( *lpstr
&& lpbstr
- lpBuffer
< length
)
994 do { lpend
++; } while( *lpend
&& *lpend
!= '%' );
995 if( *lpend
== '%' && lpend
- lpstr
> 1 ) /* found key */
999 lpKey
= SHELL_FindString(lpEnv
, lpstr
+1);
1000 if( lpKey
) /* found key value */
1002 int l
= strlen(lpKey
);
1004 if( l
> length
- (lpbstr
- lpBuffer
) - 1 )
1006 WARN(shell
,"-- Env subst aborted - string too short\n");
1010 strcpy(lpbstr
, lpKey
);
1017 else break; /* back off and whine */
1022 *lpbstr
++ = *lpstr
++;
1026 if( lpstr
- str
== strlen(str
) )
1028 strncpy(str
, lpBuffer
, length
);
1034 TRACE(shell
,"-- return %s\n", str
);
1036 OemToChar32A(str
,str
);
1037 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1039 /* Return str length in the LOWORD
1040 * and 1 in HIWORD if subst was successful.
1042 return (DWORD
)MAKELONG(strlen(str
), length
);
1045 /*************************************************************************
1046 * ShellHookProc [SHELL.103]
1047 * System-wide WH_SHELL hook.
1049 LRESULT WINAPI
ShellHookProc(INT16 code
, WPARAM16 wParam
, LPARAM lParam
)
1051 TRACE(shell
,"%i, %04x, %08x\n", code
, wParam
,
1053 if( SHELL_hHook
&& SHELL_hWnd
)
1058 case HSHELL_WINDOWCREATED
: uMsg
= uMsgWndCreated
; break;
1059 case HSHELL_WINDOWDESTROYED
: uMsg
= uMsgWndDestroyed
; break;
1060 case HSHELL_ACTIVATESHELLWINDOW
: uMsg
= uMsgShellActivate
;
1062 PostMessage16( SHELL_hWnd
, uMsg
, wParam
, 0 );
1064 return CallNextHookEx16( WH_SHELL
, code
, wParam
, lParam
);
1067 /*************************************************************************
1068 * RegisterShellHook [SHELL.102]
1070 BOOL32 WINAPI
RegisterShellHook(HWND16 hWnd
, UINT16 uAction
)
1071 { TRACE(shell
,"%04x [%u]\n", hWnd
, uAction
);
1074 { case 2: /* register hWnd as a shell window */
1076 { HMODULE16 hShell
= GetModuleHandle16( "SHELL" );
1077 SHELL_hHook
= SetWindowsHookEx16( WH_SHELL
, ShellHookProc
, hShell
, 0 );
1079 { uMsgWndCreated
= RegisterWindowMessage32A( lpstrMsgWndCreated
);
1080 uMsgWndDestroyed
= RegisterWindowMessage32A( lpstrMsgWndDestroyed
);
1081 uMsgShellActivate
= RegisterWindowMessage32A( lpstrMsgShellActivate
);
1084 WARN(shell
,"-- unable to install ShellHookProc()!\n");
1088 return ((SHELL_hWnd
= hWnd
) != 0);
1092 WARN(shell
, "-- unknown code %i\n", uAction
);