4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
11 #include <sys/types.h>
19 #include "wine/winbase16.h"
20 #include "wine/winuser16.h"
25 #include "cursoricon.h"
31 #include "debugtools.h"
35 DEFAULT_DEBUG_CHANNEL(resource
);
36 DECLARE_DEBUG_CHANNEL(accel
);
38 extern WORD WINE_LanguageId
;
40 #define HRSRC_MAP_BLOCKSIZE 16
42 typedef struct _HRSRC_ELEM
48 typedef struct _HRSRC_MAP
55 /**********************************************************************
58 static HRSRC16
MapHRsrc32To16( NE_MODULE
*pModule
, HANDLE hRsrc32
, WORD type
)
60 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
64 /* On first call, initialize HRSRC map */
67 if ( !(map
= (HRSRC_MAP
*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
68 sizeof(HRSRC_MAP
) ) ) )
70 ERR("Cannot allocate HRSRC map\n" );
73 pModule
->hRsrcMap
= (LPVOID
)map
;
76 /* Check whether HRSRC32 already in map */
77 for ( i
= 0; i
< map
->nUsed
; i
++ )
78 if ( map
->elem
[i
].hRsrc
== hRsrc32
)
79 return (HRSRC16
)(i
+ 1);
81 /* If no space left, grow table */
82 if ( map
->nUsed
== map
->nAlloc
)
84 if ( !(newElem
= (HRSRC_ELEM
*)HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
86 (map
->nAlloc
+ HRSRC_MAP_BLOCKSIZE
)
87 * sizeof(HRSRC_ELEM
) ) ))
89 ERR("Cannot grow HRSRC map\n" );
93 map
->nAlloc
+= HRSRC_MAP_BLOCKSIZE
;
96 /* Add HRSRC32 to table */
97 map
->elem
[map
->nUsed
].hRsrc
= hRsrc32
;
98 map
->elem
[map
->nUsed
].type
= type
;
101 return (HRSRC16
)map
->nUsed
;
104 /**********************************************************************
107 static HANDLE
MapHRsrc16To32( NE_MODULE
*pModule
, HRSRC16 hRsrc16
)
109 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
110 if ( !map
|| !hRsrc16
|| (int)hRsrc16
> map
->nUsed
) return 0;
112 return map
->elem
[(int)hRsrc16
-1].hRsrc
;
115 /**********************************************************************
118 static WORD
MapHRsrc16ToType( NE_MODULE
*pModule
, HRSRC16 hRsrc16
)
120 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
121 if ( !map
|| !hRsrc16
|| (int)hRsrc16
> map
->nUsed
) return 0;
123 return map
->elem
[(int)hRsrc16
-1].type
;
127 /**********************************************************************
130 static HRSRC
RES_FindResource( HMODULE hModule
, LPCSTR type
,
131 LPCSTR name
, WORD lang
,
132 BOOL bUnicode
, BOOL bRet16
)
136 HMODULE16 hMod16
= MapHModuleLS( hModule
);
137 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
138 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
139 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
141 TRACE("(%08x %s, %08x%s, %08x%s, %04x, %s, %s)\n",
143 pModule
? (char *)NE_MODULE_NAME(pModule
) : "NULL dereference",
144 (UINT
)type
, HIWORD(type
)? (bUnicode
? debugstr_w((LPWSTR
)type
) : debugstr_a(type
)) : "",
145 (UINT
)name
, HIWORD(name
)? (bUnicode
? debugstr_w((LPWSTR
)name
) : debugstr_a(name
)) : "",
148 bRet16
? "NE" : "PE" );
150 if ( !pModule
) return 0;
154 /* 32-bit PE module */
155 LPWSTR typeStr
, nameStr
;
157 if ( HIWORD( type
) && !bUnicode
)
158 typeStr
= HEAP_strdupAtoW( GetProcessHeap(), 0, type
);
160 typeStr
= (LPWSTR
)type
;
161 if ( HIWORD( name
) && !bUnicode
)
162 nameStr
= HEAP_strdupAtoW( GetProcessHeap(), 0, name
);
164 nameStr
= (LPWSTR
)name
;
166 hRsrc
= PE_FindResourceExW( wm
, nameStr
, typeStr
, lang
);
168 if ( HIWORD( type
) && !bUnicode
)
169 HeapFree( GetProcessHeap(), 0, typeStr
);
170 if ( HIWORD( name
) && !bUnicode
)
171 HeapFree( GetProcessHeap(), 0, nameStr
);
174 /* If we need to return 16-bit HRSRC, perform conversion */
176 hRsrc
= MapHRsrc32To16( pModule
, hRsrc
,
177 HIWORD( type
)? 0 : LOWORD( type
) );
181 /* 16-bit NE module */
182 LPSTR typeStr
, nameStr
;
184 if ( HIWORD( type
) && bUnicode
)
185 typeStr
= HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)type
);
187 typeStr
= (LPSTR
)type
;
188 if ( HIWORD( name
) && bUnicode
)
189 nameStr
= HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)name
);
191 nameStr
= (LPSTR
)name
;
193 hRsrc
= NE_FindResource( pModule
, nameStr
, typeStr
);
195 if ( HIWORD( type
) && bUnicode
)
196 HeapFree( GetProcessHeap(), 0, typeStr
);
197 if ( HIWORD( name
) && bUnicode
)
198 HeapFree( GetProcessHeap(), 0, nameStr
);
201 /* If we need to return 32-bit HRSRC, no conversion is necessary,
202 we simply use the 16-bit HRSRC as 32-bit HRSRC */
208 /**********************************************************************
211 static DWORD
RES_SizeofResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
215 HMODULE16 hMod16
= MapHModuleLS( hModule
);
216 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
217 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
218 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
220 TRACE("(%08x %s, %08x, %s)\n",
221 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
223 if ( !pModule
|| !hRsrc
) return 0;
227 /* 32-bit PE module */
229 /* If we got a 16-bit hRsrc, convert it */
230 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
232 size
= PE_SizeofResource( hModule
, hRsrc32
);
236 /* 16-bit NE module */
238 /* If we got a 32-bit hRsrc, we don't need to convert it */
240 size
= NE_SizeofResource( pModule
, hRsrc
);
246 /**********************************************************************
249 static HFILE
RES_AccessResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
251 HFILE hFile
= HFILE_ERROR
;
253 HMODULE16 hMod16
= MapHModuleLS( hModule
);
254 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
255 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
256 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
258 TRACE("(%08x %s, %08x, %s)\n",
259 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
261 if ( !pModule
|| !hRsrc
) return HFILE_ERROR
;
265 /* 32-bit PE module */
267 /* If we got a 16-bit hRsrc, convert it */
268 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
271 FIXME("32-bit modules not yet supported.\n" );
274 /* If we need to return a 16-bit file handle, convert it */
276 hFile
= FILE_AllocDosHandle( hFile
);
280 /* 16-bit NE module */
282 /* If we got a 32-bit hRsrc, we don't need to convert it */
284 hFile
= NE_AccessResource( pModule
, hRsrc
);
286 /* If we are to return a 32-bit file handle, convert it */
288 hFile
= FILE_GetHandle( hFile
);
294 /**********************************************************************
297 static HGLOBAL
RES_LoadResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
301 HMODULE16 hMod16
= MapHModuleLS( hModule
);
302 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
303 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
304 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
306 TRACE("(%08x %s, %08x, %s)\n",
307 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
309 if ( !pModule
|| !hRsrc
) return 0;
313 /* 32-bit PE module */
315 /* If we got a 16-bit hRsrc, convert it */
316 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
318 hMem
= PE_LoadResource( wm
, hRsrc32
);
320 /* If we need to return a 16-bit resource, convert it */
323 WORD type
= MapHRsrc16ToType( pModule
, hRsrc
);
324 DWORD size
= SizeofResource( hModule
, hRsrc
);
325 LPVOID bits
= LockResource( hMem
);
327 hMem
= NE_LoadPEResource( pModule
, type
, bits
, size
);
332 /* 16-bit NE module */
334 /* If we got a 32-bit hRsrc, we don't need to convert it */
336 hMem
= NE_LoadResource( pModule
, hRsrc
);
338 /* If we are to return a 32-bit resource, we should probably
339 convert it but we don't for now. FIXME !!! */
345 /**********************************************************************
348 static LPVOID
RES_LockResource( HGLOBAL handle
, BOOL bRet16
)
352 TRACE("(%08x, %s)\n", handle
, bRet16
? "NE" : "PE" );
354 if ( HIWORD( handle
) )
356 /* 32-bit memory handle */
359 FIXME("can't return SEGPTR to 32-bit resource %08x.\n", handle
);
361 bits
= (LPVOID
)handle
;
365 /* 16-bit memory handle */
367 /* May need to reload the resource if discarded */
368 SEGPTR segPtr
= WIN16_GlobalLock16( handle
);
371 bits
= (LPVOID
)segPtr
;
373 bits
= PTR_SEG_TO_LIN( segPtr
);
379 /**********************************************************************
382 static BOOL
RES_FreeResource( HGLOBAL handle
)
384 HGLOBAL retv
= handle
;
386 TRACE("(%08x)\n", handle
);
388 if ( HIWORD( handle
) )
390 /* 32-bit memory handle: nothing to do */
394 /* 16-bit memory handle */
395 NE_MODULE
*pModule
= NE_GetPtr( FarGetOwner16( handle
) );
397 /* Try NE resource first */
398 retv
= NE_FreeResource( pModule
, handle
);
400 /* If this failed, call USER.DestroyIcon32; this will check
401 whether it is a shared cursor/icon; if not it will call
404 if ( Callout
.DestroyIcon32
)
405 retv
= Callout
.DestroyIcon32( handle
, CID_RESOURCE
);
407 retv
= GlobalFree16( handle
);
415 /**********************************************************************
416 * FindResource16 (KERNEL.60)
418 HRSRC16 WINAPI
FindResource16( HMODULE16 hModule
, SEGPTR name
, SEGPTR type
)
420 LPCSTR nameStr
= HIWORD(name
)? PTR_SEG_TO_LIN(name
) : (LPCSTR
)name
;
421 LPCSTR typeStr
= HIWORD(type
)? PTR_SEG_TO_LIN(type
) : (LPCSTR
)type
;
423 return RES_FindResource( hModule
, typeStr
, nameStr
,
424 WINE_LanguageId
, FALSE
, TRUE
);
427 /**********************************************************************
428 * FindResourceA (KERNEL32.128)
430 HANDLE WINAPI
FindResourceA( HMODULE hModule
, LPCSTR name
, LPCSTR type
)
432 return RES_FindResource( hModule
, type
, name
,
433 WINE_LanguageId
, FALSE
, FALSE
);
436 /**********************************************************************
437 * FindResourceExA (KERNEL32.129)
439 HANDLE WINAPI
FindResourceExA( HMODULE hModule
,
440 LPCSTR type
, LPCSTR name
, WORD lang
)
442 return RES_FindResource( hModule
, type
, name
,
443 lang
, FALSE
, FALSE
);
446 /**********************************************************************
447 * FindResourceExW (KERNEL32.130)
449 HRSRC WINAPI
FindResourceExW( HMODULE hModule
,
450 LPCWSTR type
, LPCWSTR name
, WORD lang
)
452 return RES_FindResource( hModule
, (LPCSTR
)type
, (LPCSTR
)name
,
456 /**********************************************************************
457 * FindResourceW (KERNEL32.131)
459 HRSRC WINAPI
FindResourceW(HINSTANCE hModule
, LPCWSTR name
, LPCWSTR type
)
461 return RES_FindResource( hModule
, (LPCSTR
)type
, (LPCSTR
)name
,
462 WINE_LanguageId
, TRUE
, FALSE
);
465 /**********************************************************************
466 * LoadResource16 (KERNEL.61)
468 HGLOBAL16 WINAPI
LoadResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
470 return RES_LoadResource( hModule
, hRsrc
, TRUE
);
473 /**********************************************************************
474 * LoadResource (KERNEL32.370)
476 HGLOBAL WINAPI
LoadResource( HINSTANCE hModule
, HRSRC hRsrc
)
478 return RES_LoadResource( hModule
, hRsrc
, FALSE
);
481 /**********************************************************************
482 * LockResource16 (KERNEL.62)
484 SEGPTR WINAPI
WIN16_LockResource16( HGLOBAL16 handle
)
486 return (SEGPTR
)RES_LockResource( handle
, TRUE
);
488 LPVOID WINAPI
LockResource16( HGLOBAL16 handle
)
490 return RES_LockResource( handle
, FALSE
);
493 /**********************************************************************
494 * LockResource (KERNEL32.384)
496 LPVOID WINAPI
LockResource( HGLOBAL handle
)
498 return RES_LockResource( handle
, FALSE
);
501 /**********************************************************************
502 * FreeResource16 (KERNEL.63)
504 BOOL16 WINAPI
FreeResource16( HGLOBAL16 handle
)
506 return RES_FreeResource( handle
);
509 /**********************************************************************
510 * FreeResource (KERNEL32.145)
512 BOOL WINAPI
FreeResource( HGLOBAL handle
)
514 return RES_FreeResource( handle
);
517 /**********************************************************************
518 * AccessResource16 (KERNEL.64)
520 INT16 WINAPI
AccessResource16( HINSTANCE16 hModule
, HRSRC16 hRsrc
)
522 return RES_AccessResource( hModule
, hRsrc
, TRUE
);
525 /**********************************************************************
526 * AccessResource (KERNEL32.64)
528 INT WINAPI
AccessResource( HMODULE hModule
, HRSRC hRsrc
)
530 return RES_AccessResource( hModule
, hRsrc
, FALSE
);
533 /**********************************************************************
534 * SizeofResource16 (KERNEL.65)
536 DWORD WINAPI
SizeofResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
538 return RES_SizeofResource( hModule
, hRsrc
, TRUE
);
541 /**********************************************************************
542 * SizeofResource (KERNEL32.522)
544 DWORD WINAPI
SizeofResource( HINSTANCE hModule
, HRSRC hRsrc
)
546 return RES_SizeofResource( hModule
, hRsrc
, FALSE
);
551 /**********************************************************************
552 * LoadAccelerators16 [USER.177]
554 HACCEL16 WINAPI
LoadAccelerators16(HINSTANCE16 instance
, SEGPTR lpTableName
)
558 if (HIWORD(lpTableName
))
559 TRACE_(accel
)("%04x '%s'\n",
560 instance
, (char *)PTR_SEG_TO_LIN( lpTableName
) );
562 TRACE_(accel
)("%04x %04x\n",
563 instance
, LOWORD(lpTableName
) );
565 if (!(hRsrc
= FindResource16( instance
, lpTableName
, RT_ACCELERATOR16
))) {
566 WARN_(accel
)("couldn't find accelerator table resource\n");
570 TRACE_(accel
)("returning HACCEL 0x%x\n", hRsrc
);
571 return LoadResource16(instance
,hRsrc
);
574 /**********************************************************************
575 * LoadAcceleratorsW [USER.177]
576 * The image layout seems to look like this (not 100% sure):
577 * 00: BYTE type type of accelerator
578 * 01: BYTE pad (to WORD boundary)
581 * 06: WORD pad (to DWORD boundary)
583 HACCEL WINAPI
LoadAcceleratorsW(HINSTANCE instance
,LPCWSTR lpTableName
)
586 HACCEL hMem
,hRetval
=0;
589 if (HIWORD(lpTableName
))
590 TRACE_(accel
)("%p '%s'\n",
591 (LPVOID
)instance
, (char *)( lpTableName
) );
593 TRACE_(accel
)("%p 0x%04x\n",
594 (LPVOID
)instance
, LOWORD(lpTableName
) );
596 if (!(hRsrc
= FindResourceW( instance
, lpTableName
, RT_ACCELERATORW
)))
598 WARN_(accel
)("couldn't find accelerator table resource\n");
600 hMem
= LoadResource( instance
, hRsrc
);
601 size
= SizeofResource( instance
, hRsrc
);
602 if(size
>=sizeof(PE_ACCEL
))
604 LPPE_ACCEL accel_table
= (LPPE_ACCEL
) hMem
;
606 int i
,nrofaccells
= size
/sizeof(PE_ACCEL
);
608 hRetval
= GlobalAlloc16(0,sizeof(ACCEL16
)*nrofaccells
);
609 accel16
= (LPACCEL16
)GlobalLock16(hRetval
);
610 for (i
=0;i
<nrofaccells
;i
++) {
611 accel16
[i
].fVirt
= accel_table
[i
].fVirt
;
612 accel16
[i
].key
= accel_table
[i
].key
;
613 accel16
[i
].cmd
= accel_table
[i
].cmd
;
615 accel16
[i
-1].fVirt
|= 0x80;
618 TRACE_(accel
)("returning HACCEL 0x%x\n", hRsrc
);
622 /***********************************************************************
625 HACCEL WINAPI
LoadAcceleratorsA(HINSTANCE instance
,LPCSTR lpTableName
)
629 if (HIWORD(lpTableName
))
630 uni
= HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName
);
632 uni
= (LPWSTR
)lpTableName
;
633 result
= LoadAcceleratorsW(instance
,uni
);
634 if (HIWORD(uni
)) HeapFree( GetProcessHeap(), 0, uni
);
638 /**********************************************************************
639 * CopyAcceleratorTableA (USER32.58)
641 INT WINAPI
CopyAcceleratorTableA(HACCEL src
, LPACCEL dst
, INT entries
)
643 return CopyAcceleratorTableW(src
, dst
, entries
);
646 /**********************************************************************
647 * CopyAcceleratorTableW (USER32.59)
649 * By mortene@pvv.org 980321
651 INT WINAPI
CopyAcceleratorTableW(HACCEL src
, LPACCEL dst
,
655 LPACCEL16 accel
= (LPACCEL16
)GlobalLock16(src
);
658 /* Do parameter checking to avoid the explosions and the screaming
659 as far as possible. */
660 if((dst
&& (entries
< 1)) || (src
== (HACCEL
)NULL
) || !accel
) {
661 WARN_(accel
)("Application sent invalid parameters (%p %p %d).\n",
662 (LPVOID
)src
, (LPVOID
)dst
, entries
);
665 xsize
= GlobalSize16(src
)/sizeof(ACCEL16
);
666 if (xsize
>entries
) entries
=xsize
;
670 /* Spit out some debugging information. */
671 TRACE_(accel
)("accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
672 i
, accel
[i
].fVirt
, accel
[i
].key
, accel
[i
].cmd
);
674 /* Copy data to the destination structure array (if dst == NULL,
675 we're just supposed to count the number of entries). */
677 dst
[i
].fVirt
= accel
[i
].fVirt
;
678 dst
[i
].key
= accel
[i
].key
;
679 dst
[i
].cmd
= accel
[i
].cmd
;
681 /* Check if we've reached the end of the application supplied
682 accelerator table. */
684 /* Turn off the high order bit, just in case. */
685 dst
[i
].fVirt
&= 0x7f;
690 /* The highest order bit seems to mark the end of the accelerator
691 resource table, but not always. Use GlobalSize() check too. */
692 if((accel
[i
].fVirt
& 0x80) != 0) done
= TRUE
;
700 /*********************************************************************
701 * CreateAcceleratorTableA (USER32.64)
703 * By mortene@pvv.org 980321
705 HACCEL WINAPI
CreateAcceleratorTableA(LPACCEL lpaccel
, INT cEntries
)
711 /* Do parameter checking just in case someone's trying to be
714 WARN_(accel
)("Application sent invalid parameters (%p %d).\n",
716 SetLastError(ERROR_INVALID_PARAMETER
);
719 FIXME_(accel
)("should check that the accelerator descriptions are valid,"
720 " return NULL and SetLastError() if not.\n");
723 /* Allocate memory and copy the table. */
724 hAccel
= GlobalAlloc16(0,cEntries
*sizeof(ACCEL16
));
726 TRACE_(accel
)("handle %x\n", hAccel
);
728 ERR_(accel
)("Out of memory.\n");
729 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
732 accel
= GlobalLock16(hAccel
);
733 for (i
=0;i
<cEntries
;i
++) {
734 accel
[i
].fVirt
= lpaccel
[i
].fVirt
;
735 accel
[i
].key
= lpaccel
[i
].key
;
736 accel
[i
].cmd
= lpaccel
[i
].cmd
;
738 /* Set the end-of-table terminator. */
739 accel
[cEntries
-1].fVirt
|= 0x80;
741 TRACE_(accel
)("Allocated accelerator handle %x\n", hAccel
);
745 /*********************************************************************
746 * CreateAcceleratorTableW (USER32.64)
750 HACCEL WINAPI
CreateAcceleratorTableW(LPACCEL lpaccel
, INT cEntries
)
757 /* Do parameter checking just in case someone's trying to be
760 WARN_(accel
)("Application sent invalid parameters (%p %d).\n",
762 SetLastError(ERROR_INVALID_PARAMETER
);
765 FIXME_(accel
)("should check that the accelerator descriptions are valid,"
766 " return NULL and SetLastError() if not.\n");
769 /* Allocate memory and copy the table. */
770 hAccel
= GlobalAlloc16(0,cEntries
*sizeof(ACCEL16
));
772 TRACE_(accel
)("handle %x\n", hAccel
);
774 ERR_(accel
)("Out of memory.\n");
775 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
778 accel
= GlobalLock16(hAccel
);
781 for (i
=0;i
<cEntries
;i
++) {
782 accel
[i
].fVirt
= lpaccel
[i
].fVirt
;
783 if( !(accel
[i
].fVirt
& FVIRTKEY
) ) {
784 ckey
= (char) lpaccel
[i
].key
;
785 if(!MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, &ckey
, 1, &accel
[i
].key
, 1))
786 WARN_(accel
)("Error converting ASCII accelerator table to Unicode");
789 accel
[i
].key
= lpaccel
[i
].key
;
790 accel
[i
].cmd
= lpaccel
[i
].cmd
;
793 /* Set the end-of-table terminator. */
794 accel
[cEntries
-1].fVirt
|= 0x80;
796 TRACE_(accel
)("Allocated accelerator handle %x\n", hAccel
);
800 /******************************************************************************
801 * DestroyAcceleratorTable [USER32.130]
802 * Destroys an accelerator table
805 * By mortene@pvv.org 980321
808 * handle [I] Handle to accelerator table
812 BOOL WINAPI
DestroyAcceleratorTable( HACCEL handle
)
814 return GlobalFree16(handle
);
817 /**********************************************************************
820 INT16 WINAPI
LoadString16( HINSTANCE16 instance
, UINT16 resource_id
,
821 LPSTR buffer
, INT16 buflen
)
829 TRACE("inst=%04x id=%04x buff=%08x len=%d\n",
830 instance
, resource_id
, (int) buffer
, buflen
);
832 hrsrc
= FindResource16( instance
, (SEGPTR
)((resource_id
>>4)+1), RT_STRING16
);
833 if (!hrsrc
) return 0;
834 hmem
= LoadResource16( instance
, hrsrc
);
837 p
= LockResource16(hmem
);
838 string_num
= resource_id
& 0x000f;
839 for (i
= 0; i
< string_num
; i
++)
842 TRACE("strlen = %d\n", (int)*p
);
844 if (buffer
== NULL
) return *p
;
845 i
= min(buflen
- 1, *p
);
847 memcpy(buffer
, p
+ 1, i
);
854 WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
856 FreeResource16( hmem
);
858 TRACE("'%s' loaded !\n", buffer
);
862 /**********************************************************************
863 * LoadStringW (USER32.376)
865 INT WINAPI
LoadStringW( HINSTANCE instance
, UINT resource_id
,
866 LPWSTR buffer
, INT buflen
)
874 if (HIWORD(resource_id
)==0xFFFF) /* netscape 3 passes this */
875 resource_id
= (UINT
)(-((INT
)resource_id
));
876 TRACE("instance = %04x, id = %04x, buffer = %08x, "
877 "length = %d\n", instance
, (int)resource_id
, (int) buffer
, buflen
);
879 /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
881 hrsrc
= FindResourceW( instance
, (LPCWSTR
)(((resource_id
>>4)&0xffff)+1),
883 if (!hrsrc
) return 0;
884 hmem
= LoadResource( instance
, hrsrc
);
887 p
= LockResource(hmem
);
888 string_num
= resource_id
& 0x000f;
889 for (i
= 0; i
< string_num
; i
++)
892 TRACE("strlen = %d\n", (int)*p
);
894 if (buffer
== NULL
) return *p
;
895 i
= min(buflen
- 1, *p
);
897 memcpy(buffer
, p
+ 1, i
* sizeof (WCHAR
));
898 buffer
[i
] = (WCHAR
) 0;
901 buffer
[0] = (WCHAR
) 0;
905 WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
909 TRACE("%s loaded !\n", debugstr_w(buffer
));
913 /**********************************************************************
914 * LoadStringA (USER32.375)
916 INT WINAPI
LoadStringA( HINSTANCE instance
, UINT resource_id
,
917 LPSTR buffer
, INT buflen
)
925 if ( buffer
!= NULL
&& buflen
> 0 )
928 wbuflen
= LoadStringW(instance
,resource_id
,NULL
,0);
934 wbuf
= HeapAlloc( GetProcessHeap(), 0, wbuflen
* sizeof(WCHAR
) );
935 wbuflen
= LoadStringW(instance
,resource_id
,wbuf
,wbuflen
);
938 abuflen
= WideCharToMultiByte(CP_ACP
,0,wbuf
,wbuflen
,NULL
,0,NULL
,NULL
);
941 if ( buffer
== NULL
|| buflen
== 0 )
945 abuf
= HeapAlloc( GetProcessHeap(), 0, abuflen
* sizeof(CHAR
) );
946 abuflen
= WideCharToMultiByte(CP_ACP
,0,wbuf
,wbuflen
,abuf
,abuflen
,NULL
,NULL
);
949 abuflen
= min(abuflen
,buflen
- 1);
950 memcpy( buffer
, abuf
, abuflen
);
954 HeapFree( GetProcessHeap(), 0, abuf
);
958 HeapFree( GetProcessHeap(), 0, wbuf
);
963 /* Messages...used by FormatMessage32* (KERNEL32.something)
965 * They can be specified either directly or using a message ID and
966 * loading them from the resource.
968 * The resourcedata has following format:
970 * 0: DWORD nrofentries
971 * nrofentries * subentry:
972 * 0: DWORD firstentry
974 * 8: DWORD offset from start to the stringentries
976 * (lastentry-firstentry) * stringentry:
977 * 0: WORD len (0 marks end)
980 * (stringentry i of a subentry refers to the ID 'firstentry+i')
982 * Yes, ANSI strings in win32 resources. Go figure.
985 /**********************************************************************
986 * LoadMessageA (internal)
988 INT WINAPI
LoadMessageA( HMODULE instance
, UINT id
, WORD lang
,
989 LPSTR buffer
, INT buflen
)
993 PMESSAGE_RESOURCE_DATA mrd
;
994 PMESSAGE_RESOURCE_BLOCK mrb
;
995 PMESSAGE_RESOURCE_ENTRY mre
;
998 TRACE("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD
)instance
, (DWORD
)id
, buffer
, (DWORD
)buflen
);
1000 /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
1001 hrsrc
= FindResourceExW(instance
,RT_MESSAGELISTW
,(LPWSTR
)1,lang
);
1002 if (!hrsrc
) return 0;
1003 hmem
= LoadResource( instance
, hrsrc
);
1004 if (!hmem
) return 0;
1006 mrd
= (PMESSAGE_RESOURCE_DATA
)LockResource(hmem
);
1008 mrb
= &(mrd
->Blocks
[0]);
1009 for (i
=mrd
->NumberOfBlocks
;i
--;) {
1010 if ((id
>=mrb
->LowId
) && (id
<=mrb
->HighId
)) {
1011 mre
= (PMESSAGE_RESOURCE_ENTRY
)(((char*)mrd
)+mrb
->OffsetToEntries
);
1022 mre
= (PMESSAGE_RESOURCE_ENTRY
)(((char*)mre
)+(mre
->Length
));
1025 TRACE(" - strlen=%d\n",slen
);
1026 i
= min(buflen
- 1, slen
);
1030 lstrcpynA(buffer
,(char*)mre
->Text
,i
);
1039 TRACE("'%s' copied !\n", buffer
);
1043 /**********************************************************************
1044 * LoadMessageW (internal)
1046 INT WINAPI
LoadMessageW( HMODULE instance
, UINT id
, WORD lang
,
1047 LPWSTR buffer
, INT buflen
)
1050 LPSTR buffer2
= NULL
;
1051 if (buffer
&& buflen
)
1052 buffer2
= HeapAlloc( GetProcessHeap(), 0, buflen
);
1053 retval
= LoadMessageA(instance
,id
,lang
,buffer2
,buflen
);
1057 lstrcpynAtoW( buffer
, buffer2
, buflen
);
1058 retval
= lstrlenW( buffer
);
1060 HeapFree( GetProcessHeap(), 0, buffer2
);
1066 /**********************************************************************
1067 * EnumResourceTypesA (KERNEL32.90)
1069 BOOL WINAPI
EnumResourceTypesA( HMODULE hmodule
,ENUMRESTYPEPROCA lpfun
,
1072 /* FIXME: move WINE_MODREF stuff here */
1073 return PE_EnumResourceTypesA(hmodule
,lpfun
,lParam
);
1076 /**********************************************************************
1077 * EnumResourceTypesW (KERNEL32.91)
1079 BOOL WINAPI
EnumResourceTypesW( HMODULE hmodule
,ENUMRESTYPEPROCW lpfun
,
1082 /* FIXME: move WINE_MODREF stuff here */
1083 return PE_EnumResourceTypesW(hmodule
,lpfun
,lParam
);
1086 /**********************************************************************
1087 * EnumResourceNamesA (KERNEL32.88)
1089 BOOL WINAPI
EnumResourceNamesA( HMODULE hmodule
, LPCSTR type
,
1090 ENUMRESNAMEPROCA lpfun
, LONG lParam
)
1092 /* FIXME: move WINE_MODREF stuff here */
1093 return PE_EnumResourceNamesA(hmodule
,type
,lpfun
,lParam
);
1095 /**********************************************************************
1096 * EnumResourceNamesW (KERNEL32.89)
1098 BOOL WINAPI
EnumResourceNamesW( HMODULE hmodule
, LPCWSTR type
,
1099 ENUMRESNAMEPROCW lpfun
, LONG lParam
)
1101 /* FIXME: move WINE_MODREF stuff here */
1102 return PE_EnumResourceNamesW(hmodule
,type
,lpfun
,lParam
);
1105 /**********************************************************************
1106 * EnumResourceLanguagesA (KERNEL32.86)
1108 BOOL WINAPI
EnumResourceLanguagesA( HMODULE hmodule
, LPCSTR type
,
1109 LPCSTR name
, ENUMRESLANGPROCA lpfun
,
1112 /* FIXME: move WINE_MODREF stuff here */
1113 return PE_EnumResourceLanguagesA(hmodule
,type
,name
,lpfun
,lParam
);
1115 /**********************************************************************
1116 * EnumResourceLanguagesW (KERNEL32.87)
1118 BOOL WINAPI
EnumResourceLanguagesW( HMODULE hmodule
, LPCWSTR type
,
1119 LPCWSTR name
, ENUMRESLANGPROCW lpfun
,
1122 /* FIXME: move WINE_MODREF stuff here */
1123 return PE_EnumResourceLanguagesW(hmodule
,type
,name
,lpfun
,lParam
);