dlls/user/resource.c

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