1 /* Font backend for the Microsoft W32 API.
2 Copyright (C) 2007, 2008 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 3, 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 static Lisp_Object Qmonospace
, Qsansserif
, Qmono
, Qsans
, Qsans_serif
;
49 static Lisp_Object Qserif
, Qscript
, Qdecorative
;
50 static Lisp_Object 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 (f
)
141 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
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
);
230 if (font
->font
.full_name
&& font
->font
.full_name
!= font
->font
.name
)
231 xfree (font
->font
.full_name
);
234 xfree (font
->font
.name
);
239 /* w32 implementation of has_char for font backend.
241 If FONT_ENTITY has a glyph for character C (Unicode code point),
242 return 1. If not, return 0. If a font must be opened to check
245 w32font_has_char (entity
, c
)
249 Lisp_Object supported_scripts
, extra
, script
;
252 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
256 supported_scripts
= assq_no_quit (QCscript
, extra
);
257 if (!CONSP (supported_scripts
))
260 supported_scripts
= XCDR (supported_scripts
);
262 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
264 return (memq_no_quit (script
, supported_scripts
)) ? 1 : 0;
267 /* w32 implementation of encode_char for font backend.
268 Return a glyph code of FONT for characer C (Unicode code point).
269 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
271 w32font_encode_char (font
, c
)
275 /* Avoid unneccesary conversion - all the Win32 APIs will take a unicode
280 /* w32 implementation of text_extents for font backend.
281 Perform the size computation of glyphs of FONT and fillin members
282 of METRICS. The glyphs are specified by their glyph codes in
283 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
284 case just return the overall width. */
286 w32font_text_extents (font
, code
, nglyphs
, metrics
)
290 struct font_metrics
*metrics
;
293 HFONT old_font
= NULL
;
297 WORD
*wcode
= alloca(nglyphs
* sizeof (WORD
));
300 /* TODO: Frames can come and go, and their fonts outlive them. So we
301 can't cache the frame in the font structure. Use selected_frame
302 until the API is updated to pass in a frame. */
303 f
= XFRAME (selected_frame
);
310 /* Set transform to the identity matrix. */
311 bzero (&transform
, sizeof (transform
));
312 transform
.eM11
.value
= 1;
313 transform
.eM22
.value
= 1;
316 metrics
->descent
= 0;
317 metrics
->lbearing
= 0;
319 for (i
= 0; i
< nglyphs
; i
++)
321 if (*(code
+ i
) < 128 && *(code
+ i
) > 32)
323 /* Use cached metrics for ASCII. */
324 struct font_metrics
*char_metric
325 = &((struct w32font_info
*)font
)->ascii_metrics
[*(code
+i
)-32];
327 /* If we couldn't get metrics when caching, use fallback. */
328 if (char_metric
->width
== 0)
331 metrics
->lbearing
= max (metrics
->lbearing
,
332 char_metric
->lbearing
- metrics
->width
);
333 metrics
->rbearing
= max (metrics
->rbearing
,
334 metrics
->width
+ char_metric
->rbearing
);
335 metrics
->width
+= char_metric
->width
;
336 metrics
->ascent
= max (metrics
->ascent
, char_metric
->ascent
);
337 metrics
->descent
= max (metrics
->descent
, char_metric
->descent
);
343 dc
= get_frame_dc (f
);
344 old_font
= SelectObject (dc
, ((W32FontStruct
*)
345 (font
->font
.font
))->hfont
);
347 if (GetGlyphOutlineW (dc
, *(code
+ i
), GGO_METRICS
, &gm
, 0,
348 NULL
, &transform
) != GDI_ERROR
)
350 int new_val
= metrics
->width
+ gm
.gmBlackBoxX
351 + gm
.gmptGlyphOrigin
.x
;
352 metrics
->rbearing
= max (metrics
->rbearing
, new_val
);
353 new_val
= -gm
.gmptGlyphOrigin
.x
- metrics
->width
;
354 metrics
->lbearing
= max (metrics
->lbearing
, new_val
);
355 metrics
->width
+= gm
.gmCellIncX
;
356 new_val
= -gm
.gmptGlyphOrigin
.y
;
357 metrics
->ascent
= max (metrics
->ascent
, new_val
);
358 new_val
= gm
.gmBlackBoxY
+ gm
.gmptGlyphOrigin
.y
;
359 metrics
->descent
= max (metrics
->descent
, new_val
);
363 /* Rely on an estimate based on the overall font metrics. */
369 /* If we got through everything, return. */
374 /* Restore state and release DC. */
375 SelectObject (dc
, old_font
);
376 release_frame_dc (f
, dc
);
379 return metrics
->width
;
383 for (i
= 0; i
< nglyphs
; i
++)
385 if (code
[i
] < 0x10000)
389 /* TODO: Convert to surrogate, reallocating array if needed */
396 dc
= get_frame_dc (f
);
397 old_font
= SelectObject (dc
, ((W32FontStruct
*)
398 (font
->font
.font
))->hfont
);
401 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
403 total_width
= size
.cx
;
409 rect
.top
= 0; rect
.bottom
= font
->font
.height
; rect
.left
= 0; rect
.right
= 1;
410 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
411 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
412 total_width
= rect
.right
;
417 metrics
->width
= total_width
;
418 metrics
->ascent
= font
->ascent
;
419 metrics
->descent
= font
->descent
;
420 metrics
->lbearing
= 0;
421 metrics
->rbearing
= total_width
422 + ((struct w32font_info
*) font
)->metrics
.tmOverhang
;
425 /* Restore state and release DC. */
426 SelectObject (dc
, old_font
);
427 release_frame_dc (f
, dc
);
432 /* w32 implementation of draw for font backend.
434 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
435 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
436 is nonzero, fill the background in advance. It is assured that
437 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
439 TODO: Currently this assumes that the colors and fonts are already
440 set in the DC. This seems to be true now, but maybe only due to
441 the old font code setting it up. It may be safer to resolve faces
442 and fonts in here and set them explicitly
446 w32font_draw (s
, from
, to
, x
, y
, with_background
)
447 struct glyph_string
*s
;
448 int from
, to
, x
, y
, with_background
;
453 /* Save clip region for later restoration. */
454 GetClipRgn(s
->hdc
, orig_clip
);
456 if (s
->num_clips
> 0)
458 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
460 if (s
->num_clips
> 1)
462 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
464 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
465 DeleteObject (clip2
);
468 SelectClipRgn (s
->hdc
, new_clip
);
469 DeleteObject (new_clip
);
472 /* Using OPAQUE background mode can clear more background than expected
473 when Cleartype is used. Draw the background manually to avoid this. */
474 SetBkMode (s
->hdc
, TRANSPARENT
);
479 struct font
*font
= (struct font
*) s
->face
->font_info
;
481 brush
= CreateSolidBrush (s
->gc
->background
);
483 rect
.top
= y
- font
->ascent
;
484 rect
.right
= x
+ s
->width
;
485 rect
.bottom
= y
+ font
->descent
;
486 FillRect (s
->hdc
, &rect
, brush
);
487 DeleteObject (brush
);
492 int len
= to
- from
, i
;
494 for (i
= 0; i
< len
; i
++)
495 ExtTextOutW (s
->hdc
, x
+ i
, y
, options
, NULL
,
496 s
->char2b
+ from
+ i
, 1, NULL
);
499 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, to
- from
, NULL
);
501 /* Restore clip region. */
502 if (s
->num_clips
> 0)
504 SelectClipRgn (s
->hdc
, orig_clip
);
508 /* w32 implementation of free_entity for font backend.
509 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
510 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
512 w32font_free_entity (Lisp_Object entity);
515 /* w32 implementation of prepare_face for font backend.
516 Optional (if FACE->extra is not used).
517 Prepare FACE for displaying characters by FONT on frame F by
518 storing some data in FACE->extra. If successful, return 0.
519 Otherwise, return -1.
521 w32font_prepare_face (FRAME_PTR f, struct face *face);
523 /* w32 implementation of done_face for font backend.
525 Done FACE for displaying characters by FACE->font on frame F.
527 w32font_done_face (FRAME_PTR f, struct face *face); */
529 /* w32 implementation of get_bitmap for font backend.
531 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
532 intended that this method is called from the other font-driver
535 w32font_get_bitmap (struct font *font, unsigned code,
536 struct font_bitmap *bitmap, int bits_per_pixel);
538 /* w32 implementation of free_bitmap for font backend.
540 Free bitmap data in BITMAP.
542 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
544 /* w32 implementation of get_outline for font backend.
546 Return an outline data for glyph-code CODE of FONT. The format
547 of the outline data depends on the font-driver.
549 w32font_get_outline (struct font *font, unsigned code);
551 /* w32 implementation of free_outline for font backend.
553 Free OUTLINE (that is obtained by the above method).
555 w32font_free_outline (struct font *font, void *outline);
557 /* w32 implementation of anchor_point for font backend.
559 Get coordinates of the INDEXth anchor point of the glyph whose
560 code is CODE. Store the coordinates in *X and *Y. Return 0 if
561 the operations was successfull. Otherwise return -1.
563 w32font_anchor_point (struct font *font, unsigned code,
564 int index, int *x, int *y);
566 /* w32 implementation of otf_capability for font backend.
568 Return a list describing which scripts/languages FONT
569 supports by which GSUB/GPOS features of OpenType tables.
571 w32font_otf_capability (struct font *font);
573 /* w32 implementation of otf_drive for font backend.
575 Apply FONT's OTF-FEATURES to the glyph string.
577 FEATURES specifies which OTF features to apply in this format:
578 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
579 See the documentation of `font-drive-otf' for the detail.
581 This method applies the specified features to the codes in the
582 elements of GSTRING-IN (between FROMth and TOth). The output
583 codes are stored in GSTRING-OUT at the IDXth element and the
586 Return the number of output codes. If none of the features are
587 applicable to the input data, return 0. If GSTRING-OUT is too
590 w32font_otf_drive (struct font *font, Lisp_Object features,
591 Lisp_Object gstring_in, int from, int to,
592 Lisp_Object gstring_out, int idx,
593 int alternate_subst);
596 /* Internal implementation of w32font_list.
597 Additional parameter opentype_only restricts the returned fonts to
598 opentype fonts, which can be used with the Uniscribe backend. */
600 w32font_list_internal (frame
, font_spec
, opentype_only
)
601 Lisp_Object frame
, font_spec
;
604 struct font_callback_data match_data
;
606 FRAME_PTR f
= XFRAME (frame
);
608 match_data
.orig_font_spec
= font_spec
;
609 match_data
.list
= Qnil
;
610 match_data
.frame
= frame
;
612 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
613 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
615 match_data
.opentype_only
= opentype_only
;
617 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
619 if (match_data
.pattern
.lfFaceName
[0] == '\0')
621 /* EnumFontFamiliesEx does not take other fields into account if
622 font name is blank, so need to use two passes. */
623 list_all_matching_fonts (&match_data
);
627 dc
= get_frame_dc (f
);
629 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
630 (FONTENUMPROC
) add_font_entity_to_list
,
631 (LPARAM
) &match_data
, 0);
632 release_frame_dc (f
, dc
);
635 return NILP (match_data
.list
) ? null_vector
: Fvconcat (1, &match_data
.list
);
638 /* Internal implementation of w32font_match.
639 Additional parameter opentype_only restricts the returned fonts to
640 opentype fonts, which can be used with the Uniscribe backend. */
642 w32font_match_internal (frame
, font_spec
, opentype_only
)
643 Lisp_Object frame
, font_spec
;
646 struct font_callback_data match_data
;
648 FRAME_PTR f
= XFRAME (frame
);
650 match_data
.orig_font_spec
= font_spec
;
651 match_data
.frame
= frame
;
652 match_data
.list
= Qnil
;
654 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
655 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
657 match_data
.opentype_only
= opentype_only
;
659 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
661 dc
= get_frame_dc (f
);
663 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
664 (FONTENUMPROC
) add_one_font_entity_to_list
,
665 (LPARAM
) &match_data
, 0);
666 release_frame_dc (f
, dc
);
668 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
672 w32font_open_internal (f
, font_entity
, pixel_size
, w32_font
)
674 Lisp_Object font_entity
;
676 struct w32font_info
*w32_font
;
681 HFONT hfont
, old_font
;
682 Lisp_Object val
, extra
;
683 /* For backwards compatibility. */
684 W32FontStruct
*compat_w32_font
;
686 struct font
* font
= (struct font
*) w32_font
;
690 bzero (&logfont
, sizeof (logfont
));
691 fill_in_logfont (f
, &logfont
, font_entity
);
693 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
697 logfont
.lfHeight
= -size
;
698 hfont
= CreateFontIndirect (&logfont
);
703 /* Get the metrics for this font. */
704 dc
= get_frame_dc (f
);
705 old_font
= SelectObject (dc
, hfont
);
707 GetTextMetrics (dc
, &w32_font
->metrics
);
709 /* Cache ASCII metrics. */
715 bzero (&transform
, sizeof (transform
));
716 transform
.eM11
.value
= 1;
717 transform
.eM22
.value
= 1;
719 for (i
= 0; i
< 96; i
++)
721 struct font_metrics
* char_metric
= &w32_font
->ascii_metrics
[i
];
723 if (GetGlyphOutlineW (dc
, i
+ 32, GGO_METRICS
, &gm
, 0,
724 NULL
, &transform
) != GDI_ERROR
)
726 char_metric
->lbearing
= -gm
.gmptGlyphOrigin
.x
;
727 char_metric
->rbearing
= gm
.gmBlackBoxX
+ gm
.gmptGlyphOrigin
.x
;
728 char_metric
->width
= gm
.gmCellIncX
;
729 char_metric
->ascent
= -gm
.gmptGlyphOrigin
.y
;
730 char_metric
->descent
= gm
.gmBlackBoxY
+ gm
.gmptGlyphOrigin
.y
;
733 char_metric
->width
= 0;
736 SelectObject (dc
, old_font
);
737 release_frame_dc (f
, dc
);
738 /* W32FontStruct - we should get rid of this, and use the w32font_info
739 struct for any W32 specific fields. font->font.font can then be hfont. */
740 font
->font
.font
= xmalloc (sizeof (W32FontStruct
));
741 compat_w32_font
= (W32FontStruct
*) font
->font
.font
;
742 bzero (compat_w32_font
, sizeof (W32FontStruct
));
743 compat_w32_font
->font_type
= UNICODE_FONT
;
744 /* Duplicate the text metrics. */
745 bcopy (&w32_font
->metrics
, &compat_w32_font
->tm
, sizeof (TEXTMETRIC
));
746 compat_w32_font
->hfont
= hfont
;
748 len
= strlen (logfont
.lfFaceName
);
749 font
->font
.name
= (char *) xmalloc (len
+ 1);
750 bcopy (logfont
.lfFaceName
, font
->font
.name
, len
);
751 font
->font
.name
[len
] = '\0';
756 /* We don't know how much space we need for the full name, so start with
757 96 bytes and go up in steps of 32. */
759 name
= xmalloc (len
);
760 while (name
&& font_unparse_fcname (font_entity
, pixel_size
, name
, len
) < 0)
762 char *new = xrealloc (name
, len
+= 32);
769 font
->font
.full_name
= name
;
771 font
->font
.full_name
= font
->font
.name
;
773 font
->font
.charset
= 0;
774 font
->font
.codepage
= 0;
775 font
->font
.size
= w32_font
->metrics
.tmMaxCharWidth
;
776 font
->font
.height
= w32_font
->metrics
.tmHeight
777 + w32_font
->metrics
.tmExternalLeading
;
778 font
->font
.space_width
= font
->font
.average_width
779 = w32_font
->metrics
.tmAveCharWidth
;
781 font
->font
.vertical_centering
= 0;
782 font
->font
.encoding_type
= 0;
783 font
->font
.baseline_offset
= 0;
784 font
->font
.relative_compose
= 0;
785 font
->font
.default_ascent
= w32_font
->metrics
.tmAscent
;
786 font
->font
.font_encoder
= NULL
;
787 font
->entity
= font_entity
;
788 font
->pixel_size
= size
;
789 font
->driver
= &w32font_driver
;
791 font
->file_name
= NULL
;
792 font
->encoding_charset
= -1;
793 font
->repertory_charset
= -1;
794 /* TODO: do we really want the minimum width here, which could be negative? */
795 font
->min_width
= font
->font
.space_width
;
796 font
->ascent
= w32_font
->metrics
.tmAscent
;
797 font
->descent
= w32_font
->metrics
.tmDescent
;
798 font
->scalable
= w32_font
->metrics
.tmPitchAndFamily
& TMPF_VECTOR
;
800 /* Set global flag fonts_changed_p to non-zero if the font loaded
801 has a character with a smaller width than any other character
802 before, or if the font loaded has a smaller height than any other
803 font loaded before. If this happens, it will make a glyph matrix
804 reallocation necessary. */
806 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
809 if (dpyinfo
->n_fonts
== 1)
811 dpyinfo
->smallest_font_height
= font
->font
.height
;
812 dpyinfo
->smallest_char_width
= font
->min_width
;
816 if (dpyinfo
->smallest_font_height
> font
->font
.height
)
818 dpyinfo
->smallest_font_height
= font
->font
.height
;
819 fonts_changed_p
|= 1;
821 if (dpyinfo
->smallest_char_width
> font
->min_width
)
823 dpyinfo
->smallest_char_width
= font
->min_width
;
824 fonts_changed_p
|= 1;
832 /* Callback function for EnumFontFamiliesEx.
833 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
835 add_font_name_to_list (logical_font
, physical_font
, font_type
, list_object
)
836 ENUMLOGFONTEX
*logical_font
;
837 NEWTEXTMETRICEX
*physical_font
;
841 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
844 /* Skip vertical fonts (intended only for printing) */
845 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
848 family
= intern_downcase (logical_font
->elfLogFont
.lfFaceName
,
849 strlen (logical_font
->elfLogFont
.lfFaceName
));
850 if (! memq_no_quit (family
, *list
))
851 *list
= Fcons (family
, *list
);
856 /* Convert an enumerated Windows font to an Emacs font entity. */
858 w32_enumfont_pattern_entity (frame
, logical_font
, physical_font
,
859 font_type
, requested_font
)
861 ENUMLOGFONTEX
*logical_font
;
862 NEWTEXTMETRICEX
*physical_font
;
864 LOGFONT
*requested_font
;
866 Lisp_Object entity
, tem
;
867 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
870 entity
= Fmake_vector (make_number (FONT_ENTITY_MAX
), Qnil
);
872 ASET (entity
, FONT_TYPE_INDEX
, Qgdi
);
873 ASET (entity
, FONT_FRAME_INDEX
, frame
);
874 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
));
875 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
877 /* Foundry is difficult to get in readable form on Windows.
878 But Emacs crashes if it is not set, so set it to something more
879 generic. Thes values make xflds compatible with Emacs 22. */
880 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
882 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
887 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
889 /* Save the generic family in the extra info, as it is likely to be
890 useful to users looking for a close match. */
891 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
892 if (generic_type
== FF_DECORATIVE
)
894 else if (generic_type
== FF_MODERN
)
896 else if (generic_type
== FF_ROMAN
)
898 else if (generic_type
== FF_SCRIPT
)
900 else if (generic_type
== FF_SWISS
)
905 ASET (entity
, FONT_ADSTYLE_INDEX
, tem
);
907 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
908 font_put_extra (entity
, QCspacing
, make_number (FONT_SPACING_PROPORTIONAL
));
910 font_put_extra (entity
, QCspacing
, make_number (FONT_SPACING_MONO
));
912 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
914 font_put_extra (entity
, QCantialias
,
915 lispy_antialias_type (requested_font
->lfQuality
));
917 ASET (entity
, FONT_FAMILY_INDEX
,
918 intern_downcase (lf
->lfFaceName
, strlen (lf
->lfFaceName
)));
920 ASET (entity
, FONT_WEIGHT_INDEX
, make_number (lf
->lfWeight
));
921 ASET (entity
, FONT_SLANT_INDEX
, make_number (lf
->lfItalic
? 200 : 100));
922 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
924 ASET (entity
, FONT_WIDTH_INDEX
, make_number (100));
926 if (font_type
& RASTER_FONTTYPE
)
927 ASET (entity
, FONT_SIZE_INDEX
, make_number (physical_font
->ntmTm
.tmHeight
));
929 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
931 /* Cache unicode codepoints covered by this font, as there is no other way
932 of getting this information easily. */
933 if (font_type
& TRUETYPE_FONTTYPE
)
935 font_put_extra (entity
, QCscript
,
936 font_supported_scripts (&physical_font
->ntmFontSig
));
943 /* Convert generic families to the family portion of lfPitchAndFamily. */
945 w32_generic_family (Lisp_Object name
)
947 /* Generic families. */
948 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
950 else if (EQ (name
, Qsans
) || EQ (name
, Qsans_serif
) || EQ (name
, Qsansserif
))
952 else if (EQ (name
, Qserif
))
954 else if (EQ (name
, Qdecorative
))
955 return FF_DECORATIVE
;
956 else if (EQ (name
, Qscript
))
963 logfonts_match (font
, pattern
)
964 LOGFONT
*font
, *pattern
;
966 /* Only check height for raster fonts. */
967 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
968 && font
->lfHeight
!= pattern
->lfHeight
)
971 /* Have some flexibility with weights. */
972 if (pattern
->lfWeight
973 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
974 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
977 /* Charset and face should be OK. Italic has to be checked
978 against the original spec, in case we don't have any preference. */
983 font_matches_spec (type
, font
, spec
)
985 NEWTEXTMETRICEX
*font
;
988 Lisp_Object extra
, val
;
990 /* Check italic. Can't check logfonts, since it is a boolean field,
991 so there is no difference between "non-italic" and "don't care". */
992 val
= AREF (spec
, FONT_SLANT_INDEX
);
995 int slant
= XINT (val
);
996 if ((slant
> 150 && !font
->ntmTm
.tmItalic
)
997 || (slant
<= 150 && font
->ntmTm
.tmItalic
))
1001 /* Check adstyle against generic family. */
1002 val
= AREF (spec
, FONT_ADSTYLE_INDEX
);
1005 BYTE family
= w32_generic_family (val
);
1006 if (family
!= FF_DONTCARE
1007 && family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
1011 /* Check extra parameters. */
1012 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
1013 CONSP (extra
); extra
= XCDR (extra
))
1015 Lisp_Object extra_entry
;
1016 extra_entry
= XCAR (extra
);
1017 if (CONSP (extra_entry
))
1019 Lisp_Object key
= XCAR (extra_entry
);
1020 val
= XCDR (extra_entry
);
1021 if (EQ (key
, QCspacing
))
1026 int spacing
= XINT (val
);
1027 proportional
= (spacing
< FONT_SPACING_MONO
);
1029 else if (EQ (val
, Qp
))
1031 else if (EQ (val
, Qc
) || EQ (val
, Qm
))
1034 return 0; /* Bad font spec. */
1036 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
1037 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
1040 else if (EQ (key
, QCscript
) && SYMBOLP (val
))
1042 /* Only truetype fonts will have information about what
1043 scripts they support. This probably means the user
1044 will have to force Emacs to use raster, postscript
1045 or atm fonts for non-ASCII text. */
1046 if (type
& TRUETYPE_FONTTYPE
)
1049 = font_supported_scripts (&font
->ntmFontSig
);
1050 if (! memq_no_quit (val
, support
))
1055 /* Return specific matches, but play it safe. Fonts
1056 that cover more than their charset would suggest
1057 are likely to be truetype or opentype fonts,
1059 if (EQ (val
, Qlatin
))
1061 /* Although every charset but symbol, thai and
1062 arabic contains the basic ASCII set of latin
1063 characters, Emacs expects much more. */
1064 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
1067 else if (EQ (val
, Qsymbol
))
1069 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
1072 else if (EQ (val
, Qcyrillic
))
1074 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
1077 else if (EQ (val
, Qgreek
))
1079 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
1082 else if (EQ (val
, Qarabic
))
1084 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
1087 else if (EQ (val
, Qhebrew
))
1089 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
1092 else if (EQ (val
, Qthai
))
1094 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
1097 else if (EQ (val
, Qkana
))
1099 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1102 else if (EQ (val
, Qbopomofo
))
1104 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1107 else if (EQ (val
, Qhangul
))
1109 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1110 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1113 else if (EQ (val
, Qhan
))
1115 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
1116 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1117 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1118 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
1119 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1123 /* Other scripts unlikely to be handled. */
1132 /* Callback function for EnumFontFamiliesEx.
1133 * Checks if a font matches everything we are trying to check agaist,
1134 * and if so, adds it to a list. Both the data we are checking against
1135 * and the list to which the fonts are added are passed in via the
1136 * lparam argument, in the form of a font_callback_data struct. */
1138 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1139 ENUMLOGFONTEX
*logical_font
;
1140 NEWTEXTMETRICEX
*physical_font
;
1144 struct font_callback_data
*match_data
1145 = (struct font_callback_data
*) lParam
;
1147 if ((!match_data
->opentype_only
1148 || (physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
))
1149 && logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1150 && font_matches_spec (font_type
, physical_font
,
1151 match_data
->orig_font_spec
)
1152 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1153 We limit this to raster fonts, because the test can catch some
1154 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1155 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1156 therefore get through this test. Since full names can be prefixed
1157 by a foundry, we accept raster fonts if the font name is found
1158 anywhere within the full name. */
1159 && (logical_font
->elfLogFont
.lfOutPrecision
!= OUT_STRING_PRECIS
1160 || strstr (logical_font
->elfFullName
,
1161 logical_font
->elfLogFont
.lfFaceName
)))
1164 = w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1165 physical_font
, font_type
,
1166 &match_data
->pattern
);
1168 match_data
->list
= Fcons (entity
, match_data
->list
);
1173 /* Callback function for EnumFontFamiliesEx.
1174 * Terminates the search once we have a match. */
1176 add_one_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1177 ENUMLOGFONTEX
*logical_font
;
1178 NEWTEXTMETRICEX
*physical_font
;
1182 struct font_callback_data
*match_data
1183 = (struct font_callback_data
*) lParam
;
1184 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1186 /* If we have a font in the list, terminate the search. */
1187 return !NILP (match_data
->list
);
1190 /* Convert a Lisp font registry (symbol) to a windows charset. */
1192 registry_to_w32_charset (charset
)
1193 Lisp_Object charset
;
1195 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1196 || EQ (charset
, Qunicode_sip
))
1197 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1198 else if (EQ (charset
, Qiso8859_1
))
1199 return ANSI_CHARSET
;
1200 else if (SYMBOLP (charset
))
1201 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1202 else if (STRINGP (charset
))
1203 return x_to_w32_charset (SDATA (charset
));
1205 return DEFAULT_CHARSET
;
1209 w32_registry (w32_charset
)
1212 if (w32_charset
== ANSI_CHARSET
)
1216 char * charset
= w32_to_x_charset (w32_charset
, NULL
);
1217 return intern_downcase (charset
, strlen(charset
));
1221 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1223 fill_in_logfont (f
, logfont
, font_spec
)
1226 Lisp_Object font_spec
;
1228 Lisp_Object tmp
, extra
;
1229 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1231 extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
1232 /* Allow user to override dpi settings. */
1235 tmp
= assq_no_quit (QCdpi
, extra
);
1236 if (CONSP (tmp
) && INTEGERP (XCDR (tmp
)))
1238 dpi
= XINT (XCDR (tmp
));
1240 else if (CONSP (tmp
) && FLOATP (XCDR (tmp
)))
1242 dpi
= (int) (XFLOAT_DATA (XCDR (tmp
)) + 0.5);
1247 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1249 logfont
->lfHeight
= -1 * XINT (tmp
);
1250 else if (FLOATP (tmp
))
1251 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1258 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1260 logfont
->lfWeight
= XINT (tmp
);
1263 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
1266 int slant
= XINT (tmp
);
1267 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
1275 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1277 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
1281 /* Clip Precision */
1284 logfont
->lfQuality
= DEFAULT_QUALITY
;
1286 /* Generic Family and Face Name */
1287 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
1289 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1292 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
1293 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
1294 ; /* Font name was generic, don't fill in font name. */
1295 /* Font families are interned, but allow for strings also in case of
1297 else if (SYMBOLP (tmp
))
1298 strncpy (logfont
->lfFaceName
, SDATA (SYMBOL_NAME (tmp
)), LF_FACESIZE
);
1299 else if (STRINGP (tmp
))
1300 strncpy (logfont
->lfFaceName
, SDATA (tmp
), LF_FACESIZE
);
1303 tmp
= AREF (font_spec
, FONT_ADSTYLE_INDEX
);
1306 /* Override generic family. */
1307 BYTE family
= w32_generic_family (tmp
);
1308 if (family
!= FF_DONTCARE
)
1309 logfont
->lfPitchAndFamily
= family
| DEFAULT_PITCH
;
1312 /* Process EXTRA info. */
1313 for ( ; CONSP (extra
); extra
= XCDR (extra
))
1318 Lisp_Object key
, val
;
1319 key
= XCAR (tmp
), val
= XCDR (tmp
);
1320 if (EQ (key
, QCspacing
))
1322 /* Set pitch based on the spacing property. */
1325 int spacing
= XINT (val
);
1326 if (spacing
< FONT_SPACING_MONO
)
1327 logfont
->lfPitchAndFamily
1328 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1330 logfont
->lfPitchAndFamily
1331 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1333 else if (EQ (val
, Qp
))
1334 logfont
->lfPitchAndFamily
1335 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1336 else if (EQ (val
, Qc
) || EQ (val
, Qm
))
1337 logfont
->lfPitchAndFamily
1338 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1340 /* Only use QCscript if charset is not provided, or is unicode
1341 and a single script is specified. This is rather crude,
1342 and is only used to narrow down the fonts returned where
1343 there is a definite match. Some scripts, such as latin, han,
1344 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1346 else if (EQ (key
, QCscript
)
1347 && logfont
->lfCharSet
== DEFAULT_CHARSET
1350 if (EQ (val
, Qgreek
))
1351 logfont
->lfCharSet
= GREEK_CHARSET
;
1352 else if (EQ (val
, Qhangul
))
1353 logfont
->lfCharSet
= HANGUL_CHARSET
;
1354 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
1355 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
1356 else if (EQ (val
, Qbopomofo
))
1357 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
1358 /* GB 18030 supports tibetan, yi, mongolian,
1359 fonts that support it should show up if we ask for
1361 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
1362 || EQ (val
, Qmongolian
))
1363 logfont
->lfCharSet
= GB2312_CHARSET
;
1364 else if (EQ (val
, Qhebrew
))
1365 logfont
->lfCharSet
= HEBREW_CHARSET
;
1366 else if (EQ (val
, Qarabic
))
1367 logfont
->lfCharSet
= ARABIC_CHARSET
;
1368 else if (EQ (val
, Qthai
))
1369 logfont
->lfCharSet
= THAI_CHARSET
;
1370 else if (EQ (val
, Qsymbol
))
1371 logfont
->lfCharSet
= SYMBOL_CHARSET
;
1373 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
1375 logfont
->lfQuality
= w32_antialias_type (val
);
1382 list_all_matching_fonts (match_data
)
1383 struct font_callback_data
*match_data
;
1386 Lisp_Object families
= w32font_list_family (match_data
->frame
);
1387 struct frame
*f
= XFRAME (match_data
->frame
);
1389 dc
= get_frame_dc (f
);
1391 while (!NILP (families
))
1393 /* TODO: Use the Unicode versions of the W32 APIs, so we can
1394 handle non-ASCII font names. */
1396 Lisp_Object family
= CAR (families
);
1397 families
= CDR (families
);
1400 else if (STRINGP (family
))
1401 name
= SDATA (family
);
1403 name
= SDATA (SYMBOL_NAME (family
));
1405 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
1406 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
1408 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
1409 (FONTENUMPROC
) add_font_entity_to_list
,
1410 (LPARAM
) match_data
, 0);
1413 release_frame_dc (f
, dc
);
1417 lispy_antialias_type (type
)
1424 case NONANTIALIASED_QUALITY
:
1427 case ANTIALIASED_QUALITY
:
1430 case CLEARTYPE_QUALITY
:
1433 case CLEARTYPE_NATURAL_QUALITY
:
1443 /* Convert antialiasing symbols to lfQuality */
1445 w32_antialias_type (type
)
1448 if (EQ (type
, Qnone
))
1449 return NONANTIALIASED_QUALITY
;
1450 else if (EQ (type
, Qstandard
))
1451 return ANTIALIASED_QUALITY
;
1452 else if (EQ (type
, Qsubpixel
))
1453 return CLEARTYPE_QUALITY
;
1454 else if (EQ (type
, Qnatural
))
1455 return CLEARTYPE_NATURAL_QUALITY
;
1457 return DEFAULT_QUALITY
;
1460 /* Return a list of all the scripts that the font supports. */
1462 font_supported_scripts (FONTSIGNATURE
* sig
)
1464 DWORD
* subranges
= sig
->fsUsb
;
1465 Lisp_Object supported
= Qnil
;
1467 /* Match a single subrange. SYM is set if bit N is set in subranges. */
1468 #define SUBRANGE(n,sym) \
1469 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
1470 supported = Fcons ((sym), supported)
1472 /* Match multiple subranges. SYM is set if any MASK bit is set in
1473 subranges[0 - 3]. */
1474 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
1475 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
1476 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
1477 supported = Fcons ((sym), supported)
1479 SUBRANGE (0, Qlatin
); /* There are many others... */
1481 SUBRANGE (7, Qgreek
);
1482 SUBRANGE (8, Qcoptic
);
1483 SUBRANGE (9, Qcyrillic
);
1484 SUBRANGE (10, Qarmenian
);
1485 SUBRANGE (11, Qhebrew
);
1486 SUBRANGE (13, Qarabic
);
1487 SUBRANGE (14, Qnko
);
1488 SUBRANGE (15, Qdevanagari
);
1489 SUBRANGE (16, Qbengali
);
1490 SUBRANGE (17, Qgurmukhi
);
1491 SUBRANGE (18, Qgujarati
);
1492 SUBRANGE (19, Qoriya
);
1493 SUBRANGE (20, Qtamil
);
1494 SUBRANGE (21, Qtelugu
);
1495 SUBRANGE (22, Qkannada
);
1496 SUBRANGE (23, Qmalayalam
);
1497 SUBRANGE (24, Qthai
);
1498 SUBRANGE (25, Qlao
);
1499 SUBRANGE (26, Qgeorgian
);
1501 SUBRANGE (48, Qcjk_misc
);
1502 SUBRANGE (51, Qbopomofo
);
1503 SUBRANGE (54, Qkanbun
); /* Is this right? */
1504 SUBRANGE (56, Qhangul
);
1506 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
1507 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in */
1509 SUBRANGE (70, Qtibetan
);
1510 SUBRANGE (71, Qsyriac
);
1511 SUBRANGE (72, Qthaana
);
1512 SUBRANGE (73, Qsinhala
);
1513 SUBRANGE (74, Qmyanmar
);
1514 SUBRANGE (75, Qethiopic
);
1515 SUBRANGE (76, Qcherokee
);
1516 SUBRANGE (77, Qcanadian_aboriginal
);
1517 SUBRANGE (78, Qogham
);
1518 SUBRANGE (79, Qrunic
);
1519 SUBRANGE (80, Qkhmer
);
1520 SUBRANGE (81, Qmongolian
);
1521 SUBRANGE (82, Qbraille
);
1524 SUBRANGE (88, Qbyzantine_musical_symbol
);
1525 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
1527 SUBRANGE (89, Qmathematical
);
1529 /* Match either katakana or hiragana for kana. */
1530 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
1532 /* There isn't really a main symbol range, so include symbol if any
1533 relevant range is set. */
1534 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
1543 struct font_driver w32font_driver
=
1549 w32font_list_family
,
1550 NULL
, /* free_entity */
1553 NULL
, /* prepare_face */
1554 NULL
, /* done_face */
1556 w32font_encode_char
,
1557 w32font_text_extents
,
1559 NULL
, /* get_bitmap */
1560 NULL
, /* free_bitmap */
1561 NULL
, /* get_outline */
1562 NULL
, /* free_outline */
1563 NULL
, /* anchor_point */
1564 NULL
, /* otf_capability */
1565 NULL
, /* otf_drive */
1566 NULL
, /* start_for_frame */
1567 NULL
, /* end_for_frame */
1572 /* Initialize state that does not change between invocations. This is only
1573 called when Emacs is dumped. */
1577 DEFSYM (Qgdi
, "gdi");
1579 /* Generic font families. */
1580 DEFSYM (Qmonospace
, "monospace");
1581 DEFSYM (Qserif
, "serif");
1582 DEFSYM (Qsansserif
, "sansserif");
1583 DEFSYM (Qscript
, "script");
1584 DEFSYM (Qdecorative
, "decorative");
1586 DEFSYM (Qsans_serif
, "sans_serif");
1587 DEFSYM (Qsans
, "sans");
1588 DEFSYM (Qmono
, "mono");
1590 /* Fake foundries. */
1591 DEFSYM (Qraster
, "raster");
1592 DEFSYM (Qoutline
, "outline");
1593 DEFSYM (Qunknown
, "unknown");
1596 DEFSYM (Qstandard
, "standard");
1597 DEFSYM (Qsubpixel
, "subpixel");
1598 DEFSYM (Qnatural
, "natural");
1601 DEFSYM (Qlatin
, "latin");
1602 DEFSYM (Qgreek
, "greek");
1603 DEFSYM (Qcoptic
, "coptic");
1604 DEFSYM (Qcyrillic
, "cyrillic");
1605 DEFSYM (Qarmenian
, "armenian");
1606 DEFSYM (Qhebrew
, "hebrew");
1607 DEFSYM (Qarabic
, "arabic");
1608 DEFSYM (Qsyriac
, "syriac");
1609 DEFSYM (Qnko
, "nko");
1610 DEFSYM (Qthaana
, "thaana");
1611 DEFSYM (Qdevanagari
, "devanagari");
1612 DEFSYM (Qbengali
, "bengali");
1613 DEFSYM (Qgurmukhi
, "gurmukhi");
1614 DEFSYM (Qgujarati
, "gujarati");
1615 DEFSYM (Qoriya
, "oriya");
1616 DEFSYM (Qtamil
, "tamil");
1617 DEFSYM (Qtelugu
, "telugu");
1618 DEFSYM (Qkannada
, "kannada");
1619 DEFSYM (Qmalayalam
, "malayalam");
1620 DEFSYM (Qsinhala
, "sinhala");
1621 DEFSYM (Qthai
, "thai");
1622 DEFSYM (Qlao
, "lao");
1623 DEFSYM (Qtibetan
, "tibetan");
1624 DEFSYM (Qmyanmar
, "myanmar");
1625 DEFSYM (Qgeorgian
, "georgian");
1626 DEFSYM (Qhangul
, "hangul");
1627 DEFSYM (Qethiopic
, "ethiopic");
1628 DEFSYM (Qcherokee
, "cherokee");
1629 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
1630 DEFSYM (Qogham
, "ogham");
1631 DEFSYM (Qrunic
, "runic");
1632 DEFSYM (Qkhmer
, "khmer");
1633 DEFSYM (Qmongolian
, "mongolian");
1634 DEFSYM (Qsymbol
, "symbol");
1635 DEFSYM (Qbraille
, "braille");
1636 DEFSYM (Qhan
, "han");
1637 DEFSYM (Qideographic_description
, "ideographic-description");
1638 DEFSYM (Qcjk_misc
, "cjk-misc");
1639 DEFSYM (Qkana
, "kana");
1640 DEFSYM (Qbopomofo
, "bopomofo");
1641 DEFSYM (Qkanbun
, "kanbun");
1643 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
1644 DEFSYM (Qmusical_symbol
, "musical-symbol");
1645 DEFSYM (Qmathematical
, "mathematical");
1647 w32font_driver
.type
= Qgdi
;
1648 register_font_driver (&w32font_driver
, NULL
);
1651 /* arch-tag: 65b8a3cd-46aa-4c0d-a1f3-99e75b9c07ee
1652 (do not change this comment) */