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 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "dispextern.h"
27 #include "character.h"
33 /* Cleartype available on Windows XP, cleartype_natural from XP SP1.
34 The latter does not try to fit cleartype smoothed fonts into the
35 same bounding box as the non-antialiased version of the font.
37 #ifndef CLEARTYPE_QUALITY
38 #define CLEARTYPE_QUALITY 5
40 #ifndef CLEARTYPE_NATURAL_QUALITY
41 #define CLEARTYPE_NATURAL_QUALITY 6
44 extern struct font_driver w32font_driver
;
47 Lisp_Object Quniscribe
;
48 static Lisp_Object QCformat
;
49 static Lisp_Object Qmonospace
, Qsansserif
, Qmono
, Qsans
, Qsans_serif
;
50 static Lisp_Object Qserif
, Qscript
, Qdecorative
;
51 static Lisp_Object Qraster
, Qoutline
, Qunknown
;
54 extern Lisp_Object QCantialias
, QCotf
, QClang
; /* defined in font.c */
55 extern Lisp_Object Qnone
; /* reuse from w32fns.c */
56 static Lisp_Object Qstandard
, Qsubpixel
, Qnatural
;
59 static Lisp_Object Qja
, Qko
, Qzh
;
62 static Lisp_Object Qlatin
, Qgreek
, Qcoptic
, Qcyrillic
, Qarmenian
, Qhebrew
;
63 static Lisp_Object Qarabic
, Qsyriac
, Qnko
, Qthaana
, Qdevanagari
, Qbengali
;
64 static Lisp_Object Qgurmukhi
, Qgujarati
, Qoriya
, Qtamil
, Qtelugu
;
65 static Lisp_Object Qkannada
, Qmalayalam
, Qsinhala
, Qthai
, Qlao
;
66 static Lisp_Object Qtibetan
, Qmyanmar
, Qgeorgian
, Qhangul
, Qethiopic
;
67 static Lisp_Object Qcherokee
, Qcanadian_aboriginal
, Qogham
, Qrunic
;
68 static Lisp_Object Qkhmer
, Qmongolian
, Qsymbol
, Qbraille
, Qhan
;
69 static Lisp_Object Qideographic_description
, Qcjk_misc
, Qkana
, Qbopomofo
;
70 static Lisp_Object Qkanbun
, Qyi
, Qbyzantine_musical_symbol
;
71 static Lisp_Object Qmusical_symbol
, Qmathematical
;
72 /* Not defined in characters.el, but referenced in fontset.el. */
73 static Lisp_Object Qbalinese
, Qbuginese
, Qbuhid
, Qcuneiform
, Qcypriot
;
74 static Lisp_Object Qdeseret
, Qglagolitic
, Qgothic
, Qhanunoo
, Qkharoshthi
;
75 static Lisp_Object Qlimbu
, Qlinear_b
, Qold_italic
, Qold_persian
, Qosmanya
;
76 static Lisp_Object Qphags_pa
, Qphoenician
, Qshavian
, Qsyloti_nagri
;
77 static Lisp_Object Qtagalog
, Qtagbanwa
, Qtai_le
, Qtifinagh
, Qugaritic
;
78 /* Only defined here, but useful for distinguishing IPA capable fonts. */
79 static Lisp_Object Qphonetic
;
81 /* Font spacing symbols - defined in font.c. */
82 extern Lisp_Object Qc
, Qp
, Qm
;
84 static void fill_in_logfont
P_ ((FRAME_PTR
, LOGFONT
*, Lisp_Object
));
86 static BYTE w32_antialias_type
P_ ((Lisp_Object
));
87 static Lisp_Object lispy_antialias_type
P_ ((BYTE
));
89 static Lisp_Object font_supported_scripts
P_ ((FONTSIGNATURE
*));
90 static int w32font_full_name
P_ ((LOGFONT
*, Lisp_Object
, int, char *, int));
91 static void compute_metrics
P_ ((HDC
, struct w32font_info
*, unsigned int,
92 struct w32_metric_cache
*));
93 static void clear_cached_metrics
P_ ((struct w32font_info
*));
95 static Lisp_Object w32_registry
P_ ((LONG
, DWORD
));
97 /* EnumFontFamiliesEx callbacks. */
98 static int CALLBACK add_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
101 static int CALLBACK add_one_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
104 static int CALLBACK add_font_name_to_list
P_ ((ENUMLOGFONTEX
*,
108 /* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
109 of what we really want. */
110 struct font_callback_data
112 /* The logfont we are matching against. EnumFontFamiliesEx only matches
113 face name and charset, so we need to manually match everything else
114 in the callback function. */
116 /* The original font spec or entity. */
117 Lisp_Object orig_font_spec
;
118 /* The frame the font is being loaded on. */
120 /* The list to add matches to. */
122 /* Whether to match only opentype fonts. */
126 /* Handles the problem that EnumFontFamiliesEx will not return all
127 style variations if the font name is not specified. */
128 static void list_all_matching_fonts
P_ ((struct font_callback_data
*));
130 /* From old font code in w32fns.c */
131 char * w32_to_x_charset
P_ ((int, char *));
135 memq_no_quit (elt
, list
)
136 Lisp_Object elt
, list
;
138 while (CONSP (list
) && ! EQ (XCAR (list
), elt
))
140 return (CONSP (list
));
143 /* w32 implementation of get_cache for font backend.
144 Return a cache of font-entities on FRAME. The cache must be a
145 cons whose cdr part is the actual cache area. */
147 w32font_get_cache (f
)
150 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
152 return (dpyinfo
->name_list_element
);
155 /* w32 implementation of list for font backend.
156 List fonts exactly matching with FONT_SPEC on FRAME. The value
157 is a vector of font-entities. This is the sole API that
158 allocates font-entities. */
160 w32font_list (frame
, font_spec
)
161 Lisp_Object frame
, font_spec
;
163 return w32font_list_internal (frame
, font_spec
, 0);
166 /* w32 implementation of match for font backend.
167 Return a font entity most closely matching with FONT_SPEC on
168 FRAME. The closeness is detemined by the font backend, thus
169 `face-font-selection-order' is ignored here. */
171 w32font_match (frame
, font_spec
)
172 Lisp_Object frame
, font_spec
;
174 return w32font_match_internal (frame
, font_spec
, 0);
177 /* w32 implementation of list_family for font backend.
178 List available families. The value is a list of family names
181 w32font_list_family (frame
)
184 Lisp_Object list
= Qnil
;
185 LOGFONT font_match_pattern
;
187 FRAME_PTR f
= XFRAME (frame
);
189 bzero (&font_match_pattern
, sizeof (font_match_pattern
));
190 font_match_pattern
.lfCharSet
= DEFAULT_CHARSET
;
192 dc
= get_frame_dc (f
);
194 EnumFontFamiliesEx (dc
, &font_match_pattern
,
195 (FONTENUMPROC
) add_font_name_to_list
,
197 release_frame_dc (f
, dc
);
202 /* w32 implementation of open for font backend.
203 Open a font specified by FONT_ENTITY on frame F.
204 If the font is scalable, open it with PIXEL_SIZE. */
206 w32font_open (f
, font_entity
, pixel_size
)
208 Lisp_Object font_entity
;
211 Lisp_Object font_object
;
213 font_object
= font_make_object (VECSIZE (struct w32font_info
));
215 if (!w32font_open_internal (f
, font_entity
, pixel_size
, font_object
))
223 /* w32 implementation of close for font_backend.
224 Close FONT on frame F. */
226 w32font_close (f
, font
)
230 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
232 if (w32_font
->compat_w32_font
)
234 W32FontStruct
*old_w32_font
= w32_font
->compat_w32_font
;
235 DeleteObject (old_w32_font
->hfont
);
236 xfree (old_w32_font
);
237 w32_font
->compat_w32_font
= 0;
241 /* w32 implementation of has_char for font backend.
243 If FONT_ENTITY has a glyph for character C (Unicode code point),
244 return 1. If not, return 0. If a font must be opened to check
247 w32font_has_char (entity
, c
)
251 Lisp_Object supported_scripts
, extra
, script
;
254 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
258 supported_scripts
= assq_no_quit (QCscript
, extra
);
259 if (!CONSP (supported_scripts
))
262 supported_scripts
= XCDR (supported_scripts
);
264 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
266 return (memq_no_quit (script
, supported_scripts
)) ? -1 : 0;
269 /* w32 implementation of encode_char for font backend.
270 Return a glyph code of FONT for characer C (Unicode code point).
271 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
273 w32font_encode_char (font
, c
)
285 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
287 /* If glyph indexing is not working for this font, just return the
288 unicode code-point. */
289 if (!w32_font
->glyph_idx
)
294 /* TODO: Encode as surrogate pair and lookup the glyph. */
295 return FONT_INVALID_CODE
;
303 bzero (&result
, sizeof (result
));
304 result
.lStructSize
= sizeof (result
);
305 result
.lpGlyphs
= out
;
308 f
= XFRAME (selected_frame
);
310 dc
= get_frame_dc (f
);
311 old_font
= SelectObject (dc
, w32_font
->compat_w32_font
->hfont
);
313 retval
= GetCharacterPlacementW (dc
, in
, len
, 0, &result
, 0);
315 SelectObject (dc
, old_font
);
316 release_frame_dc (f
, dc
);
320 if (result
.nGlyphs
!= 1 || !result
.lpGlyphs
[0])
321 return FONT_INVALID_CODE
;
322 return result
.lpGlyphs
[0];
327 /* Mark this font as not supporting glyph indices. This can happen
328 on Windows9x, and maybe with non-Truetype fonts on NT etc. */
329 w32_font
->glyph_idx
= 0;
330 /* Clear metrics cache. */
331 clear_cached_metrics (w32_font
);
337 /* w32 implementation of text_extents for font backend.
338 Perform the size computation of glyphs of FONT and fillin members
339 of METRICS. The glyphs are specified by their glyph codes in
340 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
341 case just return the overall width. */
343 w32font_text_extents (font
, code
, nglyphs
, metrics
)
347 struct font_metrics
*metrics
;
350 HFONT old_font
= NULL
;
359 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
362 metrics
->ascent
= font
->ascent
;
363 metrics
->descent
= font
->descent
;
364 metrics
->lbearing
= 0;
366 for (i
= 0; i
< nglyphs
; i
++)
368 struct w32_metric_cache
*char_metric
;
369 int block
= *(code
+ i
) / CACHE_BLOCKSIZE
;
370 int pos_in_block
= *(code
+ i
) % CACHE_BLOCKSIZE
;
372 if (block
>= w32_font
->n_cache_blocks
)
374 if (!w32_font
->cached_metrics
)
375 w32_font
->cached_metrics
376 = xmalloc ((block
+ 1)
377 * sizeof (struct w32_cached_metric
*));
379 w32_font
->cached_metrics
380 = xrealloc (w32_font
->cached_metrics
,
382 * sizeof (struct w32_cached_metric
*));
383 bzero (w32_font
->cached_metrics
+ w32_font
->n_cache_blocks
,
384 ((block
+ 1 - w32_font
->n_cache_blocks
)
385 * sizeof (struct w32_cached_metric
*)));
386 w32_font
->n_cache_blocks
= block
+ 1;
389 if (!w32_font
->cached_metrics
[block
])
391 w32_font
->cached_metrics
[block
]
392 = xmalloc (CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
393 bzero (w32_font
->cached_metrics
[block
],
394 CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
397 char_metric
= w32_font
->cached_metrics
[block
] + pos_in_block
;
399 if (char_metric
->status
== W32METRIC_NO_ATTEMPT
)
403 /* TODO: Frames can come and go, and their fonts
404 outlive them. So we can't cache the frame in the
405 font structure. Use selected_frame until the API
406 is updated to pass in a frame. */
407 f
= XFRAME (selected_frame
);
409 dc
= get_frame_dc (f
);
410 old_font
= SelectObject (dc
, FONT_COMPAT (font
)->hfont
);
412 compute_metrics (dc
, w32_font
, *(code
+ i
), char_metric
);
415 if (char_metric
->status
== W32METRIC_SUCCESS
)
417 metrics
->lbearing
= min (metrics
->lbearing
,
418 metrics
->width
+ char_metric
->lbearing
);
419 metrics
->rbearing
= max (metrics
->rbearing
,
420 metrics
->width
+ char_metric
->rbearing
);
421 metrics
->width
+= char_metric
->width
;
424 /* If we couldn't get metrics for a char,
425 use alternative method. */
428 /* If we got through everything, return. */
433 /* Restore state and release DC. */
434 SelectObject (dc
, old_font
);
435 release_frame_dc (f
, dc
);
438 return metrics
->width
;
442 /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
443 fallback on other methods that will at least give some of the metric
446 wcode
= alloca (nglyphs
* sizeof (WORD
));
447 for (i
= 0; i
< nglyphs
; i
++)
449 if (code
[i
] < 0x10000)
453 /* TODO: Convert to surrogate, reallocating array if needed */
460 /* TODO: Frames can come and go, and their fonts outlive
461 them. So we can't cache the frame in the font structure. Use
462 selected_frame until the API is updated to pass in a
464 f
= XFRAME (selected_frame
);
466 dc
= get_frame_dc (f
);
467 old_font
= SelectObject (dc
, FONT_COMPAT (font
)->hfont
);
470 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
472 total_width
= size
.cx
;
475 /* On 95/98/ME, only some unicode functions are available, so fallback
476 on doing a dummy draw to find the total width. */
480 rect
.top
= 0; rect
.bottom
= font
->height
; rect
.left
= 0; rect
.right
= 1;
481 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
482 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
483 total_width
= rect
.right
;
486 /* Give our best estimate of the metrics, based on what we know. */
489 metrics
->width
= total_width
;
490 metrics
->lbearing
= 0;
491 metrics
->rbearing
= total_width
492 + ((struct w32font_info
*) font
)->metrics
.tmOverhang
;
495 /* Restore state and release DC. */
496 SelectObject (dc
, old_font
);
497 release_frame_dc (f
, dc
);
502 /* w32 implementation of draw for font backend.
504 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
505 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
506 is nonzero, fill the background in advance. It is assured that
507 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
509 TODO: Currently this assumes that the colors and fonts are already
510 set in the DC. This seems to be true now, but maybe only due to
511 the old font code setting it up. It may be safer to resolve faces
512 and fonts in here and set them explicitly
516 w32font_draw (s
, from
, to
, x
, y
, with_background
)
517 struct glyph_string
*s
;
518 int from
, to
, x
, y
, with_background
;
522 struct w32font_info
*w32font
= (struct w32font_info
*) s
->font
;
524 options
= w32font
->glyph_idx
;
526 /* Save clip region for later restoration. */
527 GetClipRgn(s
->hdc
, orig_clip
);
529 if (s
->num_clips
> 0)
531 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
533 if (s
->num_clips
> 1)
535 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
537 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
538 DeleteObject (clip2
);
541 SelectClipRgn (s
->hdc
, new_clip
);
542 DeleteObject (new_clip
);
545 /* Using OPAQUE background mode can clear more background than expected
546 when Cleartype is used. Draw the background manually to avoid this. */
547 SetBkMode (s
->hdc
, TRANSPARENT
);
552 struct font
*font
= s
->font
;
554 brush
= CreateSolidBrush (s
->gc
->background
);
556 rect
.top
= y
- font
->ascent
;
557 rect
.right
= x
+ s
->width
;
558 rect
.bottom
= y
+ font
->descent
;
559 FillRect (s
->hdc
, &rect
, brush
);
560 DeleteObject (brush
);
565 int len
= to
- from
, i
;
567 for (i
= 0; i
< len
; i
++)
568 ExtTextOutW (s
->hdc
, x
+ i
, y
, options
, NULL
,
569 s
->char2b
+ from
+ i
, 1, NULL
);
572 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, to
- from
, NULL
);
574 /* Restore clip region. */
575 if (s
->num_clips
> 0)
577 SelectClipRgn (s
->hdc
, orig_clip
);
581 /* w32 implementation of free_entity for font backend.
582 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
583 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
585 w32font_free_entity (Lisp_Object entity);
588 /* w32 implementation of prepare_face for font backend.
589 Optional (if FACE->extra is not used).
590 Prepare FACE for displaying characters by FONT on frame F by
591 storing some data in FACE->extra. If successful, return 0.
592 Otherwise, return -1.
594 w32font_prepare_face (FRAME_PTR f, struct face *face);
596 /* w32 implementation of done_face for font backend.
598 Done FACE for displaying characters by FACE->font on frame F.
600 w32font_done_face (FRAME_PTR f, struct face *face); */
602 /* w32 implementation of get_bitmap for font backend.
604 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
605 intended that this method is called from the other font-driver
608 w32font_get_bitmap (struct font *font, unsigned code,
609 struct font_bitmap *bitmap, int bits_per_pixel);
611 /* w32 implementation of free_bitmap for font backend.
613 Free bitmap data in BITMAP.
615 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
617 /* w32 implementation of get_outline for font backend.
619 Return an outline data for glyph-code CODE of FONT. The format
620 of the outline data depends on the font-driver.
622 w32font_get_outline (struct font *font, unsigned code);
624 /* w32 implementation of free_outline for font backend.
626 Free OUTLINE (that is obtained by the above method).
628 w32font_free_outline (struct font *font, void *outline);
630 /* w32 implementation of anchor_point for font backend.
632 Get coordinates of the INDEXth anchor point of the glyph whose
633 code is CODE. Store the coordinates in *X and *Y. Return 0 if
634 the operations was successfull. Otherwise return -1.
636 w32font_anchor_point (struct font *font, unsigned code,
637 int index, int *x, int *y);
639 /* w32 implementation of otf_capability for font backend.
641 Return a list describing which scripts/languages FONT
642 supports by which GSUB/GPOS features of OpenType tables.
644 w32font_otf_capability (struct font *font);
646 /* w32 implementation of otf_drive for font backend.
648 Apply FONT's OTF-FEATURES to the glyph string.
650 FEATURES specifies which OTF features to apply in this format:
651 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
652 See the documentation of `font-drive-otf' for the detail.
654 This method applies the specified features to the codes in the
655 elements of GSTRING-IN (between FROMth and TOth). The output
656 codes are stored in GSTRING-OUT at the IDXth element and the
659 Return the number of output codes. If none of the features are
660 applicable to the input data, return 0. If GSTRING-OUT is too
663 w32font_otf_drive (struct font *font, Lisp_Object features,
664 Lisp_Object gstring_in, int from, int to,
665 Lisp_Object gstring_out, int idx,
666 int alternate_subst);
669 /* Internal implementation of w32font_list.
670 Additional parameter opentype_only restricts the returned fonts to
671 opentype fonts, which can be used with the Uniscribe backend. */
673 w32font_list_internal (frame
, font_spec
, opentype_only
)
674 Lisp_Object frame
, font_spec
;
677 struct font_callback_data match_data
;
679 FRAME_PTR f
= XFRAME (frame
);
681 match_data
.orig_font_spec
= font_spec
;
682 match_data
.list
= Qnil
;
683 match_data
.frame
= frame
;
685 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
686 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
688 match_data
.opentype_only
= opentype_only
;
690 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
692 if (match_data
.pattern
.lfFaceName
[0] == '\0')
694 /* EnumFontFamiliesEx does not take other fields into account if
695 font name is blank, so need to use two passes. */
696 list_all_matching_fonts (&match_data
);
700 dc
= get_frame_dc (f
);
702 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
703 (FONTENUMPROC
) add_font_entity_to_list
,
704 (LPARAM
) &match_data
, 0);
705 release_frame_dc (f
, dc
);
708 return NILP (match_data
.list
) ? Qnil
: match_data
.list
;
711 /* Internal implementation of w32font_match.
712 Additional parameter opentype_only restricts the returned fonts to
713 opentype fonts, which can be used with the Uniscribe backend. */
715 w32font_match_internal (frame
, font_spec
, opentype_only
)
716 Lisp_Object frame
, font_spec
;
719 struct font_callback_data match_data
;
721 FRAME_PTR f
= XFRAME (frame
);
723 match_data
.orig_font_spec
= font_spec
;
724 match_data
.frame
= frame
;
725 match_data
.list
= Qnil
;
727 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
728 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
730 match_data
.opentype_only
= opentype_only
;
732 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
734 dc
= get_frame_dc (f
);
736 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
737 (FONTENUMPROC
) add_one_font_entity_to_list
,
738 (LPARAM
) &match_data
, 0);
739 release_frame_dc (f
, dc
);
741 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
745 w32font_open_internal (f
, font_entity
, pixel_size
, font_object
)
747 Lisp_Object font_entity
;
749 Lisp_Object font_object
;
754 HFONT hfont
, old_font
;
755 Lisp_Object val
, extra
;
756 /* For backwards compatibility. */
757 W32FontStruct
*compat_w32_font
;
758 struct w32font_info
*w32_font
;
760 OUTLINETEXTMETRIC
* metrics
= NULL
;
762 w32_font
= (struct w32font_info
*) XFONT_OBJECT (font_object
);
763 font
= (struct font
*) w32_font
;
768 /* Copy from font entity. */
769 for (i
= 0; i
< FONT_ENTITY_MAX
; i
++)
770 ASET (font_object
, i
, AREF (font_entity
, i
));
771 ASET (font_object
, FONT_SIZE_INDEX
, make_number (pixel_size
));
773 bzero (&logfont
, sizeof (logfont
));
774 fill_in_logfont (f
, &logfont
, font_entity
);
776 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
780 logfont
.lfHeight
= -size
;
781 hfont
= CreateFontIndirect (&logfont
);
786 /* Get the metrics for this font. */
787 dc
= get_frame_dc (f
);
788 old_font
= SelectObject (dc
, hfont
);
790 /* Try getting the outline metrics (only works for truetype fonts). */
791 len
= GetOutlineTextMetrics (dc
, 0, NULL
);
794 metrics
= (OUTLINETEXTMETRIC
*) alloca (len
);
795 if (GetOutlineTextMetrics (dc
, len
, metrics
))
796 bcopy (&metrics
->otmTextMetrics
, &w32_font
->metrics
,
797 sizeof (TEXTMETRIC
));
802 GetTextMetrics (dc
, &w32_font
->metrics
);
804 w32_font
->glyph_idx
= ETO_GLYPH_INDEX
;
806 w32_font
->cached_metrics
= NULL
;
807 w32_font
->n_cache_blocks
= 0;
809 SelectObject (dc
, old_font
);
810 release_frame_dc (f
, dc
);
812 /* W32FontStruct - we should get rid of this, and use the w32font_info
813 struct for any W32 specific fields. font->font.font can then be hfont. */
814 w32_font
->compat_w32_font
= xmalloc (sizeof (W32FontStruct
));
815 compat_w32_font
= w32_font
->compat_w32_font
;
816 bzero (compat_w32_font
, sizeof (W32FontStruct
));
817 compat_w32_font
->font_type
= UNICODE_FONT
;
818 /* Duplicate the text metrics. */
819 bcopy (&w32_font
->metrics
, &compat_w32_font
->tm
, sizeof (TEXTMETRIC
));
820 compat_w32_font
->hfont
= hfont
;
825 /* We don't know how much space we need for the full name, so start with
826 96 bytes and go up in steps of 32. */
828 name
= xmalloc (len
);
829 while (name
&& w32font_full_name (&logfont
, font_entity
, pixel_size
,
832 char *new = xrealloc (name
, len
+= 32);
839 font
->props
[FONT_FULLNAME_INDEX
]
840 = make_unibyte_string (name
, strlen (name
));
842 font
->props
[FONT_FULLNAME_INDEX
] =
843 make_unibyte_string (logfont
.lfFaceName
, len
);
846 font
->max_width
= w32_font
->metrics
.tmMaxCharWidth
;
847 font
->height
= w32_font
->metrics
.tmHeight
848 + w32_font
->metrics
.tmExternalLeading
;
849 font
->space_width
= font
->average_width
= w32_font
->metrics
.tmAveCharWidth
;
851 font
->vertical_centering
= 0;
852 font
->encoding_type
= 0;
853 font
->baseline_offset
= 0;
854 font
->relative_compose
= 0;
855 font
->default_ascent
= w32_font
->metrics
.tmAscent
;
856 font
->font_encoder
= NULL
;
857 font
->pixel_size
= size
;
858 font
->driver
= &w32font_driver
;
859 /* Use format cached during list, as the information we have access to
860 here is incomplete. */
861 extra
= AREF (font_entity
, FONT_EXTRA_INDEX
);
864 val
= assq_no_quit (QCformat
, extra
);
866 font
->props
[FONT_FORMAT_INDEX
] = XCDR (val
);
868 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
871 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
873 font
->props
[FONT_FILE_INDEX
] = Qnil
;
874 font
->encoding_charset
= -1;
875 font
->repertory_charset
= -1;
876 /* TODO: do we really want the minimum width here, which could be negative? */
877 font
->min_width
= font
->space_width
;
878 font
->ascent
= w32_font
->metrics
.tmAscent
;
879 font
->descent
= w32_font
->metrics
.tmDescent
;
883 font
->underline_thickness
= metrics
->otmsUnderscoreSize
;
884 font
->underline_position
= -metrics
->otmsUnderscorePosition
;
888 font
->underline_thickness
= 0;
889 font
->underline_position
= -1;
892 /* max_descent is used for underlining in w32term.c. Hopefully this
893 is temporary, as we'll want to get rid of the old compatibility
895 compat_w32_font
->max_bounds
.descent
= font
->descent
;
897 /* For temporary compatibility with legacy code that expects the
898 name to be usable in x-list-fonts. Eventually we expect to change
899 x-list-fonts and other places that use fonts so that this can be
900 an fcname or similar. */
901 font
->props
[FONT_NAME_INDEX
] = Ffont_xlfd_name (font_object
, Qnil
);
906 /* Callback function for EnumFontFamiliesEx.
907 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
909 add_font_name_to_list (logical_font
, physical_font
, font_type
, list_object
)
910 ENUMLOGFONTEX
*logical_font
;
911 NEWTEXTMETRICEX
*physical_font
;
915 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
918 /* Skip vertical fonts (intended only for printing) */
919 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
922 family
= font_intern_prop (logical_font
->elfLogFont
.lfFaceName
,
923 strlen (logical_font
->elfLogFont
.lfFaceName
));
924 if (! memq_no_quit (family
, *list
))
925 *list
= Fcons (family
, *list
);
930 static int w32_decode_weight
P_ ((int));
931 static int w32_encode_weight
P_ ((int));
933 /* Convert an enumerated Windows font to an Emacs font entity. */
935 w32_enumfont_pattern_entity (frame
, logical_font
, physical_font
,
936 font_type
, requested_font
, backend
)
938 ENUMLOGFONTEX
*logical_font
;
939 NEWTEXTMETRICEX
*physical_font
;
941 LOGFONT
*requested_font
;
944 Lisp_Object entity
, tem
;
945 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
947 DWORD full_type
= physical_font
->ntmTm
.ntmFlags
;
949 entity
= font_make_entity ();
951 ASET (entity
, FONT_TYPE_INDEX
, backend
);
952 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
, font_type
));
953 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
955 /* Foundry is difficult to get in readable form on Windows.
956 But Emacs crashes if it is not set, so set it to something more
957 generic. These values make xflds compatible with Emacs 22. */
958 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
960 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
965 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
967 /* Save the generic family in the extra info, as it is likely to be
968 useful to users looking for a close match. */
969 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
970 if (generic_type
== FF_DECORATIVE
)
972 else if (generic_type
== FF_MODERN
)
974 else if (generic_type
== FF_ROMAN
)
976 else if (generic_type
== FF_SCRIPT
)
978 else if (generic_type
== FF_SWISS
)
983 ASET (entity
, FONT_ADSTYLE_INDEX
, tem
);
985 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
986 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_PROPORTIONAL
));
988 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_MONO
));
990 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
992 font_put_extra (entity
, QCantialias
,
993 lispy_antialias_type (requested_font
->lfQuality
));
995 ASET (entity
, FONT_FAMILY_INDEX
,
996 font_intern_prop (lf
->lfFaceName
, strlen (lf
->lfFaceName
)));
998 FONT_SET_STYLE (entity
, FONT_WEIGHT_INDEX
,
999 make_number (w32_decode_weight (lf
->lfWeight
)));
1000 FONT_SET_STYLE (entity
, FONT_SLANT_INDEX
,
1001 make_number (lf
->lfItalic
? 200 : 100));
1002 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
1004 FONT_SET_STYLE (entity
, FONT_WIDTH_INDEX
, make_number (100));
1006 if (font_type
& RASTER_FONTTYPE
)
1007 ASET (entity
, FONT_SIZE_INDEX
, make_number (physical_font
->ntmTm
.tmHeight
));
1009 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
1011 /* Cache unicode codepoints covered by this font, as there is no other way
1012 of getting this information easily. */
1013 if (font_type
& TRUETYPE_FONTTYPE
)
1015 font_put_extra (entity
, QCscript
,
1016 font_supported_scripts (&physical_font
->ntmFontSig
));
1019 /* This information is not fully available when opening fonts, so
1020 save it here. Only Windows 2000 and later return information
1021 about opentype and type1 fonts, so need a fallback for detecting
1022 truetype so that this information is not any worse than we could
1023 have obtained later. */
1024 if (EQ (backend
, Quniscribe
) && (full_type
& NTMFLAGS_OPENTYPE
))
1025 tem
= intern ("opentype");
1026 else if (font_type
& TRUETYPE_FONTTYPE
)
1027 tem
= intern ("truetype");
1028 else if (full_type
& NTM_PS_OPENTYPE
)
1029 tem
= intern ("postscript");
1030 else if (full_type
& NTM_TYPE1
)
1031 tem
= intern ("type1");
1032 else if (font_type
& RASTER_FONTTYPE
)
1033 tem
= intern ("w32bitmap");
1035 tem
= intern ("w32vector");
1037 font_put_extra (entity
, QCformat
, tem
);
1043 /* Convert generic families to the family portion of lfPitchAndFamily. */
1045 w32_generic_family (Lisp_Object name
)
1047 /* Generic families. */
1048 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
1050 else if (EQ (name
, Qsans
) || EQ (name
, Qsans_serif
) || EQ (name
, Qsansserif
))
1052 else if (EQ (name
, Qserif
))
1054 else if (EQ (name
, Qdecorative
))
1055 return FF_DECORATIVE
;
1056 else if (EQ (name
, Qscript
))
1063 logfonts_match (font
, pattern
)
1064 LOGFONT
*font
, *pattern
;
1066 /* Only check height for raster fonts. */
1067 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
1068 && font
->lfHeight
!= pattern
->lfHeight
)
1071 /* Have some flexibility with weights. */
1072 if (pattern
->lfWeight
1073 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
1074 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
1077 /* Charset and face should be OK. Italic has to be checked
1078 against the original spec, in case we don't have any preference. */
1083 font_matches_spec (type
, font
, spec
, backend
, logfont
)
1085 NEWTEXTMETRICEX
*font
;
1087 Lisp_Object backend
;
1090 Lisp_Object extra
, val
;
1092 /* Check italic. Can't check logfonts, since it is a boolean field,
1093 so there is no difference between "non-italic" and "don't care". */
1095 int slant
= FONT_SLANT_NUMERIC (spec
);
1098 && ((slant
> 150 && !font
->ntmTm
.tmItalic
)
1099 || (slant
<= 150 && font
->ntmTm
.tmItalic
)))
1103 /* Check adstyle against generic family. */
1104 val
= AREF (spec
, FONT_ADSTYLE_INDEX
);
1107 BYTE family
= w32_generic_family (val
);
1108 if (family
!= FF_DONTCARE
1109 && family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
1114 val
= AREF (spec
, FONT_SPACING_INDEX
);
1117 int spacing
= XINT (val
);
1118 int proportional
= (spacing
< FONT_SPACING_MONO
);
1120 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
1121 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
1125 /* Check extra parameters. */
1126 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
1127 CONSP (extra
); extra
= XCDR (extra
))
1129 Lisp_Object extra_entry
;
1130 extra_entry
= XCAR (extra
);
1131 if (CONSP (extra_entry
))
1133 Lisp_Object key
= XCAR (extra_entry
);
1135 val
= XCDR (extra_entry
);
1136 if (EQ (key
, QCscript
) && SYMBOLP (val
))
1138 /* Only truetype fonts will have information about what
1139 scripts they support. This probably means the user
1140 will have to force Emacs to use raster, postscript
1141 or atm fonts for non-ASCII text. */
1142 if (type
& TRUETYPE_FONTTYPE
)
1145 = font_supported_scripts (&font
->ntmFontSig
);
1146 if (! memq_no_quit (val
, support
))
1151 /* Return specific matches, but play it safe. Fonts
1152 that cover more than their charset would suggest
1153 are likely to be truetype or opentype fonts,
1155 if (EQ (val
, Qlatin
))
1157 /* Although every charset but symbol, thai and
1158 arabic contains the basic ASCII set of latin
1159 characters, Emacs expects much more. */
1160 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
1163 else if (EQ (val
, Qsymbol
))
1165 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
1168 else if (EQ (val
, Qcyrillic
))
1170 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
1173 else if (EQ (val
, Qgreek
))
1175 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
1178 else if (EQ (val
, Qarabic
))
1180 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
1183 else if (EQ (val
, Qhebrew
))
1185 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
1188 else if (EQ (val
, Qthai
))
1190 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
1193 else if (EQ (val
, Qkana
))
1195 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1198 else if (EQ (val
, Qbopomofo
))
1200 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1203 else if (EQ (val
, Qhangul
))
1205 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1206 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1209 else if (EQ (val
, Qhan
))
1211 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
1212 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1213 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1214 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
1215 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1219 /* Other scripts unlikely to be handled by non-truetype
1224 else if (EQ (key
, QClang
) && SYMBOLP (val
))
1226 /* Just handle the CJK languages here, as the language
1227 parameter is used to select a font with appropriate
1228 glyphs in the cjk unified ideographs block. Other fonts
1229 support for a language can be solely determined by
1230 its character coverage. */
1233 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1236 else if (EQ (val
, Qko
))
1238 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1239 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1242 else if (EQ (val
, Qzh
))
1244 if (font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1245 && font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1249 /* Any other language, we don't recognize it. Fontset
1250 spec should have a fallback, as some backends do
1251 not recognize language at all. */
1254 else if (EQ (key
, QCotf
) && CONSP (val
))
1256 /* OTF features only supported by the uniscribe backend. */
1257 if (EQ (backend
, Quniscribe
))
1259 if (!uniscribe_check_otf (logfont
, val
))
1271 w32font_coverage_ok (coverage
, charset
)
1272 FONTSIGNATURE
* coverage
;
1275 DWORD subrange1
= coverage
->fsUsb
[1];
1277 #define SUBRANGE1_HAN_MASK 0x08000000
1278 #define SUBRANGE1_HANGEUL_MASK 0x01000000
1279 #define SUBRANGE1_JAPANESE_MASK (0x00060000 | SUBRANGE1_HAN_MASK)
1281 if (charset
== GB2312_CHARSET
|| charset
== CHINESEBIG5_CHARSET
)
1283 return (subrange1
& SUBRANGE1_HAN_MASK
) == SUBRANGE1_HAN_MASK
;
1285 else if (charset
== SHIFTJIS_CHARSET
)
1287 return (subrange1
& SUBRANGE1_JAPANESE_MASK
) == SUBRANGE1_JAPANESE_MASK
;
1289 else if (charset
== HANGEUL_CHARSET
)
1291 return (subrange1
& SUBRANGE1_HANGEUL_MASK
) == SUBRANGE1_HANGEUL_MASK
;
1297 /* Callback function for EnumFontFamiliesEx.
1298 * Checks if a font matches everything we are trying to check agaist,
1299 * and if so, adds it to a list. Both the data we are checking against
1300 * and the list to which the fonts are added are passed in via the
1301 * lparam argument, in the form of a font_callback_data struct. */
1303 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1304 ENUMLOGFONTEX
*logical_font
;
1305 NEWTEXTMETRICEX
*physical_font
;
1309 struct font_callback_data
*match_data
1310 = (struct font_callback_data
*) lParam
;
1311 Lisp_Object backend
= match_data
->opentype_only
? Quniscribe
: Qgdi
;
1313 if ((!match_data
->opentype_only
1314 || (physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
))
1315 && logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1316 && font_matches_spec (font_type
, physical_font
,
1317 match_data
->orig_font_spec
, backend
,
1318 &logical_font
->elfLogFont
)
1319 && w32font_coverage_ok (&physical_font
->ntmFontSig
,
1320 match_data
->pattern
.lfCharSet
)
1321 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1322 We limit this to raster fonts, because the test can catch some
1323 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1324 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1325 therefore get through this test. Since full names can be prefixed
1326 by a foundry, we accept raster fonts if the font name is found
1327 anywhere within the full name. */
1328 && (logical_font
->elfLogFont
.lfOutPrecision
!= OUT_STRING_PRECIS
1329 || strstr (logical_font
->elfFullName
,
1330 logical_font
->elfLogFont
.lfFaceName
)))
1333 = w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1334 physical_font
, font_type
,
1335 &match_data
->pattern
,
1338 match_data
->list
= Fcons (entity
, match_data
->list
);
1343 /* Callback function for EnumFontFamiliesEx.
1344 * Terminates the search once we have a match. */
1346 add_one_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1347 ENUMLOGFONTEX
*logical_font
;
1348 NEWTEXTMETRICEX
*physical_font
;
1352 struct font_callback_data
*match_data
1353 = (struct font_callback_data
*) lParam
;
1354 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1356 /* If we have a font in the list, terminate the search. */
1357 return !NILP (match_data
->list
);
1360 /* Convert a Lisp font registry (symbol) to a windows charset. */
1362 registry_to_w32_charset (charset
)
1363 Lisp_Object charset
;
1365 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1366 || EQ (charset
, Qunicode_sip
))
1367 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1368 else if (EQ (charset
, Qiso8859_1
))
1369 return ANSI_CHARSET
;
1370 else if (SYMBOLP (charset
))
1371 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1373 return DEFAULT_CHARSET
;
1377 w32_registry (w32_charset
, font_type
)
1381 /* If charset is defaulted, use ANSI (unicode for truetype fonts). */
1382 if (w32_charset
== DEFAULT_CHARSET
)
1383 w32_charset
= ANSI_CHARSET
;
1385 if (font_type
== TRUETYPE_FONTTYPE
&& w32_charset
== ANSI_CHARSET
)
1389 char * charset
= w32_to_x_charset (w32_charset
, NULL
);
1390 return font_intern_prop (charset
, strlen(charset
));
1396 unsigned w32_numeric
;
1398 } w32_weight_table
[] =
1400 { FW_EXTRALIGHT
, 40 },
1404 { FW_SEMIBOLD
, 180},
1406 { FW_EXTRABOLD
, 205},
1410 w32_decode_weight (fnweight
)
1413 if (fnweight
>= FW_HEAVY
) return 210;
1414 if (fnweight
>= FW_EXTRABOLD
) return 205;
1415 if (fnweight
>= FW_BOLD
) return 200;
1416 if (fnweight
>= FW_SEMIBOLD
) return 180;
1417 if (fnweight
>= FW_NORMAL
) return 100;
1418 if (fnweight
>= FW_LIGHT
) return 50;
1419 if (fnweight
>= FW_EXTRALIGHT
) return 40;
1420 if (fnweight
> FW_THIN
) return 20;
1425 w32_encode_weight (n
)
1428 if (n
>= 210) return FW_HEAVY
;
1429 if (n
>= 205) return FW_EXTRABOLD
;
1430 if (n
>= 200) return FW_BOLD
;
1431 if (n
>= 180) return FW_SEMIBOLD
;
1432 if (n
>= 100) return FW_NORMAL
;
1433 if (n
>= 50) return FW_LIGHT
;
1434 if (n
>= 40) return FW_EXTRALIGHT
;
1435 if (n
>= 20) return FW_THIN
;
1439 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1441 fill_in_logfont (f
, logfont
, font_spec
)
1444 Lisp_Object font_spec
;
1446 Lisp_Object tmp
, extra
;
1447 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1449 tmp
= AREF (font_spec
, FONT_DPI_INDEX
);
1454 else if (FLOATP (tmp
))
1456 dpi
= (int) (XFLOAT_DATA (tmp
) + 0.5);
1460 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1462 logfont
->lfHeight
= -1 * XINT (tmp
);
1463 else if (FLOATP (tmp
))
1464 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1471 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1473 logfont
->lfWeight
= w32_encode_weight (FONT_WEIGHT_NUMERIC (font_spec
));
1476 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
1479 int slant
= FONT_SLANT_NUMERIC (font_spec
);
1480 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
1488 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1490 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
1492 logfont
->lfCharSet
= DEFAULT_CHARSET
;
1496 /* Clip Precision */
1499 logfont
->lfQuality
= DEFAULT_QUALITY
;
1501 /* Generic Family and Face Name */
1502 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
1504 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1507 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
1508 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
1509 ; /* Font name was generic, don't fill in font name. */
1510 /* Font families are interned, but allow for strings also in case of
1512 else if (SYMBOLP (tmp
))
1513 strncpy (logfont
->lfFaceName
, SDATA (SYMBOL_NAME (tmp
)), LF_FACESIZE
);
1516 tmp
= AREF (font_spec
, FONT_ADSTYLE_INDEX
);
1519 /* Override generic family. */
1520 BYTE family
= w32_generic_family (tmp
);
1521 if (family
!= FF_DONTCARE
)
1522 logfont
->lfPitchAndFamily
= family
| DEFAULT_PITCH
;
1526 /* Set pitch based on the spacing property. */
1527 tmp
= AREF (font_spec
, FONT_SPACING_INDEX
);
1530 int spacing
= XINT (tmp
);
1531 if (spacing
< FONT_SPACING_MONO
)
1532 logfont
->lfPitchAndFamily
1533 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1535 logfont
->lfPitchAndFamily
1536 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1539 /* Process EXTRA info. */
1540 for (extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
1541 CONSP (extra
); extra
= XCDR (extra
))
1546 Lisp_Object key
, val
;
1547 key
= XCAR (tmp
), val
= XCDR (tmp
);
1548 /* Only use QCscript if charset is not provided, or is unicode
1549 and a single script is specified. This is rather crude,
1550 and is only used to narrow down the fonts returned where
1551 there is a definite match. Some scripts, such as latin, han,
1552 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1554 if (EQ (key
, QCscript
)
1555 && logfont
->lfCharSet
== DEFAULT_CHARSET
1558 if (EQ (val
, Qgreek
))
1559 logfont
->lfCharSet
= GREEK_CHARSET
;
1560 else if (EQ (val
, Qhangul
))
1561 logfont
->lfCharSet
= HANGUL_CHARSET
;
1562 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
1563 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
1564 else if (EQ (val
, Qbopomofo
))
1565 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
1566 /* GB 18030 supports tibetan, yi, mongolian,
1567 fonts that support it should show up if we ask for
1569 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
1570 || EQ (val
, Qmongolian
))
1571 logfont
->lfCharSet
= GB2312_CHARSET
;
1572 else if (EQ (val
, Qhebrew
))
1573 logfont
->lfCharSet
= HEBREW_CHARSET
;
1574 else if (EQ (val
, Qarabic
))
1575 logfont
->lfCharSet
= ARABIC_CHARSET
;
1576 else if (EQ (val
, Qthai
))
1577 logfont
->lfCharSet
= THAI_CHARSET
;
1578 else if (EQ (val
, Qsymbol
))
1579 logfont
->lfCharSet
= SYMBOL_CHARSET
;
1581 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
1583 logfont
->lfQuality
= w32_antialias_type (val
);
1590 list_all_matching_fonts (match_data
)
1591 struct font_callback_data
*match_data
;
1594 Lisp_Object families
= w32font_list_family (match_data
->frame
);
1595 struct frame
*f
= XFRAME (match_data
->frame
);
1597 dc
= get_frame_dc (f
);
1599 while (!NILP (families
))
1601 /* TODO: Use the Unicode versions of the W32 APIs, so we can
1602 handle non-ASCII font names. */
1604 Lisp_Object family
= CAR (families
);
1605 families
= CDR (families
);
1608 else if (SYMBOLP (family
))
1609 name
= SDATA (SYMBOL_NAME (family
));
1613 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
1614 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
1616 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
1617 (FONTENUMPROC
) add_font_entity_to_list
,
1618 (LPARAM
) match_data
, 0);
1621 release_frame_dc (f
, dc
);
1625 lispy_antialias_type (type
)
1632 case NONANTIALIASED_QUALITY
:
1635 case ANTIALIASED_QUALITY
:
1638 case CLEARTYPE_QUALITY
:
1641 case CLEARTYPE_NATURAL_QUALITY
:
1651 /* Convert antialiasing symbols to lfQuality */
1653 w32_antialias_type (type
)
1656 if (EQ (type
, Qnone
))
1657 return NONANTIALIASED_QUALITY
;
1658 else if (EQ (type
, Qstandard
))
1659 return ANTIALIASED_QUALITY
;
1660 else if (EQ (type
, Qsubpixel
))
1661 return CLEARTYPE_QUALITY
;
1662 else if (EQ (type
, Qnatural
))
1663 return CLEARTYPE_NATURAL_QUALITY
;
1665 return DEFAULT_QUALITY
;
1668 /* Return a list of all the scripts that the font supports. */
1670 font_supported_scripts (FONTSIGNATURE
* sig
)
1672 DWORD
* subranges
= sig
->fsUsb
;
1673 Lisp_Object supported
= Qnil
;
1675 /* Match a single subrange. SYM is set if bit N is set in subranges. */
1676 #define SUBRANGE(n,sym) \
1677 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
1678 supported = Fcons ((sym), supported)
1680 /* Match multiple subranges. SYM is set if any MASK bit is set in
1681 subranges[0 - 3]. */
1682 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
1683 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
1684 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
1685 supported = Fcons ((sym), supported)
1687 SUBRANGE (0, Qlatin
);
1688 /* The following count as latin too, ASCII should be present in these fonts,
1689 so don't need to mark them separately. */
1690 /* 1: Latin-1 supplement, 2: Latin Extended A, 3: Latin Extended B. */
1691 SUBRANGE (4, Qphonetic
);
1692 /* 5: Spacing and tone modifiers, 6: Combining Diacriticals. */
1693 SUBRANGE (7, Qgreek
);
1694 SUBRANGE (8, Qcoptic
);
1695 SUBRANGE (9, Qcyrillic
);
1696 SUBRANGE (10, Qarmenian
);
1697 SUBRANGE (11, Qhebrew
);
1698 SUBRANGE (13, Qarabic
);
1699 SUBRANGE (14, Qnko
);
1700 SUBRANGE (15, Qdevanagari
);
1701 SUBRANGE (16, Qbengali
);
1702 SUBRANGE (17, Qgurmukhi
);
1703 SUBRANGE (18, Qgujarati
);
1704 SUBRANGE (19, Qoriya
);
1705 SUBRANGE (20, Qtamil
);
1706 SUBRANGE (21, Qtelugu
);
1707 SUBRANGE (22, Qkannada
);
1708 SUBRANGE (23, Qmalayalam
);
1709 SUBRANGE (24, Qthai
);
1710 SUBRANGE (25, Qlao
);
1711 SUBRANGE (26, Qgeorgian
);
1712 SUBRANGE (27, Qbalinese
);
1713 /* 28: Hangul Jamo. */
1714 /* 29: Latin Extended, 30: Greek Extended, 31: Punctuation. */
1715 /* 32-47: Symbols (defined below). */
1716 SUBRANGE (48, Qcjk_misc
);
1717 /* Match either 49: katakana or 50: hiragana for kana. */
1718 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
1719 SUBRANGE (51, Qbopomofo
);
1720 /* 52: Compatibility Jamo */
1721 SUBRANGE (53, Qphags_pa
);
1722 /* 54: Enclosed CJK letters and months, 55: CJK Compatibility. */
1723 SUBRANGE (56, Qhangul
);
1724 /* 57: Surrogates. */
1725 SUBRANGE (58, Qphoenician
);
1726 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
1727 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in. */
1728 SUBRANGE (59, Qkanbun
); /* And this. */
1729 /* 60: Private use, 61: CJK strokes and compatibility. */
1730 /* 62: Alphabetic Presentation, 63: Arabic Presentation A. */
1731 /* 64: Combining half marks, 65: Vertical and CJK compatibility. */
1732 /* 66: Small forms, 67: Arabic Presentation B, 68: Half and Full width. */
1734 SUBRANGE (70, Qtibetan
);
1735 SUBRANGE (71, Qsyriac
);
1736 SUBRANGE (72, Qthaana
);
1737 SUBRANGE (73, Qsinhala
);
1738 SUBRANGE (74, Qmyanmar
);
1739 SUBRANGE (75, Qethiopic
);
1740 SUBRANGE (76, Qcherokee
);
1741 SUBRANGE (77, Qcanadian_aboriginal
);
1742 SUBRANGE (78, Qogham
);
1743 SUBRANGE (79, Qrunic
);
1744 SUBRANGE (80, Qkhmer
);
1745 SUBRANGE (81, Qmongolian
);
1746 SUBRANGE (82, Qbraille
);
1748 SUBRANGE (84, Qbuhid
);
1749 SUBRANGE (84, Qhanunoo
);
1750 SUBRANGE (84, Qtagalog
);
1751 SUBRANGE (84, Qtagbanwa
);
1752 SUBRANGE (85, Qold_italic
);
1753 SUBRANGE (86, Qgothic
);
1754 SUBRANGE (87, Qdeseret
);
1755 SUBRANGE (88, Qbyzantine_musical_symbol
);
1756 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
1757 SUBRANGE (89, Qmathematical
);
1758 /* 90: Private use, 91: Variation selectors, 92: Tags. */
1759 SUBRANGE (93, Qlimbu
);
1760 SUBRANGE (94, Qtai_le
);
1761 /* 95: New Tai Le */
1762 SUBRANGE (90, Qbuginese
);
1763 SUBRANGE (97, Qglagolitic
);
1764 SUBRANGE (98, Qtifinagh
);
1765 /* 99: Yijing Hexagrams. */
1766 SUBRANGE (100, Qsyloti_nagri
);
1767 SUBRANGE (101, Qlinear_b
);
1768 /* 102: Ancient Greek Numbers. */
1769 SUBRANGE (103, Qugaritic
);
1770 SUBRANGE (104, Qold_persian
);
1771 SUBRANGE (105, Qshavian
);
1772 SUBRANGE (106, Qosmanya
);
1773 SUBRANGE (107, Qcypriot
);
1774 SUBRANGE (108, Qkharoshthi
);
1775 /* 109: Tai Xuan Jing. */
1776 SUBRANGE (110, Qcuneiform
);
1777 /* 111: Counting Rods. */
1779 /* There isn't really a main symbol range, so include symbol if any
1780 relevant range is set. */
1781 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
1783 /* Missing: Tai Viet (U+AA80) and Cham (U+AA00) . */
1790 /* Generate a full name for a Windows font.
1791 The full name is in fcname format, with weight, slant and antialiasing
1792 specified if they are not "normal". */
1794 w32font_full_name (font
, font_obj
, pixel_size
, name
, nbytes
)
1796 Lisp_Object font_obj
;
1801 int len
, height
, outline
;
1803 Lisp_Object antialiasing
, weight
= Qnil
;
1805 len
= strlen (font
->lfFaceName
);
1807 outline
= EQ (AREF (font_obj
, FONT_FOUNDRY_INDEX
), Qoutline
);
1809 /* Represent size of scalable fonts by point size. But use pixelsize for
1810 raster fonts to indicate that they are exactly that size. */
1812 len
+= 11; /* -SIZE */
1814 len
= strlen (font
->lfFaceName
) + 21;
1817 len
+= 7; /* :italic */
1819 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
1821 weight
= FONT_WEIGHT_SYMBOLIC (font_obj
);
1822 len
+= 8 + SBYTES (SYMBOL_NAME (weight
)); /* :weight=NAME */
1825 antialiasing
= lispy_antialias_type (font
->lfQuality
);
1826 if (! NILP (antialiasing
))
1827 len
+= 11 + SBYTES (SYMBOL_NAME (antialiasing
)); /* :antialias=NAME */
1829 /* Check that the buffer is big enough */
1834 p
+= sprintf (p
, "%s", font
->lfFaceName
);
1836 height
= font
->lfHeight
? eabs (font
->lfHeight
) : pixel_size
;
1842 float pointsize
= height
* 72.0 / one_w32_display_info
.resy
;
1843 /* Round to nearest half point. floor is used, since round is not
1844 supported in MS library. */
1845 pointsize
= floor (pointsize
* 2 + 0.5) / 2;
1846 p
+= sprintf (p
, "-%1.1f", pointsize
);
1849 p
+= sprintf (p
, ":pixelsize=%d", height
);
1853 p
+= sprintf (p
, ":italic");
1855 if (SYMBOLP (weight
) && ! NILP (weight
))
1856 p
+= sprintf (p
, ":weight=%s", SDATA (SYMBOL_NAME (weight
)));
1858 if (SYMBOLP (antialiasing
) && ! NILP (antialiasing
))
1859 p
+= sprintf (p
, ":antialias=%s", SDATA (SYMBOL_NAME (antialiasing
)));
1865 static void compute_metrics (dc
, w32_font
, code
, metrics
)
1867 struct w32font_info
*w32_font
;
1869 struct w32_metric_cache
*metrics
;
1873 unsigned int options
= GGO_METRICS
;
1875 if (w32_font
->glyph_idx
)
1876 options
|= GGO_GLYPH_INDEX
;
1878 bzero (&transform
, sizeof (transform
));
1879 transform
.eM11
.value
= 1;
1880 transform
.eM22
.value
= 1;
1882 if (GetGlyphOutlineW (dc
, code
, options
, &gm
, 0, NULL
, &transform
)
1885 metrics
->lbearing
= gm
.gmptGlyphOrigin
.x
;
1886 metrics
->rbearing
= gm
.gmptGlyphOrigin
.x
+ gm
.gmBlackBoxX
;
1887 metrics
->width
= gm
.gmCellIncX
;
1888 metrics
->status
= W32METRIC_SUCCESS
;
1892 if (w32_font
->glyph_idx
)
1894 /* Can't use glyph indexes after all.
1895 Avoid it in future, and clear any metrics that were based on
1897 w32_font
->glyph_idx
= 0;
1898 clear_cached_metrics (w32_font
);
1900 metrics
->status
= W32METRIC_FAIL
;
1905 clear_cached_metrics (w32_font
)
1906 struct w32font_info
*w32_font
;
1909 for (i
= 0; i
< w32_font
->n_cache_blocks
; i
++)
1911 if (w32_font
->cached_metrics
[i
])
1912 bzero (w32_font
->cached_metrics
[i
],
1913 CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
1917 struct font_driver w32font_driver
=
1920 0, /* case insensitive */
1924 w32font_list_family
,
1925 NULL
, /* free_entity */
1928 NULL
, /* prepare_face */
1929 NULL
, /* done_face */
1931 w32font_encode_char
,
1932 w32font_text_extents
,
1934 NULL
, /* get_bitmap */
1935 NULL
, /* free_bitmap */
1936 NULL
, /* get_outline */
1937 NULL
, /* free_outline */
1938 NULL
, /* anchor_point */
1939 NULL
, /* otf_capability */
1940 NULL
, /* otf_drive */
1941 NULL
, /* start_for_frame */
1942 NULL
, /* end_for_frame */
1947 /* Initialize state that does not change between invocations. This is only
1948 called when Emacs is dumped. */
1952 DEFSYM (Qgdi
, "gdi");
1953 DEFSYM (Quniscribe
, "uniscribe");
1954 DEFSYM (QCformat
, ":format");
1956 /* Generic font families. */
1957 DEFSYM (Qmonospace
, "monospace");
1958 DEFSYM (Qserif
, "serif");
1959 DEFSYM (Qsansserif
, "sansserif");
1960 DEFSYM (Qscript
, "script");
1961 DEFSYM (Qdecorative
, "decorative");
1963 DEFSYM (Qsans_serif
, "sans_serif");
1964 DEFSYM (Qsans
, "sans");
1965 DEFSYM (Qmono
, "mono");
1967 /* Fake foundries. */
1968 DEFSYM (Qraster
, "raster");
1969 DEFSYM (Qoutline
, "outline");
1970 DEFSYM (Qunknown
, "unknown");
1973 DEFSYM (Qstandard
, "standard");
1974 DEFSYM (Qsubpixel
, "subpixel");
1975 DEFSYM (Qnatural
, "natural");
1983 DEFSYM (Qlatin
, "latin");
1984 DEFSYM (Qgreek
, "greek");
1985 DEFSYM (Qcoptic
, "coptic");
1986 DEFSYM (Qcyrillic
, "cyrillic");
1987 DEFSYM (Qarmenian
, "armenian");
1988 DEFSYM (Qhebrew
, "hebrew");
1989 DEFSYM (Qarabic
, "arabic");
1990 DEFSYM (Qsyriac
, "syriac");
1991 DEFSYM (Qnko
, "nko");
1992 DEFSYM (Qthaana
, "thaana");
1993 DEFSYM (Qdevanagari
, "devanagari");
1994 DEFSYM (Qbengali
, "bengali");
1995 DEFSYM (Qgurmukhi
, "gurmukhi");
1996 DEFSYM (Qgujarati
, "gujarati");
1997 DEFSYM (Qoriya
, "oriya");
1998 DEFSYM (Qtamil
, "tamil");
1999 DEFSYM (Qtelugu
, "telugu");
2000 DEFSYM (Qkannada
, "kannada");
2001 DEFSYM (Qmalayalam
, "malayalam");
2002 DEFSYM (Qsinhala
, "sinhala");
2003 DEFSYM (Qthai
, "thai");
2004 DEFSYM (Qlao
, "lao");
2005 DEFSYM (Qtibetan
, "tibetan");
2006 DEFSYM (Qmyanmar
, "myanmar");
2007 DEFSYM (Qgeorgian
, "georgian");
2008 DEFSYM (Qhangul
, "hangul");
2009 DEFSYM (Qethiopic
, "ethiopic");
2010 DEFSYM (Qcherokee
, "cherokee");
2011 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
2012 DEFSYM (Qogham
, "ogham");
2013 DEFSYM (Qrunic
, "runic");
2014 DEFSYM (Qkhmer
, "khmer");
2015 DEFSYM (Qmongolian
, "mongolian");
2016 DEFSYM (Qsymbol
, "symbol");
2017 DEFSYM (Qbraille
, "braille");
2018 DEFSYM (Qhan
, "han");
2019 DEFSYM (Qideographic_description
, "ideographic-description");
2020 DEFSYM (Qcjk_misc
, "cjk-misc");
2021 DEFSYM (Qkana
, "kana");
2022 DEFSYM (Qbopomofo
, "bopomofo");
2023 DEFSYM (Qkanbun
, "kanbun");
2025 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
2026 DEFSYM (Qmusical_symbol
, "musical-symbol");
2027 DEFSYM (Qmathematical
, "mathematical");
2028 DEFSYM (Qphonetic
, "phonetic");
2029 DEFSYM (Qbalinese
, "balinese");
2030 DEFSYM (Qbuginese
, "buginese");
2031 DEFSYM (Qbuhid
, "buhid");
2032 DEFSYM (Qcuneiform
, "cuneiform");
2033 DEFSYM (Qcypriot
, "cypriot");
2034 DEFSYM (Qdeseret
, "deseret");
2035 DEFSYM (Qglagolitic
, "glagolitic");
2036 DEFSYM (Qgothic
, "gothic");
2037 DEFSYM (Qhanunoo
, "hanunoo");
2038 DEFSYM (Qkharoshthi
, "kharoshthi");
2039 DEFSYM (Qlimbu
, "limbu");
2040 DEFSYM (Qlinear_b
, "linear_b");
2041 DEFSYM (Qold_italic
, "old_italic");
2042 DEFSYM (Qold_persian
, "old_persian");
2043 DEFSYM (Qosmanya
, "osmanya");
2044 DEFSYM (Qphags_pa
, "phags-pa");
2045 DEFSYM (Qphoenician
, "phoenician");
2046 DEFSYM (Qshavian
, "shavian");
2047 DEFSYM (Qsyloti_nagri
, "syloti_nagri");
2048 DEFSYM (Qtagalog
, "tagalog");
2049 DEFSYM (Qtagbanwa
, "tagbanwa");
2050 DEFSYM (Qtai_le
, "tai_le");
2051 DEFSYM (Qtifinagh
, "tifinagh");
2052 DEFSYM (Qugaritic
, "ugaritic");
2054 w32font_driver
.type
= Qgdi
;
2055 register_font_driver (&w32font_driver
, NULL
);
2058 /* arch-tag: 65b8a3cd-46aa-4c0d-a1f3-99e75b9c07ee
2059 (do not change this comment) */