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