misc/resource.c

   1 #ifndef WINELIB
   2 static char RCSId[] = "$Id: resource.c,v 1.4 1993/07/04 04:04:21 root Exp root $";
   3 static char Copyright[] = "Copyright  Robert J. Amstadt, 1993";
   4 #endif
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11 #include <unistd.h>
  12 #include "arch.h"
  13 #include "prototypes.h"
  14 #include "windows.h"
  15 #include "gdi.h"
  16 #include "wine.h"
  17 #include "icon.h"
  18 #include "accel.h"
  19
  20 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  21
  22 typedef struct resource_s
  23 {
  24     struct resource_s *next;
  25     HANDLE info_mem;
  26     int size_shift;
  27     struct resource_nameinfo_s nameinfo;
  28     HANDLE rsc_mem;
  29 } RESOURCE;
  30
  31 static int ResourceFd = -1;
  32 static HANDLE ResourceInst = 0;
  33 static struct w_files *ResourceFileInfo = NULL;
  34 static RESOURCE *Top = NULL;
  35 extern HINSTANCE hSysRes;
  36
  37 HANDLE RSC_LoadResource(int instance, char *rsc_name, int type, int *image_size_ret);
  38
  39 extern char *ProgramName;
  40
  41 /*****************************************************************************
  42   * Super Patch, I promise to arrange things as soon as I can.
  43   *
  44 ******************************************************************************/
  45 #ifdef WINELIB
  46 #include "../loader/wine.c"
  47 #endif
  48
  49 \f
  50 /**********************************************************************
  51  *                                      OpenResourceFile
  52  */
  53 int
  54 OpenResourceFile(HANDLE instance)
  55 {
  56     struct w_files *w;
  57     char   *res_file;
  58
  59     if (ResourceInst == instance)
  60         return ResourceFd;
  61
  62     w = GetFileInfo(instance);
  63     if (w == NULL)
  64         return -1;
  65     ResourceFileInfo = w;
  66     res_file = w->filename;
  67
  68     if (ResourceFd >= 0)
  69         close(ResourceFd);
  70
  71     ResourceInst = instance;
  72
  73     ResourceFd = open (res_file, O_RDONLY);
  74
  75 #ifdef DEBUG_RESOURCE
  76     printf("OpenResourceFile(%04X) // file='%s' hFile=%04X !\n",
  77                 instance, w->filename, ResourceFd);
  78 #endif
  79     return ResourceFd;
  80 }
  81 \f
  82 /**********************************************************************
  83  *                                      ConvertCoreBitmap
  84  */
  85 HBITMAP
  86 ConvertCoreBitmap( HDC hdc, BITMAPCOREHEADER * image )
  87 {
  88     BITMAPINFO * bmpInfo;
  89     HBITMAP hbitmap;
  90     char * bits;
  91     int i, size, n_colors;
  92
  93     n_colors = 1 << image->bcBitCount;
  94
  95     if (image->bcBitCount < 24)
  96     {
  97         size = sizeof(BITMAPINFOHEADER) + n_colors * sizeof(RGBQUAD);
  98         bits = (char *) (image + 1) + (n_colors * sizeof(RGBTRIPLE));
  99     }
 100     else
 101     {
 102         size = sizeof(BITMAPINFOHEADER);
 103         bits = (char *) (image + 1);
 104     }
 105     bmpInfo = (BITMAPINFO *) malloc( size );
 106
 107     bmpInfo->bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
 108     bmpInfo->bmiHeader.biWidth         = image->bcWidth;
 109     bmpInfo->bmiHeader.biHeight        = image->bcHeight;
 110     bmpInfo->bmiHeader.biPlanes        = image->bcPlanes;
 111     bmpInfo->bmiHeader.biBitCount      = image->bcBitCount;
 112     bmpInfo->bmiHeader.biCompression   = 0;
 113     bmpInfo->bmiHeader.biSizeImage     = 0;
 114     bmpInfo->bmiHeader.biXPelsPerMeter = 0;
 115     bmpInfo->bmiHeader.biYPelsPerMeter = 0;
 116     bmpInfo->bmiHeader.biClrUsed       = 0;
 117     bmpInfo->bmiHeader.biClrImportant  = 0;
 118
 119     if (image->bcBitCount < 24)
 120     {
 121         RGBTRIPLE * oldMap = (RGBTRIPLE *)(image + 1);
 122         RGBQUAD * newMap = bmpInfo->bmiColors;
 123         for (i = 0; i < n_colors; i++, oldMap++, newMap++)
 124         {
 125             newMap->rgbRed      = oldMap->rgbtRed;
 126             newMap->rgbGreen    = oldMap->rgbtGreen;
 127             newMap->rgbBlue     = oldMap->rgbtBlue;
 128             newMap->rgbReserved = 0;
 129         }
 130     }
 131
 132     hbitmap = CreateDIBitmap( hdc, &bmpInfo->bmiHeader, CBM_INIT,
 133                               bits, bmpInfo, DIB_RGB_COLORS );
 134     free( bmpInfo );
 135     return hbitmap;
 136 }
 137
 138 /**********************************************************************
 139  *                                      ConvertInfoBitmap
 140  */
 141 HBITMAP
 142 ConvertInfoBitmap( HDC hdc, BITMAPINFO * image )
 143 {
 144     char * bits = ((char *)image) + DIB_BitmapInfoSize(image, DIB_RGB_COLORS);
 145     return CreateDIBitmap( hdc, &image->bmiHeader, CBM_INIT,
 146                            bits, image, DIB_RGB_COLORS );
 147 }
 148 \f
 149 #ifndef WINELIB
 150 load_typeinfo (int fd, struct resource_typeinfo_s *typeinfo)
 151 {
 152     return read (fd, typeinfo, sizeof (*typeinfo)) == sizeof (*typeinfo);
 153 }
 154 #endif
 155 /**********************************************************************
 156  *                                      FindResourceByNumber
 157  */
 158 int
 159 FindResourceByNumber(struct resource_nameinfo_s *result_p,
 160                      int type_id, int resource_id)
 161 {
 162     struct resource_typeinfo_s typeinfo;
 163     struct resource_nameinfo_s nameinfo;
 164     unsigned short size_shift;
 165     int i;
 166     off_t rtoff;
 167
 168     /*
 169      * Move to beginning of resource table.
 170      */
 171     rtoff = (ResourceFileInfo->mz_header->ne_offset +
 172              ResourceFileInfo->ne_header->resource_tab_offset);
 173     lseek(ResourceFd, rtoff, SEEK_SET);
 174
 175     /*
 176      * Read block size.
 177      */
 178     if (read(ResourceFd, &size_shift, sizeof(size_shift)) !=
 179         sizeof(size_shift))
 180     {
 181         printf("FindResourceByNumber (%s) bad block size !\n", resource_id);
 182         return -1;
 183     }
 184     size_shift = CONV_SHORT(size_shift);
 185     /*
 186      * Find resource.
 187      */
 188     typeinfo.type_id = 0xffff;
 189     while (typeinfo.type_id != 0) {
 190         if (!load_typeinfo (ResourceFd, &typeinfo)){
 191             printf("FindResourceByNumber (%X) bad typeinfo size !\n", resource_id);
 192             return -1;
 193             }
 194 #ifdef DEBUG_RESOURCE
 195         printf("FindResourceByNumber type=%X count=%d searched=%d \n",
 196                         typeinfo.type_id, typeinfo.count, type_id);
 197 #endif
 198         if (typeinfo.type_id == 0) break;
 199         if (typeinfo.type_id == type_id || type_id == -1) {
 200             for (i = 0; i < typeinfo.count; i++) {
 201 #ifndef WINELIB
 202                 if (read(ResourceFd, &nameinfo, sizeof(nameinfo)) !=
 203                     sizeof(nameinfo))
 204 #else
 205                 if (!load_nameinfo (ResourceFd, &nameinfo))
 206 #endif
 207                 {
 208                     printf("FindResourceByNumber (%X) bad nameinfo size !\n", resource_id);
 209                     return -1;
 210                     }
 211 #ifdef DEBUG_RESOURCE
 212                 printf("FindResource: search type=%X id=%X // type=%X id=%X\n",
 213                         type_id, resource_id, typeinfo.type_id, nameinfo.id);
 214 #endif
 215                 if (nameinfo.id == resource_id) {
 216                     memcpy(result_p, &nameinfo, sizeof(nameinfo));
 217                     return size_shift;
 218                     }
 219                 }
 220             }
 221         else {
 222             lseek(ResourceFd, (typeinfo.count * sizeof(nameinfo)), SEEK_CUR);
 223             }
 224         }
 225     return -1;
 226 }
 227 \f
 228 /**********************************************************************
 229  *                                      FindResourceByName
 230  */
 231 int
 232 FindResourceByName(struct resource_nameinfo_s *result_p,
 233                      int type_id, char *resource_name)
 234 {
 235     struct resource_typeinfo_s typeinfo;
 236     struct resource_nameinfo_s nameinfo;
 237     unsigned short size_shift;
 238     off_t old_pos, new_pos;
 239     unsigned char nbytes;
 240     char name[256];
 241     int i;
 242     off_t rtoff;
 243
 244     /*
 245      * Move to beginning of resource table.
 246      */
 247     rtoff = (ResourceFileInfo->mz_header->ne_offset +
 248              ResourceFileInfo->ne_header->resource_tab_offset);
 249     lseek(ResourceFd, rtoff, SEEK_SET);
 250
 251     /*
 252      * Read block size.
 253      */
 254     if (read(ResourceFd, &size_shift, sizeof(size_shift)) !=
 255         sizeof(size_shift))
 256     {
 257         printf("FindResourceByName (%s) bad block size !\n", resource_name);
 258         return -1;
 259     }
 260     size_shift = CONV_SHORT (size_shift);
 261
 262     /*
 263      * Find resource.
 264      */
 265     typeinfo.type_id = 0xffff;
 266     while (typeinfo.type_id != 0)
 267     {
 268         if (!load_typeinfo (ResourceFd, &typeinfo))
 269         {
 270             printf("FindResourceByName (%s) bad typeinfo size !\n", resource_name);
 271             return -1;
 272         }
 273 #ifdef DEBUG_RESOURCE
 274         printf("FindResourceByName typeinfo.type_id=%X count=%d type_id=%X\n",
 275                         typeinfo.type_id, typeinfo.count, type_id);
 276 #endif
 277         if (typeinfo.type_id == 0) break;
 278         if (typeinfo.type_id == type_id || type_id == -1)
 279         {
 280             for (i = 0; i < typeinfo.count; i++)
 281             {
 282 #ifndef WINELIB
 283                 if (read(ResourceFd, &nameinfo, sizeof(nameinfo)) !=
 284                     sizeof(nameinfo))
 285 #else
 286                 if (!load_nameinfo (ResourceFd, &nameinfo))
 287 #endif
 288                 {
 289                     printf("FindResourceByName (%s) bad nameinfo size !\n", resource_name);
 290                     return -1;
 291                 }
 292 /*
 293                 if ((nameinfo.id & 0x8000) != 0) continue;
 294 */
 295 #ifdef DEBUG_RESOURCE
 296                 printf("FindResourceByName // nameinfo.id=%04X !\n", nameinfo.id);
 297 #endif
 298                 old_pos = lseek(ResourceFd, 0, SEEK_CUR);
 299                 new_pos = rtoff + nameinfo.id;
 300                 lseek(ResourceFd, new_pos, SEEK_SET);
 301                 read(ResourceFd, &nbytes, 1);
 302 #ifdef DEBUG_RESOURCE
 303                 printf("FindResourceByName // namesize=%d !\n", nbytes);
 304 #endif
 305                 nbytes = CONV_CHAR_TO_LONG (nbytes);
 306                 read(ResourceFd, name, nbytes);
 307                 lseek(ResourceFd, old_pos, SEEK_SET);
 308                 name[nbytes] = '\0';
 309 #ifdef DEBUG_RESOURCE
 310                 printf("FindResourceByName type_id=%X (%d of %d) name='%s' resource_name='%s'\n",
 311                         typeinfo.type_id, i + 1, typeinfo.count,
 312                         name, resource_name);
 313 #endif
 314 /*              if (strcasecmp(name, resource_name) == 0) */
 315                 if (strcasecmp(name, resource_name) == 0 ||
 316                 (nameinfo.id == 0x8001 && type_id == NE_RSCTYPE_MENU))
 317                 {
 318                     memcpy(result_p, &nameinfo, sizeof(nameinfo));
 319                     return size_shift;
 320                 }
 321             }
 322         }
 323         else {
 324             lseek(ResourceFd, (typeinfo.count * sizeof(nameinfo)), SEEK_CUR);
 325             }
 326     }
 327     return -1;
 328 }
 329
 330
 331 /**********************************************************************
 332  *                      LoadIcon [USER.174]
 333  */
 334 HICON LoadIcon(HANDLE instance, LPSTR icon_name)
 335 {
 336     HICON       hIcon;
 337     HANDLE      rsc_mem;
 338     WORD        *lp;
 339     ICONDESCRIP *lpicodesc;
 340     ICONALLOC   *lpico;
 341     int         width, height;
 342     BITMAPINFO  *bmi;
 343     BITMAPINFOHEADER    *bih;
 344     RGBQUAD     *rgbq;
 345     HBITMAP     hBitMap;
 346     HDC         hMemDC;
 347     HDC         hMemDC2;
 348     HDC         hdc;
 349     int         i, j, image_size;
 350 #ifdef DEBUG_RESOURCE
 351     printf("LoadIcon: instance = %04x, name = %08x\n",
 352            instance, icon_name);
 353 #endif
 354
 355     if (!(hdc = GetDC(GetDesktopWindow()))) return 0;
 356     if (instance == (HANDLE)NULL)  instance = hSysRes;
 357     rsc_mem = RSC_LoadResource(instance, icon_name, NE_RSCTYPE_GROUP_ICON,
 358                                &image_size);
 359     if (rsc_mem == (HANDLE)NULL) {
 360         printf("LoadIcon / Icon %04X not Found !\n", icon_name);
 361         ReleaseDC(GetDesktopWindow(), hdc);
 362         return 0;
 363         }
 364     lp = (WORD *)GlobalLock(rsc_mem);
 365     if (lp == NULL) {
 366         GlobalFree(rsc_mem);
 367         ReleaseDC(GetDesktopWindow(), hdc);
 368         return 0;
 369         }
 370     lpicodesc = (ICONDESCRIP *)(lp + 3);
 371     hIcon = GlobalAlloc(GMEM_MOVEABLE, sizeof(ICONALLOC) + 1024);
 372     if (hIcon == (HICON)NULL) {
 373         GlobalFree(rsc_mem);
 374         ReleaseDC(GetDesktopWindow(), hdc);
 375         return 0;
 376         }
 377     lpico = (ICONALLOC *)GlobalLock(hIcon);
 378     lpico->descriptor = *lpicodesc;
 379     width = lpicodesc->Width;
 380     height = lpicodesc->Height;
 381     GlobalUnlock(rsc_mem);
 382     GlobalFree(rsc_mem);
 383     rsc_mem = RSC_LoadResource(instance,
 384         MAKEINTRESOURCE(lpicodesc->icoDIBOffset),
 385         NE_RSCTYPE_ICON, &image_size);
 386     if (rsc_mem == (HANDLE)NULL) {
 387         printf("LoadIcon / Icon %04X Bitmaps not Found !\n", icon_name);
 388         ReleaseDC(GetDesktopWindow(), hdc);
 389         return 0;
 390         }
 391     lp = (WORD *)GlobalLock(rsc_mem);
 392     if (lp == NULL) {
 393         GlobalFree(rsc_mem);
 394         ReleaseDC(GetDesktopWindow(), hdc);
 395         return 0;
 396         }
 397     bmi = (BITMAPINFO *)lp;
 398     bih = (BITMAPINFOHEADER *)lp;
 399     rgbq = &bmi->bmiColors[0];
 400     bih->biHeight = bih->biHeight / 2;
 401 /*
 402     printf("LoadIcon / image_size=%d width=%d height=%d bih->biBitCount=%d bih->biSizeImage=%ld\n",
 403         image_size, width, height, bih->biBitCount, bih->biSizeImage);
 404 */
 405     if (bih->biSize == sizeof(BITMAPINFOHEADER))
 406         lpico->hBitmap = ConvertInfoBitmap(hdc, (BITMAPINFO *)bih);
 407     else
 408         lpico->hBitmap = 0;
 409     bih->biBitCount = 1;
 410     bih->biClrUsed = bih->biClrImportant  = 2;
 411     rgbq[0].rgbBlue     = 0xFF;
 412     rgbq[0].rgbGreen    = 0xFF;
 413     rgbq[0].rgbRed      = 0xFF;
 414     rgbq[0].rgbReserved = 0x00;
 415     rgbq[1].rgbBlue     = 0x00;
 416     rgbq[1].rgbGreen    = 0x00;
 417     rgbq[1].rgbRed      = 0x00;
 418     rgbq[1].rgbReserved = 0x00;
 419     lpico->hBitMask = CreateDIBitmap(hdc, bih, CBM_INIT,
 420         (LPSTR)lp + bih->biSizeImage - sizeof(BITMAPINFOHEADER) / 2 - 4,
 421         (BITMAPINFO *)bih, DIB_RGB_COLORS );
 422     GlobalUnlock(rsc_mem);
 423     GlobalFree(rsc_mem);
 424     hMemDC = CreateCompatibleDC(hdc);
 425     hMemDC2 = CreateCompatibleDC(hdc);
 426     SelectObject(hMemDC, lpico->hBitmap);
 427     SelectObject(hMemDC2, lpico->hBitMask);
 428     BitBlt(hMemDC, 0, 0, bih->biWidth, bih->biHeight, hMemDC2, 0, 0, SRCINVERT);
 429     DeleteDC(hMemDC);
 430     DeleteDC(hMemDC2);
 431     ReleaseDC(GetDesktopWindow(), hdc);
 432     GlobalUnlock(hIcon);
 433 #ifdef DEBUG_RESOURCE
 434     printf("LoadIcon Alloc hIcon=%X\n", hIcon);
 435 #endif
 436     return hIcon;
 437 }
 438
 439
 440 /**********************************************************************
 441  *                      DestroyIcon [USER.457]
 442  */
 443 BOOL DestroyIcon(HICON hIcon)
 444 {
 445     ICONALLOC   *lpico;
 446     if (hIcon == (HICON)NULL) return FALSE;
 447     lpico = (ICONALLOC *)GlobalLock(hIcon);
 448     if (lpico->hBitmap != (HBITMAP)NULL) DeleteObject(lpico->hBitmap);
 449     GlobalFree(hIcon);
 450     return TRUE;
 451 }
 452
 453
 454 /**********************************************************************
 455  *                      LoadAccelerators        [USER.177]
 456  */
 457 HANDLE LoadAccelerators(HANDLE instance, LPSTR lpTableName)
 458 {
 459     HANDLE      hAccel;
 460     HANDLE      rsc_mem;
 461     BYTE        *lp;
 462     ACCELHEADER *lpAccelTbl;
 463     int         i, image_size;
 464 #ifdef DEBUG_ACCEL
 465     if (((LONG)lpTableName & 0xFFFF0000L) == 0L)
 466         printf("LoadAccelerators: instance = %04X, name = %08X\n",
 467                         instance, lpTableName);
 468     else
 469         printf("LoadAccelerators: instance = %04X, name = '%s'\n",
 470                         instance, lpTableName);
 471 #endif
 472     if (instance == (HANDLE)NULL)  instance = hSysRes;
 473     rsc_mem = RSC_LoadResource(instance, lpTableName, NE_RSCTYPE_ACCELERATOR,
 474                                &image_size);
 475     if (rsc_mem == (HANDLE)NULL) {
 476         printf("LoadAccelerators / AccelTable %04X not Found !\n", lpTableName);
 477         return 0;
 478         }
 479     lp = (BYTE *)GlobalLock(rsc_mem);
 480     if (lp == NULL) {
 481         GlobalFree(rsc_mem);
 482         return 0;
 483         }
 484 #ifdef DEBUG_ACCEL
 485     printf("LoadAccelerators / image_size=%d\n", image_size);
 486 #endif
 487     hAccel = GlobalAlloc(GMEM_MOVEABLE,
 488         sizeof(ACCELHEADER) + sizeof(ACCELENTRY) + image_size);
 489     lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel);
 490     lpAccelTbl->wCount = 0;
 491     for (i = 0; ; i++) {
 492         lpAccelTbl->tbl[i].type = *(lp++);
 493         lpAccelTbl->tbl[i].wEvent = *((WORD *)lp);
 494         lp += 2;
 495         lpAccelTbl->tbl[i].wIDval = *((WORD *)lp);
 496         lp += 2;
 497         if (lpAccelTbl->tbl[i].wEvent == 0) break;
 498 #ifdef DEBUG_ACCEL
 499         printf("Accelerator #%u / event=%04X id=%04X type=%02X \n",
 500                 i, lpAccelTbl->tbl[i].wEvent, lpAccelTbl->tbl[i].wIDval,
 501                 lpAccelTbl->tbl[i].type);
 502 #endif
 503         lpAccelTbl->wCount++;
 504         }
 505     GlobalUnlock(hAccel);
 506     GlobalUnlock(rsc_mem);
 507     GlobalFree(rsc_mem);
 508     return hAccel;
 509 }
 510
 511 /**********************************************************************
 512  *                      TranslateAccelerator    [USER.178]
 513  */
 514 int TranslateAccelerator(HWND hWnd, HANDLE hAccel, LPMSG msg)
 515 {
 516     ACCELHEADER *lpAccelTbl;
 517     int         i, image_size;
 518     if (hAccel == 0 || msg == NULL) return 0;
 519     if (msg->message != WM_KEYDOWN &&
 520         msg->message != WM_KEYUP &&
 521         msg->message != WM_CHAR) return 0;
 522 #ifdef DEBUG_ACCEL
 523     printf("TranslateAccelerators hAccel=%04X !\n", hAccel);
 524 #endif
 525     lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel);
 526     for (i = 0; i < lpAccelTbl->wCount; i++) {
 527 /*      if (lpAccelTbl->tbl[i].type & SHIFT_ACCEL) { */
 528 /*      if (lpAccelTbl->tbl[i].type & CONTROL_ACCEL) { */
 529         if (lpAccelTbl->tbl[i].type & VIRTKEY_ACCEL) {
 530             if (msg->wParam == lpAccelTbl->tbl[i].wEvent &&
 531                 msg->message == WM_KEYDOWN) {
 532                 SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval, 0x00010000L);
 533                 return 1;
 534                 }
 535             if (msg->message == WM_KEYUP) return 1;
 536             }
 537         else {
 538             if (msg->wParam == lpAccelTbl->tbl[i].wEvent &&
 539                 msg->message == WM_CHAR) {
 540                 SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval, 0x00010000L);
 541                 return 1;
 542                 }
 543             }
 544         }
 545     GlobalUnlock(hAccel);
 546     return 0;
 547 }
 548
 549 /**********************************************************************
 550  *                              FindResource    [KERNEL.60]
 551  */
 552 HANDLE FindResource(HANDLE instance, LPSTR resource_name, LPSTR type_name)
 553 {
 554     RESOURCE *r;
 555     HANDLE rh;
 556
 557     if (instance == 0)
 558         return 0;
 559
 560 #ifdef DEBUG_RESOURCE
 561     printf("FindResource hInst=%04X typename=%08X resname=%08X\n",
 562                 instance, type_name, resource_name);
 563 #endif
 564     if (OpenResourceFile(instance) < 0)
 565         return 0;
 566
 567     rh = GlobalAlloc(GMEM_MOVEABLE, sizeof(*r));
 568     if (rh == 0)
 569         return 0;
 570     r = (RESOURCE *)GlobalLock(rh);
 571
 572     r->next = Top;
 573     Top = r;
 574     r->info_mem = rh;
 575     r->rsc_mem = 0;
 576
 577     if (((int) resource_name & 0xffff0000) == 0)
 578     {
 579         r->size_shift = FindResourceByNumber(&r->nameinfo, (int)type_name,
 580                                              (int) resource_name | 0x8000);
 581     }
 582     else
 583     {
 584         r->size_shift = FindResourceByName(&r->nameinfo, (int)type_name,
 585                                            resource_name);
 586     }
 587
 588     if (r->size_shift == -1)
 589     {
 590         GlobalFree(rh);
 591         return 0;
 592     }
 593
 594     return rh;
 595 }
 596
 597 /**********************************************************************
 598  *                              LoadResource    [KERNEL.61]
 599  */
 600 HANDLE LoadResource(HANDLE instance, HANDLE hResInfo)
 601 {
 602     RESOURCE *r;
 603     int image_size;
 604     void *image;
 605     HANDLE h;
 606
 607     if (instance == 0)
 608         return 0;
 609
 610     if (OpenResourceFile(instance) < 0)
 611         return 0;
 612
 613     r = (RESOURCE *)GlobalLock(hResInfo);
 614     if (r == NULL)
 615         return 0;
 616
 617     image_size = r->nameinfo.length << r->size_shift;
 618
 619     h = r->rsc_mem = GlobalAlloc(GMEM_MOVEABLE, image_size);
 620     image = GlobalLock(h);
 621
 622     lseek(ResourceFd, ((int) r->nameinfo.offset << r->size_shift), SEEK_SET);
 623
 624     if (image == NULL || read(ResourceFd, image, image_size) != image_size)
 625     {
 626         GlobalFree(h);
 627         GlobalUnlock(hResInfo);
 628         return 0;
 629     }
 630
 631     GlobalUnlock(h);
 632     GlobalUnlock(hResInfo);
 633     return h;
 634 }
 635
 636 /**********************************************************************
 637  *                              LockResource    [KERNEL.62]
 638  */
 639 LPSTR LockResource(HANDLE hResData)
 640 {
 641     return GlobalLock(hResData);
 642 }
 643
 644 /**********************************************************************
 645  *                              FreeResource    [KERNEL.63]
 646  */
 647 HANDLE FreeResource(HANDLE hResData)
 648 {
 649     RESOURCE *r, *rp;
 650
 651     for (r = rp = Top; r != NULL; r = r->next)
 652     {
 653         if (r->info_mem == hResData)
 654         {
 655             if (rp != NULL)
 656                 rp->next = r->next;
 657             else
 658                 Top = r->next;
 659
 660             GlobalFree(r->rsc_mem);
 661             GlobalFree(r->info_mem);
 662             return 0;
 663         }
 664     }
 665
 666     return hResData;
 667 }
 668
 669 /**********************************************************************
 670  *                              AccessResource  [KERNEL.64]
 671  */
 672 int AccessResource(HANDLE instance, HANDLE hResInfo)
 673 {
 674     int resfile;
 675 #ifdef DEBUG_RESOURCE
 676     printf("AccessResource(%04X, %04X);\n", instance, hResInfo);
 677 #endif
 678 /*
 679     resfile = OpenResourceFile(instance);
 680     return resfile;
 681 */
 682     return - 1;
 683 }
 684
 685
 686 \f
 687 /**********************************************************************
 688  *                                      RSC_LoadResource
 689  */
 690 HANDLE
 691 RSC_LoadResource(int instance, char *rsc_name, int type, int *image_size_ret)
 692 {
 693     struct resource_nameinfo_s nameinfo;
 694     HANDLE hmem;
 695     void *image;
 696     int image_size;
 697     int size_shift;
 698
 699     /*
 700      * Built-in resources
 701      */
 702     if (instance == 0)
 703     {
 704         return 0;
 705     }
 706     else if (OpenResourceFile(instance) < 0)
 707         return 0;
 708
 709     /*
 710      * Get resource by ordinal
 711      */
 712     if (((int) rsc_name & 0xffff0000) == 0)
 713     {
 714         size_shift = FindResourceByNumber(&nameinfo, type,
 715                                           (int) rsc_name | 0x8000);
 716     }
 717     /*
 718      * Get resource by name
 719      */
 720     else
 721     {
 722         size_shift = FindResourceByName(&nameinfo, type, rsc_name);
 723     }
 724     if (size_shift == -1) {
 725         if ((LONG)rsc_name >= 0x00010000L)
 726             printf("RSC_LoadResource / Resource '%s' not Found !\n", rsc_name);
 727         else
 728             printf("RSC_LoadResource / Resource '%X' not Found !\n", rsc_name);
 729         return 0;
 730         }
 731     /*
 732      * Read resource.
 733      */
 734     lseek(ResourceFd, ((int) nameinfo.offset << size_shift), SEEK_SET);
 735
 736     image_size = nameinfo.length << size_shift;
 737     if (image_size_ret != NULL)
 738         *image_size_ret = image_size;
 739     hmem = GlobalAlloc(GMEM_MOVEABLE, image_size);
 740     image = GlobalLock(hmem);
 741     if (image == NULL || read(ResourceFd, image, image_size) != image_size)
 742     {
 743         GlobalFree(hmem);
 744         return 0;
 745     }
 746
 747     GlobalUnlock(hmem);
 748     return hmem;
 749 }
 750 \f
 751 /**********************************************************************
 752  *                                      LoadString
 753  */
 754 int
 755 LoadString(HANDLE instance, WORD resource_id, LPSTR buffer, int buflen)
 756 {
 757     HANDLE hmem;
 758     int rsc_size;
 759     unsigned char *p;
 760     int string_num;
 761     int i;
 762
 763 #ifdef DEBUG_RESOURCE
 764     printf("LoadString: instance = %04x, id = %d, "
 765            "buffer = %08x, length = %d\n",
 766            instance, resource_id, buffer, buflen);
 767 #endif
 768
 769     hmem = RSC_LoadResource(instance, (char *) ((resource_id >> 4) + 1),
 770                             NE_RSCTYPE_STRING, &rsc_size);
 771     if (hmem == 0)
 772         return 0;
 773
 774     p = GlobalLock(hmem);
 775     string_num = resource_id & 0x000f;
 776     for (i = 0; i < string_num; i++)
 777         p += *p + 1;
 778
 779     i = MIN(buflen - 1, *p);
 780     memcpy(buffer, p + 1, i);
 781     buffer[i] = '\0';
 782
 783     GlobalFree(hmem);
 784
 785 #ifdef DEBUG_RESOURCE
 786     printf("            '%s'\n", buffer);
 787 #endif
 788     return i;
 789 }
 790 \f
 791 /**********************************************************************
 792  *                                      RSC_LoadMenu
 793  */
 794 HANDLE
 795 RSC_LoadMenu(HANDLE instance, LPSTR menu_name)
 796 {
 797     return RSC_LoadResource(instance, menu_name, NE_RSCTYPE_MENU, NULL);
 798 }
 799 \f
 800 /**********************************************************************
 801  *                                      LoadBitmap
 802  */
 803 HBITMAP
 804 LoadBitmap(HANDLE instance, LPSTR bmp_name)
 805 {
 806     HBITMAP hbitmap;
 807     HANDLE rsc_mem;
 808     HDC hdc;
 809     long *lp;
 810     int image_size;
 811
 812 #ifdef DEBUG_RESOURCE
 813     printf("LoadBitmap: instance = %04x, name = %08x\n",
 814            instance, bmp_name);
 815 #endif
 816     if (instance == (HANDLE)NULL)  instance = hSysRes;
 817     if (!(hdc = GetDC(GetDesktopWindow()))) return 0;
 818
 819     rsc_mem = RSC_LoadResource(instance, bmp_name, NE_RSCTYPE_BITMAP,
 820                                &image_size);
 821     if (rsc_mem == (HANDLE)NULL) {
 822         printf("LoadBitmap / BitMap %04X not Found !\n", bmp_name);
 823         return 0;
 824         }
 825     lp = (long *) GlobalLock(rsc_mem);
 826     if (lp == NULL)
 827     {
 828         GlobalFree(rsc_mem);
 829         return 0;
 830     }
 831     if (*lp == sizeof(BITMAPCOREHEADER))
 832         hbitmap = ConvertCoreBitmap( hdc, (BITMAPCOREHEADER *) lp );
 833     else if (*lp == sizeof(BITMAPINFOHEADER))
 834         hbitmap = ConvertInfoBitmap( hdc, (BITMAPINFO *) lp );
 835     else hbitmap = 0;
 836     GlobalFree(rsc_mem);
 837     ReleaseDC( 0, hdc );
 838     return hbitmap;
 839 }
 840
 841