HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
(QChinting , QCautohint, QChintstyle, QCrgba)
[bpt/emacs.git] / src / ftfont.c
CommitLineData
c2f5bfd6 1/* ftfont.c -- FreeType font driver.
77ad4cfe
GM		 2 Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
3 Copyright (C) 2006, 2007, 2008
c2f5bfd6
KH		 4 National Institute of Advanced Industrial Science and Technology (AIST)
5 Registration Number H13PRO009
6
7This file is part of GNU Emacs.
8
9ec0b715 9GNU Emacs is free software: you can redistribute it and/or modify
c2f5bfd6 10it under the terms of the GNU General Public License as published by
9ec0b715
GM		 11the Free Software Foundation, either version 3 of the License, or
12(at your option) any later version.
c2f5bfd6
KH		 13
14GNU Emacs is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
9ec0b715 20along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
c2f5bfd6
KH		 21
22#include <config.h>
23#include <stdio.h>
24
c2f5bfd6
KH		 25#include <fontconfig/fontconfig.h>
26#include <fontconfig/fcfreetype.h>
27
28#include "lisp.h"
29#include "dispextern.h"
30#include "frame.h"
31#include "blockinput.h"
32#include "character.h"
33#include "charset.h"
34#include "coding.h"
35#include "fontset.h"
36#include "font.h"
de023c40 37#include "ftfont.h"
c2f5bfd6 38
c2801c99 39/* Symbolic type of this font-driver. */
c2f5bfd6
KH		 40Lisp_Object Qfreetype;
41
706b6995
KH		 42/* Fontconfig's generic families and their aliases. */
43static Lisp_Object Qmonospace, Qsans_serif, Qserif, Qmono, Qsans, Qsans__serif;
44
2a46904e 45/* Flag to tell if FcInit is already called or not. */
c2f5bfd6 46static int fc_initialized;
c2801c99
KH		 47
48/* Handle to a FreeType library instance. */
c2f5bfd6
KH		 49static FT_Library ft_library;
50
c2801c99 51/* Cache for FreeType fonts. */
c2f5bfd6
KH		 52static Lisp_Object freetype_font_cache;
53
21988a08
KH		 54/* Cache for FT_Face */
55static Lisp_Object ft_face_cache;
c2f5bfd6
KH		 56
57/* The actual structure for FreeType font that can be casted to struct
58 font. */
59
60struct ftfont_info
61{
62 struct font font;
63 FT_Size ft_size;
21988a08 64 int fc_charset_idx;
de023c40
KH		 65#ifdef HAVE_LIBOTF
66 int maybe_otf; /* Flag to tell if this may be OTF or not. */
67 OTF *otf;
68#endif /* HAVE_LIBOTF */
c2f5bfd6
KH		 69};
70
21988a08
KH		 71static Lisp_Object ftfont_pattern_entity P_ ((FcPattern *, Lisp_Object, int));
72
318548be 73static Lisp_Object ftfont_resolve_generic_family P_ ((Lisp_Object));
0b966021 74Lisp_Object ftfont_font_format P_ ((FcPattern *));
706b6995
KH		 75
76#define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))
77
21988a08 78static struct
c2f5bfd6 79{
21988a08
KH		 80 /* charset name */
81 char *name;
82 /* characters to distinguish the charset from the others */
83 int uniquifier[6];
84 /* set in syms_of_ftfont */
85 int charset_id;
86 /* set on demand */
87 FcCharSet *fc_charset;
88} fc_charset_table[] =
89 { { "iso-8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 }, -1 },
90 { "iso-8859-2", { 0x00A0, 0x010E }},
91 { "iso-8859-3", { 0x00A0, 0x0108 }},
92 { "iso-8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }},
93 { "iso-8859-5", { 0x00A0, 0x0401 }},
94 { "iso-8859-6", { 0x00A0, 0x060C }},
95 { "iso-8859-7", { 0x00A0, 0x0384 }},
96 { "iso-8859-8", { 0x00A0, 0x05D0 }},
97 { "iso-8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }},
98 { "iso-8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }},
99 { "iso-8859-11", { 0x00A0, 0x0E01 }},
100 { "iso-8859-13", { 0x00A0, 0x201C }},
101 { "iso-8859-14", { 0x00A0, 0x0174 }},
102 { "iso-8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
103 { "iso-8859-16", { 0x00A0, 0x0218}},
104 { "chinese-gb2312", { 0x4E13 }},
105 { "big5", { 0xF6B1 }},
106 { "japanese-jisx0208", { 0x4E55 }},
107 { "korean-ksc5601", { 0xAC00 }},
108 { "chinese-cns11643-1", { 0xFE32 }},
109 { "chinese-cns11643-2", { 0x4E33, 0x7934 }},
110 { "chinese-cns11643-3", { 0x201A9 }},
111 { "chinese-cns11643-4", { 0x20057 }},
112 { "chinese-cns11643-5", { 0x20000 }},
113 { "chinese-cns11643-6", { 0x20003 }},
114 { "chinese-cns11643-7", { 0x20055 }},
115 { "chinese-gbk", { 0x4E06 }},
116 { "japanese-jisx0212", { 0x4E44 }},
117 { "japanese-jisx0213-1", { 0xFA10 }},
118 { "japanese-jisx0213-2", { 0xFA49 }},
119 { "japanese-jisx0213.2004-1", { 0x20B9F }},
120 { "viscii", { 0x1EA0, 0x1EAE, 0x1ED2 }},
121 { "tis620", { 0x0E01 }},
122 { "windows-1251", { 0x0401, 0x0490 }},
123 { "koi8-r", { 0x0401, 0x2219 }},
124 { "mule-lao", { 0x0E81 }},
125 { NULL }
126 };
c2f5bfd6 127
42984a74
KH		 128extern Lisp_Object Qc, Qm, Qp, Qd;
129
706b6995 130static Lisp_Object
21988a08 131ftfont_pattern_entity (p, registry, fc_charset_idx)
c2801c99 132 FcPattern *p;
42984a74 133 Lisp_Object registry;
21988a08 134 int fc_charset_idx;
c2801c99
KH		 135{
136 Lisp_Object entity;
21988a08 137 char *file, *str;
c2801c99
KH		 138 int numeric;
139 double dbl;
42984a74 140 FcBool b;
c2801c99 141
21988a08 142 if (FcPatternGetString (p, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
c2801c99 143 return Qnil;
c2801c99 144
42984a74 145 entity = font_make_entity ();
c2801c99
KH		 146
147 ASET (entity, FONT_TYPE_INDEX, Qfreetype);
148 ASET (entity, FONT_REGISTRY_INDEX, registry);
c2801c99 149
21988a08 150 if (FcPatternGetString (p, FC_FOUNDRY, 0, (FcChar8 **) &str) == FcResultMatch)
a1a94102 151 ASET (entity, FONT_FOUNDRY_INDEX, font_intern_prop (str, strlen (str), 1));
21988a08 152 if (FcPatternGetString (p, FC_FAMILY, 0, (FcChar8 **) &str) == FcResultMatch)
a1a94102 153 ASET (entity, FONT_FAMILY_INDEX, font_intern_prop (str, strlen (str), 1));
c2801c99 154 if (FcPatternGetInteger (p, FC_WEIGHT, 0, &numeric) == FcResultMatch)
f63d54dc 155 {
42984a74
KH		 156 if (numeric >= FC_WEIGHT_REGULAR && numeric < FC_WEIGHT_MEDIUM)
157 numeric = FC_WEIGHT_MEDIUM;
158 FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, make_number (numeric));
f63d54dc 159 }
c2801c99 160 if (FcPatternGetInteger (p, FC_SLANT, 0, &numeric) == FcResultMatch)
42984a74
KH		 161 {
162 numeric += 100;
163 FONT_SET_STYLE (entity, FONT_SLANT_INDEX, make_number (numeric));
164 }
c2801c99 165 if (FcPatternGetInteger (p, FC_WIDTH, 0, &numeric) == FcResultMatch)
42984a74
KH		 166 {
167 FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_number (numeric));
168 }
c2801c99
KH		 169 if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
170 ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
171 else
172 ASET (entity, FONT_SIZE_INDEX, make_number (0));
42984a74
KH		 173 if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) == FcResultMatch)
174 ASET (entity, FONT_SPACING_INDEX, make_number (numeric));
175 if (FcPatternGetDouble (p, FC_DPI, 0, &dbl) == FcResultMatch)
176 {
177 int dpi = dbl;
178 ASET (entity, FONT_DPI_INDEX, make_number (dpi));
179 }
180 if (FcPatternGetBool (p, FC_SCALABLE, 0, &b) == FcResultMatch
181 && b == FcTrue)
182 ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
c2801c99 183
21988a08
KH		 184 font_put_extra (entity, QCfont_entity,
185 Fcons (make_unibyte_string ((char *) file,
186 strlen ((char *) file)),
187 make_number (fc_charset_idx)));
c2801c99
KH		 188 return entity;
189}
190
42984a74 191
706b6995
KH		 192static Lisp_Object ftfont_generic_family_list;
193
194static Lisp_Object
318548be 195ftfont_resolve_generic_family (family)
42984a74 196 Lisp_Object family;
706b6995 197{
318548be
KH		 198 Lisp_Object slot;
199 FcPattern *pattern = NULL, *match;
200 FcResult result;
706b6995 201
318548be 202 family = Fintern (Fdowncase (SYMBOL_NAME (family)), Qnil);
706b6995
KH		 203 if (EQ (family, Qmono))
204 family = Qmonospace;
205 else if (EQ (family, Qsans) || EQ (family, Qsans__serif))
206 family = Qsans_serif;
207 slot = assq_no_quit (family, ftfont_generic_family_list);
208 if (! CONSP (slot))
42984a74 209 return Qnil;
318548be
KH		 210 if (! EQ (XCDR (slot), Qt))
211 return XCDR (slot);
42984a74
KH		 212 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString,
213 SYMBOL_FcChar8 (family), (char *) 0);
214 if (! pattern)
215 goto err;
42984a74 216 FcConfigSubstitute (NULL, pattern, FcMatchPattern);
318548be
KH		 217 FcDefaultSubstitute (pattern);
218 match = FcFontMatch (NULL, pattern, &result);
219 if (match)
706b6995 220 {
318548be
KH		 221 FcChar8 *fam;
222
223 if (FcPatternGetString (match, FC_FAMILY, 0, &fam) == FcResultMatch)
224 family = intern ((char *) fam);
706b6995 225 }
318548be
KH		 226 else
227 family = Qnil;
228 XSETCDR (slot, family);
42984a74 229 err:
318548be 230 if (match) FcPatternDestroy (match);
42984a74 231 if (pattern) FcPatternDestroy (pattern);
318548be 232 return family;
706b6995
KH		 233}
234
21988a08
KH		 235Lisp_Object
236ftfont_lookup_cache (filename)
237 Lisp_Object filename;
238{
239 Lisp_Object cache, val;
240
241 cache = assoc_no_quit (filename, ft_face_cache);
242 if (NILP (cache))
243 {
244 val = make_save_value (NULL, 0);
245 cache = Fcons (filename, val);
246 ft_face_cache = Fcons (cache, ft_face_cache);
247 }
248 else
249 val = XCDR (cache);
250 if (! XSAVE_VALUE (val)->pointer)
251 {
252 FT_Face ft_face;
253
254 if (! ft_library
255 && FT_Init_FreeType (&ft_library) != 0)
256 return Qnil;
257 if (FT_New_Face (ft_library, (char *) SDATA (filename), 0, &ft_face) != 0)
258 return Qnil;
259 XSAVE_VALUE (val)->pointer = ft_face;
260 }
261 return cache;
262}
263
77175228 264static Lisp_Object ftfont_get_cache P_ ((FRAME_PTR));
c2f5bfd6 265static Lisp_Object ftfont_list P_ ((Lisp_Object, Lisp_Object));
8daf5667 266static Lisp_Object ftfont_match P_ ((Lisp_Object, Lisp_Object));
c2f5bfd6 267static Lisp_Object ftfont_list_family P_ ((Lisp_Object));
42984a74 268static Lisp_Object ftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
c2f5bfd6
KH		 269static void ftfont_close P_ ((FRAME_PTR, struct font *));
270static int ftfont_has_char P_ ((Lisp_Object, int));
271static unsigned ftfont_encode_char P_ ((struct font *, int));
272static int ftfont_text_extents P_ ((struct font *, unsigned *, int,
273 struct font_metrics *));
274static int ftfont_get_bitmap P_ ((struct font *, unsigned,
275 struct font_bitmap *, int));
276static int ftfont_anchor_point P_ ((struct font *, unsigned, int,
277 int *, int *));
de023c40 278static Lisp_Object ftfont_shape P_ ((Lisp_Object));
c2f5bfd6
KH		 279
280struct font_driver ftfont_driver =
281 {
09a56ce4 282 0, /* Qfreetype */
42984a74 283 0, /* case insensitive */
c2f5bfd6 284 ftfont_get_cache,
c2f5bfd6 285 ftfont_list,
8daf5667 286 ftfont_match,
c2f5bfd6 287 ftfont_list_family,
42984a74 288 NULL,
c2f5bfd6
KH		 289 ftfont_open,
290 ftfont_close,
291 /* We can't draw a text without device dependent functions. */
292 NULL,
293 NULL,
294 ftfont_has_char,
295 ftfont_encode_char,
296 ftfont_text_extents,
297 /* We can't draw a text without device dependent functions. */
298 NULL,
299 ftfont_get_bitmap,
300 NULL,
301 NULL,
302 NULL,
303 ftfont_anchor_point,
c2f5bfd6
KH		 304 NULL,
305 NULL,
de023c40
KH		 306 NULL,
307 NULL,
637ac44c 308#if defined (HAVE_M17N_FLT) && defined (HAVE_LIBOTF)
de023c40 309 ftfont_shape
637ac44c 310#else /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
c2f5bfd6 311 NULL
637ac44c 312#endif /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
c2f5bfd6
KH		 313 };
314
c2f5bfd6
KH		 315extern Lisp_Object QCname;
316
317static Lisp_Object
77175228
KH		 318ftfont_get_cache (f)
319 FRAME_PTR f;
c2f5bfd6 320{
c2f5bfd6
KH		 321 return freetype_font_cache;
322}
323
21988a08
KH		 324static int
325ftfont_get_charset (registry)
326 Lisp_Object registry;
327{
328 struct charset *encoding;
329 int i, j;
330
331 if (font_registry_charsets (registry, &encoding, NULL) < 0)
332 return -1;
333 if (fc_charset_table[0].charset_id < 0)
334 /* Setup charset_id field of all elements. */
335 for (i = 0; fc_charset_table[i].name; i++)
336 {
337 Lisp_Object sym = intern (fc_charset_table[i].name);
338
339 if (CHARSETP (sym))
340 fc_charset_table[i].charset_id = XINT (CHARSET_SYMBOL_ID (sym));
341 else
342 fc_charset_table[i].charset_id = -1;
343 }
344
345 for (i = 0; fc_charset_table[i].name; i++)
346 if (encoding->id == fc_charset_table[i].charset_id)
347 break;
348 if (! fc_charset_table[i].name)
349 return -1;
350 if (! fc_charset_table[i].fc_charset)
351 {
352 FcCharSet *charset = FcCharSetCreate ();
353 int *uniquifier = fc_charset_table[i].uniquifier;
354
355 if (! charset)
356 return -1;
357 for (j = 0; uniquifier[j]; j++)
358 if (! FcCharSetAddChar (charset, uniquifier[j]))
359 {
360 FcCharSetDestroy (charset);
361 return -1;
362 }
2a46904e 363 fc_charset_table[i].fc_charset = charset;
21988a08
KH		 364 }
365 return i;
366}
367
cc63eaf9
KH		 368struct OpenTypeSpec
369{
16963817
KH		 370 Lisp_Object script;
371 unsigned int script_tag, langsys_tag;
cc63eaf9
KH		 372 int nfeatures[2];
373 unsigned int *features[2];
374};
375
7eb5d3d7 376#define OTF_SYM_TAG(SYM, TAG) \
cc63eaf9 377 do { \
7eb5d3d7
KH		 378 unsigned char *p = SDATA (SYMBOL_NAME (SYM)); \
379 TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; \
cc63eaf9
KH		 380 } while (0)
381
7eb5d3d7 382#define OTF_TAG_STR(TAG, P) \
cc63eaf9 383 do { \
7eb5d3d7
KH		 384 (P)[0] = (char) (TAG >> 24); \
385 (P)[1] = (char) ((TAG >> 16) & 0xFF); \
386 (P)[2] = (char) ((TAG >> 8) & 0xFF); \
387 (P)[3] = (char) (TAG & 0xFF); \
16963817 388 (P)[4] = '\0'; \
cc63eaf9
KH		 389 } while (0)
390
391static struct OpenTypeSpec *
392ftfont_get_open_type_spec (Lisp_Object otf_spec)
393{
394 struct OpenTypeSpec *spec = malloc (sizeof (struct OpenTypeSpec));
395 Lisp_Object val;
396 int i, j, negative;
397
398 if (! spec)
399 return NULL;
16963817 400 spec->script = XCAR (otf_spec);
43f4f91c 401 if (! NILP (spec->script))
16963817
KH		 402 {
403 OTF_SYM_TAG (spec->script, spec->script_tag);
404 val = assq_no_quit (spec->script, Votf_script_alist);
405 if (CONSP (val) && SYMBOLP (XCDR (val)))
406 spec->script = XCDR (val);
407 else
408 spec->script = Qnil;
409 }
cc63eaf9 410 else
16963817 411 spec->script_tag = 0x44464C54; /* "DFLT" */
cc63eaf9
KH		 412 otf_spec = XCDR (otf_spec);
413 val = XCAR (otf_spec);
414 if (! NILP (val))
16963817 415 OTF_SYM_TAG (val, spec->langsys_tag);
cc63eaf9 416 else
16963817 417 spec->langsys_tag = 0;
cc63eaf9
KH		 418 spec->nfeatures[0] = spec->nfeatures[1] = 0;
419 for (i = 0; i < 2; i++)
420 {
421 Lisp_Object len;
422
2a46904e 423 otf_spec = XCDR (otf_spec);
cc63eaf9
KH		 424 if (NILP (otf_spec))
425 break;
426 val = XCAR (otf_spec);
427 if (NILP (val))
428 continue;
429 len = Flength (val);
430 spec->features[i] = malloc (sizeof (int) * XINT (len));
431 if (! spec->features[i])
432 {
433 if (i > 0 && spec->features[0])
434 free (spec->features[0]);
435 free (spec);
436 return NULL;
437 }
438 for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
439 {
440 if (NILP (XCAR (val)))
441 negative = 1;
442 else
443 {
444 unsigned int tag;
445
446 OTF_SYM_TAG (XCAR (val), tag);
447 spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
448 }
449 }
450 spec->nfeatures[i] = j;
451 }
452 return spec;
453}
454
21988a08
KH		 455static FcPattern *ftfont_spec_pattern P_ ((Lisp_Object, int *, char *,
456 struct OpenTypeSpec **));
457
42984a74 458static FcPattern *
21988a08 459ftfont_spec_pattern (spec, fc_charset_idx, otlayout, otspec)
42984a74 460 Lisp_Object spec;
21988a08 461 int *fc_charset_idx;
42984a74
KH		 462 char *otlayout;
463 struct OpenTypeSpec **otspec;
c2f5bfd6 464{
21988a08 465 Lisp_Object tmp, extra;
c2f5bfd6
KH		 466 FcPattern *pattern = NULL;
467 FcCharSet *charset = NULL;
468 FcLangSet *langset = NULL;
42984a74
KH		 469 int n;
470 int dpi = -1;
bc9a2afe 471 int scalable = -1;
42984a74
KH		 472 Lisp_Object name = Qnil;
473 Lisp_Object script = Qnil;
21988a08 474 Lisp_Object registry;
c2f5bfd6 475
63565713 476 if (! NILP (AREF (spec, FONT_ADSTYLE_INDEX))
42984a74
KH		 477 && SBYTES (SYMBOL_NAME (AREF (spec, FONT_ADSTYLE_INDEX))) > 0)
478 /* Fontconfig doesn't support adstyle property. */
479 return NULL;
480 if ((n = FONT_SLANT_NUMERIC (spec)) >= 0
481 && n < 100)
63565713 482 /* Fontconfig doesn't support reverse-italic/obligue. */
42984a74
KH		 483 return NULL;
484
485 if (INTEGERP (AREF (spec, FONT_DPI_INDEX)))
486 dpi = XINT (AREF (spec, FONT_DPI_INDEX));
42984a74
KH		 487 if (INTEGERP (AREF (spec, FONT_AVGWIDTH_INDEX))
488 && XINT (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
489 scalable = 1;
63565713 490
21988a08
KH		 491 registry = AREF (spec, FONT_REGISTRY_INDEX);
492 if (NILP (registry)
770835fd 493 || EQ (registry, Qascii_0)
21988a08
KH		 494 || EQ (registry, Qiso10646_1)
495 || EQ (registry, Qunicode_bmp)
496 || EQ (registry, Qunicode_sip))
497 *fc_charset_idx = -1;
498 else
c2f5bfd6 499 {
21988a08
KH		 500 *fc_charset_idx = ftfont_get_charset (registry);
501 if (*fc_charset_idx < 0)
42984a74 502 return NULL;
21988a08 503 charset = fc_charset_table[*fc_charset_idx].fc_charset;
c2f5bfd6
KH		 504 }
505
cc63eaf9 506 otlayout[0] = '\0';
8daf5667
KH		 507 for (extra = AREF (spec, FONT_EXTRA_INDEX);
508 CONSP (extra); extra = XCDR (extra))
c2f5bfd6 509 {
8daf5667
KH		 510 Lisp_Object key, val;
511
42984a74
KH		 512 key = XCAR (XCAR (extra)), val = XCDR (XCAR (extra));
513 if (EQ (key, QCdpi))
514 dpi = XINT (val);
515 else if (EQ (key, QCfc_unknown_spec))
516 name = val;
517 else if (EQ (key, QClang))
c2f5bfd6
KH		 518 {
519 langset = FcLangSetCreate ();
520 if (! langset)
521 goto err;
8daf5667 522 if (SYMBOLP (val))
c2f5bfd6 523 {
8daf5667 524 if (! FcLangSetAdd (langset, SYMBOL_FcChar8 (val)))
c2f5bfd6
KH		 525 goto err;
526 }
527 else
8daf5667
KH		 528 for (; CONSP (val); val = XCDR (val))
529 if (SYMBOLP (XCAR (val))
530 && ! FcLangSetAdd (langset, SYMBOL_FcChar8 (XCAR (val))))
531 goto err;
c2f5bfd6 532 }
42984a74
KH		 533 else if (EQ (key, QCname))
534 name = val;
535 else if (EQ (key, QCotf))
536 {
537 *otspec = ftfont_get_open_type_spec (val);
538 if (! *otspec)
539 return NULL;
540 strcat (otlayout, "otlayout:");
541 OTF_TAG_STR ((*otspec)->script_tag, otlayout + 9);
542 script = (*otspec)->script;
543 }
8daf5667
KH		 544 else if (EQ (key, QCscript))
545 script = val;
8daf5667
KH		 546 else if (EQ (key, QCscalable))
547 scalable = ! NILP (val);
548 }
c2f5bfd6 549
8daf5667
KH		 550 if (! NILP (script) && ! charset)
551 {
552 Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
553
554 if (CONSP (chars))
555 {
556 charset = FcCharSetCreate ();
557 if (! charset)
558 goto err;
559 for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
560 if (CHARACTERP (XCAR (chars))
561 && ! FcCharSetAddChar (charset, XUINT (XCAR (chars))))
562 goto err;
c2f5bfd6
KH		 563 }
564 }
565
42984a74 566 pattern = NILP (name) ? FcPatternCreate () : FcNameParse (SDATA (name));
706b6995
KH		 567 if (! pattern)
568 goto err;
42984a74
KH		 569 FcPatternDel (pattern, FC_SIZE);
570 FcPatternDel (pattern, FC_PIXEL_SIZE);
318548be
KH		 571 FcPatternDel (pattern, FC_FOUNDRY);
572 FcPatternDel (pattern, FC_FAMILY);
706b6995 573 tmp = AREF (spec, FONT_FOUNDRY_INDEX);
42984a74 574 if (! NILP (tmp)
706b6995
KH		 575 && ! FcPatternAddString (pattern, FC_FOUNDRY, SYMBOL_FcChar8 (tmp)))
576 goto err;
318548be
KH		 577 tmp = AREF (spec, FONT_FAMILY_INDEX);
578 if (! NILP (tmp)
579 && ! FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (tmp)))
580 goto err;
c2f5bfd6
KH		 581 if (charset
582 && ! FcPatternAddCharSet (pattern, FC_CHARSET, charset))
583 goto err;
584 if (langset
585 && ! FcPatternAddLangSet (pattern, FC_LANG, langset))
586 goto err;
bc9a2afe
KH		 587 if (dpi >= 0
588 && ! FcPatternAddDouble (pattern, FC_DPI, dpi))
589 goto err;
bc9a2afe 590 if (scalable >= 0
25a5d05b 591 && ! FcPatternAddBool (pattern, FC_SCALABLE, scalable ? FcTrue : FcFalse))
bc9a2afe 592 goto err;
42984a74 593 goto finish;
c2f5bfd6 594
42984a74
KH		 595 err:
596 /* We come here because of unexpected error in fontconfig API call
597 (usually insufficient memory). */
598 if (pattern)
599 {
600 FcPatternDestroy (pattern);
601 pattern = NULL;
602 }
603 if (*otspec)
604 {
605 if ((*otspec)->nfeatures[0] > 0)
606 free ((*otspec)->features[0]);
607 if ((*otspec)->nfeatures[1] > 0)
608 free ((*otspec)->features[1]);
609 free (*otspec);
610 *otspec = NULL;
611 }
612
613 finish:
42984a74 614 if (langset) FcLangSetDestroy (langset);
de24e3eb 615 if (charset && *fc_charset_idx < 0) FcCharSetDestroy (charset);
42984a74
KH		 616 return pattern;
617}
618
619static Lisp_Object
620ftfont_list (frame, spec)
621 Lisp_Object frame, spec;
622{
318548be 623 Lisp_Object val = Qnil, registry, family;
42984a74
KH		 624 int i;
625 FcPattern *pattern;
626 FcFontSet *fontset = NULL;
627 FcObjectSet *objset = NULL;
21988a08 628 int fc_charset_idx;
42984a74
KH		 629 char otlayout[15]; /* For "otlayout:XXXX" */
630 struct OpenTypeSpec *otspec = NULL;
5d376f74 631 int spacing = -1;
2a46904e 632
42984a74
KH		 633 if (! fc_initialized)
634 {
635 FcInit ();
636 fc_initialized = 1;
637 }
638
21988a08 639 pattern = ftfont_spec_pattern (spec, &fc_charset_idx, otlayout, &otspec);
42984a74
KH		 640 if (! pattern)
641 return Qnil;
5d376f74
KH		 642 if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
643 spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
318548be
KH		 644 registry = AREF (spec, FONT_REGISTRY_INDEX);
645 family = AREF (spec, FONT_FAMILY_INDEX);
646 if (! NILP (family))
647 {
648 Lisp_Object resolved;
649
650 resolved = ftfont_resolve_generic_family (family);
651 if (! NILP (resolved))
652 {
653 FcPatternDel (pattern, FC_FAMILY);
654 if (! FcPatternAddString (pattern, FC_FAMILY,
655 SYMBOL_FcChar8 (resolved)))
656 goto err;
657 }
658 }
659
706b6995 660 objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
42984a74 661 FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING, FC_SCALABLE,
5d376f74 662 FC_FILE,
42984a74
KH		 663#ifdef FC_CAPABILITY
664 FC_CAPABILITY,
665#endif /* FC_CAPABILITY */
e907d979 666 NULL);
706b6995
KH		 667 if (! objset)
668 goto err;
42984a74 669
318548be
KH		 670 fontset = FcFontList (NULL, pattern, objset);
671 if (! fontset)
672 goto err;
770835fd
KH		 673#if 0
674 /* Need fix because this finds any fonts. */
675 if (fontset->nfont == 0 && ! NILP (family))
676 {
677 /* Try maching with configuration. For instance, the
678 configuration may specify "Nimbus Mono L" as an alias of
679 "Courier". */
680 FcPattern *pat = FcPatternBuild (0, FC_FAMILY, FcTypeString,
681 SYMBOL_FcChar8 (family), NULL);
682 FcChar8 *fam;
683
684 if (FcConfigSubstitute (NULL, pat, FcMatchPattern) == FcTrue)
685 {
686 for (i = 0;
687 FcPatternGetString (pat, FC_FAMILY, i, &fam) == FcResultMatch;
688 i++)
689 {
690 FcPatternDel (pattern, FC_FAMILY);
691 FcPatternAddString (pattern, FC_FAMILY, fam);
692 FcFontSetDestroy (fontset);
693 fontset = FcFontList (NULL, pattern, objset);
694 if (fontset->nfont > 0)
695 break;
696 }
697 }
698 }
699#endif
318548be 700 for (i = 0; i < fontset->nfont; i++)
bc5f6c42 701 {
318548be 702 Lisp_Object entity;
f63d54dc 703
5d376f74
KH		 704 if (spacing >= 0)
705 {
706 int this;
707
708 if ((FcPatternGetInteger (fontset->fonts[i], FC_SPACING, 0, &this)
709 == FcResultMatch)
710 && spacing != this)
711 continue;
712 }
713
bc5f6c42 714#ifdef FC_CAPABILITY
318548be
KH		 715 if (otlayout[0])
716 {
717 FcChar8 *this;
a85f724a 718
318548be
KH		 719 if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0,
720 &this) != FcResultMatch
721 || ! strstr ((char *) this, otlayout))
722 continue;
723 }
bc5f6c42 724#endif /* FC_CAPABILITY */
cc63eaf9 725#ifdef HAVE_LIBOTF
318548be
KH		 726 if (otspec)
727 {
728 FcChar8 *file;
729 OTF *otf;
730
731 if (FcPatternGetString (fontset->fonts[i], FC_FILE, 0, &file)
732 != FcResultMatch)
733 continue;
734 otf = OTF_open ((char *) file);
735 if (! otf)
736 continue;
737 if (OTF_check_features (otf, 1,
738 otspec->script_tag, otspec->langsys_tag,
739 otspec->features[0],
740 otspec->nfeatures[0]) != 1
741 || OTF_check_features (otf, 0,
742 otspec->script_tag, otspec->langsys_tag,
743 otspec->features[1],
744 otspec->nfeatures[1]) != 1)
745 continue;
c2f5bfd6 746 }
318548be
KH		 747#endif /* HAVE_LIBOTF */
748 entity = ftfont_pattern_entity (fontset->fonts[i], registry,
749 fc_charset_idx);
750 if (! NILP (entity))
751 val = Fcons (entity, val);
c2f5bfd6 752 }
318548be 753 font_add_log ("ftfont-list", spec, val);
c2f5bfd6
KH		 754 goto finish;
755
756 err:
757 /* We come here because of unexpected error in fontconfig API call
706b6995 758 (usually insufficient memory). */
c2f5bfd6
KH		 759 val = Qnil;
760
761 finish:
c2f5bfd6
KH		 762 if (objset) FcObjectSetDestroy (objset);
763 if (fontset) FcFontSetDestroy (fontset);
c2f5bfd6 764 if (pattern) FcPatternDestroy (pattern);
c2f5bfd6
KH		 765 return val;
766}
767
8daf5667
KH		 768static Lisp_Object
769ftfont_match (frame, spec)
770 Lisp_Object frame, spec;
771{
21988a08 772 Lisp_Object entity;
42984a74 773 FcPattern *pattern, *match = NULL;
8daf5667 774 FcResult result;
42984a74
KH		 775 char otlayout[15]; /* For "otlayout:XXXX" */
776 struct OpenTypeSpec *otspec = NULL;
21988a08 777 int fc_charset_idx;
8daf5667
KH		 778
779 if (! fc_initialized)
780 {
781 FcInit ();
782 fc_initialized = 1;
783 }
784
21988a08 785 pattern = ftfont_spec_pattern (spec, &fc_charset_idx, otlayout, &otspec);
42984a74 786 if (! pattern)
8daf5667
KH		 787 return Qnil;
788
42984a74 789 if (INTEGERP (AREF (spec, FONT_SIZE_INDEX)))
8daf5667 790 {
42984a74 791 FcValue value;
55082642 792
42984a74
KH		 793 value.type = FcTypeDouble;
794 value.u.d = XINT (AREF (spec, FONT_SIZE_INDEX));
795 FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse);
796 }
797 if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
798 {
799 FcDefaultSubstitute (pattern);
800 match = FcFontMatch (NULL, pattern, &result);
801 if (match)
8daf5667 802 {
21988a08 803 entity = ftfont_pattern_entity (match, Qunicode_bmp, fc_charset_idx);
42984a74
KH		 804 FcPatternDestroy (match);
805 if (! NILP (AREF (spec, FONT_FAMILY_INDEX))
806 && NILP (assq_no_quit (AREF (spec, FONT_FAMILY_INDEX),
807 ftfont_generic_family_list))
808 && NILP (Fstring_equal (AREF (spec, FONT_FAMILY_INDEX),
809 AREF (entity, FONT_FAMILY_INDEX))))
810 entity = Qnil;
8daf5667 811 }
8daf5667 812 }
42984a74 813 FcPatternDestroy (pattern);
8daf5667 814
318548be 815 font_add_log ("ftfont-match", spec, entity);
8daf5667
KH		 816 return entity;
817}
818
c2f5bfd6
KH		 819static Lisp_Object
820ftfont_list_family (frame)
821 Lisp_Object frame;
822{
823 Lisp_Object list;
824 FcPattern *pattern = NULL;
825 FcFontSet *fontset = NULL;
826 FcObjectSet *objset = NULL;
827 int i;
828
829 if (! fc_initialized)
830 {
831 FcInit ();
832 fc_initialized = 1;
833 }
834
835 pattern = FcPatternCreate ();
836 if (! pattern)
837 goto finish;
706b6995 838 objset = FcObjectSetBuild (FC_FAMILY, NULL);
c2f5bfd6
KH		 839 if (! objset)
840 goto finish;
841 fontset = FcFontList (NULL, pattern, objset);
842 if (! fontset)
843 goto finish;
844
845 list = Qnil;
846 for (i = 0; i < fontset->nfont; i++)
847 {
848 FcPattern *pat = fontset->fonts[i];
849 FcChar8 *str;
850
851 if (FcPatternGetString (pat, FC_FAMILY, 0, &str) == FcResultMatch)
42984a74 852 list = Fcons (intern ((char *) str), list);
c2f5bfd6
KH		 853 }
854
855 finish:
856 if (objset) FcObjectSetDestroy (objset);
857 if (fontset) FcFontSetDestroy (fontset);
858 if (pattern) FcPatternDestroy (pattern);
859
860 return list;
861}
862
863
42984a74 864static Lisp_Object
c2f5bfd6
KH		 865ftfont_open (f, entity, pixel_size)
866 FRAME_PTR f;
867 Lisp_Object entity;
868 int pixel_size;
869{
870 struct ftfont_info *ftfont_info;
871 struct font *font;
872 FT_Face ft_face;
873 FT_Size ft_size;
874 FT_UInt size;
21988a08
KH		 875 Lisp_Object val, filename, cache, font_object;
876 int fc_charset_idx;
c2f5bfd6 877 FcPattern *pattern;
21988a08 878 int scalable;
c2f5bfd6 879 int spacing;
42984a74
KH		 880 char name[256];
881 int i, len;
882 int upEM;
c2f5bfd6 883
42984a74
KH		 884 val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
885 if (! CONSP (val))
886 return Qnil;
887 val = XCDR (val);
21988a08
KH		 888 filename = XCAR (val);
889 fc_charset_idx = XINT (XCDR (val));
890 cache = ftfont_lookup_cache (filename);
891 if (NILP (cache))
892 return Qnil;
893 filename = XCAR (cache);
894 val = XCDR (cache);
895 ft_face = XSAVE_VALUE (val)->pointer;
896 if (XSAVE_VALUE (val)->integer > 0)
c2f5bfd6 897 {
21988a08 898 /* FT_Face in this cache is already used by the different size. */
c2f5bfd6 899 if (FT_New_Size (ft_face, &ft_size) != 0)
42984a74 900 return Qnil;
c2f5bfd6
KH		 901 if (FT_Activate_Size (ft_size) != 0)
902 {
903 FT_Done_Size (ft_size);
42984a74 904 return Qnil;
c2f5bfd6 905 }
21988a08
KH		 906 }
907 XSAVE_VALUE (val)->integer++;
c2f5bfd6
KH		 908 size = XINT (AREF (entity, FONT_SIZE_INDEX));
909 if (size == 0)
910 size = pixel_size;
911 if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
912 {
913 if (XSAVE_VALUE (val)->integer == 0)
914 FT_Done_Face (ft_face);
42984a74 915 return Qnil;
c2f5bfd6
KH		 916 }
917
42984a74
KH		 918 font_object = font_make_object (VECSIZE (struct ftfont_info));
919 ASET (font_object, FONT_TYPE_INDEX, Qfreetype);
920 for (i = 1;i < FONT_ENTITY_MAX; i++)
921 ASET (font_object, i, AREF (entity, i));
922 ASET (font_object, FONT_SIZE_INDEX, make_number (size));
923 len = font_unparse_xlfd (entity, size, name, 256);
924 if (len > 0)
925 ASET (font_object, FONT_NAME_INDEX, make_unibyte_string (name, len));
926 len = font_unparse_fcname (entity, size, name, 256);
927 if (len > 0)
928 ASET (font_object, FONT_FULLNAME_INDEX, make_unibyte_string (name, len));
929 else
930 ASET (font_object, FONT_FULLNAME_INDEX,
931 AREF (font_object, FONT_NAME_INDEX));
21988a08 932 ASET (font_object, FONT_FILE_INDEX, filename);
42984a74
KH		 933 ASET (font_object, FONT_FORMAT_INDEX, ftfont_font_format (pattern));
934 font = XFONT_OBJECT (font_object);
935 ftfont_info = (struct ftfont_info *) font;
21988a08
KH		 936 ftfont_info->ft_size = ft_face->size;
937 ftfont_info->fc_charset_idx = fc_charset_idx;
0d674a05 938#ifdef HAVE_LIBOTF
de023c40
KH		 939 ftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
940 ftfont_info->otf = NULL;
0d674a05 941#endif /* HAVE_LIBOTF */
c2f5bfd6
KH		 942 font->pixel_size = size;
943 font->driver = &ftfont_driver;
42984a74 944 font->encoding_charset = font->repertory_charset = -1;
c9c0c429 945
42984a74 946 upEM = ft_face->units_per_EM;
21988a08
KH		 947 scalable = (INTEGERP (AREF (entity, FONT_AVGWIDTH_INDEX))
948 && XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
42984a74
KH		 949 if (scalable)
950 {
951 font->ascent = ft_face->ascender * size / upEM;
952 font->descent = - ft_face->descender * size / upEM;
953 font->height = ft_face->height * size / upEM;
954 }
955 else
956 {
957 font->ascent = ft_face->size->metrics.ascender >> 6;
958 font->descent = - ft_face->size->metrics.descender >> 6;
959 font->height = ft_face->size->metrics.height >> 6;
c9c0c429 960 }
21988a08
KH		 961 if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
962 spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
963 else
c9c0c429
KH		 964 spacing = FC_PROPORTIONAL;
965 if (spacing != FC_PROPORTIONAL)
42984a74
KH		 966 font->min_width = font->average_width = font->space_width
967 = (scalable ? ft_face->max_advance_width * size / upEM
968 : ft_face->size->metrics.max_advance >> 6);
c2f5bfd6
KH		 969 else
970 {
42984a74 971 int n;
c2f5bfd6 972
42984a74
KH		 973 font->min_width = font->average_width = font->space_width = 0;
974 for (i = 32, n = 0; i < 127; i++)
975 if (FT_Load_Char (ft_face, i, FT_LOAD_DEFAULT) != 0)
976 {
977 int this_width = ft_face->glyph->metrics.horiAdvance >> 6;
978
979 if (this_width > 0
980 && (! font->min_width || font->min_width > this_width))
981 font->min_width = this_width;
982 if (i == 32)
983 font->space_width = this_width;
984 font->average_width += this_width;
985 n++;
986 }
987 if (n > 0)
988 font->average_width /= n;
c2f5bfd6
KH		 989 }
990
42984a74
KH		 991 font->baseline_offset = 0;
992 font->relative_compose = 0;
993 font->default_ascent = 0;
994 font->vertical_centering = 0;
995 if (scalable)
996 {
997 font->underline_position = -ft_face->underline_position * size / upEM;
998 font->underline_thickness = -ft_face->underline_thickness * size / upEM;
999 }
1000 else
1001 {
1002 font->underline_position = -1;
1003 font->underline_thickness = 0;
1004 }
c2f5bfd6 1005
42984a74 1006 return font_object;
c2f5bfd6
KH		 1007}
1008
1009static void
1010ftfont_close (f, font)
1011 FRAME_PTR f;
1012 struct font *font;
1013{
1014 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
21988a08 1015 Lisp_Object val, cache;
c2f5bfd6 1016
21988a08
KH		 1017 cache = ftfont_lookup_cache (font->props[FONT_FILE_INDEX]);
1018 val = XCDR (cache);
c2f5bfd6
KH		 1019 (XSAVE_VALUE (val)->integer)--;
1020 if (XSAVE_VALUE (val)->integer == 0)
de023c40 1021 {
21988a08
KH		 1022 FT_Face ft_face = XSAVE_VALUE (val)->pointer;
1023
1024 FT_Done_Face (ft_face);
de023c40
KH		 1025#ifdef HAVE_LIBOTF
1026 if (ftfont_info->otf)
1027 OTF_close (ftfont_info->otf);
1028#endif
21988a08 1029 XSAVE_VALUE (val)->pointer = NULL;
de023c40 1030 }
c2f5bfd6
KH		 1031 else
1032 FT_Done_Size (ftfont_info->ft_size);
c2f5bfd6
KH		 1033}
1034
2a46904e 1035static int
c2f5bfd6
KH		 1036ftfont_has_char (entity, c)
1037 Lisp_Object entity;
1038 int c;
1039{
1040 Lisp_Object val;
21988a08
KH		 1041 int fc_charset_idx;
1042 struct charset *charset;
c2f5bfd6 1043
42984a74 1044 val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
21988a08
KH		 1045 fc_charset_idx = XINT (XCDR (XCDR (val)));
1046 if (fc_charset_idx < 0)
c2801c99 1047 return -1;
21988a08
KH		 1048 charset = CHARSET_FROM_ID (fc_charset_table[fc_charset_idx].charset_id);
1049 return (ENCODE_CHAR (charset, c) != CHARSET_INVALID_CODE (charset));
c2f5bfd6
KH		 1050}
1051
1052static unsigned
1053ftfont_encode_char (font, c)
1054 struct font *font;
1055 int c;
1056{
1057 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1058 FT_Face ft_face = ftfont_info->ft_size->face;
1059 FT_ULong charcode = c;
1060 FT_UInt code = FT_Get_Char_Index (ft_face, charcode);
1061
4cec6061 1062 return (code > 0 ? code : FONT_INVALID_CODE);
c2f5bfd6
KH		 1063}
1064
1065static int
1066ftfont_text_extents (font, code, nglyphs, metrics)
1067 struct font *font;
1068 unsigned *code;
1069 int nglyphs;
1070 struct font_metrics *metrics;
1071{
1072 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1073 FT_Face ft_face = ftfont_info->ft_size->face;
1074 int width = 0;
1075 int i;
1076
1077 if (ftfont_info->ft_size != ft_face->size)
1078 FT_Activate_Size (ftfont_info->ft_size);
1079 if (metrics)
1080 bzero (metrics, sizeof (struct font_metrics));
1081 for (i = 0; i < nglyphs; i++)
1082 {
1083 if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)
1084 {
1085 FT_Glyph_Metrics *m = &ft_face->glyph->metrics;
1086
1087 if (metrics)
1088 {
1089 if (metrics->lbearing > width + (m->horiBearingX >> 6))
1090 metrics->lbearing = width + (m->horiBearingX >> 6);
1091 if (metrics->rbearing
1092 < width + ((m->horiBearingX + m->width) >> 6))
1093 metrics->rbearing
1094 = width + ((m->horiBearingX + m->width) >> 6);
1095 if (metrics->ascent < (m->horiBearingY >> 6))
1096 metrics->ascent = m->horiBearingY >> 6;
1097 if (metrics->descent > ((m->horiBearingY + m->height) >> 6))
1098 metrics->descent = (m->horiBearingY + m->height) >> 6;
1099 }
1100 width += m->horiAdvance >> 6;
1101 }
1102 else
1103 {
42984a74 1104 width += font->space_width;
c2f5bfd6
KH		 1105 }
1106 }
1107 if (metrics)
1108 metrics->width = width;
1109
1110 return width;
1111}
1112
1113static int
1114ftfont_get_bitmap (font, code, bitmap, bits_per_pixel)
1115 struct font *font;
1116 unsigned code;
1117 struct font_bitmap *bitmap;
1118 int bits_per_pixel;
1119{
1120 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1121 FT_Face ft_face = ftfont_info->ft_size->face;
1122 FT_Int32 load_flags = FT_LOAD_RENDER;
1123
1124 if (ftfont_info->ft_size != ft_face->size)
1125 FT_Activate_Size (ftfont_info->ft_size);
1126 if (bits_per_pixel == 1)
1127 {
1128#ifdef FT_LOAD_TARGET_MONO
1129 load_flags |= FT_LOAD_TARGET_MONO;
1130#else
1131 load_flags |= FT_LOAD_MONOCHROME;
1132#endif
1133 }
1134 else if (bits_per_pixel != 8)
1135 /* We don't support such a rendering. */
1136 return -1;
1137
1138 if (FT_Load_Glyph (ft_face, code, load_flags) != 0)
1139 return -1;
b51e5112
KH		 1140 bitmap->bits_per_pixel
1141 = (ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 1
1142 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY ? 8
1143 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD ? 8
1144 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V ? 8
1145 : -1);
1146 if (bitmap->bits_per_pixel < 0)
1147 /* We don't suport that kind of pixel mode. */
1148 return -1;
c2f5bfd6
KH		 1149 bitmap->rows = ft_face->glyph->bitmap.rows;
1150 bitmap->width = ft_face->glyph->bitmap.width;
1151 bitmap->pitch = ft_face->glyph->bitmap.pitch;
1152 bitmap->buffer = ft_face->glyph->bitmap.buffer;
1153 bitmap->left = ft_face->glyph->bitmap_left;
1154 bitmap->top = ft_face->glyph->bitmap_top;
1155 bitmap->advance = ft_face->glyph->metrics.horiAdvance >> 6;
1156 bitmap->extra = NULL;
1157
1158 return 0;
1159}
1160
1161static int
1162ftfont_anchor_point (font, code, index, x, y)
1163 struct font *font;
1164 unsigned code;
1165 int index;
1166 int *x, *y;
1167{
1168 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1169 FT_Face ft_face = ftfont_info->ft_size->face;
1170
1171 if (ftfont_info->ft_size != ft_face->size)
1172 FT_Activate_Size (ftfont_info->ft_size);
1173 if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
1174 return -1;
1175 if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
1176 return -1;
1177 if (index >= ft_face->glyph->outline.n_points)
1178 return -1;
1179 *x = ft_face->glyph->outline.points[index].x;
1180 *y = ft_face->glyph->outline.points[index].y;
1181 return 0;
1182}
1183
de023c40
KH		 1184#ifdef HAVE_LIBOTF
1185#ifdef HAVE_M17N_FLT
1186
1187struct MFLTFontFT
1188{
1189 MFLTFont flt_font;
1190 struct font *font;
1191 FT_Face ft_face;
1192 OTF *otf;
1193};
1194
1195static int
1196ftfont_get_glyph_id (font, gstring, from, to)
1197 MFLTFont *font;
1198 MFLTGlyphString *gstring;
1199 int from, to;
1200{
1201 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1202 FT_Face ft_face = flt_font_ft->ft_face;
1203 MFLTGlyph *g;
1204
1205 for (g = gstring->glyphs + from; from < to; g++, from++)
1206 if (! g->encoded)
1207 {
1208 FT_UInt code = FT_Get_Char_Index (ft_face, g->code);
1209
1210 g->code = code > 0 ? code : FONT_INVALID_CODE;
1211 g->encoded = 1;
1212 }
1213 return 0;
1214}
1215
1216static int
1217ftfont_get_metrics (font, gstring, from, to)
1218 MFLTFont *font;
1219 MFLTGlyphString *gstring;
1220 int from, to;
1221{
1222 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1223 FT_Face ft_face = flt_font_ft->ft_face;
1224 MFLTGlyph *g;
1225
1226 for (g = gstring->glyphs + from; from < to; g++, from++)
1227 if (! g->measured)
1228 {
1229 if (g->code != FONT_INVALID_CODE)
1230 {
1231 FT_Glyph_Metrics *m;
1232
1233 if (FT_Load_Glyph (ft_face, g->code, FT_LOAD_DEFAULT) != 0)
1234 abort ();
1235 m = &ft_face->glyph->metrics;
1236
1237 g->lbearing = m->horiBearingX;
1238 g->rbearing = m->horiBearingX + m->width;
1239 g->ascent = m->horiBearingY;
1240 g->descent = m->height - m->horiBearingY;
1241 g->xadv = m->horiAdvance;
1242 }
1243 else
1244 {
1245 g->lbearing = 0;
42984a74 1246 g->rbearing = g->xadv = flt_font_ft->font->space_width << 6;
de023c40
KH		 1247 g->ascent = flt_font_ft->font->ascent << 6;
1248 g->descent = flt_font_ft->font->descent << 6;
1249 }
1250 g->yadv = 0;
1251 g->measured = 1;
1252 }
1253 return 0;
1254}
1255
2a46904e 1256static int
de023c40
KH		 1257ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
1258{
1259 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1260 OTF *otf = flt_font_ft->otf;
1261 OTF_Tag *tags;
1262 int i, n, negative;
1263
1264 for (i = 0; i < 2; i++)
1265 {
1266 if (! spec->features[i])
1267 continue;
1268 for (n = 0; spec->features[i][n]; n++);
1269 tags = alloca (sizeof (OTF_Tag) * n);
1270 for (n = 0, negative = 0; spec->features[i][n]; n++)
1271 {
1272 if (spec->features[i][n] == 0xFFFFFFFF)
1273 negative = 1;
1274 else if (negative)
1275 tags[n - 1] = spec->features[i][n] | 0x80000000;
1276 else
1277 tags[n] = spec->features[i][n];
1278 }
1279 if (n - negative > 0
1280 && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
1281 tags, n - negative) != 1)
1282 return 0;
1283 }
1284 return 1;
1285}
1286
1287#define DEVICE_DELTA(table, size) \
1288 (((size) >= (table).StartSize && (size) <= (table).EndSize) \
1289 ? (table).DeltaValue[(size) - (table).StartSize] << 6 \
1290 : 0)
1291
1292static void
1293adjust_anchor (FT_Face ft_face, OTF_Anchor *anchor,
1294 unsigned code, int x_ppem, int y_ppem, int *x, int *y)
1295{
1296 if (anchor->AnchorFormat == 2)
1297 {
1298 FT_Outline *outline;
1299 int ap = anchor->f.f1.AnchorPoint;
1300
1301 FT_Load_Glyph (ft_face, (FT_UInt) code, FT_LOAD_MONOCHROME);
1302 outline = &ft_face->glyph->outline;
1303 if (ap < outline->n_points)
1304 {
1305 *x = outline->points[ap].x << 6;
1306 *y = outline->points[ap].y << 6;
1307 }
1308 }
1309 else if (anchor->AnchorFormat == 3)
1310 {
1311 if (anchor->f.f2.XDeviceTable.offset)
1312 *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, x_ppem);
1313 if (anchor->f.f2.YDeviceTable.offset)
1314 *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, y_ppem);
1315 }
1316}
1317
1318static OTF_GlyphString otf_gstring;
1319
2a46904e 1320static int
de023c40
KH		 1321ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
1322 MFLTFont *font;
1323 MFLTOtfSpec *spec;
1324 MFLTGlyphString *in;
1325 int from, to;
1326 MFLTGlyphString *out;
1327 MFLTGlyphAdjustment *adjustment;
1328{
1329 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1330 FT_Face ft_face = flt_font_ft->ft_face;
1331 OTF *otf = flt_font_ft->otf;
1332 int len = to - from;
1333 int i, j, gidx;
1334 OTF_Glyph *otfg;
1335 char script[5], *langsys = NULL;
1336 char *gsub_features = NULL, *gpos_features = NULL;
1337
1338 if (len == 0)
1339 return from;
1340 OTF_tag_name (spec->script, script);
1341 if (spec->langsys)
1342 {
1343 langsys = alloca (5);
1344 OTF_tag_name (spec->langsys, langsys);
1345 }
1346 for (i = 0; i < 2; i++)
1347 {
1348 char *p;
1349
1350 if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
1351 {
1352 for (j = 0; spec->features[i][j]; j++);
1353 if (i == 0)
1354 p = gsub_features = alloca (6 * j);
1355 else
1356 p = gpos_features = alloca (6 * j);
1357 for (j = 0; spec->features[i][j]; j++)
1358 {
1359 if (spec->features[i][j] == 0xFFFFFFFF)
1360 *p++ = '*', *p++ = ',';
1361 else
1362 {
1363 OTF_tag_name (spec->features[i][j], p);
1364 p[4] = ',';
1365 p += 5;
1366 }
1367 }
1368 *--p = '\0';
1369 }
1370 }
1371
1372 if (otf_gstring.size == 0)
1373 {
1374 otf_gstring.glyphs = (OTF_Glyph *) malloc (sizeof (OTF_Glyph) * len);
1375 otf_gstring.size = len;
1376 }
1377 else if (otf_gstring.size < len)
1378 {
1379 otf_gstring.glyphs = (OTF_Glyph *) realloc (otf_gstring.glyphs,
1380 sizeof (OTF_Glyph) * len);
1381 otf_gstring.size = len;
1382 }
1383 otf_gstring.used = len;
1384 memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * len);
1385 for (i = 0; i < len; i++)
1386 {
1387 otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
1388 otf_gstring.glyphs[i].glyph_id = in->glyphs[from + i].code;
1389 }
1390
1391 OTF_drive_gdef (otf, &otf_gstring);
1392 gidx = out->used;
1393
1394 if (gsub_features)
1395 {
1396 if (OTF_drive_gsub (otf, &otf_gstring, script, langsys, gsub_features)
1397 < 0)
1398 goto simple_copy;
1399 if (out->allocated < out->used + otf_gstring.used)
1400 return -2;
7d2fd545 1401 for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; )
de023c40 1402 {
7d2fd545
KH		 1403 MFLTGlyph *g;
1404 int min_from, max_to;
de023c40
KH		 1405 int j;
1406
7d2fd545 1407 g = out->glyphs + out->used;
de023c40 1408 *g = in->glyphs[from + otfg->f.index.from];
de023c40
KH		 1409 if (g->code != otfg->glyph_id)
1410 {
7d2fd545 1411 g->c = 0;
de023c40
KH		 1412 g->code = otfg->glyph_id;
1413 g->measured = 0;
1414 }
1415 out->used++;
7d2fd545
KH		 1416 min_from = g->from;
1417 max_to = g->to;
1418 if (otfg->f.index.from < otfg->f.index.to)
1419 {
1420 /* OTFG substitutes multiple glyphs in IN. */
1421 for (j = from + otfg->f.index.from + 1;
1422 j <= from + otfg->f.index.to; j++)
1423 {
1424 if (min_from > in->glyphs[j].from)
1425 min_from = in->glyphs[j].from;
1426 if (max_to < in->glyphs[j].to)
1427 max_to = in->glyphs[j].to;
1428 }
1429 g->from = min_from;
1430 g->to = max_to;
1431 }
1432 for (i++, otfg++; (i < otf_gstring.used
1433 && otfg->f.index.from == otfg[-1].f.index.from);
1434 i++, otfg++)
1435 {
1436 g = out->glyphs + out->used;
1437 *g = in->glyphs[from + otfg->f.index.to];
1438 if (g->code != otfg->glyph_id)
1439 {
1440 g->c = 0;
1441 g->code = otfg->glyph_id;
1442 g->measured = 0;
1443 }
1444 out->used++;
1445 }
de023c40
KH		 1446 }
1447 }
1448 else
1449 {
1450 if (out->allocated < out->used + len)
1451 return -2;
1452 for (i = 0; i < len; i++)
1453 out->glyphs[out->used++] = in->glyphs[from + i];
1454 }
1455
1456 if (gpos_features)
1457 {
1458 MFLTGlyph *base = NULL, *mark = NULL, *g;
1459 int x_ppem, y_ppem, x_scale, y_scale;
1460
1461 if (OTF_drive_gpos (otf, &otf_gstring, script, langsys, gpos_features)
1462 < 0)
1463 return to;
1464
1465 x_ppem = ft_face->size->metrics.x_ppem;
1466 y_ppem = ft_face->size->metrics.y_ppem;
1467 x_scale = ft_face->size->metrics.x_scale;
1468 y_scale = ft_face->size->metrics.y_scale;
1469
1470 for (i = 0, otfg = otf_gstring.glyphs, g = out->glyphs + gidx;
1471 i < otf_gstring.used; i++, otfg++, g++)
1472 {
1473 MFLTGlyph *prev;
1474
1475 if (! otfg->glyph_id)
1476 continue;
1477 switch (otfg->positioning_type)
1478 {
1479 case 0:
1480 break;
1481 case 1: /* Single */
1482 case 2: /* Pair */
1483 {
1484 int format = otfg->f.f1.format;
1485
1486 if (format & OTF_XPlacement)
1487 adjustment[i].xoff
1488 = otfg->f.f1.value->XPlacement * x_scale / 0x10000;
1489 if (format & OTF_XPlaDevice)
1490 adjustment[i].xoff
1491 += DEVICE_DELTA (otfg->f.f1.value->XPlaDevice, x_ppem);
1492 if (format & OTF_YPlacement)
1493 adjustment[i].yoff
1494 = - (otfg->f.f1.value->YPlacement * y_scale / 0x10000);
1495 if (format & OTF_YPlaDevice)
1496 adjustment[i].yoff
1497 -= DEVICE_DELTA (otfg->f.f1.value->YPlaDevice, y_ppem);
1498 if (format & OTF_XAdvance)
1499 adjustment[i].xadv
1500 += otfg->f.f1.value->XAdvance * x_scale / 0x10000;
1501 if (format & OTF_XAdvDevice)
1502 adjustment[i].xadv
1503 += DEVICE_DELTA (otfg->f.f1.value->XAdvDevice, x_ppem);
1504 if (format & OTF_YAdvance)
1505 adjustment[i].yadv
1506 += otfg->f.f1.value->YAdvance * y_scale / 0x10000;
1507 if (format & OTF_YAdvDevice)
1508 adjustment[i].yadv
1509 += DEVICE_DELTA (otfg->f.f1.value->YAdvDevice, y_ppem);
1510 adjustment[i].set = 1;
1511 }
1512 break;
1513 case 3: /* Cursive */
1514 /* Not yet supported. */
1515 break;
1516 case 4: /* Mark-to-Base */
1517 case 5: /* Mark-to-Ligature */
1518 if (! base)
1519 break;
1520 prev = base;
1521 goto label_adjust_anchor;
1522 default: /* i.e. case 6 Mark-to-Mark */
1523 if (! mark)
1524 break;
1525 prev = mark;
1526
1527 label_adjust_anchor:
1528 {
1529 int base_x, base_y, mark_x, mark_y;
1530 int this_from, this_to;
1531
1532 base_x = otfg->f.f4.base_anchor->XCoordinate * x_scale / 0x10000;
1533 base_y = otfg->f.f4.base_anchor->YCoordinate * y_scale / 0x10000;
1534 mark_x = otfg->f.f4.mark_anchor->XCoordinate * x_scale / 0x10000;
1535 mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;;
1536
1537 if (otfg->f.f4.base_anchor->AnchorFormat != 1)
1538 adjust_anchor (ft_face, otfg->f.f4.base_anchor,
1539 prev->code, x_ppem, y_ppem, &base_x, &base_y);
1540 if (otfg->f.f4.mark_anchor->AnchorFormat != 1)
1541 adjust_anchor (ft_face, otfg->f.f4.mark_anchor, g->code,
1542 x_ppem, y_ppem, &mark_x, &mark_y);
1543 adjustment[i].xoff = (base_x - mark_x);
1544 adjustment[i].yoff = - (base_y - mark_y);
1545 adjustment[i].back = (g - prev);
1546 adjustment[i].xadv = 0;
1547 adjustment[i].advance_is_absolute = 1;
1548 adjustment[i].set = 1;
1549 this_from = g->from;
1550 this_to = g->to;
1551 for (j = 0; prev + j < g; j++)
1552 {
1553 if (this_from > prev[j].from)
1554 this_from = prev[j].from;
1555 if (this_to < prev[j].to)
1556 this_to = prev[j].to;
1557 }
1558 for (; prev <= g; prev++)
1559 {
1560 prev->from = this_from;
1561 prev->to = this_to;
1562 }
1563 }
1564 }
1565 if (otfg->GlyphClass == OTF_GlyphClass0)
1566 base = mark = g;
1567 else if (otfg->GlyphClass == OTF_GlyphClassMark)
1568 mark = g;
1569 else
1570 base = g;
1571 }
1572 }
1573 return to;
1574
1575 simple_copy:
1576 if (out->allocated < out->used + len)
1577 return -2;
1578 font->get_metrics (font, in, from, to);
1579 memcpy (out->glyphs + out->used, in->glyphs + from,
1580 sizeof (MFLTGlyph) * len);
1581 out->used += len;
1582 return to;
1583}
1584
1585static MFLTGlyphString gstring;
1586
1587static int m17n_flt_initialized;
1588
1589extern Lisp_Object QCfamily;
1590
1591Lisp_Object
1592ftfont_shape_by_flt (lgstring, font, ft_face, otf)
1593 Lisp_Object lgstring;
1594 struct font *font;
1595 FT_Face ft_face;
1596 OTF *otf;
1597{
1598 EMACS_UINT len = LGSTRING_LENGTH (lgstring);
1599 EMACS_UINT i;
1600 struct MFLTFontFT flt_font_ft;
1601
1602 if (! m17n_flt_initialized)
1603 {
1604 M17N_INIT ();
1605 m17n_flt_initialized = 1;
1606 }
1607
1608 for (i = 0; i < len; i++)
1609 if (NILP (LGSTRING_GLYPH (lgstring, i)))
1610 break;
1611 len = i;
1612
1613 if (gstring.allocated == 0)
1614 {
1615 gstring.allocated = len * 2;
1616 gstring.glyph_size = sizeof (MFLTGlyph);
1617 gstring.glyphs = malloc (sizeof (MFLTGlyph) * gstring.allocated);
1618 }
1619 else if (gstring.allocated < len * 2)
1620 {
1621 gstring.allocated = len * 2;
1622 gstring.glyphs = realloc (gstring.glyphs,
1623 sizeof (MFLTGlyph) * gstring.allocated);
1624 }
1625 for (i = 0; i < len; i++)
1626 gstring.glyphs[i].c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
1627 gstring.used = len;
1628 gstring.r2l = 0;
1629
1630 {
1631 Lisp_Object family = Ffont_get (LGSTRING_FONT (lgstring), QCfamily);
1632
1633 if (NILP (family))
1634 flt_font_ft.flt_font.family = Mnil;
1635 else
21988a08
KH		 1636 flt_font_ft.flt_font.family
1637 = msymbol ((char *) SDATA (SYMBOL_NAME (family)));
de023c40
KH		 1638 }
1639 flt_font_ft.flt_font.x_ppem = ft_face->size->metrics.x_ppem;
1640 flt_font_ft.flt_font.y_ppem = ft_face->size->metrics.y_ppem;
1641 flt_font_ft.flt_font.get_glyph_id = ftfont_get_glyph_id;
1642 flt_font_ft.flt_font.get_metrics = ftfont_get_metrics;
1643 flt_font_ft.flt_font.check_otf = ftfont_check_otf;
1644 flt_font_ft.flt_font.drive_otf = ftfont_drive_otf;
1645 flt_font_ft.flt_font.internal = NULL;
1646 flt_font_ft.font = font;
1647 flt_font_ft.ft_face = ft_face;
1648 flt_font_ft.otf = otf;
1649 for (i = 0; i < 3; i++)
1650 {
1651 int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, NULL);
1652 if (result != -2)
1653 break;
1654 gstring.allocated += gstring.allocated;
1655 gstring.glyphs = realloc (gstring.glyphs,
1656 sizeof (MFLTGlyph) * gstring.allocated);
1657 }
1658 if (gstring.used > LGSTRING_LENGTH (lgstring))
1659 return Qnil;
1660 for (i = 0; i < gstring.used; i++)
1661 {
1662 MFLTGlyph *g = gstring.glyphs + i;
1663
1664 g->from = LGLYPH_FROM (LGSTRING_GLYPH (lgstring, g->from));
1665 g->to = LGLYPH_TO (LGSTRING_GLYPH (lgstring, g->to));
1666 }
1667
1668 for (i = 0; i < gstring.used; i++)
1669 {
1670 Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
1671 MFLTGlyph *g = gstring.glyphs + i;
1672
4cec6061
KH		 1673 if (NILP (lglyph))
1674 {
1675 lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
1676 LGSTRING_SET_GLYPH (lgstring, i, lglyph);
1677 }
de023c40
KH		 1678 LGLYPH_SET_FROM (lglyph, g->from);
1679 LGLYPH_SET_TO (lglyph, g->to);
1680 LGLYPH_SET_CHAR (lglyph, g->c);
1681 LGLYPH_SET_CODE (lglyph, g->code);
1682 LGLYPH_SET_WIDTH (lglyph, g->xadv >> 6);
1683 LGLYPH_SET_LBEARING (lglyph, g->lbearing >> 6);
1684 LGLYPH_SET_RBEARING (lglyph, g->rbearing >> 6);
1685 LGLYPH_SET_ASCENT (lglyph, g->ascent >> 6);
1686 LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
1687 if (g->adjusted)
1688 {
1689 Lisp_Object vec;
1690
1691 vec = Fmake_vector (make_number (3), Qnil);
1692 ASET (vec, 0, make_number (g->xoff >> 6));
1693 ASET (vec, 1, make_number (g->yoff >> 6));
1694 ASET (vec, 2, make_number (g->xadv >> 6));
1695 LGLYPH_SET_ADJUSTMENT (lglyph, vec);
1696 }
1697 }
1698 return make_number (i);
1699}
1700
1701Lisp_Object
1702ftfont_shape (lgstring)
1703 Lisp_Object lgstring;
1704{
1705 struct font *font;
1706 struct ftfont_info *ftfont_info;
1707
1708 CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
1709 ftfont_info = (struct ftfont_info *) font;
1710 if (! ftfont_info->maybe_otf)
4cc1c806 1711 return make_number (0);
de023c40
KH		 1712 if (! ftfont_info->otf)
1713 {
1714 OTF *otf = OTF_open_ft_face (ftfont_info->ft_size->face);
1715
1716 if (! otf || OTF_get_table (otf, "head") < 0)
1717 {
1718 if (otf)
1719 OTF_close (otf);
1720 ftfont_info->maybe_otf = 0;
4cc1c806 1721 return make_number (0);
de023c40
KH		 1722 }
1723
1724 ftfont_info->otf = otf;
1725 }
1726
1727 return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face,
1728 ftfont_info->otf);
1729}
1730
1731#endif /* HAVE_M17N_FLT */
1732#endif /* HAVE_LIBOTF */
1733
0b966021
KH		 1734Lisp_Object
1735ftfont_font_format (FcPattern *pattern)
1736{
e907d979 1737 FcChar8 *str;
0b966021 1738
e907d979
KH		 1739#ifdef FC_FONTFORMAT
1740 if (FcPatternGetString (pattern, FC_FONTFORMAT, 0, &str) != FcResultMatch)
0b966021 1741 return Qnil;
e907d979 1742 if (strcmp ((char *) str, "TrueType") == 0)
0b966021 1743 return intern ("truetype");
48875afe 1744 if (strcmp ((char *) str, "Type 1") == 0)
0b966021 1745 return intern ("type1");
2a46904e 1746 if (strcmp ((char *) str, "PCF") == 0)
0b966021 1747 return intern ("pcf");
2a46904e 1748 if (strcmp ((char *) str, "BDF") == 0)
0b966021 1749 return intern ("bdf");
e907d979 1750#else /* not FC_FONTFORMAT */
2f4c3d6d
KH		 1751 int len;
1752
09a56ce4 1753 if (FcPatternGetString (pattern, FC_FILE, 0, &str) != FcResultMatch)
e907d979 1754 return Qnil;
719b3d63
KH		 1755 len = strlen ((char *) str);
1756 if (len >= 4)
1757 {
1758 str += len - 4;
1759 if (xstrcasecmp ((char *) str, ".ttf") == 0)
1760 return intern ("truetype");
1761 if (xstrcasecmp ((char *) str, "pfb") == 0)
1762 return intern ("type1");
2a46904e 1763 if (xstrcasecmp ((char *) str, "pcf") == 0)
719b3d63 1764 return intern ("pcf");
2a46904e 1765 if (xstrcasecmp ((char *) str, "bdf") == 0)
719b3d63
KH		 1766 return intern ("bdf");
1767 }
e907d979 1768#endif /* not FC_FONTFORMAT */
0b966021
KH		 1769 return intern ("unknown");
1770}
1771
c2f5bfd6
KH		 1772\f
1773void
1774syms_of_ftfont ()
1775{
706b6995
KH		 1776 DEFSYM (Qfreetype, "freetype");
1777 DEFSYM (Qmonospace, "monospace");
1778 DEFSYM (Qsans_serif, "sans-serif");
1779 DEFSYM (Qserif, "serif");
1780 DEFSYM (Qmono, "mono");
1781 DEFSYM (Qsans, "sans");
1782 DEFSYM (Qsans__serif, "sans serif");
1783
c2f5bfd6 1784 staticpro (&freetype_font_cache);
c2801c99 1785 freetype_font_cache = Fcons (Qt, Qnil);
c2f5bfd6 1786
706b6995
KH		 1787 staticpro (&ftfont_generic_family_list);
1788 ftfont_generic_family_list
1789 = Fcons (Fcons (Qmonospace, Qt),
1790 Fcons (Fcons (Qsans_serif, Qt),
1791 Fcons (Fcons (Qsans, Qt), Qnil)));
c2f5bfd6 1792
21988a08
KH		 1793 staticpro (&ft_face_cache);
1794 ft_face_cache = Qnil;
1795
c2f5bfd6
KH		 1796 ftfont_driver.type = Qfreetype;
1797 register_font_driver (&ftfont_driver, NULL);
1798}
885b7d09
MB		 1799
1800/* arch-tag: 7cfa432c-33a6-4988-83d2-a82ed8604aca
1801 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.