4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
11 #include <sys/types.h>
18 #include "wine/winbase16.h"
19 #include "wine/winuser16.h"
24 #include "cursoricon.h"
35 extern WORD WINE_LanguageId
;
37 #define HRSRC_MAP_BLOCKSIZE 16
39 typedef struct _HRSRC_ELEM
45 typedef struct _HRSRC_MAP
52 /**********************************************************************
55 static HRSRC16
MapHRsrc32To16( NE_MODULE
*pModule
, HANDLE hRsrc32
, WORD type
)
57 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
61 /* On first call, initialize HRSRC map */
64 if ( !(map
= (HRSRC_MAP
*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
65 sizeof(HRSRC_MAP
) ) ) )
67 ERR( resource
, "Cannot allocate HRSRC map\n" );
70 pModule
->hRsrcMap
= (LPVOID
)map
;
73 /* Check whether HRSRC32 already in map */
74 for ( i
= 0; i
< map
->nUsed
; i
++ )
75 if ( map
->elem
[i
].hRsrc
== hRsrc32
)
76 return (HRSRC16
)(i
+ 1);
78 /* If no space left, grow table */
79 if ( map
->nUsed
== map
->nAlloc
)
81 if ( !(newElem
= (HRSRC_ELEM
*)HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
83 (map
->nAlloc
+ HRSRC_MAP_BLOCKSIZE
)
84 * sizeof(HRSRC_ELEM
) ) ))
86 ERR( resource
, "Cannot grow HRSRC map\n" );
90 map
->nAlloc
+= HRSRC_MAP_BLOCKSIZE
;
93 /* Add HRSRC32 to table */
94 map
->elem
[map
->nUsed
].hRsrc
= hRsrc32
;
95 map
->elem
[map
->nUsed
].type
= type
;
98 return (HRSRC16
)map
->nUsed
;
101 /**********************************************************************
104 static HANDLE
MapHRsrc16To32( NE_MODULE
*pModule
, HRSRC16 hRsrc16
)
106 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
107 if ( !map
|| !hRsrc16
|| (int)hRsrc16
> map
->nUsed
) return 0;
109 return map
->elem
[(int)hRsrc16
-1].hRsrc
;
112 /**********************************************************************
115 static WORD
MapHRsrc16ToType( NE_MODULE
*pModule
, HRSRC16 hRsrc16
)
117 HRSRC_MAP
*map
= (HRSRC_MAP
*)pModule
->hRsrcMap
;
118 if ( !map
|| !hRsrc16
|| (int)hRsrc16
> map
->nUsed
) return 0;
120 return map
->elem
[(int)hRsrc16
-1].type
;
124 /**********************************************************************
127 static HRSRC
RES_FindResource( HMODULE hModule
, LPCSTR type
,
128 LPCSTR name
, WORD lang
,
129 BOOL bUnicode
, BOOL bRet16
)
133 HMODULE16 hMod16
= MapHModuleLS( hModule
);
134 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
135 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
136 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
138 TRACE( resource
, "(%08x %s, %08x%s, %08x%s, %04x, %s, %s)\n",
139 hModule
, NE_MODULE_NAME(pModule
),
140 (UINT
)type
, HIWORD(type
)? (bUnicode
? debugstr_w((LPWSTR
)type
) : debugstr_a(type
)) : "",
141 (UINT
)name
, HIWORD(name
)? (bUnicode
? debugstr_w((LPWSTR
)name
) : debugstr_a(name
)) : "",
144 bRet16
? "NE" : "PE" );
146 if ( !pModule
) return 0;
150 /* 32-bit PE/ELF module */
151 LPWSTR typeStr
, nameStr
;
153 if ( HIWORD( type
) && !bUnicode
)
154 typeStr
= HEAP_strdupAtoW( GetProcessHeap(), 0, type
);
156 typeStr
= (LPWSTR
)type
;
157 if ( HIWORD( name
) && !bUnicode
)
158 nameStr
= HEAP_strdupAtoW( GetProcessHeap(), 0, name
);
160 nameStr
= (LPWSTR
)name
;
165 hRsrc
= PE_FindResourceExW( wm
, nameStr
, typeStr
, lang
);
169 hRsrc
= LIBRES_FindResource( hModule
, nameStr
, typeStr
);
173 ERR( resource
, "unknown module type %d\n", wm
->type
);
177 if ( HIWORD( type
) && !bUnicode
)
178 HeapFree( GetProcessHeap(), 0, typeStr
);
179 if ( HIWORD( name
) && !bUnicode
)
180 HeapFree( GetProcessHeap(), 0, nameStr
);
183 /* If we need to return 16-bit HRSRC, perform conversion */
185 hRsrc
= MapHRsrc32To16( pModule
, hRsrc
,
186 HIWORD( type
)? 0 : LOWORD( type
) );
190 /* 16-bit NE module */
191 LPSTR typeStr
, nameStr
;
193 if ( HIWORD( type
) && bUnicode
)
194 typeStr
= HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)type
);
196 typeStr
= (LPSTR
)type
;
197 if ( HIWORD( name
) && bUnicode
)
198 nameStr
= HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)name
);
200 nameStr
= (LPSTR
)name
;
202 hRsrc
= NE_FindResource( pModule
, nameStr
, typeStr
);
204 if ( HIWORD( type
) && bUnicode
)
205 HeapFree( GetProcessHeap(), 0, typeStr
);
206 if ( HIWORD( name
) && bUnicode
)
207 HeapFree( GetProcessHeap(), 0, nameStr
);
210 /* If we need to return 32-bit HRSRC, no conversion is necessary,
211 we simply use the 16-bit HRSRC as 32-bit HRSRC */
217 /**********************************************************************
220 static DWORD
RES_SizeofResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
224 HMODULE16 hMod16
= MapHModuleLS( hModule
);
225 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
226 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
227 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
229 TRACE( resource
, "(%08x %s, %08x, %s)\n",
230 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
232 if ( !pModule
|| !hRsrc
) return 0;
236 /* 32-bit PE/ELF module */
238 /* If we got a 16-bit hRsrc, convert it */
239 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
244 size
= PE_SizeofResource( hModule
, hRsrc32
);
248 size
= LIBRES_SizeofResource( hModule
, hRsrc32
);
252 ERR( resource
, "unknown module type %d\n", wm
->type
);
258 /* 16-bit NE module */
260 /* If we got a 32-bit hRsrc, we don't need to convert it */
262 size
= NE_SizeofResource( pModule
, hRsrc
);
268 /**********************************************************************
271 static HFILE
RES_AccessResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
273 HFILE hFile
= HFILE_ERROR
;
275 HMODULE16 hMod16
= MapHModuleLS( hModule
);
276 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
277 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
278 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
280 TRACE( resource
, "(%08x %s, %08x, %s)\n",
281 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
283 if ( !pModule
|| !hRsrc
) return HFILE_ERROR
;
287 /* 32-bit PE/ELF module */
289 /* If we got a 16-bit hRsrc, convert it */
290 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
293 FIXME( resource
, "32-bit modules not yet supported.\n" );
296 /* If we need to return a 16-bit file handle, convert it */
298 hFile
= FILE_AllocDosHandle( hFile
);
302 /* 16-bit NE module */
304 /* If we got a 32-bit hRsrc, we don't need to convert it */
306 hFile
= NE_AccessResource( pModule
, hRsrc
);
308 /* If we are to return a 32-bit file handle, convert it */
310 hFile
= FILE_GetHandle( hFile
);
316 /**********************************************************************
319 static HGLOBAL
RES_LoadResource( HMODULE hModule
, HRSRC hRsrc
, BOOL bRet16
)
323 HMODULE16 hMod16
= MapHModuleLS( hModule
);
324 NE_MODULE
*pModule
= NE_GetPtr( hMod16
);
325 WINE_MODREF
*wm
= pModule
&& pModule
->module32
?
326 MODULE32_LookupHMODULE( pModule
->module32
) : NULL
;
328 TRACE( resource
, "(%08x %s, %08x, %s)\n",
329 hModule
, NE_MODULE_NAME(pModule
), hRsrc
, bRet16
? "NE" : "PE" );
331 if ( !pModule
|| !hRsrc
) return 0;
335 /* 32-bit PE/ELF module */
337 /* If we got a 16-bit hRsrc, convert it */
338 HRSRC hRsrc32
= HIWORD(hRsrc
)? hRsrc
: MapHRsrc16To32( pModule
, hRsrc
);
343 hMem
= PE_LoadResource( wm
, hRsrc32
);
347 hMem
= LIBRES_LoadResource( hModule
, hRsrc32
);
351 ERR( resource
, "unknown module type %d\n", wm
->type
);
355 /* If we need to return a 16-bit resource, convert it */
358 WORD type
= MapHRsrc16ToType( pModule
, hRsrc
);
359 DWORD size
= SizeofResource( hModule
, hRsrc
);
360 LPVOID bits
= LockResource( hMem
);
362 hMem
= NE_LoadPEResource( pModule
, type
, bits
, size
);
367 /* 16-bit NE module */
369 /* If we got a 32-bit hRsrc, we don't need to convert it */
371 hMem
= NE_LoadResource( pModule
, hRsrc
);
373 /* If we are to return a 32-bit resource, we should probably
374 convert it but we don't for now. FIXME !!! */
380 /**********************************************************************
383 static LPVOID
RES_LockResource( HGLOBAL handle
, BOOL bRet16
)
387 TRACE( resource
, "(%08x, %s)\n", handle
, bRet16
? "NE" : "PE" );
389 if ( HIWORD( handle
) )
391 /* 32-bit memory handle */
394 FIXME( resource
, "can't return SEGPTR to 32-bit resource %08x.\n", handle
);
396 bits
= (LPVOID
)handle
;
400 /* 16-bit memory handle */
402 /* May need to reload the resource if discarded */
403 SEGPTR segPtr
= WIN16_GlobalLock16( handle
);
406 bits
= (LPVOID
)segPtr
;
408 bits
= PTR_SEG_TO_LIN( segPtr
);
414 /**********************************************************************
417 static BOOL
RES_FreeResource( HGLOBAL handle
)
419 HGLOBAL retv
= handle
;
421 TRACE( resource
, "(%08x)\n", handle
);
423 if ( HIWORD( handle
) )
425 /* 32-bit memory handle: nothing to do */
429 /* 16-bit memory handle */
430 NE_MODULE
*pModule
= NE_GetPtr( FarGetOwner16( handle
) );
432 /* Try NE resource first */
433 retv
= NE_FreeResource( pModule
, handle
);
435 /* If this failed, call USER.DestroyIcon32; this will check
436 whether it is a shared cursor/icon; if not it will call
439 if ( Callout
.DestroyIcon32
)
440 retv
= Callout
.DestroyIcon32( handle
, CID_RESOURCE
);
442 retv
= GlobalFree16( handle
);
450 /**********************************************************************
451 * FindResource16 (KERNEL.60)
453 HRSRC16 WINAPI
FindResource16( HMODULE16 hModule
, SEGPTR name
, SEGPTR type
)
455 LPCSTR nameStr
= HIWORD(name
)? PTR_SEG_TO_LIN(name
) : (LPCSTR
)name
;
456 LPCSTR typeStr
= HIWORD(type
)? PTR_SEG_TO_LIN(type
) : (LPCSTR
)type
;
458 return RES_FindResource( hModule
, typeStr
, nameStr
,
459 WINE_LanguageId
, FALSE
, TRUE
);
462 /**********************************************************************
463 * FindResourceA (KERNEL32.128)
465 HANDLE WINAPI
FindResourceA( HMODULE hModule
, LPCSTR name
, LPCSTR type
)
467 return RES_FindResource( hModule
, type
, name
,
468 WINE_LanguageId
, FALSE
, FALSE
);
471 /**********************************************************************
472 * FindResourceExA (KERNEL32.129)
474 HANDLE WINAPI
FindResourceExA( HMODULE hModule
,
475 LPCSTR type
, LPCSTR name
, WORD lang
)
477 return RES_FindResource( hModule
, type
, name
,
478 lang
, FALSE
, FALSE
);
481 /**********************************************************************
482 * FindResourceExW (KERNEL32.130)
484 HRSRC WINAPI
FindResourceExW( HMODULE hModule
,
485 LPCWSTR type
, LPCWSTR name
, WORD lang
)
487 return RES_FindResource( hModule
, (LPCSTR
)type
, (LPCSTR
)name
,
491 /**********************************************************************
492 * FindResourceW (KERNEL32.131)
494 HRSRC WINAPI
FindResourceW(HINSTANCE hModule
, LPCWSTR name
, LPCWSTR type
)
496 return RES_FindResource( hModule
, (LPCSTR
)type
, (LPCSTR
)name
,
497 WINE_LanguageId
, TRUE
, FALSE
);
500 /**********************************************************************
501 * LoadResource16 (KERNEL.61)
503 HGLOBAL16 WINAPI
LoadResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
505 return RES_LoadResource( hModule
, hRsrc
, TRUE
);
508 /**********************************************************************
509 * LoadResource (KERNEL32.370)
511 HGLOBAL WINAPI
LoadResource( HINSTANCE hModule
, HRSRC hRsrc
)
513 return RES_LoadResource( hModule
, hRsrc
, FALSE
);
516 /**********************************************************************
517 * LockResource16 (KERNEL.62)
519 SEGPTR WINAPI
WIN16_LockResource16( HGLOBAL16 handle
)
521 return (SEGPTR
)RES_LockResource( handle
, TRUE
);
523 LPVOID WINAPI
LockResource16( HGLOBAL16 handle
)
525 return RES_LockResource( handle
, FALSE
);
528 /**********************************************************************
529 * LockResource (KERNEL32.384)
531 LPVOID WINAPI
LockResource( HGLOBAL handle
)
533 return RES_LockResource( handle
, FALSE
);
536 /**********************************************************************
537 * FreeResource16 (KERNEL.63)
539 BOOL16 WINAPI
FreeResource16( HGLOBAL16 handle
)
541 return RES_FreeResource( handle
);
544 /**********************************************************************
545 * FreeResource (KERNEL32.145)
547 BOOL WINAPI
FreeResource( HGLOBAL handle
)
549 return RES_FreeResource( handle
);
552 /**********************************************************************
553 * AccessResource16 (KERNEL.64)
555 INT16 WINAPI
AccessResource16( HINSTANCE16 hModule
, HRSRC16 hRsrc
)
557 return RES_AccessResource( hModule
, hRsrc
, TRUE
);
560 /**********************************************************************
561 * AccessResource (KERNEL32.64)
563 INT WINAPI
AccessResource( HMODULE hModule
, HRSRC hRsrc
)
565 return RES_AccessResource( hModule
, hRsrc
, FALSE
);
568 /**********************************************************************
569 * SizeofResource16 (KERNEL.65)
571 DWORD WINAPI
SizeofResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
573 return RES_SizeofResource( hModule
, hRsrc
, TRUE
);
576 /**********************************************************************
577 * SizeofResource (KERNEL32.522)
579 DWORD WINAPI
SizeofResource( HINSTANCE hModule
, HRSRC hRsrc
)
581 return RES_SizeofResource( hModule
, hRsrc
, FALSE
);
586 /**********************************************************************
587 * LoadAccelerators16 [USER.177]
589 HACCEL16 WINAPI
LoadAccelerators16(HINSTANCE16 instance
, SEGPTR lpTableName
)
593 if (HIWORD(lpTableName
))
594 TRACE(accel
, "%04x '%s'\n",
595 instance
, (char *)PTR_SEG_TO_LIN( lpTableName
) );
597 TRACE(accel
, "%04x %04x\n",
598 instance
, LOWORD(lpTableName
) );
600 if (!(hRsrc
= FindResource16( instance
, lpTableName
, RT_ACCELERATOR16
))) {
601 WARN(accel
, "couldn't find accelerator table resource\n");
605 TRACE(accel
, "returning HACCEL 0x%x\n", hRsrc
);
606 return LoadResource16(instance
,hRsrc
);
609 /**********************************************************************
610 * LoadAccelerators32W [USER.177]
611 * The image layout seems to look like this (not 100% sure):
612 * 00: BYTE type type of accelerator
613 * 01: BYTE pad (to WORD boundary)
616 * 06: WORD pad (to DWORD boundary)
618 HACCEL WINAPI
LoadAcceleratorsW(HINSTANCE instance
,LPCWSTR lpTableName
)
621 HACCEL hMem
,hRetval
=0;
624 if (HIWORD(lpTableName
))
625 TRACE(accel
, "%p '%s'\n",
626 (LPVOID
)instance
, (char *)( lpTableName
) );
628 TRACE(accel
, "%p 0x%04x\n",
629 (LPVOID
)instance
, LOWORD(lpTableName
) );
631 if (!(hRsrc
= FindResourceW( instance
, lpTableName
, RT_ACCELERATORW
)))
633 WARN(accel
, "couldn't find accelerator table resource\n");
635 hMem
= LoadResource( instance
, hRsrc
);
636 size
= SizeofResource( instance
, hRsrc
);
637 if(size
>=sizeof(PE_ACCEL
))
639 LPPE_ACCEL accel_table
= (LPPE_ACCEL
) hMem
;
641 int i
,nrofaccells
= size
/sizeof(PE_ACCEL
);
643 hRetval
= GlobalAlloc16(0,sizeof(ACCEL16
)*nrofaccells
);
644 accel16
= (LPACCEL16
)GlobalLock16(hRetval
);
645 for (i
=0;i
<nrofaccells
;i
++) {
646 accel16
[i
].fVirt
= accel_table
[i
].fVirt
;
647 accel16
[i
].key
= accel_table
[i
].key
;
648 accel16
[i
].cmd
= accel_table
[i
].cmd
;
650 accel16
[i
-1].fVirt
|= 0x80;
653 TRACE(accel
, "returning HACCEL 0x%x\n", hRsrc
);
657 HACCEL WINAPI
LoadAcceleratorsA(HINSTANCE instance
,LPCSTR lpTableName
)
661 if (HIWORD(lpTableName
))
662 uni
= HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName
);
664 uni
= (LPWSTR
)lpTableName
;
665 result
= LoadAcceleratorsW(instance
,uni
);
666 if (HIWORD(uni
)) HeapFree( GetProcessHeap(), 0, uni
);
670 /**********************************************************************
671 * CopyAcceleratorTable32A (USER32.58)
673 INT WINAPI
CopyAcceleratorTableA(HACCEL src
, LPACCEL dst
, INT entries
)
675 return CopyAcceleratorTableW(src
, dst
, entries
);
678 /**********************************************************************
679 * CopyAcceleratorTable32W (USER32.59)
681 * By mortene@pvv.org 980321
683 INT WINAPI
CopyAcceleratorTableW(HACCEL src
, LPACCEL dst
,
687 LPACCEL16 accel
= (LPACCEL16
)GlobalLock16(src
);
690 /* Do parameter checking to avoid the explosions and the screaming
691 as far as possible. */
692 if((dst
&& (entries
< 1)) || (src
== (HACCEL
)NULL
) || !accel
) {
693 WARN(accel
, "Application sent invalid parameters (%p %p %d).\n",
694 (LPVOID
)src
, (LPVOID
)dst
, entries
);
697 xsize
= GlobalSize16(src
)/sizeof(ACCEL16
);
698 if (xsize
>entries
) entries
=xsize
;
702 /* Spit out some debugging information. */
703 TRACE(accel
, "accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
704 i
, accel
[i
].fVirt
, accel
[i
].key
, accel
[i
].cmd
);
706 /* Copy data to the destination structure array (if dst == NULL,
707 we're just supposed to count the number of entries). */
709 dst
[i
].fVirt
= accel
[i
].fVirt
;
710 dst
[i
].key
= accel
[i
].key
;
711 dst
[i
].cmd
= accel
[i
].cmd
;
713 /* Check if we've reached the end of the application supplied
714 accelerator table. */
716 /* Turn off the high order bit, just in case. */
717 dst
[i
].fVirt
&= 0x7f;
722 /* The highest order bit seems to mark the end of the accelerator
723 resource table, but not always. Use GlobalSize() check too. */
724 if((accel
[i
].fVirt
& 0x80) != 0) done
= TRUE
;
732 /*********************************************************************
733 * CreateAcceleratorTable (USER32.64)
735 * By mortene@pvv.org 980321
737 HACCEL WINAPI
CreateAcceleratorTableA(LPACCEL lpaccel
, INT cEntries
)
743 /* Do parameter checking just in case someone's trying to be
746 WARN(accel
, "Application sent invalid parameters (%p %d).\n",
748 SetLastError(ERROR_INVALID_PARAMETER
);
751 FIXME(accel
, "should check that the accelerator descriptions are valid,"
752 " return NULL and SetLastError() if not.\n");
755 /* Allocate memory and copy the table. */
756 hAccel
= GlobalAlloc16(0,cEntries
*sizeof(ACCEL16
));
758 TRACE(accel
, "handle %x\n", hAccel
);
760 ERR(accel
, "Out of memory.\n");
761 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
764 accel
= GlobalLock16(hAccel
);
765 for (i
=0;i
<cEntries
;i
++) {
766 accel
[i
].fVirt
= lpaccel
[i
].fVirt
;
767 accel
[i
].key
= lpaccel
[i
].key
;
768 accel
[i
].cmd
= lpaccel
[i
].cmd
;
770 /* Set the end-of-table terminator. */
771 accel
[cEntries
-1].fVirt
|= 0x80;
773 TRACE(accel
, "Allocated accelerator handle %x\n", hAccel
);
778 /******************************************************************************
779 * DestroyAcceleratorTable [USER32.130]
780 * Destroys an accelerator table
783 * By mortene@pvv.org 980321
786 * handle [I] Handle to accelerator table
790 BOOL WINAPI
DestroyAcceleratorTable( HACCEL handle
)
792 FIXME(accel
, "(0x%x): stub\n", handle
);
793 /* FIXME: GlobalFree16(handle); */
797 /**********************************************************************
800 INT16 WINAPI
LoadString16( HINSTANCE16 instance
, UINT16 resource_id
,
801 LPSTR buffer
, INT16 buflen
)
809 TRACE(resource
,"inst=%04x id=%04x buff=%08x len=%d\n",
810 instance
, resource_id
, (int) buffer
, buflen
);
812 hrsrc
= FindResource16( instance
, (SEGPTR
)((resource_id
>>4)+1), RT_STRING16
);
813 if (!hrsrc
) return 0;
814 hmem
= LoadResource16( instance
, hrsrc
);
817 p
= LockResource16(hmem
);
818 string_num
= resource_id
& 0x000f;
819 for (i
= 0; i
< string_num
; i
++)
822 TRACE(resource
, "strlen = %d\n", (int)*p
);
824 i
= MIN(buflen
- 1, *p
);
828 memcpy(buffer
, p
+ 1, i
);
835 WARN(resource
,"Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
837 FreeResource16( hmem
);
839 TRACE(resource
,"'%s' loaded !\n", buffer
);
843 /**********************************************************************
844 * LoadString32W (USER32.376)
846 INT WINAPI
LoadStringW( HINSTANCE instance
, UINT resource_id
,
847 LPWSTR buffer
, INT buflen
)
855 if (HIWORD(resource_id
)==0xFFFF) /* netscape 3 passes this */
856 resource_id
= (UINT
)(-((INT
)resource_id
));
857 TRACE(resource
, "instance = %04x, id = %04x, buffer = %08x, "
858 "length = %d\n", instance
, (int)resource_id
, (int) buffer
, buflen
);
860 /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
862 hrsrc
= FindResourceW( instance
, (LPCWSTR
)(((resource_id
>>4)&0xffff)+1),
864 if (!hrsrc
) return 0;
865 hmem
= LoadResource( instance
, hrsrc
);
868 p
= LockResource(hmem
);
869 string_num
= resource_id
& 0x000f;
870 for (i
= 0; i
< string_num
; i
++)
873 TRACE(resource
, "strlen = %d\n", (int)*p
);
875 i
= MIN(buflen
- 1, *p
);
879 memcpy(buffer
, p
+ 1, i
* sizeof (WCHAR
));
880 buffer
[i
] = (WCHAR
) 0;
883 buffer
[0] = (WCHAR
) 0;
887 WARN(resource
,"Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
891 TRACE(resource
,"%s loaded !\n", debugstr_w(buffer
));
895 /**********************************************************************
896 * LoadString32A (USER32.375)
898 INT WINAPI
LoadStringA( HINSTANCE instance
, UINT resource_id
,
899 LPSTR buffer
, INT buflen
)
902 LPWSTR buffer2
= NULL
;
903 if (buffer
&& buflen
)
904 buffer2
= HeapAlloc( GetProcessHeap(), 0, buflen
* 2 );
905 retval
= LoadStringW(instance
,resource_id
,buffer2
,buflen
);
910 lstrcpynWtoA( buffer
, buffer2
, buflen
);
911 retval
= lstrlenA( buffer
);
915 HeapFree( GetProcessHeap(), 0, buffer2
);
920 /* Messages...used by FormatMessage32* (KERNEL32.something)
922 * They can be specified either directly or using a message ID and
923 * loading them from the resource.
925 * The resourcedata has following format:
927 * 0: DWORD nrofentries
928 * nrofentries * subentry:
929 * 0: DWORD firstentry
931 * 8: DWORD offset from start to the stringentries
933 * (lastentry-firstentry) * stringentry:
934 * 0: WORD len (0 marks end)
937 * (stringentry i of a subentry refers to the ID 'firstentry+i')
939 * Yes, ANSI strings in win32 resources. Go figure.
942 /**********************************************************************
943 * LoadMessage32A (internal)
945 INT WINAPI
LoadMessageA( HMODULE instance
, UINT id
, WORD lang
,
946 LPSTR buffer
, INT buflen
)
950 PMESSAGE_RESOURCE_DATA mrd
;
951 PMESSAGE_RESOURCE_BLOCK mrb
;
952 PMESSAGE_RESOURCE_ENTRY mre
;
955 TRACE(resource
, "instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD
)instance
, (DWORD
)id
, buffer
, (DWORD
)buflen
);
957 /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
958 hrsrc
= FindResourceExW(instance
,RT_MESSAGELISTW
,(LPWSTR
)1,lang
);
959 if (!hrsrc
) return 0;
960 hmem
= LoadResource( instance
, hrsrc
);
963 mrd
= (PMESSAGE_RESOURCE_DATA
)LockResource(hmem
);
965 mrb
= &(mrd
->Blocks
[0]);
966 for (i
=mrd
->NumberOfBlocks
;i
--;) {
967 if ((id
>=mrb
->LowId
) && (id
<=mrb
->HighId
)) {
968 mre
= (PMESSAGE_RESOURCE_ENTRY
)(((char*)mrd
)+mrb
->OffsetToEntries
);
979 mre
= (PMESSAGE_RESOURCE_ENTRY
)(((char*)mre
)+(mre
->Length
));
982 TRACE(resource
," - strlen=%d\n",slen
);
983 i
= MIN(buflen
- 1, slen
);
985 return slen
; /* different to LoadString */
987 lstrcpynA(buffer
,(char*)mre
->Text
,i
);
996 TRACE(resource
,"'%s' copied !\n", buffer
);
1000 /**********************************************************************
1001 * LoadMessage32W (internal)
1003 INT WINAPI
LoadMessageW( HMODULE instance
, UINT id
, WORD lang
,
1004 LPWSTR buffer
, INT buflen
)
1007 LPSTR buffer2
= NULL
;
1008 if (buffer
&& buflen
)
1009 buffer2
= HeapAlloc( GetProcessHeap(), 0, buflen
);
1010 retval
= LoadMessageA(instance
,id
,lang
,buffer2
,buflen
);
1014 lstrcpynAtoW( buffer
, buffer2
, buflen
);
1015 retval
= lstrlenW( buffer
);
1017 HeapFree( GetProcessHeap(), 0, buffer2
);
1023 /**********************************************************************
1024 * EnumResourceTypesA (KERNEL32.90)
1026 BOOL WINAPI
EnumResourceTypesA( HMODULE hmodule
,ENUMRESTYPEPROCA lpfun
,
1029 /* FIXME: move WINE_MODREF stuff here */
1030 return PE_EnumResourceTypesA(hmodule
,lpfun
,lParam
);
1033 /**********************************************************************
1034 * EnumResourceTypesW (KERNEL32.91)
1036 BOOL WINAPI
EnumResourceTypesW( HMODULE hmodule
,ENUMRESTYPEPROCW lpfun
,
1039 /* FIXME: move WINE_MODREF stuff here */
1040 return PE_EnumResourceTypesW(hmodule
,lpfun
,lParam
);
1043 /**********************************************************************
1044 * EnumResourceNamesA (KERNEL32.88)
1046 BOOL WINAPI
EnumResourceNamesA( HMODULE hmodule
, LPCSTR type
,
1047 ENUMRESNAMEPROCA lpfun
, LONG lParam
)
1049 /* FIXME: move WINE_MODREF stuff here */
1050 return PE_EnumResourceNamesA(hmodule
,type
,lpfun
,lParam
);
1052 /**********************************************************************
1053 * EnumResourceNamesW (KERNEL32.89)
1055 BOOL WINAPI
EnumResourceNamesW( HMODULE hmodule
, LPCWSTR type
,
1056 ENUMRESNAMEPROCW lpfun
, LONG lParam
)
1058 /* FIXME: move WINE_MODREF stuff here */
1059 return PE_EnumResourceNamesW(hmodule
,type
,lpfun
,lParam
);
1062 /**********************************************************************
1063 * EnumResourceLanguagesA (KERNEL32.86)
1065 BOOL WINAPI
EnumResourceLanguagesA( HMODULE hmodule
, LPCSTR type
,
1066 LPCSTR name
, ENUMRESLANGPROCA lpfun
,
1069 /* FIXME: move WINE_MODREF stuff here */
1070 return PE_EnumResourceLanguagesA(hmodule
,type
,name
,lpfun
,lParam
);
1072 /**********************************************************************
1073 * EnumResourceLanguagesW (KERNEL32.87)
1075 BOOL WINAPI
EnumResourceLanguagesW( HMODULE hmodule
, LPCWSTR type
,
1076 LPCWSTR name
, ENUMRESLANGPROCW lpfun
,
1079 /* FIXME: move WINE_MODREF stuff here */
1080 return PE_EnumResourceLanguagesW(hmodule
,type
,name
,lpfun
,lParam
);