Remove unneeded checks on the GetModuleHandle() return value for cases where we are...
[wine] / dlls / user32 / resource.c
1 /*
2  * USER resource functions
3  *
4  * Copyright 1993 Robert J. Amstadt
5  * Copyright 1995 Alexandre Julliard
6  *
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.
11  *
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.
16  *
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "winnls.h"
28 #include "wine/winbase16.h"
29 #include "wine/winuser16.h"
30 #include "wownt32.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(resource);
34 WINE_DECLARE_DEBUG_CHANNEL(accel);
35
36 /* this is the 8 byte accel struct used in Win32 resources (internal only) */
37 typedef struct
38 {
39     WORD   fVirt;
40     WORD   key;
41     WORD   cmd;
42     WORD   pad;
43 } PE_ACCEL, *LPPE_ACCEL;
44
45 /**********************************************************************
46  *                      LoadAccelerators        [USER.177]
47  */
48 HACCEL16 WINAPI LoadAccelerators16(HINSTANCE16 instance, LPCSTR lpTableName)
49 {
50     HRSRC16     hRsrc;
51
52     TRACE_(accel)("%04x %s\n", instance, debugstr_a(lpTableName) );
53
54     if (!(hRsrc = FindResource16( instance, lpTableName, (LPSTR)RT_ACCELERATOR ))) {
55       WARN_(accel)("couldn't find accelerator table resource\n");
56       return 0;
57     }
58
59     TRACE_(accel)("returning HACCEL 0x%x\n", hRsrc);
60     return LoadResource16(instance,hRsrc);
61 }
62
63 /**********************************************************************
64  *                      LoadAcceleratorsW       (USER32.@)
65  * The image layout seems to look like this (not 100% sure):
66  * 00:  WORD    type            type of accelerator
67  * 02:  WORD    event
68  * 04:  WORD    IDval
69  * 06:  WORD    pad             (to DWORD boundary)
70  */
71 HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance,LPCWSTR lpTableName)
72 {
73     HRSRC hRsrc;
74     HACCEL hMem;
75     HACCEL16 hRetval=0;
76     DWORD size;
77
78     if (HIWORD(lpTableName))
79         TRACE_(accel)("%p '%s'\n",
80                       (LPVOID)instance, (const char *)( lpTableName ) );
81     else
82         TRACE_(accel)("%p 0x%04x\n",
83                        (LPVOID)instance, LOWORD(lpTableName) );
84
85     if (!(hRsrc = FindResourceW( instance, lpTableName, (LPWSTR)RT_ACCELERATOR )))
86     {
87       WARN_(accel)("couldn't find accelerator table resource\n");
88     } else {
89       hMem = LoadResource( instance, hRsrc );
90       size = SizeofResource( instance, hRsrc );
91       if(size>=sizeof(PE_ACCEL))
92       {
93         LPPE_ACCEL accel_table = (LPPE_ACCEL) hMem;
94         LPACCEL16 accel16;
95         int i,nrofaccells = size/sizeof(PE_ACCEL);
96
97         hRetval = GlobalAlloc16(0,sizeof(ACCEL16)*nrofaccells);
98         accel16 = (LPACCEL16)GlobalLock16(hRetval);
99         for (i=0;i<nrofaccells;i++) {
100           accel16[i].fVirt = accel_table[i].fVirt & 0x7f;
101           accel16[i].key = accel_table[i].key;
102           if( !(accel16[i].fVirt & FVIRTKEY) )
103             accel16[i].key &= 0x00ff;
104           accel16[i].cmd = accel_table[i].cmd;
105         }
106         accel16[i-1].fVirt |= 0x80;
107       }
108     }
109     TRACE_(accel)("returning HACCEL %p\n", hRsrc);
110     return HACCEL_32(hRetval);
111 }
112
113 /***********************************************************************
114  *              LoadAcceleratorsA   (USER32.@)
115  */
116 HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
117 {
118     INT len;
119     LPWSTR uni;
120     HACCEL result = 0;
121
122     if (!HIWORD(lpTableName)) return LoadAcceleratorsW( instance, (LPCWSTR)lpTableName );
123
124     len = MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, NULL, 0 );
125     if ((uni = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
126     {
127         MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, uni, len );
128         result = LoadAcceleratorsW(instance,uni);
129         HeapFree( GetProcessHeap(), 0, uni);
130     }
131     return result;
132 }
133
134 /**********************************************************************
135  *             CopyAcceleratorTableA   (USER32.@)
136  */
137 INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT entries)
138 {
139   return CopyAcceleratorTableW(src, dst, entries);
140 }
141
142 /**********************************************************************
143  *             CopyAcceleratorTableW   (USER32.@)
144  *
145  * By mortene@pvv.org 980321
146  */
147 INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst,
148                                      INT entries)
149 {
150   int i,xsize;
151   LPACCEL16 accel = (LPACCEL16)GlobalLock16(HACCEL_16(src));
152   BOOL done = FALSE;
153
154   /* Do parameter checking to avoid the explosions and the screaming
155      as far as possible. */
156   if((dst && (entries < 1)) || (src == NULL) || !accel) {
157     WARN_(accel)("Application sent invalid parameters (%p %p %d).\n",
158          (LPVOID)src, (LPVOID)dst, entries);
159     return 0;
160   }
161   xsize = GlobalSize16(HACCEL_16(src))/sizeof(ACCEL16);
162   if (xsize<entries) entries=xsize;
163
164   i=0;
165   while(!done) {
166     /* Spit out some debugging information. */
167     TRACE_(accel)("accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
168           i, accel[i].fVirt, accel[i].key, accel[i].cmd);
169
170     /* Copy data to the destination structure array (if dst == NULL,
171        we're just supposed to count the number of entries). */
172     if(dst) {
173       dst[i].fVirt = accel[i].fVirt&0x7f;
174       dst[i].key = accel[i].key;
175       dst[i].cmd = accel[i].cmd;
176
177       /* Check if we've reached the end of the application supplied
178          accelerator table. */
179       if(i+1 == entries)
180         done = TRUE;
181     }
182
183     /* The highest order bit seems to mark the end of the accelerator
184        resource table, but not always. Use GlobalSize() check too. */
185     if((accel[i].fVirt & 0x80) != 0) done = TRUE;
186
187     i++;
188   }
189
190   return i;
191 }
192
193 /*********************************************************************
194  *                    CreateAcceleratorTableA   (USER32.@)
195  *
196  * By mortene@pvv.org 980321
197  */
198 HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT cEntries)
199 {
200   HACCEL        hAccel;
201   LPACCEL16     accel;
202   int           i;
203
204   /* Do parameter checking just in case someone's trying to be
205      funny. */
206   if(cEntries < 1) {
207     WARN_(accel)("Application sent invalid parameters (%p %d).\n",
208          lpaccel, cEntries);
209     SetLastError(ERROR_INVALID_PARAMETER);
210     return NULL;
211   }
212
213   /* Allocate memory and copy the table. */
214   hAccel = HACCEL_32(GlobalAlloc16(0,cEntries*sizeof(ACCEL16)));
215
216   TRACE_(accel)("handle %p\n", hAccel);
217   if(!hAccel) {
218     ERR_(accel)("Out of memory.\n");
219     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
220     return NULL;
221   }
222   accel = GlobalLock16(HACCEL_16(hAccel));
223   for (i=0;i<cEntries;i++) {
224     accel[i].fVirt = lpaccel[i].fVirt&0x7f;
225     accel[i].key = lpaccel[i].key;
226     if( !(accel[i].fVirt & FVIRTKEY) )
227       accel[i].key &= 0x00ff;
228     accel[i].cmd = lpaccel[i].cmd;
229   }
230   /* Set the end-of-table terminator. */
231   accel[cEntries-1].fVirt |= 0x80;
232
233   TRACE_(accel)("Allocated accelerator handle %p with %d entries\n", hAccel,cEntries);
234   return hAccel;
235 }
236
237 /*********************************************************************
238  *                    CreateAcceleratorTableW   (USER32.@)
239  *
240  *
241  */
242 HACCEL WINAPI CreateAcceleratorTableW(LPACCEL lpaccel, INT cEntries)
243 {
244   HACCEL        hAccel;
245   LPACCEL16     accel;
246   int           i;
247   char          ckey;
248
249   /* Do parameter checking just in case someone's trying to be
250      funny. */
251   if(cEntries < 1) {
252     WARN_(accel)("Application sent invalid parameters (%p %d).\n",
253          lpaccel, cEntries);
254     SetLastError(ERROR_INVALID_PARAMETER);
255     return NULL;
256   }
257
258   /* Allocate memory and copy the table. */
259   hAccel = HACCEL_32(GlobalAlloc16(0,cEntries*sizeof(ACCEL16)));
260
261   TRACE_(accel)("handle %p\n", hAccel);
262   if(!hAccel) {
263     ERR_(accel)("Out of memory.\n");
264     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
265     return NULL;
266   }
267   accel = GlobalLock16(HACCEL_16(hAccel));
268
269
270   for (i=0;i<cEntries;i++) {
271        accel[i].fVirt = lpaccel[i].fVirt&0x7f;
272        if( !(accel[i].fVirt & FVIRTKEY) ) {
273           ckey = (char) lpaccel[i].key;
274          if(!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, &ckey, 1, &accel[i].key, 1))
275             WARN_(accel)("Error converting ASCII accelerator table to Unicode\n");
276        }
277        else
278          accel[i].key = lpaccel[i].key;
279        accel[i].cmd = lpaccel[i].cmd;
280   }
281
282   /* Set the end-of-table terminator. */
283   accel[cEntries-1].fVirt |= 0x80;
284
285   TRACE_(accel)("Allocated accelerator handle %p\n", hAccel);
286   return hAccel;
287 }
288
289 /******************************************************************************
290  * DestroyAcceleratorTable [USER32.@]
291  * Destroys an accelerator table
292  *
293  * NOTES
294  *    By mortene@pvv.org 980321
295  *
296  * PARAMS
297  *    handle [I] Handle to accelerator table
298  *
299  * RETURNS
300  *    Success: TRUE
301  *    Failure: FALSE
302  */
303 BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
304 {
305     if( !handle )
306         return FALSE;
307     return !GlobalFree16(HACCEL_16(handle));
308 }
309
310 /**********************************************************************
311  *     LoadString   (USER.176)
312  */
313 INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
314                            LPSTR buffer, INT16 buflen )
315 {
316     HGLOBAL16 hmem;
317     HRSRC16 hrsrc;
318     unsigned char *p;
319     int string_num;
320     int i;
321
322     TRACE("inst=%04x id=%04x buff=%p len=%d\n",
323           instance, resource_id, buffer, buflen);
324
325     hrsrc = FindResource16( instance, MAKEINTRESOURCEA((resource_id>>4)+1), (LPSTR)RT_STRING );
326     if (!hrsrc) return 0;
327     hmem = LoadResource16( instance, hrsrc );
328     if (!hmem) return 0;
329
330     p = LockResource16(hmem);
331     string_num = resource_id & 0x000f;
332     for (i = 0; i < string_num; i++)
333         p += *p + 1;
334
335     TRACE("strlen = %d\n", (int)*p );
336
337     if (buffer == NULL) return *p;
338     i = min(buflen - 1, *p);
339     if (i > 0) {
340         memcpy(buffer, p + 1, i);
341         buffer[i] = '\0';
342     } else {
343         if (buflen > 1) {
344             buffer[0] = '\0';
345             return 0;
346         }
347         WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
348     }
349     FreeResource16( hmem );
350
351     TRACE("'%s' loaded !\n", buffer);
352     return i;
353 }
354
355 /**********************************************************************
356  *      LoadStringW             (USER32.@)
357  */
358 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
359                             LPWSTR buffer, INT buflen )
360 {
361     HGLOBAL hmem;
362     HRSRC hrsrc;
363     WCHAR *p;
364     int string_num;
365     int i;
366
367     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
368           instance, resource_id, buffer, buflen);
369
370     /* Use loword (incremented by 1) as resourceid */
371     hrsrc = FindResourceW( instance, MAKEINTRESOURCEW((LOWORD(resource_id) >> 4) + 1),
372                            (LPWSTR)RT_STRING );
373     if (!hrsrc) return 0;
374     hmem = LoadResource( instance, hrsrc );
375     if (!hmem) return 0;
376
377     p = LockResource(hmem);
378     string_num = resource_id & 0x000f;
379     for (i = 0; i < string_num; i++)
380         p += *p + 1;
381
382     TRACE("strlen = %d\n", (int)*p );
383
384     if (buffer == NULL) return *p;
385     i = min(buflen - 1, *p);
386     if (i > 0) {
387         memcpy(buffer, p + 1, i * sizeof (WCHAR));
388         buffer[i] = (WCHAR) 0;
389     } else {
390         if (buflen > 1) {
391             buffer[0] = (WCHAR) 0;
392             return 0;
393         }
394     }
395
396     TRACE("%s loaded !\n", debugstr_w(buffer));
397     return i;
398 }
399
400 /**********************************************************************
401  *      LoadStringA     (USER32.@)
402  */
403 INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
404                             LPSTR buffer, INT buflen )
405 {
406     INT    retval;
407     LPWSTR wbuf;
408
409     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
410           instance, resource_id, buffer, buflen);
411
412     if(buffer == NULL) /* asked size of string */
413         return LoadStringW(instance, resource_id, NULL, 0);
414
415     wbuf = HeapAlloc(GetProcessHeap(), 0, buflen * sizeof(WCHAR));
416     if(!wbuf)
417         return 0;
418
419     retval = LoadStringW(instance, resource_id, wbuf, buflen);
420     if(retval != 0)
421     {
422         retval = WideCharToMultiByte(CP_ACP, 0, wbuf, retval, buffer, buflen - 1, NULL, NULL);
423         buffer[retval] = 0;
424         TRACE("%s loaded !\n", debugstr_a(buffer));
425     }
426     else buffer[0] = 0;    /* no check of buflen here */
427     HeapFree( GetProcessHeap(), 0, wbuf );
428
429     return retval;
430 }
431
432 /**********************************************************************
433  *      GetGuiResources (USER32.@)
434  */
435 DWORD WINAPI GetGuiResources( HANDLE hProcess, DWORD uiFlags )
436 {
437     FIXME("(%p,%x): stub\n",hProcess,uiFlags);
438     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
439     return 0;
440 }