1 /* Font backend for the Microsoft W32 API.
2 Copyright (C) 2007-2011 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/>. */
29 #include "dispextern.h"
30 #include "character.h"
37 /* Cleartype available on Windows XP, cleartype_natural from XP SP1.
38 The latter does not try to fit cleartype smoothed fonts into the
39 same bounding box as the non-antialiased version of the font.
41 #ifndef CLEARTYPE_QUALITY
42 #define CLEARTYPE_QUALITY 5
44 #ifndef CLEARTYPE_NATURAL_QUALITY
45 #define CLEARTYPE_NATURAL_QUALITY 6
48 /* VIETNAMESE_CHARSET and JOHAB_CHARSET are not defined in some versions
50 #ifndef VIETNAMESE_CHARSET
51 #define VIETNAMESE_CHARSET 163
54 #define JOHAB_CHARSET 130
58 Lisp_Object Quniscribe
;
59 static Lisp_Object QCformat
;
60 static Lisp_Object Qmonospace
, Qsansserif
, Qmono
, Qsans
, Qsans_serif
;
61 static Lisp_Object Qserif
, Qscript
, Qdecorative
;
62 static Lisp_Object Qraster
, Qoutline
, Qunknown
;
65 extern Lisp_Object Qnone
; /* reuse from w32fns.c */
66 static Lisp_Object Qstandard
, Qsubpixel
, Qnatural
;
69 static Lisp_Object Qzh
;
72 static Lisp_Object Qgreek
, Qcoptic
, Qcyrillic
, Qarmenian
, Qhebrew
;
73 static Lisp_Object Qarabic
, Qsyriac
, Qnko
, Qthaana
, Qdevanagari
, Qbengali
;
74 static Lisp_Object Qgurmukhi
, Qgujarati
, Qoriya
, Qtamil
, Qtelugu
;
75 static Lisp_Object Qkannada
, Qmalayalam
, Qsinhala
, Qthai
, Qlao
;
76 static Lisp_Object Qtibetan
, Qmyanmar
, Qgeorgian
, Qhangul
, Qethiopic
;
77 static Lisp_Object Qcherokee
, Qcanadian_aboriginal
, Qogham
, Qrunic
;
78 static Lisp_Object Qkhmer
, Qmongolian
, Qsymbol
, Qbraille
, Qhan
;
79 static Lisp_Object Qideographic_description
, Qcjk_misc
, Qkana
, Qbopomofo
;
80 static Lisp_Object Qkanbun
, Qyi
, Qbyzantine_musical_symbol
;
81 static Lisp_Object Qmusical_symbol
, Qmathematical
, Qcham
, Qphonetic
;
82 /* Not defined in characters.el, but referenced in fontset.el. */
83 static Lisp_Object Qbalinese
, Qbuginese
, Qbuhid
, Qcuneiform
, Qcypriot
;
84 static Lisp_Object Qdeseret
, Qglagolitic
, Qgothic
, Qhanunoo
, Qkharoshthi
;
85 static Lisp_Object Qlimbu
, Qlinear_b
, Qold_italic
, Qold_persian
, Qosmanya
;
86 static Lisp_Object Qphags_pa
, Qphoenician
, Qshavian
, Qsyloti_nagri
;
87 static Lisp_Object Qtagalog
, Qtagbanwa
, Qtai_le
, Qtifinagh
, Qugaritic
;
89 /* W32 charsets: for use in Vw32_charset_info_alist. */
90 static Lisp_Object Qw32_charset_ansi
, Qw32_charset_default
;
91 static Lisp_Object Qw32_charset_symbol
, Qw32_charset_shiftjis
;
92 static Lisp_Object Qw32_charset_hangeul
, Qw32_charset_gb2312
;
93 static Lisp_Object Qw32_charset_chinesebig5
, Qw32_charset_oem
;
94 static Lisp_Object Qw32_charset_easteurope
, Qw32_charset_turkish
;
95 static Lisp_Object Qw32_charset_baltic
, Qw32_charset_russian
;
96 static Lisp_Object Qw32_charset_arabic
, Qw32_charset_greek
;
97 static Lisp_Object Qw32_charset_hebrew
, Qw32_charset_vietnamese
;
98 static Lisp_Object Qw32_charset_thai
, Qw32_charset_johab
, Qw32_charset_mac
;
100 /* Font spacing symbols - defined in font.c. */
101 extern Lisp_Object Qc
, Qp
, Qm
;
103 static void fill_in_logfont (FRAME_PTR
, LOGFONT
*, Lisp_Object
);
105 static BYTE
w32_antialias_type (Lisp_Object
);
106 static Lisp_Object
lispy_antialias_type (BYTE
);
108 static Lisp_Object
font_supported_scripts (FONTSIGNATURE
*);
109 static int w32font_full_name (LOGFONT
*, Lisp_Object
, int, char *, int);
110 static void compute_metrics (HDC
, struct w32font_info
*, unsigned int,
111 struct w32_metric_cache
*);
113 static Lisp_Object
w32_registry (LONG
, DWORD
);
115 /* EnumFontFamiliesEx callbacks. */
116 static int CALLBACK
add_font_entity_to_list (ENUMLOGFONTEX
*,
119 static int CALLBACK
add_one_font_entity_to_list (ENUMLOGFONTEX
*,
122 static int CALLBACK
add_font_name_to_list (ENUMLOGFONTEX
*,
126 /* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
127 of what we really want. */
128 struct font_callback_data
130 /* The logfont we are matching against. EnumFontFamiliesEx only matches
131 face name and charset, so we need to manually match everything else
132 in the callback function. */
134 /* The original font spec or entity. */
135 Lisp_Object orig_font_spec
;
136 /* The frame the font is being loaded on. */
138 /* The list to add matches to. */
140 /* Whether to match only opentype fonts. */
144 /* Handles the problem that EnumFontFamiliesEx will not return all
145 style variations if the font name is not specified. */
146 static void list_all_matching_fonts (struct font_callback_data
*);
150 memq_no_quit (Lisp_Object elt
, Lisp_Object list
)
152 while (CONSP (list
) && ! EQ (XCAR (list
), elt
))
154 return (CONSP (list
));
158 intern_font_name (char * string
)
160 Lisp_Object obarray
, tem
, str
;
163 str
= DECODE_SYSTEM (build_string (string
));
166 /* The following code is copied from the function intern (in lread.c). */
168 if (!VECTORP (obarray
) || XVECTOR (obarray
)->size
== 0)
169 obarray
= check_obarray (obarray
);
170 tem
= oblookup (obarray
, SDATA (str
), len
, len
);
173 return Fintern (str
, obarray
);
176 /* w32 implementation of get_cache for font backend.
177 Return a cache of font-entities on FRAME. The cache must be a
178 cons whose cdr part is the actual cache area. */
180 w32font_get_cache (FRAME_PTR f
)
182 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
184 return (dpyinfo
->name_list_element
);
187 /* w32 implementation of list for font backend.
188 List fonts exactly matching with FONT_SPEC on FRAME. The value
189 is a vector of font-entities. This is the sole API that
190 allocates font-entities. */
192 w32font_list (Lisp_Object frame
, Lisp_Object font_spec
)
194 Lisp_Object fonts
= w32font_list_internal (frame
, font_spec
, 0);
195 FONT_ADD_LOG ("w32font-list", font_spec
, fonts
);
199 /* w32 implementation of match for font backend.
200 Return a font entity most closely matching with FONT_SPEC on
201 FRAME. The closeness is detemined by the font backend, thus
202 `face-font-selection-order' is ignored here. */
204 w32font_match (Lisp_Object frame
, Lisp_Object font_spec
)
206 Lisp_Object entity
= w32font_match_internal (frame
, font_spec
, 0);
207 FONT_ADD_LOG ("w32font-match", font_spec
, entity
);
211 /* w32 implementation of list_family for font backend.
212 List available families. The value is a list of family names
215 w32font_list_family (Lisp_Object frame
)
217 Lisp_Object list
= Qnil
;
218 LOGFONT font_match_pattern
;
220 FRAME_PTR f
= XFRAME (frame
);
222 memset (&font_match_pattern
, 0, sizeof (font_match_pattern
));
223 font_match_pattern
.lfCharSet
= DEFAULT_CHARSET
;
225 dc
= get_frame_dc (f
);
227 EnumFontFamiliesEx (dc
, &font_match_pattern
,
228 (FONTENUMPROC
) add_font_name_to_list
,
230 release_frame_dc (f
, dc
);
235 /* w32 implementation of open for font backend.
236 Open a font specified by FONT_ENTITY on frame F.
237 If the font is scalable, open it with PIXEL_SIZE. */
239 w32font_open (FRAME_PTR f
, Lisp_Object font_entity
, int pixel_size
)
241 Lisp_Object font_object
242 = font_make_object (VECSIZE (struct w32font_info
),
243 font_entity
, pixel_size
);
244 struct w32font_info
*w32_font
245 = (struct w32font_info
*) XFONT_OBJECT (font_object
);
247 ASET (font_object
, FONT_TYPE_INDEX
, Qgdi
);
249 if (!w32font_open_internal (f
, font_entity
, pixel_size
, font_object
))
254 /* GDI backend does not use glyph indices. */
255 w32_font
->glyph_idx
= 0;
260 /* w32 implementation of close for font_backend.
261 Close FONT on frame F. */
263 w32font_close (FRAME_PTR f
, struct font
*font
)
266 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
268 /* Delete the GDI font object. */
269 DeleteObject (w32_font
->hfont
);
271 /* Free all the cached metrics. */
272 if (w32_font
->cached_metrics
)
274 for (i
= 0; i
< w32_font
->n_cache_blocks
; i
++)
276 xfree (w32_font
->cached_metrics
[i
]);
278 xfree (w32_font
->cached_metrics
);
279 w32_font
->cached_metrics
= NULL
;
283 /* w32 implementation of has_char for font backend.
285 If FONT_ENTITY has a glyph for character C (Unicode code point),
286 return 1. If not, return 0. If a font must be opened to check
289 w32font_has_char (Lisp_Object entity
, int c
)
291 /* We can't be certain about which characters a font will support until
292 we open it. Checking the scripts that the font supports turns out
293 to not be reliable. */
297 Lisp_Object supported_scripts
, extra
, script
;
300 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
304 supported_scripts
= assq_no_quit (QCscript
, extra
);
305 /* If font doesn't claim to support any scripts, then we can't be certain
307 if (!CONSP (supported_scripts
))
310 supported_scripts
= XCDR (supported_scripts
);
312 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
314 /* If we don't know what script the character is from, then we can't be
315 certain until we open it. Also if the font claims support for the script
316 the character is from, it may only have partial coverage, so we still
317 can't be certain until we open the font. */
318 if (NILP (script
) || memq_no_quit (script
, supported_scripts
))
321 /* Font reports what scripts it supports, and none of them are the script
322 the character is from. But we still can't be certain, as some fonts
323 will contain some/most/all of the characters in that script without
324 claiming support for it. */
329 /* w32 implementation of encode_char for font backend.
330 Return a glyph code of FONT for character C (Unicode code point).
331 If FONT doesn't have such a glyph, return FONT_INVALID_CODE.
333 For speed, the gdi backend uses unicode (Emacs calls encode_char
334 far too often for it to be efficient). But we still need to detect
335 which characters are not supported by the font.
338 w32font_encode_char (struct font
*font
, int c
)
340 struct w32font_info
* w32_font
= (struct w32font_info
*)font
;
342 if (c
< w32_font
->metrics
.tmFirstChar
343 || c
> w32_font
->metrics
.tmLastChar
)
344 return FONT_INVALID_CODE
;
349 /* w32 implementation of text_extents for font backend.
350 Perform the size computation of glyphs of FONT and fillin members
351 of METRICS. The glyphs are specified by their glyph codes in
352 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
353 case just return the overall width. */
355 w32font_text_extents (struct font
*font
, unsigned *code
,
356 int nglyphs
, struct font_metrics
*metrics
)
359 HFONT old_font
= NULL
;
366 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
370 memset (metrics
, 0, sizeof (struct font_metrics
));
371 metrics
->ascent
= font
->ascent
;
372 metrics
->descent
= font
->descent
;
374 for (i
= 0; i
< nglyphs
; i
++)
376 struct w32_metric_cache
*char_metric
;
377 int block
= *(code
+ i
) / CACHE_BLOCKSIZE
;
378 int pos_in_block
= *(code
+ i
) % CACHE_BLOCKSIZE
;
380 if (block
>= w32_font
->n_cache_blocks
)
382 if (!w32_font
->cached_metrics
)
383 w32_font
->cached_metrics
384 = xmalloc ((block
+ 1)
385 * sizeof (struct w32_metric_cache
*));
387 w32_font
->cached_metrics
388 = xrealloc (w32_font
->cached_metrics
,
390 * sizeof (struct w32_metric_cache
*));
391 memset (w32_font
->cached_metrics
+ w32_font
->n_cache_blocks
, 0,
392 ((block
+ 1 - w32_font
->n_cache_blocks
)
393 * sizeof (struct w32_metric_cache
*)));
394 w32_font
->n_cache_blocks
= block
+ 1;
397 if (!w32_font
->cached_metrics
[block
])
399 w32_font
->cached_metrics
[block
]
400 = xmalloc (CACHE_BLOCKSIZE
* sizeof (struct w32_metric_cache
));
401 memset (w32_font
->cached_metrics
[block
], 0,
402 CACHE_BLOCKSIZE
* sizeof (struct w32_metric_cache
));
405 char_metric
= w32_font
->cached_metrics
[block
] + pos_in_block
;
407 if (char_metric
->status
== W32METRIC_NO_ATTEMPT
)
411 /* TODO: Frames can come and go, and their fonts
412 outlive them. So we can't cache the frame in the
413 font structure. Use selected_frame until the API
414 is updated to pass in a frame. */
415 f
= XFRAME (selected_frame
);
417 dc
= get_frame_dc (f
);
418 old_font
= SelectObject (dc
, w32_font
->hfont
);
420 compute_metrics (dc
, w32_font
, *(code
+ i
), char_metric
);
423 if (char_metric
->status
== W32METRIC_SUCCESS
)
425 metrics
->lbearing
= min (metrics
->lbearing
,
426 metrics
->width
+ char_metric
->lbearing
);
427 metrics
->rbearing
= max (metrics
->rbearing
,
428 metrics
->width
+ char_metric
->rbearing
);
429 metrics
->width
+= char_metric
->width
;
432 /* If we couldn't get metrics for a char,
433 use alternative method. */
436 /* If we got through everything, return. */
441 /* Restore state and release DC. */
442 SelectObject (dc
, old_font
);
443 release_frame_dc (f
, dc
);
446 return metrics
->width
;
450 /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
451 fallback on other methods that will at least give some of the metric
454 /* Make array big enough to hold surrogates. */
455 wcode
= alloca (nglyphs
* sizeof (WORD
) * 2);
456 for (i
= 0; i
< nglyphs
; i
++)
458 if (code
[i
] < 0x10000)
462 DWORD surrogate
= code
[i
] - 0x10000;
464 /* High surrogate: U+D800 - U+DBFF. */
465 wcode
[i
++] = 0xD800 + ((surrogate
>> 10) & 0x03FF);
466 /* Low surrogate: U+DC00 - U+DFFF. */
467 wcode
[i
] = 0xDC00 + (surrogate
& 0x03FF);
468 /* An extra glyph. wcode is already double the size of code to
476 /* TODO: Frames can come and go, and their fonts outlive
477 them. So we can't cache the frame in the font structure. Use
478 selected_frame until the API is updated to pass in a
480 f
= XFRAME (selected_frame
);
482 dc
= get_frame_dc (f
);
483 old_font
= SelectObject (dc
, w32_font
->hfont
);
486 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
488 total_width
= size
.cx
;
491 /* On 95/98/ME, only some unicode functions are available, so fallback
492 on doing a dummy draw to find the total width. */
496 rect
.top
= 0; rect
.bottom
= font
->height
; rect
.left
= 0; rect
.right
= 1;
497 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
498 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
499 total_width
= rect
.right
;
502 /* Give our best estimate of the metrics, based on what we know. */
505 metrics
->width
= total_width
- w32_font
->metrics
.tmOverhang
;
506 metrics
->lbearing
= 0;
507 metrics
->rbearing
= total_width
;
510 /* Restore state and release DC. */
511 SelectObject (dc
, old_font
);
512 release_frame_dc (f
, dc
);
517 /* w32 implementation of draw for font backend.
519 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
520 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
521 is nonzero, fill the background in advance. It is assured that
522 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
524 TODO: Currently this assumes that the colors and fonts are already
525 set in the DC. This seems to be true now, but maybe only due to
526 the old font code setting it up. It may be safer to resolve faces
527 and fonts in here and set them explicitly
531 w32font_draw (struct glyph_string
*s
, int from
, int to
,
532 int x
, int y
, int with_background
)
535 HRGN orig_clip
= NULL
;
536 struct w32font_info
*w32font
= (struct w32font_info
*) s
->font
;
538 options
= w32font
->glyph_idx
;
540 if (s
->num_clips
> 0)
542 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
544 /* Save clip region for later restoration. */
545 orig_clip
= CreateRectRgn (0, 0, 0, 0);
546 if (!GetClipRgn (s
->hdc
, orig_clip
))
548 DeleteObject (orig_clip
);
552 if (s
->num_clips
> 1)
554 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
556 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
557 DeleteObject (clip2
);
560 SelectClipRgn (s
->hdc
, new_clip
);
561 DeleteObject (new_clip
);
564 /* Using OPAQUE background mode can clear more background than expected
565 when Cleartype is used. Draw the background manually to avoid this. */
566 SetBkMode (s
->hdc
, TRANSPARENT
);
571 struct font
*font
= s
->font
;
573 brush
= CreateSolidBrush (s
->gc
->background
);
575 rect
.top
= y
- font
->ascent
;
576 rect
.right
= x
+ s
->width
;
577 rect
.bottom
= y
+ font
->descent
;
578 FillRect (s
->hdc
, &rect
, brush
);
579 DeleteObject (brush
);
584 int len
= to
- from
, i
;
586 for (i
= 0; i
< len
; i
++)
587 ExtTextOutW (s
->hdc
, x
+ i
, y
, options
, NULL
,
588 s
->char2b
+ from
+ i
, 1, NULL
);
591 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, to
- from
, NULL
);
593 /* Restore clip region. */
594 if (s
->num_clips
> 0)
595 SelectClipRgn (s
->hdc
, orig_clip
);
598 DeleteObject (orig_clip
);
601 /* w32 implementation of free_entity for font backend.
602 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
603 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
605 w32font_free_entity (Lisp_Object entity);
608 /* w32 implementation of prepare_face for font backend.
609 Optional (if FACE->extra is not used).
610 Prepare FACE for displaying characters by FONT on frame F by
611 storing some data in FACE->extra. If successful, return 0.
612 Otherwise, return -1.
614 w32font_prepare_face (FRAME_PTR f, struct face *face);
616 /* w32 implementation of done_face for font backend.
618 Done FACE for displaying characters by FACE->font on frame F.
620 w32font_done_face (FRAME_PTR f, struct face *face); */
622 /* w32 implementation of get_bitmap for font backend.
624 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
625 intended that this method is called from the other font-driver
628 w32font_get_bitmap (struct font *font, unsigned code,
629 struct font_bitmap *bitmap, int bits_per_pixel);
631 /* w32 implementation of free_bitmap for font backend.
633 Free bitmap data in BITMAP.
635 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
637 /* w32 implementation of get_outline for font backend.
639 Return an outline data for glyph-code CODE of FONT. The format
640 of the outline data depends on the font-driver.
642 w32font_get_outline (struct font *font, unsigned code);
644 /* w32 implementation of free_outline for font backend.
646 Free OUTLINE (that is obtained by the above method).
648 w32font_free_outline (struct font *font, void *outline);
650 /* w32 implementation of anchor_point for font backend.
652 Get coordinates of the INDEXth anchor point of the glyph whose
653 code is CODE. Store the coordinates in *X and *Y. Return 0 if
654 the operations was successfull. Otherwise return -1.
656 w32font_anchor_point (struct font *font, unsigned code,
657 int index, int *x, int *y);
659 /* w32 implementation of otf_capability for font backend.
661 Return a list describing which scripts/languages FONT
662 supports by which GSUB/GPOS features of OpenType tables.
664 w32font_otf_capability (struct font *font);
666 /* w32 implementation of otf_drive for font backend.
668 Apply FONT's OTF-FEATURES to the glyph string.
670 FEATURES specifies which OTF features to apply in this format:
671 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
672 See the documentation of `font-drive-otf' for the detail.
674 This method applies the specified features to the codes in the
675 elements of GSTRING-IN (between FROMth and TOth). The output
676 codes are stored in GSTRING-OUT at the IDXth element and the
679 Return the number of output codes. If none of the features are
680 applicable to the input data, return 0. If GSTRING-OUT is too
683 w32font_otf_drive (struct font *font, Lisp_Object features,
684 Lisp_Object gstring_in, int from, int to,
685 Lisp_Object gstring_out, int idx,
686 int alternate_subst);
689 /* Internal implementation of w32font_list.
690 Additional parameter opentype_only restricts the returned fonts to
691 opentype fonts, which can be used with the Uniscribe backend. */
693 w32font_list_internal (Lisp_Object frame
, Lisp_Object font_spec
, int opentype_only
)
695 struct font_callback_data match_data
;
697 FRAME_PTR f
= XFRAME (frame
);
699 match_data
.orig_font_spec
= font_spec
;
700 match_data
.list
= Qnil
;
701 match_data
.frame
= frame
;
703 memset (&match_data
.pattern
, 0, sizeof (LOGFONT
));
704 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
706 /* If the charset is unrecognized, then we won't find a font, so don't
707 waste time looking for one. */
708 if (match_data
.pattern
.lfCharSet
== DEFAULT_CHARSET
)
710 Lisp_Object spec_charset
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
711 if (!NILP (spec_charset
)
712 && !EQ (spec_charset
, Qiso10646_1
)
713 && !EQ (spec_charset
, Qunicode_bmp
)
714 && !EQ (spec_charset
, Qunicode_sip
)
715 && !EQ (spec_charset
, Qunknown
))
719 match_data
.opentype_only
= opentype_only
;
721 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
723 if (match_data
.pattern
.lfFaceName
[0] == '\0')
725 /* EnumFontFamiliesEx does not take other fields into account if
726 font name is blank, so need to use two passes. */
727 list_all_matching_fonts (&match_data
);
731 dc
= get_frame_dc (f
);
733 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
734 (FONTENUMPROC
) add_font_entity_to_list
,
735 (LPARAM
) &match_data
, 0);
736 release_frame_dc (f
, dc
);
739 return match_data
.list
;
742 /* Internal implementation of w32font_match.
743 Additional parameter opentype_only restricts the returned fonts to
744 opentype fonts, which can be used with the Uniscribe backend. */
746 w32font_match_internal (Lisp_Object frame
, Lisp_Object font_spec
, int opentype_only
)
748 struct font_callback_data match_data
;
750 FRAME_PTR f
= XFRAME (frame
);
752 match_data
.orig_font_spec
= font_spec
;
753 match_data
.frame
= frame
;
754 match_data
.list
= Qnil
;
756 memset (&match_data
.pattern
, 0, sizeof (LOGFONT
));
757 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
759 match_data
.opentype_only
= opentype_only
;
761 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
763 dc
= get_frame_dc (f
);
765 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
766 (FONTENUMPROC
) add_one_font_entity_to_list
,
767 (LPARAM
) &match_data
, 0);
768 release_frame_dc (f
, dc
);
770 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
774 w32font_open_internal (FRAME_PTR f
, Lisp_Object font_entity
,
775 int pixel_size
, Lisp_Object font_object
)
780 HFONT hfont
, old_font
;
781 Lisp_Object val
, extra
;
782 struct w32font_info
*w32_font
;
784 OUTLINETEXTMETRICW
* metrics
= NULL
;
786 w32_font
= (struct w32font_info
*) XFONT_OBJECT (font_object
);
787 font
= (struct font
*) w32_font
;
792 memset (&logfont
, 0, sizeof (logfont
));
793 fill_in_logfont (f
, &logfont
, font_entity
);
795 /* Prefer truetype fonts, to avoid known problems with type1 fonts, and
796 limitations in bitmap fonts. */
797 val
= AREF (font_entity
, FONT_FOUNDRY_INDEX
);
798 if (!EQ (val
, Qraster
))
799 logfont
.lfOutPrecision
= OUT_TT_PRECIS
;
801 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
805 logfont
.lfHeight
= -size
;
806 hfont
= CreateFontIndirect (&logfont
);
811 /* Get the metrics for this font. */
812 dc
= get_frame_dc (f
);
813 old_font
= SelectObject (dc
, hfont
);
815 /* Try getting the outline metrics (only works for truetype fonts). */
816 len
= GetOutlineTextMetricsW (dc
, 0, NULL
);
819 metrics
= (OUTLINETEXTMETRICW
*) alloca (len
);
820 if (GetOutlineTextMetricsW (dc
, len
, metrics
))
821 memcpy (&w32_font
->metrics
, &metrics
->otmTextMetrics
,
822 sizeof (TEXTMETRICW
));
828 GetTextMetricsW (dc
, &w32_font
->metrics
);
830 w32_font
->cached_metrics
= NULL
;
831 w32_font
->n_cache_blocks
= 0;
833 SelectObject (dc
, old_font
);
834 release_frame_dc (f
, dc
);
836 w32_font
->hfont
= hfont
;
841 /* We don't know how much space we need for the full name, so start with
842 96 bytes and go up in steps of 32. */
845 while (name
&& w32font_full_name (&logfont
, font_entity
, pixel_size
,
852 font
->props
[FONT_FULLNAME_INDEX
]
853 = DECODE_SYSTEM (build_string (name
));
855 font
->props
[FONT_FULLNAME_INDEX
]
856 = DECODE_SYSTEM (build_string (logfont
.lfFaceName
));
859 font
->max_width
= w32_font
->metrics
.tmMaxCharWidth
;
860 /* Parts of Emacs display assume that height = ascent + descent...
861 so height is defined later, after ascent and descent.
862 font->height = w32_font->metrics.tmHeight
863 + w32_font->metrics.tmExternalLeading;
866 font
->space_width
= font
->average_width
= w32_font
->metrics
.tmAveCharWidth
;
868 font
->vertical_centering
= 0;
869 font
->encoding_type
= 0;
870 font
->baseline_offset
= 0;
871 font
->relative_compose
= 0;
872 font
->default_ascent
= w32_font
->metrics
.tmAscent
;
873 font
->font_encoder
= NULL
;
874 font
->pixel_size
= size
;
875 font
->driver
= &w32font_driver
;
876 /* Use format cached during list, as the information we have access to
877 here is incomplete. */
878 extra
= AREF (font_entity
, FONT_EXTRA_INDEX
);
881 val
= assq_no_quit (QCformat
, extra
);
883 font
->props
[FONT_FORMAT_INDEX
] = XCDR (val
);
885 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
888 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
890 font
->props
[FONT_FILE_INDEX
] = Qnil
;
891 font
->encoding_charset
= -1;
892 font
->repertory_charset
= -1;
893 /* TODO: do we really want the minimum width here, which could be negative? */
894 font
->min_width
= font
->space_width
;
895 font
->ascent
= w32_font
->metrics
.tmAscent
;
896 font
->descent
= w32_font
->metrics
.tmDescent
;
897 font
->height
= font
->ascent
+ font
->descent
;
901 font
->underline_thickness
= metrics
->otmsUnderscoreSize
;
902 font
->underline_position
= -metrics
->otmsUnderscorePosition
;
906 font
->underline_thickness
= 0;
907 font
->underline_position
= -1;
910 /* For temporary compatibility with legacy code that expects the
911 name to be usable in x-list-fonts. Eventually we expect to change
912 x-list-fonts and other places that use fonts so that this can be
913 an fcname or similar. */
914 font
->props
[FONT_NAME_INDEX
] = Ffont_xlfd_name (font_object
, Qnil
);
919 /* Callback function for EnumFontFamiliesEx.
920 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
922 add_font_name_to_list (ENUMLOGFONTEX
*logical_font
,
923 NEWTEXTMETRICEX
*physical_font
,
924 DWORD font_type
, LPARAM list_object
)
926 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
929 /* Skip vertical fonts (intended only for printing) */
930 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
933 family
= intern_font_name (logical_font
->elfLogFont
.lfFaceName
);
934 if (! memq_no_quit (family
, *list
))
935 *list
= Fcons (family
, *list
);
940 static int w32_decode_weight (int);
941 static int w32_encode_weight (int);
943 /* Convert an enumerated Windows font to an Emacs font entity. */
945 w32_enumfont_pattern_entity (Lisp_Object frame
,
946 ENUMLOGFONTEX
*logical_font
,
947 NEWTEXTMETRICEX
*physical_font
,
949 LOGFONT
*requested_font
,
952 Lisp_Object entity
, tem
;
953 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
955 DWORD full_type
= physical_font
->ntmTm
.ntmFlags
;
957 entity
= font_make_entity ();
959 ASET (entity
, FONT_TYPE_INDEX
, backend
);
960 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
, font_type
));
961 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
963 /* Foundry is difficult to get in readable form on Windows.
964 But Emacs crashes if it is not set, so set it to something more
965 generic. These values make xlfds compatible with Emacs 22. */
966 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
968 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
973 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
975 /* Save the generic family in the extra info, as it is likely to be
976 useful to users looking for a close match. */
977 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
978 if (generic_type
== FF_DECORATIVE
)
980 else if (generic_type
== FF_MODERN
)
982 else if (generic_type
== FF_ROMAN
)
984 else if (generic_type
== FF_SCRIPT
)
986 else if (generic_type
== FF_SWISS
)
991 ASET (entity
, FONT_ADSTYLE_INDEX
, tem
);
993 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
994 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_PROPORTIONAL
));
996 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_CHARCELL
));
998 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
1000 font_put_extra (entity
, QCantialias
,
1001 lispy_antialias_type (requested_font
->lfQuality
));
1003 ASET (entity
, FONT_FAMILY_INDEX
,
1004 intern_font_name (lf
->lfFaceName
));
1006 FONT_SET_STYLE (entity
, FONT_WEIGHT_INDEX
,
1007 make_number (w32_decode_weight (lf
->lfWeight
)));
1008 FONT_SET_STYLE (entity
, FONT_SLANT_INDEX
,
1009 make_number (lf
->lfItalic
? 200 : 100));
1010 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
1012 FONT_SET_STYLE (entity
, FONT_WIDTH_INDEX
, make_number (100));
1014 if (font_type
& RASTER_FONTTYPE
)
1015 ASET (entity
, FONT_SIZE_INDEX
,
1016 make_number (physical_font
->ntmTm
.tmHeight
1017 + physical_font
->ntmTm
.tmExternalLeading
));
1019 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
1021 /* Cache unicode codepoints covered by this font, as there is no other way
1022 of getting this information easily. */
1023 if (font_type
& TRUETYPE_FONTTYPE
)
1025 tem
= font_supported_scripts (&physical_font
->ntmFontSig
);
1027 font_put_extra (entity
, QCscript
, tem
);
1030 /* This information is not fully available when opening fonts, so
1031 save it here. Only Windows 2000 and later return information
1032 about opentype and type1 fonts, so need a fallback for detecting
1033 truetype so that this information is not any worse than we could
1034 have obtained later. */
1035 if (EQ (backend
, Quniscribe
) && (full_type
& NTMFLAGS_OPENTYPE
))
1036 tem
= intern ("opentype");
1037 else if (font_type
& TRUETYPE_FONTTYPE
)
1038 tem
= intern ("truetype");
1039 else if (full_type
& NTM_PS_OPENTYPE
)
1040 tem
= intern ("postscript");
1041 else if (full_type
& NTM_TYPE1
)
1042 tem
= intern ("type1");
1043 else if (font_type
& RASTER_FONTTYPE
)
1044 tem
= intern ("w32bitmap");
1046 tem
= intern ("w32vector");
1048 font_put_extra (entity
, QCformat
, tem
);
1054 /* Convert generic families to the family portion of lfPitchAndFamily. */
1056 w32_generic_family (Lisp_Object name
)
1058 /* Generic families. */
1059 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
1061 else if (EQ (name
, Qsans
) || EQ (name
, Qsans_serif
) || EQ (name
, Qsansserif
))
1063 else if (EQ (name
, Qserif
))
1065 else if (EQ (name
, Qdecorative
))
1066 return FF_DECORATIVE
;
1067 else if (EQ (name
, Qscript
))
1074 logfonts_match (LOGFONT
*font
, LOGFONT
*pattern
)
1076 /* Only check height for raster fonts. */
1077 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
1078 && font
->lfHeight
!= pattern
->lfHeight
)
1081 /* Have some flexibility with weights. */
1082 if (pattern
->lfWeight
1083 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
1084 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
1087 /* Charset and face should be OK. Italic has to be checked
1088 against the original spec, in case we don't have any preference. */
1092 /* Codepage Bitfields in FONTSIGNATURE struct. */
1093 #define CSB_JAPANESE (1 << 17)
1094 #define CSB_KOREAN ((1 << 19) | (1 << 21))
1095 #define CSB_CHINESE ((1 << 18) | (1 << 20))
1098 font_matches_spec (DWORD type
, NEWTEXTMETRICEX
*font
,
1099 Lisp_Object spec
, Lisp_Object backend
,
1102 Lisp_Object extra
, val
;
1104 /* Check italic. Can't check logfonts, since it is a boolean field,
1105 so there is no difference between "non-italic" and "don't care". */
1107 int slant
= FONT_SLANT_NUMERIC (spec
);
1110 && ((slant
> 150 && !font
->ntmTm
.tmItalic
)
1111 || (slant
<= 150 && font
->ntmTm
.tmItalic
)))
1115 /* Check adstyle against generic family. */
1116 val
= AREF (spec
, FONT_ADSTYLE_INDEX
);
1119 BYTE family
= w32_generic_family (val
);
1120 if (family
!= FF_DONTCARE
1121 && family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
1126 val
= AREF (spec
, FONT_SPACING_INDEX
);
1129 int spacing
= XINT (val
);
1130 int proportional
= (spacing
< FONT_SPACING_MONO
);
1132 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
1133 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
1137 /* Check extra parameters. */
1138 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
1139 CONSP (extra
); extra
= XCDR (extra
))
1141 Lisp_Object extra_entry
;
1142 extra_entry
= XCAR (extra
);
1143 if (CONSP (extra_entry
))
1145 Lisp_Object key
= XCAR (extra_entry
);
1147 val
= XCDR (extra_entry
);
1148 if (EQ (key
, QCscript
) && SYMBOLP (val
))
1150 /* Only truetype fonts will have information about what
1151 scripts they support. This probably means the user
1152 will have to force Emacs to use raster, postscript
1153 or atm fonts for non-ASCII text. */
1154 if (type
& TRUETYPE_FONTTYPE
)
1157 = font_supported_scripts (&font
->ntmFontSig
);
1158 if (! memq_no_quit (val
, support
))
1163 /* Return specific matches, but play it safe. Fonts
1164 that cover more than their charset would suggest
1165 are likely to be truetype or opentype fonts,
1167 if (EQ (val
, Qlatin
))
1169 /* Although every charset but symbol, thai and
1170 arabic contains the basic ASCII set of latin
1171 characters, Emacs expects much more. */
1172 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
1175 else if (EQ (val
, Qsymbol
))
1177 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
1180 else if (EQ (val
, Qcyrillic
))
1182 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
1185 else if (EQ (val
, Qgreek
))
1187 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
1190 else if (EQ (val
, Qarabic
))
1192 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
1195 else if (EQ (val
, Qhebrew
))
1197 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
1200 else if (EQ (val
, Qthai
))
1202 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
1205 else if (EQ (val
, Qkana
))
1207 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1210 else if (EQ (val
, Qbopomofo
))
1212 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1215 else if (EQ (val
, Qhangul
))
1217 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1218 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1221 else if (EQ (val
, Qhan
))
1223 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
1224 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1225 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1226 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
1227 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1231 /* Other scripts unlikely to be handled by non-truetype
1236 else if (EQ (key
, QClang
) && SYMBOLP (val
))
1238 /* Just handle the CJK languages here, as the lang
1239 parameter is used to select a font with appropriate
1240 glyphs in the cjk unified ideographs block. Other fonts
1241 support for a language can be solely determined by
1242 its character coverage. */
1245 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_JAPANESE
))
1248 else if (EQ (val
, Qko
))
1250 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_KOREAN
))
1253 else if (EQ (val
, Qzh
))
1255 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_CHINESE
))
1259 /* Any other language, we don't recognize it. Only the above
1260 currently appear in fontset.el, so it isn't worth
1261 creating a mapping table of codepages/scripts to languages
1262 or opening the font to see if there are any language tags
1263 in it that the W32 API does not expose. Fontset
1264 spec should have a fallback, as some backends do
1265 not recognize language at all. */
1268 else if (EQ (key
, QCotf
) && CONSP (val
))
1270 /* OTF features only supported by the uniscribe backend. */
1271 if (EQ (backend
, Quniscribe
))
1273 if (!uniscribe_check_otf (logfont
, val
))
1285 w32font_coverage_ok (FONTSIGNATURE
* coverage
, BYTE charset
)
1287 DWORD subrange1
= coverage
->fsUsb
[1];
1289 #define SUBRANGE1_HAN_MASK 0x08000000
1290 #define SUBRANGE1_HANGEUL_MASK 0x01000000
1291 #define SUBRANGE1_JAPANESE_MASK (0x00060000 | SUBRANGE1_HAN_MASK)
1293 if (charset
== GB2312_CHARSET
|| charset
== CHINESEBIG5_CHARSET
)
1295 return (subrange1
& SUBRANGE1_HAN_MASK
) == SUBRANGE1_HAN_MASK
;
1297 else if (charset
== SHIFTJIS_CHARSET
)
1299 return (subrange1
& SUBRANGE1_JAPANESE_MASK
) == SUBRANGE1_JAPANESE_MASK
;
1301 else if (charset
== HANGEUL_CHARSET
)
1303 return (subrange1
& SUBRANGE1_HANGEUL_MASK
) == SUBRANGE1_HANGEUL_MASK
;
1311 check_face_name (LOGFONT
*font
, char *full_name
)
1313 char full_iname
[LF_FULLFACESIZE
+1];
1315 /* Just check for names known to cause problems, since the full name
1316 can contain expanded abbreviations, prefixed foundry, postfixed
1317 style, the latter of which sometimes differs from the style indicated
1318 in the shorter name (eg Lt becomes Light or even Extra Light) */
1320 /* Helvetica is mapped to Arial in Windows, but if a Type-1 Helvetica is
1321 installed, we run into problems with the Uniscribe backend which tries
1322 to avoid non-truetype fonts, and ends up mixing the Type-1 Helvetica
1323 with Arial's characteristics, since that attempt to use Truetype works
1324 some places, but not others. */
1325 if (!xstrcasecmp (font
->lfFaceName
, "helvetica"))
1327 strncpy (full_iname
, full_name
, LF_FULLFACESIZE
);
1328 full_iname
[LF_FULLFACESIZE
] = 0;
1329 _strlwr (full_iname
);
1330 return strstr ("helvetica", full_iname
) != NULL
;
1332 /* Same for Helv. */
1333 if (!xstrcasecmp (font
->lfFaceName
, "helv"))
1335 strncpy (full_iname
, full_name
, LF_FULLFACESIZE
);
1336 full_iname
[LF_FULLFACESIZE
] = 0;
1337 _strlwr (full_iname
);
1338 return strstr ("helv", full_iname
) != NULL
;
1341 /* Since Times is mapped to Times New Roman, a substring
1342 match is not sufficient to filter out the bogus match. */
1343 else if (!xstrcasecmp (font
->lfFaceName
, "times"))
1344 return xstrcasecmp (full_name
, "times") == 0;
1350 /* Callback function for EnumFontFamiliesEx.
1351 * Checks if a font matches everything we are trying to check agaist,
1352 * and if so, adds it to a list. Both the data we are checking against
1353 * and the list to which the fonts are added are passed in via the
1354 * lparam argument, in the form of a font_callback_data struct. */
1356 add_font_entity_to_list (ENUMLOGFONTEX
*logical_font
,
1357 NEWTEXTMETRICEX
*physical_font
,
1358 DWORD font_type
, LPARAM lParam
)
1360 struct font_callback_data
*match_data
1361 = (struct font_callback_data
*) lParam
;
1362 Lisp_Object backend
= match_data
->opentype_only
? Quniscribe
: Qgdi
;
1365 int is_unicode
= physical_font
->ntmFontSig
.fsUsb
[3]
1366 || physical_font
->ntmFontSig
.fsUsb
[2]
1367 || physical_font
->ntmFontSig
.fsUsb
[1]
1368 || physical_font
->ntmFontSig
.fsUsb
[0] & 0x3fffffff;
1370 /* Skip non matching fonts. */
1372 /* For uniscribe backend, consider only truetype or opentype fonts
1373 that have some unicode coverage. */
1374 if (match_data
->opentype_only
1375 && ((!physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
1376 && !(font_type
& TRUETYPE_FONTTYPE
))
1380 /* Ensure a match. */
1381 if (!logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1382 || !font_matches_spec (font_type
, physical_font
,
1383 match_data
->orig_font_spec
, backend
,
1384 &logical_font
->elfLogFont
)
1385 || !w32font_coverage_ok (&physical_font
->ntmFontSig
,
1386 match_data
->pattern
.lfCharSet
))
1389 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1390 We limit this to raster fonts, because the test can catch some
1391 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1392 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1393 therefore get through this test. Since full names can be prefixed
1394 by a foundry, we accept raster fonts if the font name is found
1395 anywhere within the full name. */
1396 if ((logical_font
->elfLogFont
.lfOutPrecision
== OUT_STRING_PRECIS
1397 && !strstr (logical_font
->elfFullName
,
1398 logical_font
->elfLogFont
.lfFaceName
))
1399 /* Check for well known substitutions that mess things up in the
1400 presence of Type-1 fonts of the same name. */
1401 || (!check_face_name (&logical_font
->elfLogFont
,
1402 logical_font
->elfFullName
)))
1405 /* Make a font entity for the font. */
1406 entity
= w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1407 physical_font
, font_type
,
1408 &match_data
->pattern
,
1413 Lisp_Object spec_charset
= AREF (match_data
->orig_font_spec
,
1414 FONT_REGISTRY_INDEX
);
1416 /* iso10646-1 fonts must contain unicode mapping tables. */
1417 if (EQ (spec_charset
, Qiso10646_1
))
1422 /* unicode-bmp fonts must contain characters from the BMP. */
1423 else if (EQ (spec_charset
, Qunicode_bmp
))
1425 if (!physical_font
->ntmFontSig
.fsUsb
[3]
1426 && !(physical_font
->ntmFontSig
.fsUsb
[2] & 0xFFFFFF9E)
1427 && !(physical_font
->ntmFontSig
.fsUsb
[1] & 0xE81FFFFF)
1428 && !(physical_font
->ntmFontSig
.fsUsb
[0] & 0x007F001F))
1431 /* unicode-sip fonts must contain characters in unicode plane 2.
1432 so look for bit 57 (surrogates) in the Unicode subranges, plus
1433 the bits for CJK ranges that include those characters. */
1434 else if (EQ (spec_charset
, Qunicode_sip
))
1436 if (!physical_font
->ntmFontSig
.fsUsb
[1] & 0x02000000
1437 || !physical_font
->ntmFontSig
.fsUsb
[1] & 0x28000000)
1441 /* This font matches. */
1443 /* If registry was specified, ensure it is reported as the same. */
1444 if (!NILP (spec_charset
))
1445 ASET (entity
, FONT_REGISTRY_INDEX
, spec_charset
);
1447 /* Otherwise if using the uniscribe backend, report ANSI and DEFAULT
1448 fonts as unicode and skip other charsets. */
1449 else if (match_data
->opentype_only
)
1451 if (logical_font
->elfLogFont
.lfCharSet
== ANSI_CHARSET
1452 || logical_font
->elfLogFont
.lfCharSet
== DEFAULT_CHARSET
)
1453 ASET (entity
, FONT_REGISTRY_INDEX
, Qiso10646_1
);
1458 /* Add this font to the list. */
1459 match_data
->list
= Fcons (entity
, match_data
->list
);
1464 /* Callback function for EnumFontFamiliesEx.
1465 * Terminates the search once we have a match. */
1467 add_one_font_entity_to_list (ENUMLOGFONTEX
*logical_font
,
1468 NEWTEXTMETRICEX
*physical_font
,
1469 DWORD font_type
, LPARAM lParam
)
1471 struct font_callback_data
*match_data
1472 = (struct font_callback_data
*) lParam
;
1473 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1475 /* If we have a font in the list, terminate the search. */
1476 return NILP (match_data
->list
);
1479 /* Old function to convert from x to w32 charset, from w32fns.c. */
1481 x_to_w32_charset (char * lpcs
)
1483 Lisp_Object this_entry
, w32_charset
;
1485 int len
= strlen (lpcs
);
1487 /* Support "*-#nnn" format for unknown charsets. */
1488 if (strncmp (lpcs
, "*-#", 3) == 0)
1489 return atoi (lpcs
+ 3);
1491 /* All Windows fonts qualify as unicode. */
1492 if (!strncmp (lpcs
, "iso10646", 8))
1493 return DEFAULT_CHARSET
;
1495 /* Handle wildcards by ignoring them; eg. treat "big5*-*" as "big5". */
1496 charset
= alloca (len
+ 1);
1497 strcpy (charset
, lpcs
);
1498 lpcs
= strchr (charset
, '*');
1502 /* Look through w32-charset-info-alist for the character set.
1503 Format of each entry is
1504 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
1506 this_entry
= Fassoc (build_string (charset
), Vw32_charset_info_alist
);
1508 if (NILP (this_entry
))
1510 /* At startup, we want iso8859-1 fonts to come up properly. */
1511 if (xstrcasecmp (charset
, "iso8859-1") == 0)
1512 return ANSI_CHARSET
;
1514 return DEFAULT_CHARSET
;
1517 w32_charset
= Fcar (Fcdr (this_entry
));
1519 /* Translate Lisp symbol to number. */
1520 if (EQ (w32_charset
, Qw32_charset_ansi
))
1521 return ANSI_CHARSET
;
1522 if (EQ (w32_charset
, Qw32_charset_symbol
))
1523 return SYMBOL_CHARSET
;
1524 if (EQ (w32_charset
, Qw32_charset_shiftjis
))
1525 return SHIFTJIS_CHARSET
;
1526 if (EQ (w32_charset
, Qw32_charset_hangeul
))
1527 return HANGEUL_CHARSET
;
1528 if (EQ (w32_charset
, Qw32_charset_chinesebig5
))
1529 return CHINESEBIG5_CHARSET
;
1530 if (EQ (w32_charset
, Qw32_charset_gb2312
))
1531 return GB2312_CHARSET
;
1532 if (EQ (w32_charset
, Qw32_charset_oem
))
1534 if (EQ (w32_charset
, Qw32_charset_johab
))
1535 return JOHAB_CHARSET
;
1536 if (EQ (w32_charset
, Qw32_charset_easteurope
))
1537 return EASTEUROPE_CHARSET
;
1538 if (EQ (w32_charset
, Qw32_charset_turkish
))
1539 return TURKISH_CHARSET
;
1540 if (EQ (w32_charset
, Qw32_charset_baltic
))
1541 return BALTIC_CHARSET
;
1542 if (EQ (w32_charset
, Qw32_charset_russian
))
1543 return RUSSIAN_CHARSET
;
1544 if (EQ (w32_charset
, Qw32_charset_arabic
))
1545 return ARABIC_CHARSET
;
1546 if (EQ (w32_charset
, Qw32_charset_greek
))
1547 return GREEK_CHARSET
;
1548 if (EQ (w32_charset
, Qw32_charset_hebrew
))
1549 return HEBREW_CHARSET
;
1550 if (EQ (w32_charset
, Qw32_charset_vietnamese
))
1551 return VIETNAMESE_CHARSET
;
1552 if (EQ (w32_charset
, Qw32_charset_thai
))
1553 return THAI_CHARSET
;
1554 if (EQ (w32_charset
, Qw32_charset_mac
))
1557 return DEFAULT_CHARSET
;
1561 /* Convert a Lisp font registry (symbol) to a windows charset. */
1563 registry_to_w32_charset (Lisp_Object charset
)
1565 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1566 || EQ (charset
, Qunicode_sip
))
1567 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1568 else if (EQ (charset
, Qiso8859_1
))
1569 return ANSI_CHARSET
;
1570 else if (SYMBOLP (charset
))
1571 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1573 return DEFAULT_CHARSET
;
1576 /* Old function to convert from w32 to x charset, from w32fns.c. */
1578 w32_to_x_charset (int fncharset
, char *matching
)
1580 static char buf
[32];
1581 Lisp_Object charset_type
;
1586 /* If fully specified, accept it as it is. Otherwise use a
1588 char *wildcard
= strchr (matching
, '*');
1591 else if (strchr (matching
, '-'))
1594 match_len
= strlen (matching
);
1600 /* Handle startup case of w32-charset-info-alist not
1601 being set up yet. */
1602 if (NILP (Vw32_charset_info_alist
))
1604 charset_type
= Qw32_charset_ansi
;
1606 case DEFAULT_CHARSET
:
1607 charset_type
= Qw32_charset_default
;
1609 case SYMBOL_CHARSET
:
1610 charset_type
= Qw32_charset_symbol
;
1612 case SHIFTJIS_CHARSET
:
1613 charset_type
= Qw32_charset_shiftjis
;
1615 case HANGEUL_CHARSET
:
1616 charset_type
= Qw32_charset_hangeul
;
1618 case GB2312_CHARSET
:
1619 charset_type
= Qw32_charset_gb2312
;
1621 case CHINESEBIG5_CHARSET
:
1622 charset_type
= Qw32_charset_chinesebig5
;
1625 charset_type
= Qw32_charset_oem
;
1627 case EASTEUROPE_CHARSET
:
1628 charset_type
= Qw32_charset_easteurope
;
1630 case TURKISH_CHARSET
:
1631 charset_type
= Qw32_charset_turkish
;
1633 case BALTIC_CHARSET
:
1634 charset_type
= Qw32_charset_baltic
;
1636 case RUSSIAN_CHARSET
:
1637 charset_type
= Qw32_charset_russian
;
1639 case ARABIC_CHARSET
:
1640 charset_type
= Qw32_charset_arabic
;
1643 charset_type
= Qw32_charset_greek
;
1645 case HEBREW_CHARSET
:
1646 charset_type
= Qw32_charset_hebrew
;
1648 case VIETNAMESE_CHARSET
:
1649 charset_type
= Qw32_charset_vietnamese
;
1652 charset_type
= Qw32_charset_thai
;
1655 charset_type
= Qw32_charset_mac
;
1658 charset_type
= Qw32_charset_johab
;
1662 /* Encode numerical value of unknown charset. */
1663 sprintf (buf
, "*-#%u", fncharset
);
1669 char * best_match
= NULL
;
1670 int matching_found
= 0;
1672 /* Look through w32-charset-info-alist for the character set.
1673 Prefer ISO codepages, and prefer lower numbers in the ISO
1674 range. Only return charsets for codepages which are installed.
1676 Format of each entry is
1677 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
1679 for (rest
= Vw32_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
1682 Lisp_Object w32_charset
;
1683 Lisp_Object codepage
;
1685 Lisp_Object this_entry
= XCAR (rest
);
1687 /* Skip invalid entries in alist. */
1688 if (!CONSP (this_entry
) || !STRINGP (XCAR (this_entry
))
1689 || !CONSP (XCDR (this_entry
))
1690 || !SYMBOLP (XCAR (XCDR (this_entry
))))
1693 x_charset
= SDATA (XCAR (this_entry
));
1694 w32_charset
= XCAR (XCDR (this_entry
));
1695 codepage
= XCDR (XCDR (this_entry
));
1697 /* Look for Same charset and a valid codepage (or non-int
1698 which means ignore). */
1699 if (EQ (w32_charset
, charset_type
)
1700 && (!INTEGERP (codepage
) || XINT (codepage
) == CP_DEFAULT
1701 || IsValidCodePage (XINT (codepage
))))
1703 /* If we don't have a match already, then this is the
1707 best_match
= x_charset
;
1708 if (matching
&& !strnicmp (x_charset
, matching
, match_len
))
1711 /* If we already found a match for MATCHING, then
1712 only consider other matches. */
1713 else if (matching_found
1714 && strnicmp (x_charset
, matching
, match_len
))
1716 /* If this matches what we want, and the best so far doesn't,
1717 then this is better. */
1718 else if (!matching_found
&& matching
1719 && !strnicmp (x_charset
, matching
, match_len
))
1721 best_match
= x_charset
;
1724 /* If this is fully specified, and the best so far isn't,
1725 then this is better. */
1726 else if ((!strchr (best_match
, '-') && strchr (x_charset
, '-'))
1727 /* If this is an ISO codepage, and the best so far isn't,
1728 then this is better, but only if it fully specifies the
1730 || (strnicmp (best_match
, "iso", 3) != 0
1731 && strnicmp (x_charset
, "iso", 3) == 0
1732 && strchr (x_charset
, '-')))
1733 best_match
= x_charset
;
1734 /* If both are ISO8859 codepages, choose the one with the
1735 lowest number in the encoding field. */
1736 else if (strnicmp (best_match
, "iso8859-", 8) == 0
1737 && strnicmp (x_charset
, "iso8859-", 8) == 0)
1739 int best_enc
= atoi (best_match
+ 8);
1740 int this_enc
= atoi (x_charset
+ 8);
1741 if (this_enc
> 0 && this_enc
< best_enc
)
1742 best_match
= x_charset
;
1747 /* If no match, encode the numeric value. */
1750 sprintf (buf
, "*-#%u", fncharset
);
1754 strncpy (buf
, best_match
, 31);
1755 /* If the charset is not fully specified, put -0 on the end. */
1756 if (!strchr (best_match
, '-'))
1758 int pos
= strlen (best_match
);
1759 /* Charset specifiers shouldn't be very long. If it is a made
1760 up one, truncating it should not do any harm since it isn't
1761 recognized anyway. */
1764 strcpy (buf
+ pos
, "-0");
1772 w32_registry (LONG w32_charset
, DWORD font_type
)
1776 /* If charset is defaulted, charset is unicode or unknown, depending on
1778 if (w32_charset
== DEFAULT_CHARSET
)
1779 return font_type
== TRUETYPE_FONTTYPE
? Qiso10646_1
: Qunknown
;
1781 charset
= w32_to_x_charset (w32_charset
, NULL
);
1782 return font_intern_prop (charset
, strlen (charset
), 1);
1786 w32_decode_weight (int fnweight
)
1788 if (fnweight
>= FW_HEAVY
) return 210;
1789 if (fnweight
>= FW_EXTRABOLD
) return 205;
1790 if (fnweight
>= FW_BOLD
) return 200;
1791 if (fnweight
>= FW_SEMIBOLD
) return 180;
1792 if (fnweight
>= FW_NORMAL
) return 100;
1793 if (fnweight
>= FW_LIGHT
) return 50;
1794 if (fnweight
>= FW_EXTRALIGHT
) return 40;
1795 if (fnweight
> FW_THIN
) return 20;
1800 w32_encode_weight (int n
)
1802 if (n
>= 210) return FW_HEAVY
;
1803 if (n
>= 205) return FW_EXTRABOLD
;
1804 if (n
>= 200) return FW_BOLD
;
1805 if (n
>= 180) return FW_SEMIBOLD
;
1806 if (n
>= 100) return FW_NORMAL
;
1807 if (n
>= 50) return FW_LIGHT
;
1808 if (n
>= 40) return FW_EXTRALIGHT
;
1809 if (n
>= 20) return FW_THIN
;
1813 /* Convert a Windows font weight into one of the weights supported
1814 by fontconfig (see font.c:font_parse_fcname). */
1816 w32_to_fc_weight (int n
)
1818 if (n
>= FW_EXTRABOLD
) return intern ("black");
1819 if (n
>= FW_BOLD
) return intern ("bold");
1820 if (n
>= FW_SEMIBOLD
) return intern ("demibold");
1821 if (n
>= FW_NORMAL
) return intern ("medium");
1822 return intern ("light");
1825 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1827 fill_in_logfont (FRAME_PTR f
, LOGFONT
*logfont
, Lisp_Object font_spec
)
1829 Lisp_Object tmp
, extra
;
1830 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1832 tmp
= AREF (font_spec
, FONT_DPI_INDEX
);
1837 else if (FLOATP (tmp
))
1839 dpi
= (int) (XFLOAT_DATA (tmp
) + 0.5);
1843 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1845 logfont
->lfHeight
= -1 * XINT (tmp
);
1846 else if (FLOATP (tmp
))
1847 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1854 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1856 logfont
->lfWeight
= w32_encode_weight (FONT_WEIGHT_NUMERIC (font_spec
));
1859 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
1862 int slant
= FONT_SLANT_NUMERIC (font_spec
);
1863 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
1871 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1873 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
1875 logfont
->lfCharSet
= DEFAULT_CHARSET
;
1879 /* Clip Precision */
1882 logfont
->lfQuality
= DEFAULT_QUALITY
;
1884 /* Generic Family and Face Name */
1885 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
1887 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1890 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
1891 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
1892 ; /* Font name was generic, don't fill in font name. */
1893 /* Font families are interned, but allow for strings also in case of
1895 else if (SYMBOLP (tmp
))
1896 strncpy (logfont
->lfFaceName
,
1897 SDATA (ENCODE_SYSTEM (SYMBOL_NAME (tmp
))), LF_FACESIZE
);
1900 tmp
= AREF (font_spec
, FONT_ADSTYLE_INDEX
);
1903 /* Override generic family. */
1904 BYTE family
= w32_generic_family (tmp
);
1905 if (family
!= FF_DONTCARE
)
1906 logfont
->lfPitchAndFamily
= family
| DEFAULT_PITCH
;
1909 /* Set pitch based on the spacing property. */
1910 tmp
= AREF (font_spec
, FONT_SPACING_INDEX
);
1913 int spacing
= XINT (tmp
);
1914 if (spacing
< FONT_SPACING_MONO
)
1915 logfont
->lfPitchAndFamily
1916 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1918 logfont
->lfPitchAndFamily
1919 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1922 /* Process EXTRA info. */
1923 for (extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
1924 CONSP (extra
); extra
= XCDR (extra
))
1929 Lisp_Object key
, val
;
1930 key
= XCAR (tmp
), val
= XCDR (tmp
);
1931 /* Only use QCscript if charset is not provided, or is unicode
1932 and a single script is specified. This is rather crude,
1933 and is only used to narrow down the fonts returned where
1934 there is a definite match. Some scripts, such as latin, han,
1935 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1937 if (EQ (key
, QCscript
)
1938 && logfont
->lfCharSet
== DEFAULT_CHARSET
1941 if (EQ (val
, Qgreek
))
1942 logfont
->lfCharSet
= GREEK_CHARSET
;
1943 else if (EQ (val
, Qhangul
))
1944 logfont
->lfCharSet
= HANGUL_CHARSET
;
1945 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
1946 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
1947 else if (EQ (val
, Qbopomofo
))
1948 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
1949 /* GB 18030 supports tibetan, yi, mongolian,
1950 fonts that support it should show up if we ask for
1952 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
1953 || EQ (val
, Qmongolian
))
1954 logfont
->lfCharSet
= GB2312_CHARSET
;
1955 else if (EQ (val
, Qhebrew
))
1956 logfont
->lfCharSet
= HEBREW_CHARSET
;
1957 else if (EQ (val
, Qarabic
))
1958 logfont
->lfCharSet
= ARABIC_CHARSET
;
1959 else if (EQ (val
, Qthai
))
1960 logfont
->lfCharSet
= THAI_CHARSET
;
1962 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
1964 logfont
->lfQuality
= w32_antialias_type (val
);
1971 list_all_matching_fonts (struct font_callback_data
*match_data
)
1974 Lisp_Object families
= w32font_list_family (match_data
->frame
);
1975 struct frame
*f
= XFRAME (match_data
->frame
);
1977 dc
= get_frame_dc (f
);
1979 while (!NILP (families
))
1981 /* Only fonts from the current locale are given localized names
1982 on Windows, so we can keep backwards compatibility with
1983 Windows 9x/ME by using non-Unicode font enumeration without
1984 sacrificing internationalization here. */
1986 Lisp_Object family
= CAR (families
);
1987 families
= CDR (families
);
1990 else if (SYMBOLP (family
))
1991 name
= SDATA (ENCODE_SYSTEM (SYMBOL_NAME (family
)));
1995 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
1996 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
1998 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
1999 (FONTENUMPROC
) add_font_entity_to_list
,
2000 (LPARAM
) match_data
, 0);
2003 release_frame_dc (f
, dc
);
2007 lispy_antialias_type (BYTE type
)
2013 case NONANTIALIASED_QUALITY
:
2016 case ANTIALIASED_QUALITY
:
2019 case CLEARTYPE_QUALITY
:
2022 case CLEARTYPE_NATURAL_QUALITY
:
2032 /* Convert antialiasing symbols to lfQuality */
2034 w32_antialias_type (Lisp_Object type
)
2036 if (EQ (type
, Qnone
))
2037 return NONANTIALIASED_QUALITY
;
2038 else if (EQ (type
, Qstandard
))
2039 return ANTIALIASED_QUALITY
;
2040 else if (EQ (type
, Qsubpixel
))
2041 return CLEARTYPE_QUALITY
;
2042 else if (EQ (type
, Qnatural
))
2043 return CLEARTYPE_NATURAL_QUALITY
;
2045 return DEFAULT_QUALITY
;
2048 /* Return a list of all the scripts that the font supports. */
2050 font_supported_scripts (FONTSIGNATURE
* sig
)
2052 DWORD
* subranges
= sig
->fsUsb
;
2053 Lisp_Object supported
= Qnil
;
2055 /* Match a single subrange. SYM is set if bit N is set in subranges. */
2056 #define SUBRANGE(n,sym) \
2057 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
2058 supported = Fcons ((sym), supported)
2060 /* Match multiple subranges. SYM is set if any MASK bit is set in
2061 subranges[0 - 3]. */
2062 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
2063 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
2064 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
2065 supported = Fcons ((sym), supported)
2067 SUBRANGE (0, Qlatin
);
2068 /* The following count as latin too, ASCII should be present in these fonts,
2069 so don't need to mark them separately. */
2070 /* 1: Latin-1 supplement, 2: Latin Extended A, 3: Latin Extended B. */
2071 SUBRANGE (4, Qphonetic
);
2072 /* 5: Spacing and tone modifiers, 6: Combining Diacriticals. */
2073 SUBRANGE (7, Qgreek
);
2074 SUBRANGE (8, Qcoptic
);
2075 SUBRANGE (9, Qcyrillic
);
2076 SUBRANGE (10, Qarmenian
);
2077 SUBRANGE (11, Qhebrew
);
2079 SUBRANGE (13, Qarabic
);
2080 SUBRANGE (14, Qnko
);
2081 SUBRANGE (15, Qdevanagari
);
2082 SUBRANGE (16, Qbengali
);
2083 SUBRANGE (17, Qgurmukhi
);
2084 SUBRANGE (18, Qgujarati
);
2085 SUBRANGE (19, Qoriya
);
2086 SUBRANGE (20, Qtamil
);
2087 SUBRANGE (21, Qtelugu
);
2088 SUBRANGE (22, Qkannada
);
2089 SUBRANGE (23, Qmalayalam
);
2090 SUBRANGE (24, Qthai
);
2091 SUBRANGE (25, Qlao
);
2092 SUBRANGE (26, Qgeorgian
);
2093 SUBRANGE (27, Qbalinese
);
2094 /* 28: Hangul Jamo. */
2095 /* 29: Latin Extended, 30: Greek Extended, 31: Punctuation. */
2096 /* 32-47: Symbols (defined below). */
2097 SUBRANGE (48, Qcjk_misc
);
2098 /* Match either 49: katakana or 50: hiragana for kana. */
2099 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
2100 SUBRANGE (51, Qbopomofo
);
2101 /* 52: Compatibility Jamo */
2102 SUBRANGE (53, Qphags_pa
);
2103 /* 54: Enclosed CJK letters and months, 55: CJK Compatibility. */
2104 SUBRANGE (56, Qhangul
);
2105 /* 57: Surrogates. */
2106 SUBRANGE (58, Qphoenician
);
2107 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
2108 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in. */
2109 SUBRANGE (59, Qkanbun
); /* And this. */
2110 /* 60: Private use, 61: CJK strokes and compatibility. */
2111 /* 62: Alphabetic Presentation, 63: Arabic Presentation A. */
2112 /* 64: Combining half marks, 65: Vertical and CJK compatibility. */
2113 /* 66: Small forms, 67: Arabic Presentation B, 68: Half and Full width. */
2115 SUBRANGE (70, Qtibetan
);
2116 SUBRANGE (71, Qsyriac
);
2117 SUBRANGE (72, Qthaana
);
2118 SUBRANGE (73, Qsinhala
);
2119 SUBRANGE (74, Qmyanmar
);
2120 SUBRANGE (75, Qethiopic
);
2121 SUBRANGE (76, Qcherokee
);
2122 SUBRANGE (77, Qcanadian_aboriginal
);
2123 SUBRANGE (78, Qogham
);
2124 SUBRANGE (79, Qrunic
);
2125 SUBRANGE (80, Qkhmer
);
2126 SUBRANGE (81, Qmongolian
);
2127 SUBRANGE (82, Qbraille
);
2129 SUBRANGE (84, Qbuhid
);
2130 SUBRANGE (84, Qhanunoo
);
2131 SUBRANGE (84, Qtagalog
);
2132 SUBRANGE (84, Qtagbanwa
);
2133 SUBRANGE (85, Qold_italic
);
2134 SUBRANGE (86, Qgothic
);
2135 SUBRANGE (87, Qdeseret
);
2136 SUBRANGE (88, Qbyzantine_musical_symbol
);
2137 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
2138 SUBRANGE (89, Qmathematical
);
2139 /* 90: Private use, 91: Variation selectors, 92: Tags. */
2140 SUBRANGE (93, Qlimbu
);
2141 SUBRANGE (94, Qtai_le
);
2142 /* 95: New Tai Le */
2143 SUBRANGE (90, Qbuginese
);
2144 SUBRANGE (97, Qglagolitic
);
2145 SUBRANGE (98, Qtifinagh
);
2146 /* 99: Yijing Hexagrams. */
2147 SUBRANGE (100, Qsyloti_nagri
);
2148 SUBRANGE (101, Qlinear_b
);
2149 /* 102: Ancient Greek Numbers. */
2150 SUBRANGE (103, Qugaritic
);
2151 SUBRANGE (104, Qold_persian
);
2152 SUBRANGE (105, Qshavian
);
2153 SUBRANGE (106, Qosmanya
);
2154 SUBRANGE (107, Qcypriot
);
2155 SUBRANGE (108, Qkharoshthi
);
2156 /* 109: Tai Xuan Jing. */
2157 SUBRANGE (110, Qcuneiform
);
2158 /* 111: Counting Rods, 112: Sundanese, 113: Lepcha, 114: Ol Chiki. */
2159 /* 115: Saurashtra, 116: Kayah Li, 117: Rejang. */
2160 SUBRANGE (118, Qcham
);
2161 /* 119: Ancient symbols, 120: Phaistos Disc. */
2162 /* 121: Carian, Lycian, Lydian, 122: Dominos, Mah Jong tiles. */
2163 /* 123-127: Reserved. */
2165 /* There isn't really a main symbol range, so include symbol if any
2166 relevant range is set. */
2167 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
2169 /* Missing: Tai Viet (U+AA80-U+AADF). */
2176 /* Generate a full name for a Windows font.
2177 The full name is in fcname format, with weight, slant and antialiasing
2178 specified if they are not "normal". */
2180 w32font_full_name (LOGFONT
* font
, Lisp_Object font_obj
,
2181 int pixel_size
, char *name
, int nbytes
)
2183 int len
, height
, outline
;
2185 Lisp_Object antialiasing
, weight
= Qnil
;
2187 len
= strlen (font
->lfFaceName
);
2189 outline
= EQ (AREF (font_obj
, FONT_FOUNDRY_INDEX
), Qoutline
);
2191 /* Represent size of scalable fonts by point size. But use pixelsize for
2192 raster fonts to indicate that they are exactly that size. */
2194 len
+= 11; /* -SIZE */
2199 len
+= 7; /* :italic */
2201 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
2203 weight
= w32_to_fc_weight (font
->lfWeight
);
2204 len
+= 1 + SBYTES (SYMBOL_NAME (weight
)); /* :WEIGHT */
2207 antialiasing
= lispy_antialias_type (font
->lfQuality
);
2208 if (! NILP (antialiasing
))
2209 len
+= 11 + SBYTES (SYMBOL_NAME (antialiasing
)); /* :antialias=NAME */
2211 /* Check that the buffer is big enough */
2216 p
+= sprintf (p
, "%s", font
->lfFaceName
);
2218 height
= font
->lfHeight
? eabs (font
->lfHeight
) : pixel_size
;
2224 float pointsize
= height
* 72.0 / one_w32_display_info
.resy
;
2225 /* Round to nearest half point. floor is used, since round is not
2226 supported in MS library. */
2227 pointsize
= floor (pointsize
* 2 + 0.5) / 2;
2228 p
+= sprintf (p
, "-%1.1f", pointsize
);
2231 p
+= sprintf (p
, ":pixelsize=%d", height
);
2234 if (SYMBOLP (weight
) && ! NILP (weight
))
2235 p
+= sprintf (p
, ":%s", SDATA (SYMBOL_NAME (weight
)));
2238 p
+= sprintf (p
, ":italic");
2240 if (SYMBOLP (antialiasing
) && ! NILP (antialiasing
))
2241 p
+= sprintf (p
, ":antialias=%s", SDATA (SYMBOL_NAME (antialiasing
)));
2246 /* Convert a logfont and point size into a fontconfig style font name.
2247 POINTSIZE is in tenths of points.
2248 If SIZE indicates the size of buffer FCNAME, into which the font name
2249 is written. If the buffer is not large enough to contain the name,
2250 the function returns -1, otherwise it returns the number of bytes
2251 written to FCNAME. */
2253 logfont_to_fcname (LOGFONT
* font
, int pointsize
, char *fcname
, int size
)
2257 Lisp_Object weight
= Qnil
;
2259 len
= strlen (font
->lfFaceName
) + 2;
2260 height
= pointsize
/ 10;
2261 while (height
/= 10)
2268 len
+= 7; /* :italic */
2269 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
2271 weight
= w32_to_fc_weight (font
->lfWeight
);
2272 len
+= SBYTES (SYMBOL_NAME (weight
)) + 1;
2278 p
+= sprintf (p
, "%s-%d", font
->lfFaceName
, pointsize
/ 10);
2280 p
+= sprintf (p
, ".%d", pointsize
% 10);
2282 if (SYMBOLP (weight
) && !NILP (weight
))
2283 p
+= sprintf (p
, ":%s", SDATA (SYMBOL_NAME (weight
)));
2286 p
+= sprintf (p
, ":italic");
2288 return (p
- fcname
);
2292 compute_metrics (HDC dc
, struct w32font_info
*w32_font
, unsigned int code
,
2293 struct w32_metric_cache
*metrics
)
2297 unsigned int options
= GGO_METRICS
;
2299 if (w32_font
->glyph_idx
)
2300 options
|= GGO_GLYPH_INDEX
;
2302 memset (&transform
, 0, sizeof (transform
));
2303 transform
.eM11
.value
= 1;
2304 transform
.eM22
.value
= 1;
2306 if (GetGlyphOutlineW (dc
, code
, options
, &gm
, 0, NULL
, &transform
)
2309 metrics
->lbearing
= gm
.gmptGlyphOrigin
.x
;
2310 metrics
->rbearing
= gm
.gmptGlyphOrigin
.x
+ gm
.gmBlackBoxX
;
2311 metrics
->width
= gm
.gmCellIncX
;
2312 metrics
->status
= W32METRIC_SUCCESS
;
2315 metrics
->status
= W32METRIC_FAIL
;
2318 DEFUN ("x-select-font", Fx_select_font
, Sx_select_font
, 0, 2, 0,
2319 doc
: /* Read a font name using a W32 font selection dialog.
2320 Return fontconfig style font string corresponding to the selection.
2322 If FRAME is omitted or nil, it defaults to the selected frame.
2323 If EXCLUDE-PROPORTIONAL is non-nil, exclude proportional fonts
2324 in the font selection dialog. */)
2325 (Lisp_Object frame
, Lisp_Object exclude_proportional
)
2327 FRAME_PTR f
= check_x_frame (frame
);
2335 memset (&cf
, 0, sizeof (cf
));
2336 memset (&lf
, 0, sizeof (lf
));
2338 cf
.lStructSize
= sizeof (cf
);
2339 cf
.hwndOwner
= FRAME_W32_WINDOW (f
);
2340 cf
.Flags
= CF_FORCEFONTEXIST
| CF_SCREENFONTS
| CF_NOVERTFONTS
;
2342 /* If exclude_proportional is non-nil, limit the selection to
2343 monospaced fonts. */
2344 if (!NILP (exclude_proportional
))
2345 cf
.Flags
|= CF_FIXEDPITCHONLY
;
2349 /* Initialize as much of the font details as we can from the current
2351 hdc
= GetDC (FRAME_W32_WINDOW (f
));
2352 oldobj
= SelectObject (hdc
, FONT_HANDLE (FRAME_FONT (f
)));
2353 GetTextFace (hdc
, LF_FACESIZE
, lf
.lfFaceName
);
2354 if (GetTextMetrics (hdc
, &tm
))
2356 lf
.lfHeight
= tm
.tmInternalLeading
- tm
.tmHeight
;
2357 lf
.lfWeight
= tm
.tmWeight
;
2358 lf
.lfItalic
= tm
.tmItalic
;
2359 lf
.lfUnderline
= tm
.tmUnderlined
;
2360 lf
.lfStrikeOut
= tm
.tmStruckOut
;
2361 lf
.lfCharSet
= tm
.tmCharSet
;
2362 cf
.Flags
|= CF_INITTOLOGFONTSTRUCT
;
2364 SelectObject (hdc
, oldobj
);
2365 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
2367 if (!ChooseFont (&cf
)
2368 || logfont_to_fcname (&lf
, cf
.iPointSize
, buf
, 100) < 0)
2371 return DECODE_SYSTEM (build_string (buf
));
2374 static const char *const w32font_booleans
[] = {
2378 static const char *const w32font_non_booleans
[] = {
2386 w32font_filter_properties (Lisp_Object font
, Lisp_Object alist
)
2388 font_filter_properties (font
, alist
, w32font_booleans
, w32font_non_booleans
);
2391 struct font_driver w32font_driver
=
2394 0, /* case insensitive */
2398 w32font_list_family
,
2399 NULL
, /* free_entity */
2402 NULL
, /* prepare_face */
2403 NULL
, /* done_face */
2405 w32font_encode_char
,
2406 w32font_text_extents
,
2408 NULL
, /* get_bitmap */
2409 NULL
, /* free_bitmap */
2410 NULL
, /* get_outline */
2411 NULL
, /* free_outline */
2412 NULL
, /* anchor_point */
2413 NULL
, /* otf_capability */
2414 NULL
, /* otf_drive */
2415 NULL
, /* start_for_frame */
2416 NULL
, /* end_for_frame */
2419 NULL
, /* get_variation_glyphs */
2420 w32font_filter_properties
,
2424 /* Initialize state that does not change between invocations. This is only
2425 called when Emacs is dumped. */
2427 syms_of_w32font (void)
2429 DEFSYM (Qgdi
, "gdi");
2430 DEFSYM (Quniscribe
, "uniscribe");
2431 DEFSYM (QCformat
, ":format");
2433 /* Generic font families. */
2434 DEFSYM (Qmonospace
, "monospace");
2435 DEFSYM (Qserif
, "serif");
2436 DEFSYM (Qsansserif
, "sansserif");
2437 DEFSYM (Qscript
, "script");
2438 DEFSYM (Qdecorative
, "decorative");
2440 DEFSYM (Qsans_serif
, "sans_serif");
2441 DEFSYM (Qsans
, "sans");
2442 DEFSYM (Qmono
, "mono");
2444 /* Fake foundries. */
2445 DEFSYM (Qraster
, "raster");
2446 DEFSYM (Qoutline
, "outline");
2447 DEFSYM (Qunknown
, "unknown");
2450 DEFSYM (Qstandard
, "standard");
2451 DEFSYM (Qsubpixel
, "subpixel");
2452 DEFSYM (Qnatural
, "natural");
2458 DEFSYM (Qlatin
, "latin");
2459 DEFSYM (Qgreek
, "greek");
2460 DEFSYM (Qcoptic
, "coptic");
2461 DEFSYM (Qcyrillic
, "cyrillic");
2462 DEFSYM (Qarmenian
, "armenian");
2463 DEFSYM (Qhebrew
, "hebrew");
2464 DEFSYM (Qarabic
, "arabic");
2465 DEFSYM (Qsyriac
, "syriac");
2466 DEFSYM (Qnko
, "nko");
2467 DEFSYM (Qthaana
, "thaana");
2468 DEFSYM (Qdevanagari
, "devanagari");
2469 DEFSYM (Qbengali
, "bengali");
2470 DEFSYM (Qgurmukhi
, "gurmukhi");
2471 DEFSYM (Qgujarati
, "gujarati");
2472 DEFSYM (Qoriya
, "oriya");
2473 DEFSYM (Qtamil
, "tamil");
2474 DEFSYM (Qtelugu
, "telugu");
2475 DEFSYM (Qkannada
, "kannada");
2476 DEFSYM (Qmalayalam
, "malayalam");
2477 DEFSYM (Qsinhala
, "sinhala");
2478 DEFSYM (Qthai
, "thai");
2479 DEFSYM (Qlao
, "lao");
2480 DEFSYM (Qtibetan
, "tibetan");
2481 DEFSYM (Qmyanmar
, "myanmar");
2482 DEFSYM (Qgeorgian
, "georgian");
2483 DEFSYM (Qhangul
, "hangul");
2484 DEFSYM (Qethiopic
, "ethiopic");
2485 DEFSYM (Qcherokee
, "cherokee");
2486 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
2487 DEFSYM (Qogham
, "ogham");
2488 DEFSYM (Qrunic
, "runic");
2489 DEFSYM (Qkhmer
, "khmer");
2490 DEFSYM (Qmongolian
, "mongolian");
2491 DEFSYM (Qsymbol
, "symbol");
2492 DEFSYM (Qbraille
, "braille");
2493 DEFSYM (Qhan
, "han");
2494 DEFSYM (Qideographic_description
, "ideographic-description");
2495 DEFSYM (Qcjk_misc
, "cjk-misc");
2496 DEFSYM (Qkana
, "kana");
2497 DEFSYM (Qbopomofo
, "bopomofo");
2498 DEFSYM (Qkanbun
, "kanbun");
2500 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
2501 DEFSYM (Qmusical_symbol
, "musical-symbol");
2502 DEFSYM (Qmathematical
, "mathematical");
2503 DEFSYM (Qcham
, "cham");
2504 DEFSYM (Qphonetic
, "phonetic");
2505 DEFSYM (Qbalinese
, "balinese");
2506 DEFSYM (Qbuginese
, "buginese");
2507 DEFSYM (Qbuhid
, "buhid");
2508 DEFSYM (Qcuneiform
, "cuneiform");
2509 DEFSYM (Qcypriot
, "cypriot");
2510 DEFSYM (Qdeseret
, "deseret");
2511 DEFSYM (Qglagolitic
, "glagolitic");
2512 DEFSYM (Qgothic
, "gothic");
2513 DEFSYM (Qhanunoo
, "hanunoo");
2514 DEFSYM (Qkharoshthi
, "kharoshthi");
2515 DEFSYM (Qlimbu
, "limbu");
2516 DEFSYM (Qlinear_b
, "linear_b");
2517 DEFSYM (Qold_italic
, "old_italic");
2518 DEFSYM (Qold_persian
, "old_persian");
2519 DEFSYM (Qosmanya
, "osmanya");
2520 DEFSYM (Qphags_pa
, "phags-pa");
2521 DEFSYM (Qphoenician
, "phoenician");
2522 DEFSYM (Qshavian
, "shavian");
2523 DEFSYM (Qsyloti_nagri
, "syloti_nagri");
2524 DEFSYM (Qtagalog
, "tagalog");
2525 DEFSYM (Qtagbanwa
, "tagbanwa");
2526 DEFSYM (Qtai_le
, "tai_le");
2527 DEFSYM (Qtifinagh
, "tifinagh");
2528 DEFSYM (Qugaritic
, "ugaritic");
2530 /* W32 font encodings. */
2531 DEFVAR_LISP ("w32-charset-info-alist",
2532 Vw32_charset_info_alist
,
2533 doc
: /* Alist linking Emacs character sets to Windows fonts and codepages.
2534 Each entry should be of the form:
2536 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))
2538 where CHARSET_NAME is a string used in font names to identify the charset,
2539 WINDOWS_CHARSET is a symbol that can be one of:
2541 w32-charset-ansi, w32-charset-default, w32-charset-symbol,
2542 w32-charset-shiftjis, w32-charset-hangeul, w32-charset-gb2312,
2543 w32-charset-chinesebig5, w32-charset-johab, w32-charset-hebrew,
2544 w32-charset-arabic, w32-charset-greek, w32-charset-turkish,
2545 w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,
2546 w32-charset-russian, w32-charset-mac, w32-charset-baltic,
2549 CODEPAGE should be an integer specifying the codepage that should be used
2550 to display the character set, t to do no translation and output as Unicode,
2551 or nil to do no translation and output as 8 bit (or multibyte on far-east
2552 versions of Windows) characters. */);
2553 Vw32_charset_info_alist
= Qnil
;
2555 DEFSYM (Qw32_charset_ansi
, "w32-charset-ansi");
2556 DEFSYM (Qw32_charset_symbol
, "w32-charset-symbol");
2557 DEFSYM (Qw32_charset_default
, "w32-charset-default");
2558 DEFSYM (Qw32_charset_shiftjis
, "w32-charset-shiftjis");
2559 DEFSYM (Qw32_charset_hangeul
, "w32-charset-hangeul");
2560 DEFSYM (Qw32_charset_chinesebig5
, "w32-charset-chinesebig5");
2561 DEFSYM (Qw32_charset_gb2312
, "w32-charset-gb2312");
2562 DEFSYM (Qw32_charset_oem
, "w32-charset-oem");
2563 DEFSYM (Qw32_charset_johab
, "w32-charset-johab");
2564 DEFSYM (Qw32_charset_easteurope
, "w32-charset-easteurope");
2565 DEFSYM (Qw32_charset_turkish
, "w32-charset-turkish");
2566 DEFSYM (Qw32_charset_baltic
, "w32-charset-baltic");
2567 DEFSYM (Qw32_charset_russian
, "w32-charset-russian");
2568 DEFSYM (Qw32_charset_arabic
, "w32-charset-arabic");
2569 DEFSYM (Qw32_charset_greek
, "w32-charset-greek");
2570 DEFSYM (Qw32_charset_hebrew
, "w32-charset-hebrew");
2571 DEFSYM (Qw32_charset_vietnamese
, "w32-charset-vietnamese");
2572 DEFSYM (Qw32_charset_thai
, "w32-charset-thai");
2573 DEFSYM (Qw32_charset_mac
, "w32-charset-mac");
2575 defsubr (&Sx_select_font
);
2577 w32font_driver
.type
= Qgdi
;
2578 register_font_driver (&w32font_driver
, NULL
);