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