loader/resource.c

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