4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
11 #include <sys/types.h>
27 #define PrintId(name) \
28 if (HIWORD((DWORD)name)) \
29 dprintf_resource( stddeb, "'%s'", (char *)PTR_SEG_TO_LIN(name)); \
31 dprintf_resource( stddeb, "#%04x", LOWORD(name));
34 /**********************************************************************
35 * FindResource (KERNEL.60)
37 HRSRC
FindResource( HMODULE hModule
, SEGPTR name
, SEGPTR type
)
41 hModule
= GetExePtr( hModule
); /* In case we were passed an hInstance */
42 dprintf_resource(stddeb
, "FindResource: module=%04x type=", hModule
);
44 if (HIWORD(name
)) /* Check for '#xxx' name */
46 char *ptr
= PTR_SEG_TO_LIN( name
);
48 if (!(name
= (SEGPTR
)atoi( ptr
+ 1 ))) return 0;
51 dprintf_resource( stddeb
, " name=" );
53 dprintf_resource( stddeb
, "\n" );
54 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
56 if (pModule
->flags
& NE_FFLAGS_WIN32
)
58 fprintf(stderr
,"Don't know how to FindResource() for Win32 module\n");
61 return NE_FindResource( hModule
, type
, name
);
63 return LIBRES_FindResource( hModule
, name
, type
);
68 /**********************************************************************
69 * LoadResource (KERNEL.61)
71 HGLOBAL
LoadResource( HMODULE hModule
, HRSRC hRsrc
)
75 hModule
= GetExePtr( hModule
); /* In case we were passed an hInstance */
76 dprintf_resource(stddeb
, "LoadResource: module=%04x res=%04x\n",
79 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
81 if (pModule
->flags
& NE_FFLAGS_WIN32
)
83 fprintf(stderr
,"Don't know how to LoadResource() for Win32 module\n");
86 return NE_LoadResource( hModule
, hRsrc
);
88 return LIBRES_LoadResource( hModule
, hRsrc
);
93 /**********************************************************************
94 * LockResource (KERNEL.62)
97 SEGPTR
WIN16_LockResource( HGLOBAL handle
)
103 dprintf_resource(stddeb
, "LockResource: handle=%04x\n", handle
);
104 if (!handle
) return (SEGPTR
)0;
105 hModule
= GetExePtr( handle
);
106 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
107 if (pModule
->flags
& NE_FFLAGS_WIN32
)
109 fprintf(stderr
,"Don't know how to LockResource() for Win32 module\n");
112 return NE_LockResource( hModule
, handle
);
114 return LIBRES_LockResource( handle
);
119 LPVOID
LockResource( HGLOBAL handle
)
125 dprintf_resource(stddeb
, "LockResource: handle=%04x\n", handle
);
126 if (!handle
) return NULL
;
127 hModule
= GetExePtr( handle
);
128 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
129 if (pModule
->flags
& NE_FFLAGS_WIN32
)
131 fprintf(stderr
,"Don't know how to LockResource() for Win32 module\n");
134 return (LPSTR
)PTR_SEG_TO_LIN( NE_LockResource( hModule
, handle
) );
136 return LIBRES_LockResource( handle
);
141 /**********************************************************************
142 * FreeResource (KERNEL.63)
144 BOOL
FreeResource( HGLOBAL handle
)
150 dprintf_resource(stddeb
, "FreeResource: handle=%04x\n", handle
);
151 if (!handle
) return FALSE
;
152 hModule
= GetExePtr( handle
);
153 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
154 if (pModule
->flags
& NE_FFLAGS_WIN32
)
156 fprintf(stderr
,"Don't know how to FreeResource() for Win32 module\n");
159 return NE_FreeResource( hModule
, handle
);
161 return LIBRES_FreeResource( handle
);
166 /**********************************************************************
167 * AccessResource (KERNEL.64)
169 INT
AccessResource( HINSTANCE hModule
, HRSRC hRsrc
)
173 hModule
= GetExePtr( hModule
); /* In case we were passed an hInstance */
174 dprintf_resource(stddeb
, "AccessResource: module=%04x res=%04x\n",
176 if (!hRsrc
) return 0;
177 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
179 if (pModule
->flags
& NE_FFLAGS_WIN32
)
181 fprintf(stderr
,"Don't know how to AccessResource() for Win32 module\n");
184 return NE_AccessResource( hModule
, hRsrc
);
186 return LIBRES_AccessResource( hModule
, hRsrc
);
191 /**********************************************************************
192 * SizeofResource (KERNEL.65)
194 DWORD
SizeofResource( HMODULE hModule
, HRSRC hRsrc
)
198 hModule
= GetExePtr( hModule
); /* In case we were passed an hInstance */
199 dprintf_resource(stddeb
, "SizeofResource: module=%04x res=%04x\n",
201 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
203 if (pModule
->flags
& NE_FFLAGS_WIN32
)
205 fprintf(stderr
,"Don't know how to SizeOfResource() for Win32 module\n");
208 return NE_SizeofResource( hModule
, hRsrc
);
210 return LIBRES_SizeofResource( hModule
, hRsrc
);
215 /**********************************************************************
216 * AllocResource (KERNEL.66)
218 HGLOBAL
AllocResource( HMODULE hModule
, HRSRC hRsrc
, DWORD size
)
222 hModule
= GetExePtr( hModule
); /* In case we were passed an hInstance */
223 dprintf_resource(stddeb
, "AllocResource: module=%04x res=%04x size=%ld\n",
224 hModule
, hRsrc
, size
);
225 if (!hRsrc
) return 0;
226 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
228 if (pModule
->flags
& NE_FFLAGS_WIN32
)
230 fprintf(stderr
,"Don't know how to AllocResource() for Win32 module\n");
233 return NE_AllocResource( hModule
, hRsrc
, size
);
235 return LIBRES_AllocResource( hModule
, hRsrc
, size
);
239 /**********************************************************************
240 * DirectResAlloc (KERNEL.168)
242 * Check Schulman, p. 232 for details
244 HANDLE
DirectResAlloc(HANDLE hInstance
, WORD wType
, WORD wSize
)
246 dprintf_resource(stddeb
,"DirectResAlloc(%04x,%04x,%04x)\n",
247 hInstance
, wType
, wSize
);
248 hInstance
= GetExePtr(hInstance
);
249 if(!hInstance
)return 0;
250 if(wType
!= 0x10) /* 0x10 is the only observed value, passed from
251 CreateCursorIndirect. */
252 fprintf(stderr
, "DirectResAlloc: wType = %x\n", wType
);
253 return GLOBAL_Alloc(GMEM_MOVEABLE
, wSize
, hInstance
, FALSE
, FALSE
, FALSE
);
257 /**********************************************************************
258 * LoadAccelerators [USER.177]
260 HANDLE
LoadAccelerators(HANDLE instance
, SEGPTR lpTableName
)
266 ACCELHEADER
*lpAccelTbl
;
269 if (HIWORD(lpTableName
))
270 dprintf_accel( stddeb
, "LoadAccelerators: %04x '%s'\n",
271 instance
, (char *)PTR_SEG_TO_LIN( lpTableName
) );
273 dprintf_accel( stddeb
, "LoadAccelerators: %04x %04x\n",
274 instance
, LOWORD(lpTableName
) );
276 if (!(hRsrc
= FindResource( instance
, lpTableName
, RT_ACCELERATOR
)))
278 if (!(rsc_mem
= LoadResource( instance
, hRsrc
))) return 0;
280 lp
= (BYTE
*)LockResource(rsc_mem
);
281 n
= SizeofResource( instance
, hRsrc
) / sizeof(ACCELENTRY
);
282 hAccel
= GlobalAlloc16(GMEM_MOVEABLE
,
283 sizeof(ACCELHEADER
) + (n
+ 1)*sizeof(ACCELENTRY
));
284 lpAccelTbl
= (LPACCELHEADER
)GlobalLock16(hAccel
);
285 lpAccelTbl
->wCount
= 0;
286 for (i
= 0; i
< n
; i
++) {
287 lpAccelTbl
->tbl
[i
].type
= *(lp
++);
288 lpAccelTbl
->tbl
[i
].wEvent
= *((WORD
*)lp
);
290 lpAccelTbl
->tbl
[i
].wIDval
= *((WORD
*)lp
);
292 if (lpAccelTbl
->tbl
[i
].wEvent
== 0) break;
293 dprintf_accel(stddeb
,
294 "Accelerator #%u / event=%04X id=%04X type=%02X \n",
295 i
, lpAccelTbl
->tbl
[i
].wEvent
, lpAccelTbl
->tbl
[i
].wIDval
,
296 lpAccelTbl
->tbl
[i
].type
);
297 lpAccelTbl
->wCount
++;
299 GlobalUnlock16(hAccel
);
300 FreeResource( rsc_mem
);
304 /**********************************************************************
305 * TranslateAccelerator [USER.178]
307 int TranslateAccelerator(HWND hWnd
, HANDLE hAccel
, LPMSG16 msg
)
309 ACCELHEADER
*lpAccelTbl
;
312 if (hAccel
== 0 || msg
== NULL
) return 0;
313 if (msg
->message
!= WM_KEYDOWN
&&
314 msg
->message
!= WM_KEYUP
&&
315 msg
->message
!= WM_SYSKEYDOWN
&&
316 msg
->message
!= WM_SYSKEYUP
&&
317 msg
->message
!= WM_CHAR
) return 0;
319 dprintf_accel(stddeb
, "TranslateAccelerators hAccel=%04x !\n", hAccel
);
321 lpAccelTbl
= (LPACCELHEADER
)GlobalLock16(hAccel
);
322 for (i
= 0; i
< lpAccelTbl
->wCount
; i
++) {
323 if(lpAccelTbl
->tbl
[i
].type
& VIRTKEY_ACCEL
) {
324 if(msg
->wParam
== lpAccelTbl
->tbl
[i
].wEvent
&&
325 (msg
->message
== WM_KEYDOWN
|| msg
->message
== WM_SYSKEYDOWN
)) {
328 if(GetKeyState(VK_SHIFT
) & 0x8000) mask
|= SHIFT_ACCEL
;
329 if(GetKeyState(VK_CONTROL
) & 0x8000) mask
|= CONTROL_ACCEL
;
330 if(GetKeyState(VK_MENU
) & 0x8000) mask
|= ALT_ACCEL
;
331 if(mask
== (lpAccelTbl
->tbl
[i
].type
&
332 (SHIFT_ACCEL
| CONTROL_ACCEL
| ALT_ACCEL
))) {
333 SendMessage16(hWnd
, WM_COMMAND
, lpAccelTbl
->tbl
[i
].wIDval
,
335 GlobalUnlock16(hAccel
);
338 if (msg
->message
== WM_KEYUP
|| msg
->message
== WM_SYSKEYUP
)
343 if (msg
->wParam
== lpAccelTbl
->tbl
[i
].wEvent
&&
344 msg
->message
== WM_CHAR
) {
345 SendMessage16(hWnd
, WM_COMMAND
, lpAccelTbl
->tbl
[i
].wIDval
, 0x00010000L
);
346 GlobalUnlock16(hAccel
);
351 GlobalUnlock16(hAccel
);
355 /**********************************************************************
359 LoadString(HANDLE instance
, WORD resource_id
, LPSTR buffer
, int buflen
)
366 dprintf_resource(stddeb
,"LoadString: inst=%04x id=%04x buff=%08x len=%d\n",
367 instance
, resource_id
, (int) buffer
, buflen
);
369 hrsrc
= FindResource( instance
, (SEGPTR
)((resource_id
>>4)+1), RT_STRING
);
370 if (!hrsrc
) return 0;
371 hmem
= LoadResource( instance
, hrsrc
);
374 p
= LockResource(hmem
);
375 string_num
= resource_id
& 0x000f;
376 for (i
= 0; i
< string_num
; i
++)
379 dprintf_resource( stddeb
, "strlen = %d\n", (int)*p
);
381 i
= MIN(buflen
- 1, *p
);
385 memcpy(buffer
, p
+ 1, i
);
392 fprintf(stderr
,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen
, *p
);
393 fprintf(stderr
,"LoadString // and try to obtain string '%s'\n", p
+ 1);
395 FreeResource( hmem
);
397 dprintf_resource(stddeb
,"LoadString // '%s' copied !\n", buffer
);