1 /* Font backend for the Microsoft W32 API.
2 Copyright (C) 2007 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)
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., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
27 #include "dispextern.h"
28 #include "character.h"
34 /* Cleartype available on Windows XP, cleartype_natural from XP SP1.
35 The latter does not try to fit cleartype smoothed fonts into the
36 same bounding box as the non-antialiased version of the font.
38 #ifndef CLEARTYPE_QUALITY
39 #define CLEARTYPE_QUALITY 5
41 #ifndef CLEARTYPE_NATURAL_QUALITY
42 #define CLEARTYPE_NATURAL_QUALITY 6
45 extern struct font_driver w32font_driver
;
48 extern Lisp_Object QCfamily
; /* reuse from xfaces.c */
49 static Lisp_Object Qmonospace
, Qsans_serif
, Qserif
, Qmono
, Qsans
, Qsans__serif
;
50 static Lisp_Object Qscript
, Qdecorative
, Qraster
, Qoutline
, Qunknown
;
53 extern Lisp_Object QCantialias
; /* defined in font.c */
54 extern Lisp_Object Qnone
; /* reuse from w32fns.c */
55 static Lisp_Object Qstandard
, Qsubpixel
, Qnatural
;
58 static Lisp_Object Qlatin
, Qgreek
, Qcoptic
, Qcyrillic
, Qarmenian
, Qhebrew
;
59 static Lisp_Object Qarabic
, Qsyriac
, Qnko
, Qthaana
, Qdevanagari
, Qbengali
;
60 static Lisp_Object Qgurmukhi
, Qgujarati
, Qoriya
, Qtamil
, Qtelugu
;
61 static Lisp_Object Qkannada
, Qmalayalam
, Qsinhala
, Qthai
, Qlao
;
62 static Lisp_Object Qtibetan
, Qmyanmar
, Qgeorgian
, Qhangul
, Qethiopic
;
63 static Lisp_Object Qcherokee
, Qcanadian_aboriginal
, Qogham
, Qrunic
;
64 static Lisp_Object Qkhmer
, Qmongolian
, Qsymbol
, Qbraille
, Qhan
;
65 static Lisp_Object Qideographic_description
, Qcjk_misc
, Qkana
, Qbopomofo
;
66 static Lisp_Object Qkanbun
, Qyi
, Qbyzantine_musical_symbol
;
67 static Lisp_Object Qmusical_symbol
, Qmathematical
;
69 /* Font spacing symbols - defined in font.c. */
70 extern Lisp_Object Qc
, Qp
, Qm
;
72 static void fill_in_logfont
P_ ((FRAME_PTR f
, LOGFONT
*logfont
,
73 Lisp_Object font_spec
));
75 static BYTE w32_antialias_type
P_ ((Lisp_Object type
));
76 static Lisp_Object lispy_antialias_type
P_ ((BYTE type
));
78 static Lisp_Object font_supported_scripts
P_ ((FONTSIGNATURE
* sig
));
80 /* From old font code in w32fns.c */
81 char * w32_to_x_charset
P_ ((int charset
, char * matching
));
83 static Lisp_Object w32_registry
P_ ((LONG w32_charset
));
85 /* EnumFontFamiliesEx callbacks. */
86 static int CALLBACK add_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
89 static int CALLBACK add_one_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
92 static int CALLBACK add_font_name_to_list
P_ ((ENUMLOGFONTEX
*,
96 /* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
97 of what we really want. */
98 struct font_callback_data
100 /* The logfont we are matching against. EnumFontFamiliesEx only matches
101 face name and charset, so we need to manually match everything else
102 in the callback function. */
104 /* The original font spec or entity. */
105 Lisp_Object orig_font_spec
;
106 /* The frame the font is being loaded on. */
108 /* The list to add matches to. */
110 /* Whether to match only opentype fonts. */
114 /* Handles the problem that EnumFontFamiliesEx will not return all
115 style variations if the font name is not specified. */
116 static void list_all_matching_fonts
P_ ((struct font_callback_data
*match
));
119 /* MingW headers only define this when _WIN32_WINNT >= 0x0500, but we
120 target older versions. */
121 #ifndef GGI_MARK_NONEXISTING_GLYPHS
122 #define GGI_MARK_NONEXISTING_GLYPHS 1
126 memq_no_quit (elt
, list
)
127 Lisp_Object elt
, list
;
129 while (CONSP (list
) && ! EQ (XCAR (list
), elt
))
131 return (CONSP (list
));
134 /* w32 implementation of get_cache for font backend.
135 Return a cache of font-entities on FRAME. The cache must be a
136 cons whose cdr part is the actual cache area. */
138 w32font_get_cache (frame
)
141 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (frame
));
143 return (dpyinfo
->name_list_element
);
146 /* w32 implementation of list for font backend.
147 List fonts exactly matching with FONT_SPEC on FRAME. The value
148 is a vector of font-entities. This is the sole API that
149 allocates font-entities. */
151 w32font_list (frame
, font_spec
)
152 Lisp_Object frame
, font_spec
;
154 return w32font_list_internal (frame
, font_spec
, 0);
157 /* w32 implementation of match for font backend.
158 Return a font entity most closely matching with FONT_SPEC on
159 FRAME. The closeness is detemined by the font backend, thus
160 `face-font-selection-order' is ignored here. */
162 w32font_match (frame
, font_spec
)
163 Lisp_Object frame
, font_spec
;
165 return w32font_match_internal (frame
, font_spec
, 0);
168 /* w32 implementation of list_family for font backend.
169 List available families. The value is a list of family names
172 w32font_list_family (frame
)
175 Lisp_Object list
= Qnil
;
176 LOGFONT font_match_pattern
;
178 FRAME_PTR f
= XFRAME (frame
);
180 bzero (&font_match_pattern
, sizeof (font_match_pattern
));
182 dc
= get_frame_dc (f
);
184 EnumFontFamiliesEx (dc
, &font_match_pattern
,
185 (FONTENUMPROC
) add_font_name_to_list
,
187 release_frame_dc (f
, dc
);
192 /* w32 implementation of open for font backend.
193 Open a font specified by FONT_ENTITY on frame F.
194 If the font is scalable, open it with PIXEL_SIZE. */
196 w32font_open (f
, font_entity
, pixel_size
)
198 Lisp_Object font_entity
;
201 struct w32font_info
*w32_font
= xmalloc (sizeof (struct w32font_info
));
203 if (w32_font
== NULL
)
206 if (!w32font_open_internal (f
, font_entity
, pixel_size
, w32_font
))
212 return (struct font
*) w32_font
;
215 /* w32 implementation of close for font_backend.
216 Close FONT on frame F. */
218 w32font_close (f
, font
)
224 W32FontStruct
*old_w32_font
= (W32FontStruct
*)font
->font
.font
;
225 DeleteObject (old_w32_font
->hfont
);
226 xfree (old_w32_font
);
231 xfree (font
->font
.name
);
235 /* w32 implementation of has_char for font backend.
237 If FONT_ENTITY has a glyph for character C (Unicode code point),
238 return 1. If not, return 0. If a font must be opened to check
241 w32font_has_char (entity
, c
)
245 Lisp_Object supported_scripts
, extra
, script
;
248 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
252 supported_scripts
= assq_no_quit (QCscript
, extra
);
253 if (!CONSP (supported_scripts
))
256 supported_scripts
= XCDR (supported_scripts
);
258 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
260 return (memq_no_quit (script
, supported_scripts
)) ? 1 : 0;
263 /* w32 implementation of encode_char for font backend.
264 Return a glyph code of FONT for characer C (Unicode code point).
265 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
267 w32font_encode_char (font
, c
)
271 /* Avoid unneccesary conversion - all the Win32 APIs will take a unicode
276 /* w32 implementation of text_extents for font backend.
277 Perform the size computation of glyphs of FONT and fillin members
278 of METRICS. The glyphs are specified by their glyph codes in
279 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
280 case just return the overall width. */
282 w32font_text_extents (font
, code
, nglyphs
, metrics
)
286 struct font_metrics
*metrics
;
293 WORD
*wcode
= alloca(nglyphs
* sizeof (WORD
));
296 f
= ((struct w32font_info
*)font
)->owning_frame
;
297 dc
= get_frame_dc (f
);
298 old_font
= SelectObject (dc
, ((W32FontStruct
*)(font
->font
.font
))->hfont
);
305 /* Set transform to the identity matrix. */
306 bzero (&transform
, sizeof (transform
));
307 transform
.eM11
.value
= 1;
308 transform
.eM22
.value
= 1;
311 metrics
->descent
= 0;
313 for (i
= 0; i
< nglyphs
; i
++)
315 if (GetGlyphOutlineW (dc
, *(code
+ i
), GGO_METRICS
, &gm
, 0,
316 NULL
, &transform
) != GDI_ERROR
)
318 int new_val
= metrics
->width
+ gm
.gmBlackBoxX
319 + gm
.gmptGlyphOrigin
.x
;
321 metrics
->rbearing
= max (metrics
->rbearing
, new_val
);
322 metrics
->width
+= gm
.gmCellIncX
;
323 new_val
= -gm
.gmptGlyphOrigin
.y
;
324 metrics
->ascent
= max (metrics
->ascent
, new_val
);
325 new_val
= gm
.gmBlackBoxY
+ gm
.gmptGlyphOrigin
.y
;
326 metrics
->descent
= max (metrics
->descent
, new_val
);
330 /* Rely on an estimate based on the overall font metrics. */
335 /* If we got through everything, return. */
338 /* Restore state and release DC. */
339 SelectObject (dc
, old_font
);
340 release_frame_dc (f
, dc
);
342 return metrics
->width
;
346 for (i
= 0; i
< nglyphs
; i
++)
348 if (code
[i
] < 0x10000)
352 /* TODO: Convert to surrogate, reallocating array if needed */
357 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
359 total_width
= size
.cx
;
365 rect
.top
= 0; rect
.bottom
= font
->font
.height
; rect
.left
= 0; rect
.right
= 1;
366 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
367 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
368 total_width
= rect
.right
;
373 metrics
->width
= total_width
;
374 metrics
->ascent
= font
->ascent
;
375 metrics
->descent
= font
->descent
;
376 metrics
->lbearing
= 0;
377 metrics
->rbearing
= total_width
378 + ((struct w32font_info
*) font
)->metrics
.tmOverhang
;
381 /* Restore state and release DC. */
382 SelectObject (dc
, old_font
);
383 release_frame_dc (f
, dc
);
388 /* w32 implementation of draw for font backend.
390 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
391 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
392 is nonzero, fill the background in advance. It is assured that
393 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
395 TODO: Currently this assumes that the colors and fonts are already
396 set in the DC. This seems to be true now, but maybe only due to
397 the old font code setting it up. It may be safer to resolve faces
398 and fonts in here and set them explicitly
402 w32font_draw (s
, from
, to
, x
, y
, with_background
)
403 struct glyph_string
*s
;
404 int from
, to
, x
, y
, with_background
;
409 /* Save clip region for later restoration. */
410 GetClipRgn(s
->hdc
, orig_clip
);
412 if (s
->num_clips
> 0)
414 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
416 if (s
->num_clips
> 1)
418 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
420 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
421 DeleteObject (clip2
);
424 SelectClipRgn (s
->hdc
, new_clip
);
425 DeleteObject (new_clip
);
428 /* Using OPAQUE background mode can clear more background than expected
429 when Cleartype is used. Draw the background manually to avoid this. */
430 SetBkMode (s
->hdc
, TRANSPARENT
);
435 struct font
*font
= (struct font
*) s
->face
->font_info
;
437 brush
= CreateSolidBrush (s
->gc
->background
);
439 rect
.top
= y
- font
->ascent
;
440 rect
.right
= x
+ s
->width
;
441 rect
.bottom
= y
+ font
->descent
;
442 FillRect (s
->hdc
, &rect
, brush
);
443 DeleteObject (brush
);
446 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, to
- from
, NULL
);
448 /* Restore clip region. */
449 if (s
->num_clips
> 0)
451 SelectClipRgn (s
->hdc
, orig_clip
);
455 /* w32 implementation of free_entity for font backend.
456 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
457 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
459 w32font_free_entity (Lisp_Object entity);
462 /* w32 implementation of prepare_face for font backend.
463 Optional (if FACE->extra is not used).
464 Prepare FACE for displaying characters by FONT on frame F by
465 storing some data in FACE->extra. If successful, return 0.
466 Otherwise, return -1.
468 w32font_prepare_face (FRAME_PTR f, struct face *face);
470 /* w32 implementation of done_face for font backend.
472 Done FACE for displaying characters by FACE->font on frame F.
474 w32font_done_face (FRAME_PTR f, struct face *face); */
476 /* w32 implementation of get_bitmap for font backend.
478 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
479 intended that this method is called from the other font-driver
482 w32font_get_bitmap (struct font *font, unsigned code,
483 struct font_bitmap *bitmap, int bits_per_pixel);
485 /* w32 implementation of free_bitmap for font backend.
487 Free bitmap data in BITMAP.
489 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
491 /* w32 implementation of get_outline for font backend.
493 Return an outline data for glyph-code CODE of FONT. The format
494 of the outline data depends on the font-driver.
496 w32font_get_outline (struct font *font, unsigned code);
498 /* w32 implementation of free_outline for font backend.
500 Free OUTLINE (that is obtained by the above method).
502 w32font_free_outline (struct font *font, void *outline);
504 /* w32 implementation of anchor_point for font backend.
506 Get coordinates of the INDEXth anchor point of the glyph whose
507 code is CODE. Store the coordinates in *X and *Y. Return 0 if
508 the operations was successfull. Otherwise return -1.
510 w32font_anchor_point (struct font *font, unsigned code,
511 int index, int *x, int *y);
513 /* w32 implementation of otf_capability for font backend.
515 Return a list describing which scripts/languages FONT
516 supports by which GSUB/GPOS features of OpenType tables.
518 w32font_otf_capability (struct font *font);
520 /* w32 implementation of otf_drive for font backend.
522 Apply FONT's OTF-FEATURES to the glyph string.
524 FEATURES specifies which OTF features to apply in this format:
525 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
526 See the documentation of `font-drive-otf' for the detail.
528 This method applies the specified features to the codes in the
529 elements of GSTRING-IN (between FROMth and TOth). The output
530 codes are stored in GSTRING-OUT at the IDXth element and the
533 Return the number of output codes. If none of the features are
534 applicable to the input data, return 0. If GSTRING-OUT is too
537 w32font_otf_drive (struct font *font, Lisp_Object features,
538 Lisp_Object gstring_in, int from, int to,
539 Lisp_Object gstring_out, int idx,
540 int alternate_subst);
543 /* Internal implementation of w32font_list.
544 Additional parameter opentype_only restricts the returned fonts to
545 opentype fonts, which can be used with the Uniscribe backend. */
547 w32font_list_internal (frame
, font_spec
, opentype_only
)
548 Lisp_Object frame
, font_spec
;
551 struct font_callback_data match_data
;
553 FRAME_PTR f
= XFRAME (frame
);
555 match_data
.orig_font_spec
= font_spec
;
556 match_data
.list
= Qnil
;
557 match_data
.frame
= frame
;
559 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
560 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
562 match_data
.opentype_only
= opentype_only
;
564 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
566 if (match_data
.pattern
.lfFaceName
[0] == '\0')
568 /* EnumFontFamiliesEx does not take other fields into account if
569 font name is blank, so need to use two passes. */
570 list_all_matching_fonts (&match_data
);
574 dc
= get_frame_dc (f
);
576 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
577 (FONTENUMPROC
) add_font_entity_to_list
,
578 (LPARAM
) &match_data
, 0);
579 release_frame_dc (f
, dc
);
582 return NILP (match_data
.list
) ? null_vector
: Fvconcat (1, &match_data
.list
);
585 /* Internal implementation of w32font_match.
586 Additional parameter opentype_only restricts the returned fonts to
587 opentype fonts, which can be used with the Uniscribe backend. */
589 w32font_match_internal (frame
, font_spec
, opentype_only
)
590 Lisp_Object frame
, font_spec
;
593 struct font_callback_data match_data
;
595 FRAME_PTR f
= XFRAME (frame
);
597 match_data
.orig_font_spec
= font_spec
;
598 match_data
.frame
= frame
;
599 match_data
.list
= Qnil
;
601 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
602 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
604 match_data
.opentype_only
= opentype_only
;
606 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
608 dc
= get_frame_dc (f
);
610 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
611 (FONTENUMPROC
) add_one_font_entity_to_list
,
612 (LPARAM
) &match_data
, 0);
613 release_frame_dc (f
, dc
);
615 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
619 w32font_open_internal (f
, font_entity
, pixel_size
, w32_font
)
621 Lisp_Object font_entity
;
623 struct w32font_info
*w32_font
;
628 HFONT hfont
, old_font
;
629 Lisp_Object val
, extra
;
630 /* For backwards compatibility. */
631 W32FontStruct
*compat_w32_font
;
633 struct font
* font
= (struct font
*) w32_font
;
637 bzero (&logfont
, sizeof (logfont
));
638 fill_in_logfont (f
, &logfont
, font_entity
);
640 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
644 logfont
.lfHeight
= -size
;
645 hfont
= CreateFontIndirect (&logfont
);
650 w32_font
->owning_frame
= f
;
652 /* Get the metrics for this font. */
653 dc
= get_frame_dc (f
);
654 old_font
= SelectObject (dc
, hfont
);
656 GetTextMetrics (dc
, &w32_font
->metrics
);
658 SelectObject (dc
, old_font
);
659 release_frame_dc (f
, dc
);
660 /* W32FontStruct - we should get rid of this, and use the w32font_info
661 struct for any W32 specific fields. font->font.font can then be hfont. */
662 font
->font
.font
= xmalloc (sizeof (W32FontStruct
));
663 compat_w32_font
= (W32FontStruct
*) font
->font
.font
;
664 bzero (compat_w32_font
, sizeof (W32FontStruct
));
665 compat_w32_font
->font_type
= UNICODE_FONT
;
666 /* Duplicate the text metrics. */
667 bcopy (&w32_font
->metrics
, &compat_w32_font
->tm
, sizeof (TEXTMETRIC
));
668 compat_w32_font
->hfont
= hfont
;
670 len
= strlen (logfont
.lfFaceName
);
671 font
->font
.name
= (char *) xmalloc (len
+ 1);
672 bcopy (logfont
.lfFaceName
, font
->font
.name
, len
);
673 font
->font
.name
[len
] = '\0';
674 font
->font
.full_name
= font
->font
.name
;
675 font
->font
.charset
= 0;
676 font
->font
.codepage
= 0;
677 font
->font
.size
= w32_font
->metrics
.tmMaxCharWidth
;
678 font
->font
.height
= w32_font
->metrics
.tmHeight
679 + w32_font
->metrics
.tmExternalLeading
;
680 font
->font
.space_width
= font
->font
.average_width
681 = w32_font
->metrics
.tmAveCharWidth
;
683 font
->font
.vertical_centering
= 0;
684 font
->font
.encoding_type
= 0;
685 font
->font
.baseline_offset
= 0;
686 font
->font
.relative_compose
= 0;
687 font
->font
.default_ascent
= w32_font
->metrics
.tmAscent
;
688 font
->font
.font_encoder
= NULL
;
689 font
->entity
= font_entity
;
690 font
->pixel_size
= size
;
691 font
->driver
= &w32font_driver
;
693 font
->file_name
= NULL
;
694 font
->encoding_charset
= -1;
695 font
->repertory_charset
= -1;
697 font
->ascent
= w32_font
->metrics
.tmAscent
;
698 font
->descent
= w32_font
->metrics
.tmDescent
;
699 font
->scalable
= w32_font
->metrics
.tmPitchAndFamily
& TMPF_VECTOR
;
704 /* Callback function for EnumFontFamiliesEx.
705 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
707 add_font_name_to_list (logical_font
, physical_font
, font_type
, list_object
)
708 ENUMLOGFONTEX
*logical_font
;
709 NEWTEXTMETRICEX
*physical_font
;
713 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
716 /* Skip vertical fonts (intended only for printing) */
717 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
720 family
= intern_downcase (logical_font
->elfLogFont
.lfFaceName
,
721 strlen (logical_font
->elfLogFont
.lfFaceName
));
722 if (! memq_no_quit (family
, *list
))
723 *list
= Fcons (family
, *list
);
728 /* Convert an enumerated Windows font to an Emacs font entity. */
730 w32_enumfont_pattern_entity (frame
, logical_font
, physical_font
,
731 font_type
, requested_font
)
733 ENUMLOGFONTEX
*logical_font
;
734 NEWTEXTMETRICEX
*physical_font
;
736 LOGFONT
*requested_font
;
738 Lisp_Object entity
, tem
;
739 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
742 entity
= Fmake_vector (make_number (FONT_ENTITY_MAX
), Qnil
);
744 ASET (entity
, FONT_TYPE_INDEX
, Qgdi
);
745 ASET (entity
, FONT_FRAME_INDEX
, frame
);
746 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
));
747 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
749 /* Foundry is difficult to get in readable form on Windows.
750 But Emacs crashes if it is not set, so set it to something more
751 generic. Thes values make xflds compatible with Emacs 22. */
752 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
754 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
759 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
761 /* Save the generic family in the extra info, as it is likely to be
762 useful to users looking for a close match. */
763 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
764 if (generic_type
== FF_DECORATIVE
)
766 else if (generic_type
== FF_MODERN
)
768 else if (generic_type
== FF_ROMAN
)
770 else if (generic_type
== FF_SCRIPT
)
772 else if (generic_type
== FF_SWISS
)
778 font_put_extra (entity
, QCfamily
, tem
);
780 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
781 font_put_extra (entity
, QCspacing
, make_number (FONT_SPACING_PROPORTIONAL
));
783 font_put_extra (entity
, QCspacing
, make_number (FONT_SPACING_MONO
));
785 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
787 font_put_extra (entity
, QCantialias
,
788 lispy_antialias_type (requested_font
->lfQuality
));
790 ASET (entity
, FONT_FAMILY_INDEX
,
791 intern_downcase (lf
->lfFaceName
, strlen (lf
->lfFaceName
)));
793 ASET (entity
, FONT_WEIGHT_INDEX
, make_number (lf
->lfWeight
));
794 ASET (entity
, FONT_SLANT_INDEX
, make_number (lf
->lfItalic
? 200 : 100));
795 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
797 ASET (entity
, FONT_WIDTH_INDEX
, make_number (100));
799 if (font_type
& RASTER_FONTTYPE
)
800 ASET (entity
, FONT_SIZE_INDEX
, make_number (physical_font
->ntmTm
.tmHeight
));
802 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
804 /* Cache unicode codepoints covered by this font, as there is no other way
805 of getting this information easily. */
806 if (font_type
& TRUETYPE_FONTTYPE
)
808 font_put_extra (entity
, QCscript
,
809 font_supported_scripts (&physical_font
->ntmFontSig
));
816 /* Convert generic families to the family portion of lfPitchAndFamily. */
818 w32_generic_family (Lisp_Object name
)
820 /* Generic families. */
821 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
823 else if (EQ (name
, Qsans_serif
) || EQ (name
, Qsans__serif
)
826 else if (EQ (name
, Qserif
))
828 else if (EQ (name
, Qdecorative
))
829 return FF_DECORATIVE
;
830 else if (EQ (name
, Qscript
))
837 logfonts_match (font
, pattern
)
838 LOGFONT
*font
, *pattern
;
840 /* Only check height for raster fonts. */
841 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
842 && font
->lfHeight
!= pattern
->lfHeight
)
845 /* Have some flexibility with weights. */
846 if (pattern
->lfWeight
847 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
848 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
851 /* Charset and face should be OK. Italic has to be checked
852 against the original spec, in case we don't have any preference. */
857 font_matches_spec (type
, font
, spec
)
859 NEWTEXTMETRICEX
*font
;
862 Lisp_Object extra
, val
;
864 /* Check italic. Can't check logfonts, since it is a boolean field,
865 so there is no difference between "non-italic" and "don't care". */
866 val
= AREF (spec
, FONT_SLANT_INDEX
);
869 int slant
= XINT (val
);
870 if ((slant
> 150 && !font
->ntmTm
.tmItalic
)
871 || (slant
<= 150 && font
->ntmTm
.tmItalic
))
875 /* Check extra parameters. */
876 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
877 CONSP (extra
); extra
= XCDR (extra
))
879 Lisp_Object extra_entry
;
880 extra_entry
= XCAR (extra
);
881 if (CONSP (extra_entry
))
883 Lisp_Object key
= XCAR (extra_entry
);
884 val
= XCDR (extra_entry
);
885 if (EQ (key
, QCfamily
))
887 /* Generic family. Most useful when there is no font name
888 specified. eg, if a script does not exist in the default
889 font, we could look for a font with the same generic family
890 that does support the script. Full PANOSE support would
891 be better, but we need to open the font to get that. */
892 BYTE w32_family
= w32_generic_family (val
);
894 /* Reject if FF_DONTCARE is returned, as it means the
896 if (w32_family
== FF_DONTCARE
897 || w32_family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
900 else if (EQ (key
, QCspacing
))
905 int spacing
= XINT (val
);
906 proportional
= (spacing
< FONT_SPACING_MONO
);
908 else if (EQ (val
, Qp
))
910 else if (EQ (val
, Qc
) || EQ (val
, Qm
))
913 return 0; /* Bad font spec. */
915 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
916 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
919 else if (EQ (key
, QCscript
) && SYMBOLP (val
))
921 /* Only truetype fonts will have information about what
922 scripts they support. This probably means the user
923 will have to force Emacs to use raster, postscript
924 or atm fonts for non-ASCII text. */
925 if (type
& TRUETYPE_FONTTYPE
)
928 = font_supported_scripts (&font
->ntmFontSig
);
929 if (! memq_no_quit (val
, support
))
934 /* Return specific matches, but play it safe. Fonts
935 that cover more than their charset would suggest
936 are likely to be truetype or opentype fonts,
938 if (EQ (val
, Qlatin
))
940 /* Although every charset but symbol, thai and
941 arabic contains the basic ASCII set of latin
942 characters, Emacs expects much more. */
943 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
946 else if (EQ (val
, Qsymbol
))
948 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
951 else if (EQ (val
, Qcyrillic
))
953 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
956 else if (EQ (val
, Qgreek
))
958 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
961 else if (EQ (val
, Qarabic
))
963 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
966 else if (EQ (val
, Qhebrew
))
968 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
971 else if (EQ (val
, Qthai
))
973 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
976 else if (EQ (val
, Qkana
))
978 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
981 else if (EQ (val
, Qbopomofo
))
983 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
986 else if (EQ (val
, Qhangul
))
988 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
989 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
992 else if (EQ (val
, Qhan
))
994 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
995 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
996 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
997 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
998 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1002 /* Other scripts unlikely to be handled. */
1011 /* Callback function for EnumFontFamiliesEx.
1012 * Checks if a font matches everything we are trying to check agaist,
1013 * and if so, adds it to a list. Both the data we are checking against
1014 * and the list to which the fonts are added are passed in via the
1015 * lparam argument, in the form of a font_callback_data struct. */
1017 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1018 ENUMLOGFONTEX
*logical_font
;
1019 NEWTEXTMETRICEX
*physical_font
;
1023 struct font_callback_data
*match_data
1024 = (struct font_callback_data
*) lParam
;
1026 if ((!match_data
->opentype_only
1027 || (physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
))
1028 && logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1029 && font_matches_spec (font_type
, physical_font
,
1030 match_data
->orig_font_spec
))
1033 = w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1034 physical_font
, font_type
,
1035 &match_data
->pattern
);
1037 match_data
->list
= Fcons (entity
, match_data
->list
);
1042 /* Callback function for EnumFontFamiliesEx.
1043 * Terminates the search once we have a match. */
1045 add_one_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1046 ENUMLOGFONTEX
*logical_font
;
1047 NEWTEXTMETRICEX
*physical_font
;
1051 struct font_callback_data
*match_data
1052 = (struct font_callback_data
*) lParam
;
1053 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1055 /* If we have a font in the list, terminate the search. */
1056 return !NILP (match_data
->list
);
1059 /* Convert a Lisp font registry (symbol) to a windows charset. */
1061 registry_to_w32_charset (charset
)
1062 Lisp_Object charset
;
1064 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1065 || EQ (charset
, Qunicode_sip
))
1066 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1067 else if (EQ (charset
, Qiso8859_1
))
1068 return ANSI_CHARSET
;
1069 else if (SYMBOLP (charset
))
1070 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1071 else if (STRINGP (charset
))
1072 return x_to_w32_charset (SDATA (charset
));
1074 return DEFAULT_CHARSET
;
1078 w32_registry (w32_charset
)
1081 if (w32_charset
== ANSI_CHARSET
)
1085 char * charset
= w32_to_x_charset (w32_charset
, NULL
);
1086 return intern_downcase (charset
, strlen(charset
));
1090 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1092 fill_in_logfont (f
, logfont
, font_spec
)
1095 Lisp_Object font_spec
;
1097 Lisp_Object tmp
, extra
;
1098 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1100 extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
1101 /* Allow user to override dpi settings. */
1104 tmp
= assq_no_quit (QCdpi
, extra
);
1105 if (CONSP (tmp
) && INTEGERP (XCDR (tmp
)))
1107 dpi
= XINT (XCDR (tmp
));
1109 else if (CONSP (tmp
) && FLOATP (XCDR (tmp
)))
1111 dpi
= (int) (XFLOAT_DATA (XCDR (tmp
)) + 0.5);
1116 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1118 logfont
->lfHeight
= -1 * XINT (tmp
);
1119 else if (FLOATP (tmp
))
1120 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1127 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1129 logfont
->lfWeight
= XINT (tmp
);
1132 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
1135 int slant
= XINT (tmp
);
1136 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
1144 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1146 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
1150 /* Clip Precision */
1153 logfont
->lfQuality
= DEFAULT_QUALITY
;
1155 /* Generic Family and Face Name */
1156 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
1158 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1161 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
1162 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
1163 ; /* Font name was generic, don't fill in font name. */
1164 /* Font families are interned, but allow for strings also in case of
1166 else if (SYMBOLP (tmp
))
1167 strncpy (logfont
->lfFaceName
, SDATA (SYMBOL_NAME (tmp
)), LF_FACESIZE
);
1168 else if (STRINGP (tmp
))
1169 strncpy (logfont
->lfFaceName
, SDATA (tmp
), LF_FACESIZE
);
1172 /* Process EXTRA info. */
1173 for ( ; CONSP (extra
); extra
= XCDR (extra
))
1178 Lisp_Object key
, val
;
1179 key
= XCAR (tmp
), val
= XCDR (tmp
);
1180 if (EQ (key
, QCfamily
))
1182 /* Override generic family. */
1183 BYTE family
= w32_generic_family (val
);
1184 if (family
!= FF_DONTCARE
)
1185 logfont
->lfPitchAndFamily
1186 = logfont
->lfPitchAndFamily
& 0x0F | family
;
1188 else if (EQ (key
, QCspacing
))
1190 /* Set pitch based on the spacing property. */
1193 int spacing
= XINT (val
);
1194 if (spacing
< FONT_SPACING_MONO
)
1195 logfont
->lfPitchAndFamily
1196 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1198 logfont
->lfPitchAndFamily
1199 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1201 else if (EQ (val
, Qp
))
1202 logfont
->lfPitchAndFamily
1203 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1204 else if (EQ (val
, Qc
) || EQ (val
, Qm
))
1205 logfont
->lfPitchAndFamily
1206 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1208 /* Only use QCscript if charset is not provided, or is unicode
1209 and a single script is specified. This is rather crude,
1210 and is only used to narrow down the fonts returned where
1211 there is a definite match. Some scripts, such as latin, han,
1212 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1214 else if (EQ (key
, QCscript
)
1215 && logfont
->lfCharSet
== DEFAULT_CHARSET
1218 if (EQ (val
, Qgreek
))
1219 logfont
->lfCharSet
= GREEK_CHARSET
;
1220 else if (EQ (val
, Qhangul
))
1221 logfont
->lfCharSet
= HANGUL_CHARSET
;
1222 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
1223 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
1224 else if (EQ (val
, Qbopomofo
))
1225 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
1226 /* GB 18030 supports tibetan, yi, mongolian,
1227 fonts that support it should show up if we ask for
1229 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
1230 || EQ (val
, Qmongolian
))
1231 logfont
->lfCharSet
= GB2312_CHARSET
;
1232 else if (EQ (val
, Qhebrew
))
1233 logfont
->lfCharSet
= HEBREW_CHARSET
;
1234 else if (EQ (val
, Qarabic
))
1235 logfont
->lfCharSet
= ARABIC_CHARSET
;
1236 else if (EQ (val
, Qthai
))
1237 logfont
->lfCharSet
= THAI_CHARSET
;
1238 else if (EQ (val
, Qsymbol
))
1239 logfont
->lfCharSet
= SYMBOL_CHARSET
;
1241 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
1243 logfont
->lfQuality
= w32_antialias_type (val
);
1250 list_all_matching_fonts (match_data
)
1251 struct font_callback_data
*match_data
;
1254 Lisp_Object families
= w32font_list_family (match_data
->frame
);
1255 struct frame
*f
= XFRAME (match_data
->frame
);
1257 dc
= get_frame_dc (f
);
1259 while (!NILP (families
))
1261 /* TODO: Use the Unicode versions of the W32 APIs, so we can
1262 handle non-ASCII font names. */
1264 Lisp_Object family
= CAR (families
);
1265 families
= CDR (families
);
1268 else if (STRINGP (family
))
1269 name
= SDATA (family
);
1271 name
= SDATA (SYMBOL_NAME (family
));
1273 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
1274 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
1276 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
1277 (FONTENUMPROC
) add_font_entity_to_list
,
1278 (LPARAM
) match_data
, 0);
1281 release_frame_dc (f
, dc
);
1285 lispy_antialias_type (type
)
1292 case NONANTIALIASED_QUALITY
:
1295 case ANTIALIASED_QUALITY
:
1298 case CLEARTYPE_QUALITY
:
1301 case CLEARTYPE_NATURAL_QUALITY
:
1311 /* Convert antialiasing symbols to lfQuality */
1313 w32_antialias_type (type
)
1316 if (EQ (type
, Qnone
))
1317 return NONANTIALIASED_QUALITY
;
1318 else if (EQ (type
, Qstandard
))
1319 return ANTIALIASED_QUALITY
;
1320 else if (EQ (type
, Qsubpixel
))
1321 return CLEARTYPE_QUALITY
;
1322 else if (EQ (type
, Qnatural
))
1323 return CLEARTYPE_NATURAL_QUALITY
;
1325 return DEFAULT_QUALITY
;
1328 /* Return a list of all the scripts that the font supports. */
1330 font_supported_scripts (FONTSIGNATURE
* sig
)
1332 DWORD
* subranges
= sig
->fsUsb
;
1333 Lisp_Object supported
= Qnil
;
1335 /* Match a single subrange. SYM is set if bit N is set in subranges. */
1336 #define SUBRANGE(n,sym) \
1337 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
1338 supported = Fcons ((sym), supported)
1340 /* Match multiple subranges. SYM is set if any MASK bit is set in
1341 subranges[0 - 3]. */
1342 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
1343 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
1344 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
1345 supported = Fcons ((sym), supported)
1347 SUBRANGE (0, Qlatin
); /* There are many others... */
1349 SUBRANGE (7, Qgreek
);
1350 SUBRANGE (8, Qcoptic
);
1351 SUBRANGE (9, Qcyrillic
);
1352 SUBRANGE (10, Qarmenian
);
1353 SUBRANGE (11, Qhebrew
);
1354 SUBRANGE (13, Qarabic
);
1355 SUBRANGE (14, Qnko
);
1356 SUBRANGE (15, Qdevanagari
);
1357 SUBRANGE (16, Qbengali
);
1358 SUBRANGE (17, Qgurmukhi
);
1359 SUBRANGE (18, Qgujarati
);
1360 SUBRANGE (19, Qoriya
);
1361 SUBRANGE (20, Qtamil
);
1362 SUBRANGE (21, Qtelugu
);
1363 SUBRANGE (22, Qkannada
);
1364 SUBRANGE (23, Qmalayalam
);
1365 SUBRANGE (24, Qthai
);
1366 SUBRANGE (25, Qlao
);
1367 SUBRANGE (26, Qgeorgian
);
1369 SUBRANGE (48, Qcjk_misc
);
1370 SUBRANGE (51, Qbopomofo
);
1371 SUBRANGE (54, Qkanbun
); /* Is this right? */
1372 SUBRANGE (56, Qhangul
);
1374 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
1375 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in */
1377 SUBRANGE (70, Qtibetan
);
1378 SUBRANGE (71, Qsyriac
);
1379 SUBRANGE (72, Qthaana
);
1380 SUBRANGE (73, Qsinhala
);
1381 SUBRANGE (74, Qmyanmar
);
1382 SUBRANGE (75, Qethiopic
);
1383 SUBRANGE (76, Qcherokee
);
1384 SUBRANGE (77, Qcanadian_aboriginal
);
1385 SUBRANGE (78, Qogham
);
1386 SUBRANGE (79, Qrunic
);
1387 SUBRANGE (80, Qkhmer
);
1388 SUBRANGE (81, Qmongolian
);
1389 SUBRANGE (82, Qbraille
);
1392 SUBRANGE (88, Qbyzantine_musical_symbol
);
1393 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
1395 SUBRANGE (89, Qmathematical
);
1397 /* Match either katakana or hiragana for kana. */
1398 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
1400 /* There isn't really a main symbol range, so include symbol if any
1401 relevant range is set. */
1402 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
1411 struct font_driver w32font_driver
=
1417 w32font_list_family
,
1418 NULL
, /* free_entity */
1421 NULL
, /* prepare_face */
1422 NULL
, /* done_face */
1424 w32font_encode_char
,
1425 w32font_text_extents
,
1427 NULL
, /* get_bitmap */
1428 NULL
, /* free_bitmap */
1429 NULL
, /* get_outline */
1430 NULL
, /* free_outline */
1431 NULL
, /* anchor_point */
1432 NULL
, /* otf_capability */
1433 NULL
, /* otf_drive */
1434 NULL
, /* start_for_frame */
1435 NULL
, /* end_for_frame */
1440 /* Initialize state that does not change between invocations. This is only
1441 called when Emacs is dumped. */
1445 DEFSYM (Qgdi
, "gdi");
1447 /* Generic font families. */
1448 DEFSYM (Qmonospace
, "monospace");
1449 DEFSYM (Qserif
, "serif");
1450 DEFSYM (Qsans_serif
, "sans-serif");
1451 DEFSYM (Qscript
, "script");
1452 DEFSYM (Qdecorative
, "decorative");
1454 DEFSYM (Qsans__serif
, "sans_serif");
1455 DEFSYM (Qsans
, "sans");
1456 DEFSYM (Qmono
, "mono");
1458 /* Fake foundries. */
1459 DEFSYM (Qraster
, "raster");
1460 DEFSYM (Qoutline
, "outline");
1461 DEFSYM (Qunknown
, "unknown");
1464 DEFSYM (Qstandard
, "standard");
1465 DEFSYM (Qsubpixel
, "subpixel");
1466 DEFSYM (Qnatural
, "natural");
1469 DEFSYM (Qlatin
, "latin");
1470 DEFSYM (Qgreek
, "greek");
1471 DEFSYM (Qcoptic
, "coptic");
1472 DEFSYM (Qcyrillic
, "cyrillic");
1473 DEFSYM (Qarmenian
, "armenian");
1474 DEFSYM (Qhebrew
, "hebrew");
1475 DEFSYM (Qarabic
, "arabic");
1476 DEFSYM (Qsyriac
, "syriac");
1477 DEFSYM (Qnko
, "nko");
1478 DEFSYM (Qthaana
, "thaana");
1479 DEFSYM (Qdevanagari
, "devanagari");
1480 DEFSYM (Qbengali
, "bengali");
1481 DEFSYM (Qgurmukhi
, "gurmukhi");
1482 DEFSYM (Qgujarati
, "gujarati");
1483 DEFSYM (Qoriya
, "oriya");
1484 DEFSYM (Qtamil
, "tamil");
1485 DEFSYM (Qtelugu
, "telugu");
1486 DEFSYM (Qkannada
, "kannada");
1487 DEFSYM (Qmalayalam
, "malayalam");
1488 DEFSYM (Qsinhala
, "sinhala");
1489 DEFSYM (Qthai
, "thai");
1490 DEFSYM (Qlao
, "lao");
1491 DEFSYM (Qtibetan
, "tibetan");
1492 DEFSYM (Qmyanmar
, "myanmar");
1493 DEFSYM (Qgeorgian
, "georgian");
1494 DEFSYM (Qhangul
, "hangul");
1495 DEFSYM (Qethiopic
, "ethiopic");
1496 DEFSYM (Qcherokee
, "cherokee");
1497 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
1498 DEFSYM (Qogham
, "ogham");
1499 DEFSYM (Qrunic
, "runic");
1500 DEFSYM (Qkhmer
, "khmer");
1501 DEFSYM (Qmongolian
, "mongolian");
1502 DEFSYM (Qsymbol
, "symbol");
1503 DEFSYM (Qbraille
, "braille");
1504 DEFSYM (Qhan
, "han");
1505 DEFSYM (Qideographic_description
, "ideographic-description");
1506 DEFSYM (Qcjk_misc
, "cjk-misc");
1507 DEFSYM (Qkana
, "kana");
1508 DEFSYM (Qbopomofo
, "bopomofo");
1509 DEFSYM (Qkanbun
, "kanbun");
1511 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
1512 DEFSYM (Qmusical_symbol
, "musical-symbol");
1513 DEFSYM (Qmathematical
, "mathematical");
1515 w32font_driver
.type
= Qgdi
;
1516 register_font_driver (&w32font_driver
, NULL
);
1519 /* arch-tag: 65b8a3cd-46aa-4c0d-a1f3-99e75b9c07ee
1520 (do not change this comment) */