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