Log missing environment vars for easier debugging.
[wine] / dlls / user / 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 STD
300  */
301 BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
302 {
303     if( !handle )
304         return FALSE;
305     return !GlobalFree16(HACCEL_16(handle));
306 }
307
308 /**********************************************************************
309  *     LoadString   (USER.176)
310  */
311 INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
312                            LPSTR buffer, INT16 buflen )
313 {
314     HGLOBAL16 hmem;
315     HRSRC16 hrsrc;
316     unsigned char *p;
317     int string_num;
318     int i;
319
320     TRACE("inst=%04x id=%04x buff=%08x len=%d\n",
321           instance, resource_id, (int) buffer, buflen);
322
323     hrsrc = FindResource16( instance, (LPCSTR)((resource_id>>4)+1), (LPSTR)RT_STRING );
324     if (!hrsrc) return 0;
325     hmem = LoadResource16( instance, hrsrc );
326     if (!hmem) return 0;
327
328     p = LockResource16(hmem);
329     string_num = resource_id & 0x000f;
330     for (i = 0; i < string_num; i++)
331         p += *p + 1;
332
333     TRACE("strlen = %d\n", (int)*p );
334
335     if (buffer == NULL) return *p;
336     i = min(buflen - 1, *p);
337     if (i > 0) {
338         memcpy(buffer, p + 1, i);
339         buffer[i] = '\0';
340     } else {
341         if (buflen > 1) {
342             buffer[0] = '\0';
343             return 0;
344         }
345         WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
346     }
347     FreeResource16( hmem );
348
349     TRACE("'%s' loaded !\n", buffer);
350     return i;
351 }
352
353 /**********************************************************************
354  *      LoadStringW             (USER32.@)
355  */
356 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
357                             LPWSTR buffer, INT buflen )
358 {
359     HGLOBAL hmem;
360     HRSRC hrsrc;
361     WCHAR *p;
362     int string_num;
363     int i;
364
365     if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
366         resource_id = (UINT)(-((INT)resource_id));
367     TRACE("instance = %p, id = %04x, buffer = %08x, length = %d\n",
368           instance, (int)resource_id, (int) buffer, buflen);
369
370     /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
371      * 20 - 31. */
372     hrsrc = FindResourceW( instance, (LPCWSTR)(((resource_id>>4)&0xffff)+1),
373                            (LPWSTR)RT_STRING );
374     if (!hrsrc) return 0;
375     hmem = LoadResource( instance, hrsrc );
376     if (!hmem) return 0;
377
378     p = LockResource(hmem);
379     string_num = resource_id & 0x000f;
380     for (i = 0; i < string_num; i++)
381         p += *p + 1;
382
383     TRACE("strlen = %d\n", (int)*p );
384
385     if (buffer == NULL) return *p;
386     i = min(buflen - 1, *p);
387     if (i > 0) {
388         memcpy(buffer, p + 1, i * sizeof (WCHAR));
389         buffer[i] = (WCHAR) 0;
390     } else {
391         if (buflen > 1) {
392             buffer[0] = (WCHAR) 0;
393             return 0;
394         }
395 #if 0
396         WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
397 #endif
398     }
399
400     TRACE("%s loaded !\n", debugstr_w(buffer));
401     return i;
402 }
403
404 /**********************************************************************
405  *      LoadStringA     (USER32.@)
406  */
407 INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
408                             LPSTR buffer, INT buflen )
409 {
410     INT    retval;
411     LPWSTR wbuf;
412
413     TRACE("instance = %p, id = %04x, buffer = %08x, length = %d\n",
414           instance, (int)resource_id, (int) buffer, buflen);
415
416     if(buffer == NULL) /* asked size of string */
417         return LoadStringW(instance, resource_id, NULL, 0);
418
419     wbuf = HeapAlloc(GetProcessHeap(), 0, buflen * sizeof(WCHAR));
420     if(!wbuf)
421         return 0;
422
423     retval = LoadStringW(instance, resource_id, wbuf, buflen);
424     if(retval != 0)
425     {
426         retval = WideCharToMultiByte(CP_ACP, 0, wbuf, retval, buffer, buflen - 1, NULL, NULL);
427         buffer[retval] = 0;
428         TRACE("%s loaded !\n", debugstr_a(buffer));
429     }
430     else buffer[0] = 0;    /* no check of buflen here */
431     HeapFree( GetProcessHeap(), 0, wbuf );
432
433     return retval;
434 }
435
436 /**********************************************************************
437  *      GetGuiResources (USER32.@)
438  */
439 DWORD WINAPI GetGuiResources( HANDLE hProcess, DWORD uiFlags )
440 {
441     FIXME("(%p,%lx): stub\n",hProcess,uiFlags);
442     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
443     return 0;
444 }