HCoop / bpt / emacs.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
*** empty log message ***
[bpt/emacs.git] / src / w32font.c
... / ...
CommitLineData
1/* Font backend for the Microsoft W32 API.
2 Copyright (C) 2007, 2008 Free Software Foundation, Inc.
3
4This file is part of GNU Emacs.
5
6GNU Emacs is free software: you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation, either version 3 of the License, or
9(at your option) any later version.
10
11GNU Emacs is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
18
19#include <config.h>
20#include <windows.h>
21#include <math.h>
22
23#include "lisp.h"
24#include "w32term.h"
25#include "frame.h"
26#include "dispextern.h"
27#include "character.h"
28#include "charset.h"
29#include "fontset.h"
30#include "font.h"
31#include "w32font.h"
32
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.
36 */
37#ifndef CLEARTYPE_QUALITY
38#define CLEARTYPE_QUALITY 5
39#endif
40#ifndef CLEARTYPE_NATURAL_QUALITY
41#define CLEARTYPE_NATURAL_QUALITY 6
42#endif
43
44extern struct font_driver w32font_driver;
45
46Lisp_Object Qgdi;
47Lisp_Object Quniscribe;
48static Lisp_Object QCformat;
49static Lisp_Object Qmonospace, Qsansserif, Qmono, Qsans, Qsans_serif;
50static Lisp_Object Qserif, Qscript, Qdecorative;
51static Lisp_Object Qraster, Qoutline, Qunknown;
52
53/* antialiasing */
54extern Lisp_Object QCantialias, QCotf, QClang; /* defined in font.c */
55extern Lisp_Object Qnone; /* reuse from w32fns.c */
56static Lisp_Object Qstandard, Qsubpixel, Qnatural;
57
58/* languages */
59static Lisp_Object Qja, Qko, Qzh;
60
61/* scripts */
62static Lisp_Object Qlatin, Qgreek, Qcoptic, Qcyrillic, Qarmenian, Qhebrew;
63static Lisp_Object Qarabic, Qsyriac, Qnko, Qthaana, Qdevanagari, Qbengali;
64static Lisp_Object Qgurmukhi, Qgujarati, Qoriya, Qtamil, Qtelugu;
65static Lisp_Object Qkannada, Qmalayalam, Qsinhala, Qthai, Qlao;
66static Lisp_Object Qtibetan, Qmyanmar, Qgeorgian, Qhangul, Qethiopic;
67static Lisp_Object Qcherokee, Qcanadian_aboriginal, Qogham, Qrunic;
68static Lisp_Object Qkhmer, Qmongolian, Qsymbol, Qbraille, Qhan;
69static Lisp_Object Qideographic_description, Qcjk_misc, Qkana, Qbopomofo;
70static Lisp_Object Qkanbun, Qyi, Qbyzantine_musical_symbol;
71static Lisp_Object Qmusical_symbol, Qmathematical;
72/* Not defined in characters.el, but referenced in fontset.el. */
73static Lisp_Object Qbalinese, Qbuginese, Qbuhid, Qcuneiform, Qcypriot;
74static Lisp_Object Qdeseret, Qglagolitic, Qgothic, Qhanunoo, Qkharoshthi;
75static Lisp_Object Qlimbu, Qlinear_b, Qold_italic, Qold_persian, Qosmanya;
76static Lisp_Object Qphags_pa, Qphoenician, Qshavian, Qsyloti_nagri;
77static Lisp_Object Qtagalog, Qtagbanwa, Qtai_le, Qtifinagh, Qugaritic;
78/* Only defined here, but useful for distinguishing IPA capable fonts. */
79static Lisp_Object Qphonetic;
80
81/* Font spacing symbols - defined in font.c. */
82extern Lisp_Object Qc, Qp, Qm;
83
84static void fill_in_logfont P_ ((FRAME_PTR, LOGFONT *, Lisp_Object));
85
86static BYTE w32_antialias_type P_ ((Lisp_Object));
87static Lisp_Object lispy_antialias_type P_ ((BYTE));
88
89static Lisp_Object font_supported_scripts P_ ((FONTSIGNATURE *));
90static int w32font_full_name P_ ((LOGFONT *, Lisp_Object, int, char *, int));
91static void compute_metrics P_ ((HDC, struct w32font_info *, unsigned int,
92 struct w32_metric_cache *));
93static void clear_cached_metrics P_ ((struct w32font_info *));
94
95static Lisp_Object w32_registry P_ ((LONG, DWORD));
96
97/* EnumFontFamiliesEx callbacks. */
98static int CALLBACK add_font_entity_to_list P_ ((ENUMLOGFONTEX *,
99 NEWTEXTMETRICEX *,
100 DWORD, LPARAM));
101static int CALLBACK add_one_font_entity_to_list P_ ((ENUMLOGFONTEX *,
102 NEWTEXTMETRICEX *,
103 DWORD, LPARAM));
104static int CALLBACK add_font_name_to_list P_ ((ENUMLOGFONTEX *,
105 NEWTEXTMETRICEX *,
106 DWORD, LPARAM));
107
108/* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
109 of what we really want. */
110struct font_callback_data
111{
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. */
115 LOGFONT pattern;
116 /* The original font spec or entity. */
117 Lisp_Object orig_font_spec;
118 /* The frame the font is being loaded on. */
119 Lisp_Object frame;
120 /* The list to add matches to. */
121 Lisp_Object list;
122 /* Whether to match only opentype fonts. */
123 int opentype_only;
124};
125
126/* Handles the problem that EnumFontFamiliesEx will not return all
127 style variations if the font name is not specified. */
128static void list_all_matching_fonts P_ ((struct font_callback_data *));
129
130/* From old font code in w32fns.c */
131char * w32_to_x_charset P_ ((int, char *));
132
133
134static int
135memq_no_quit (elt, list)
136 Lisp_Object elt, list;
137{
138 while (CONSP (list) && ! EQ (XCAR (list), elt))
139 list = XCDR (list);
140 return (CONSP (list));
141}
142
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. */
146Lisp_Object
147w32font_get_cache (f)
148 FRAME_PTR f;
149{
150 struct w32_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
151
152 return (dpyinfo->name_list_element);
153}
154
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. */
159static Lisp_Object
160w32font_list (frame, font_spec)
161 Lisp_Object frame, font_spec;
162{
163 return w32font_list_internal (frame, font_spec, 0);
164}
165
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. */
170static Lisp_Object
171w32font_match (frame, font_spec)
172 Lisp_Object frame, font_spec;
173{
174 return w32font_match_internal (frame, font_spec, 0);
175}
176
177/* w32 implementation of list_family for font backend.
178 List available families. The value is a list of family names
179 (symbols). */
180static Lisp_Object
181w32font_list_family (frame)
182 Lisp_Object frame;
183{
184 Lisp_Object list = Qnil;
185 LOGFONT font_match_pattern;
186 HDC dc;
187 FRAME_PTR f = XFRAME (frame);
188
189 bzero (&font_match_pattern, sizeof (font_match_pattern));
190 font_match_pattern.lfCharSet = DEFAULT_CHARSET;
191
192 dc = get_frame_dc (f);
193
194 EnumFontFamiliesEx (dc, &font_match_pattern,
195 (FONTENUMPROC) add_font_name_to_list,
196 (LPARAM) &list, 0);
197 release_frame_dc (f, dc);
198
199 return list;
200}
201
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. */
205static Lisp_Object
206w32font_open (f, font_entity, pixel_size)
207 FRAME_PTR f;
208 Lisp_Object font_entity;
209 int pixel_size;
210{
211 Lisp_Object font_object;
212
213 font_object = font_make_object (VECSIZE (struct w32font_info));
214
215 if (!w32font_open_internal (f, font_entity, pixel_size, font_object))
216 {
217 return Qnil;
218 }
219
220 return font_object;
221}
222
223/* w32 implementation of close for font_backend.
224 Close FONT on frame F. */
225void
226w32font_close (f, font)
227 FRAME_PTR f;
228 struct font *font;
229{
230 struct w32font_info *w32_font = (struct w32font_info *) font;
231
232 if (w32_font->compat_w32_font)
233 {
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;
238 }
239}
240
241/* w32 implementation of has_char for font backend.
242 Optional.
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
245 it, return -1. */
246int
247w32font_has_char (entity, c)
248 Lisp_Object entity;
249 int c;
250{
251 Lisp_Object supported_scripts, extra, script;
252 DWORD mask;
253
254 extra = AREF (entity, FONT_EXTRA_INDEX);
255 if (!CONSP (extra))
256 return -1;
257
258 supported_scripts = assq_no_quit (QCscript, extra);
259 if (!CONSP (supported_scripts))
260 return -1;
261
262 supported_scripts = XCDR (supported_scripts);
263
264 script = CHAR_TABLE_REF (Vchar_script_table, c);
265
266 return (memq_no_quit (script, supported_scripts)) ? -1 : 0;
267}
268
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. */
272static unsigned
273w32font_encode_char (font, c)
274 struct font *font;
275 int c;
276{
277 struct frame *f;
278 HDC dc;
279 HFONT old_font;
280 DWORD retval;
281 GCP_RESULTSW result;
282 wchar_t in[2];
283 wchar_t out[2];
284 int len;
285 struct w32font_info *w32_font = (struct w32font_info *) font;
286
287 /* If glyph indexing is not working for this font, just return the
288 unicode code-point. */
289 if (!w32_font->glyph_idx)
290 return c;
291
292 if (c > 0xFFFF)
293 {
294 /* TODO: Encode as surrogate pair and lookup the glyph. */
295 return FONT_INVALID_CODE;
296 }
297 else
298 {
299 in[0] = (wchar_t) c;
300 len = 1;
301 }
302
303 bzero (&result, sizeof (result));
304 result.lStructSize = sizeof (result);
305 result.lpGlyphs = out;
306 result.nGlyphs = 2;
307
308 f = XFRAME (selected_frame);
309
310 dc = get_frame_dc (f);
311 old_font = SelectObject (dc, w32_font->compat_w32_font->hfont);
312
313 retval = GetCharacterPlacementW (dc, in, len, 0, &result, 0);
314
315 SelectObject (dc, old_font);
316 release_frame_dc (f, dc);
317
318 if (retval)
319 {
320 if (result.nGlyphs != 1 || !result.lpGlyphs[0])
321 return FONT_INVALID_CODE;
322 return result.lpGlyphs[0];
323 }
324 else
325 {
326 int i;
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);
332
333 return c;
334 }
335}
336
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. */
342int
343w32font_text_extents (font, code, nglyphs, metrics)
344 struct font *font;
345 unsigned *code;
346 int nglyphs;
347 struct font_metrics *metrics;
348{
349 int i;
350 HFONT old_font = NULL;
351 HDC dc = NULL;
352 struct frame * f;
353 int total_width = 0;
354 WORD *wcode = NULL;
355 SIZE size;
356
357 if (metrics)
358 {
359 struct w32font_info *w32_font = (struct w32font_info *) font;
360
361 bzero (metrics, sizeof (struct font_metrics));
362 metrics->ascent = font->ascent;
363 metrics->descent = font->descent;
364
365 for (i = 0; i < nglyphs; i++)
366 {
367 struct w32_metric_cache *char_metric;
368 int block = *(code + i) / CACHE_BLOCKSIZE;
369 int pos_in_block = *(code + i) % CACHE_BLOCKSIZE;
370
371 if (block >= w32_font->n_cache_blocks)
372 {
373 if (!w32_font->cached_metrics)
374 w32_font->cached_metrics
375 = xmalloc ((block + 1)
376 * sizeof (struct w32_cached_metric *));
377 else
378 w32_font->cached_metrics
379 = xrealloc (w32_font->cached_metrics,
380 (block + 1)
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;
386 }
387
388 if (!w32_font->cached_metrics[block])
389 {
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));
394 }
395
396 char_metric = w32_font->cached_metrics[block] + pos_in_block;
397
398 if (char_metric->status == W32METRIC_NO_ATTEMPT)
399 {
400 if (dc == NULL)
401 {
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);
407
408 dc = get_frame_dc (f);
409 old_font = SelectObject (dc, FONT_COMPAT (font)->hfont);
410 }
411 compute_metrics (dc, w32_font, *(code + i), char_metric);
412 }
413
414 if (char_metric->status == W32METRIC_SUCCESS)
415 {
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;
421 }
422 else
423 /* If we couldn't get metrics for a char,
424 use alternative method. */
425 break;
426 }
427 /* If we got through everything, return. */
428 if (i == nglyphs)
429 {
430 if (dc != NULL)
431 {
432 /* Restore state and release DC. */
433 SelectObject (dc, old_font);
434 release_frame_dc (f, dc);
435 }
436
437 return metrics->width;
438 }
439 }
440
441 /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
442 fallback on other methods that will at least give some of the metric
443 information. */
444 if (!wcode) {
445 wcode = alloca (nglyphs * sizeof (WORD));
446 for (i = 0; i < nglyphs; i++)
447 {
448 if (code[i] < 0x10000)
449 wcode[i] = code[i];
450 else
451 {
452 /* TODO: Convert to surrogate, reallocating array if needed */
453 wcode[i] = 0xffff;
454 }
455 }
456 }
457 if (dc == NULL)
458 {
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
462 frame. */
463 f = XFRAME (selected_frame);
464
465 dc = get_frame_dc (f);
466 old_font = SelectObject (dc, FONT_COMPAT (font)->hfont);
467 }
468
469 if (GetTextExtentPoint32W (dc, wcode, nglyphs, &size))
470 {
471 total_width = size.cx;
472 }
473
474 /* On 95/98/ME, only some unicode functions are available, so fallback
475 on doing a dummy draw to find the total width. */
476 if (!total_width)
477 {
478 RECT rect;
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;
483 }
484
485 /* Give our best estimate of the metrics, based on what we know. */
486 if (metrics)
487 {
488 metrics->width = total_width;
489 metrics->lbearing = 0;
490 metrics->rbearing = total_width
491 + ((struct w32font_info *) font)->metrics.tmOverhang;
492 }
493
494 /* Restore state and release DC. */
495 SelectObject (dc, old_font);
496 release_frame_dc (f, dc);
497
498 return total_width;
499}
500
501/* w32 implementation of draw for font backend.
502 Optional.
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).
507
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
512*/
513
514int
515w32font_draw (s, from, to, x, y, with_background)
516 struct glyph_string *s;
517 int from, to, x, y, with_background;
518{
519 UINT options;
520 HRGN orig_clip;
521 struct w32font_info *w32font = (struct w32font_info *) s->font;
522
523 options = w32font->glyph_idx;
524
525 /* Save clip region for later restoration. */
526 GetClipRgn(s->hdc, orig_clip);
527
528 if (s->num_clips > 0)
529 {
530 HRGN new_clip = CreateRectRgnIndirect (s->clip);
531
532 if (s->num_clips > 1)
533 {
534 HRGN clip2 = CreateRectRgnIndirect (s->clip + 1);
535
536 CombineRgn (new_clip, new_clip, clip2, RGN_OR);
537 DeleteObject (clip2);
538 }
539
540 SelectClipRgn (s->hdc, new_clip);
541 DeleteObject (new_clip);
542 }
543
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);
547 if (with_background)
548 {
549 HBRUSH brush;
550 RECT rect;
551 struct font *font = s->font;
552
553 brush = CreateSolidBrush (s->gc->background);
554 rect.left = x;
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);
560 }
561
562 if (s->padding_p)
563 {
564 int len = to - from, i;
565
566 for (i = 0; i < len; i++)
567 ExtTextOutW (s->hdc, x + i, y, options, NULL,
568 s->char2b + from + i, 1, NULL);
569 }
570 else
571 ExtTextOutW (s->hdc, x, y, options, NULL, s->char2b + from, to - from, NULL);
572
573 /* Restore clip region. */
574 if (s->num_clips > 0)
575 {
576 SelectClipRgn (s->hdc, orig_clip);
577 }
578}
579
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.
583static void
584w32font_free_entity (Lisp_Object entity);
585 */
586
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.
592static int
593w32font_prepare_face (FRAME_PTR f, struct face *face);
594 */
595/* w32 implementation of done_face for font backend.
596 Optional.
597 Done FACE for displaying characters by FACE->font on frame F.
598static void
599w32font_done_face (FRAME_PTR f, struct face *face); */
600
601/* w32 implementation of get_bitmap for font backend.
602 Optional.
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
605 for actual drawing.
606static int
607w32font_get_bitmap (struct font *font, unsigned code,
608 struct font_bitmap *bitmap, int bits_per_pixel);
609 */
610/* w32 implementation of free_bitmap for font backend.
611 Optional.
612 Free bitmap data in BITMAP.
613static void
614w32font_free_bitmap (struct font *font, struct font_bitmap *bitmap);
615 */
616/* w32 implementation of get_outline for font backend.
617 Optional.
618 Return an outline data for glyph-code CODE of FONT. The format
619 of the outline data depends on the font-driver.
620static void *
621w32font_get_outline (struct font *font, unsigned code);
622 */
623/* w32 implementation of free_outline for font backend.
624 Optional.
625 Free OUTLINE (that is obtained by the above method).
626static void
627w32font_free_outline (struct font *font, void *outline);
628 */
629/* w32 implementation of anchor_point for font backend.
630 Optional.
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.
634static int
635w32font_anchor_point (struct font *font, unsigned code,
636 int index, int *x, int *y);
637 */
638/* w32 implementation of otf_capability for font backend.
639 Optional.
640 Return a list describing which scripts/languages FONT
641 supports by which GSUB/GPOS features of OpenType tables.
642static Lisp_Object
643w32font_otf_capability (struct font *font);
644 */
645/* w32 implementation of otf_drive for font backend.
646 Optional.
647 Apply FONT's OTF-FEATURES to the glyph string.
648
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.
652
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
656 following elements.
657
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
660 short, return -1.
661static int
662w32font_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);
666 */
667
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. */
671Lisp_Object
672w32font_list_internal (frame, font_spec, opentype_only)
673 Lisp_Object frame, font_spec;
674 int opentype_only;
675{
676 struct font_callback_data match_data;
677 HDC dc;
678 FRAME_PTR f = XFRAME (frame);
679
680 match_data.orig_font_spec = font_spec;
681 match_data.list = Qnil;
682 match_data.frame = frame;
683
684 bzero (&match_data.pattern, sizeof (LOGFONT));
685 fill_in_logfont (f, &match_data.pattern, font_spec);
686
687 match_data.opentype_only = opentype_only;
688 if (opentype_only)
689 match_data.pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;
690
691 if (match_data.pattern.lfFaceName[0] == '\0')
692 {
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);
696 }
697 else
698 {
699 dc = get_frame_dc (f);
700
701 EnumFontFamiliesEx (dc, &match_data.pattern,
702 (FONTENUMPROC) add_font_entity_to_list,
703 (LPARAM) &match_data, 0);
704 release_frame_dc (f, dc);
705 }
706
707 return NILP (match_data.list) ? Qnil : match_data.list;
708}
709
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. */
713Lisp_Object
714w32font_match_internal (frame, font_spec, opentype_only)
715 Lisp_Object frame, font_spec;
716 int opentype_only;
717{
718 struct font_callback_data match_data;
719 HDC dc;
720 FRAME_PTR f = XFRAME (frame);
721
722 match_data.orig_font_spec = font_spec;
723 match_data.frame = frame;
724 match_data.list = Qnil;
725
726 bzero (&match_data.pattern, sizeof (LOGFONT));
727 fill_in_logfont (f, &match_data.pattern, font_spec);
728
729 match_data.opentype_only = opentype_only;
730 if (opentype_only)
731 match_data.pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;
732
733 dc = get_frame_dc (f);
734
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);
739
740 return NILP (match_data.list) ? Qnil : XCAR (match_data.list);
741}
742
743int
744w32font_open_internal (f, font_entity, pixel_size, font_object)
745 FRAME_PTR f;
746 Lisp_Object font_entity;
747 int pixel_size;
748 Lisp_Object font_object;
749{
750 int len, size, i;
751 LOGFONT logfont;
752 HDC dc;
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;
758 struct font * font;
759 OUTLINETEXTMETRIC* metrics = NULL;
760
761 w32_font = (struct w32font_info *) XFONT_OBJECT (font_object);
762 font = (struct font *) w32_font;
763
764 if (!font)
765 return 0;
766
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));
771
772 bzero (&logfont, sizeof (logfont));
773 fill_in_logfont (f, &logfont, font_entity);
774
775 size = XINT (AREF (font_entity, FONT_SIZE_INDEX));
776 if (!size)
777 size = pixel_size;
778
779 logfont.lfHeight = -size;
780 hfont = CreateFontIndirect (&logfont);
781
782 if (hfont == NULL)
783 return 0;
784
785 /* Get the metrics for this font. */
786 dc = get_frame_dc (f);
787 old_font = SelectObject (dc, hfont);
788
789 /* Try getting the outline metrics (only works for truetype fonts). */
790 len = GetOutlineTextMetrics (dc, 0, NULL);
791 if (len)
792 {
793 metrics = (OUTLINETEXTMETRIC *) alloca (len);
794 if (GetOutlineTextMetrics (dc, len, metrics))
795 bcopy (&metrics->otmTextMetrics, &w32_font->metrics,
796 sizeof (TEXTMETRIC));
797 else
798 metrics = NULL;
799
800 /* If it supports outline metrics, it should support Glyph Indices. */
801 w32_font->glyph_idx = ETO_GLYPH_INDEX;
802 }
803
804 if (!metrics)
805 {
806 GetTextMetrics (dc, &w32_font->metrics);
807 w32_font->glyph_idx = 0;
808 }
809
810 w32_font->cached_metrics = NULL;
811 w32_font->n_cache_blocks = 0;
812
813 SelectObject (dc, old_font);
814 release_frame_dc (f, dc);
815
816 /* W32FontStruct - we should get rid of this, and use the w32font_info
817 struct for any W32 specific fields. font->font.font can then be hfont. */
818 w32_font->compat_w32_font = xmalloc (sizeof (W32FontStruct));
819 compat_w32_font = w32_font->compat_w32_font;
820 bzero (compat_w32_font, sizeof (W32FontStruct));
821 compat_w32_font->font_type = UNICODE_FONT;
822 /* Duplicate the text metrics. */
823 bcopy (&w32_font->metrics, &compat_w32_font->tm, sizeof (TEXTMETRIC));
824 compat_w32_font->hfont = hfont;
825
826 {
827 char *name;
828
829 /* We don't know how much space we need for the full name, so start with
830 96 bytes and go up in steps of 32. */
831 len = 96;
832 name = xmalloc (len);
833 while (name && w32font_full_name (&logfont, font_entity, pixel_size,
834 name, len) < 0)
835 {
836 char *new = xrealloc (name, len += 32);
837
838 if (! new)
839 xfree (name);
840 name = new;
841 }
842 if (name)
843 font->props[FONT_FULLNAME_INDEX]
844 = make_unibyte_string (name, strlen (name));
845 else
846 font->props[FONT_FULLNAME_INDEX] =
847 make_unibyte_string (logfont.lfFaceName, len);
848 }
849
850 font->max_width = w32_font->metrics.tmMaxCharWidth;
851 font->height = w32_font->metrics.tmHeight
852 + w32_font->metrics.tmExternalLeading;
853 font->space_width = font->average_width = w32_font->metrics.tmAveCharWidth;
854
855 font->vertical_centering = 0;
856 font->encoding_type = 0;
857 font->baseline_offset = 0;
858 font->relative_compose = 0;
859 font->default_ascent = w32_font->metrics.tmAscent;
860 font->font_encoder = NULL;
861 font->pixel_size = size;
862 font->driver = &w32font_driver;
863 /* Use format cached during list, as the information we have access to
864 here is incomplete. */
865 extra = AREF (font_entity, FONT_EXTRA_INDEX);
866 if (CONSP (extra))
867 {
868 val = assq_no_quit (QCformat, extra);
869 if (CONSP (val))
870 font->props[FONT_FORMAT_INDEX] = XCDR (val);
871 else
872 font->props[FONT_FORMAT_INDEX] = Qunknown;
873 }
874 else
875 font->props[FONT_FORMAT_INDEX] = Qunknown;
876
877 font->props[FONT_FILE_INDEX] = Qnil;
878 font->encoding_charset = -1;
879 font->repertory_charset = -1;
880 /* TODO: do we really want the minimum width here, which could be negative? */
881 font->min_width = font->space_width;
882 font->ascent = w32_font->metrics.tmAscent;
883 font->descent = w32_font->metrics.tmDescent;
884
885 if (metrics)
886 {
887 font->underline_thickness = metrics->otmsUnderscoreSize;
888 font->underline_position = -metrics->otmsUnderscorePosition;
889 }
890 else
891 {
892 font->underline_thickness = 0;
893 font->underline_position = -1;
894 }
895
896 /* max_descent is used for underlining in w32term.c. Hopefully this
897 is temporary, as we'll want to get rid of the old compatibility
898 stuff later. */
899 compat_w32_font->max_bounds.descent = font->descent;
900
901 /* For temporary compatibility with legacy code that expects the
902 name to be usable in x-list-fonts. Eventually we expect to change
903 x-list-fonts and other places that use fonts so that this can be
904 an fcname or similar. */
905 font->props[FONT_NAME_INDEX] = Ffont_xlfd_name (font_object, Qnil);
906
907 return 1;
908}
909
910/* Callback function for EnumFontFamiliesEx.
911 * Adds the name of a font to a Lisp list (passed in as the lParam arg). */
912static int CALLBACK
913add_font_name_to_list (logical_font, physical_font, font_type, list_object)
914 ENUMLOGFONTEX *logical_font;
915 NEWTEXTMETRICEX *physical_font;
916 DWORD font_type;
917 LPARAM list_object;
918{
919 Lisp_Object* list = (Lisp_Object *) list_object;
920 Lisp_Object family;
921
922 /* Skip vertical fonts (intended only for printing) */
923 if (logical_font->elfLogFont.lfFaceName[0] == '@')
924 return 1;
925
926 family = font_intern_prop (logical_font->elfLogFont.lfFaceName,
927 strlen (logical_font->elfLogFont.lfFaceName));
928 if (! memq_no_quit (family, *list))
929 *list = Fcons (family, *list);
930
931 return 1;
932}
933
934static int w32_decode_weight P_ ((int));
935static int w32_encode_weight P_ ((int));
936
937/* Convert an enumerated Windows font to an Emacs font entity. */
938static Lisp_Object
939w32_enumfont_pattern_entity (frame, logical_font, physical_font,
940 font_type, requested_font, backend)
941 Lisp_Object frame;
942 ENUMLOGFONTEX *logical_font;
943 NEWTEXTMETRICEX *physical_font;
944 DWORD font_type;
945 LOGFONT *requested_font;
946 Lisp_Object backend;
947{
948 Lisp_Object entity, tem;
949 LOGFONT *lf = (LOGFONT*) logical_font;
950 BYTE generic_type;
951 DWORD full_type = physical_font->ntmTm.ntmFlags;
952
953 entity = font_make_entity ();
954
955 ASET (entity, FONT_TYPE_INDEX, backend);
956 ASET (entity, FONT_REGISTRY_INDEX, w32_registry (lf->lfCharSet, font_type));
957 ASET (entity, FONT_OBJLIST_INDEX, Qnil);
958
959 /* Foundry is difficult to get in readable form on Windows.
960 But Emacs crashes if it is not set, so set it to something more
961 generic. These values make xlfds compatible with Emacs 22. */
962 if (lf->lfOutPrecision == OUT_STRING_PRECIS)
963 tem = Qraster;
964 else if (lf->lfOutPrecision == OUT_STROKE_PRECIS)
965 tem = Qoutline;
966 else
967 tem = Qunknown;
968
969 ASET (entity, FONT_FOUNDRY_INDEX, tem);
970
971 /* Save the generic family in the extra info, as it is likely to be
972 useful to users looking for a close match. */
973 generic_type = physical_font->ntmTm.tmPitchAndFamily & 0xF0;
974 if (generic_type == FF_DECORATIVE)
975 tem = Qdecorative;
976 else if (generic_type == FF_MODERN)
977 tem = Qmono;
978 else if (generic_type == FF_ROMAN)
979 tem = Qserif;
980 else if (generic_type == FF_SCRIPT)
981 tem = Qscript;
982 else if (generic_type == FF_SWISS)
983 tem = Qsans;
984 else
985 tem = Qnil;
986
987 ASET (entity, FONT_ADSTYLE_INDEX, tem);
988
989 if (physical_font->ntmTm.tmPitchAndFamily & 0x01)
990 ASET (entity, FONT_SPACING_INDEX, make_number (FONT_SPACING_PROPORTIONAL));
991 else
992 ASET (entity, FONT_SPACING_INDEX, make_number (FONT_SPACING_CHARCELL));
993
994 if (requested_font->lfQuality != DEFAULT_QUALITY)
995 {
996 font_put_extra (entity, QCantialias,
997 lispy_antialias_type (requested_font->lfQuality));
998 }
999 ASET (entity, FONT_FAMILY_INDEX,
1000 font_intern_prop (lf->lfFaceName, strlen (lf->lfFaceName)));
1001
1002 FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX,
1003 make_number (w32_decode_weight (lf->lfWeight)));
1004 FONT_SET_STYLE (entity, FONT_SLANT_INDEX,
1005 make_number (lf->lfItalic ? 200 : 100));
1006 /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
1007 to get it. */
1008 FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_number (100));
1009
1010 if (font_type & RASTER_FONTTYPE)
1011 ASET (entity, FONT_SIZE_INDEX, make_number (physical_font->ntmTm.tmHeight));
1012 else
1013 ASET (entity, FONT_SIZE_INDEX, make_number (0));
1014
1015 /* Cache unicode codepoints covered by this font, as there is no other way
1016 of getting this information easily. */
1017 if (font_type & TRUETYPE_FONTTYPE)
1018 {
1019 font_put_extra (entity, QCscript,
1020 font_supported_scripts (&physical_font->ntmFontSig));
1021 }
1022
1023 /* This information is not fully available when opening fonts, so
1024 save it here. Only Windows 2000 and later return information
1025 about opentype and type1 fonts, so need a fallback for detecting
1026 truetype so that this information is not any worse than we could
1027 have obtained later. */
1028 if (EQ (backend, Quniscribe) && (full_type & NTMFLAGS_OPENTYPE))
1029 tem = intern ("opentype");
1030 else if (font_type & TRUETYPE_FONTTYPE)
1031 tem = intern ("truetype");
1032 else if (full_type & NTM_PS_OPENTYPE)
1033 tem = intern ("postscript");
1034 else if (full_type & NTM_TYPE1)
1035 tem = intern ("type1");
1036 else if (font_type & RASTER_FONTTYPE)
1037 tem = intern ("w32bitmap");
1038 else
1039 tem = intern ("w32vector");
1040
1041 font_put_extra (entity, QCformat, tem);
1042
1043 return entity;
1044}
1045
1046
1047/* Convert generic families to the family portion of lfPitchAndFamily. */
1048BYTE
1049w32_generic_family (Lisp_Object name)
1050{
1051 /* Generic families. */
1052 if (EQ (name, Qmonospace) || EQ (name, Qmono))
1053 return FF_MODERN;
1054 else if (EQ (name, Qsans) || EQ (name, Qsans_serif) || EQ (name, Qsansserif))
1055 return FF_SWISS;
1056 else if (EQ (name, Qserif))
1057 return FF_ROMAN;
1058 else if (EQ (name, Qdecorative))
1059 return FF_DECORATIVE;
1060 else if (EQ (name, Qscript))
1061 return FF_SCRIPT;
1062 else
1063 return FF_DONTCARE;
1064}
1065
1066static int
1067logfonts_match (font, pattern)
1068 LOGFONT *font, *pattern;
1069{
1070 /* Only check height for raster fonts. */
1071 if (pattern->lfHeight && font->lfOutPrecision == OUT_STRING_PRECIS
1072 && font->lfHeight != pattern->lfHeight)
1073 return 0;
1074
1075 /* Have some flexibility with weights. */
1076 if (pattern->lfWeight
1077 && ((font->lfWeight < (pattern->lfWeight - 150))
1078 || font->lfWeight > (pattern->lfWeight + 150)))
1079 return 0;
1080
1081 /* Charset and face should be OK. Italic has to be checked
1082 against the original spec, in case we don't have any preference. */
1083 return 1;
1084}
1085
1086static int
1087font_matches_spec (type, font, spec, backend, logfont)
1088 DWORD type;
1089 NEWTEXTMETRICEX *font;
1090 Lisp_Object spec;
1091 Lisp_Object backend;
1092 LOGFONT *logfont;
1093{
1094 Lisp_Object extra, val;
1095
1096 /* Check italic. Can't check logfonts, since it is a boolean field,
1097 so there is no difference between "non-italic" and "don't care". */
1098 {
1099 int slant = FONT_SLANT_NUMERIC (spec);
1100
1101 if (slant >= 0
1102 && ((slant > 150 && !font->ntmTm.tmItalic)
1103 || (slant <= 150 && font->ntmTm.tmItalic)))
1104 return 0;
1105 }
1106
1107 /* Check adstyle against generic family. */
1108 val = AREF (spec, FONT_ADSTYLE_INDEX);
1109 if (!NILP (val))
1110 {
1111 BYTE family = w32_generic_family (val);
1112 if (family != FF_DONTCARE
1113 && family != (font->ntmTm.tmPitchAndFamily & 0xF0))
1114 return 0;
1115 }
1116
1117 /* Check spacing */
1118 val = AREF (spec, FONT_SPACING_INDEX);
1119 if (INTEGERP (val))
1120 {
1121 int spacing = XINT (val);
1122 int proportional = (spacing < FONT_SPACING_MONO);
1123
1124 if ((proportional && !(font->ntmTm.tmPitchAndFamily & 0x01))
1125 || (!proportional && (font->ntmTm.tmPitchAndFamily & 0x01)))
1126 return 0;
1127 }
1128
1129 /* Check extra parameters. */
1130 for (extra = AREF (spec, FONT_EXTRA_INDEX);
1131 CONSP (extra); extra = XCDR (extra))
1132 {
1133 Lisp_Object extra_entry;
1134 extra_entry = XCAR (extra);
1135 if (CONSP (extra_entry))
1136 {
1137 Lisp_Object key = XCAR (extra_entry);
1138
1139 val = XCDR (extra_entry);
1140 if (EQ (key, QCscript) && SYMBOLP (val))
1141 {
1142 /* Only truetype fonts will have information about what
1143 scripts they support. This probably means the user
1144 will have to force Emacs to use raster, postscript
1145 or atm fonts for non-ASCII text. */
1146 if (type & TRUETYPE_FONTTYPE)
1147 {
1148 Lisp_Object support
1149 = font_supported_scripts (&font->ntmFontSig);
1150 if (! memq_no_quit (val, support))
1151 return 0;
1152 }
1153 else
1154 {
1155 /* Return specific matches, but play it safe. Fonts
1156 that cover more than their charset would suggest
1157 are likely to be truetype or opentype fonts,
1158 covered above. */
1159 if (EQ (val, Qlatin))
1160 {
1161 /* Although every charset but symbol, thai and
1162 arabic contains the basic ASCII set of latin
1163 characters, Emacs expects much more. */
1164 if (font->ntmTm.tmCharSet != ANSI_CHARSET)
1165 return 0;
1166 }
1167 else if (EQ (val, Qsymbol))
1168 {
1169 if (font->ntmTm.tmCharSet != SYMBOL_CHARSET)
1170 return 0;
1171 }
1172 else if (EQ (val, Qcyrillic))
1173 {
1174 if (font->ntmTm.tmCharSet != RUSSIAN_CHARSET)
1175 return 0;
1176 }
1177 else if (EQ (val, Qgreek))
1178 {
1179 if (font->ntmTm.tmCharSet != GREEK_CHARSET)
1180 return 0;
1181 }
1182 else if (EQ (val, Qarabic))
1183 {
1184 if (font->ntmTm.tmCharSet != ARABIC_CHARSET)
1185 return 0;
1186 }
1187 else if (EQ (val, Qhebrew))
1188 {
1189 if (font->ntmTm.tmCharSet != HEBREW_CHARSET)
1190 return 0;
1191 }
1192 else if (EQ (val, Qthai))
1193 {
1194 if (font->ntmTm.tmCharSet != THAI_CHARSET)
1195 return 0;
1196 }
1197 else if (EQ (val, Qkana))
1198 {
1199 if (font->ntmTm.tmCharSet != SHIFTJIS_CHARSET)
1200 return 0;
1201 }
1202 else if (EQ (val, Qbopomofo))
1203 {
1204 if (font->ntmTm.tmCharSet != CHINESEBIG5_CHARSET)
1205 return 0;
1206 }
1207 else if (EQ (val, Qhangul))
1208 {
1209 if (font->ntmTm.tmCharSet != HANGUL_CHARSET
1210 && font->ntmTm.tmCharSet != JOHAB_CHARSET)
1211 return 0;
1212 }
1213 else if (EQ (val, Qhan))
1214 {
1215 if (font->ntmTm.tmCharSet != CHINESEBIG5_CHARSET
1216 && font->ntmTm.tmCharSet != GB2312_CHARSET
1217 && font->ntmTm.tmCharSet != HANGUL_CHARSET
1218 && font->ntmTm.tmCharSet != JOHAB_CHARSET
1219 && font->ntmTm.tmCharSet != SHIFTJIS_CHARSET)
1220 return 0;
1221 }
1222 else
1223 /* Other scripts unlikely to be handled by non-truetype
1224 fonts. */
1225 return 0;
1226 }
1227 }
1228 else if (EQ (key, QClang) && SYMBOLP (val))
1229 {
1230 /* Just handle the CJK languages here, as the language
1231 parameter is used to select a font with appropriate
1232 glyphs in the cjk unified ideographs block. Other fonts
1233 support for a language can be solely determined by
1234 its character coverage. */
1235 if (EQ (val, Qja))
1236 {
1237 if (font->ntmTm.tmCharSet != SHIFTJIS_CHARSET)
1238 return 0;
1239 }
1240 else if (EQ (val, Qko))
1241 {
1242 if (font->ntmTm.tmCharSet != HANGUL_CHARSET
1243 && font->ntmTm.tmCharSet != JOHAB_CHARSET)
1244 return 0;
1245 }
1246 else if (EQ (val, Qzh))
1247 {
1248 if (font->ntmTm.tmCharSet != GB2312_CHARSET
1249 && font->ntmTm.tmCharSet != CHINESEBIG5_CHARSET)
1250 return 0;
1251 }
1252 else
1253 /* Any other language, we don't recognize it. Fontset
1254 spec should have a fallback, as some backends do
1255 not recognize language at all. */
1256 return 0;
1257 }
1258 else if (EQ (key, QCotf) && CONSP (val))
1259 {
1260 /* OTF features only supported by the uniscribe backend. */
1261 if (EQ (backend, Quniscribe))
1262 {
1263 if (!uniscribe_check_otf (logfont, val))
1264 return 0;
1265 }
1266 else
1267 return 0;
1268 }
1269 }
1270 }
1271 return 1;
1272}
1273
1274static int
1275w32font_coverage_ok (coverage, charset)
1276 FONTSIGNATURE * coverage;
1277 BYTE charset;
1278{
1279 DWORD subrange1 = coverage->fsUsb[1];
1280
1281#define SUBRANGE1_HAN_MASK 0x08000000
1282#define SUBRANGE1_HANGEUL_MASK 0x01000000
1283#define SUBRANGE1_JAPANESE_MASK (0x00060000 | SUBRANGE1_HAN_MASK)
1284
1285 if (charset == GB2312_CHARSET || charset == CHINESEBIG5_CHARSET)
1286 {
1287 return (subrange1 & SUBRANGE1_HAN_MASK) == SUBRANGE1_HAN_MASK;
1288 }
1289 else if (charset == SHIFTJIS_CHARSET)
1290 {
1291 return (subrange1 & SUBRANGE1_JAPANESE_MASK) == SUBRANGE1_JAPANESE_MASK;
1292 }
1293 else if (charset == HANGEUL_CHARSET)
1294 {
1295 return (subrange1 & SUBRANGE1_HANGEUL_MASK) == SUBRANGE1_HANGEUL_MASK;
1296 }
1297
1298 return 1;
1299}
1300
1301/* Callback function for EnumFontFamiliesEx.
1302 * Checks if a font matches everything we are trying to check agaist,
1303 * and if so, adds it to a list. Both the data we are checking against
1304 * and the list to which the fonts are added are passed in via the
1305 * lparam argument, in the form of a font_callback_data struct. */
1306static int CALLBACK
1307add_font_entity_to_list (logical_font, physical_font, font_type, lParam)
1308 ENUMLOGFONTEX *logical_font;
1309 NEWTEXTMETRICEX *physical_font;
1310 DWORD font_type;
1311 LPARAM lParam;
1312{
1313 struct font_callback_data *match_data
1314 = (struct font_callback_data *) lParam;
1315 Lisp_Object backend = match_data->opentype_only ? Quniscribe : Qgdi;
1316
1317 if ((!match_data->opentype_only
1318 || (physical_font->ntmTm.ntmFlags & NTMFLAGS_OPENTYPE))
1319 && logfonts_match (&logical_font->elfLogFont, &match_data->pattern)
1320 && font_matches_spec (font_type, physical_font,
1321 match_data->orig_font_spec, backend,
1322 &logical_font->elfLogFont)
1323 && w32font_coverage_ok (&physical_font->ntmFontSig,
1324 match_data->pattern.lfCharSet)
1325 /* Avoid substitutions involving raster fonts (eg Helv -> MS Sans Serif)
1326 We limit this to raster fonts, because the test can catch some
1327 genuine fonts (eg the full name of DejaVu Sans Mono Light is actually
1328 DejaVu Sans Mono ExtraLight). Helvetica -> Arial substitution will
1329 therefore get through this test. Since full names can be prefixed
1330 by a foundry, we accept raster fonts if the font name is found
1331 anywhere within the full name. */
1332 && (logical_font->elfLogFont.lfOutPrecision != OUT_STRING_PRECIS
1333 || strstr (logical_font->elfFullName,
1334 logical_font->elfLogFont.lfFaceName)))
1335 {
1336 Lisp_Object entity
1337 = w32_enumfont_pattern_entity (match_data->frame, logical_font,
1338 physical_font, font_type,
1339 &match_data->pattern,
1340 backend);
1341 if (!NILP (entity))
1342 match_data->list = Fcons (entity, match_data->list);
1343 }
1344 return 1;
1345}
1346
1347/* Callback function for EnumFontFamiliesEx.
1348 * Terminates the search once we have a match. */
1349static int CALLBACK
1350add_one_font_entity_to_list (logical_font, physical_font, font_type, lParam)
1351 ENUMLOGFONTEX *logical_font;
1352 NEWTEXTMETRICEX *physical_font;
1353 DWORD font_type;
1354 LPARAM lParam;
1355{
1356 struct font_callback_data *match_data
1357 = (struct font_callback_data *) lParam;
1358 add_font_entity_to_list (logical_font, physical_font, font_type, lParam);
1359
1360 /* If we have a font in the list, terminate the search. */
1361 return !NILP (match_data->list);
1362}
1363
1364/* Convert a Lisp font registry (symbol) to a windows charset. */
1365static LONG
1366registry_to_w32_charset (charset)
1367 Lisp_Object charset;
1368{
1369 if (EQ (charset, Qiso10646_1) || EQ (charset, Qunicode_bmp)
1370 || EQ (charset, Qunicode_sip))
1371 return DEFAULT_CHARSET; /* UNICODE_CHARSET not defined in MingW32 */
1372 else if (EQ (charset, Qiso8859_1))
1373 return ANSI_CHARSET;
1374 else if (SYMBOLP (charset))
1375 return x_to_w32_charset (SDATA (SYMBOL_NAME (charset)));
1376 else
1377 return DEFAULT_CHARSET;
1378}
1379
1380static Lisp_Object
1381w32_registry (w32_charset, font_type)
1382 LONG w32_charset;
1383 DWORD font_type;
1384{
1385 /* If charset is defaulted, use ANSI (unicode for truetype fonts). */
1386 if (w32_charset == DEFAULT_CHARSET)
1387 w32_charset = ANSI_CHARSET;
1388
1389 if (font_type == TRUETYPE_FONTTYPE && w32_charset == ANSI_CHARSET)
1390 return Qiso10646_1;
1391 else
1392 {
1393 char * charset = w32_to_x_charset (w32_charset, NULL);
1394 return font_intern_prop (charset, strlen(charset));
1395 }
1396}
1397
1398static int
1399w32_decode_weight (fnweight)
1400 int fnweight;
1401{
1402 if (fnweight >= FW_HEAVY) return 210;
1403 if (fnweight >= FW_EXTRABOLD) return 205;
1404 if (fnweight >= FW_BOLD) return 200;
1405 if (fnweight >= FW_SEMIBOLD) return 180;
1406 if (fnweight >= FW_NORMAL) return 100;
1407 if (fnweight >= FW_LIGHT) return 50;
1408 if (fnweight >= FW_EXTRALIGHT) return 40;
1409 if (fnweight > FW_THIN) return 20;
1410 return 0;
1411}
1412
1413static int
1414w32_encode_weight (n)
1415 int n;
1416{
1417 if (n >= 210) return FW_HEAVY;
1418 if (n >= 205) return FW_EXTRABOLD;
1419 if (n >= 200) return FW_BOLD;
1420 if (n >= 180) return FW_SEMIBOLD;
1421 if (n >= 100) return FW_NORMAL;
1422 if (n >= 50) return FW_LIGHT;
1423 if (n >= 40) return FW_EXTRALIGHT;
1424 if (n >= 20) return FW_THIN;
1425 return 0;
1426}
1427
1428/* Fill in all the available details of LOGFONT from FONT_SPEC. */
1429static void
1430fill_in_logfont (f, logfont, font_spec)
1431 FRAME_PTR f;
1432 LOGFONT *logfont;
1433 Lisp_Object font_spec;
1434{
1435 Lisp_Object tmp, extra;
1436 int dpi = FRAME_W32_DISPLAY_INFO (f)->resy;
1437
1438 tmp = AREF (font_spec, FONT_DPI_INDEX);
1439 if (INTEGERP (tmp))
1440 {
1441 dpi = XINT (tmp);
1442 }
1443 else if (FLOATP (tmp))
1444 {
1445 dpi = (int) (XFLOAT_DATA (tmp) + 0.5);
1446 }
1447
1448 /* Height */
1449 tmp = AREF (font_spec, FONT_SIZE_INDEX);
1450 if (INTEGERP (tmp))
1451 logfont->lfHeight = -1 * XINT (tmp);
1452 else if (FLOATP (tmp))
1453 logfont->lfHeight = (int) (-1.0 * dpi * XFLOAT_DATA (tmp) / 72.27 + 0.5);
1454
1455 /* Escapement */
1456
1457 /* Orientation */
1458
1459 /* Weight */
1460 tmp = AREF (font_spec, FONT_WEIGHT_INDEX);
1461 if (INTEGERP (tmp))
1462 logfont->lfWeight = w32_encode_weight (FONT_WEIGHT_NUMERIC (font_spec));
1463
1464 /* Italic */
1465 tmp = AREF (font_spec, FONT_SLANT_INDEX);
1466 if (INTEGERP (tmp))
1467 {
1468 int slant = FONT_SLANT_NUMERIC (font_spec);
1469 logfont->lfItalic = slant > 150 ? 1 : 0;
1470 }
1471
1472 /* Underline */
1473
1474 /* Strikeout */
1475
1476 /* Charset */
1477 tmp = AREF (font_spec, FONT_REGISTRY_INDEX);
1478 if (! NILP (tmp))
1479 logfont->lfCharSet = registry_to_w32_charset (tmp);
1480 else
1481 logfont->lfCharSet = DEFAULT_CHARSET;
1482
1483 /* Out Precision */
1484
1485 /* Clip Precision */
1486
1487 /* Quality */
1488 logfont->lfQuality = DEFAULT_QUALITY;
1489
1490 /* Generic Family and Face Name */
1491 logfont->lfPitchAndFamily = FF_DONTCARE | DEFAULT_PITCH;
1492
1493 tmp = AREF (font_spec, FONT_FAMILY_INDEX);
1494 if (! NILP (tmp))
1495 {
1496 logfont->lfPitchAndFamily = w32_generic_family (tmp) | DEFAULT_PITCH;
1497 if ((logfont->lfPitchAndFamily & 0xF0) != FF_DONTCARE)
1498 ; /* Font name was generic, don't fill in font name. */
1499 /* Font families are interned, but allow for strings also in case of
1500 user input. */
1501 else if (SYMBOLP (tmp))
1502 strncpy (logfont->lfFaceName, SDATA (SYMBOL_NAME (tmp)), LF_FACESIZE);
1503 }
1504
1505 tmp = AREF (font_spec, FONT_ADSTYLE_INDEX);
1506 if (!NILP (tmp))
1507 {
1508 /* Override generic family. */
1509 BYTE family = w32_generic_family (tmp);
1510 if (family != FF_DONTCARE)
1511 logfont->lfPitchAndFamily = family | DEFAULT_PITCH;
1512 }
1513
1514
1515 /* Set pitch based on the spacing property. */
1516 tmp = AREF (font_spec, FONT_SPACING_INDEX);
1517 if (INTEGERP (tmp))
1518 {
1519 int spacing = XINT (tmp);
1520 if (spacing < FONT_SPACING_MONO)
1521 logfont->lfPitchAndFamily
1522 = logfont->lfPitchAndFamily & 0xF0 | VARIABLE_PITCH;
1523 else
1524 logfont->lfPitchAndFamily
1525 = logfont->lfPitchAndFamily & 0xF0 | FIXED_PITCH;
1526 }
1527
1528 /* Process EXTRA info. */
1529 for (extra = AREF (font_spec, FONT_EXTRA_INDEX);
1530 CONSP (extra); extra = XCDR (extra))
1531 {
1532 tmp = XCAR (extra);
1533 if (CONSP (tmp))
1534 {
1535 Lisp_Object key, val;
1536 key = XCAR (tmp), val = XCDR (tmp);
1537 /* Only use QCscript if charset is not provided, or is unicode
1538 and a single script is specified. This is rather crude,
1539 and is only used to narrow down the fonts returned where
1540 there is a definite match. Some scripts, such as latin, han,
1541 cjk-misc match multiple lfCharSet values, so we can't pre-filter
1542 them. */
1543 if (EQ (key, QCscript)
1544 && logfont->lfCharSet == DEFAULT_CHARSET
1545 && SYMBOLP (val))
1546 {
1547 if (EQ (val, Qgreek))
1548 logfont->lfCharSet = GREEK_CHARSET;
1549 else if (EQ (val, Qhangul))
1550 logfont->lfCharSet = HANGUL_CHARSET;
1551 else if (EQ (val, Qkana) || EQ (val, Qkanbun))
1552 logfont->lfCharSet = SHIFTJIS_CHARSET;
1553 else if (EQ (val, Qbopomofo))
1554 logfont->lfCharSet = CHINESEBIG5_CHARSET;
1555 /* GB 18030 supports tibetan, yi, mongolian,
1556 fonts that support it should show up if we ask for
1557 GB2312 fonts. */
1558 else if (EQ (val, Qtibetan) || EQ (val, Qyi)
1559 || EQ (val, Qmongolian))
1560 logfont->lfCharSet = GB2312_CHARSET;
1561 else if (EQ (val, Qhebrew))
1562 logfont->lfCharSet = HEBREW_CHARSET;
1563 else if (EQ (val, Qarabic))
1564 logfont->lfCharSet = ARABIC_CHARSET;
1565 else if (EQ (val, Qthai))
1566 logfont->lfCharSet = THAI_CHARSET;
1567 else if (EQ (val, Qsymbol))
1568 logfont->lfCharSet = SYMBOL_CHARSET;
1569 }
1570 else if (EQ (key, QCantialias) && SYMBOLP (val))
1571 {
1572 logfont->lfQuality = w32_antialias_type (val);
1573 }
1574 }
1575 }
1576}
1577
1578static void
1579list_all_matching_fonts (match_data)
1580 struct font_callback_data *match_data;
1581{
1582 HDC dc;
1583 Lisp_Object families = w32font_list_family (match_data->frame);
1584 struct frame *f = XFRAME (match_data->frame);
1585
1586 dc = get_frame_dc (f);
1587
1588 while (!NILP (families))
1589 {
1590 /* TODO: Use the Unicode versions of the W32 APIs, so we can
1591 handle non-ASCII font names. */
1592 char *name;
1593 Lisp_Object family = CAR (families);
1594 families = CDR (families);
1595 if (NILP (family))
1596 continue;
1597 else if (SYMBOLP (family))
1598 name = SDATA (SYMBOL_NAME (family));
1599 else
1600 continue;
1601
1602 strncpy (match_data->pattern.lfFaceName, name, LF_FACESIZE);
1603 match_data->pattern.lfFaceName[LF_FACESIZE - 1] = '\0';
1604
1605 EnumFontFamiliesEx (dc, &match_data->pattern,
1606 (FONTENUMPROC) add_font_entity_to_list,
1607 (LPARAM) match_data, 0);
1608 }
1609
1610 release_frame_dc (f, dc);
1611}
1612
1613static Lisp_Object
1614lispy_antialias_type (type)
1615 BYTE type;
1616{
1617 Lisp_Object lispy;
1618
1619 switch (type)
1620 {
1621 case NONANTIALIASED_QUALITY:
1622 lispy = Qnone;
1623 break;
1624 case ANTIALIASED_QUALITY:
1625 lispy = Qstandard;
1626 break;
1627 case CLEARTYPE_QUALITY:
1628 lispy = Qsubpixel;
1629 break;
1630 case CLEARTYPE_NATURAL_QUALITY:
1631 lispy = Qnatural;
1632 break;
1633 default:
1634 lispy = Qnil;
1635 break;
1636 }
1637 return lispy;
1638}
1639
1640/* Convert antialiasing symbols to lfQuality */
1641static BYTE
1642w32_antialias_type (type)
1643 Lisp_Object type;
1644{
1645 if (EQ (type, Qnone))
1646 return NONANTIALIASED_QUALITY;
1647 else if (EQ (type, Qstandard))
1648 return ANTIALIASED_QUALITY;
1649 else if (EQ (type, Qsubpixel))
1650 return CLEARTYPE_QUALITY;
1651 else if (EQ (type, Qnatural))
1652 return CLEARTYPE_NATURAL_QUALITY;
1653 else
1654 return DEFAULT_QUALITY;
1655}
1656
1657/* Return a list of all the scripts that the font supports. */
1658static Lisp_Object
1659font_supported_scripts (FONTSIGNATURE * sig)
1660{
1661 DWORD * subranges = sig->fsUsb;
1662 Lisp_Object supported = Qnil;
1663
1664 /* Match a single subrange. SYM is set if bit N is set in subranges. */
1665#define SUBRANGE(n,sym) \
1666 if (subranges[(n) / 32] & (1 << ((n) % 32))) \
1667 supported = Fcons ((sym), supported)
1668
1669 /* Match multiple subranges. SYM is set if any MASK bit is set in
1670 subranges[0 - 3]. */
1671#define MASK_ANY(mask0,mask1,mask2,mask3,sym) \
1672 if ((subranges[0] & (mask0)) || (subranges[1] & (mask1)) \
1673 || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
1674 supported = Fcons ((sym), supported)
1675
1676 SUBRANGE (0, Qlatin);
1677 /* The following count as latin too, ASCII should be present in these fonts,
1678 so don't need to mark them separately. */
1679 /* 1: Latin-1 supplement, 2: Latin Extended A, 3: Latin Extended B. */
1680 SUBRANGE (4, Qphonetic);
1681 /* 5: Spacing and tone modifiers, 6: Combining Diacriticals. */
1682 SUBRANGE (7, Qgreek);
1683 SUBRANGE (8, Qcoptic);
1684 SUBRANGE (9, Qcyrillic);
1685 SUBRANGE (10, Qarmenian);
1686 SUBRANGE (11, Qhebrew);
1687 SUBRANGE (13, Qarabic);
1688 SUBRANGE (14, Qnko);
1689 SUBRANGE (15, Qdevanagari);
1690 SUBRANGE (16, Qbengali);
1691 SUBRANGE (17, Qgurmukhi);
1692 SUBRANGE (18, Qgujarati);
1693 SUBRANGE (19, Qoriya);
1694 SUBRANGE (20, Qtamil);
1695 SUBRANGE (21, Qtelugu);
1696 SUBRANGE (22, Qkannada);
1697 SUBRANGE (23, Qmalayalam);
1698 SUBRANGE (24, Qthai);
1699 SUBRANGE (25, Qlao);
1700 SUBRANGE (26, Qgeorgian);
1701 SUBRANGE (27, Qbalinese);
1702 /* 28: Hangul Jamo. */
1703 /* 29: Latin Extended, 30: Greek Extended, 31: Punctuation. */
1704 /* 32-47: Symbols (defined below). */
1705 SUBRANGE (48, Qcjk_misc);
1706 /* Match either 49: katakana or 50: hiragana for kana. */
1707 MASK_ANY (0, 0x00060000, 0, 0, Qkana);
1708 SUBRANGE (51, Qbopomofo);
1709 /* 52: Compatibility Jamo */
1710 SUBRANGE (53, Qphags_pa);
1711 /* 54: Enclosed CJK letters and months, 55: CJK Compatibility. */
1712 SUBRANGE (56, Qhangul);
1713 /* 57: Surrogates. */
1714 SUBRANGE (58, Qphoenician);
1715 SUBRANGE (59, Qhan); /* There are others, but this is the main one. */
1716 SUBRANGE (59, Qideographic_description); /* Windows lumps this in. */
1717 SUBRANGE (59, Qkanbun); /* And this. */
1718 /* 60: Private use, 61: CJK strokes and compatibility. */
1719 /* 62: Alphabetic Presentation, 63: Arabic Presentation A. */
1720 /* 64: Combining half marks, 65: Vertical and CJK compatibility. */
1721 /* 66: Small forms, 67: Arabic Presentation B, 68: Half and Full width. */
1722 /* 69: Specials. */
1723 SUBRANGE (70, Qtibetan);
1724 SUBRANGE (71, Qsyriac);
1725 SUBRANGE (72, Qthaana);
1726 SUBRANGE (73, Qsinhala);
1727 SUBRANGE (74, Qmyanmar);
1728 SUBRANGE (75, Qethiopic);
1729 SUBRANGE (76, Qcherokee);
1730 SUBRANGE (77, Qcanadian_aboriginal);
1731 SUBRANGE (78, Qogham);
1732 SUBRANGE (79, Qrunic);
1733 SUBRANGE (80, Qkhmer);
1734 SUBRANGE (81, Qmongolian);
1735 SUBRANGE (82, Qbraille);
1736 SUBRANGE (83, Qyi);
1737 SUBRANGE (84, Qbuhid);
1738 SUBRANGE (84, Qhanunoo);
1739 SUBRANGE (84, Qtagalog);
1740 SUBRANGE (84, Qtagbanwa);
1741 SUBRANGE (85, Qold_italic);
1742 SUBRANGE (86, Qgothic);
1743 SUBRANGE (87, Qdeseret);
1744 SUBRANGE (88, Qbyzantine_musical_symbol);
1745 SUBRANGE (88, Qmusical_symbol); /* Windows doesn't distinguish these. */
1746 SUBRANGE (89, Qmathematical);
1747 /* 90: Private use, 91: Variation selectors, 92: Tags. */
1748 SUBRANGE (93, Qlimbu);
1749 SUBRANGE (94, Qtai_le);
1750 /* 95: New Tai Le */
1751 SUBRANGE (90, Qbuginese);
1752 SUBRANGE (97, Qglagolitic);
1753 SUBRANGE (98, Qtifinagh);
1754 /* 99: Yijing Hexagrams. */
1755 SUBRANGE (100, Qsyloti_nagri);
1756 SUBRANGE (101, Qlinear_b);
1757 /* 102: Ancient Greek Numbers. */
1758 SUBRANGE (103, Qugaritic);
1759 SUBRANGE (104, Qold_persian);
1760 SUBRANGE (105, Qshavian);
1761 SUBRANGE (106, Qosmanya);
1762 SUBRANGE (107, Qcypriot);
1763 SUBRANGE (108, Qkharoshthi);
1764 /* 109: Tai Xuan Jing. */
1765 SUBRANGE (110, Qcuneiform);
1766 /* 111: Counting Rods. */
1767
1768 /* There isn't really a main symbol range, so include symbol if any
1769 relevant range is set. */
1770 MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol);
1771
1772 /* Missing: Tai Viet (U+AA80) and Cham (U+AA00) . */
1773#undef SUBRANGE
1774#undef MASK_ANY
1775
1776 return supported;
1777}
1778
1779/* Generate a full name for a Windows font.
1780 The full name is in fcname format, with weight, slant and antialiasing
1781 specified if they are not "normal". */
1782static int
1783w32font_full_name (font, font_obj, pixel_size, name, nbytes)
1784 LOGFONT * font;
1785 Lisp_Object font_obj;
1786 int pixel_size;
1787 char *name;
1788 int nbytes;
1789{
1790 int len, height, outline;
1791 char *p;
1792 Lisp_Object antialiasing, weight = Qnil;
1793
1794 len = strlen (font->lfFaceName);
1795
1796 outline = EQ (AREF (font_obj, FONT_FOUNDRY_INDEX), Qoutline);
1797
1798 /* Represent size of scalable fonts by point size. But use pixelsize for
1799 raster fonts to indicate that they are exactly that size. */
1800 if (outline)
1801 len += 11; /* -SIZE */
1802 else
1803 len = strlen (font->lfFaceName) + 21;
1804
1805 if (font->lfItalic)
1806 len += 7; /* :italic */
1807
1808 if (font->lfWeight && font->lfWeight != FW_NORMAL)
1809 {
1810 weight = FONT_WEIGHT_SYMBOLIC (font_obj);
1811 len += 8 + SBYTES (SYMBOL_NAME (weight)); /* :weight=NAME */
1812 }
1813
1814 antialiasing = lispy_antialias_type (font->lfQuality);
1815 if (! NILP (antialiasing))
1816 len += 11 + SBYTES (SYMBOL_NAME (antialiasing)); /* :antialias=NAME */
1817
1818 /* Check that the buffer is big enough */
1819 if (len > nbytes)
1820 return -1;
1821
1822 p = name;
1823 p += sprintf (p, "%s", font->lfFaceName);
1824
1825 height = font->lfHeight ? eabs (font->lfHeight) : pixel_size;
1826
1827 if (height > 0)
1828 {
1829 if (outline)
1830 {
1831 float pointsize = height * 72.0 / one_w32_display_info.resy;
1832 /* Round to nearest half point. floor is used, since round is not
1833 supported in MS library. */
1834 pointsize = floor (pointsize * 2 + 0.5) / 2;
1835 p += sprintf (p, "-%1.1f", pointsize);
1836 }
1837 else
1838 p += sprintf (p, ":pixelsize=%d", height);
1839 }
1840
1841 if (font->lfItalic)
1842 p += sprintf (p, ":italic");
1843
1844 if (SYMBOLP (weight) && ! NILP (weight))
1845 p += sprintf (p, ":weight=%s", SDATA (SYMBOL_NAME (weight)));
1846
1847 if (SYMBOLP (antialiasing) && ! NILP (antialiasing))
1848 p += sprintf (p, ":antialias=%s", SDATA (SYMBOL_NAME (antialiasing)));
1849
1850 return (p - name);
1851}
1852
1853
1854static void
1855compute_metrics (dc, w32_font, code, metrics)
1856 HDC dc;
1857 struct w32font_info *w32_font;
1858 unsigned int code;
1859 struct w32_metric_cache *metrics;
1860{
1861 GLYPHMETRICS gm;
1862 MAT2 transform;
1863 unsigned int options = GGO_METRICS;
1864
1865 if (w32_font->glyph_idx)
1866 options |= GGO_GLYPH_INDEX;
1867
1868 bzero (&transform, sizeof (transform));
1869 transform.eM11.value = 1;
1870 transform.eM22.value = 1;
1871
1872 if (GetGlyphOutlineW (dc, code, options, &gm, 0, NULL, &transform)
1873 != GDI_ERROR)
1874 {
1875 metrics->lbearing = gm.gmptGlyphOrigin.x;
1876 metrics->rbearing = gm.gmptGlyphOrigin.x + gm.gmBlackBoxX;
1877 metrics->width = gm.gmCellIncX;
1878 metrics->status = W32METRIC_SUCCESS;
1879 }
1880 else if (w32_font->glyph_idx)
1881 {
1882 /* Can't use glyph indexes after all.
1883 Avoid it in future, and clear any metrics that were based on
1884 glyph indexes. */
1885 w32_font->glyph_idx = 0;
1886 clear_cached_metrics (w32_font);
1887 }
1888 else
1889 metrics->status = W32METRIC_FAIL;
1890}
1891
1892static void
1893clear_cached_metrics (w32_font)
1894 struct w32font_info *w32_font;
1895{
1896 int i;
1897 for (i = 0; i < w32_font->n_cache_blocks; i++)
1898 {
1899 if (w32_font->cached_metrics[i])
1900 bzero (w32_font->cached_metrics[i],
1901 CACHE_BLOCKSIZE * sizeof (struct font_metrics));
1902 }
1903}
1904
1905struct font_driver w32font_driver =
1906 {
1907 0, /* Qgdi */
1908 0, /* case insensitive */
1909 w32font_get_cache,
1910 w32font_list,
1911 w32font_match,
1912 w32font_list_family,
1913 NULL, /* free_entity */
1914 w32font_open,
1915 w32font_close,
1916 NULL, /* prepare_face */
1917 NULL, /* done_face */
1918 w32font_has_char,
1919 w32font_encode_char,
1920 w32font_text_extents,
1921 w32font_draw,
1922 NULL, /* get_bitmap */
1923 NULL, /* free_bitmap */
1924 NULL, /* get_outline */
1925 NULL, /* free_outline */
1926 NULL, /* anchor_point */
1927 NULL, /* otf_capability */
1928 NULL, /* otf_drive */
1929 NULL, /* start_for_frame */
1930 NULL, /* end_for_frame */
1931 NULL /* shape */
1932 };
1933
1934
1935/* Initialize state that does not change between invocations. This is only
1936 called when Emacs is dumped. */
1937void
1938syms_of_w32font ()
1939{
1940 DEFSYM (Qgdi, "gdi");
1941 DEFSYM (Quniscribe, "uniscribe");
1942 DEFSYM (QCformat, ":format");
1943
1944 /* Generic font families. */
1945 DEFSYM (Qmonospace, "monospace");
1946 DEFSYM (Qserif, "serif");
1947 DEFSYM (Qsansserif, "sansserif");
1948 DEFSYM (Qscript, "script");
1949 DEFSYM (Qdecorative, "decorative");
1950 /* Aliases. */
1951 DEFSYM (Qsans_serif, "sans_serif");
1952 DEFSYM (Qsans, "sans");
1953 DEFSYM (Qmono, "mono");
1954
1955 /* Fake foundries. */
1956 DEFSYM (Qraster, "raster");
1957 DEFSYM (Qoutline, "outline");
1958 DEFSYM (Qunknown, "unknown");
1959
1960 /* Antialiasing. */
1961 DEFSYM (Qstandard, "standard");
1962 DEFSYM (Qsubpixel, "subpixel");
1963 DEFSYM (Qnatural, "natural");
1964
1965 /* Languages */
1966 DEFSYM (Qja, "ja");
1967 DEFSYM (Qko, "ko");
1968 DEFSYM (Qzh, "zh");
1969
1970 /* Scripts */
1971 DEFSYM (Qlatin, "latin");
1972 DEFSYM (Qgreek, "greek");
1973 DEFSYM (Qcoptic, "coptic");
1974 DEFSYM (Qcyrillic, "cyrillic");
1975 DEFSYM (Qarmenian, "armenian");
1976 DEFSYM (Qhebrew, "hebrew");
1977 DEFSYM (Qarabic, "arabic");
1978 DEFSYM (Qsyriac, "syriac");
1979 DEFSYM (Qnko, "nko");
1980 DEFSYM (Qthaana, "thaana");
1981 DEFSYM (Qdevanagari, "devanagari");
1982 DEFSYM (Qbengali, "bengali");
1983 DEFSYM (Qgurmukhi, "gurmukhi");
1984 DEFSYM (Qgujarati, "gujarati");
1985 DEFSYM (Qoriya, "oriya");
1986 DEFSYM (Qtamil, "tamil");
1987 DEFSYM (Qtelugu, "telugu");
1988 DEFSYM (Qkannada, "kannada");
1989 DEFSYM (Qmalayalam, "malayalam");
1990 DEFSYM (Qsinhala, "sinhala");
1991 DEFSYM (Qthai, "thai");
1992 DEFSYM (Qlao, "lao");
1993 DEFSYM (Qtibetan, "tibetan");
1994 DEFSYM (Qmyanmar, "myanmar");
1995 DEFSYM (Qgeorgian, "georgian");
1996 DEFSYM (Qhangul, "hangul");
1997 DEFSYM (Qethiopic, "ethiopic");
1998 DEFSYM (Qcherokee, "cherokee");
1999 DEFSYM (Qcanadian_aboriginal, "canadian-aboriginal");
2000 DEFSYM (Qogham, "ogham");
2001 DEFSYM (Qrunic, "runic");
2002 DEFSYM (Qkhmer, "khmer");
2003 DEFSYM (Qmongolian, "mongolian");
2004 DEFSYM (Qsymbol, "symbol");
2005 DEFSYM (Qbraille, "braille");
2006 DEFSYM (Qhan, "han");
2007 DEFSYM (Qideographic_description, "ideographic-description");
2008 DEFSYM (Qcjk_misc, "cjk-misc");
2009 DEFSYM (Qkana, "kana");
2010 DEFSYM (Qbopomofo, "bopomofo");
2011 DEFSYM (Qkanbun, "kanbun");
2012 DEFSYM (Qyi, "yi");
2013 DEFSYM (Qbyzantine_musical_symbol, "byzantine-musical-symbol");
2014 DEFSYM (Qmusical_symbol, "musical-symbol");
2015 DEFSYM (Qmathematical, "mathematical");
2016 DEFSYM (Qphonetic, "phonetic");
2017 DEFSYM (Qbalinese, "balinese");
2018 DEFSYM (Qbuginese, "buginese");
2019 DEFSYM (Qbuhid, "buhid");
2020 DEFSYM (Qcuneiform, "cuneiform");
2021 DEFSYM (Qcypriot, "cypriot");
2022 DEFSYM (Qdeseret, "deseret");
2023 DEFSYM (Qglagolitic, "glagolitic");
2024 DEFSYM (Qgothic, "gothic");
2025 DEFSYM (Qhanunoo, "hanunoo");
2026 DEFSYM (Qkharoshthi, "kharoshthi");
2027 DEFSYM (Qlimbu, "limbu");
2028 DEFSYM (Qlinear_b, "linear_b");
2029 DEFSYM (Qold_italic, "old_italic");
2030 DEFSYM (Qold_persian, "old_persian");
2031 DEFSYM (Qosmanya, "osmanya");
2032 DEFSYM (Qphags_pa, "phags-pa");
2033 DEFSYM (Qphoenician, "phoenician");
2034 DEFSYM (Qshavian, "shavian");
2035 DEFSYM (Qsyloti_nagri, "syloti_nagri");
2036 DEFSYM (Qtagalog, "tagalog");
2037 DEFSYM (Qtagbanwa, "tagbanwa");
2038 DEFSYM (Qtai_le, "tai_le");
2039 DEFSYM (Qtifinagh, "tifinagh");
2040 DEFSYM (Qugaritic, "ugaritic");
2041
2042 w32font_driver.type = Qgdi;
2043 register_font_driver (&w32font_driver, NULL);
2044}
2045
2046/* arch-tag: 65b8a3cd-46aa-4c0d-a1f3-99e75b9c07ee
2047 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.