1 /* Font backend for the Microsoft Windows API.
2 Copyright (C) 2007-2012 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/>. */
30 #include "dispextern.h"
31 #include "character.h"
38 /* Cleartype available on Windows XP, cleartype_natural from XP SP1.
39 The latter does not try to fit cleartype smoothed fonts into the
40 same bounding box as the non-antialiased version of the font.
42 #ifndef CLEARTYPE_QUALITY
43 #define CLEARTYPE_QUALITY 5
45 #ifndef CLEARTYPE_NATURAL_QUALITY
46 #define CLEARTYPE_NATURAL_QUALITY 6
49 /* VIETNAMESE_CHARSET and JOHAB_CHARSET are not defined in some versions
51 #ifndef VIETNAMESE_CHARSET
52 #define VIETNAMESE_CHARSET 163
55 #define JOHAB_CHARSET 130
59 Lisp_Object Quniscribe
;
60 static Lisp_Object QCformat
;
61 static Lisp_Object Qmonospace
, Qsansserif
, Qmono
, Qsans
, Qsans_serif
;
62 static Lisp_Object Qserif
, Qscript
, Qdecorative
;
63 static Lisp_Object Qraster
, Qoutline
, Qunknown
;
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
, 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
*);
148 static BOOL g_b_init_is_w9x
;
149 static BOOL g_b_init_get_outline_metrics_w
;
150 static BOOL g_b_init_get_text_metrics_w
;
151 static BOOL g_b_init_get_glyph_outline_w
;
152 static BOOL g_b_init_get_glyph_outline_w
;
154 typedef UINT (WINAPI
* GetOutlineTextMetricsW_Proc
) (
157 LPOUTLINETEXTMETRICW lpotmw
);
158 typedef BOOL (WINAPI
* GetTextMetricsW_Proc
) (
160 LPTEXTMETRICW lptmw
);
161 typedef DWORD (WINAPI
* GetGlyphOutlineW_Proc
) (
170 /* Several "wide" functions we use to support the font backends are
171 unavailable on Windows 9X, unless UNICOWS.DLL is installed (their
172 versions in the default libraries are non-functional stubs). On NT
173 and later systems, these functions are in GDI32.DLL. The following
174 helper function attempts to load UNICOWS.DLL on Windows 9X, and
175 refuses to let Emacs start up if that library is not found. On NT
176 and later versions, it simply loads GDI32.DLL, which should always
179 w32_load_unicows_or_gdi32 (void)
181 static BOOL is_9x
= 0;
182 OSVERSIONINFO os_ver
;
184 if (g_b_init_is_w9x
== 0)
187 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
188 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
189 if (GetVersionEx (&os_ver
))
190 is_9x
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
194 ret
= LoadLibrary ("Unicows.dll");
199 button
= MessageBox (NULL
,
200 "Emacs cannot load the UNICOWS.DLL library.\n"
201 "This library is essential for using Emacs\n"
202 "on this system. You need to install it.\n\n"
203 "However, you can still use Emacs by invoking\n"
204 "it with the '-nw' command-line option.\n\n"
205 "Emacs will exit when you click OK.",
206 "Emacs cannot load UNICOWS.DLL",
207 MB_ICONERROR
| MB_TASKMODAL
208 | MB_SETFOREGROUND
| MB_OK
);
218 ret
= LoadLibrary ("Gdi32.dll");
222 /* The following 3 functions call the problematic "wide" APIs via
223 function pointers, to avoid linking against the non-standard
224 libunicows on W9X. */
226 get_outline_metrics_w(HDC hdc
, UINT cbData
, LPOUTLINETEXTMETRICW lpotmw
)
228 static GetOutlineTextMetricsW_Proc s_pfn_Get_Outline_Text_MetricsW
= NULL
;
229 HMODULE hm_unicows
= NULL
;
230 if (g_b_init_get_outline_metrics_w
== 0)
232 g_b_init_get_outline_metrics_w
= 1;
233 hm_unicows
= w32_load_unicows_or_gdi32 ();
235 s_pfn_Get_Outline_Text_MetricsW
= (GetOutlineTextMetricsW_Proc
)
236 GetProcAddress (hm_unicows
, "GetOutlineTextMetricsW");
238 eassert (s_pfn_Get_Outline_Text_MetricsW
!= NULL
);
239 return s_pfn_Get_Outline_Text_MetricsW (hdc
, cbData
, lpotmw
);
243 get_text_metrics_w(HDC hdc
, LPTEXTMETRICW lptmw
)
245 static GetTextMetricsW_Proc s_pfn_Get_Text_MetricsW
= NULL
;
246 HMODULE hm_unicows
= NULL
;
247 if (g_b_init_get_text_metrics_w
== 0)
249 g_b_init_get_text_metrics_w
= 1;
250 hm_unicows
= w32_load_unicows_or_gdi32 ();
252 s_pfn_Get_Text_MetricsW
= (GetTextMetricsW_Proc
)
253 GetProcAddress (hm_unicows
, "GetTextMetricsW");
255 eassert (s_pfn_Get_Text_MetricsW
!= NULL
);
256 return s_pfn_Get_Text_MetricsW (hdc
, lptmw
);
260 get_glyph_outline_w (HDC hdc
, UINT uChar
, UINT uFormat
, LPGLYPHMETRICS lpgm
,
261 DWORD cbBuffer
, LPVOID lpvBuffer
, const MAT2
*lpmat2
)
263 static GetGlyphOutlineW_Proc s_pfn_Get_Glyph_OutlineW
= NULL
;
264 HMODULE hm_unicows
= NULL
;
265 if (g_b_init_get_glyph_outline_w
== 0)
267 g_b_init_get_glyph_outline_w
= 1;
268 hm_unicows
= w32_load_unicows_or_gdi32 ();
270 s_pfn_Get_Glyph_OutlineW
= (GetGlyphOutlineW_Proc
)
271 GetProcAddress (hm_unicows
, "GetGlyphOutlineW");
273 eassert (s_pfn_Get_Glyph_OutlineW
!= NULL
);
274 return s_pfn_Get_Glyph_OutlineW (hdc
, uChar
, uFormat
, lpgm
, cbBuffer
,
279 memq_no_quit (Lisp_Object elt
, Lisp_Object list
)
281 while (CONSP (list
) && ! EQ (XCAR (list
), elt
))
283 return (CONSP (list
));
287 intern_font_name (char * string
)
289 Lisp_Object str
= DECODE_SYSTEM (build_string (string
));
290 int len
= SCHARS (str
);
291 Lisp_Object obarray
= check_obarray (Vobarray
);
292 Lisp_Object tem
= oblookup (obarray
, SDATA (str
), len
, len
);
293 /* This code is similar to intern function from lread.c. */
294 return SYMBOLP (tem
) ? tem
: Fintern (str
, obarray
);
297 /* w32 implementation of get_cache for font backend.
298 Return a cache of font-entities on FRAME. The cache must be a
299 cons whose cdr part is the actual cache area. */
301 w32font_get_cache (FRAME_PTR f
)
303 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
305 return (dpyinfo
->name_list_element
);
308 /* w32 implementation of list for font backend.
309 List fonts exactly matching with FONT_SPEC on FRAME. The value
310 is a vector of font-entities. This is the sole API that
311 allocates font-entities. */
313 w32font_list (Lisp_Object frame
, Lisp_Object font_spec
)
315 Lisp_Object fonts
= w32font_list_internal (frame
, font_spec
, 0);
316 FONT_ADD_LOG ("w32font-list", font_spec
, fonts
);
320 /* w32 implementation of match for font backend.
321 Return a font entity most closely matching with FONT_SPEC on
322 FRAME. The closeness is determined by the font backend, thus
323 `face-font-selection-order' is ignored here. */
325 w32font_match (Lisp_Object frame
, Lisp_Object font_spec
)
327 Lisp_Object entity
= w32font_match_internal (frame
, font_spec
, 0);
328 FONT_ADD_LOG ("w32font-match", font_spec
, entity
);
332 /* w32 implementation of list_family for font backend.
333 List available families. The value is a list of family names
336 w32font_list_family (Lisp_Object frame
)
338 Lisp_Object list
= Qnil
;
339 LOGFONT font_match_pattern
;
341 FRAME_PTR f
= XFRAME (frame
);
343 memset (&font_match_pattern
, 0, sizeof (font_match_pattern
));
344 font_match_pattern
.lfCharSet
= DEFAULT_CHARSET
;
346 dc
= get_frame_dc (f
);
348 EnumFontFamiliesEx (dc
, &font_match_pattern
,
349 (FONTENUMPROC
) add_font_name_to_list
,
351 release_frame_dc (f
, dc
);
356 /* w32 implementation of open for font backend.
357 Open a font specified by FONT_ENTITY on frame F.
358 If the font is scalable, open it with PIXEL_SIZE. */
360 w32font_open (FRAME_PTR f
, Lisp_Object font_entity
, int pixel_size
)
362 Lisp_Object font_object
363 = font_make_object (VECSIZE (struct w32font_info
),
364 font_entity
, pixel_size
);
365 struct w32font_info
*w32_font
366 = (struct w32font_info
*) XFONT_OBJECT (font_object
);
368 ASET (font_object
, FONT_TYPE_INDEX
, Qgdi
);
370 if (!w32font_open_internal (f
, font_entity
, pixel_size
, font_object
))
375 /* GDI backend does not use glyph indices. */
376 w32_font
->glyph_idx
= 0;
381 /* w32 implementation of close for font_backend.
382 Close FONT on frame F. */
384 w32font_close (FRAME_PTR f
, struct font
*font
)
387 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
389 /* Delete the GDI font object. */
390 DeleteObject (w32_font
->hfont
);
392 /* Free all the cached metrics. */
393 if (w32_font
->cached_metrics
)
395 for (i
= 0; i
< w32_font
->n_cache_blocks
; i
++)
397 xfree (w32_font
->cached_metrics
[i
]);
399 xfree (w32_font
->cached_metrics
);
400 w32_font
->cached_metrics
= NULL
;
404 /* w32 implementation of has_char for font backend.
406 If FONT_ENTITY has a glyph for character C (Unicode code point),
407 return 1. If not, return 0. If a font must be opened to check
410 w32font_has_char (Lisp_Object entity
, int c
)
412 /* We can't be certain about which characters a font will support until
413 we open it. Checking the scripts that the font supports turns out
414 to not be reliable. */
418 Lisp_Object supported_scripts
, extra
, script
;
421 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
425 supported_scripts
= assq_no_quit (QCscript
, extra
);
426 /* If font doesn't claim to support any scripts, then we can't be certain
428 if (!CONSP (supported_scripts
))
431 supported_scripts
= XCDR (supported_scripts
);
433 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
435 /* If we don't know what script the character is from, then we can't be
436 certain until we open it. Also if the font claims support for the script
437 the character is from, it may only have partial coverage, so we still
438 can't be certain until we open the font. */
439 if (NILP (script
) || memq_no_quit (script
, supported_scripts
))
442 /* Font reports what scripts it supports, and none of them are the script
443 the character is from. But we still can't be certain, as some fonts
444 will contain some/most/all of the characters in that script without
445 claiming support for it. */
450 /* w32 implementation of encode_char for font backend.
451 Return a glyph code of FONT for character C (Unicode code point).
452 If FONT doesn't have such a glyph, return FONT_INVALID_CODE.
454 For speed, the gdi backend uses Unicode (Emacs calls encode_char
455 far too often for it to be efficient). But we still need to detect
456 which characters are not supported by the font.
459 w32font_encode_char (struct font
*font
, int c
)
461 struct w32font_info
* w32_font
= (struct w32font_info
*)font
;
463 if (c
< w32_font
->metrics
.tmFirstChar
464 || c
> w32_font
->metrics
.tmLastChar
)
465 return FONT_INVALID_CODE
;
470 /* w32 implementation of text_extents for font backend.
471 Perform the size computation of glyphs of FONT and fillin members
472 of METRICS. The glyphs are specified by their glyph codes in
473 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
474 case just return the overall width. */
476 w32font_text_extents (struct font
*font
, unsigned *code
,
477 int nglyphs
, struct font_metrics
*metrics
)
480 HFONT old_font
= NULL
;
487 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
491 memset (metrics
, 0, sizeof (struct font_metrics
));
492 metrics
->ascent
= font
->ascent
;
493 metrics
->descent
= font
->descent
;
495 for (i
= 0; i
< nglyphs
; i
++)
497 struct w32_metric_cache
*char_metric
;
498 int block
= *(code
+ i
) / CACHE_BLOCKSIZE
;
499 int pos_in_block
= *(code
+ i
) % CACHE_BLOCKSIZE
;
501 if (block
>= w32_font
->n_cache_blocks
)
503 if (!w32_font
->cached_metrics
)
504 w32_font
->cached_metrics
505 = xmalloc ((block
+ 1)
506 * sizeof (struct w32_metric_cache
*));
508 w32_font
->cached_metrics
509 = xrealloc (w32_font
->cached_metrics
,
511 * sizeof (struct w32_metric_cache
*));
512 memset (w32_font
->cached_metrics
+ w32_font
->n_cache_blocks
, 0,
513 ((block
+ 1 - w32_font
->n_cache_blocks
)
514 * sizeof (struct w32_metric_cache
*)));
515 w32_font
->n_cache_blocks
= block
+ 1;
518 if (!w32_font
->cached_metrics
[block
])
520 w32_font
->cached_metrics
[block
]
521 = xzalloc (CACHE_BLOCKSIZE
* sizeof (struct w32_metric_cache
));
524 char_metric
= w32_font
->cached_metrics
[block
] + pos_in_block
;
526 if (char_metric
->status
== W32METRIC_NO_ATTEMPT
)
530 /* TODO: Frames can come and go, and their fonts
531 outlive them. So we can't cache the frame in the
532 font structure. Use selected_frame until the API
533 is updated to pass in a frame. */
534 f
= XFRAME (selected_frame
);
536 dc
= get_frame_dc (f
);
537 old_font
= SelectObject (dc
, w32_font
->hfont
);
539 compute_metrics (dc
, w32_font
, *(code
+ i
), char_metric
);
542 if (char_metric
->status
== W32METRIC_SUCCESS
)
544 metrics
->lbearing
= min (metrics
->lbearing
,
545 metrics
->width
+ char_metric
->lbearing
);
546 metrics
->rbearing
= max (metrics
->rbearing
,
547 metrics
->width
+ char_metric
->rbearing
);
548 metrics
->width
+= char_metric
->width
;
551 /* If we couldn't get metrics for a char,
552 use alternative method. */
555 /* If we got through everything, return. */
560 /* Restore state and release DC. */
561 SelectObject (dc
, old_font
);
562 release_frame_dc (f
, dc
);
565 return metrics
->width
;
569 /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
570 fallback on other methods that will at least give some of the metric
573 /* Make array big enough to hold surrogates. */
574 wcode
= alloca (nglyphs
* sizeof (WORD
) * 2);
575 for (i
= 0; i
< nglyphs
; i
++)
577 if (code
[i
] < 0x10000)
581 DWORD surrogate
= code
[i
] - 0x10000;
583 /* High surrogate: U+D800 - U+DBFF. */
584 wcode
[i
++] = 0xD800 + ((surrogate
>> 10) & 0x03FF);
585 /* Low surrogate: U+DC00 - U+DFFF. */
586 wcode
[i
] = 0xDC00 + (surrogate
& 0x03FF);
587 /* An extra glyph. wcode is already double the size of code to
595 /* TODO: Frames can come and go, and their fonts outlive
596 them. So we can't cache the frame in the font structure. Use
597 selected_frame until the API is updated to pass in a
599 f
= XFRAME (selected_frame
);
601 dc
= get_frame_dc (f
);
602 old_font
= SelectObject (dc
, w32_font
->hfont
);
605 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
607 total_width
= size
.cx
;
610 /* On 95/98/ME, only some Unicode functions are available, so fallback
611 on doing a dummy draw to find the total width. */
615 rect
.top
= 0; rect
.bottom
= font
->height
; rect
.left
= 0; rect
.right
= 1;
616 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
617 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
618 total_width
= rect
.right
;
621 /* Give our best estimate of the metrics, based on what we know. */
624 metrics
->width
= total_width
- w32_font
->metrics
.tmOverhang
;
625 metrics
->lbearing
= 0;
626 metrics
->rbearing
= total_width
;
629 /* Restore state and release DC. */
630 SelectObject (dc
, old_font
);
631 release_frame_dc (f
, dc
);
636 /* w32 implementation of draw for font backend.
638 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
639 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
640 is nonzero, fill the background in advance. It is assured that
641 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
643 TODO: Currently this assumes that the colors and fonts are already
644 set in the DC. This seems to be true now, but maybe only due to
645 the old font code setting it up. It may be safer to resolve faces
646 and fonts in here and set them explicitly
650 w32font_draw (struct glyph_string
*s
, int from
, int to
,
651 int x
, int y
, int with_background
)
654 HRGN orig_clip
= NULL
;
656 struct w32font_info
*w32font
= (struct w32font_info
*) s
->font
;
658 options
= w32font
->glyph_idx
;
660 if (s
->num_clips
> 0)
662 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
664 /* Save clip region for later restoration. */
665 orig_clip
= CreateRectRgn (0, 0, 0, 0);
666 if (!GetClipRgn (s
->hdc
, orig_clip
))
668 DeleteObject (orig_clip
);
672 if (s
->num_clips
> 1)
674 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
676 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
677 DeleteObject (clip2
);
680 SelectClipRgn (s
->hdc
, new_clip
);
681 DeleteObject (new_clip
);
684 /* Using OPAQUE background mode can clear more background than expected
685 when Cleartype is used. Draw the background manually to avoid this. */
686 SetBkMode (s
->hdc
, TRANSPARENT
);
691 struct font
*font
= s
->font
;
693 brush
= CreateSolidBrush (s
->gc
->background
);
695 rect
.top
= y
- font
->ascent
;
696 rect
.right
= x
+ s
->width
;
697 rect
.bottom
= y
+ font
->descent
;
698 FillRect (s
->hdc
, &rect
, brush
);
699 DeleteObject (brush
);
706 for (i
= 0; i
< len
; i
++)
707 ExtTextOutW (s
->hdc
, x
+ i
, y
, options
, NULL
,
708 s
->char2b
+ from
+ i
, 1, NULL
);
711 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, len
, NULL
);
713 /* Restore clip region. */
714 if (s
->num_clips
> 0)
715 SelectClipRgn (s
->hdc
, orig_clip
);
718 DeleteObject (orig_clip
);
723 /* w32 implementation of free_entity for font backend.
724 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
725 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
727 w32font_free_entity (Lisp_Object entity);
730 /* w32 implementation of prepare_face for font backend.
731 Optional (if FACE->extra is not used).
732 Prepare FACE for displaying characters by FONT on frame F by
733 storing some data in FACE->extra. If successful, return 0.
734 Otherwise, return -1.
736 w32font_prepare_face (FRAME_PTR f, struct face *face);
738 /* w32 implementation of done_face for font backend.
740 Done FACE for displaying characters by FACE->font on frame F.
742 w32font_done_face (FRAME_PTR f, struct face *face); */
744 /* w32 implementation of get_bitmap for font backend.
746 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
747 intended that this method is called from the other font-driver
750 w32font_get_bitmap (struct font *font, unsigned code,
751 struct font_bitmap *bitmap, int bits_per_pixel);
753 /* w32 implementation of free_bitmap for font backend.
755 Free bitmap data in BITMAP.
757 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
759 /* w32 implementation of get_outline for font backend.
761 Return an outline data for glyph-code CODE of FONT. The format
762 of the outline data depends on the font-driver.
764 w32font_get_outline (struct font *font, unsigned code);
766 /* w32 implementation of free_outline for font backend.
768 Free OUTLINE (that is obtained by the above method).
770 w32font_free_outline (struct font *font, void *outline);
772 /* w32 implementation of anchor_point for font backend.
774 Get coordinates of the INDEXth anchor point of the glyph whose
775 code is CODE. Store the coordinates in *X and *Y. Return 0 if
776 the operations was successful. Otherwise return -1.
778 w32font_anchor_point (struct font *font, unsigned code,
779 int index, int *x, int *y);
781 /* w32 implementation of otf_capability for font backend.
783 Return a list describing which scripts/languages FONT
784 supports by which GSUB/GPOS features of OpenType tables.
786 w32font_otf_capability (struct font *font);
788 /* w32 implementation of otf_drive for font backend.
790 Apply FONT's OTF-FEATURES to the glyph string.
792 FEATURES specifies which OTF features to apply in this format:
793 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
794 See the documentation of `font-drive-otf' for the detail.
796 This method applies the specified features to the codes in the
797 elements of GSTRING-IN (between FROMth and TOth). The output
798 codes are stored in GSTRING-OUT at the IDXth element and the
801 Return the number of output codes. If none of the features are
802 applicable to the input data, return 0. If GSTRING-OUT is too
805 w32font_otf_drive (struct font *font, Lisp_Object features,
806 Lisp_Object gstring_in, int from, int to,
807 Lisp_Object gstring_out, int idx,
808 int alternate_subst);
811 /* Internal implementation of w32font_list.
812 Additional parameter opentype_only restricts the returned fonts to
813 opentype fonts, which can be used with the Uniscribe backend. */
815 w32font_list_internal (Lisp_Object frame
, Lisp_Object font_spec
, int opentype_only
)
817 struct font_callback_data match_data
;
819 FRAME_PTR f
= XFRAME (frame
);
821 match_data
.orig_font_spec
= font_spec
;
822 match_data
.list
= Qnil
;
823 match_data
.frame
= frame
;
825 memset (&match_data
.pattern
, 0, sizeof (LOGFONT
));
826 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
828 /* If the charset is unrecognized, then we won't find a font, so don't
829 waste time looking for one. */
830 if (match_data
.pattern
.lfCharSet
== DEFAULT_CHARSET
)
832 Lisp_Object spec_charset
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
833 if (!NILP (spec_charset
)
834 && !EQ (spec_charset
, Qiso10646_1
)
835 && !EQ (spec_charset
, Qunicode_bmp
)
836 && !EQ (spec_charset
, Qunicode_sip
)
837 && !EQ (spec_charset
, Qunknown
))
841 match_data
.opentype_only
= opentype_only
;
843 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
845 if (match_data
.pattern
.lfFaceName
[0] == '\0')
847 /* EnumFontFamiliesEx does not take other fields into account if
848 font name is blank, so need to use two passes. */
849 list_all_matching_fonts (&match_data
);
853 dc
= get_frame_dc (f
);
855 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
856 (FONTENUMPROC
) add_font_entity_to_list
,
857 (LPARAM
) &match_data
, 0);
858 release_frame_dc (f
, dc
);
861 return match_data
.list
;
864 /* Internal implementation of w32font_match.
865 Additional parameter opentype_only restricts the returned fonts to
866 opentype fonts, which can be used with the Uniscribe backend. */
868 w32font_match_internal (Lisp_Object frame
, Lisp_Object font_spec
, int opentype_only
)
870 struct font_callback_data match_data
;
872 FRAME_PTR f
= XFRAME (frame
);
874 match_data
.orig_font_spec
= font_spec
;
875 match_data
.frame
= frame
;
876 match_data
.list
= Qnil
;
878 memset (&match_data
.pattern
, 0, sizeof (LOGFONT
));
879 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
881 match_data
.opentype_only
= opentype_only
;
883 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
885 dc
= get_frame_dc (f
);
887 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
888 (FONTENUMPROC
) add_one_font_entity_to_list
,
889 (LPARAM
) &match_data
, 0);
890 release_frame_dc (f
, dc
);
892 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
896 w32font_open_internal (FRAME_PTR f
, Lisp_Object font_entity
,
897 int pixel_size
, Lisp_Object font_object
)
902 HFONT hfont
, old_font
;
903 Lisp_Object val
, extra
;
904 struct w32font_info
*w32_font
;
906 OUTLINETEXTMETRICW
* metrics
= NULL
;
908 w32_font
= (struct w32font_info
*) XFONT_OBJECT (font_object
);
909 font
= (struct font
*) w32_font
;
914 memset (&logfont
, 0, sizeof (logfont
));
915 fill_in_logfont (f
, &logfont
, font_entity
);
917 /* Prefer truetype fonts, to avoid known problems with type1 fonts, and
918 limitations in bitmap fonts. */
919 val
= AREF (font_entity
, FONT_FOUNDRY_INDEX
);
920 if (!EQ (val
, Qraster
))
921 logfont
.lfOutPrecision
= OUT_TT_PRECIS
;
923 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
927 logfont
.lfHeight
= -size
;
928 hfont
= CreateFontIndirect (&logfont
);
933 /* Get the metrics for this font. */
934 dc
= get_frame_dc (f
);
935 old_font
= SelectObject (dc
, hfont
);
937 /* Try getting the outline metrics (only works for truetype fonts). */
938 len
= get_outline_metrics_w (dc
, 0, NULL
);
941 metrics
= (OUTLINETEXTMETRICW
*) alloca (len
);
942 if (get_outline_metrics_w (dc
, len
, metrics
))
943 memcpy (&w32_font
->metrics
, &metrics
->otmTextMetrics
,
944 sizeof (TEXTMETRICW
));
950 get_text_metrics_w (dc
, &w32_font
->metrics
);
952 w32_font
->cached_metrics
= NULL
;
953 w32_font
->n_cache_blocks
= 0;
955 SelectObject (dc
, old_font
);
956 release_frame_dc (f
, dc
);
958 w32_font
->hfont
= hfont
;
963 /* We don't know how much space we need for the full name, so start with
964 96 bytes and go up in steps of 32. */
967 while (name
&& w32font_full_name (&logfont
, font_entity
, pixel_size
,
974 font
->props
[FONT_FULLNAME_INDEX
]
975 = DECODE_SYSTEM (build_string (name
));
977 font
->props
[FONT_FULLNAME_INDEX
]
978 = DECODE_SYSTEM (build_string (logfont
.lfFaceName
));
981 font
->max_width
= w32_font
->metrics
.tmMaxCharWidth
;
982 /* Parts of Emacs display assume that height = ascent + descent...
983 so height is defined later, after ascent and descent.
984 font->height = w32_font->metrics.tmHeight
985 + w32_font->metrics.tmExternalLeading;
988 font
->space_width
= font
->average_width
= w32_font
->metrics
.tmAveCharWidth
;
990 font
->vertical_centering
= 0;
991 font
->encoding_type
= 0;
992 font
->baseline_offset
= 0;
993 font
->relative_compose
= 0;
994 font
->default_ascent
= w32_font
->metrics
.tmAscent
;
995 font
->font_encoder
= NULL
;
996 font
->pixel_size
= size
;
997 font
->driver
= &w32font_driver
;
998 /* Use format cached during list, as the information we have access to
999 here is incomplete. */
1000 extra
= AREF (font_entity
, FONT_EXTRA_INDEX
);
1003 val
= assq_no_quit (QCformat
, extra
);
1005 font
->props
[FONT_FORMAT_INDEX
] = XCDR (val
);
1007 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
1010 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
1012 font
->props
[FONT_FILE_INDEX
] = Qnil
;
1013 font
->encoding_charset
= -1;
1014 font
->repertory_charset
= -1;
1015 /* TODO: do we really want the minimum width here, which could be negative? */
1016 font
->min_width
= font
->space_width
;
1017 font
->ascent
= w32_font
->metrics
.tmAscent
;
1018 font
->descent
= w32_font
->metrics
.tmDescent
;
1019 font
->height
= font
->ascent
+ font
->descent
;
1023 font
->underline_thickness
= metrics
->otmsUnderscoreSize
;
1024 font
->underline_position
= -metrics
->otmsUnderscorePosition
;
1028 font
->underline_thickness
= 0;
1029 font
->underline_position
= -1;
1032 /* For temporary compatibility with legacy code that expects the
1033 name to be usable in x-list-fonts. Eventually we expect to change
1034 x-list-fonts and other places that use fonts so that this can be
1035 an fcname or similar. */
1036 font
->props
[FONT_NAME_INDEX
] = Ffont_xlfd_name (font_object
, Qnil
);
1041 /* Callback function for EnumFontFamiliesEx.
1042 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
1044 add_font_name_to_list (ENUMLOGFONTEX
*logical_font
,
1045 NEWTEXTMETRICEX
*physical_font
,
1046 DWORD font_type
, LPARAM list_object
)
1048 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
1051 /* Skip vertical fonts (intended only for printing) */
1052 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
1055 family
= intern_font_name (logical_font
->elfLogFont
.lfFaceName
);
1056 if (! memq_no_quit (family
, *list
))
1057 *list
= Fcons (family
, *list
);
1062 static int w32_decode_weight (int);
1063 static int w32_encode_weight (int);
1065 /* Convert an enumerated Windows font to an Emacs font entity. */
1067 w32_enumfont_pattern_entity (Lisp_Object frame
,
1068 ENUMLOGFONTEX
*logical_font
,
1069 NEWTEXTMETRICEX
*physical_font
,
1071 LOGFONT
*requested_font
,
1072 Lisp_Object backend
)
1074 Lisp_Object entity
, tem
;
1075 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
1077 DWORD full_type
= physical_font
->ntmTm
.ntmFlags
;
1079 entity
= font_make_entity ();
1081 ASET (entity
, FONT_TYPE_INDEX
, backend
);
1082 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
, font_type
));
1083 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
1085 /* Foundry is difficult to get in readable form on Windows.
1086 But Emacs crashes if it is not set, so set it to something more
1087 generic. These values make xlfds compatible with Emacs 22. */
1088 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
1090 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
1095 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
1097 /* Save the generic family in the extra info, as it is likely to be
1098 useful to users looking for a close match. */
1099 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
1100 if (generic_type
== FF_DECORATIVE
)
1102 else if (generic_type
== FF_MODERN
)
1104 else if (generic_type
== FF_ROMAN
)
1106 else if (generic_type
== FF_SCRIPT
)
1108 else if (generic_type
== FF_SWISS
)
1113 ASET (entity
, FONT_ADSTYLE_INDEX
, tem
);
1115 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
1116 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_PROPORTIONAL
));
1118 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_CHARCELL
));
1120 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
1122 font_put_extra (entity
, QCantialias
,
1123 lispy_antialias_type (requested_font
->lfQuality
));
1125 ASET (entity
, FONT_FAMILY_INDEX
,
1126 intern_font_name (lf
->lfFaceName
));
1128 FONT_SET_STYLE (entity
, FONT_WEIGHT_INDEX
,
1129 make_number (w32_decode_weight (lf
->lfWeight
)));
1130 FONT_SET_STYLE (entity
, FONT_SLANT_INDEX
,
1131 make_number (lf
->lfItalic
? 200 : 100));
1132 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
1134 FONT_SET_STYLE (entity
, FONT_WIDTH_INDEX
, make_number (100));
1136 if (font_type
& RASTER_FONTTYPE
)
1137 ASET (entity
, FONT_SIZE_INDEX
,
1138 make_number (physical_font
->ntmTm
.tmHeight
1139 + physical_font
->ntmTm
.tmExternalLeading
));
1141 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
1143 /* Cache Unicode codepoints covered by this font, as there is no other way
1144 of getting this information easily. */
1145 if (font_type
& TRUETYPE_FONTTYPE
)
1147 tem
= font_supported_scripts (&physical_font
->ntmFontSig
);
1149 font_put_extra (entity
, QCscript
, tem
);
1152 /* This information is not fully available when opening fonts, so
1153 save it here. Only Windows 2000 and later return information
1154 about opentype and type1 fonts, so need a fallback for detecting
1155 truetype so that this information is not any worse than we could
1156 have obtained later. */
1157 if (EQ (backend
, Quniscribe
) && (full_type
& NTMFLAGS_OPENTYPE
))
1158 tem
= intern ("opentype");
1159 else if (font_type
& TRUETYPE_FONTTYPE
)
1160 tem
= intern ("truetype");
1161 else if (full_type
& NTM_PS_OPENTYPE
)
1162 tem
= intern ("postscript");
1163 else if (full_type
& NTM_TYPE1
)
1164 tem
= intern ("type1");
1165 else if (font_type
& RASTER_FONTTYPE
)
1166 tem
= intern ("w32bitmap");
1168 tem
= intern ("w32vector");
1170 font_put_extra (entity
, QCformat
, tem
);
1176 /* Convert generic families to the family portion of lfPitchAndFamily. */
1178 w32_generic_family (Lisp_Object name
)
1180 /* Generic families. */
1181 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
1183 else if (EQ (name
, Qsans
) || EQ (name
, Qsans_serif
) || EQ (name
, Qsansserif
))
1185 else if (EQ (name
, Qserif
))
1187 else if (EQ (name
, Qdecorative
))
1188 return FF_DECORATIVE
;
1189 else if (EQ (name
, Qscript
))
1196 logfonts_match (LOGFONT
*font
, LOGFONT
*pattern
)
1198 /* Only check height for raster fonts. */
1199 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
1200 && font
->lfHeight
!= pattern
->lfHeight
)
1203 /* Have some flexibility with weights. */
1204 if (pattern
->lfWeight
1205 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
1206 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
1209 /* Charset and face should be OK. Italic has to be checked
1210 against the original spec, in case we don't have any preference. */
1214 /* Codepage Bitfields in FONTSIGNATURE struct. */
1215 #define CSB_JAPANESE (1 << 17)
1216 #define CSB_KOREAN ((1 << 19) | (1 << 21))
1217 #define CSB_CHINESE ((1 << 18) | (1 << 20))
1220 font_matches_spec (DWORD type
, NEWTEXTMETRICEX
*font
,
1221 Lisp_Object spec
, Lisp_Object backend
,
1224 Lisp_Object extra
, val
;
1226 /* Check italic. Can't check logfonts, since it is a boolean field,
1227 so there is no difference between "non-italic" and "don't care". */
1229 int slant
= FONT_SLANT_NUMERIC (spec
);
1232 && ((slant
> 150 && !font
->ntmTm
.tmItalic
)
1233 || (slant
<= 150 && font
->ntmTm
.tmItalic
)))
1237 /* Check adstyle against generic family. */
1238 val
= AREF (spec
, FONT_ADSTYLE_INDEX
);
1241 BYTE family
= w32_generic_family (val
);
1242 if (family
!= FF_DONTCARE
1243 && family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
1248 val
= AREF (spec
, FONT_SPACING_INDEX
);
1251 int spacing
= XINT (val
);
1252 int proportional
= (spacing
< FONT_SPACING_MONO
);
1254 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
1255 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
1259 /* Check extra parameters. */
1260 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
1261 CONSP (extra
); extra
= XCDR (extra
))
1263 Lisp_Object extra_entry
;
1264 extra_entry
= XCAR (extra
);
1265 if (CONSP (extra_entry
))
1267 Lisp_Object key
= XCAR (extra_entry
);
1269 val
= XCDR (extra_entry
);
1270 if (EQ (key
, QCscript
) && SYMBOLP (val
))
1272 /* Only truetype fonts will have information about what
1273 scripts they support. This probably means the user
1274 will have to force Emacs to use raster, PostScript
1275 or ATM fonts for non-ASCII text. */
1276 if (type
& TRUETYPE_FONTTYPE
)
1279 = font_supported_scripts (&font
->ntmFontSig
);
1280 if (! memq_no_quit (val
, support
))
1283 /* Avoid using non-Japanese fonts for Japanese, even
1284 if they claim they are capable, due to known
1285 breakage in Vista and Windows 7 fonts
1288 && (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
1289 || !(font
->ntmFontSig
.fsCsb
[0] & CSB_JAPANESE
)))
1294 /* Return specific matches, but play it safe. Fonts
1295 that cover more than their charset would suggest
1296 are likely to be truetype or opentype fonts,
1298 if (EQ (val
, Qlatin
))
1300 /* Although every charset but symbol, thai and
1301 arabic contains the basic ASCII set of latin
1302 characters, Emacs expects much more. */
1303 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
1306 else if (EQ (val
, Qsymbol
))
1308 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
1311 else if (EQ (val
, Qcyrillic
))
1313 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
1316 else if (EQ (val
, Qgreek
))
1318 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
1321 else if (EQ (val
, Qarabic
))
1323 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
1326 else if (EQ (val
, Qhebrew
))
1328 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
1331 else if (EQ (val
, Qthai
))
1333 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
1336 else if (EQ (val
, Qkana
))
1338 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1341 else if (EQ (val
, Qbopomofo
))
1343 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1346 else if (EQ (val
, Qhangul
))
1348 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1349 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1352 else if (EQ (val
, Qhan
))
1354 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
1355 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1356 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1357 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
1358 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1362 /* Other scripts unlikely to be handled by non-truetype
1367 else if (EQ (key
, QClang
) && SYMBOLP (val
))
1369 /* Just handle the CJK languages here, as the lang
1370 parameter is used to select a font with appropriate
1371 glyphs in the cjk unified ideographs block. Other fonts
1372 support for a language can be solely determined by
1373 its character coverage. */
1376 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_JAPANESE
))
1379 else if (EQ (val
, Qko
))
1381 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_KOREAN
))
1384 else if (EQ (val
, Qzh
))
1386 if (!(font
->ntmFontSig
.fsCsb
[0] & CSB_CHINESE
))
1390 /* Any other language, we don't recognize it. Only the above
1391 currently appear in fontset.el, so it isn't worth
1392 creating a mapping table of codepages/scripts to languages
1393 or opening the font to see if there are any language tags
1394 in it that the Windows API does not expose. Fontset
1395 spec should have a fallback, as some backends do
1396 not recognize language at all. */
1399 else if (EQ (key
, QCotf
) && CONSP (val
))
1401 /* OTF features only supported by the uniscribe backend. */
1402 if (EQ (backend
, Quniscribe
))
1404 if (!uniscribe_check_otf (logfont
, val
))
1416 w32font_coverage_ok (FONTSIGNATURE
* coverage
, BYTE charset
)
1418 DWORD subrange1
= coverage
->fsUsb
[1];
1420 #define SUBRANGE1_HAN_MASK 0x08000000
1421 #define SUBRANGE1_HANGEUL_MASK 0x01000000
1422 #define SUBRANGE1_JAPANESE_MASK (0x00060000 | SUBRANGE1_HAN_MASK)
1424 if (charset
== GB2312_CHARSET
|| charset
== CHINESEBIG5_CHARSET
)
1426 return (subrange1
& SUBRANGE1_HAN_MASK
) == SUBRANGE1_HAN_MASK
;
1428 else if (charset
== SHIFTJIS_CHARSET
)
1430 return (subrange1
& SUBRANGE1_JAPANESE_MASK
) == SUBRANGE1_JAPANESE_MASK
;
1432 else if (charset
== HANGEUL_CHARSET
)
1434 return (subrange1
& SUBRANGE1_HANGEUL_MASK
) == SUBRANGE1_HANGEUL_MASK
;
1441 #define _strlwr strlwr
1442 #endif /* !WINDOWSNT */
1445 check_face_name (LOGFONT
*font
, char *full_name
)
1447 char full_iname
[LF_FULLFACESIZE
+1];
1449 /* Just check for names known to cause problems, since the full name
1450 can contain expanded abbreviations, prefixed foundry, postfixed
1451 style, the latter of which sometimes differs from the style indicated
1452 in the shorter name (eg Lt becomes Light or even Extra Light) */
1454 /* Helvetica is mapped to Arial in Windows, but if a Type-1 Helvetica is
1455 installed, we run into problems with the Uniscribe backend which tries
1456 to avoid non-truetype fonts, and ends up mixing the Type-1 Helvetica
1457 with Arial's characteristics, since that attempt to use TrueType works
1458 some places, but not others. */
1459 if (!xstrcasecmp (font
->lfFaceName
, "helvetica"))
1461 strncpy (full_iname
, full_name
, LF_FULLFACESIZE
);
1462 full_iname
[LF_FULLFACESIZE
] = 0;
1463 _strlwr (full_iname
);
1464 return strstr ("helvetica", full_iname
) != NULL
;
1466 /* Same for Helv. */
1467 if (!xstrcasecmp (font
->lfFaceName
, "helv"))
1469 strncpy (full_iname
, full_name
, LF_FULLFACESIZE
);
1470 full_iname
[LF_FULLFACESIZE
] = 0;
1471 _strlwr (full_iname
);
1472 return strstr ("helv", full_iname
) != NULL
;
1475 /* Since Times is mapped to Times New Roman, a substring
1476 match is not sufficient to filter out the bogus match. */
1477 else if (!xstrcasecmp (font
->lfFaceName
, "times"))
1478 return xstrcasecmp (full_name
, "times") == 0;
1484 /* Callback function for EnumFontFamiliesEx.
1485 * Checks if a font matches everything we are trying to check against,
1486 * and if so, adds it to a list. Both the data we are checking against
1487 * and the list to which the fonts are added are passed in via the
1488 * lparam argument, in the form of a font_callback_data struct. */
1490 add_font_entity_to_list (ENUMLOGFONTEX
*logical_font
,
1491 NEWTEXTMETRICEX
*physical_font
,
1492 DWORD font_type
, LPARAM lParam
)
1494 struct font_callback_data
*match_data
1495 = (struct font_callback_data
*) lParam
;
1496 Lisp_Object backend
= match_data
->opentype_only
? Quniscribe
: Qgdi
;
1499 int is_unicode
= physical_font
->ntmFontSig
.fsUsb
[3]
1500 || physical_font
->ntmFontSig
.fsUsb
[2]
1501 || physical_font
->ntmFontSig
.fsUsb
[1]
1502 || physical_font
->ntmFontSig
.fsUsb
[0] & 0x3fffffff;
1504 /* Skip non matching fonts. */
1506 /* For uniscribe backend, consider only truetype or opentype fonts
1507 that have some Unicode coverage. */
1508 if (match_data
->opentype_only
1509 && ((!(physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
)
1510 && !(font_type
& TRUETYPE_FONTTYPE
))
1514 /* Ensure a match. */
1515 if (!logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1516 || !font_matches_spec (font_type
, physical_font
,
1517 match_data
->orig_font_spec
, backend
,
1518 &logical_font
->elfLogFont
)
1519 || !w32font_coverage_ok (&physical_font
->ntmFontSig
,
1520 match_data
->pattern
.lfCharSet
))
1523 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1524 We limit this to raster fonts, because the test can catch some
1525 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1526 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1527 therefore get through this test. Since full names can be prefixed
1528 by a foundry, we accept raster fonts if the font name is found
1529 anywhere within the full name. */
1530 if ((logical_font
->elfLogFont
.lfOutPrecision
== OUT_STRING_PRECIS
1531 && !strstr (logical_font
->elfFullName
,
1532 logical_font
->elfLogFont
.lfFaceName
))
1533 /* Check for well known substitutions that mess things up in the
1534 presence of Type-1 fonts of the same name. */
1535 || (!check_face_name (&logical_font
->elfLogFont
,
1536 logical_font
->elfFullName
)))
1539 /* Make a font entity for the font. */
1540 entity
= w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1541 physical_font
, font_type
,
1542 &match_data
->pattern
,
1547 Lisp_Object spec_charset
= AREF (match_data
->orig_font_spec
,
1548 FONT_REGISTRY_INDEX
);
1550 /* iso10646-1 fonts must contain Unicode mapping tables. */
1551 if (EQ (spec_charset
, Qiso10646_1
))
1556 /* unicode-bmp fonts must contain characters from the BMP. */
1557 else if (EQ (spec_charset
, Qunicode_bmp
))
1559 if (!physical_font
->ntmFontSig
.fsUsb
[3]
1560 && !(physical_font
->ntmFontSig
.fsUsb
[2] & 0xFFFFFF9E)
1561 && !(physical_font
->ntmFontSig
.fsUsb
[1] & 0xE81FFFFF)
1562 && !(physical_font
->ntmFontSig
.fsUsb
[0] & 0x007F001F))
1565 /* unicode-sip fonts must contain characters in Unicode plane 2.
1566 so look for bit 57 (surrogates) in the Unicode subranges, plus
1567 the bits for CJK ranges that include those characters. */
1568 else if (EQ (spec_charset
, Qunicode_sip
))
1570 if (!(physical_font
->ntmFontSig
.fsUsb
[1] & 0x02000000)
1571 || !(physical_font
->ntmFontSig
.fsUsb
[1] & 0x28000000))
1575 /* This font matches. */
1577 /* If registry was specified, ensure it is reported as the same. */
1578 if (!NILP (spec_charset
))
1580 /* Avoid using non-Japanese fonts for Japanese, even if they
1581 claim they are capable, due to known breakage in Vista
1582 and Windows 7 fonts (bug#6029). */
1583 if (logical_font
->elfLogFont
.lfCharSet
== SHIFTJIS_CHARSET
1584 && !(physical_font
->ntmFontSig
.fsCsb
[0] & CSB_JAPANESE
))
1587 ASET (entity
, FONT_REGISTRY_INDEX
, spec_charset
);
1589 /* Otherwise if using the uniscribe backend, report ANSI and DEFAULT
1590 fonts as Unicode and skip other charsets. */
1591 else if (match_data
->opentype_only
)
1593 if (logical_font
->elfLogFont
.lfCharSet
== ANSI_CHARSET
1594 || logical_font
->elfLogFont
.lfCharSet
== DEFAULT_CHARSET
)
1595 ASET (entity
, FONT_REGISTRY_INDEX
, Qiso10646_1
);
1600 /* Add this font to the list. */
1601 match_data
->list
= Fcons (entity
, match_data
->list
);
1606 /* Callback function for EnumFontFamiliesEx.
1607 * Terminates the search once we have a match. */
1609 add_one_font_entity_to_list (ENUMLOGFONTEX
*logical_font
,
1610 NEWTEXTMETRICEX
*physical_font
,
1611 DWORD font_type
, LPARAM lParam
)
1613 struct font_callback_data
*match_data
1614 = (struct font_callback_data
*) lParam
;
1615 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1617 /* If we have a font in the list, terminate the search. */
1618 return NILP (match_data
->list
);
1621 /* Old function to convert from x to w32 charset, from w32fns.c. */
1623 x_to_w32_charset (char * lpcs
)
1625 Lisp_Object this_entry
, w32_charset
;
1627 int len
= strlen (lpcs
);
1629 /* Support "*-#nnn" format for unknown charsets. */
1630 if (strncmp (lpcs
, "*-#", 3) == 0)
1631 return atoi (lpcs
+ 3);
1633 /* All Windows fonts qualify as Unicode. */
1634 if (!strncmp (lpcs
, "iso10646", 8))
1635 return DEFAULT_CHARSET
;
1637 /* Handle wildcards by ignoring them; eg. treat "big5*-*" as "big5". */
1638 charset
= alloca (len
+ 1);
1639 strcpy (charset
, lpcs
);
1640 lpcs
= strchr (charset
, '*');
1644 /* Look through w32-charset-info-alist for the character set.
1645 Format of each entry is
1646 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
1648 this_entry
= Fassoc (build_string (charset
), Vw32_charset_info_alist
);
1650 if (NILP (this_entry
))
1652 /* At startup, we want iso8859-1 fonts to come up properly. */
1653 if (xstrcasecmp (charset
, "iso8859-1") == 0)
1654 return ANSI_CHARSET
;
1656 return DEFAULT_CHARSET
;
1659 w32_charset
= Fcar (Fcdr (this_entry
));
1661 /* Translate Lisp symbol to number. */
1662 if (EQ (w32_charset
, Qw32_charset_ansi
))
1663 return ANSI_CHARSET
;
1664 if (EQ (w32_charset
, Qw32_charset_symbol
))
1665 return SYMBOL_CHARSET
;
1666 if (EQ (w32_charset
, Qw32_charset_shiftjis
))
1667 return SHIFTJIS_CHARSET
;
1668 if (EQ (w32_charset
, Qw32_charset_hangeul
))
1669 return HANGEUL_CHARSET
;
1670 if (EQ (w32_charset
, Qw32_charset_chinesebig5
))
1671 return CHINESEBIG5_CHARSET
;
1672 if (EQ (w32_charset
, Qw32_charset_gb2312
))
1673 return GB2312_CHARSET
;
1674 if (EQ (w32_charset
, Qw32_charset_oem
))
1676 if (EQ (w32_charset
, Qw32_charset_johab
))
1677 return JOHAB_CHARSET
;
1678 if (EQ (w32_charset
, Qw32_charset_easteurope
))
1679 return EASTEUROPE_CHARSET
;
1680 if (EQ (w32_charset
, Qw32_charset_turkish
))
1681 return TURKISH_CHARSET
;
1682 if (EQ (w32_charset
, Qw32_charset_baltic
))
1683 return BALTIC_CHARSET
;
1684 if (EQ (w32_charset
, Qw32_charset_russian
))
1685 return RUSSIAN_CHARSET
;
1686 if (EQ (w32_charset
, Qw32_charset_arabic
))
1687 return ARABIC_CHARSET
;
1688 if (EQ (w32_charset
, Qw32_charset_greek
))
1689 return GREEK_CHARSET
;
1690 if (EQ (w32_charset
, Qw32_charset_hebrew
))
1691 return HEBREW_CHARSET
;
1692 if (EQ (w32_charset
, Qw32_charset_vietnamese
))
1693 return VIETNAMESE_CHARSET
;
1694 if (EQ (w32_charset
, Qw32_charset_thai
))
1695 return THAI_CHARSET
;
1696 if (EQ (w32_charset
, Qw32_charset_mac
))
1699 return DEFAULT_CHARSET
;
1703 /* Convert a Lisp font registry (symbol) to a windows charset. */
1705 registry_to_w32_charset (Lisp_Object charset
)
1707 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1708 || EQ (charset
, Qunicode_sip
))
1709 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1710 else if (EQ (charset
, Qiso8859_1
))
1711 return ANSI_CHARSET
;
1712 else if (SYMBOLP (charset
))
1713 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1715 return DEFAULT_CHARSET
;
1718 /* Old function to convert from w32 to x charset, from w32fns.c. */
1720 w32_to_x_charset (int fncharset
, char *matching
)
1722 static char buf
[32];
1723 Lisp_Object charset_type
;
1728 /* If fully specified, accept it as it is. Otherwise use a
1730 char *wildcard
= strchr (matching
, '*');
1733 else if (strchr (matching
, '-'))
1736 match_len
= strlen (matching
);
1742 /* Handle startup case of w32-charset-info-alist not
1743 being set up yet. */
1744 if (NILP (Vw32_charset_info_alist
))
1746 charset_type
= Qw32_charset_ansi
;
1748 case DEFAULT_CHARSET
:
1749 charset_type
= Qw32_charset_default
;
1751 case SYMBOL_CHARSET
:
1752 charset_type
= Qw32_charset_symbol
;
1754 case SHIFTJIS_CHARSET
:
1755 charset_type
= Qw32_charset_shiftjis
;
1757 case HANGEUL_CHARSET
:
1758 charset_type
= Qw32_charset_hangeul
;
1760 case GB2312_CHARSET
:
1761 charset_type
= Qw32_charset_gb2312
;
1763 case CHINESEBIG5_CHARSET
:
1764 charset_type
= Qw32_charset_chinesebig5
;
1767 charset_type
= Qw32_charset_oem
;
1769 case EASTEUROPE_CHARSET
:
1770 charset_type
= Qw32_charset_easteurope
;
1772 case TURKISH_CHARSET
:
1773 charset_type
= Qw32_charset_turkish
;
1775 case BALTIC_CHARSET
:
1776 charset_type
= Qw32_charset_baltic
;
1778 case RUSSIAN_CHARSET
:
1779 charset_type
= Qw32_charset_russian
;
1781 case ARABIC_CHARSET
:
1782 charset_type
= Qw32_charset_arabic
;
1785 charset_type
= Qw32_charset_greek
;
1787 case HEBREW_CHARSET
:
1788 charset_type
= Qw32_charset_hebrew
;
1790 case VIETNAMESE_CHARSET
:
1791 charset_type
= Qw32_charset_vietnamese
;
1794 charset_type
= Qw32_charset_thai
;
1797 charset_type
= Qw32_charset_mac
;
1800 charset_type
= Qw32_charset_johab
;
1804 /* Encode numerical value of unknown charset. */
1805 sprintf (buf
, "*-#%u", fncharset
);
1811 char * best_match
= NULL
;
1812 int matching_found
= 0;
1814 /* Look through w32-charset-info-alist for the character set.
1815 Prefer ISO codepages, and prefer lower numbers in the ISO
1816 range. Only return charsets for codepages which are installed.
1818 Format of each entry is
1819 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
1821 for (rest
= Vw32_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
1824 Lisp_Object w32_charset
;
1825 Lisp_Object codepage
;
1827 Lisp_Object this_entry
= XCAR (rest
);
1829 /* Skip invalid entries in alist. */
1830 if (!CONSP (this_entry
) || !STRINGP (XCAR (this_entry
))
1831 || !CONSP (XCDR (this_entry
))
1832 || !SYMBOLP (XCAR (XCDR (this_entry
))))
1835 x_charset
= SDATA (XCAR (this_entry
));
1836 w32_charset
= XCAR (XCDR (this_entry
));
1837 codepage
= XCDR (XCDR (this_entry
));
1839 /* Look for Same charset and a valid codepage (or non-int
1840 which means ignore). */
1841 if (EQ (w32_charset
, charset_type
)
1842 && (!INTEGERP (codepage
) || XINT (codepage
) == CP_DEFAULT
1843 || IsValidCodePage (XINT (codepage
))))
1845 /* If we don't have a match already, then this is the
1849 best_match
= x_charset
;
1850 if (matching
&& !strnicmp (x_charset
, matching
, match_len
))
1853 /* If we already found a match for MATCHING, then
1854 only consider other matches. */
1855 else if (matching_found
1856 && strnicmp (x_charset
, matching
, match_len
))
1858 /* If this matches what we want, and the best so far doesn't,
1859 then this is better. */
1860 else if (!matching_found
&& matching
1861 && !strnicmp (x_charset
, matching
, match_len
))
1863 best_match
= x_charset
;
1866 /* If this is fully specified, and the best so far isn't,
1867 then this is better. */
1868 else if ((!strchr (best_match
, '-') && strchr (x_charset
, '-'))
1869 /* If this is an ISO codepage, and the best so far isn't,
1870 then this is better, but only if it fully specifies the
1872 || (strnicmp (best_match
, "iso", 3) != 0
1873 && strnicmp (x_charset
, "iso", 3) == 0
1874 && strchr (x_charset
, '-')))
1875 best_match
= x_charset
;
1876 /* If both are ISO8859 codepages, choose the one with the
1877 lowest number in the encoding field. */
1878 else if (strnicmp (best_match
, "iso8859-", 8) == 0
1879 && strnicmp (x_charset
, "iso8859-", 8) == 0)
1881 int best_enc
= atoi (best_match
+ 8);
1882 int this_enc
= atoi (x_charset
+ 8);
1883 if (this_enc
> 0 && this_enc
< best_enc
)
1884 best_match
= x_charset
;
1889 /* If no match, encode the numeric value. */
1892 sprintf (buf
, "*-#%u", fncharset
);
1896 strncpy (buf
, best_match
, 31);
1897 /* If the charset is not fully specified, put -0 on the end. */
1898 if (!strchr (best_match
, '-'))
1900 int pos
= strlen (best_match
);
1901 /* Charset specifiers shouldn't be very long. If it is a made
1902 up one, truncating it should not do any harm since it isn't
1903 recognized anyway. */
1906 strcpy (buf
+ pos
, "-0");
1914 w32_registry (LONG w32_charset
, DWORD font_type
)
1918 /* If charset is defaulted, charset is Unicode or unknown, depending on
1920 if (w32_charset
== DEFAULT_CHARSET
)
1921 return font_type
== TRUETYPE_FONTTYPE
? Qiso10646_1
: Qunknown
;
1923 charset
= w32_to_x_charset (w32_charset
, NULL
);
1924 return font_intern_prop (charset
, strlen (charset
), 1);
1928 w32_decode_weight (int fnweight
)
1930 if (fnweight
>= FW_HEAVY
) return 210;
1931 if (fnweight
>= FW_EXTRABOLD
) return 205;
1932 if (fnweight
>= FW_BOLD
) return 200;
1933 if (fnweight
>= FW_SEMIBOLD
) return 180;
1934 if (fnweight
>= FW_NORMAL
) return 100;
1935 if (fnweight
>= FW_LIGHT
) return 50;
1936 if (fnweight
>= FW_EXTRALIGHT
) return 40;
1937 if (fnweight
> FW_THIN
) return 20;
1942 w32_encode_weight (int n
)
1944 if (n
>= 210) return FW_HEAVY
;
1945 if (n
>= 205) return FW_EXTRABOLD
;
1946 if (n
>= 200) return FW_BOLD
;
1947 if (n
>= 180) return FW_SEMIBOLD
;
1948 if (n
>= 100) return FW_NORMAL
;
1949 if (n
>= 50) return FW_LIGHT
;
1950 if (n
>= 40) return FW_EXTRALIGHT
;
1951 if (n
>= 20) return FW_THIN
;
1955 /* Convert a Windows font weight into one of the weights supported
1956 by fontconfig (see font.c:font_parse_fcname). */
1958 w32_to_fc_weight (int n
)
1960 if (n
>= FW_EXTRABOLD
) return intern ("black");
1961 if (n
>= FW_BOLD
) return intern ("bold");
1962 if (n
>= FW_SEMIBOLD
) return intern ("demibold");
1963 if (n
>= FW_NORMAL
) return intern ("medium");
1964 return intern ("light");
1967 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1969 fill_in_logfont (FRAME_PTR f
, LOGFONT
*logfont
, Lisp_Object font_spec
)
1971 Lisp_Object tmp
, extra
;
1972 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1974 tmp
= AREF (font_spec
, FONT_DPI_INDEX
);
1979 else if (FLOATP (tmp
))
1981 dpi
= (int) (XFLOAT_DATA (tmp
) + 0.5);
1985 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1987 logfont
->lfHeight
= -1 * XINT (tmp
);
1988 else if (FLOATP (tmp
))
1989 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1996 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1998 logfont
->lfWeight
= w32_encode_weight (FONT_WEIGHT_NUMERIC (font_spec
));
2001 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
2004 int slant
= FONT_SLANT_NUMERIC (font_spec
);
2005 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
2013 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
2015 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
2017 logfont
->lfCharSet
= DEFAULT_CHARSET
;
2021 /* Clip Precision */
2024 logfont
->lfQuality
= DEFAULT_QUALITY
;
2026 /* Generic Family and Face Name */
2027 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
2029 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
2032 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
2033 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
2034 ; /* Font name was generic, don't fill in font name. */
2035 /* Font families are interned, but allow for strings also in case of
2037 else if (SYMBOLP (tmp
))
2039 strncpy (logfont
->lfFaceName
,
2040 SDATA (ENCODE_SYSTEM (SYMBOL_NAME (tmp
))), LF_FACESIZE
);
2041 logfont
->lfFaceName
[LF_FACESIZE
-1] = '\0';
2045 tmp
= AREF (font_spec
, FONT_ADSTYLE_INDEX
);
2048 /* Override generic family. */
2049 BYTE family
= w32_generic_family (tmp
);
2050 if (family
!= FF_DONTCARE
)
2051 logfont
->lfPitchAndFamily
= family
| DEFAULT_PITCH
;
2054 /* Set pitch based on the spacing property. */
2055 tmp
= AREF (font_spec
, FONT_SPACING_INDEX
);
2058 int spacing
= XINT (tmp
);
2059 if (spacing
< FONT_SPACING_MONO
)
2060 logfont
->lfPitchAndFamily
2061 = (logfont
->lfPitchAndFamily
& 0xF0) | VARIABLE_PITCH
;
2063 logfont
->lfPitchAndFamily
2064 = (logfont
->lfPitchAndFamily
& 0xF0) | FIXED_PITCH
;
2067 /* Process EXTRA info. */
2068 for (extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
2069 CONSP (extra
); extra
= XCDR (extra
))
2074 Lisp_Object key
, val
;
2075 key
= XCAR (tmp
), val
= XCDR (tmp
);
2076 /* Only use QCscript if charset is not provided, or is Unicode
2077 and a single script is specified. This is rather crude,
2078 and is only used to narrow down the fonts returned where
2079 there is a definite match. Some scripts, such as latin, han,
2080 cjk-misc match multiple lfCharSet values, so we can't pre-filter
2082 if (EQ (key
, QCscript
)
2083 && logfont
->lfCharSet
== DEFAULT_CHARSET
2086 if (EQ (val
, Qgreek
))
2087 logfont
->lfCharSet
= GREEK_CHARSET
;
2088 else if (EQ (val
, Qhangul
))
2089 logfont
->lfCharSet
= HANGUL_CHARSET
;
2090 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
2091 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
2092 else if (EQ (val
, Qbopomofo
))
2093 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
2094 /* GB 18030 supports tibetan, yi, mongolian,
2095 fonts that support it should show up if we ask for
2097 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
2098 || EQ (val
, Qmongolian
))
2099 logfont
->lfCharSet
= GB2312_CHARSET
;
2100 else if (EQ (val
, Qhebrew
))
2101 logfont
->lfCharSet
= HEBREW_CHARSET
;
2102 else if (EQ (val
, Qarabic
))
2103 logfont
->lfCharSet
= ARABIC_CHARSET
;
2104 else if (EQ (val
, Qthai
))
2105 logfont
->lfCharSet
= THAI_CHARSET
;
2107 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
2109 logfont
->lfQuality
= w32_antialias_type (val
);
2116 list_all_matching_fonts (struct font_callback_data
*match_data
)
2119 Lisp_Object families
= w32font_list_family (match_data
->frame
);
2120 struct frame
*f
= XFRAME (match_data
->frame
);
2122 dc
= get_frame_dc (f
);
2124 while (!NILP (families
))
2126 /* Only fonts from the current locale are given localized names
2127 on Windows, so we can keep backwards compatibility with
2128 Windows 9x/ME by using non-Unicode font enumeration without
2129 sacrificing internationalization here. */
2131 Lisp_Object family
= CAR (families
);
2132 families
= CDR (families
);
2135 else if (SYMBOLP (family
))
2136 name
= SDATA (ENCODE_SYSTEM (SYMBOL_NAME (family
)));
2140 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
2141 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
2143 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
2144 (FONTENUMPROC
) add_font_entity_to_list
,
2145 (LPARAM
) match_data
, 0);
2148 release_frame_dc (f
, dc
);
2152 lispy_antialias_type (BYTE type
)
2158 case NONANTIALIASED_QUALITY
:
2161 case ANTIALIASED_QUALITY
:
2164 case CLEARTYPE_QUALITY
:
2167 case CLEARTYPE_NATURAL_QUALITY
:
2177 /* Convert antialiasing symbols to lfQuality */
2179 w32_antialias_type (Lisp_Object type
)
2181 if (EQ (type
, Qnone
))
2182 return NONANTIALIASED_QUALITY
;
2183 else if (EQ (type
, Qstandard
))
2184 return ANTIALIASED_QUALITY
;
2185 else if (EQ (type
, Qsubpixel
))
2186 return CLEARTYPE_QUALITY
;
2187 else if (EQ (type
, Qnatural
))
2188 return CLEARTYPE_NATURAL_QUALITY
;
2190 return DEFAULT_QUALITY
;
2193 /* Return a list of all the scripts that the font supports. */
2195 font_supported_scripts (FONTSIGNATURE
* sig
)
2197 DWORD
* subranges
= sig
->fsUsb
;
2198 Lisp_Object supported
= Qnil
;
2200 /* Match a single subrange. SYM is set if bit N is set in subranges. */
2201 #define SUBRANGE(n,sym) \
2202 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
2203 supported = Fcons ((sym), supported)
2205 /* Match multiple subranges. SYM is set if any MASK bit is set in
2206 subranges[0 - 3]. */
2207 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
2208 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
2209 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
2210 supported = Fcons ((sym), supported)
2212 SUBRANGE (0, Qlatin
);
2213 /* The following count as latin too, ASCII should be present in these fonts,
2214 so don't need to mark them separately. */
2215 /* 1: Latin-1 supplement, 2: Latin Extended A, 3: Latin Extended B. */
2216 SUBRANGE (4, Qphonetic
);
2217 /* 5: Spacing and tone modifiers, 6: Combining Diacritical Marks. */
2218 SUBRANGE (7, Qgreek
);
2219 SUBRANGE (8, Qcoptic
);
2220 SUBRANGE (9, Qcyrillic
);
2221 SUBRANGE (10, Qarmenian
);
2222 SUBRANGE (11, Qhebrew
);
2224 SUBRANGE (13, Qarabic
);
2225 SUBRANGE (14, Qnko
);
2226 SUBRANGE (15, Qdevanagari
);
2227 SUBRANGE (16, Qbengali
);
2228 SUBRANGE (17, Qgurmukhi
);
2229 SUBRANGE (18, Qgujarati
);
2230 SUBRANGE (19, Qoriya
);
2231 SUBRANGE (20, Qtamil
);
2232 SUBRANGE (21, Qtelugu
);
2233 SUBRANGE (22, Qkannada
);
2234 SUBRANGE (23, Qmalayalam
);
2235 SUBRANGE (24, Qthai
);
2236 SUBRANGE (25, Qlao
);
2237 SUBRANGE (26, Qgeorgian
);
2238 SUBRANGE (27, Qbalinese
);
2239 /* 28: Hangul Jamo. */
2240 /* 29: Latin Extended, 30: Greek Extended, 31: Punctuation. */
2241 /* 32-47: Symbols (defined below). */
2242 SUBRANGE (48, Qcjk_misc
);
2243 /* Match either 49: katakana or 50: hiragana for kana. */
2244 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
2245 SUBRANGE (51, Qbopomofo
);
2246 /* 52: Compatibility Jamo */
2247 SUBRANGE (53, Qphags_pa
);
2248 /* 54: Enclosed CJK letters and months, 55: CJK Compatibility. */
2249 SUBRANGE (56, Qhangul
);
2250 /* 57: Surrogates. */
2251 SUBRANGE (58, Qphoenician
);
2252 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
2253 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in. */
2254 SUBRANGE (59, Qkanbun
); /* And this. */
2255 /* 60: Private use, 61: CJK strokes and compatibility. */
2256 /* 62: Alphabetic Presentation, 63: Arabic Presentation A. */
2257 /* 64: Combining half marks, 65: Vertical and CJK compatibility. */
2258 /* 66: Small forms, 67: Arabic Presentation B, 68: Half and Full width. */
2260 SUBRANGE (70, Qtibetan
);
2261 SUBRANGE (71, Qsyriac
);
2262 SUBRANGE (72, Qthaana
);
2263 SUBRANGE (73, Qsinhala
);
2264 SUBRANGE (74, Qmyanmar
);
2265 SUBRANGE (75, Qethiopic
);
2266 SUBRANGE (76, Qcherokee
);
2267 SUBRANGE (77, Qcanadian_aboriginal
);
2268 SUBRANGE (78, Qogham
);
2269 SUBRANGE (79, Qrunic
);
2270 SUBRANGE (80, Qkhmer
);
2271 SUBRANGE (81, Qmongolian
);
2272 SUBRANGE (82, Qbraille
);
2274 SUBRANGE (84, Qbuhid
);
2275 SUBRANGE (84, Qhanunoo
);
2276 SUBRANGE (84, Qtagalog
);
2277 SUBRANGE (84, Qtagbanwa
);
2278 SUBRANGE (85, Qold_italic
);
2279 SUBRANGE (86, Qgothic
);
2280 SUBRANGE (87, Qdeseret
);
2281 SUBRANGE (88, Qbyzantine_musical_symbol
);
2282 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
2283 SUBRANGE (89, Qmathematical
);
2284 /* 90: Private use, 91: Variation selectors, 92: Tags. */
2285 SUBRANGE (93, Qlimbu
);
2286 SUBRANGE (94, Qtai_le
);
2287 /* 95: New Tai Le */
2288 SUBRANGE (90, Qbuginese
);
2289 SUBRANGE (97, Qglagolitic
);
2290 SUBRANGE (98, Qtifinagh
);
2291 /* 99: Yijing Hexagrams. */
2292 SUBRANGE (100, Qsyloti_nagri
);
2293 SUBRANGE (101, Qlinear_b
);
2294 /* 102: Ancient Greek Numbers. */
2295 SUBRANGE (103, Qugaritic
);
2296 SUBRANGE (104, Qold_persian
);
2297 SUBRANGE (105, Qshavian
);
2298 SUBRANGE (106, Qosmanya
);
2299 SUBRANGE (107, Qcypriot
);
2300 SUBRANGE (108, Qkharoshthi
);
2301 /* 109: Tai Xuan Jing. */
2302 SUBRANGE (110, Qcuneiform
);
2303 /* 111: Counting Rods, 112: Sundanese, 113: Lepcha, 114: Ol Chiki. */
2304 /* 115: Saurashtra, 116: Kayah Li, 117: Rejang. */
2305 SUBRANGE (118, Qcham
);
2306 /* 119: Ancient symbols, 120: Phaistos Disc. */
2307 /* 121: Carian, Lycian, Lydian, 122: Dominoes, Mahjong tiles. */
2308 /* 123-127: Reserved. */
2310 /* There isn't really a main symbol range, so include symbol if any
2311 relevant range is set. */
2312 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
2314 /* Missing: Tai Viet (U+AA80-U+AADF). */
2321 /* Generate a full name for a Windows font.
2322 The full name is in fcname format, with weight, slant and antialiasing
2323 specified if they are not "normal". */
2325 w32font_full_name (LOGFONT
* font
, Lisp_Object font_obj
,
2326 int pixel_size
, char *name
, int nbytes
)
2328 int len
, height
, outline
;
2330 Lisp_Object antialiasing
, weight
= Qnil
;
2332 len
= strlen (font
->lfFaceName
);
2334 outline
= EQ (AREF (font_obj
, FONT_FOUNDRY_INDEX
), Qoutline
);
2336 /* Represent size of scalable fonts by point size. But use pixelsize for
2337 raster fonts to indicate that they are exactly that size. */
2339 len
+= 11; /* -SIZE */
2344 len
+= 7; /* :italic */
2346 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
2348 weight
= w32_to_fc_weight (font
->lfWeight
);
2349 len
+= 1 + SBYTES (SYMBOL_NAME (weight
)); /* :WEIGHT */
2352 antialiasing
= lispy_antialias_type (font
->lfQuality
);
2353 if (! NILP (antialiasing
))
2354 len
+= 11 + SBYTES (SYMBOL_NAME (antialiasing
)); /* :antialias=NAME */
2356 /* Check that the buffer is big enough */
2361 p
+= sprintf (p
, "%s", font
->lfFaceName
);
2363 height
= font
->lfHeight
? eabs (font
->lfHeight
) : pixel_size
;
2369 float pointsize
= height
* 72.0 / one_w32_display_info
.resy
;
2370 /* Round to nearest half point. floor is used, since round is not
2371 supported in MS library. */
2372 pointsize
= floor (pointsize
* 2 + 0.5) / 2;
2373 p
+= sprintf (p
, "-%1.1f", pointsize
);
2376 p
+= sprintf (p
, ":pixelsize=%d", height
);
2379 if (SYMBOLP (weight
) && ! NILP (weight
))
2380 p
+= sprintf (p
, ":%s", SDATA (SYMBOL_NAME (weight
)));
2383 p
+= sprintf (p
, ":italic");
2385 if (SYMBOLP (antialiasing
) && ! NILP (antialiasing
))
2386 p
+= sprintf (p
, ":antialias=%s", SDATA (SYMBOL_NAME (antialiasing
)));
2391 /* Convert a logfont and point size into a fontconfig style font name.
2392 POINTSIZE is in tenths of points.
2393 If SIZE indicates the size of buffer FCNAME, into which the font name
2394 is written. If the buffer is not large enough to contain the name,
2395 the function returns -1, otherwise it returns the number of bytes
2396 written to FCNAME. */
2398 logfont_to_fcname (LOGFONT
* font
, int pointsize
, char *fcname
, int size
)
2402 Lisp_Object weight
= Qnil
;
2404 len
= strlen (font
->lfFaceName
) + 2;
2405 height
= pointsize
/ 10;
2406 while (height
/= 10)
2413 len
+= 7; /* :italic */
2414 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
2416 weight
= w32_to_fc_weight (font
->lfWeight
);
2417 len
+= SBYTES (SYMBOL_NAME (weight
)) + 1;
2423 p
+= sprintf (p
, "%s-%d", font
->lfFaceName
, pointsize
/ 10);
2425 p
+= sprintf (p
, ".%d", pointsize
% 10);
2427 if (SYMBOLP (weight
) && !NILP (weight
))
2428 p
+= sprintf (p
, ":%s", SDATA (SYMBOL_NAME (weight
)));
2431 p
+= sprintf (p
, ":italic");
2433 return (p
- fcname
);
2437 compute_metrics (HDC dc
, struct w32font_info
*w32_font
, unsigned int code
,
2438 struct w32_metric_cache
*metrics
)
2442 unsigned int options
= GGO_METRICS
;
2444 if (w32_font
->glyph_idx
)
2445 options
|= GGO_GLYPH_INDEX
;
2447 memset (&transform
, 0, sizeof (transform
));
2448 transform
.eM11
.value
= 1;
2449 transform
.eM22
.value
= 1;
2451 if (get_glyph_outline_w (dc
, code
, options
, &gm
, 0, NULL
, &transform
)
2454 metrics
->lbearing
= gm
.gmptGlyphOrigin
.x
;
2455 metrics
->rbearing
= gm
.gmptGlyphOrigin
.x
+ gm
.gmBlackBoxX
;
2456 metrics
->width
= gm
.gmCellIncX
;
2457 metrics
->status
= W32METRIC_SUCCESS
;
2460 metrics
->status
= W32METRIC_FAIL
;
2463 DEFUN ("x-select-font", Fx_select_font
, Sx_select_font
, 0, 2, 0,
2464 doc
: /* Read a font name using a W32 font selection dialog.
2465 Return fontconfig style font string corresponding to the selection.
2467 If FRAME is omitted or nil, it defaults to the selected frame.
2468 If EXCLUDE-PROPORTIONAL is non-nil, exclude proportional fonts
2469 in the font selection dialog. */)
2470 (Lisp_Object frame
, Lisp_Object exclude_proportional
)
2472 FRAME_PTR f
= check_x_frame (frame
);
2480 memset (&cf
, 0, sizeof (cf
));
2481 memset (&lf
, 0, sizeof (lf
));
2483 cf
.lStructSize
= sizeof (cf
);
2484 cf
.hwndOwner
= FRAME_W32_WINDOW (f
);
2485 cf
.Flags
= CF_FORCEFONTEXIST
| CF_SCREENFONTS
| CF_NOVERTFONTS
;
2487 /* If exclude_proportional is non-nil, limit the selection to
2488 monospaced fonts. */
2489 if (!NILP (exclude_proportional
))
2490 cf
.Flags
|= CF_FIXEDPITCHONLY
;
2494 /* Initialize as much of the font details as we can from the current
2496 hdc
= GetDC (FRAME_W32_WINDOW (f
));
2497 oldobj
= SelectObject (hdc
, FONT_HANDLE (FRAME_FONT (f
)));
2498 GetTextFace (hdc
, LF_FACESIZE
, lf
.lfFaceName
);
2499 if (GetTextMetrics (hdc
, &tm
))
2501 lf
.lfHeight
= tm
.tmInternalLeading
- tm
.tmHeight
;
2502 lf
.lfWeight
= tm
.tmWeight
;
2503 lf
.lfItalic
= tm
.tmItalic
;
2504 lf
.lfUnderline
= tm
.tmUnderlined
;
2505 lf
.lfStrikeOut
= tm
.tmStruckOut
;
2506 lf
.lfCharSet
= tm
.tmCharSet
;
2507 cf
.Flags
|= CF_INITTOLOGFONTSTRUCT
;
2509 SelectObject (hdc
, oldobj
);
2510 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
2512 if (!ChooseFont (&cf
)
2513 || logfont_to_fcname (&lf
, cf
.iPointSize
, buf
, 100) < 0)
2516 return DECODE_SYSTEM (build_string (buf
));
2519 static const char *const w32font_booleans
[] = {
2523 static const char *const w32font_non_booleans
[] = {
2531 w32font_filter_properties (Lisp_Object font
, Lisp_Object alist
)
2533 font_filter_properties (font
, alist
, w32font_booleans
, w32font_non_booleans
);
2536 struct font_driver w32font_driver
=
2539 0, /* case insensitive */
2543 w32font_list_family
,
2544 NULL
, /* free_entity */
2547 NULL
, /* prepare_face */
2548 NULL
, /* done_face */
2550 w32font_encode_char
,
2551 w32font_text_extents
,
2553 NULL
, /* get_bitmap */
2554 NULL
, /* free_bitmap */
2555 NULL
, /* get_outline */
2556 NULL
, /* free_outline */
2557 NULL
, /* anchor_point */
2558 NULL
, /* otf_capability */
2559 NULL
, /* otf_drive */
2560 NULL
, /* start_for_frame */
2561 NULL
, /* end_for_frame */
2564 NULL
, /* get_variation_glyphs */
2565 w32font_filter_properties
,
2566 NULL
, /* cached_font_ok */
2570 /* Initialize state that does not change between invocations. This is only
2571 called when Emacs is dumped. */
2573 syms_of_w32font (void)
2575 DEFSYM (Qgdi
, "gdi");
2576 DEFSYM (Quniscribe
, "uniscribe");
2577 DEFSYM (QCformat
, ":format");
2579 /* Generic font families. */
2580 DEFSYM (Qmonospace
, "monospace");
2581 DEFSYM (Qserif
, "serif");
2582 DEFSYM (Qsansserif
, "sansserif");
2583 DEFSYM (Qscript
, "script");
2584 DEFSYM (Qdecorative
, "decorative");
2586 DEFSYM (Qsans_serif
, "sans_serif");
2587 DEFSYM (Qsans
, "sans");
2588 DEFSYM (Qmono
, "mono");
2590 /* Fake foundries. */
2591 DEFSYM (Qraster
, "raster");
2592 DEFSYM (Qoutline
, "outline");
2593 DEFSYM (Qunknown
, "unknown");
2596 DEFSYM (Qstandard
, "standard");
2597 DEFSYM (Qsubpixel
, "subpixel");
2598 DEFSYM (Qnatural
, "natural");
2604 DEFSYM (Qlatin
, "latin");
2605 DEFSYM (Qgreek
, "greek");
2606 DEFSYM (Qcoptic
, "coptic");
2607 DEFSYM (Qcyrillic
, "cyrillic");
2608 DEFSYM (Qarmenian
, "armenian");
2609 DEFSYM (Qhebrew
, "hebrew");
2610 DEFSYM (Qarabic
, "arabic");
2611 DEFSYM (Qsyriac
, "syriac");
2612 DEFSYM (Qnko
, "nko");
2613 DEFSYM (Qthaana
, "thaana");
2614 DEFSYM (Qdevanagari
, "devanagari");
2615 DEFSYM (Qbengali
, "bengali");
2616 DEFSYM (Qgurmukhi
, "gurmukhi");
2617 DEFSYM (Qgujarati
, "gujarati");
2618 DEFSYM (Qoriya
, "oriya");
2619 DEFSYM (Qtamil
, "tamil");
2620 DEFSYM (Qtelugu
, "telugu");
2621 DEFSYM (Qkannada
, "kannada");
2622 DEFSYM (Qmalayalam
, "malayalam");
2623 DEFSYM (Qsinhala
, "sinhala");
2624 DEFSYM (Qthai
, "thai");
2625 DEFSYM (Qlao
, "lao");
2626 DEFSYM (Qtibetan
, "tibetan");
2627 DEFSYM (Qmyanmar
, "myanmar");
2628 DEFSYM (Qgeorgian
, "georgian");
2629 DEFSYM (Qhangul
, "hangul");
2630 DEFSYM (Qethiopic
, "ethiopic");
2631 DEFSYM (Qcherokee
, "cherokee");
2632 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
2633 DEFSYM (Qogham
, "ogham");
2634 DEFSYM (Qrunic
, "runic");
2635 DEFSYM (Qkhmer
, "khmer");
2636 DEFSYM (Qmongolian
, "mongolian");
2637 DEFSYM (Qbraille
, "braille");
2638 DEFSYM (Qhan
, "han");
2639 DEFSYM (Qideographic_description
, "ideographic-description");
2640 DEFSYM (Qcjk_misc
, "cjk-misc");
2641 DEFSYM (Qkana
, "kana");
2642 DEFSYM (Qbopomofo
, "bopomofo");
2643 DEFSYM (Qkanbun
, "kanbun");
2645 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
2646 DEFSYM (Qmusical_symbol
, "musical-symbol");
2647 DEFSYM (Qmathematical
, "mathematical");
2648 DEFSYM (Qcham
, "cham");
2649 DEFSYM (Qphonetic
, "phonetic");
2650 DEFSYM (Qbalinese
, "balinese");
2651 DEFSYM (Qbuginese
, "buginese");
2652 DEFSYM (Qbuhid
, "buhid");
2653 DEFSYM (Qcuneiform
, "cuneiform");
2654 DEFSYM (Qcypriot
, "cypriot");
2655 DEFSYM (Qdeseret
, "deseret");
2656 DEFSYM (Qglagolitic
, "glagolitic");
2657 DEFSYM (Qgothic
, "gothic");
2658 DEFSYM (Qhanunoo
, "hanunoo");
2659 DEFSYM (Qkharoshthi
, "kharoshthi");
2660 DEFSYM (Qlimbu
, "limbu");
2661 DEFSYM (Qlinear_b
, "linear_b");
2662 DEFSYM (Qold_italic
, "old_italic");
2663 DEFSYM (Qold_persian
, "old_persian");
2664 DEFSYM (Qosmanya
, "osmanya");
2665 DEFSYM (Qphags_pa
, "phags-pa");
2666 DEFSYM (Qphoenician
, "phoenician");
2667 DEFSYM (Qshavian
, "shavian");
2668 DEFSYM (Qsyloti_nagri
, "syloti_nagri");
2669 DEFSYM (Qtagalog
, "tagalog");
2670 DEFSYM (Qtagbanwa
, "tagbanwa");
2671 DEFSYM (Qtai_le
, "tai_le");
2672 DEFSYM (Qtifinagh
, "tifinagh");
2673 DEFSYM (Qugaritic
, "ugaritic");
2675 /* W32 font encodings. */
2676 DEFVAR_LISP ("w32-charset-info-alist",
2677 Vw32_charset_info_alist
,
2678 doc
: /* Alist linking Emacs character sets to Windows fonts and codepages.
2679 Each entry should be of the form:
2681 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))
2683 where CHARSET_NAME is a string used in font names to identify the charset,
2684 WINDOWS_CHARSET is a symbol that can be one of:
2686 w32-charset-ansi, w32-charset-default, w32-charset-symbol,
2687 w32-charset-shiftjis, w32-charset-hangeul, w32-charset-gb2312,
2688 w32-charset-chinesebig5, w32-charset-johab, w32-charset-hebrew,
2689 w32-charset-arabic, w32-charset-greek, w32-charset-turkish,
2690 w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,
2691 w32-charset-russian, w32-charset-mac, w32-charset-baltic,
2694 CODEPAGE should be an integer specifying the codepage that should be used
2695 to display the character set, t to do no translation and output as Unicode,
2696 or nil to do no translation and output as 8 bit (or multibyte on far-east
2697 versions of Windows) characters. */);
2698 Vw32_charset_info_alist
= Qnil
;
2700 DEFSYM (Qw32_charset_ansi
, "w32-charset-ansi");
2701 DEFSYM (Qw32_charset_symbol
, "w32-charset-symbol");
2702 DEFSYM (Qw32_charset_default
, "w32-charset-default");
2703 DEFSYM (Qw32_charset_shiftjis
, "w32-charset-shiftjis");
2704 DEFSYM (Qw32_charset_hangeul
, "w32-charset-hangeul");
2705 DEFSYM (Qw32_charset_chinesebig5
, "w32-charset-chinesebig5");
2706 DEFSYM (Qw32_charset_gb2312
, "w32-charset-gb2312");
2707 DEFSYM (Qw32_charset_oem
, "w32-charset-oem");
2708 DEFSYM (Qw32_charset_johab
, "w32-charset-johab");
2709 DEFSYM (Qw32_charset_easteurope
, "w32-charset-easteurope");
2710 DEFSYM (Qw32_charset_turkish
, "w32-charset-turkish");
2711 DEFSYM (Qw32_charset_baltic
, "w32-charset-baltic");
2712 DEFSYM (Qw32_charset_russian
, "w32-charset-russian");
2713 DEFSYM (Qw32_charset_arabic
, "w32-charset-arabic");
2714 DEFSYM (Qw32_charset_greek
, "w32-charset-greek");
2715 DEFSYM (Qw32_charset_hebrew
, "w32-charset-hebrew");
2716 DEFSYM (Qw32_charset_vietnamese
, "w32-charset-vietnamese");
2717 DEFSYM (Qw32_charset_thai
, "w32-charset-thai");
2718 DEFSYM (Qw32_charset_mac
, "w32-charset-mac");
2720 defsubr (&Sx_select_font
);
2722 w32font_driver
.type
= Qgdi
;
2723 register_font_driver (&w32font_driver
, NULL
);
2727 globals_of_w32font (void)
2729 g_b_init_is_w9x
= 0;
2730 g_b_init_get_outline_metrics_w
= 0;
2731 g_b_init_get_text_metrics_w
= 0;
2732 g_b_init_get_glyph_outline_w
= 0;