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