2 * USER resource functions
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include "wine/winbase16.h"
29 #include "wine/winuser16.h"
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(resource
);
35 WINE_DECLARE_DEBUG_CHANNEL(accel
);
37 /* this is the 8 byte accel struct used in Win32 resources (internal only) */
45 } PE_ACCEL
, *LPPE_ACCEL
;
47 /**********************************************************************
48 * LoadAccelerators [USER.177]
50 HACCEL16 WINAPI
LoadAccelerators16(HINSTANCE16 instance
, LPCSTR lpTableName
)
54 TRACE_(accel
)("%04x %s\n", instance
, debugstr_a(lpTableName
) );
56 if (!(hRsrc
= FindResource16( instance
, lpTableName
, (LPSTR
)RT_ACCELERATOR
))) {
57 WARN_(accel
)("couldn't find accelerator table resource\n");
61 TRACE_(accel
)("returning HACCEL 0x%x\n", hRsrc
);
62 return LoadResource16(instance
,hRsrc
);
65 /**********************************************************************
66 * LoadAcceleratorsW (USER32.@)
67 * The image layout seems to look like this (not 100% sure):
68 * 00: BYTE type type of accelerator
69 * 01: BYTE pad (to WORD boundary)
72 * 06: WORD pad (to DWORD boundary)
74 HACCEL WINAPI
LoadAcceleratorsW(HINSTANCE instance
,LPCWSTR lpTableName
)
81 if (HIWORD(lpTableName
))
82 TRACE_(accel
)("%p '%s'\n",
83 (LPVOID
)instance
, (char *)( lpTableName
) );
85 TRACE_(accel
)("%p 0x%04x\n",
86 (LPVOID
)instance
, LOWORD(lpTableName
) );
88 if (!(hRsrc
= FindResourceW( instance
, lpTableName
, (LPWSTR
)RT_ACCELERATOR
)))
90 WARN_(accel
)("couldn't find accelerator table resource\n");
92 hMem
= LoadResource( instance
, hRsrc
);
93 size
= SizeofResource( instance
, hRsrc
);
94 if(size
>=sizeof(PE_ACCEL
))
96 LPPE_ACCEL accel_table
= (LPPE_ACCEL
) hMem
;
98 int i
,nrofaccells
= size
/sizeof(PE_ACCEL
);
100 hRetval
= GlobalAlloc16(0,sizeof(ACCEL16
)*nrofaccells
);
101 accel16
= (LPACCEL16
)GlobalLock16(hRetval
);
102 for (i
=0;i
<nrofaccells
;i
++) {
103 accel16
[i
].fVirt
= accel_table
[i
].fVirt
& 0x7f;
104 accel16
[i
].key
= accel_table
[i
].key
;
105 if( !(accel16
[i
].fVirt
& FVIRTKEY
) )
106 accel16
[i
].key
&= 0x00ff;
107 accel16
[i
].cmd
= accel_table
[i
].cmd
;
109 accel16
[i
-1].fVirt
|= 0x80;
112 TRACE_(accel
)("returning HACCEL %p\n", hRsrc
);
113 return HACCEL_32(hRetval
);
116 /***********************************************************************
117 * LoadAcceleratorsA (USER32.@)
119 HACCEL WINAPI
LoadAcceleratorsA(HINSTANCE instance
,LPCSTR lpTableName
)
125 if (!HIWORD(lpTableName
)) return LoadAcceleratorsW( instance
, (LPCWSTR
)lpTableName
);
127 len
= MultiByteToWideChar( CP_ACP
, 0, lpTableName
, -1, NULL
, 0 );
128 if ((uni
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
130 MultiByteToWideChar( CP_ACP
, 0, lpTableName
, -1, uni
, len
);
131 result
= LoadAcceleratorsW(instance
,uni
);
132 HeapFree( GetProcessHeap(), 0, uni
);
137 /**********************************************************************
138 * CopyAcceleratorTableA (USER32.@)
140 INT WINAPI
CopyAcceleratorTableA(HACCEL src
, LPACCEL dst
, INT entries
)
142 return CopyAcceleratorTableW(src
, dst
, entries
);
145 /**********************************************************************
146 * CopyAcceleratorTableW (USER32.@)
148 * By mortene@pvv.org 980321
150 INT WINAPI
CopyAcceleratorTableW(HACCEL src
, LPACCEL dst
,
154 LPACCEL16 accel
= (LPACCEL16
)GlobalLock16(HACCEL_16(src
));
157 /* Do parameter checking to avoid the explosions and the screaming
158 as far as possible. */
159 if((dst
&& (entries
< 1)) || (src
== NULL
) || !accel
) {
160 WARN_(accel
)("Application sent invalid parameters (%p %p %d).\n",
161 (LPVOID
)src
, (LPVOID
)dst
, entries
);
164 xsize
= GlobalSize16(HACCEL_16(src
))/sizeof(ACCEL16
);
165 if (xsize
<entries
) entries
=xsize
;
169 /* Spit out some debugging information. */
170 TRACE_(accel
)("accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
171 i
, accel
[i
].fVirt
, accel
[i
].key
, accel
[i
].cmd
);
173 /* Copy data to the destination structure array (if dst == NULL,
174 we're just supposed to count the number of entries). */
176 dst
[i
].fVirt
= accel
[i
].fVirt
&0x7f;
177 dst
[i
].key
= accel
[i
].key
;
178 dst
[i
].cmd
= accel
[i
].cmd
;
180 /* Check if we've reached the end of the application supplied
181 accelerator table. */
186 /* The highest order bit seems to mark the end of the accelerator
187 resource table, but not always. Use GlobalSize() check too. */
188 if((accel
[i
].fVirt
& 0x80) != 0) done
= TRUE
;
196 /*********************************************************************
197 * CreateAcceleratorTableA (USER32.@)
199 * By mortene@pvv.org 980321
201 HACCEL WINAPI
CreateAcceleratorTableA(LPACCEL lpaccel
, INT cEntries
)
207 /* Do parameter checking just in case someone's trying to be
210 WARN_(accel
)("Application sent invalid parameters (%p %d).\n",
212 SetLastError(ERROR_INVALID_PARAMETER
);
216 /* Allocate memory and copy the table. */
217 hAccel
= HACCEL_32(GlobalAlloc16(0,cEntries
*sizeof(ACCEL16
)));
219 TRACE_(accel
)("handle %p\n", hAccel
);
221 ERR_(accel
)("Out of memory.\n");
222 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
225 accel
= GlobalLock16(HACCEL_16(hAccel
));
226 for (i
=0;i
<cEntries
;i
++) {
227 accel
[i
].fVirt
= lpaccel
[i
].fVirt
&0x7f;
228 accel
[i
].key
= lpaccel
[i
].key
;
229 if( !(accel
[i
].fVirt
& FVIRTKEY
) )
230 accel
[i
].key
&= 0x00ff;
231 accel
[i
].cmd
= lpaccel
[i
].cmd
;
233 /* Set the end-of-table terminator. */
234 accel
[cEntries
-1].fVirt
|= 0x80;
236 TRACE_(accel
)("Allocated accelerator handle %p with %d entries\n", hAccel
,cEntries
);
240 /*********************************************************************
241 * CreateAcceleratorTableW (USER32.@)
245 HACCEL WINAPI
CreateAcceleratorTableW(LPACCEL lpaccel
, INT cEntries
)
252 /* Do parameter checking just in case someone's trying to be
255 WARN_(accel
)("Application sent invalid parameters (%p %d).\n",
257 SetLastError(ERROR_INVALID_PARAMETER
);
261 /* Allocate memory and copy the table. */
262 hAccel
= HACCEL_32(GlobalAlloc16(0,cEntries
*sizeof(ACCEL16
)));
264 TRACE_(accel
)("handle %p\n", hAccel
);
266 ERR_(accel
)("Out of memory.\n");
267 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
270 accel
= GlobalLock16(HACCEL_16(hAccel
));
273 for (i
=0;i
<cEntries
;i
++) {
274 accel
[i
].fVirt
= lpaccel
[i
].fVirt
&0x7f;
275 if( !(accel
[i
].fVirt
& FVIRTKEY
) ) {
276 ckey
= (char) lpaccel
[i
].key
;
277 if(!MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, &ckey
, 1, &accel
[i
].key
, 1))
278 WARN_(accel
)("Error converting ASCII accelerator table to Unicode\n");
281 accel
[i
].key
= lpaccel
[i
].key
;
282 accel
[i
].cmd
= lpaccel
[i
].cmd
;
285 /* Set the end-of-table terminator. */
286 accel
[cEntries
-1].fVirt
|= 0x80;
288 TRACE_(accel
)("Allocated accelerator handle %p\n", hAccel
);
292 /******************************************************************************
293 * DestroyAcceleratorTable [USER32.@]
294 * Destroys an accelerator table
297 * By mortene@pvv.org 980321
300 * handle [I] Handle to accelerator table
304 BOOL WINAPI
DestroyAcceleratorTable( HACCEL handle
)
308 return !GlobalFree16(HACCEL_16(handle
));
311 /**********************************************************************
312 * LoadString (USER.176)
314 INT16 WINAPI
LoadString16( HINSTANCE16 instance
, UINT16 resource_id
,
315 LPSTR buffer
, INT16 buflen
)
323 TRACE("inst=%04x id=%04x buff=%08x len=%d\n",
324 instance
, resource_id
, (int) buffer
, buflen
);
326 hrsrc
= FindResource16( instance
, (LPCSTR
)((resource_id
>>4)+1), (LPSTR
)RT_STRING
);
327 if (!hrsrc
) return 0;
328 hmem
= LoadResource16( instance
, hrsrc
);
331 p
= LockResource16(hmem
);
332 string_num
= resource_id
& 0x000f;
333 for (i
= 0; i
< string_num
; i
++)
336 TRACE("strlen = %d\n", (int)*p
);
338 if (buffer
== NULL
) return *p
;
339 i
= min(buflen
- 1, *p
);
341 memcpy(buffer
, p
+ 1, i
);
348 WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
350 FreeResource16( hmem
);
352 TRACE("'%s' loaded !\n", buffer
);
356 /**********************************************************************
357 * LoadStringW (USER32.@)
359 INT WINAPI
LoadStringW( HINSTANCE instance
, UINT resource_id
,
360 LPWSTR buffer
, INT buflen
)
368 if (HIWORD(resource_id
)==0xFFFF) /* netscape 3 passes this */
369 resource_id
= (UINT
)(-((INT
)resource_id
));
370 TRACE("instance = %p, id = %04x, buffer = %08x, length = %d\n",
371 instance
, (int)resource_id
, (int) buffer
, buflen
);
373 /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
375 hrsrc
= FindResourceW( instance
, (LPCWSTR
)(((resource_id
>>4)&0xffff)+1),
377 if (!hrsrc
) return 0;
378 hmem
= LoadResource( instance
, hrsrc
);
381 p
= LockResource(hmem
);
382 string_num
= resource_id
& 0x000f;
383 for (i
= 0; i
< string_num
; i
++)
386 TRACE("strlen = %d\n", (int)*p
);
388 if (buffer
== NULL
) return *p
;
389 i
= min(buflen
- 1, *p
);
391 memcpy(buffer
, p
+ 1, i
* sizeof (WCHAR
));
392 buffer
[i
] = (WCHAR
) 0;
395 buffer
[0] = (WCHAR
) 0;
399 WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen
, *p
, p
+ 1);
403 TRACE("%s loaded !\n", debugstr_w(buffer
));
407 /**********************************************************************
408 * LoadStringA (USER32.@)
410 INT WINAPI
LoadStringA( HINSTANCE instance
, UINT resource_id
,
411 LPSTR buffer
, INT buflen
)
416 TRACE("instance = %p, id = %04x, buffer = %08x, length = %d\n",
417 instance
, (int)resource_id
, (int) buffer
, buflen
);
419 if(buffer
== NULL
) /* asked size of string */
420 return LoadStringW(instance
, resource_id
, NULL
, 0);
422 wbuf
= HeapAlloc(GetProcessHeap(), 0, buflen
* sizeof(WCHAR
));
426 retval
= LoadStringW(instance
, resource_id
, wbuf
, buflen
);
429 retval
= WideCharToMultiByte(CP_ACP
, 0, wbuf
, retval
, buffer
, buflen
- 1, NULL
, NULL
);
431 TRACE("%s loaded !\n", debugstr_a(buffer
));
433 else buffer
[0] = 0; /* no check of buflen here */
434 HeapFree( GetProcessHeap(), 0, wbuf
);
439 /**********************************************************************
440 * GetGuiResources (USER32.@)
442 DWORD WINAPI
GetGuiResources( HANDLE hProcess
, DWORD uiFlags
)
444 FIXME("(%p,%lx): stub\n",hProcess
,uiFlags
);
445 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);