loader/resource.c

   1 /*
   2  * Resources
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <unistd.h>
  15 #include "arch.h"
  16 #include "windows.h"
  17 #include "gdi.h"
  18 #include "global.h"
  19 #include "neexe.h"
  20 #include "accel.h"
  21 #include "dlls.h"
  22 #include "module.h"
  23 #include "resource.h"
  24 #include "stddebug.h"
  25 #include "debug.h"
  26 #include "libres.h"
  27
  28 #define PrintId(name) \
  29     if (HIWORD((DWORD)name)) \
  30         dprintf_resource( stddeb, "'%s'", (char *)PTR_SEG_TO_LIN(name)); \
  31     else \
  32         dprintf_resource( stddeb, "#%04x", LOWORD(name));
  33
  34
  35 /**********************************************************************
  36  *          FindResource    (KERNEL.60)
  37  */
  38 HRSRC FindResource( HMODULE hModule, SEGPTR name, SEGPTR type )
  39 {
  40     WORD *pModule;
  41
  42     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
  43     dprintf_resource(stddeb, "FindResource: module="NPFMT" type=", hModule );
  44     PrintId( type );
  45     if (HIWORD(name))  /* Check for '#xxx' name */
  46     {
  47         char *ptr = PTR_SEG_TO_LIN( name );
  48         if (ptr[0] == '#') {
  49             if (!(name = (SEGPTR)atoi( ptr + 1 ))) return 0;
  50         }
  51     }
  52     dprintf_resource( stddeb, " name=" );
  53     PrintId( name );
  54     dprintf_resource( stddeb, "\n" );
  55     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
  56 #ifndef WINELIB
  57     switch(*pModule)
  58     {
  59       case NE_SIGNATURE:
  60         return NE_FindResource( hModule, type, name );
  61       case PE_SIGNATURE:
  62         return 0;
  63       default:
  64         return 0;
  65     }
  66 #else
  67     return LIBRES_FindResource( hModule, type, name );
  68 #endif
  69 }
  70
  71
  72 /**********************************************************************
  73  *          LoadResource    (KERNEL.61)
  74  */
  75 HGLOBAL LoadResource( HMODULE hModule, HRSRC hRsrc )
  76 {
  77     WORD *pModule;
  78
  79     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
  80     dprintf_resource(stddeb, "LoadResource: module="NPFMT" res="NPFMT"\n",
  81                      hModule, hRsrc );
  82     if (!hRsrc) return 0;
  83     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
  84 #ifndef WINELIB
  85     switch(*pModule)
  86     {
  87       case NE_SIGNATURE:
  88         return NE_LoadResource( hModule, hRsrc );
  89       case PE_SIGNATURE:
  90         return 0;
  91       default:
  92         return 0;
  93     }
  94 #else
  95     return LIBRES_LoadResource( hModule, hRsrc );
  96 #endif
  97 }
  98
  99
 100 /**********************************************************************
 101  *          LockResource    (KERNEL.62)
 102  */
 103 /* 16-bit version */
 104 SEGPTR WIN16_LockResource( HGLOBAL handle )
 105 {
 106     HMODULE hModule;
 107     WORD *pModule;
 108
 109     dprintf_resource(stddeb, "LockResource: handle="NPFMT"\n", handle );
 110     if (!handle) return (SEGPTR)0;
 111     hModule = GetExePtr( handle );
 112     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 113 #ifndef WINELIB
 114     switch(*pModule)
 115     {
 116       case NE_SIGNATURE:
 117         return NE_LockResource( hModule, handle );
 118       case PE_SIGNATURE:
 119         return 0;
 120       default:
 121         return 0;
 122     }
 123 #else
 124     return LIBRES_LockResource( hModule, handle );
 125 #endif
 126 }
 127
 128 /* 32-bit version */
 129 LPSTR LockResource( HGLOBAL handle )
 130 {
 131     HMODULE hModule;
 132     WORD *pModule;
 133
 134     dprintf_resource(stddeb, "LockResource: handle="NPFMT"\n", handle );
 135     if (!handle) return NULL;
 136     hModule = GetExePtr( handle );
 137     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 138 #ifndef WINELIB
 139     switch(*pModule)
 140     {
 141       case NE_SIGNATURE:
 142         return (LPSTR)PTR_SEG_TO_LIN( NE_LockResource( hModule, handle ) );
 143       case PE_SIGNATURE:
 144         return 0;
 145       default:
 146         return 0;
 147     }
 148 #else
 149     return LIBRES_LockResource( hModule, handle );
 150 #endif
 151 }
 152
 153
 154 /**********************************************************************
 155  *          FreeResource    (KERNEL.63)
 156  */
 157 BOOL FreeResource( HGLOBAL handle )
 158 {
 159     HMODULE hModule;
 160     WORD *pModule;
 161
 162     dprintf_resource(stddeb, "FreeResource: handle="NPFMT"\n", handle );
 163     if (!handle) return FALSE;
 164     hModule = GetExePtr( handle );
 165     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 166 #ifndef WINELIB
 167     switch(*pModule)
 168     {
 169       case NE_SIGNATURE:
 170         return NE_FreeResource( hModule, handle );
 171       case PE_SIGNATURE:
 172         return FALSE;
 173       default:
 174         return FALSE;
 175     }
 176 #else
 177     return LIBRES_FreeResource( hModule, handle );
 178 #endif
 179 }
 180
 181
 182 /**********************************************************************
 183  *          AccessResource    (KERNEL.64)
 184  */
 185 INT AccessResource( HINSTANCE hModule, HRSRC hRsrc )
 186 {
 187     WORD *pModule;
 188
 189     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 190     dprintf_resource(stddeb, "AccessResource: module="NPFMT" res="NPFMT"\n",
 191                      hModule, hRsrc );
 192     if (!hRsrc) return 0;
 193     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 194 #ifndef WINELIB
 195     switch(*pModule)
 196     {
 197       case NE_SIGNATURE:
 198         return NE_AccessResource( hModule, hRsrc );
 199       case PE_SIGNATURE:
 200         return 0;
 201       default:
 202         return 0;
 203     }
 204 #else
 205         return LIBRES_AccessResource( hModule, hRsrc );
 206 #endif
 207 }
 208
 209
 210 /**********************************************************************
 211  *          SizeofResource    (KERNEL.65)
 212  */
 213 DWORD SizeofResource( HMODULE hModule, HRSRC hRsrc )
 214 {
 215     WORD *pModule;
 216
 217     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 218     dprintf_resource(stddeb, "SizeofResource: module="NPFMT" res="NPFMT"\n",
 219                      hModule, hRsrc );
 220     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 221 #ifndef WINELIB
 222     switch(*pModule)
 223     {
 224       case NE_SIGNATURE:
 225         return NE_SizeofResource( hModule, hRsrc );
 226       case PE_SIGNATURE:
 227         return 0;
 228       default:
 229         return 0;
 230     }
 231 #else
 232     return LIBRES_SizeofResource( hModule, hRsrc );
 233 #endif
 234 }
 235
 236
 237 /**********************************************************************
 238  *          AllocResource    (KERNEL.66)
 239  */
 240 HGLOBAL AllocResource( HMODULE hModule, HRSRC hRsrc, DWORD size )
 241 {
 242     WORD *pModule;
 243
 244     hModule = GetExePtr( hModule );  /* In case we were passed an hInstance */
 245     dprintf_resource(stddeb, "AllocResource: module="NPFMT" res="NPFMT" size=%ld\n",
 246                      hModule, hRsrc, size );
 247     if (!hRsrc) return 0;
 248     if (!(pModule = (WORD *)GlobalLock( hModule ))) return 0;
 249 #ifndef WINELIB
 250     switch(*pModule)
 251     {
 252       case NE_SIGNATURE:
 253         return NE_AllocResource( hModule, hRsrc, size );
 254       case PE_SIGNATURE:
 255         return 0;
 256       default:
 257         return 0;
 258     }
 259 #else
 260     return LIBRES_AllocResource( hModule, hRsrc, size );
 261 #endif
 262 }
 263
 264 /**********************************************************************
 265  *      DirectResAlloc    (KERNEL.168)
 266  *
 267  * Check Schulman, p. 232 for details
 268  */
 269 HANDLE DirectResAlloc(HANDLE hInstance, WORD wType, WORD wSize)
 270 {
 271     dprintf_resource(stddeb,"DirectResAlloc("NPFMT",%x,%x)\n",hInstance,wType,wSize);
 272     hInstance = GetExePtr(hInstance);
 273     if(!hInstance)return 0;
 274     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
 275                            CreateCursorIndirect. */
 276         fprintf(stderr, "DirectResAlloc: wType = %x\n", wType);
 277     return GLOBAL_Alloc(GMEM_MOVEABLE, wSize, hInstance, FALSE, FALSE, FALSE);
 278 }
 279
 280
 281 /**********************************************************************
 282  *                      LoadAccelerators        [USER.177]
 283  */
 284 HANDLE LoadAccelerators(HANDLE instance, SEGPTR lpTableName)
 285 {
 286     HANDLE      hAccel;
 287     HANDLE      rsc_mem;
 288     HRSRC hRsrc;
 289     BYTE        *lp;
 290     ACCELHEADER *lpAccelTbl;
 291     int         i, n;
 292
 293     if (HIWORD(lpTableName))
 294         dprintf_accel( stddeb, "LoadAccelerators: "NPFMT" '%s'\n",
 295                       instance, (char *)PTR_SEG_TO_LIN( lpTableName ) );
 296     else
 297         dprintf_accel( stddeb, "LoadAccelerators: "NPFMT" %04x\n",
 298                        instance, LOWORD(lpTableName) );
 299
 300     if (!(hRsrc = FindResource( instance, lpTableName, RT_ACCELERATOR )))
 301       return 0;
 302     if (!(rsc_mem = LoadResource( instance, hRsrc ))) return 0;
 303
 304     lp = (BYTE *)LockResource(rsc_mem);
 305     n = SizeofResource( instance, hRsrc ) / sizeof(ACCELENTRY);
 306     hAccel = GlobalAlloc(GMEM_MOVEABLE,
 307         sizeof(ACCELHEADER) + (n + 1)*sizeof(ACCELENTRY));
 308     lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel);
 309     lpAccelTbl->wCount = 0;
 310     for (i = 0; i < n; i++) {
 311         lpAccelTbl->tbl[i].type = *(lp++);
 312         lpAccelTbl->tbl[i].wEvent = *((WORD *)lp);
 313         lp += 2;
 314         lpAccelTbl->tbl[i].wIDval = *((WORD *)lp);
 315         lp += 2;
 316         if (lpAccelTbl->tbl[i].wEvent == 0) break;
 317         dprintf_accel(stddeb,
 318                 "Accelerator #%u / event=%04X id=%04X type=%02X \n",
 319                 i, lpAccelTbl->tbl[i].wEvent, lpAccelTbl->tbl[i].wIDval,
 320                 lpAccelTbl->tbl[i].type);
 321         lpAccelTbl->wCount++;
 322         }
 323     GlobalUnlock(hAccel);
 324     FreeResource( rsc_mem );
 325     return hAccel;
 326 }
 327 \f
 328 /**********************************************************************
 329  *                      TranslateAccelerator    [USER.178]
 330  */
 331 int TranslateAccelerator(HWND hWnd, HANDLE hAccel, LPMSG msg)
 332 {
 333     ACCELHEADER *lpAccelTbl;
 334     int         i;
 335
 336     if (hAccel == 0 || msg == NULL) return 0;
 337     if (msg->message != WM_KEYDOWN &&
 338         msg->message != WM_KEYUP &&
 339         msg->message != WM_SYSKEYDOWN &&
 340         msg->message != WM_SYSKEYUP &&
 341         msg->message != WM_CHAR) return 0;
 342
 343     dprintf_accel(stddeb, "TranslateAccelerators hAccel="NPFMT" !\n", hAccel);
 344
 345     lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel);
 346     for (i = 0; i < lpAccelTbl->wCount; i++) {
 347         if(lpAccelTbl->tbl[i].type & VIRTKEY_ACCEL) {
 348             if(msg->wParam == lpAccelTbl->tbl[i].wEvent &&
 349                (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)) {
 350                 INT mask = 0;
 351
 352                 if(GetKeyState(VK_SHIFT) & 0xf) mask |= SHIFT_ACCEL;
 353                 if(GetKeyState(VK_CONTROL) & 0xf) mask |= CONTROL_ACCEL;
 354                 if(GetKeyState(VK_MENU) & 0xf) mask |= ALT_ACCEL;
 355                 if(mask == (lpAccelTbl->tbl[i].type &
 356                             (SHIFT_ACCEL | CONTROL_ACCEL | ALT_ACCEL))) {
 357                     SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval,
 358                                 0x00010000L);
 359                     GlobalUnlock(hAccel);
 360                     return 1;
 361                 }
 362                 if (msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
 363                     return 1;
 364             }
 365         }
 366         else {
 367             if (msg->wParam == lpAccelTbl->tbl[i].wEvent &&
 368                 msg->message == WM_CHAR) {
 369                 SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval, 0x00010000L);
 370                 GlobalUnlock(hAccel);
 371                 return 1;
 372                 }
 373             }
 374         }
 375     GlobalUnlock(hAccel);
 376     return 0;
 377 }
 378 \f
 379 /**********************************************************************
 380  *                                      LoadString
 381  */
 382 int
 383 LoadString(HANDLE instance, WORD resource_id, LPSTR buffer, int buflen)
 384 {
 385     HANDLE hmem, hrsrc;
 386     unsigned char *p;
 387     int string_num;
 388     int i;
 389
 390     dprintf_resource(stddeb, "LoadString: instance = "NPFMT", id = %04x, buffer = %08x, "
 391            "length = %d\n", instance, resource_id, (int) buffer, buflen);
 392
 393     hrsrc = FindResource( instance, (SEGPTR)((resource_id>>4)+1), RT_STRING );
 394     if (!hrsrc) return 0;
 395     hmem = LoadResource( instance, hrsrc );
 396     if (!hmem) return 0;
 397
 398     p = LockResource(hmem);
 399     string_num = resource_id & 0x000f;
 400     for (i = 0; i < string_num; i++)
 401         p += *p + 1;
 402
 403     dprintf_resource( stddeb, "strlen = %d\n", (int)*p );
 404
 405     i = MIN(buflen - 1, *p);
 406     if (buffer == NULL)
 407         return i;
 408     if (i > 0) {
 409         memcpy(buffer, p + 1, i);
 410         buffer[i] = '\0';
 411     } else {
 412         if (buflen > 1) {
 413             buffer[0] = '\0';
 414             return 0;
 415         }
 416         fprintf(stderr,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen, *p);
 417         fprintf(stderr,"LoadString // and try to obtain string '%s'\n", p + 1);
 418     }
 419     FreeResource( hmem );
 420
 421     dprintf_resource(stddeb,"LoadString // '%s' copied !\n", buffer);
 422     return i;
 423 }
 424
 425
 426