*** empty log message ***
[emacs.git] / src / w32bdf.c
blob53e1b17b2187790050e0f9514714b84ae617b5fb
1 /* Implementation of BDF font handling on the Microsoft W32 API.
2 Copyright (C) 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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.
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.
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. */
21 /* Based heavily on code by H. Miyashita for Meadow (a descendant of
22 MULE for W32). */
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"
36 #define min(a, b) ((a) < (b) ? (a) : (b))
37 #define max(a, b) ((a) > (b) ? (a) : (b))
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)
44 HANDLE hbdf_cp_heap = INVALID_HANDLE_VALUE;
45 HANDLE hbdf_bmp_heap = INVALID_HANDLE_VALUE;
47 void w32_free_bdf_font(bdffont *fontp);
48 bdffont *w32_init_bdf_font(char *filename);
50 cache_bitmap cached_bitmap_slots[BDF_FONT_CACHE_SIZE];
51 cache_bitmap *pcached_bitmap_latest = cached_bitmap_slots;
53 #define FONT_CACHE_SLOT_OVER_P(p) ((p) >= cached_bitmap_slots + BDF_FONT_CACHE_SIZE)
55 static int
56 search_file_line(char *key, char *start, int len, char **val, char **next)
58 int linelen;
59 unsigned char *p, *q;
61 p = memchr(start, '\n', len);
62 if (!p) return -1;
63 for (;start < p;start++)
65 if ((*start != ' ') && (*start != '\t')) break;
67 linelen = (char *) p - start + 1;
68 *next = p + 1;
69 if (strncmp(start, key, min(strlen(key), linelen)) == 0)
71 *val = start + strlen(key);
72 return 1;
75 return 0;
78 static int
79 proceed_file_line(char *key, char *start, int *len, char **val, char **next)
81 int flag = 0;
83 do {
84 flag = search_file_line(key, start, *len, val, next);
85 *len -= (int)(*next - start);
86 start = *next;
87 }while(flag == 0);
89 if (flag == -1) return 0;
90 return 1;
93 char*
94 get_quoted_string(char *start, char *end)
96 char *p, *q, *result;
98 p = memchr(start, '\"', end - start);
99 if (!p) return NULL;
100 p++;
101 q = memchr(p, '\"', end - p);
102 if (!q) return NULL;
104 result = (char*) xmalloc(q - p + 1);
106 memcpy(result, p, q - p);
107 result[q - p] = '\0';
109 return result;
112 static int
113 set_bdf_font_info(bdffont *fontp)
115 unsigned char *start, *p, *q;
116 int len, flag;
117 int bbw, bbh, bbx, bby;
118 int val1;
120 len = fontp->size;
121 start = fontp->font;
123 fontp->yoffset = 0;
124 fontp->relative_compose = 0;
125 fontp->default_ascent = 0;
127 fontp->registry = NULL;
128 fontp->encoding = NULL;
129 fontp->slant = NULL;
130 /* fontp->width = NULL; */
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);
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;
152 flag = 0;
154 do {
155 start = q;
156 if (search_file_line("PIXEL_SIZE", start, len, &p, &q) == 1)
158 val1 = atoi(p);
159 fontp->pixsz = val1;
161 else if (search_file_line("FONT_ASCENT", start, len, &p, &q) == 1)
163 val1 = atoi(p);
164 fontp->ury = val1;
166 else if (search_file_line("FONT_DESCENT", start, len, &p, &q) == 1)
168 val1 = atoi(p);
169 fontp->lly = -val1;
171 else if (search_file_line("_MULE_BASELINE_OFFSET", start, len, &p, &q) == 1)
173 val1 = atoi(p);
174 fontp->yoffset = -val1;
176 else if (search_file_line("_MULE_RELATIVE_COMPOSE", start, len, &p, &q) == 1)
178 val1 = atoi(p);
179 fontp->relative_compose = val1;
181 else if (search_file_line("_MULE_DEFAULT_ASCENT", start, len, &p, &q) == 1)
183 val1 = atoi(p);
184 fontp->default_ascent = val1;
186 else if (search_file_line("CHARSET_REGISTRY", start, len, &p, &q) == 1)
188 fontp->registry = get_quoted_string(p, q);
190 else if (search_file_line("CHARSET_ENCODING", start, len, &p, &q) == 1)
192 fontp->encoding = get_quoted_string(p, q);
194 else if (search_file_line("SLANT", start, len, &p, &q) == 1)
196 fontp->slant = get_quoted_string(p, q);
199 else if (search_file_line("SETWIDTH_NAME", start, len, &p, &q) == 1)
201 fontp->width = get_quoted_string(p, q);
204 else
206 flag = search_file_line("ENDPROPERTIES", start, len, &p, &q);
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;
217 return 1;
220 bdffont*
221 w32_init_bdf_font(char *filename)
223 HANDLE hfile, hfilemap;
224 bdffont *bdffontp;
225 unsigned char *font;
226 BY_HANDLE_FILE_INFORMATION fileinfo;
227 int i;
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);
234 if (!hbdf_cp_heap || !hbdf_bmp_heap)
235 error("Fail to create heap for BDF.");
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))
244 CloseHandle(hfile);
245 error("Fail to open BDF file.");
247 hfilemap = CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
248 if (hfilemap == INVALID_HANDLE_VALUE)
250 CloseHandle(hfile);
251 error("Can't map font.");
254 font = MapViewOfFile(hfilemap, FILE_MAP_READ, 0, 0, 0);
256 if (!font)
258 CloseHandle(hfile);
259 CloseHandle(hfilemap);
260 error("Can't view font.");
263 bdffontp = (bdffont *) xmalloc(sizeof(bdffont));
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);
274 if (!set_bdf_font_info(bdffontp))
276 w32_free_bdf_font(bdffontp);
277 error("Invalid BDF font!");
279 return bdffontp;
282 void
283 w32_free_bdf_font(bdffont *fontp)
285 int i, j;
286 font_char *pch;
287 cache_bitmap *pcb;
289 UnmapViewOfFile(fontp->hfilemap);
290 CloseHandle(fontp->hfilemap);
291 CloseHandle(fontp->hfile);
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); */
298 xfree(fontp->filename);
299 for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
301 pch = fontp->chtbl[i];
302 if (pch)
304 for (j = 0;j < BDF_SECOND_OFFSET_TABLE;j++)
306 pcb = pch[j].pcbmp;
307 if (pcb)
309 if (pcb->pbmp)
310 HeapFree(hbdf_bmp_heap, 0, pcb->pbmp);
311 pcb->psrc = NULL;
314 HeapFree(hbdf_cp_heap, 0, pch);
317 xfree(fontp);
320 static font_char*
321 get_cached_font_char(bdffont *fontp, int index)
323 font_char *pch, *result;
324 int i;
326 if (!BDF_CODEPOINT_RANGE_COVER_P(index))
327 return NULL;
329 pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
330 if (!pch)
331 return NULL;
333 result = &pch[BDF_SECOND_OFFSET(index)];
335 if (!result->offset) return NULL;
337 return result;
340 static font_char*
341 cache_char_offset(bdffont *fontp, int index, unsigned char *offset)
343 font_char *pch, *result;
344 int i;
346 if (!BDF_CODEPOINT_RANGE_COVER_P(index))
347 return NULL;
349 pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
350 if (!pch)
352 pch = fontp->chtbl[BDF_FIRST_OFFSET(index)] =
353 (font_char*) HeapAlloc(hbdf_cp_heap,
354 HEAP_ZERO_MEMORY,
355 sizeof(font_char) *
356 BDF_SECOND_OFFSET_TABLE);
357 if (!pch) return NULL;
358 /* memset(pch, 0, sizeof(font_char) * BDF_SECOND_OFFSET_TABLE); */
361 result = &pch[BDF_SECOND_OFFSET(index)];
362 result->offset = offset;
364 return result;
367 static font_char*
368 seek_char(bdffont *fontp, int index)
370 font_char *result;
371 int len, flag, font_index;
372 unsigned char *start, *p, *q;
374 if (!fontp->seeked) return NULL;
376 start = fontp->seeked;
377 len = fontp->size - (start - fontp->font);
379 do {
380 flag = proceed_file_line("ENCODING", start, &len, &p, &q);
381 if (!flag)
383 fontp->seeked = NULL;
384 return NULL;
386 font_index = atoi(p);
387 result = cache_char_offset(fontp, font_index, q);
388 if (!result) return NULL;
390 start = result->offset;
391 } while (font_index != index);
392 fontp->seeked = start;
394 return result;
397 static void
398 clear_cached_bitmap_slots()
400 int i;
401 cache_bitmap *p;
403 p = pcached_bitmap_latest;
404 for (i = 0;i < BDF_FONT_CLEAR_SIZE;i++)
406 if (p->psrc)
408 if (p->pbmp)
409 HeapFree(hbdf_bmp_heap, 0, p->pbmp);
410 p->psrc->pcbmp = NULL;
411 p->psrc = NULL;
413 p++;
414 if (FONT_CACHE_SLOT_OVER_P(p))
415 p = cached_bitmap_slots;
419 #define GET_HEX_VAL(x) ((isdigit(x)) ? ((x) - '0') : \
420 (((x) >= 'A') && ((x) <= 'F')) ? ((x) - 'A' + 10) : \
421 (((x) >= 'a') && ((x) <= 'f')) ? ((x) - 'a' + 10) : \
422 (-1))
425 w32_get_bdf_glyph(bdffont *fontp, int index, int size, glyph_struct *glyph)
427 font_char *pch;
428 unsigned char *start, *p, *q, *bitmapp;
429 unsigned char val, val1, val2;
430 int i, j, len, flag, consumed;
431 int align, rowbytes;
433 pch = get_cached_font_char(fontp, index);
434 if (!pch)
436 pch = seek_char(fontp, index);
437 if (!pch)
438 return 0;
441 start = pch->offset;
443 if ((size == 0) && pch->pcbmp)
445 glyph->metric = pch->pcbmp->metric;
446 return 1;
449 len = fontp->size - (start - fontp->font);
451 flag = proceed_file_line("DWIDTH", start, &len, &p, &q);
452 if (!flag)
453 return 0;
454 glyph->metric.dwidth = atoi(p);
456 start = q;
457 flag = proceed_file_line("BBX", start, &len, &p, &q);
458 if (!flag)
459 return 0;
460 glyph->metric.bbw = strtol(p, &start, 10);
461 p = start;
462 glyph->metric.bbh = strtol(p, &start, 10);
463 p = start;
464 glyph->metric.bbox = strtol(p, &start, 10);
465 p = start;
466 glyph->metric.bboy = strtol(p, &start, 10);
468 if (size == 0) return 1;
470 start = q;
471 flag = proceed_file_line("BITMAP", start, &len, &p, &q);
472 if (!flag)
473 return 0;
475 consumed = 0;
476 flag = 0;
477 p = q;
478 bitmapp = glyph->bitmap;
479 rowbytes = (glyph->metric.bbw + 7) / 8;
480 /* DIB requires DWORD alignment. */
481 align = sizeof(DWORD) - rowbytes % sizeof(DWORD);
482 consumed = glyph->metric.bbh * (rowbytes + align);
483 glyph->bitmap_size = consumed;
484 glyph->row_byte_size = rowbytes;
485 if (size < consumed) return 0;
487 for(i = 0;i < glyph->metric.bbh;i++)
489 q = memchr(p, '\n', len);
490 if (!q) return 0;
491 for(j = 0;((q > p) && (j < rowbytes));j++)
493 val1 = GET_HEX_VAL(*p);
494 if (val1 == -1) return 0;
495 p++;
496 val2 = GET_HEX_VAL(*p);
497 if (val2 == -1) return 0;
498 p++;
499 val = (unsigned char)((val1 << 4) | val2);
500 if (val) flag = 1;
501 *bitmapp++ = val;
503 for(j = 0;j < align;j++)
504 *bitmapp++ = 0x00;
505 p = q + 1;
508 /* If this glyph is white space, return -1. */
509 if (flag == 0) return -1;
511 return consumed;
514 static
515 cache_bitmap*
516 get_bitmap_with_cache(bdffont *fontp, int index)
518 int bitmap_size, bitmap_real_size;
519 font_char *pch;
520 cache_bitmap* pcb;
521 unsigned char *pbmp;
522 glyph_struct glyph;
524 pch = get_cached_font_char(fontp, index);
525 if (pch)
527 pcb = pch->pcbmp;
528 if (pcb) return pcb;
531 bitmap_size = ((fontp->urx - fontp->llx) / 8 + 3) * (fontp->ury - fontp->lly)
532 + 256;
533 glyph.bitmap = (unsigned char*) alloca(sizeof(unsigned char) * bitmap_size);
535 bitmap_real_size = w32_get_bdf_glyph(fontp, index, bitmap_size, &glyph);
537 if (bitmap_real_size == 0)
538 return NULL;
540 pch = get_cached_font_char(fontp, index);
541 if (!pch) return NULL;
543 if (bitmap_real_size > 0)
545 pbmp = (unsigned char*) HeapAlloc(hbdf_bmp_heap, 0,
546 bitmap_real_size);
547 if (!pbmp) return NULL;
548 memcpy(pbmp, glyph.bitmap, bitmap_real_size);
550 else
551 pbmp = NULL; /* white space character */
553 pcb = pcached_bitmap_latest;
554 if (pcb->psrc)
555 clear_cached_bitmap_slots();
557 pcb->psrc = pch;
558 pcb->metric = glyph.metric;
559 pcb->pbmp = pbmp;
560 pcb->bitmap_size = glyph.bitmap_size;
561 pcb->row_byte_size = glyph.row_byte_size;
563 pch->pcbmp = pcb;
565 pcached_bitmap_latest++;
566 if (FONT_CACHE_SLOT_OVER_P(pcached_bitmap_latest))
567 pcached_bitmap_latest = cached_bitmap_slots;
569 return pcb;
572 static HBITMAP
573 create_offscreen_bitmap(HDC hdc, int width, int height, unsigned char **bitsp)
575 HBITMAP hBMP;
576 struct {
577 BITMAPINFOHEADER h;
578 RGBQUAD c[2];
579 } info;
581 memset(&info, 0, sizeof(info));
582 info.h.biSize = sizeof(BITMAPINFOHEADER);
583 info.h.biWidth = width;
584 info.h.biHeight = -height;
585 info.h.biPlanes = 1;
586 info.h.biBitCount = 1;
587 info.h.biCompression = BI_RGB;
588 info.c[1].rgbRed = info.c[1].rgbGreen = info.c[1].rgbBlue = 255;
590 return CreateDIBSection(hdc, (LPBITMAPINFO)&info,
591 DIB_RGB_COLORS, bitsp, NULL, 0);
594 glyph_metric *
595 w32_BDF_TextMetric(bdffont *fontp, unsigned char *text, int dim)
597 int index;
598 cache_bitmap *pcb;
600 if (dim == 1)
601 index = *text;
602 else
603 index = MAKELENDSHORT(text[1], text[0]);
605 pcb = get_bitmap_with_cache(fontp, index);
606 if (!pcb)
607 return NULL;
609 return &(pcb->metric);
613 w32_BDF_TextOut(bdffont *fontp, HDC hdc, int left,
614 int top, unsigned char *text, int dim, int bytelen,
615 int fixed_pitch_size)
617 int index, btop;
618 unsigned char *textp;
619 cache_bitmap *pcb;
620 HBRUSH hFgBrush, hOrgBrush;
621 HANDLE horgobj;
622 UINT textalign;
623 int width, height;
624 HDC hCompatDC;
625 int ret = 1;
626 static HBITMAP hBMP = 0;
627 static HDC DIBsection_hdc = 0;
628 static int DIBsection_width, DIBsection_height;
629 static unsigned char *bits;
631 hCompatDC = CreateCompatibleDC(hdc);
632 if (!hCompatDC)
633 return 0;
635 textalign = GetTextAlign(hdc);
637 hFgBrush = CreateSolidBrush(GetTextColor(hdc));
638 hOrgBrush = SelectObject(hdc, hFgBrush);
640 textp = text;
642 while(bytelen > 0)
644 if (dim == 1)
646 index = *textp++;
647 bytelen--;
649 else
651 bytelen -= 2;
652 if (bytelen < 0) break;
653 index = MAKELENDSHORT(textp[0], textp[1]);
654 textp += 2;
656 pcb = get_bitmap_with_cache(fontp, index);
657 if (!pcb)
659 ret = 0;
660 break;
662 if (pcb->pbmp)
664 width = pcb->metric.bbw;
665 height = pcb->metric.bbh;
667 if (!(hBMP
668 && (DIBsection_hdc == hdc)
669 && (DIBsection_width == width)
670 && (DIBsection_height == height)))
672 if (hBMP) DeleteObject(hBMP);
673 hBMP = create_offscreen_bitmap(hdc, width, height, &bits);
674 DIBsection_hdc = hdc;
675 DIBsection_width = width;
676 DIBsection_height = height;
677 if (!hBMP) return 0;
680 memcpy(bits, pcb->pbmp, pcb->bitmap_size);
682 if (textalign & TA_BASELINE)
683 btop = top - (pcb->metric.bbh + pcb->metric.bboy);
684 else if (textalign & TA_BOTTOM)
685 btop = top - pcb->metric.bbh;
686 else
687 btop = top;
689 horgobj = SelectObject(hCompatDC, hBMP);
690 BitBlt(hdc, left, btop, width, height, hCompatDC, 0, 0, 0xE20746);
691 SelectObject(hCompatDC, horgobj);
694 if (fixed_pitch_size)
695 left += fixed_pitch_size;
696 else
697 left += pcb->metric.dwidth;
700 DeleteDC(hCompatDC);
702 SelectObject(hdc, hOrgBrush);
703 DeleteObject(hFgBrush);
705 return ret;
708 struct font_info *w32_load_bdf_font (struct frame *f, char *fontname,
709 int size, char* filename)
711 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
712 struct font_info *fontp;
713 XFontStruct *font;
714 bdffont* bdf_font;
716 bdf_font = w32_init_bdf_font (filename);
718 if (!bdf_font) return NULL;
720 font = (XFontStruct *) xmalloc (sizeof (XFontStruct));
721 bzero (font, sizeof (*font));
723 font->bdf = bdf_font;
724 font->hfont = 0;
726 /* NTEMACS_TODO: Better way of determining if a font is double byte
727 or not. */
728 font->double_byte_p = bdf_font->nchars > 255 ? 1 : 0;
730 w32_cache_char_metrics (font);
732 /* Do we need to create the table? */
733 if (dpyinfo->font_table_size == 0)
735 dpyinfo->font_table_size = 16;
736 dpyinfo->font_table
737 = (struct font_info *) xmalloc (dpyinfo->font_table_size
738 * sizeof (struct font_info));
740 /* Do we need to grow the table? */
741 else if (dpyinfo->n_fonts
742 >= dpyinfo->font_table_size)
744 dpyinfo->font_table_size *= 2;
745 dpyinfo->font_table
746 = (struct font_info *) xrealloc (dpyinfo->font_table,
747 (dpyinfo->font_table_size
748 * sizeof (struct font_info)));
751 fontp = dpyinfo->font_table + dpyinfo->n_fonts;
753 /* Now fill in the slots of *FONTP. */
754 BLOCK_INPUT;
755 fontp->font = font;
756 fontp->font_idx = dpyinfo->n_fonts;
757 fontp->name = (char *) xmalloc (strlen (fontname) + 1);
758 bcopy (fontname, fontp->name, strlen (fontname) + 1);
759 fontp->full_name = fontp->name;
760 fontp->size = FONT_WIDTH (font);
761 fontp->height = FONT_HEIGHT (font);
763 /* The slot `encoding' specifies how to map a character
764 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
765 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF, 0:0x2020..0x7F7F,
766 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF,
767 0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF, or
768 2:0xA020..0xFF7F). For the moment, we don't know which charset
769 uses this font. So, we set informatoin in fontp->encoding[1]
770 which is never used by any charset. If mapping can't be
771 decided, set FONT_ENCODING_NOT_DECIDED. */
772 fontp->encoding[1] = FONT_ENCODING_NOT_DECIDED;
773 fontp->baseline_offset = bdf_font->yoffset;
774 fontp->relative_compose = bdf_font->relative_compose;
775 fontp->default_ascent = bdf_font->default_ascent;
777 UNBLOCK_INPUT;
778 dpyinfo->n_fonts++;
779 return fontp;
782 /* Check a file for an XFLD string describing it. */
783 int w32_BDF_to_x_font (char *file, char* xstr, int len)
785 HANDLE hfile, hfilemap;
786 BY_HANDLE_FILE_INFORMATION fileinfo;
787 char *font, *start, *p, *q;
788 int flag, size, retval = 0;
790 hfile = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL,
791 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
792 if (hfile == INVALID_HANDLE_VALUE) return 0;
793 if (!GetFileInformationByHandle(hfile, &fileinfo) ||
794 (fileinfo.nFileSizeHigh != 0) ||
795 (fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
797 CloseHandle (hfile);
798 return 0;
800 size = fileinfo.nFileSizeLow;
802 hfilemap = CreateFileMapping (hfile, NULL, PAGE_READONLY, 0, 0, NULL);
803 if (hfilemap == INVALID_HANDLE_VALUE)
805 CloseHandle (hfile);
806 return 0;
809 font = MapViewOfFile (hfilemap, FILE_MAP_READ, 0, 0, 0);
810 if (!font)
812 CloseHandle (hfile);
813 CloseHandle (hfilemap);
814 return 0;
816 start = font;
818 flag = proceed_file_line ("FONT ", start, &size, &p, &q);
819 if (flag)
821 /* If font provides a description of itself, check it is a
822 full XLFD before accepting it. */
823 int count = 0;
824 char *s;
826 for (s = p; s < q; s++)
827 if (*s == '\n')
828 break;
829 else if (*s == '-')
830 count++;
831 if (count == 14 && q - p - 1 <= len)
833 strncpy (xstr, p, q-p-1);
834 xstr[q-p-1] = '\0';
835 /* Files may have DOS line ends (ie still ^M on end). */
836 if (iscntrl(xstr[q-p-2]))
837 xstr[q-p-2] = '\0';
839 retval = 1;
842 CloseHandle (hfile);
843 CloseHandle (hfilemap);
844 return retval;