1 /* Font backend for the Microsoft W32 API.
2 Copyright (C) 2007, 2008 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "dispextern.h"
27 #include "character.h"
33 /* Cleartype available on Windows XP, cleartype_natural from XP SP1.
34 The latter does not try to fit cleartype smoothed fonts into the
35 same bounding box as the non-antialiased version of the font.
37 #ifndef CLEARTYPE_QUALITY
38 #define CLEARTYPE_QUALITY 5
40 #ifndef CLEARTYPE_NATURAL_QUALITY
41 #define CLEARTYPE_NATURAL_QUALITY 6
44 extern struct font_driver w32font_driver
;
47 Lisp_Object Quniscribe
;
48 static Lisp_Object QCformat
;
49 static Lisp_Object Qmonospace
, Qsansserif
, Qmono
, Qsans
, Qsans_serif
;
50 static Lisp_Object Qserif
, Qscript
, Qdecorative
;
51 static Lisp_Object Qraster
, Qoutline
, Qunknown
;
54 extern Lisp_Object QCantialias
, QCotf
, QClang
; /* defined in font.c */
55 extern Lisp_Object Qnone
; /* reuse from w32fns.c */
56 static Lisp_Object Qstandard
, Qsubpixel
, Qnatural
;
59 static Lisp_Object Qja
, Qko
, Qzh
;
62 static Lisp_Object Qlatin
, Qgreek
, Qcoptic
, Qcyrillic
, Qarmenian
, Qhebrew
;
63 static Lisp_Object Qarabic
, Qsyriac
, Qnko
, Qthaana
, Qdevanagari
, Qbengali
;
64 static Lisp_Object Qgurmukhi
, Qgujarati
, Qoriya
, Qtamil
, Qtelugu
;
65 static Lisp_Object Qkannada
, Qmalayalam
, Qsinhala
, Qthai
, Qlao
;
66 static Lisp_Object Qtibetan
, Qmyanmar
, Qgeorgian
, Qhangul
, Qethiopic
;
67 static Lisp_Object Qcherokee
, Qcanadian_aboriginal
, Qogham
, Qrunic
;
68 static Lisp_Object Qkhmer
, Qmongolian
, Qsymbol
, Qbraille
, Qhan
;
69 static Lisp_Object Qideographic_description
, Qcjk_misc
, Qkana
, Qbopomofo
;
70 static Lisp_Object Qkanbun
, Qyi
, Qbyzantine_musical_symbol
;
71 static Lisp_Object Qmusical_symbol
, Qmathematical
;
72 /* Not defined in characters.el, but referenced in fontset.el. */
73 static Lisp_Object Qbalinese
, Qbuginese
, Qbuhid
, Qcuneiform
, Qcypriot
;
74 static Lisp_Object Qdeseret
, Qglagolitic
, Qgothic
, Qhanunoo
, Qkharoshthi
;
75 static Lisp_Object Qlimbu
, Qlinear_b
, Qold_italic
, Qold_persian
, Qosmanya
;
76 static Lisp_Object Qphags_pa
, Qphoenician
, Qshavian
, Qsyloti_nagri
;
77 static Lisp_Object Qtagalog
, Qtagbanwa
, Qtai_le
, Qtifinagh
, Qugaritic
;
78 /* Only defined here, but useful for distinguishing IPA capable fonts. */
79 static Lisp_Object Qphonetic
;
81 /* Font spacing symbols - defined in font.c. */
82 extern Lisp_Object Qc
, Qp
, Qm
;
84 static void fill_in_logfont
P_ ((FRAME_PTR
, LOGFONT
*, Lisp_Object
));
86 static BYTE w32_antialias_type
P_ ((Lisp_Object
));
87 static Lisp_Object lispy_antialias_type
P_ ((BYTE
));
89 static Lisp_Object font_supported_scripts
P_ ((FONTSIGNATURE
*));
90 static int w32font_full_name
P_ ((LOGFONT
*, Lisp_Object
, int, char *, int));
91 static void compute_metrics
P_ ((HDC
, struct w32font_info
*, unsigned int,
92 struct w32_metric_cache
*));
93 static void clear_cached_metrics
P_ ((struct w32font_info
*));
95 static Lisp_Object w32_registry
P_ ((LONG
, DWORD
));
97 /* EnumFontFamiliesEx callbacks. */
98 static int CALLBACK add_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
101 static int CALLBACK add_one_font_entity_to_list
P_ ((ENUMLOGFONTEX
*,
104 static int CALLBACK add_font_name_to_list
P_ ((ENUMLOGFONTEX
*,
108 /* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
109 of what we really want. */
110 struct font_callback_data
112 /* The logfont we are matching against. EnumFontFamiliesEx only matches
113 face name and charset, so we need to manually match everything else
114 in the callback function. */
116 /* The original font spec or entity. */
117 Lisp_Object orig_font_spec
;
118 /* The frame the font is being loaded on. */
120 /* The list to add matches to. */
122 /* Whether to match only opentype fonts. */
126 /* Handles the problem that EnumFontFamiliesEx will not return all
127 style variations if the font name is not specified. */
128 static void list_all_matching_fonts
P_ ((struct font_callback_data
*));
130 /* From old font code in w32fns.c */
131 char * w32_to_x_charset
P_ ((int, char *));
135 memq_no_quit (elt
, list
)
136 Lisp_Object elt
, list
;
138 while (CONSP (list
) && ! EQ (XCAR (list
), elt
))
140 return (CONSP (list
));
143 /* w32 implementation of get_cache for font backend.
144 Return a cache of font-entities on FRAME. The cache must be a
145 cons whose cdr part is the actual cache area. */
147 w32font_get_cache (f
)
150 struct w32_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
152 return (dpyinfo
->name_list_element
);
155 /* w32 implementation of list for font backend.
156 List fonts exactly matching with FONT_SPEC on FRAME. The value
157 is a vector of font-entities. This is the sole API that
158 allocates font-entities. */
160 w32font_list (frame
, font_spec
)
161 Lisp_Object frame
, font_spec
;
163 return w32font_list_internal (frame
, font_spec
, 0);
166 /* w32 implementation of match for font backend.
167 Return a font entity most closely matching with FONT_SPEC on
168 FRAME. The closeness is detemined by the font backend, thus
169 `face-font-selection-order' is ignored here. */
171 w32font_match (frame
, font_spec
)
172 Lisp_Object frame
, font_spec
;
174 return w32font_match_internal (frame
, font_spec
, 0);
177 /* w32 implementation of list_family for font backend.
178 List available families. The value is a list of family names
181 w32font_list_family (frame
)
184 Lisp_Object list
= Qnil
;
185 LOGFONT font_match_pattern
;
187 FRAME_PTR f
= XFRAME (frame
);
189 bzero (&font_match_pattern
, sizeof (font_match_pattern
));
190 font_match_pattern
.lfCharSet
= DEFAULT_CHARSET
;
192 dc
= get_frame_dc (f
);
194 EnumFontFamiliesEx (dc
, &font_match_pattern
,
195 (FONTENUMPROC
) add_font_name_to_list
,
197 release_frame_dc (f
, dc
);
202 /* w32 implementation of open for font backend.
203 Open a font specified by FONT_ENTITY on frame F.
204 If the font is scalable, open it with PIXEL_SIZE. */
206 w32font_open (f
, font_entity
, pixel_size
)
208 Lisp_Object font_entity
;
211 Lisp_Object font_object
;
213 font_object
= font_make_object (VECSIZE (struct w32font_info
));
215 if (!w32font_open_internal (f
, font_entity
, pixel_size
, font_object
))
223 /* w32 implementation of close for font_backend.
224 Close FONT on frame F. */
226 w32font_close (f
, font
)
230 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
232 if (w32_font
->compat_w32_font
)
234 W32FontStruct
*old_w32_font
= w32_font
->compat_w32_font
;
235 DeleteObject (old_w32_font
->hfont
);
236 xfree (old_w32_font
);
237 w32_font
->compat_w32_font
= 0;
241 /* w32 implementation of has_char for font backend.
243 If FONT_ENTITY has a glyph for character C (Unicode code point),
244 return 1. If not, return 0. If a font must be opened to check
247 w32font_has_char (entity
, c
)
251 Lisp_Object supported_scripts
, extra
, script
;
254 extra
= AREF (entity
, FONT_EXTRA_INDEX
);
258 supported_scripts
= assq_no_quit (QCscript
, extra
);
259 if (!CONSP (supported_scripts
))
262 supported_scripts
= XCDR (supported_scripts
);
264 script
= CHAR_TABLE_REF (Vchar_script_table
, c
);
266 return (memq_no_quit (script
, supported_scripts
)) ? -1 : 0;
269 /* w32 implementation of encode_char for font backend.
270 Return a glyph code of FONT for characer C (Unicode code point).
271 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
273 w32font_encode_char (font
, c
)
285 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
287 /* If glyph indexing is not working for this font, just return the
288 unicode code-point. */
289 if (!w32_font
->glyph_idx
)
294 /* TODO: Encode as surrogate pair and lookup the glyph. */
295 return FONT_INVALID_CODE
;
303 bzero (&result
, sizeof (result
));
304 result
.lStructSize
= sizeof (result
);
305 result
.lpGlyphs
= out
;
308 f
= XFRAME (selected_frame
);
310 dc
= get_frame_dc (f
);
311 old_font
= SelectObject (dc
, w32_font
->compat_w32_font
->hfont
);
313 retval
= GetCharacterPlacementW (dc
, in
, len
, 0, &result
, 0);
315 SelectObject (dc
, old_font
);
316 release_frame_dc (f
, dc
);
320 if (result
.nGlyphs
!= 1 || !result
.lpGlyphs
[0])
321 return FONT_INVALID_CODE
;
322 return result
.lpGlyphs
[0];
327 /* Mark this font as not supporting glyph indices. This can happen
328 on Windows9x, and maybe with non-Truetype fonts on NT etc. */
329 w32_font
->glyph_idx
= 0;
330 /* Clear metrics cache. */
331 clear_cached_metrics (w32_font
);
337 /* w32 implementation of text_extents for font backend.
338 Perform the size computation of glyphs of FONT and fillin members
339 of METRICS. The glyphs are specified by their glyph codes in
340 CODE (length NGLYPHS). Apparently metrics can be NULL, in this
341 case just return the overall width. */
343 w32font_text_extents (font
, code
, nglyphs
, metrics
)
347 struct font_metrics
*metrics
;
350 HFONT old_font
= NULL
;
359 struct w32font_info
*w32_font
= (struct w32font_info
*) font
;
361 bzero (metrics
, sizeof (struct font_metrics
));
362 metrics
->ascent
= font
->ascent
;
363 metrics
->descent
= font
->descent
;
365 for (i
= 0; i
< nglyphs
; i
++)
367 struct w32_metric_cache
*char_metric
;
368 int block
= *(code
+ i
) / CACHE_BLOCKSIZE
;
369 int pos_in_block
= *(code
+ i
) % CACHE_BLOCKSIZE
;
371 if (block
>= w32_font
->n_cache_blocks
)
373 if (!w32_font
->cached_metrics
)
374 w32_font
->cached_metrics
375 = xmalloc ((block
+ 1)
376 * sizeof (struct w32_cached_metric
*));
378 w32_font
->cached_metrics
379 = xrealloc (w32_font
->cached_metrics
,
381 * sizeof (struct w32_cached_metric
*));
382 bzero (w32_font
->cached_metrics
+ w32_font
->n_cache_blocks
,
383 ((block
+ 1 - w32_font
->n_cache_blocks
)
384 * sizeof (struct w32_cached_metric
*)));
385 w32_font
->n_cache_blocks
= block
+ 1;
388 if (!w32_font
->cached_metrics
[block
])
390 w32_font
->cached_metrics
[block
]
391 = xmalloc (CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
392 bzero (w32_font
->cached_metrics
[block
],
393 CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
396 char_metric
= w32_font
->cached_metrics
[block
] + pos_in_block
;
398 if (char_metric
->status
== W32METRIC_NO_ATTEMPT
)
402 /* TODO: Frames can come and go, and their fonts
403 outlive them. So we can't cache the frame in the
404 font structure. Use selected_frame until the API
405 is updated to pass in a frame. */
406 f
= XFRAME (selected_frame
);
408 dc
= get_frame_dc (f
);
409 old_font
= SelectObject (dc
, FONT_COMPAT (font
)->hfont
);
411 compute_metrics (dc
, w32_font
, *(code
+ i
), char_metric
);
414 if (char_metric
->status
== W32METRIC_SUCCESS
)
416 metrics
->lbearing
= min (metrics
->lbearing
,
417 metrics
->width
+ char_metric
->lbearing
);
418 metrics
->rbearing
= max (metrics
->rbearing
,
419 metrics
->width
+ char_metric
->rbearing
);
420 metrics
->width
+= char_metric
->width
;
423 /* If we couldn't get metrics for a char,
424 use alternative method. */
427 /* If we got through everything, return. */
432 /* Restore state and release DC. */
433 SelectObject (dc
, old_font
);
434 release_frame_dc (f
, dc
);
437 return metrics
->width
;
441 /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
442 fallback on other methods that will at least give some of the metric
445 wcode
= alloca (nglyphs
* sizeof (WORD
));
446 for (i
= 0; i
< nglyphs
; i
++)
448 if (code
[i
] < 0x10000)
452 /* TODO: Convert to surrogate, reallocating array if needed */
459 /* TODO: Frames can come and go, and their fonts outlive
460 them. So we can't cache the frame in the font structure. Use
461 selected_frame until the API is updated to pass in a
463 f
= XFRAME (selected_frame
);
465 dc
= get_frame_dc (f
);
466 old_font
= SelectObject (dc
, FONT_COMPAT (font
)->hfont
);
469 if (GetTextExtentPoint32W (dc
, wcode
, nglyphs
, &size
))
471 total_width
= size
.cx
;
474 /* On 95/98/ME, only some unicode functions are available, so fallback
475 on doing a dummy draw to find the total width. */
479 rect
.top
= 0; rect
.bottom
= font
->height
; rect
.left
= 0; rect
.right
= 1;
480 DrawTextW (dc
, wcode
, nglyphs
, &rect
,
481 DT_CALCRECT
| DT_NOPREFIX
| DT_SINGLELINE
);
482 total_width
= rect
.right
;
485 /* Give our best estimate of the metrics, based on what we know. */
488 metrics
->width
= total_width
;
489 metrics
->lbearing
= 0;
490 metrics
->rbearing
= total_width
491 + ((struct w32font_info
*) font
)->metrics
.tmOverhang
;
494 /* Restore state and release DC. */
495 SelectObject (dc
, old_font
);
496 release_frame_dc (f
, dc
);
501 /* w32 implementation of draw for font backend.
503 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
504 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
505 is nonzero, fill the background in advance. It is assured that
506 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).
508 TODO: Currently this assumes that the colors and fonts are already
509 set in the DC. This seems to be true now, but maybe only due to
510 the old font code setting it up. It may be safer to resolve faces
511 and fonts in here and set them explicitly
515 w32font_draw (s
, from
, to
, x
, y
, with_background
)
516 struct glyph_string
*s
;
517 int from
, to
, x
, y
, with_background
;
521 struct w32font_info
*w32font
= (struct w32font_info
*) s
->font
;
523 options
= w32font
->glyph_idx
;
525 /* Save clip region for later restoration. */
526 GetClipRgn(s
->hdc
, orig_clip
);
528 if (s
->num_clips
> 0)
530 HRGN new_clip
= CreateRectRgnIndirect (s
->clip
);
532 if (s
->num_clips
> 1)
534 HRGN clip2
= CreateRectRgnIndirect (s
->clip
+ 1);
536 CombineRgn (new_clip
, new_clip
, clip2
, RGN_OR
);
537 DeleteObject (clip2
);
540 SelectClipRgn (s
->hdc
, new_clip
);
541 DeleteObject (new_clip
);
544 /* Using OPAQUE background mode can clear more background than expected
545 when Cleartype is used. Draw the background manually to avoid this. */
546 SetBkMode (s
->hdc
, TRANSPARENT
);
551 struct font
*font
= s
->font
;
553 brush
= CreateSolidBrush (s
->gc
->background
);
555 rect
.top
= y
- font
->ascent
;
556 rect
.right
= x
+ s
->width
;
557 rect
.bottom
= y
+ font
->descent
;
558 FillRect (s
->hdc
, &rect
, brush
);
559 DeleteObject (brush
);
564 int len
= to
- from
, i
;
566 for (i
= 0; i
< len
; i
++)
567 ExtTextOutW (s
->hdc
, x
+ i
, y
, options
, NULL
,
568 s
->char2b
+ from
+ i
, 1, NULL
);
571 ExtTextOutW (s
->hdc
, x
, y
, options
, NULL
, s
->char2b
+ from
, to
- from
, NULL
);
573 /* Restore clip region. */
574 if (s
->num_clips
> 0)
576 SelectClipRgn (s
->hdc
, orig_clip
);
580 /* w32 implementation of free_entity for font backend.
581 Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
582 Free FONT_EXTRA_INDEX field of FONT_ENTITY.
584 w32font_free_entity (Lisp_Object entity);
587 /* w32 implementation of prepare_face for font backend.
588 Optional (if FACE->extra is not used).
589 Prepare FACE for displaying characters by FONT on frame F by
590 storing some data in FACE->extra. If successful, return 0.
591 Otherwise, return -1.
593 w32font_prepare_face (FRAME_PTR f, struct face *face);
595 /* w32 implementation of done_face for font backend.
597 Done FACE for displaying characters by FACE->font on frame F.
599 w32font_done_face (FRAME_PTR f, struct face *face); */
601 /* w32 implementation of get_bitmap for font backend.
603 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
604 intended that this method is called from the other font-driver
607 w32font_get_bitmap (struct font *font, unsigned code,
608 struct font_bitmap *bitmap, int bits_per_pixel);
610 /* w32 implementation of free_bitmap for font backend.
612 Free bitmap data in BITMAP.
614 w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
616 /* w32 implementation of get_outline for font backend.
618 Return an outline data for glyph-code CODE of FONT. The format
619 of the outline data depends on the font-driver.
621 w32font_get_outline (struct font *font, unsigned code);
623 /* w32 implementation of free_outline for font backend.
625 Free OUTLINE (that is obtained by the above method).
627 w32font_free_outline (struct font *font, void *outline);
629 /* w32 implementation of anchor_point for font backend.
631 Get coordinates of the INDEXth anchor point of the glyph whose
632 code is CODE. Store the coordinates in *X and *Y. Return 0 if
633 the operations was successfull. Otherwise return -1.
635 w32font_anchor_point (struct font *font, unsigned code,
636 int index, int *x, int *y);
638 /* w32 implementation of otf_capability for font backend.
640 Return a list describing which scripts/languages FONT
641 supports by which GSUB/GPOS features of OpenType tables.
643 w32font_otf_capability (struct font *font);
645 /* w32 implementation of otf_drive for font backend.
647 Apply FONT's OTF-FEATURES to the glyph string.
649 FEATURES specifies which OTF features to apply in this format:
650 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
651 See the documentation of `font-drive-otf' for the detail.
653 This method applies the specified features to the codes in the
654 elements of GSTRING-IN (between FROMth and TOth). The output
655 codes are stored in GSTRING-OUT at the IDXth element and the
658 Return the number of output codes. If none of the features are
659 applicable to the input data, return 0. If GSTRING-OUT is too
662 w32font_otf_drive (struct font *font, Lisp_Object features,
663 Lisp_Object gstring_in, int from, int to,
664 Lisp_Object gstring_out, int idx,
665 int alternate_subst);
668 /* Internal implementation of w32font_list.
669 Additional parameter opentype_only restricts the returned fonts to
670 opentype fonts, which can be used with the Uniscribe backend. */
672 w32font_list_internal (frame
, font_spec
, opentype_only
)
673 Lisp_Object frame
, font_spec
;
676 struct font_callback_data match_data
;
678 FRAME_PTR f
= XFRAME (frame
);
680 match_data
.orig_font_spec
= font_spec
;
681 match_data
.list
= Qnil
;
682 match_data
.frame
= frame
;
684 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
685 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
687 match_data
.opentype_only
= opentype_only
;
689 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
691 if (match_data
.pattern
.lfFaceName
[0] == '\0')
693 /* EnumFontFamiliesEx does not take other fields into account if
694 font name is blank, so need to use two passes. */
695 list_all_matching_fonts (&match_data
);
699 dc
= get_frame_dc (f
);
701 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
702 (FONTENUMPROC
) add_font_entity_to_list
,
703 (LPARAM
) &match_data
, 0);
704 release_frame_dc (f
, dc
);
707 return NILP (match_data
.list
) ? Qnil
: match_data
.list
;
710 /* Internal implementation of w32font_match.
711 Additional parameter opentype_only restricts the returned fonts to
712 opentype fonts, which can be used with the Uniscribe backend. */
714 w32font_match_internal (frame
, font_spec
, opentype_only
)
715 Lisp_Object frame
, font_spec
;
718 struct font_callback_data match_data
;
720 FRAME_PTR f
= XFRAME (frame
);
722 match_data
.orig_font_spec
= font_spec
;
723 match_data
.frame
= frame
;
724 match_data
.list
= Qnil
;
726 bzero (&match_data
.pattern
, sizeof (LOGFONT
));
727 fill_in_logfont (f
, &match_data
.pattern
, font_spec
);
729 match_data
.opentype_only
= opentype_only
;
731 match_data
.pattern
.lfOutPrecision
= OUT_OUTLINE_PRECIS
;
733 dc
= get_frame_dc (f
);
735 EnumFontFamiliesEx (dc
, &match_data
.pattern
,
736 (FONTENUMPROC
) add_one_font_entity_to_list
,
737 (LPARAM
) &match_data
, 0);
738 release_frame_dc (f
, dc
);
740 return NILP (match_data
.list
) ? Qnil
: XCAR (match_data
.list
);
744 w32font_open_internal (f
, font_entity
, pixel_size
, font_object
)
746 Lisp_Object font_entity
;
748 Lisp_Object font_object
;
753 HFONT hfont
, old_font
;
754 Lisp_Object val
, extra
;
755 /* For backwards compatibility. */
756 W32FontStruct
*compat_w32_font
;
757 struct w32font_info
*w32_font
;
759 OUTLINETEXTMETRIC
* metrics
= NULL
;
761 w32_font
= (struct w32font_info
*) XFONT_OBJECT (font_object
);
762 font
= (struct font
*) w32_font
;
767 /* Copy from font entity. */
768 for (i
= 0; i
< FONT_ENTITY_MAX
; i
++)
769 ASET (font_object
, i
, AREF (font_entity
, i
));
770 ASET (font_object
, FONT_SIZE_INDEX
, make_number (pixel_size
));
772 bzero (&logfont
, sizeof (logfont
));
773 fill_in_logfont (f
, &logfont
, font_entity
);
775 size
= XINT (AREF (font_entity
, FONT_SIZE_INDEX
));
779 logfont
.lfHeight
= -size
;
780 hfont
= CreateFontIndirect (&logfont
);
785 /* Get the metrics for this font. */
786 dc
= get_frame_dc (f
);
787 old_font
= SelectObject (dc
, hfont
);
789 /* Try getting the outline metrics (only works for truetype fonts). */
790 len
= GetOutlineTextMetrics (dc
, 0, NULL
);
793 metrics
= (OUTLINETEXTMETRIC
*) alloca (len
);
794 if (GetOutlineTextMetrics (dc
, len
, metrics
))
795 bcopy (&metrics
->otmTextMetrics
, &w32_font
->metrics
,
796 sizeof (TEXTMETRIC
));
801 GetTextMetrics (dc
, &w32_font
->metrics
);
803 w32_font
->glyph_idx
= ETO_GLYPH_INDEX
;
805 w32_font
->cached_metrics
= NULL
;
806 w32_font
->n_cache_blocks
= 0;
808 SelectObject (dc
, old_font
);
809 release_frame_dc (f
, dc
);
811 /* W32FontStruct - we should get rid of this, and use the w32font_info
812 struct for any W32 specific fields. font->font.font can then be hfont. */
813 w32_font
->compat_w32_font
= xmalloc (sizeof (W32FontStruct
));
814 compat_w32_font
= w32_font
->compat_w32_font
;
815 bzero (compat_w32_font
, sizeof (W32FontStruct
));
816 compat_w32_font
->font_type
= UNICODE_FONT
;
817 /* Duplicate the text metrics. */
818 bcopy (&w32_font
->metrics
, &compat_w32_font
->tm
, sizeof (TEXTMETRIC
));
819 compat_w32_font
->hfont
= hfont
;
824 /* We don't know how much space we need for the full name, so start with
825 96 bytes and go up in steps of 32. */
827 name
= xmalloc (len
);
828 while (name
&& w32font_full_name (&logfont
, font_entity
, pixel_size
,
831 char *new = xrealloc (name
, len
+= 32);
838 font
->props
[FONT_FULLNAME_INDEX
]
839 = make_unibyte_string (name
, strlen (name
));
841 font
->props
[FONT_FULLNAME_INDEX
] =
842 make_unibyte_string (logfont
.lfFaceName
, len
);
845 font
->max_width
= w32_font
->metrics
.tmMaxCharWidth
;
846 font
->height
= w32_font
->metrics
.tmHeight
847 + w32_font
->metrics
.tmExternalLeading
;
848 font
->space_width
= font
->average_width
= w32_font
->metrics
.tmAveCharWidth
;
850 font
->vertical_centering
= 0;
851 font
->encoding_type
= 0;
852 font
->baseline_offset
= 0;
853 font
->relative_compose
= 0;
854 font
->default_ascent
= w32_font
->metrics
.tmAscent
;
855 font
->font_encoder
= NULL
;
856 font
->pixel_size
= size
;
857 font
->driver
= &w32font_driver
;
858 /* Use format cached during list, as the information we have access to
859 here is incomplete. */
860 extra
= AREF (font_entity
, FONT_EXTRA_INDEX
);
863 val
= assq_no_quit (QCformat
, extra
);
865 font
->props
[FONT_FORMAT_INDEX
] = XCDR (val
);
867 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
870 font
->props
[FONT_FORMAT_INDEX
] = Qunknown
;
872 font
->props
[FONT_FILE_INDEX
] = Qnil
;
873 font
->encoding_charset
= -1;
874 font
->repertory_charset
= -1;
875 /* TODO: do we really want the minimum width here, which could be negative? */
876 font
->min_width
= font
->space_width
;
877 font
->ascent
= w32_font
->metrics
.tmAscent
;
878 font
->descent
= w32_font
->metrics
.tmDescent
;
882 font
->underline_thickness
= metrics
->otmsUnderscoreSize
;
883 font
->underline_position
= -metrics
->otmsUnderscorePosition
;
887 font
->underline_thickness
= 0;
888 font
->underline_position
= -1;
891 /* max_descent is used for underlining in w32term.c. Hopefully this
892 is temporary, as we'll want to get rid of the old compatibility
894 compat_w32_font
->max_bounds
.descent
= font
->descent
;
896 /* For temporary compatibility with legacy code that expects the
897 name to be usable in x-list-fonts. Eventually we expect to change
898 x-list-fonts and other places that use fonts so that this can be
899 an fcname or similar. */
900 font
->props
[FONT_NAME_INDEX
] = Ffont_xlfd_name (font_object
, Qnil
);
905 /* Callback function for EnumFontFamiliesEx.
906 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
908 add_font_name_to_list (logical_font
, physical_font
, font_type
, list_object
)
909 ENUMLOGFONTEX
*logical_font
;
910 NEWTEXTMETRICEX
*physical_font
;
914 Lisp_Object
* list
= (Lisp_Object
*) list_object
;
917 /* Skip vertical fonts (intended only for printing) */
918 if (logical_font
->elfLogFont
.lfFaceName
[0] == '@')
921 family
= font_intern_prop (logical_font
->elfLogFont
.lfFaceName
,
922 strlen (logical_font
->elfLogFont
.lfFaceName
));
923 if (! memq_no_quit (family
, *list
))
924 *list
= Fcons (family
, *list
);
929 static int w32_decode_weight
P_ ((int));
930 static int w32_encode_weight
P_ ((int));
932 /* Convert an enumerated Windows font to an Emacs font entity. */
934 w32_enumfont_pattern_entity (frame
, logical_font
, physical_font
,
935 font_type
, requested_font
, backend
)
937 ENUMLOGFONTEX
*logical_font
;
938 NEWTEXTMETRICEX
*physical_font
;
940 LOGFONT
*requested_font
;
943 Lisp_Object entity
, tem
;
944 LOGFONT
*lf
= (LOGFONT
*) logical_font
;
946 DWORD full_type
= physical_font
->ntmTm
.ntmFlags
;
948 entity
= font_make_entity ();
950 ASET (entity
, FONT_TYPE_INDEX
, backend
);
951 ASET (entity
, FONT_REGISTRY_INDEX
, w32_registry (lf
->lfCharSet
, font_type
));
952 ASET (entity
, FONT_OBJLIST_INDEX
, Qnil
);
954 /* Foundry is difficult to get in readable form on Windows.
955 But Emacs crashes if it is not set, so set it to something more
956 generic. These values make xflds compatible with Emacs 22. */
957 if (lf
->lfOutPrecision
== OUT_STRING_PRECIS
)
959 else if (lf
->lfOutPrecision
== OUT_STROKE_PRECIS
)
964 ASET (entity
, FONT_FOUNDRY_INDEX
, tem
);
966 /* Save the generic family in the extra info, as it is likely to be
967 useful to users looking for a close match. */
968 generic_type
= physical_font
->ntmTm
.tmPitchAndFamily
& 0xF0;
969 if (generic_type
== FF_DECORATIVE
)
971 else if (generic_type
== FF_MODERN
)
973 else if (generic_type
== FF_ROMAN
)
975 else if (generic_type
== FF_SCRIPT
)
977 else if (generic_type
== FF_SWISS
)
982 ASET (entity
, FONT_ADSTYLE_INDEX
, tem
);
984 if (physical_font
->ntmTm
.tmPitchAndFamily
& 0x01)
985 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_PROPORTIONAL
));
987 ASET (entity
, FONT_SPACING_INDEX
, make_number (FONT_SPACING_CHARCELL
));
989 if (requested_font
->lfQuality
!= DEFAULT_QUALITY
)
991 font_put_extra (entity
, QCantialias
,
992 lispy_antialias_type (requested_font
->lfQuality
));
994 ASET (entity
, FONT_FAMILY_INDEX
,
995 font_intern_prop (lf
->lfFaceName
, strlen (lf
->lfFaceName
)));
997 FONT_SET_STYLE (entity
, FONT_WEIGHT_INDEX
,
998 make_number (w32_decode_weight (lf
->lfWeight
)));
999 FONT_SET_STYLE (entity
, FONT_SLANT_INDEX
,
1000 make_number (lf
->lfItalic
? 200 : 100));
1001 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
1003 FONT_SET_STYLE (entity
, FONT_WIDTH_INDEX
, make_number (100));
1005 if (font_type
& RASTER_FONTTYPE
)
1006 ASET (entity
, FONT_SIZE_INDEX
, make_number (physical_font
->ntmTm
.tmHeight
));
1008 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
1010 /* Cache unicode codepoints covered by this font, as there is no other way
1011 of getting this information easily. */
1012 if (font_type
& TRUETYPE_FONTTYPE
)
1014 font_put_extra (entity
, QCscript
,
1015 font_supported_scripts (&physical_font
->ntmFontSig
));
1018 /* This information is not fully available when opening fonts, so
1019 save it here. Only Windows 2000 and later return information
1020 about opentype and type1 fonts, so need a fallback for detecting
1021 truetype so that this information is not any worse than we could
1022 have obtained later. */
1023 if (EQ (backend
, Quniscribe
) && (full_type
& NTMFLAGS_OPENTYPE
))
1024 tem
= intern ("opentype");
1025 else if (font_type
& TRUETYPE_FONTTYPE
)
1026 tem
= intern ("truetype");
1027 else if (full_type
& NTM_PS_OPENTYPE
)
1028 tem
= intern ("postscript");
1029 else if (full_type
& NTM_TYPE1
)
1030 tem
= intern ("type1");
1031 else if (font_type
& RASTER_FONTTYPE
)
1032 tem
= intern ("w32bitmap");
1034 tem
= intern ("w32vector");
1036 font_put_extra (entity
, QCformat
, tem
);
1042 /* Convert generic families to the family portion of lfPitchAndFamily. */
1044 w32_generic_family (Lisp_Object name
)
1046 /* Generic families. */
1047 if (EQ (name
, Qmonospace
) || EQ (name
, Qmono
))
1049 else if (EQ (name
, Qsans
) || EQ (name
, Qsans_serif
) || EQ (name
, Qsansserif
))
1051 else if (EQ (name
, Qserif
))
1053 else if (EQ (name
, Qdecorative
))
1054 return FF_DECORATIVE
;
1055 else if (EQ (name
, Qscript
))
1062 logfonts_match (font
, pattern
)
1063 LOGFONT
*font
, *pattern
;
1065 /* Only check height for raster fonts. */
1066 if (pattern
->lfHeight
&& font
->lfOutPrecision
== OUT_STRING_PRECIS
1067 && font
->lfHeight
!= pattern
->lfHeight
)
1070 /* Have some flexibility with weights. */
1071 if (pattern
->lfWeight
1072 && ((font
->lfWeight
< (pattern
->lfWeight
- 150))
1073 || font
->lfWeight
> (pattern
->lfWeight
+ 150)))
1076 /* Charset and face should be OK. Italic has to be checked
1077 against the original spec, in case we don't have any preference. */
1082 font_matches_spec (type
, font
, spec
, backend
, logfont
)
1084 NEWTEXTMETRICEX
*font
;
1086 Lisp_Object backend
;
1089 Lisp_Object extra
, val
;
1091 /* Check italic. Can't check logfonts, since it is a boolean field,
1092 so there is no difference between "non-italic" and "don't care". */
1094 int slant
= FONT_SLANT_NUMERIC (spec
);
1097 && ((slant
> 150 && !font
->ntmTm
.tmItalic
)
1098 || (slant
<= 150 && font
->ntmTm
.tmItalic
)))
1102 /* Check adstyle against generic family. */
1103 val
= AREF (spec
, FONT_ADSTYLE_INDEX
);
1106 BYTE family
= w32_generic_family (val
);
1107 if (family
!= FF_DONTCARE
1108 && family
!= (font
->ntmTm
.tmPitchAndFamily
& 0xF0))
1113 val
= AREF (spec
, FONT_SPACING_INDEX
);
1116 int spacing
= XINT (val
);
1117 int proportional
= (spacing
< FONT_SPACING_MONO
);
1119 if ((proportional
&& !(font
->ntmTm
.tmPitchAndFamily
& 0x01))
1120 || (!proportional
&& (font
->ntmTm
.tmPitchAndFamily
& 0x01)))
1124 /* Check extra parameters. */
1125 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
1126 CONSP (extra
); extra
= XCDR (extra
))
1128 Lisp_Object extra_entry
;
1129 extra_entry
= XCAR (extra
);
1130 if (CONSP (extra_entry
))
1132 Lisp_Object key
= XCAR (extra_entry
);
1134 val
= XCDR (extra_entry
);
1135 if (EQ (key
, QCscript
) && SYMBOLP (val
))
1137 /* Only truetype fonts will have information about what
1138 scripts they support. This probably means the user
1139 will have to force Emacs to use raster, postscript
1140 or atm fonts for non-ASCII text. */
1141 if (type
& TRUETYPE_FONTTYPE
)
1144 = font_supported_scripts (&font
->ntmFontSig
);
1145 if (! memq_no_quit (val
, support
))
1150 /* Return specific matches, but play it safe. Fonts
1151 that cover more than their charset would suggest
1152 are likely to be truetype or opentype fonts,
1154 if (EQ (val
, Qlatin
))
1156 /* Although every charset but symbol, thai and
1157 arabic contains the basic ASCII set of latin
1158 characters, Emacs expects much more. */
1159 if (font
->ntmTm
.tmCharSet
!= ANSI_CHARSET
)
1162 else if (EQ (val
, Qsymbol
))
1164 if (font
->ntmTm
.tmCharSet
!= SYMBOL_CHARSET
)
1167 else if (EQ (val
, Qcyrillic
))
1169 if (font
->ntmTm
.tmCharSet
!= RUSSIAN_CHARSET
)
1172 else if (EQ (val
, Qgreek
))
1174 if (font
->ntmTm
.tmCharSet
!= GREEK_CHARSET
)
1177 else if (EQ (val
, Qarabic
))
1179 if (font
->ntmTm
.tmCharSet
!= ARABIC_CHARSET
)
1182 else if (EQ (val
, Qhebrew
))
1184 if (font
->ntmTm
.tmCharSet
!= HEBREW_CHARSET
)
1187 else if (EQ (val
, Qthai
))
1189 if (font
->ntmTm
.tmCharSet
!= THAI_CHARSET
)
1192 else if (EQ (val
, Qkana
))
1194 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1197 else if (EQ (val
, Qbopomofo
))
1199 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1202 else if (EQ (val
, Qhangul
))
1204 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1205 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1208 else if (EQ (val
, Qhan
))
1210 if (font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
1211 && font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1212 && font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1213 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
1214 && font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1218 /* Other scripts unlikely to be handled by non-truetype
1223 else if (EQ (key
, QClang
) && SYMBOLP (val
))
1225 /* Just handle the CJK languages here, as the language
1226 parameter is used to select a font with appropriate
1227 glyphs in the cjk unified ideographs block. Other fonts
1228 support for a language can be solely determined by
1229 its character coverage. */
1232 if (font
->ntmTm
.tmCharSet
!= SHIFTJIS_CHARSET
)
1235 else if (EQ (val
, Qko
))
1237 if (font
->ntmTm
.tmCharSet
!= HANGUL_CHARSET
1238 && font
->ntmTm
.tmCharSet
!= JOHAB_CHARSET
)
1241 else if (EQ (val
, Qzh
))
1243 if (font
->ntmTm
.tmCharSet
!= GB2312_CHARSET
1244 && font
->ntmTm
.tmCharSet
!= CHINESEBIG5_CHARSET
)
1248 /* Any other language, we don't recognize it. Fontset
1249 spec should have a fallback, as some backends do
1250 not recognize language at all. */
1253 else if (EQ (key
, QCotf
) && CONSP (val
))
1255 /* OTF features only supported by the uniscribe backend. */
1256 if (EQ (backend
, Quniscribe
))
1258 if (!uniscribe_check_otf (logfont
, val
))
1270 w32font_coverage_ok (coverage
, charset
)
1271 FONTSIGNATURE
* coverage
;
1274 DWORD subrange1
= coverage
->fsUsb
[1];
1276 #define SUBRANGE1_HAN_MASK 0x08000000
1277 #define SUBRANGE1_HANGEUL_MASK 0x01000000
1278 #define SUBRANGE1_JAPANESE_MASK (0x00060000 | SUBRANGE1_HAN_MASK)
1280 if (charset
== GB2312_CHARSET
|| charset
== CHINESEBIG5_CHARSET
)
1282 return (subrange1
& SUBRANGE1_HAN_MASK
) == SUBRANGE1_HAN_MASK
;
1284 else if (charset
== SHIFTJIS_CHARSET
)
1286 return (subrange1
& SUBRANGE1_JAPANESE_MASK
) == SUBRANGE1_JAPANESE_MASK
;
1288 else if (charset
== HANGEUL_CHARSET
)
1290 return (subrange1
& SUBRANGE1_HANGEUL_MASK
) == SUBRANGE1_HANGEUL_MASK
;
1296 /* Callback function for EnumFontFamiliesEx.
1297 * Checks if a font matches everything we are trying to check agaist,
1298 * and if so, adds it to a list. Both the data we are checking against
1299 * and the list to which the fonts are added are passed in via the
1300 * lparam argument, in the form of a font_callback_data struct. */
1302 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1303 ENUMLOGFONTEX
*logical_font
;
1304 NEWTEXTMETRICEX
*physical_font
;
1308 struct font_callback_data
*match_data
1309 = (struct font_callback_data
*) lParam
;
1310 Lisp_Object backend
= match_data
->opentype_only
? Quniscribe
: Qgdi
;
1312 if ((!match_data
->opentype_only
1313 || (physical_font
->ntmTm
.ntmFlags
& NTMFLAGS_OPENTYPE
))
1314 && logfonts_match (&logical_font
->elfLogFont
, &match_data
->pattern
)
1315 && font_matches_spec (font_type
, physical_font
,
1316 match_data
->orig_font_spec
, backend
,
1317 &logical_font
->elfLogFont
)
1318 && w32font_coverage_ok (&physical_font
->ntmFontSig
,
1319 match_data
->pattern
.lfCharSet
)
1320 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1321 We limit this to raster fonts, because the test can catch some
1322 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1323 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1324 therefore get through this test. Since full names can be prefixed
1325 by a foundry, we accept raster fonts if the font name is found
1326 anywhere within the full name. */
1327 && (logical_font
->elfLogFont
.lfOutPrecision
!= OUT_STRING_PRECIS
1328 || strstr (logical_font
->elfFullName
,
1329 logical_font
->elfLogFont
.lfFaceName
)))
1332 = w32_enumfont_pattern_entity (match_data
->frame
, logical_font
,
1333 physical_font
, font_type
,
1334 &match_data
->pattern
,
1337 match_data
->list
= Fcons (entity
, match_data
->list
);
1342 /* Callback function for EnumFontFamiliesEx.
1343 * Terminates the search once we have a match. */
1345 add_one_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
)
1346 ENUMLOGFONTEX
*logical_font
;
1347 NEWTEXTMETRICEX
*physical_font
;
1351 struct font_callback_data
*match_data
1352 = (struct font_callback_data
*) lParam
;
1353 add_font_entity_to_list (logical_font
, physical_font
, font_type
, lParam
);
1355 /* If we have a font in the list, terminate the search. */
1356 return !NILP (match_data
->list
);
1359 /* Convert a Lisp font registry (symbol) to a windows charset. */
1361 registry_to_w32_charset (charset
)
1362 Lisp_Object charset
;
1364 if (EQ (charset
, Qiso10646_1
) || EQ (charset
, Qunicode_bmp
)
1365 || EQ (charset
, Qunicode_sip
))
1366 return DEFAULT_CHARSET
; /* UNICODE_CHARSET not defined in MingW32 */
1367 else if (EQ (charset
, Qiso8859_1
))
1368 return ANSI_CHARSET
;
1369 else if (SYMBOLP (charset
))
1370 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset
)));
1372 return DEFAULT_CHARSET
;
1376 w32_registry (w32_charset
, font_type
)
1380 /* If charset is defaulted, use ANSI (unicode for truetype fonts). */
1381 if (w32_charset
== DEFAULT_CHARSET
)
1382 w32_charset
= ANSI_CHARSET
;
1384 if (font_type
== TRUETYPE_FONTTYPE
&& w32_charset
== ANSI_CHARSET
)
1388 char * charset
= w32_to_x_charset (w32_charset
, NULL
);
1389 return font_intern_prop (charset
, strlen(charset
));
1394 w32_decode_weight (fnweight
)
1397 if (fnweight
>= FW_HEAVY
) return 210;
1398 if (fnweight
>= FW_EXTRABOLD
) return 205;
1399 if (fnweight
>= FW_BOLD
) return 200;
1400 if (fnweight
>= FW_SEMIBOLD
) return 180;
1401 if (fnweight
>= FW_NORMAL
) return 100;
1402 if (fnweight
>= FW_LIGHT
) return 50;
1403 if (fnweight
>= FW_EXTRALIGHT
) return 40;
1404 if (fnweight
> FW_THIN
) return 20;
1409 w32_encode_weight (n
)
1412 if (n
>= 210) return FW_HEAVY
;
1413 if (n
>= 205) return FW_EXTRABOLD
;
1414 if (n
>= 200) return FW_BOLD
;
1415 if (n
>= 180) return FW_SEMIBOLD
;
1416 if (n
>= 100) return FW_NORMAL
;
1417 if (n
>= 50) return FW_LIGHT
;
1418 if (n
>= 40) return FW_EXTRALIGHT
;
1419 if (n
>= 20) return FW_THIN
;
1423 /* Fill in all the available details of LOGFONT from FONT_SPEC. */
1425 fill_in_logfont (f
, logfont
, font_spec
)
1428 Lisp_Object font_spec
;
1430 Lisp_Object tmp
, extra
;
1431 int dpi
= FRAME_W32_DISPLAY_INFO (f
)->resy
;
1433 tmp
= AREF (font_spec
, FONT_DPI_INDEX
);
1438 else if (FLOATP (tmp
))
1440 dpi
= (int) (XFLOAT_DATA (tmp
) + 0.5);
1444 tmp
= AREF (font_spec
, FONT_SIZE_INDEX
);
1446 logfont
->lfHeight
= -1 * XINT (tmp
);
1447 else if (FLOATP (tmp
))
1448 logfont
->lfHeight
= (int) (-1.0 * dpi
* XFLOAT_DATA (tmp
) / 72.27 + 0.5);
1455 tmp
= AREF (font_spec
, FONT_WEIGHT_INDEX
);
1457 logfont
->lfWeight
= w32_encode_weight (FONT_WEIGHT_NUMERIC (font_spec
));
1460 tmp
= AREF (font_spec
, FONT_SLANT_INDEX
);
1463 int slant
= FONT_SLANT_NUMERIC (font_spec
);
1464 logfont
->lfItalic
= slant
> 150 ? 1 : 0;
1472 tmp
= AREF (font_spec
, FONT_REGISTRY_INDEX
);
1474 logfont
->lfCharSet
= registry_to_w32_charset (tmp
);
1476 logfont
->lfCharSet
= DEFAULT_CHARSET
;
1480 /* Clip Precision */
1483 logfont
->lfQuality
= DEFAULT_QUALITY
;
1485 /* Generic Family and Face Name */
1486 logfont
->lfPitchAndFamily
= FF_DONTCARE
| DEFAULT_PITCH
;
1488 tmp
= AREF (font_spec
, FONT_FAMILY_INDEX
);
1491 logfont
->lfPitchAndFamily
= w32_generic_family (tmp
) | DEFAULT_PITCH
;
1492 if ((logfont
->lfPitchAndFamily
& 0xF0) != FF_DONTCARE
)
1493 ; /* Font name was generic, don't fill in font name. */
1494 /* Font families are interned, but allow for strings also in case of
1496 else if (SYMBOLP (tmp
))
1497 strncpy (logfont
->lfFaceName
, SDATA (SYMBOL_NAME (tmp
)), LF_FACESIZE
);
1500 tmp
= AREF (font_spec
, FONT_ADSTYLE_INDEX
);
1503 /* Override generic family. */
1504 BYTE family
= w32_generic_family (tmp
);
1505 if (family
!= FF_DONTCARE
)
1506 logfont
->lfPitchAndFamily
= family
| DEFAULT_PITCH
;
1510 /* Set pitch based on the spacing property. */
1511 tmp
= AREF (font_spec
, FONT_SPACING_INDEX
);
1514 int spacing
= XINT (tmp
);
1515 if (spacing
< FONT_SPACING_MONO
)
1516 logfont
->lfPitchAndFamily
1517 = logfont
->lfPitchAndFamily
& 0xF0 | VARIABLE_PITCH
;
1519 logfont
->lfPitchAndFamily
1520 = logfont
->lfPitchAndFamily
& 0xF0 | FIXED_PITCH
;
1523 /* Process EXTRA info. */
1524 for (extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
1525 CONSP (extra
); extra
= XCDR (extra
))
1530 Lisp_Object key
, val
;
1531 key
= XCAR (tmp
), val
= XCDR (tmp
);
1532 /* Only use QCscript if charset is not provided, or is unicode
1533 and a single script is specified. This is rather crude,
1534 and is only used to narrow down the fonts returned where
1535 there is a definite match. Some scripts, such as latin, han,
1536 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1538 if (EQ (key
, QCscript
)
1539 && logfont
->lfCharSet
== DEFAULT_CHARSET
1542 if (EQ (val
, Qgreek
))
1543 logfont
->lfCharSet
= GREEK_CHARSET
;
1544 else if (EQ (val
, Qhangul
))
1545 logfont
->lfCharSet
= HANGUL_CHARSET
;
1546 else if (EQ (val
, Qkana
) || EQ (val
, Qkanbun
))
1547 logfont
->lfCharSet
= SHIFTJIS_CHARSET
;
1548 else if (EQ (val
, Qbopomofo
))
1549 logfont
->lfCharSet
= CHINESEBIG5_CHARSET
;
1550 /* GB 18030 supports tibetan, yi, mongolian,
1551 fonts that support it should show up if we ask for
1553 else if (EQ (val
, Qtibetan
) || EQ (val
, Qyi
)
1554 || EQ (val
, Qmongolian
))
1555 logfont
->lfCharSet
= GB2312_CHARSET
;
1556 else if (EQ (val
, Qhebrew
))
1557 logfont
->lfCharSet
= HEBREW_CHARSET
;
1558 else if (EQ (val
, Qarabic
))
1559 logfont
->lfCharSet
= ARABIC_CHARSET
;
1560 else if (EQ (val
, Qthai
))
1561 logfont
->lfCharSet
= THAI_CHARSET
;
1562 else if (EQ (val
, Qsymbol
))
1563 logfont
->lfCharSet
= SYMBOL_CHARSET
;
1565 else if (EQ (key
, QCantialias
) && SYMBOLP (val
))
1567 logfont
->lfQuality
= w32_antialias_type (val
);
1574 list_all_matching_fonts (match_data
)
1575 struct font_callback_data
*match_data
;
1578 Lisp_Object families
= w32font_list_family (match_data
->frame
);
1579 struct frame
*f
= XFRAME (match_data
->frame
);
1581 dc
= get_frame_dc (f
);
1583 while (!NILP (families
))
1585 /* TODO: Use the Unicode versions of the W32 APIs, so we can
1586 handle non-ASCII font names. */
1588 Lisp_Object family
= CAR (families
);
1589 families
= CDR (families
);
1592 else if (SYMBOLP (family
))
1593 name
= SDATA (SYMBOL_NAME (family
));
1597 strncpy (match_data
->pattern
.lfFaceName
, name
, LF_FACESIZE
);
1598 match_data
->pattern
.lfFaceName
[LF_FACESIZE
- 1] = '\0';
1600 EnumFontFamiliesEx (dc
, &match_data
->pattern
,
1601 (FONTENUMPROC
) add_font_entity_to_list
,
1602 (LPARAM
) match_data
, 0);
1605 release_frame_dc (f
, dc
);
1609 lispy_antialias_type (type
)
1616 case NONANTIALIASED_QUALITY
:
1619 case ANTIALIASED_QUALITY
:
1622 case CLEARTYPE_QUALITY
:
1625 case CLEARTYPE_NATURAL_QUALITY
:
1635 /* Convert antialiasing symbols to lfQuality */
1637 w32_antialias_type (type
)
1640 if (EQ (type
, Qnone
))
1641 return NONANTIALIASED_QUALITY
;
1642 else if (EQ (type
, Qstandard
))
1643 return ANTIALIASED_QUALITY
;
1644 else if (EQ (type
, Qsubpixel
))
1645 return CLEARTYPE_QUALITY
;
1646 else if (EQ (type
, Qnatural
))
1647 return CLEARTYPE_NATURAL_QUALITY
;
1649 return DEFAULT_QUALITY
;
1652 /* Return a list of all the scripts that the font supports. */
1654 font_supported_scripts (FONTSIGNATURE
* sig
)
1656 DWORD
* subranges
= sig
->fsUsb
;
1657 Lisp_Object supported
= Qnil
;
1659 /* Match a single subrange. SYM is set if bit N is set in subranges. */
1660 #define SUBRANGE(n,sym) \
1661 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
1662 supported = Fcons ((sym), supported)
1664 /* Match multiple subranges. SYM is set if any MASK bit is set in
1665 subranges[0 - 3]. */
1666 #define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
1667 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
1668 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
1669 supported = Fcons ((sym), supported)
1671 SUBRANGE (0, Qlatin
);
1672 /* The following count as latin too, ASCII should be present in these fonts,
1673 so don't need to mark them separately. */
1674 /* 1: Latin-1 supplement, 2: Latin Extended A, 3: Latin Extended B. */
1675 SUBRANGE (4, Qphonetic
);
1676 /* 5: Spacing and tone modifiers, 6: Combining Diacriticals. */
1677 SUBRANGE (7, Qgreek
);
1678 SUBRANGE (8, Qcoptic
);
1679 SUBRANGE (9, Qcyrillic
);
1680 SUBRANGE (10, Qarmenian
);
1681 SUBRANGE (11, Qhebrew
);
1682 SUBRANGE (13, Qarabic
);
1683 SUBRANGE (14, Qnko
);
1684 SUBRANGE (15, Qdevanagari
);
1685 SUBRANGE (16, Qbengali
);
1686 SUBRANGE (17, Qgurmukhi
);
1687 SUBRANGE (18, Qgujarati
);
1688 SUBRANGE (19, Qoriya
);
1689 SUBRANGE (20, Qtamil
);
1690 SUBRANGE (21, Qtelugu
);
1691 SUBRANGE (22, Qkannada
);
1692 SUBRANGE (23, Qmalayalam
);
1693 SUBRANGE (24, Qthai
);
1694 SUBRANGE (25, Qlao
);
1695 SUBRANGE (26, Qgeorgian
);
1696 SUBRANGE (27, Qbalinese
);
1697 /* 28: Hangul Jamo. */
1698 /* 29: Latin Extended, 30: Greek Extended, 31: Punctuation. */
1699 /* 32-47: Symbols (defined below). */
1700 SUBRANGE (48, Qcjk_misc
);
1701 /* Match either 49: katakana or 50: hiragana for kana. */
1702 MASK_ANY (0, 0x00060000, 0, 0, Qkana
);
1703 SUBRANGE (51, Qbopomofo
);
1704 /* 52: Compatibility Jamo */
1705 SUBRANGE (53, Qphags_pa
);
1706 /* 54: Enclosed CJK letters and months, 55: CJK Compatibility. */
1707 SUBRANGE (56, Qhangul
);
1708 /* 57: Surrogates. */
1709 SUBRANGE (58, Qphoenician
);
1710 SUBRANGE (59, Qhan
); /* There are others, but this is the main one. */
1711 SUBRANGE (59, Qideographic_description
); /* Windows lumps this in. */
1712 SUBRANGE (59, Qkanbun
); /* And this. */
1713 /* 60: Private use, 61: CJK strokes and compatibility. */
1714 /* 62: Alphabetic Presentation, 63: Arabic Presentation A. */
1715 /* 64: Combining half marks, 65: Vertical and CJK compatibility. */
1716 /* 66: Small forms, 67: Arabic Presentation B, 68: Half and Full width. */
1718 SUBRANGE (70, Qtibetan
);
1719 SUBRANGE (71, Qsyriac
);
1720 SUBRANGE (72, Qthaana
);
1721 SUBRANGE (73, Qsinhala
);
1722 SUBRANGE (74, Qmyanmar
);
1723 SUBRANGE (75, Qethiopic
);
1724 SUBRANGE (76, Qcherokee
);
1725 SUBRANGE (77, Qcanadian_aboriginal
);
1726 SUBRANGE (78, Qogham
);
1727 SUBRANGE (79, Qrunic
);
1728 SUBRANGE (80, Qkhmer
);
1729 SUBRANGE (81, Qmongolian
);
1730 SUBRANGE (82, Qbraille
);
1732 SUBRANGE (84, Qbuhid
);
1733 SUBRANGE (84, Qhanunoo
);
1734 SUBRANGE (84, Qtagalog
);
1735 SUBRANGE (84, Qtagbanwa
);
1736 SUBRANGE (85, Qold_italic
);
1737 SUBRANGE (86, Qgothic
);
1738 SUBRANGE (87, Qdeseret
);
1739 SUBRANGE (88, Qbyzantine_musical_symbol
);
1740 SUBRANGE (88, Qmusical_symbol
); /* Windows doesn't distinguish these. */
1741 SUBRANGE (89, Qmathematical
);
1742 /* 90: Private use, 91: Variation selectors, 92: Tags. */
1743 SUBRANGE (93, Qlimbu
);
1744 SUBRANGE (94, Qtai_le
);
1745 /* 95: New Tai Le */
1746 SUBRANGE (90, Qbuginese
);
1747 SUBRANGE (97, Qglagolitic
);
1748 SUBRANGE (98, Qtifinagh
);
1749 /* 99: Yijing Hexagrams. */
1750 SUBRANGE (100, Qsyloti_nagri
);
1751 SUBRANGE (101, Qlinear_b
);
1752 /* 102: Ancient Greek Numbers. */
1753 SUBRANGE (103, Qugaritic
);
1754 SUBRANGE (104, Qold_persian
);
1755 SUBRANGE (105, Qshavian
);
1756 SUBRANGE (106, Qosmanya
);
1757 SUBRANGE (107, Qcypriot
);
1758 SUBRANGE (108, Qkharoshthi
);
1759 /* 109: Tai Xuan Jing. */
1760 SUBRANGE (110, Qcuneiform
);
1761 /* 111: Counting Rods. */
1763 /* There isn't really a main symbol range, so include symbol if any
1764 relevant range is set. */
1765 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol
);
1767 /* Missing: Tai Viet (U+AA80) and Cham (U+AA00) . */
1774 /* Generate a full name for a Windows font.
1775 The full name is in fcname format, with weight, slant and antialiasing
1776 specified if they are not "normal". */
1778 w32font_full_name (font
, font_obj
, pixel_size
, name
, nbytes
)
1780 Lisp_Object font_obj
;
1785 int len
, height
, outline
;
1787 Lisp_Object antialiasing
, weight
= Qnil
;
1789 len
= strlen (font
->lfFaceName
);
1791 outline
= EQ (AREF (font_obj
, FONT_FOUNDRY_INDEX
), Qoutline
);
1793 /* Represent size of scalable fonts by point size. But use pixelsize for
1794 raster fonts to indicate that they are exactly that size. */
1796 len
+= 11; /* -SIZE */
1798 len
= strlen (font
->lfFaceName
) + 21;
1801 len
+= 7; /* :italic */
1803 if (font
->lfWeight
&& font
->lfWeight
!= FW_NORMAL
)
1805 weight
= FONT_WEIGHT_SYMBOLIC (font_obj
);
1806 len
+= 8 + SBYTES (SYMBOL_NAME (weight
)); /* :weight=NAME */
1809 antialiasing
= lispy_antialias_type (font
->lfQuality
);
1810 if (! NILP (antialiasing
))
1811 len
+= 11 + SBYTES (SYMBOL_NAME (antialiasing
)); /* :antialias=NAME */
1813 /* Check that the buffer is big enough */
1818 p
+= sprintf (p
, "%s", font
->lfFaceName
);
1820 height
= font
->lfHeight
? eabs (font
->lfHeight
) : pixel_size
;
1826 float pointsize
= height
* 72.0 / one_w32_display_info
.resy
;
1827 /* Round to nearest half point. floor is used, since round is not
1828 supported in MS library. */
1829 pointsize
= floor (pointsize
* 2 + 0.5) / 2;
1830 p
+= sprintf (p
, "-%1.1f", pointsize
);
1833 p
+= sprintf (p
, ":pixelsize=%d", height
);
1837 p
+= sprintf (p
, ":italic");
1839 if (SYMBOLP (weight
) && ! NILP (weight
))
1840 p
+= sprintf (p
, ":weight=%s", SDATA (SYMBOL_NAME (weight
)));
1842 if (SYMBOLP (antialiasing
) && ! NILP (antialiasing
))
1843 p
+= sprintf (p
, ":antialias=%s", SDATA (SYMBOL_NAME (antialiasing
)));
1849 static void compute_metrics (dc
, w32_font
, code
, metrics
)
1851 struct w32font_info
*w32_font
;
1853 struct w32_metric_cache
*metrics
;
1857 unsigned int options
= GGO_METRICS
;
1859 if (w32_font
->glyph_idx
)
1860 options
|= GGO_GLYPH_INDEX
;
1862 bzero (&transform
, sizeof (transform
));
1863 transform
.eM11
.value
= 1;
1864 transform
.eM22
.value
= 1;
1866 if (GetGlyphOutlineW (dc
, code
, options
, &gm
, 0, NULL
, &transform
)
1869 metrics
->lbearing
= gm
.gmptGlyphOrigin
.x
;
1870 metrics
->rbearing
= gm
.gmptGlyphOrigin
.x
+ gm
.gmBlackBoxX
;
1871 metrics
->width
= gm
.gmCellIncX
;
1872 metrics
->status
= W32METRIC_SUCCESS
;
1876 if (w32_font
->glyph_idx
)
1878 /* Can't use glyph indexes after all.
1879 Avoid it in future, and clear any metrics that were based on
1881 w32_font
->glyph_idx
= 0;
1882 clear_cached_metrics (w32_font
);
1885 metrics
->status
= W32METRIC_FAIL
;
1890 clear_cached_metrics (w32_font
)
1891 struct w32font_info
*w32_font
;
1894 for (i
= 0; i
< w32_font
->n_cache_blocks
; i
++)
1896 if (w32_font
->cached_metrics
[i
])
1897 bzero (w32_font
->cached_metrics
[i
],
1898 CACHE_BLOCKSIZE
* sizeof (struct font_metrics
));
1902 struct font_driver w32font_driver
=
1905 0, /* case insensitive */
1909 w32font_list_family
,
1910 NULL
, /* free_entity */
1913 NULL
, /* prepare_face */
1914 NULL
, /* done_face */
1916 w32font_encode_char
,
1917 w32font_text_extents
,
1919 NULL
, /* get_bitmap */
1920 NULL
, /* free_bitmap */
1921 NULL
, /* get_outline */
1922 NULL
, /* free_outline */
1923 NULL
, /* anchor_point */
1924 NULL
, /* otf_capability */
1925 NULL
, /* otf_drive */
1926 NULL
, /* start_for_frame */
1927 NULL
, /* end_for_frame */
1932 /* Initialize state that does not change between invocations. This is only
1933 called when Emacs is dumped. */
1937 DEFSYM (Qgdi
, "gdi");
1938 DEFSYM (Quniscribe
, "uniscribe");
1939 DEFSYM (QCformat
, ":format");
1941 /* Generic font families. */
1942 DEFSYM (Qmonospace
, "monospace");
1943 DEFSYM (Qserif
, "serif");
1944 DEFSYM (Qsansserif
, "sansserif");
1945 DEFSYM (Qscript
, "script");
1946 DEFSYM (Qdecorative
, "decorative");
1948 DEFSYM (Qsans_serif
, "sans_serif");
1949 DEFSYM (Qsans
, "sans");
1950 DEFSYM (Qmono
, "mono");
1952 /* Fake foundries. */
1953 DEFSYM (Qraster
, "raster");
1954 DEFSYM (Qoutline
, "outline");
1955 DEFSYM (Qunknown
, "unknown");
1958 DEFSYM (Qstandard
, "standard");
1959 DEFSYM (Qsubpixel
, "subpixel");
1960 DEFSYM (Qnatural
, "natural");
1968 DEFSYM (Qlatin
, "latin");
1969 DEFSYM (Qgreek
, "greek");
1970 DEFSYM (Qcoptic
, "coptic");
1971 DEFSYM (Qcyrillic
, "cyrillic");
1972 DEFSYM (Qarmenian
, "armenian");
1973 DEFSYM (Qhebrew
, "hebrew");
1974 DEFSYM (Qarabic
, "arabic");
1975 DEFSYM (Qsyriac
, "syriac");
1976 DEFSYM (Qnko
, "nko");
1977 DEFSYM (Qthaana
, "thaana");
1978 DEFSYM (Qdevanagari
, "devanagari");
1979 DEFSYM (Qbengali
, "bengali");
1980 DEFSYM (Qgurmukhi
, "gurmukhi");
1981 DEFSYM (Qgujarati
, "gujarati");
1982 DEFSYM (Qoriya
, "oriya");
1983 DEFSYM (Qtamil
, "tamil");
1984 DEFSYM (Qtelugu
, "telugu");
1985 DEFSYM (Qkannada
, "kannada");
1986 DEFSYM (Qmalayalam
, "malayalam");
1987 DEFSYM (Qsinhala
, "sinhala");
1988 DEFSYM (Qthai
, "thai");
1989 DEFSYM (Qlao
, "lao");
1990 DEFSYM (Qtibetan
, "tibetan");
1991 DEFSYM (Qmyanmar
, "myanmar");
1992 DEFSYM (Qgeorgian
, "georgian");
1993 DEFSYM (Qhangul
, "hangul");
1994 DEFSYM (Qethiopic
, "ethiopic");
1995 DEFSYM (Qcherokee
, "cherokee");
1996 DEFSYM (Qcanadian_aboriginal
, "canadian-aboriginal");
1997 DEFSYM (Qogham
, "ogham");
1998 DEFSYM (Qrunic
, "runic");
1999 DEFSYM (Qkhmer
, "khmer");
2000 DEFSYM (Qmongolian
, "mongolian");
2001 DEFSYM (Qsymbol
, "symbol");
2002 DEFSYM (Qbraille
, "braille");
2003 DEFSYM (Qhan
, "han");
2004 DEFSYM (Qideographic_description
, "ideographic-description");
2005 DEFSYM (Qcjk_misc
, "cjk-misc");
2006 DEFSYM (Qkana
, "kana");
2007 DEFSYM (Qbopomofo
, "bopomofo");
2008 DEFSYM (Qkanbun
, "kanbun");
2010 DEFSYM (Qbyzantine_musical_symbol
, "byzantine-musical-symbol");
2011 DEFSYM (Qmusical_symbol
, "musical-symbol");
2012 DEFSYM (Qmathematical
, "mathematical");
2013 DEFSYM (Qphonetic
, "phonetic");
2014 DEFSYM (Qbalinese
, "balinese");
2015 DEFSYM (Qbuginese
, "buginese");
2016 DEFSYM (Qbuhid
, "buhid");
2017 DEFSYM (Qcuneiform
, "cuneiform");
2018 DEFSYM (Qcypriot
, "cypriot");
2019 DEFSYM (Qdeseret
, "deseret");
2020 DEFSYM (Qglagolitic
, "glagolitic");
2021 DEFSYM (Qgothic
, "gothic");
2022 DEFSYM (Qhanunoo
, "hanunoo");
2023 DEFSYM (Qkharoshthi
, "kharoshthi");
2024 DEFSYM (Qlimbu
, "limbu");
2025 DEFSYM (Qlinear_b
, "linear_b");
2026 DEFSYM (Qold_italic
, "old_italic");
2027 DEFSYM (Qold_persian
, "old_persian");
2028 DEFSYM (Qosmanya
, "osmanya");
2029 DEFSYM (Qphags_pa
, "phags-pa");
2030 DEFSYM (Qphoenician
, "phoenician");
2031 DEFSYM (Qshavian
, "shavian");
2032 DEFSYM (Qsyloti_nagri
, "syloti_nagri");
2033 DEFSYM (Qtagalog
, "tagalog");
2034 DEFSYM (Qtagbanwa
, "tagbanwa");
2035 DEFSYM (Qtai_le
, "tai_le");
2036 DEFSYM (Qtifinagh
, "tifinagh");
2037 DEFSYM (Qugaritic
, "ugaritic");
2039 w32font_driver
.type
= Qgdi
;
2040 register_font_driver (&w32font_driver
, NULL
);
2043 /* arch-tag: 65b8a3cd-46aa-4c0d-a1f3-99e75b9c07ee
2044 (do not change this comment) */