src/w32bdf.c

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