win32/resource.c

   1 /*
   2  * Win32 Resources
   3  *
   4  * Copyright 1995 Thomas Sandford
   5  * Copyright 1996 Martin von Loewis
   6  *
   7  * Based on the Win16 resource handling code in loader/resource.c
   8  * Copyright 1993 Robert J. Amstadt
   9  * Copyright 1995 Alexandre Julliard
  10  *
  11  * This is not even at ALPHA level yet. Don't expect it to work!
  12  */
  13
  14 #include <sys/types.h>
  15 #include "wintypes.h"
  16 #include "windows.h"
  17 #include "kernel32.h"
  18 #include "pe_image.h"
  19 #include "module.h"
  20 #include "handle32.h"
  21 #include "libres.h"
  22 #include "resource32.h"
  23 #include "stackframe.h"
  24 #include "neexe.h"
  25 #include "accel.h"
  26 #include "xmalloc.h"
  27 #include "string32.h"
  28 #include "stddebug.h"
  29 #include "debug.h"
  30
  31 int language = 0x0409;
  32
  33 #if 0
  34 #define PrintId(name) \
  35     if (HIWORD((DWORD)name)) \
  36         dprintf_resource( stddeb, "'%s'", name); \
  37     else \
  38         dprintf_resource( stddeb, "#%04x", LOWORD(name));
  39 #else
  40 #define PrintId(name)
  41 #endif
  42
  43 /**********************************************************************
  44  *          GetResDirEntry
  45  *
  46  *      Helper function - goes down one level of PE resource tree
  47  *
  48  */
  49 PIMAGE_RESOURCE_DIRECTORY GetResDirEntry(PIMAGE_RESOURCE_DIRECTORY resdirptr,
  50                                          LPCWSTR name,
  51                                          DWORD root)
  52 {
  53     int entrynum;
  54     PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
  55         int namelen;
  56
  57     if (HIWORD(name)) {
  58     /* FIXME: what about #xxx names? */
  59         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
  60                         (BYTE *) resdirptr +
  61                         sizeof(IMAGE_RESOURCE_DIRECTORY));
  62         namelen = STRING32_lstrlenW(name);
  63         for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
  64         {
  65                 PIMAGE_RESOURCE_DIR_STRING_U str =
  66                 (PIMAGE_RESOURCE_DIR_STRING_U) (root +
  67                         (entryTable[entrynum].Name & 0x7fffffff));
  68                 if(namelen != str->Length)
  69                         continue;
  70                 if(STRING32_lstrcmpniW(name,str->NameString,str->Length)==0)
  71                         return (PIMAGE_RESOURCE_DIRECTORY) (
  72                                 root +
  73                                 (entryTable[entrynum].OffsetToData & 0x7fffffff));
  74         }
  75         return NULL;
  76     } else {
  77         entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
  78                         (BYTE *) resdirptr +
  79                         sizeof(IMAGE_RESOURCE_DIRECTORY) +
  80                         resdirptr->NumberOfNamedEntries * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
  81         for (entrynum = 0; entrynum < resdirptr->NumberOfIdEntries; entrynum++)
  82             if ((DWORD)entryTable[entrynum].Name == (DWORD)name)
  83                 return (PIMAGE_RESOURCE_DIRECTORY) (
  84                         root +
  85                         (entryTable[entrynum].OffsetToData & 0x7fffffff));
  86         return NULL;
  87     }
  88 }
  89
  90 /**********************************************************************
  91  *          FindResource    (KERNEL.60)
  92  */
  93 HANDLE32 FindResource32( HINSTANCE hModule, LPCWSTR name, LPCWSTR type )
  94 {
  95 #ifndef WINELIB
  96     PE_MODULE *pe;
  97     NE_MODULE *pModule;
  98     PIMAGE_RESOURCE_DIRECTORY resdirptr;
  99     DWORD root;
 100         HANDLE32 result;
 101
 102     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 103     dprintf_resource(stddeb, "FindResource: module=%08x type=", hModule );
 104     PrintId( type );
 105     dprintf_resource( stddeb, " name=" );
 106     PrintId( name );
 107     dprintf_resource( stddeb, "\n" );
 108     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 109     if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0;  /* FIXME? */
 110     if (!(pe = pModule->pe_module) || !pe->pe_resource) return 0;
 111
 112     resdirptr = (PIMAGE_RESOURCE_DIRECTORY) pe->pe_resource;
 113     root = (DWORD) resdirptr;
 114     if ((resdirptr = GetResDirEntry(resdirptr, type, root)) == NULL)
 115         return 0;
 116     if ((resdirptr = GetResDirEntry(resdirptr, name, root)) == NULL)
 117         return 0;
 118     result = GetResDirEntry(resdirptr, (LPCWSTR)language, root);
 119         /* Try LANG_NEUTRAL, too */
 120     if(!result)
 121         return GetResDirEntry(resdirptr, (LPCWSTR)0, root);
 122     return result;
 123
 124 #else
 125     return LIBRES_FindResource( hModule, name, type );
 126 #endif
 127 }
 128
 129
 130 /**********************************************************************
 131  *          LoadResource    (KERNEL.61)
 132  */
 133 HANDLE32 LoadResource32( HINSTANCE hModule, HANDLE32 hRsrc )
 134 {
 135 #ifndef WINELIB
 136     NE_MODULE *pModule;
 137     PE_MODULE *pe;
 138
 139     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 140     dprintf_resource(stddeb, "LoadResource: module=%04x res=%04x\n",
 141                      hModule, hRsrc );
 142     if (!hRsrc) return 0;
 143
 144     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 145     if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0;  /* FIXME? */
 146     if (!(pe = pModule->pe_module) || !pe->pe_resource) return 0;
 147     return (HANDLE32) (pe->load_addr+((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
 148 #else
 149     return LIBRES_LoadResource( hModule, hRsrc );
 150 #endif
 151 }
 152
 153
 154 /**********************************************************************
 155  *          LockResource    (KERNEL.62)
 156  */
 157 LPVOID LockResource32( HANDLE32 handle )
 158 {
 159         return (LPVOID) handle;
 160 }
 161
 162 /**********************************************************************
 163  *          FreeResource    (KERNEL.63)
 164  */
 165 BOOL FreeResource32( HANDLE32 handle )
 166 {
 167     /* no longer used in Win32 */
 168     return TRUE;
 169 }
 170
 171 /**********************************************************************
 172  *          AccessResource    (KERNEL.64)
 173  */
 174 INT AccessResource32( HINSTANCE hModule, HRSRC hRsrc )
 175 {
 176     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 177     dprintf_resource(stddeb, "AccessResource: module=%04x res=%04x\n",
 178                      hModule, hRsrc );
 179     if (!hRsrc) return 0;
 180         fprintf(stderr,"AccessResource32: not implemented\n");
 181         return 0;
 182 }
 183
 184
 185 /**********************************************************************
 186  *          SizeofResource    (KERNEL.65)
 187  */
 188 DWORD SizeofResource32( HINSTANCE hModule, HRSRC hRsrc )
 189 {
 190     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 191     dprintf_resource(stddeb, "SizeofResource: module=%04x res=%04x\n",
 192                      hModule, hRsrc );
 193         fprintf(stderr,"SizeofResource32: not implemented\n");
 194         return 0;
 195 }
 196
 197 /**********************************************************************
 198  *                      LoadAccelerators        [USER.177]
 199 */
 200 HANDLE32 WIN32_LoadAcceleratorsW(HINSTANCE instance, LPCWSTR lpTableName)
 201 {
 202 #if 0
 203     HANDLE32    hAccel;
 204     HANDLE32    rsc_mem;
 205     HANDLE32 hRsrc;
 206     BYTE        *lp;
 207     ACCELHEADER *lpAccelTbl;
 208     int         i, n;
 209
 210     if (HIWORD(lpTableName))
 211         dprintf_accel( stddeb, "LoadAccelerators: %04x '%s'\n",
 212                       instance, (char *)( lpTableName ) );
 213     else
 214         dprintf_accel( stddeb, "LoadAccelerators: %04x %04x\n",
 215                        instance, LOWORD(lpTableName) );
 216
 217     if (!(hRsrc = FindResource32( instance, lpTableName,
 218                 (LPCWSTR)RT_ACCELERATOR )))
 219       return 0;
 220     if (!(rsc_mem = LoadResource32( instance, hRsrc ))) return 0;
 221
 222     lp = (BYTE *)LockResource32(rsc_mem);
 223     n = SizeofResource( instance, hRsrc ) / sizeof(ACCELENTRY);
 224     hAccel = GlobalAlloc16(GMEM_MOVEABLE,
 225         sizeof(ACCELHEADER) + (n + 1)*sizeof(ACCELENTRY));
 226     lpAccelTbl = (LPACCELHEADER)GlobalLock16(hAccel);
 227     lpAccelTbl->wCount = 0;
 228     for (i = 0; i < n; i++) {
 229         lpAccelTbl->tbl[i].type = *(lp++);
 230         lpAccelTbl->tbl[i].wEvent = *((WORD *)lp);
 231         lp += 2;
 232         lpAccelTbl->tbl[i].wIDval = *((WORD *)lp);
 233         lp += 2;
 234         if (lpAccelTbl->tbl[i].wEvent == 0) break;
 235         dprintf_accel(stddeb,
 236                 "Accelerator #%u / event=%04X id=%04X type=%02X \n",
 237                 i, lpAccelTbl->tbl[i].wEvent, lpAccelTbl->tbl[i].wIDval,
 238                 lpAccelTbl->tbl[i].type);
 239         lpAccelTbl->wCount++;
 240         }
 241     GlobalUnlock16(hAccel);
 242     FreeResource( rsc_mem );
 243     return hAccel;
 244 #else
 245         fprintf(stderr,"LoadAcceleratorsW: not implemented\n");
 246         return 0;
 247 #endif
 248 }
 249
 250 HANDLE32 WIN32_LoadAcceleratorsA(HINSTANCE instance, LPCSTR lpTableName)
 251 {
 252         LPWSTR          uni;
 253         HANDLE32        result;
 254         if (HIWORD(lpTableName))
 255                 uni=STRING32_DupAnsiToUni(lpTableName);
 256         else
 257                 uni=(LPWSTR)lpTableName;
 258         result=WIN32_LoadAcceleratorsW(instance,uni);
 259         if (HIWORD(uni))
 260                 free(uni);
 261         return result;
 262 }
 263 \f
 264 /**********************************************************************
 265  *                                      LoadString
 266  */
 267 int
 268 WIN32_LoadStringW(HINSTANCE instance, DWORD resource_id, LPWSTR buffer, int buflen)
 269 {
 270     HANDLE32 hmem, hrsrc;
 271     WCHAR *p;
 272     int string_num;
 273     int i;
 274
 275     dprintf_resource(stddeb, "LoadString: instance = %04x, id = %04x, buffer = %08x, "
 276            "length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
 277
 278     hrsrc = FindResource32( instance, (LPCWSTR)((resource_id>>4)+1),
 279                 (LPCWSTR)RT_STRING );
 280     if (!hrsrc) return 0;
 281     hmem = LoadResource32( instance, hrsrc );
 282     if (!hmem) return 0;
 283
 284     p = LockResource32(hmem);
 285     string_num = resource_id & 0x000f;
 286     for (i = 0; i < string_num; i++)
 287         p += *p + 1;
 288
 289     dprintf_resource( stddeb, "strlen = %d\n", (int)*p );
 290
 291     i = MIN(buflen - 1, *p);
 292     if (buffer == NULL)
 293         return i;
 294     if (i > 0) {
 295         memcpy(buffer, p + 1, i * sizeof (WCHAR));
 296         buffer[i] = (WCHAR) 0;
 297     } else {
 298         if (buflen > 1) {
 299             buffer[0] = (WCHAR) 0;
 300             return 0;
 301         }
 302 #if 0
 303         fprintf(stderr,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen, *p);
 304         fprintf(stderr,"LoadString // and try to obtain string '%s'\n", p + 1);
 305 #endif
 306     }
 307     dprintf_resource(stddeb,"LoadString // '%s' copied !\n", buffer);
 308     return i;
 309 }
 310 \f
 311 /**********************************************************************
 312  *                                      LoadStringA
 313  */
 314 int
 315 WIN32_LoadStringA(HINSTANCE instance, DWORD resource_id, LPSTR buffer, int buflen)
 316 {
 317     WCHAR *buffer2 = xmalloc(buflen*2);
 318     int retval = WIN32_LoadStringW(instance, resource_id, buffer2, buflen);
 319
 320     while (*buffer2)
 321         *buffer++ = (char) *buffer2++;
 322     *buffer = 0;
 323     return retval;
 324 }
 325
 326 HICON LoadIconW32(HINSTANCE hisnt, LPCWSTR lpszIcon)
 327
 328 {
 329         return LoadIcon(0, IDI_APPLICATION);
 330 }
 331
 332 HICON LoadIconA32(HINSTANCE hinst, LPCSTR lpszIcon)
 333
 334 {
 335         return LoadIconW32(hinst, lpszIcon);
 336 }
 337 /**********************************************************************
 338  *          LoadBitmapW
 339  */
 340 HBITMAP WIN32_LoadBitmapW( HANDLE instance, LPCWSTR name )
 341 {
 342     HBITMAP hbitmap = 0;
 343     HDC hdc;
 344     HANDLE32 hRsrc;
 345     HANDLE32 handle;
 346     BITMAPINFO *info;
 347
 348     if (!instance)  /* OEM bitmap */
 349     {
 350         if (HIWORD((int)name)) return 0;
 351         return OBM_LoadBitmap( LOWORD((int)name) );
 352     }
 353
 354     if (!(hRsrc = FindResource32( instance, name,
 355                 (LPWSTR)RT_BITMAP ))) return 0;
 356     if (!(handle = LoadResource32( instance, hRsrc ))) return 0;
 357
 358     info = (BITMAPINFO *)LockResource32( handle );
 359     if ((hdc = GetDC(0)) != 0)
 360     {
 361         char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
 362         hbitmap = CreateDIBitmap( hdc, &info->bmiHeader, CBM_INIT,
 363                                   bits, info, DIB_RGB_COLORS );
 364         ReleaseDC( 0, hdc );
 365     }
 366     return hbitmap;
 367 }
 368 /**********************************************************************
 369  *          LoadBitmapA
 370  */
 371 HBITMAP WIN32_LoadBitmapA( HANDLE instance, LPCSTR name )
 372 {
 373     HBITMAP res;
 374     if(!HIWORD(name))
 375         res = WIN32_LoadBitmapW(instance,(LPWSTR)name);
 376     else{
 377         LPWSTR uni=STRING32_DupAnsiToUni(name);
 378         res=WIN32_LoadBitmapW(instance,uni);
 379         free(uni);
 380     }
 381     return res;
 382 }
 383
 384 /*****************************************************************
 385  *        LoadMenuW                 (USER32.372)
 386  */
 387 HMENU WIN32_LoadMenuW(HANDLE instance, LPCWSTR name)
 388 {
 389         HANDLE32 hrsrc;
 390         hrsrc=FindResource32(instance,name,(LPWSTR)RT_MENU);
 391         if(!hrsrc)return 0;
 392         return LoadMenuIndirect32W( LoadResource32(instance, hrsrc) );
 393 }
 394
 395 /*****************************************************************
 396  *        LoadMenuA                 (USER32.370)
 397  */
 398 HMENU WIN32_LoadMenuA(HANDLE instance,LPCSTR name)
 399 {
 400         HMENU res;
 401         if(!HIWORD(name))
 402                 res = WIN32_LoadMenuW(instance,(LPWSTR)name);
 403         else{
 404                 LPWSTR uni=STRING32_DupAnsiToUni(name);
 405                 res=WIN32_LoadMenuW(instance,uni);
 406                 free(uni);
 407         }
 408         return res;
 409 }