src/w32bdf.c

   1 /* Implementation of BDF font handling on the Microsoft W32 API.
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* Based heavily on code by H. Miyashita for Meadow (a descendant of
  22    MULE for W32). */
  23
  24 #include <windows.h>
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include "lisp.h"
  31 #include "character.h"
  32 #include "keyboard.h"
  33 #include "frame.h"
  34 #include "dispextern.h"
  35 #include "fontset.h"
  36 #include "blockinput.h"
  37 #include "w32gui.h"
  38 #include "w32term.h"
  39 #include "w32bdf.h"
  40
  41 /* 10 planes */
  42 #define BDF_CODEPOINT_HEAP_INITIAL_SIZE (96 * 10)
  43 /* about 96 characters */
  44 #define BDF_BITMAP_HEAP_INITIAL_SIZE    (64 * 96)
  45
  46 HANDLE hbdf_cp_heap = INVALID_HANDLE_VALUE;
  47 HANDLE hbdf_bmp_heap = INVALID_HANDLE_VALUE;
  48
  49 void w32_free_bdf_font(bdffont *fontp);
  50 bdffont *w32_init_bdf_font(char *filename);
  51
  52 cache_bitmap cached_bitmap_slots[BDF_FONT_CACHE_SIZE];
  53 cache_bitmap *pcached_bitmap_latest = cached_bitmap_slots;
  54
  55 #define FONT_CACHE_SLOT_OVER_P(p) ((p) >= cached_bitmap_slots + BDF_FONT_CACHE_SIZE)
  56
  57 static int
  58 search_file_line(char *key, char *start, int len, char **val, char **next)
  59 {
  60   unsigned int linelen;
  61   unsigned char *p;
  62
  63   p = memchr(start, '\n', len);
  64   if (!p) return -1;
  65   for (;(unsigned char *)start < p;start++)
  66     {
  67       if ((*start != ' ') && (*start != '\t')) break;
  68     }
  69   linelen = (char *) p - start + 1;
  70   *next = p + 1;
  71   if (strncmp(start, key, min(strlen(key), linelen)) == 0)
  72     {
  73       *val = start + strlen(key);
  74       return 1;
  75     }
  76
  77   return 0;
  78 }
  79
  80 static int
  81 proceed_file_line(char *key, char *start, int *len, char **val, char **next)
  82 {
  83   int flag = 0;
  84
  85   do {
  86     flag = search_file_line(key, start, *len, val, next);
  87     *len -= (int)(*next - start);
  88     start = *next;
  89   }while(flag == 0);
  90
  91   if (flag == -1) return 0;
  92   return 1;
  93 }
  94
  95 char*
  96 get_quoted_string(char *start, char *end)
  97 {
  98   char *p, *q, *result;
  99
 100   p = memchr(start, '\"', end - start);
 101   if (!p) return NULL;
 102   p++;
 103   q = memchr(p, '\"', end - p);
 104   if (!q) return NULL;
 105
 106   result = (char*) xmalloc(q - p + 1);
 107
 108   memcpy(result, p, q - p);
 109   result[q - p] = '\0';
 110
 111   return result;
 112 }
 113
 114 static int
 115 set_bdf_font_info(bdffont *fontp)
 116 {
 117   unsigned char *start, *p, *q;
 118   int len, flag;
 119   int bbw, bbh, bbx, bby;
 120   int val1;
 121
 122   len = fontp->size;
 123   start = fontp->font;
 124
 125   fontp->yoffset = 0;
 126   fontp->relative_compose = 0;
 127   fontp->default_ascent = 0;
 128
 129   fontp->registry = NULL;
 130   fontp->encoding = NULL;
 131   fontp->slant = NULL;
 132 /*  fontp->width = NULL; */
 133
 134   flag = proceed_file_line("FONTBOUNDINGBOX", start, &len,
 135                            (char **)&p, (char **)&q);
 136   if (!flag) return 0;
 137   bbw = strtol(p, (char **)&start, 10);
 138   p = start;
 139   bbh = strtol(p, (char **)&start, 10);
 140   p = start;
 141   bbx = strtol(p, (char **)&start, 10);
 142   p = start;
 143   bby = strtol(p, (char **)&start, 10);
 144
 145   fontp->llx = bbx;
 146   fontp->lly = bby;
 147   fontp->urx = bbw + bbx;
 148   fontp->ury = bbh + bby;
 149   fontp->width = bbw;
 150   fontp->height = bbh;
 151   start = q;
 152   flag = proceed_file_line("STARTPROPERTIES", start, &len,
 153                            (char **)&p, (char **)&q);
 154   if (!flag) return 1;
 155
 156   flag = 0;
 157
 158   do {
 159     start = q;
 160     if (search_file_line("PIXEL_SIZE", start, len,
 161                          (char **)&p, (char **)&q) == 1)
 162       {
 163         val1 = atoi(p);
 164         fontp->pixsz = val1;
 165       }
 166     else if (search_file_line("FONT_ASCENT", start, len,
 167                               (char **)&p, (char **)&q) == 1)
 168       {
 169         val1 = atoi(p);
 170         fontp->ury = val1;
 171       }
 172     else if (search_file_line("FONT_DESCENT", start, len,
 173                               (char **)&p, (char **)&q) == 1)
 174       {
 175         val1 = atoi(p);
 176         fontp->lly = -val1;
 177       }
 178     else if (search_file_line("_MULE_BASELINE_OFFSET", start, len,
 179                               (char **)&p, (char **)&q) == 1)
 180       {
 181         val1 = atoi(p);
 182         fontp->yoffset = -val1;
 183       }
 184     else if (search_file_line("_MULE_RELATIVE_COMPOSE", start, len,
 185                               (char **)&p, (char **)&q) == 1)
 186       {
 187         val1 = atoi(p);
 188         fontp->relative_compose = val1;
 189       }
 190     else if (search_file_line("_MULE_DEFAULT_ASCENT", start, len,
 191                               (char **)&p, (char **)&q) == 1)
 192       {
 193         val1 = atoi(p);
 194         fontp->default_ascent = val1;
 195       }
 196     else if (search_file_line("CHARSET_REGISTRY", start, len,
 197                               (char **)&p, (char **)&q) == 1)
 198       {
 199         fontp->registry = get_quoted_string(p, q);
 200       }
 201     else if (search_file_line("CHARSET_ENCODING", start, len,
 202                               (char **)&p, (char **)&q) == 1)
 203       {
 204         fontp->encoding = get_quoted_string(p, q);
 205       }
 206     else if (search_file_line("SLANT", start, len,
 207                               (char **)&p, (char **)&q) == 1)
 208       {
 209         fontp->slant = get_quoted_string(p, q);
 210       }
 211 /*
 212     else if (search_file_line("SETWIDTH_NAME", start, len,
 213                               (char **)&p, (char **)&q) == 1)
 214       {
 215         fontp->width = get_quoted_string(p, q);
 216       }
 217 */
 218     else
 219       {
 220         flag = search_file_line("ENDPROPERTIES", start, len,
 221                                 (char **)&p, (char **)&q);
 222       }
 223     if (flag == -1) return 0;
 224     len -= (q - start);
 225   }while(flag == 0);
 226   start = q;
 227   flag = proceed_file_line("CHARS", start, &len, (char **)&p, (char **)&q);
 228   if (!flag) return 0;
 229   fontp->nchars = atoi(p);
 230   fontp->seeked = q;
 231
 232   return 1;
 233 }
 234
 235 bdffont*
 236 w32_init_bdf_font(char *filename)
 237 {
 238   HANDLE hfile, hfilemap;
 239   bdffont *bdffontp;
 240   unsigned char *font;
 241   BY_HANDLE_FILE_INFORMATION fileinfo;
 242   int i;
 243
 244   if (hbdf_cp_heap == INVALID_HANDLE_VALUE)
 245     hbdf_cp_heap = HeapCreate(0, BDF_CODEPOINT_HEAP_INITIAL_SIZE, 0);
 246   if (hbdf_bmp_heap == INVALID_HANDLE_VALUE)
 247     hbdf_bmp_heap = HeapCreate(0, BDF_BITMAP_HEAP_INITIAL_SIZE, 0);
 248
 249   if (!hbdf_cp_heap || !hbdf_bmp_heap)
 250     error("Fail to create heap for BDF.");
 251
 252   hfile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 253                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 254   if (hfile == INVALID_HANDLE_VALUE) return NULL;
 255   if (!GetFileInformationByHandle(hfile, &fileinfo) ||
 256       (fileinfo.nFileSizeHigh != 0) ||
 257       (fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
 258     {
 259       CloseHandle(hfile);
 260       error("Fail to open BDF file.");
 261     }
 262   hfilemap = CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
 263   if (hfilemap == INVALID_HANDLE_VALUE)
 264     {
 265       CloseHandle(hfile);
 266       error("Can't map font.");
 267     }
 268
 269   font = MapViewOfFile(hfilemap, FILE_MAP_READ, 0, 0, 0);
 270
 271   if (!font)
 272     {
 273       CloseHandle(hfile);
 274       CloseHandle(hfilemap);
 275       error("Can't view font.");
 276     }
 277
 278   bdffontp = (bdffont *) xmalloc(sizeof(bdffont));
 279
 280   for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
 281     bdffontp->chtbl[i] = NULL;
 282   bdffontp->size = fileinfo.nFileSizeLow;
 283   bdffontp->font = font;
 284   bdffontp->hfile = hfile;
 285   bdffontp->hfilemap = hfilemap;
 286   bdffontp->filename = (char*) xmalloc(strlen(filename) + 1);
 287   strcpy(bdffontp->filename, filename);
 288
 289   if (!set_bdf_font_info(bdffontp))
 290     {
 291       w32_free_bdf_font(bdffontp);
 292       error("Invalid BDF font!");
 293     }
 294   return bdffontp;
 295 }
 296
 297 void
 298 w32_free_bdf_font(bdffont *fontp)
 299 {
 300   int i, j;
 301   font_char *pch;
 302   cache_bitmap *pcb;
 303
 304   UnmapViewOfFile(fontp->hfilemap);
 305   CloseHandle(fontp->hfilemap);
 306   CloseHandle(fontp->hfile);
 307
 308   if (fontp->registry) xfree(fontp->registry);
 309   if (fontp->encoding) xfree(fontp->encoding);
 310   if (fontp->slant) xfree(fontp->slant);
 311 /*  if (fontp->width) xfree(fontp->width); */
 312
 313   xfree(fontp->filename);
 314   for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
 315     {
 316       pch = fontp->chtbl[i];
 317       if (pch)
 318         {
 319           for (j = 0;j < BDF_SECOND_OFFSET_TABLE;j++)
 320             {
 321               pcb = pch[j].pcbmp;
 322               if (pcb)
 323                 {
 324                   if (pcb->pbmp)
 325                     HeapFree(hbdf_bmp_heap, 0, pcb->pbmp);
 326                   pcb->psrc = NULL;
 327             }
 328             }
 329           HeapFree(hbdf_cp_heap, 0, pch);
 330         }
 331     }
 332   xfree(fontp);
 333 }
 334
 335 static font_char*
 336 get_cached_font_char(bdffont *fontp, int index)
 337 {
 338   font_char *pch, *result;
 339
 340   if (!BDF_CODEPOINT_RANGE_COVER_P(index))
 341     return NULL;
 342
 343   pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
 344   if (!pch)
 345     return NULL;
 346
 347   result = &pch[BDF_SECOND_OFFSET(index)];
 348
 349   if (!result->offset) return NULL;
 350
 351   return result;
 352 }
 353
 354 static font_char*
 355 cache_char_offset(bdffont *fontp, int index, unsigned char *offset)
 356 {
 357   font_char *pch, *result;
 358
 359   if (!BDF_CODEPOINT_RANGE_COVER_P(index))
 360     return NULL;
 361
 362   pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
 363   if (!pch)
 364     {
 365       pch = fontp->chtbl[BDF_FIRST_OFFSET(index)] =
 366         (font_char*) HeapAlloc(hbdf_cp_heap,
 367                                HEAP_ZERO_MEMORY,
 368                                sizeof(font_char) *
 369                                BDF_SECOND_OFFSET_TABLE);
 370       if (!pch) return NULL;
 371       /* memset(pch, 0, sizeof(font_char) * BDF_SECOND_OFFSET_TABLE); */
 372     }
 373
 374   result = &pch[BDF_SECOND_OFFSET(index)];
 375   result->offset = offset;
 376
 377   return result;
 378 }
 379
 380 static font_char*
 381 seek_char(bdffont *fontp, int index)
 382 {
 383   font_char *result;
 384   int len, flag, font_index;
 385   unsigned char *start, *p, *q;
 386
 387   if (!fontp->seeked) return NULL;
 388
 389   start = fontp->seeked;
 390   len = fontp->size - (start - fontp->font);
 391
 392   do {
 393     flag = proceed_file_line("ENCODING", start, &len,
 394                              (char **)&p, (char **)&q);
 395     if (!flag)
 396       {
 397         fontp->seeked = NULL;
 398         return NULL;
 399       }
 400     font_index = atoi(p);
 401     result = cache_char_offset(fontp, font_index, q);
 402     if (!result) return NULL;
 403
 404     start = result->offset;
 405   } while (font_index != index);
 406   fontp->seeked = start;
 407
 408   return result;
 409 }
 410
 411 static void
 412 clear_cached_bitmap_slots()
 413 {
 414   int i;
 415   cache_bitmap *p;
 416
 417   p = pcached_bitmap_latest;
 418   for (i = 0;i < BDF_FONT_CLEAR_SIZE;i++)
 419     {
 420       if (p->psrc)
 421         {
 422           if (p->pbmp)
 423             HeapFree(hbdf_bmp_heap, 0, p->pbmp);
 424           p->psrc->pcbmp = NULL;
 425           p->psrc = NULL;
 426         }
 427       p++;
 428       if (FONT_CACHE_SLOT_OVER_P(p))
 429         p = cached_bitmap_slots;
 430     }
 431 }
 432
 433 #define GET_HEX_VAL(x) ((isdigit(x)) ? ((x) - '0') : \
 434                         (((x) >= 'A') && ((x) <= 'F')) ? ((x) - 'A' + 10) : \
 435                         (((x) >= 'a') && ((x) <= 'f')) ? ((x) - 'a' + 10) : \
 436                         (-1))
 437
 438 int
 439 w32_get_bdf_glyph(bdffont *fontp, int index, int size, glyph_struct *glyph)
 440 {
 441   font_char *pch;
 442   unsigned char *start, *p, *q, *bitmapp;
 443   unsigned char val, val1, val2;
 444   int i, j, len, flag, consumed;
 445   int align, rowbytes;
 446
 447   pch = get_cached_font_char(fontp, index);
 448   if (!pch)
 449     {
 450       pch = seek_char(fontp, index);
 451       if (!pch)
 452         return 0;
 453     }
 454
 455   start = pch->offset;
 456
 457   if ((size == 0) && pch->pcbmp)
 458     {
 459       glyph->metric = pch->pcbmp->metric;
 460       return 1;
 461     }
 462
 463   len = fontp->size - (start - fontp->font);
 464
 465   flag = proceed_file_line("DWIDTH", start, &len, (char **)&p, (char **)&q);
 466   if (!flag)
 467     return 0;
 468   glyph->metric.dwidth = atoi(p);
 469
 470   start = q;
 471   flag = proceed_file_line("BBX", start, &len, (char **)&p, (char **)&q);
 472   if (!flag)
 473     return 0;
 474   glyph->metric.bbw = strtol(p, (char **)&start, 10);
 475   p = start;
 476   glyph->metric.bbh = strtol(p, (char **)&start, 10);
 477   p = start;
 478   glyph->metric.bbox = strtol(p, (char **)&start, 10);
 479   p = start;
 480   glyph->metric.bboy = strtol(p, (char **)&start, 10);
 481
 482   if (size == 0) return 1;
 483
 484   start = q;
 485   flag = proceed_file_line("BITMAP", start, &len, (char **)&p, (char **)&q);
 486   if (!flag)
 487     return 0;
 488
 489   consumed = 0;
 490   flag = 0;
 491   p = q;
 492   bitmapp = glyph->bitmap;
 493   rowbytes = (glyph->metric.bbw + 7) / 8;
 494   /* DIB requires DWORD alignment.  */
 495   align = sizeof(DWORD) - rowbytes % sizeof(DWORD);
 496   consumed = glyph->metric.bbh * (rowbytes + align);
 497   glyph->bitmap_size = consumed;
 498   glyph->row_byte_size = rowbytes;
 499   if (size < consumed) return 0;
 500
 501   for(i = 0;i < glyph->metric.bbh;i++)
 502     {
 503       q = memchr(p, '\n', len);
 504       if (!q) return 0;
 505       for(j = 0;((q > p) && (j < rowbytes));j++)
 506         {
 507           int ival = GET_HEX_VAL(*p);
 508
 509           if (ival == -1) return 0;
 510           val1 = ival;
 511           p++;
 512           ival = GET_HEX_VAL(*p);
 513           if (ival == -1) return 0;
 514           val2 = ival;
 515           p++;
 516           val = (unsigned char)((val1 << 4) | val2);
 517           if (val) flag = 1;
 518           *bitmapp++ = val;
 519         }
 520       for(j = 0;j < align;j++)
 521         *bitmapp++ = 0x00;
 522       p = q + 1;
 523     }
 524
 525   /* If this glyph is white space, return -1. */
 526   if (flag == 0) return -1;
 527
 528   return consumed;
 529 }
 530
 531 static
 532 cache_bitmap*
 533 get_bitmap_with_cache(bdffont *fontp, int index)
 534 {
 535   int bitmap_size, bitmap_real_size;
 536   font_char *pch;
 537   cache_bitmap* pcb;
 538   unsigned char *pbmp;
 539   glyph_struct glyph;
 540
 541   pch = get_cached_font_char(fontp, index);
 542   if (pch)
 543     {
 544       pcb = pch->pcbmp;
 545       if (pcb) return pcb;
 546     }
 547
 548   bitmap_size = ((fontp->urx - fontp->llx) / 8 + 3) * (fontp->ury - fontp->lly)
 549     + 256;
 550   glyph.bitmap = (unsigned char*) alloca(sizeof(unsigned char) * bitmap_size);
 551
 552   bitmap_real_size = w32_get_bdf_glyph(fontp, index, bitmap_size, &glyph);
 553
 554   if (bitmap_real_size == 0)
 555     return NULL;
 556
 557   pch = get_cached_font_char(fontp, index);
 558   if (!pch) return NULL;
 559
 560   if (bitmap_real_size > 0)
 561     {
 562        pbmp = (unsigned char*) HeapAlloc(hbdf_bmp_heap, 0,
 563                                          bitmap_real_size);
 564        if (!pbmp) return NULL;
 565        memcpy(pbmp, glyph.bitmap, bitmap_real_size);
 566     }
 567   else
 568     pbmp = NULL; /* white space character */
 569
 570   pcb = pcached_bitmap_latest;
 571   if (pcb->psrc)
 572     clear_cached_bitmap_slots();
 573
 574   pcb->psrc = pch;
 575   pcb->metric = glyph.metric;
 576   pcb->pbmp = pbmp;
 577   pcb->bitmap_size = glyph.bitmap_size;
 578   pcb->row_byte_size = glyph.row_byte_size;
 579
 580   pch->pcbmp = pcb;
 581
 582   pcached_bitmap_latest++;
 583   if (FONT_CACHE_SLOT_OVER_P(pcached_bitmap_latest))
 584     pcached_bitmap_latest = cached_bitmap_slots;
 585
 586   return pcb;
 587 }
 588
 589 static HBITMAP
 590 create_offscreen_bitmap(HDC hdc, int width, int height, unsigned char **bitsp)
 591 {
 592   struct {
 593     BITMAPINFOHEADER h;
 594     RGBQUAD c[2];
 595   } info;
 596
 597   memset(&info, 0, sizeof(info));
 598   info.h.biSize = sizeof(BITMAPINFOHEADER);
 599   info.h.biWidth = width;
 600   info.h.biHeight = -height;
 601   info.h.biPlanes = 1;
 602   info.h.biBitCount = 1;
 603   info.h.biCompression = BI_RGB;
 604   info.c[1].rgbRed = info.c[1].rgbGreen = info.c[1].rgbBlue = 255;
 605
 606   return CreateDIBSection(hdc, (LPBITMAPINFO)&info,
 607                           DIB_RGB_COLORS, bitsp, NULL, 0);
 608 }
 609
 610 glyph_metric *
 611 w32_BDF_TextMetric(bdffont *fontp, unsigned char *text, int dim)
 612 {
 613   int index;
 614   cache_bitmap *pcb;
 615
 616   if (dim == 1)
 617     index = *text;
 618   else
 619     index = MAKELENDSHORT(text[1], text[0]);
 620
 621   pcb = get_bitmap_with_cache(fontp, index);
 622   if (!pcb)
 623     return NULL;
 624
 625   return &(pcb->metric);
 626 }
 627
 628 int
 629 w32_BDF_TextOut(bdffont *fontp, HDC hdc, int left,
 630                  int top, unsigned char *text, int dim, int bytelen,
 631                  int fixed_pitch_size)
 632 {
 633   int index, btop;
 634   unsigned char *textp;
 635   cache_bitmap *pcb;
 636   HBRUSH hFgBrush, hOrgBrush;
 637   HANDLE horgobj;
 638   UINT textalign;
 639   int width, height;
 640   HDC hCompatDC;
 641   int ret = 1;
 642   static HBITMAP hBMP = 0;
 643   static HDC DIBsection_hdc = 0;
 644   static int DIBsection_width, DIBsection_height;
 645   static unsigned char *bits;
 646
 647   hCompatDC = CreateCompatibleDC(hdc);
 648   if (!hCompatDC)
 649     return 0;
 650
 651   textalign = GetTextAlign(hdc);
 652
 653   hFgBrush = CreateSolidBrush(GetTextColor(hdc));
 654   hOrgBrush = SelectObject(hdc, hFgBrush);
 655
 656   textp = text;
 657
 658   while(bytelen > 0)
 659     {
 660       if (dim == 1)
 661         {
 662           index = *textp++;
 663           bytelen--;
 664         }
 665       else
 666         {
 667           bytelen -= 2;
 668           if (bytelen < 0) break;
 669           index = MAKELENDSHORT(textp[0], textp[1]);
 670           textp += 2;
 671         }
 672       pcb = get_bitmap_with_cache(fontp, index);
 673       if (!pcb)
 674         {
 675           ret = 0;
 676           break;
 677             }
 678       if (pcb->pbmp)
 679         {
 680           width = pcb->metric.bbw;
 681           height = pcb->metric.bbh;
 682
 683           if (!(hBMP
 684                 && (DIBsection_hdc == hdc)
 685                 && (DIBsection_width == width)
 686                 && (DIBsection_height == height)))
 687             {
 688               if (hBMP) DeleteObject(hBMP);
 689               hBMP = create_offscreen_bitmap(hdc, width, height, &bits);
 690               DIBsection_hdc = hdc;
 691               DIBsection_width = width;
 692               DIBsection_height = height;
 693               if (!hBMP) return 0;
 694         }
 695
 696           memcpy(bits, pcb->pbmp, pcb->bitmap_size);
 697
 698       if (textalign & TA_BASELINE)
 699           btop = top - (pcb->metric.bbh + pcb->metric.bboy);
 700       else if (textalign & TA_BOTTOM)
 701           btop = top - pcb->metric.bbh;
 702       else
 703           btop = top;
 704
 705           horgobj = SelectObject(hCompatDC, hBMP);
 706           BitBlt(hdc, left, btop, width, height, hCompatDC, 0, 0, 0xE20746);
 707           SelectObject(hCompatDC, horgobj);
 708         }
 709
 710       if (fixed_pitch_size)
 711         left += fixed_pitch_size;
 712       else
 713         left += pcb->metric.dwidth;
 714     }
 715
 716   DeleteDC(hCompatDC);
 717
 718   SelectObject(hdc, hOrgBrush);
 719   DeleteObject(hFgBrush);
 720
 721   return ret;
 722 }
 723
 724 struct font_info *w32_load_bdf_font (struct frame *f, char *fontname,
 725                                      int size, char* filename)
 726 {
 727   struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
 728   struct font_info *fontp;
 729   XFontStruct *font;
 730   bdffont* bdf_font;
 731
 732   bdf_font = w32_init_bdf_font (filename);
 733
 734   if (!bdf_font) return NULL;
 735
 736   font = (XFontStruct *) xmalloc (sizeof (XFontStruct));
 737   bzero (font, sizeof (*font));
 738
 739   font->bdf = bdf_font;
 740   font->hfont = 0;
 741
 742   /* NTEMACS_TODO: Better way of determining if a font is double byte
 743      or not. */
 744   font->double_byte_p = bdf_font->nchars > 255 ? 1 : 0;
 745
 746   w32_cache_char_metrics (font);
 747
 748   /* Do we need to create the table?  */
 749   if (dpyinfo->font_table_size == 0)
 750     {
 751       dpyinfo->font_table_size = 16;
 752       dpyinfo->font_table
 753         = (struct font_info *) xmalloc (dpyinfo->font_table_size
 754                                         * sizeof (struct font_info));
 755     }
 756   /* Do we need to grow the table?  */
 757   else if (dpyinfo->n_fonts
 758            >= dpyinfo->font_table_size)
 759     {
 760       dpyinfo->font_table_size *= 2;
 761       dpyinfo->font_table
 762         = (struct font_info *) xrealloc (dpyinfo->font_table,
 763                                          (dpyinfo->font_table_size
 764                                           * sizeof (struct font_info)));
 765     }
 766
 767   fontp = dpyinfo->font_table + dpyinfo->n_fonts;
 768
 769   /* Now fill in the slots of *FONTP.  */
 770   BLOCK_INPUT;
 771   fontp->font = font;
 772   fontp->font_idx = dpyinfo->n_fonts;
 773   fontp->name = (char *) xmalloc (strlen (fontname) + 1);
 774   bcopy (fontname, fontp->name, strlen (fontname) + 1);
 775   fontp->full_name = fontp->name;
 776   fontp->size = FONT_WIDTH (font);
 777   fontp->height = FONT_HEIGHT (font);
 778
 779     /* The slot `encoding' specifies how to map a character
 780        code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
 781        the font code-points (0:0x20..0x7F, 1:0xA0..0xFF, 0:0x2020..0x7F7F,
 782        the font code-points (0:0x20..0x7F, 1:0xA0..0xFF,
 783        0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF, or
 784        2:0xA020..0xFF7F).  For the moment, we don't know which charset
 785        uses this font.  So, we set informatoin in fontp->encoding[1]
 786        which is never used by any charset.  If mapping can't be
 787        decided, set FONT_ENCODING_NOT_DECIDED.  */
 788     fontp->encoding[1] = FONT_ENCODING_NOT_DECIDED;
 789     fontp->baseline_offset = bdf_font->yoffset;
 790     fontp->relative_compose = bdf_font->relative_compose;
 791     fontp->default_ascent = bdf_font->default_ascent;
 792
 793     /* Set global flag fonts_changed_p to non-zero if the font loaded
 794        has a character with a smaller width than any other character
 795        before, or if the font loaded has a smaller height than any
 796        other font loaded before.  If this happens, it will make a
 797        glyph matrix reallocation necessary.  */
 798     fonts_changed_p |= x_compute_min_glyph_bounds (f);
 799
 800     UNBLOCK_INPUT;
 801     dpyinfo->n_fonts++;
 802     return fontp;
 803 }
 804
 805 /* Check a file for an XLFD string describing it.  */
 806 int w32_BDF_to_x_font (char *file, char* xstr, int len)
 807 {
 808   HANDLE hfile, hfilemap;
 809   BY_HANDLE_FILE_INFORMATION fileinfo;
 810   char *font, *start, *p, *q;
 811   int flag, size, retval = 0;
 812
 813   hfile = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL,
 814                       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 815   if (hfile == INVALID_HANDLE_VALUE) return 0;
 816   if (!GetFileInformationByHandle(hfile, &fileinfo) ||
 817       (fileinfo.nFileSizeHigh != 0) ||
 818       (fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
 819     {
 820       CloseHandle (hfile);
 821       return 0;
 822     }
 823   size = fileinfo.nFileSizeLow;
 824
 825   hfilemap = CreateFileMapping (hfile, NULL, PAGE_READONLY, 0, 0, NULL);
 826   if (hfilemap == INVALID_HANDLE_VALUE)
 827     {
 828       CloseHandle (hfile);
 829       return 0;
 830     }
 831
 832   font = MapViewOfFile (hfilemap, FILE_MAP_READ, 0, 0, 0);
 833   if (!font)
 834     {
 835       CloseHandle (hfile);
 836       CloseHandle (hfilemap);
 837       return 0;
 838     }
 839   start = font;
 840
 841   flag = proceed_file_line ("FONT ", start, &size, &p, &q);
 842   if (flag)
 843     {
 844       /* If font provides a description of itself, check it is a
 845          full XLFD before accepting it.  */
 846       int count = 0;
 847       char *s;
 848
 849       for (s = p; s < q; s++)
 850         if (*s == '\n')
 851           break;
 852         else if (*s == '-')
 853           count++;
 854       if (count == 14 && q - p - 1 <= len)
 855         {
 856           strncpy (xstr, p, q-p-1);
 857           xstr[q-p-1] = '\0';
 858           /* Files may have DOS line ends (ie still ^M on end).  */
 859           if (iscntrl(xstr[q-p-2]))
 860             xstr[q-p-2] = '\0';
 861
 862           retval = 1;
 863         }
 864     }
 865   CloseHandle (hfile);
 866   CloseHandle (hfilemap);
 867   return retval;
 868 }