HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
(json-partial-output): Fix broken GDB/MI output in -break-info command
[bpt/emacs.git] / src / ftfont.c
CommitLineData
c2f5bfd6 1/* ftfont.c -- FreeType font driver.
76b6f707
GM		 2 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
3 Copyright (C) 2006, 2007, 2008, 2009
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"
89a95b7c 35#include "composite.h"
c2f5bfd6
KH		 36#include "fontset.h"
37#include "font.h"
de023c40 38#include "ftfont.h"
c2f5bfd6 39
c2801c99 40/* Symbolic type of this font-driver. */
c2f5bfd6
KH		 41Lisp_Object Qfreetype;
42
706b6995
KH		 43/* Fontconfig's generic families and their aliases. */
44static Lisp_Object Qmonospace, Qsans_serif, Qserif, Qmono, Qsans, Qsans__serif;
45
2a46904e 46/* Flag to tell if FcInit is already called or not. */
c2f5bfd6 47static int fc_initialized;
c2801c99
KH		 48
49/* Handle to a FreeType library instance. */
c2f5bfd6
KH		 50static FT_Library ft_library;
51
c2801c99 52/* Cache for FreeType fonts. */
c2f5bfd6
KH		 53static Lisp_Object freetype_font_cache;
54
e302a291 55/* Cache for FT_Face and FcCharSet. */
21988a08 56static Lisp_Object ft_face_cache;
c2f5bfd6
KH		 57
58/* The actual structure for FreeType font that can be casted to struct
59 font. */
60
61struct ftfont_info
62{
63 struct font font;
de023c40 64#ifdef HAVE_LIBOTF
7179ce7b 65 /* The following four members must be here in this order to be
e302a291 66 compatible with struct xftfont_info (in xftfont.c). */
de023c40
KH		 67 int maybe_otf; /* Flag to tell if this may be OTF or not. */
68 OTF *otf;
69#endif /* HAVE_LIBOTF */
e302a291
KH		 70 FT_Size ft_size;
71 int index;
c2f5bfd6
KH		 72};
73
d7782105
KH		 74enum ftfont_cache_for
75 {
76 FTFONT_CACHE_FOR_FACE,
77 FTFONT_CACHE_FOR_CHARSET,
78 FTFONT_CACHE_FOR_ENTITY
79 };
80
e302a291 81static Lisp_Object ftfont_pattern_entity P_ ((FcPattern *, Lisp_Object));
21988a08 82
7d7ad10e
KH		 83static Lisp_Object ftfont_resolve_generic_family P_ ((Lisp_Object,
84 FcPattern *));
d7782105
KH		 85static Lisp_Object ftfont_lookup_cache P_ ((Lisp_Object,
86 enum ftfont_cache_for));
e302a291 87
7d7ad10e 88Lisp_Object ftfont_font_format P_ ((FcPattern *, Lisp_Object));
706b6995
KH		 89
90#define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))
91
21988a08 92static struct
c2f5bfd6 93{
e302a291 94 /* registry name */
21988a08
KH		 95 char *name;
96 /* characters to distinguish the charset from the others */
97 int uniquifier[6];
7d7ad10e
KH		 98 /* additional constraint by language */
99 char *lang;
21988a08
KH		 100 /* set on demand */
101 FcCharSet *fc_charset;
102} fc_charset_table[] =
d7782105 103 { { "iso8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 } },
e302a291
KH		 104 { "iso8859-2", { 0x00A0, 0x010E }},
105 { "iso8859-3", { 0x00A0, 0x0108 }},
106 { "iso8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }},
107 { "iso8859-5", { 0x00A0, 0x0401 }},
108 { "iso8859-6", { 0x00A0, 0x060C }},
109 { "iso8859-7", { 0x00A0, 0x0384 }},
110 { "iso8859-8", { 0x00A0, 0x05D0 }},
111 { "iso8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }},
112 { "iso8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }},
113 { "iso8859-11", { 0x00A0, 0x0E01 }},
114 { "iso8859-13", { 0x00A0, 0x201C }},
115 { "iso8859-14", { 0x00A0, 0x0174 }},
116 { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
117 { "iso8859-16", { 0x00A0, 0x0218}},
118 { "gb2312.1980-0", { 0x4E13 }, "zh-cn"},
119 { "big5-0", { 0xF6B1 }, "zh-tw" },
120 { "jisx0208.1983-0", { 0x4E55 }, "ja"},
121 { "ksc5601.1985-0", { 0xAC00 }, "ko"},
122 { "cns11643.1992-1", { 0xFE32 }, "zh-tw"},
123 { "cns11643.1992-2", { 0x4E33, 0x7934 }},
124 { "cns11643.1992-3", { 0x201A9 }},
125 { "cns11643.1992-4", { 0x20057 }},
126 { "cns11643.1992-5", { 0x20000 }},
127 { "cns11643.1992-6", { 0x20003 }},
128 { "cns11643.1992-7", { 0x20055 }},
129 { "gbk-0", { 0x4E06 }, "zh-cn"},
130 { "jisx0212.1990-0", { 0x4E44 }},
131 { "jisx0213.2000-1", { 0xFA10 }, "ja"},
132 { "jisx0213.2000-2", { 0xFA49 }},
133 { "jisx0213.2004-1", { 0x20B9F }},
134 { "viscii1.1-1", { 0x1EA0, 0x1EAE, 0x1ED2 }, "vi"},
135 { "tis620.2529-1", { 0x0E01 }, "th"},
7d7ad10e
KH		 136 { "windows-1251", { 0x0401, 0x0490 }, "ru"},
137 { "koi8-r", { 0x0401, 0x2219 }, "ru"},
e302a291 138 { "mulelao-1", { 0x0E81 }, "lo"},
7b649478 139 { "unicode-sip", { 0x20000 }},
21988a08
KH		 140 { NULL }
141 };
c2f5bfd6 142
42984a74
KH		 143extern Lisp_Object Qc, Qm, Qp, Qd;
144
99c4d65d
KH		 145/* Dirty hack for handing ADSTYLE property.
146
147 Fontconfig (actually the underlying FreeType) gives such ADSTYLE
148 font property of PCF/BDF fonts in FC_STYLE. And, "Bold",
149 "Oblique", "Italic", or any non-normal SWIDTH property names
150 (e.g. SemiCondensed) are appended. In addition, if there's no
151 ADSTYLE property nor non-normal WEIGHT/SLANT/SWIDTH properties,
152 "Regular" is used for FC_STYLE (see the function
153 pcf_interpret_style in src/pcf/pcfread.c of FreeType).
154
155 Unfortunately this behavior is not documented, so the following
156 code may fail if FreeType changes the behavior in the future. */
157
158static Lisp_Object
159get_adstyle_property (FcPattern *p)
160{
161 char *str, *end;
162 Lisp_Object adstyle;
163
164 if (FcPatternGetString (p, FC_STYLE, 0, (FcChar8 **) &str) != FcResultMatch)
165 return Qnil;
166 for (end = str; *end && *end != ' '; end++);
167 if (*end)
168 {
169 char *p = alloca (end - str + 1);
170 memcpy (p, str, end - str);
171 p[end - str] = '\0';
a8a3728b 172 end = p + (end - str);
99c4d65d
KH		 173 str = p;
174 }
175 if (xstrcasecmp (str, "Regular") == 0
176 || xstrcasecmp (str, "Bold") == 0
177 || xstrcasecmp (str, "Oblique") == 0
178 || xstrcasecmp (str, "Italic") == 0)
179 return Qnil;
42d4a64f 180 adstyle = font_intern_prop (str, end - str, 1);
99c4d65d
KH		 181 if (font_style_to_value (FONT_WIDTH_INDEX, adstyle, 0) >= 0)
182 return Qnil;
183 return adstyle;
184}
185
706b6995 186static Lisp_Object
e302a291 187ftfont_pattern_entity (p, extra)
c2801c99 188 FcPattern *p;
e302a291 189 Lisp_Object extra;
c2801c99 190{
d7782105 191 Lisp_Object key, cache, entity;
21988a08 192 char *file, *str;
e302a291 193 int index;
c2801c99
KH		 194 int numeric;
195 double dbl;
42984a74 196 FcBool b;
c2801c99 197
21988a08 198 if (FcPatternGetString (p, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
c2801c99 199 return Qnil;
e302a291
KH		 200 if (FcPatternGetInteger (p, FC_INDEX, 0, &index) != FcResultMatch)
201 return Qnil;
c2801c99 202
d7782105
KH		 203 key = Fcons (make_unibyte_string ((char *) file, strlen ((char *) file)),
204 make_number (index));
205 cache = ftfont_lookup_cache (key, FTFONT_CACHE_FOR_ENTITY);
206 entity = XCAR (cache);
207 if (! NILP (entity))
b50504f5
KH		 208 {
209 Lisp_Object val = font_make_entity ();
210 int i;
211
212 for (i = 0; i < FONT_OBJLIST_INDEX; i++)
213 ASET (val, i, AREF (entity, i));
214 return val;
215 }
42984a74 216 entity = font_make_entity ();
d7782105 217 XSETCAR (cache, entity);
c2801c99
KH		 218
219 ASET (entity, FONT_TYPE_INDEX, Qfreetype);
e302a291 220 ASET (entity, FONT_REGISTRY_INDEX, Qiso10646_1);
c2801c99 221
21988a08 222 if (FcPatternGetString (p, FC_FOUNDRY, 0, (FcChar8 **) &str) == FcResultMatch)
a1a94102 223 ASET (entity, FONT_FOUNDRY_INDEX, font_intern_prop (str, strlen (str), 1));
21988a08 224 if (FcPatternGetString (p, FC_FAMILY, 0, (FcChar8 **) &str) == FcResultMatch)
a1a94102 225 ASET (entity, FONT_FAMILY_INDEX, font_intern_prop (str, strlen (str), 1));
c2801c99 226 if (FcPatternGetInteger (p, FC_WEIGHT, 0, &numeric) == FcResultMatch)
f63d54dc 227 {
42984a74
KH		 228 if (numeric >= FC_WEIGHT_REGULAR && numeric < FC_WEIGHT_MEDIUM)
229 numeric = FC_WEIGHT_MEDIUM;
230 FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, make_number (numeric));
f63d54dc 231 }
c2801c99 232 if (FcPatternGetInteger (p, FC_SLANT, 0, &numeric) == FcResultMatch)
42984a74
KH		 233 {
234 numeric += 100;
235 FONT_SET_STYLE (entity, FONT_SLANT_INDEX, make_number (numeric));
236 }
c2801c99 237 if (FcPatternGetInteger (p, FC_WIDTH, 0, &numeric) == FcResultMatch)
42984a74
KH		 238 {
239 FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_number (numeric));
240 }
c2801c99 241 if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
99c4d65d 242 {
99c4d65d 243 ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
99c4d65d 244 }
c2801c99
KH		 245 else
246 ASET (entity, FONT_SIZE_INDEX, make_number (0));
42984a74
KH		 247 if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) == FcResultMatch)
248 ASET (entity, FONT_SPACING_INDEX, make_number (numeric));
249 if (FcPatternGetDouble (p, FC_DPI, 0, &dbl) == FcResultMatch)
250 {
251 int dpi = dbl;
252 ASET (entity, FONT_DPI_INDEX, make_number (dpi));
253 }
254 if (FcPatternGetBool (p, FC_SCALABLE, 0, &b) == FcResultMatch
255 && b == FcTrue)
d7782105
KH		 256 {
257 ASET (entity, FONT_SIZE_INDEX, make_number (0));
258 ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
259 }
260 else
261 {
262 /* As this font is not scalable, parhaps this is a BDF or PCF
263 font. */
264 FT_Face ft_face;
265
266 ASET (entity, FONT_ADSTYLE_INDEX, get_adstyle_property (p));
267 if ((ft_library || FT_Init_FreeType (&ft_library) == 0)
268 && FT_New_Face (ft_library, file, index, &ft_face) == 0)
269 {
270 BDF_PropertyRec rec;
271
272 if (FT_Get_BDF_Property (ft_face, "AVERAGE_WIDTH", &rec) == 0
273 && rec.type == BDF_PROPERTY_TYPE_INTEGER)
274 ASET (entity, FONT_AVGWIDTH_INDEX, make_number (rec.u.integer));
275 FT_Done_Face (ft_face);
276 }
277 }
c2801c99 278
4ffe34a4 279 ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
d7782105 280 font_put_extra (entity, QCfont_entity, key);
c2801c99
KH		 281 return entity;
282}
283
42984a74 284
706b6995
KH		 285static Lisp_Object ftfont_generic_family_list;
286
287static Lisp_Object
7d7ad10e 288ftfont_resolve_generic_family (family, pattern)
42984a74 289 Lisp_Object family;
7d7ad10e 290 FcPattern *pattern;
706b6995 291{
318548be 292 Lisp_Object slot;
7d7ad10e 293 FcPattern *match;
318548be 294 FcResult result;
89a95b7c 295 FcLangSet *langset;
706b6995 296
318548be 297 family = Fintern (Fdowncase (SYMBOL_NAME (family)), Qnil);
706b6995
KH		 298 if (EQ (family, Qmono))
299 family = Qmonospace;
300 else if (EQ (family, Qsans) || EQ (family, Qsans__serif))
301 family = Qsans_serif;
302 slot = assq_no_quit (family, ftfont_generic_family_list);
303 if (! CONSP (slot))
42984a74 304 return Qnil;
318548be
KH		 305 if (! EQ (XCDR (slot), Qt))
306 return XCDR (slot);
7d7ad10e 307 pattern = FcPatternDuplicate (pattern);
42984a74
KH		 308 if (! pattern)
309 goto err;
bb658864 310 FcPatternDel (pattern, FC_FOUNDRY);
7d7ad10e
KH		 311 FcPatternDel (pattern, FC_FAMILY);
312 FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (family));
89a95b7c
KH		 313 if (FcPatternGetLangSet (pattern, FC_LANG, 0, &langset) != FcResultMatch)
314 {
315 /* This is to avoid the effect of locale. */
316 langset = FcLangSetCreate ();
317 FcLangSetAdd (langset, "en");
318 FcPatternAddLangSet (pattern, FC_LANG, langset);
319 FcLangSetDestroy (langset);
320 }
42984a74 321 FcConfigSubstitute (NULL, pattern, FcMatchPattern);
318548be
KH		 322 FcDefaultSubstitute (pattern);
323 match = FcFontMatch (NULL, pattern, &result);
324 if (match)
706b6995 325 {
318548be
KH		 326 FcChar8 *fam;
327
328 if (FcPatternGetString (match, FC_FAMILY, 0, &fam) == FcResultMatch)
329 family = intern ((char *) fam);
706b6995 330 }
318548be
KH		 331 else
332 family = Qnil;
333 XSETCDR (slot, family);
318548be 334 if (match) FcPatternDestroy (match);
bf39cdd8 335 err:
42984a74 336 if (pattern) FcPatternDestroy (pattern);
318548be 337 return family;
706b6995
KH		 338}
339
e302a291
KH		 340struct ftfont_cache_data
341{
342 FT_Face ft_face;
343 FcCharSet *fc_charset;
344};
345
346static Lisp_Object
d7782105 347ftfont_lookup_cache (key, cache_for)
e302a291 348 Lisp_Object key;
d7782105 349 enum ftfont_cache_for cache_for;
21988a08 350{
99c4d65d 351 Lisp_Object cache, val, entity;
e302a291 352 struct ftfont_cache_data *cache_data;
21988a08 353
99c4d65d
KH		 354 if (FONT_ENTITY_P (key))
355 {
356 entity = key;
357 val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
358 xassert (CONSP (val));
359 key = XCDR (val);
360 }
361 else
362 entity = Qnil;
363
d7782105
KH		 364 if (NILP (ft_face_cache))
365 cache = Qnil;
366 else
367 cache = Fgethash (key, ft_face_cache, Qnil);
21988a08
KH		 368 if (NILP (cache))
369 {
d7782105
KH		 370 if (NILP (ft_face_cache))
371 {
372 Lisp_Object args[2];
373
374 args[0] = QCtest;
375 args[1] = Qequal;
376 ft_face_cache = Fmake_hash_table (2, args);
377 }
e302a291
KH		 378 cache_data = xmalloc (sizeof (struct ftfont_cache_data));
379 cache_data->ft_face = NULL;
380 cache_data->fc_charset = NULL;
21988a08 381 val = make_save_value (NULL, 0);
e302a291
KH		 382 XSAVE_VALUE (val)->integer = 0;
383 XSAVE_VALUE (val)->pointer = cache_data;
d7782105
KH		 384 cache = Fcons (Qnil, val);
385 Fputhash (key, cache, ft_face_cache);
21988a08
KH		 386 }
387 else
21988a08 388 {
e302a291
KH		 389 val = XCDR (cache);
390 cache_data = XSAVE_VALUE (val)->pointer;
391 }
d7782105
KH		 392
393 if (cache_for == FTFONT_CACHE_FOR_ENTITY)
394 return cache;
395
396 if (cache_for == FTFONT_CACHE_FOR_FACE
397 ? ! cache_data->ft_face : ! cache_data->fc_charset)
e302a291
KH		 398 {
399 char *filename = (char *) SDATA (XCAR (key));
400 int index = XINT (XCDR (key));
21988a08 401
d7782105 402 if (cache_for == FTFONT_CACHE_FOR_FACE)
e302a291
KH		 403 {
404 if (! ft_library
405 && FT_Init_FreeType (&ft_library) != 0)
406 return Qnil;
407 if (FT_New_Face (ft_library, filename, index, &cache_data->ft_face)
408 != 0)
409 return Qnil;
410 }
411 else
412 {
99c4d65d
KH		 413 FcPattern *pat = NULL;
414 FcFontSet *fontset = NULL;
415 FcObjectSet *objset = NULL;
416 FcCharSet *charset = NULL;
e302a291
KH		 417
418 pat = FcPatternBuild (0, FC_FILE, FcTypeString, (FcChar8 *) filename,
419 FC_INDEX, FcTypeInteger, index, NULL);
99c4d65d
KH		 420 if (! pat)
421 goto finish;
422 objset = FcObjectSetBuild (FC_CHARSET, FC_STYLE, NULL);
423 if (! objset)
424 goto finish;
e302a291 425 fontset = FcFontList (NULL, pat, objset);
99c4d65d
KH		 426 if (! fontset)
427 goto finish;
d7782105
KH		 428 if (fontset && fontset->nfont > 0
429 && (FcPatternGetCharSet (fontset->fonts[0], FC_CHARSET, 0,
1c0db158 430 &charset)
d7782105
KH		 431 == FcResultMatch))
432 cache_data->fc_charset = FcCharSetCopy (charset);
e302a291
KH		 433 else
434 cache_data->fc_charset = FcCharSetCreate ();
99c4d65d
KH		 435
436 finish:
437 if (fontset)
438 FcFontSetDestroy (fontset);
439 if (objset)
440 FcObjectSetDestroy (objset);
441 if (pat)
442 FcPatternDestroy (pat);
e302a291 443 }
21988a08
KH		 444 }
445 return cache;
446}
447
e302a291
KH		 448FcCharSet *
449ftfont_get_fc_charset (entity)
450 Lisp_Object entity;
451{
452 Lisp_Object val, cache;
453 struct ftfont_cache_data *cache_data;
454
d7782105 455 cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
e302a291
KH		 456 val = XCDR (cache);
457 cache_data = XSAVE_VALUE (val)->pointer;
458 return cache_data->fc_charset;
459}
460
461#ifdef HAVE_LIBOTF
462static OTF *
463ftfont_get_otf (ftfont_info)
464 struct ftfont_info *ftfont_info;
465{
466 OTF *otf;
467
468 if (ftfont_info->otf)
469 return ftfont_info->otf;
470 if (! ftfont_info->maybe_otf)
471 return NULL;
472 otf = OTF_open_ft_face (ftfont_info->ft_size->face);
473 if (! otf || OTF_get_table (otf, "head") < 0)
474 {
475 if (otf)
476 OTF_close (otf);
477 ftfont_info->maybe_otf = 0;
478 return NULL;
479 }
480 ftfont_info->otf = otf;
481 return otf;
482}
483#endif /* HAVE_LIBOTF */
484
77175228 485static Lisp_Object ftfont_get_cache P_ ((FRAME_PTR));
c2f5bfd6 486static Lisp_Object ftfont_list P_ ((Lisp_Object, Lisp_Object));
8daf5667 487static Lisp_Object ftfont_match P_ ((Lisp_Object, Lisp_Object));
c2f5bfd6 488static Lisp_Object ftfont_list_family P_ ((Lisp_Object));
42984a74 489static Lisp_Object ftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
c2f5bfd6
KH		 490static void ftfont_close P_ ((FRAME_PTR, struct font *));
491static int ftfont_has_char P_ ((Lisp_Object, int));
492static unsigned ftfont_encode_char P_ ((struct font *, int));
493static int ftfont_text_extents P_ ((struct font *, unsigned *, int,
494 struct font_metrics *));
495static int ftfont_get_bitmap P_ ((struct font *, unsigned,
496 struct font_bitmap *, int));
497static int ftfont_anchor_point P_ ((struct font *, unsigned, int,
498 int *, int *));
e302a291 499static Lisp_Object ftfont_otf_capability P_ ((struct font *));
de023c40 500static Lisp_Object ftfont_shape P_ ((Lisp_Object));
3ce80cbe 501
3ce80cbe 502#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
2b33f1ef
KH		 503static int ftfont_variation_glyphs P_ ((struct font *, int c,
504 unsigned variations[256]));
3ce80cbe 505#endif /* HAVE_OTF_GET_VARIATION_GLYPHS */
c2f5bfd6
KH		 506
507struct font_driver ftfont_driver =
508 {
09a56ce4 509 0, /* Qfreetype */
42984a74 510 0, /* case insensitive */
c2f5bfd6 511 ftfont_get_cache,
c2f5bfd6 512 ftfont_list,
8daf5667 513 ftfont_match,
c2f5bfd6 514 ftfont_list_family,
2b33f1ef 515 NULL, /* free_entity */
c2f5bfd6
KH		 516 ftfont_open,
517 ftfont_close,
518 /* We can't draw a text without device dependent functions. */
2b33f1ef
KH		 519 NULL, /* prepare_face */
520 NULL, /* done_face */
c2f5bfd6
KH		 521 ftfont_has_char,
522 ftfont_encode_char,
523 ftfont_text_extents,
524 /* We can't draw a text without device dependent functions. */
2b33f1ef 525 NULL, /* draw */
c2f5bfd6 526 ftfont_get_bitmap,
2b33f1ef
KH		 527 NULL, /* get_bitmap */
528 NULL, /* free_bitmap */
529 NULL, /* get_outline */
c2f5bfd6 530 ftfont_anchor_point,
e302a291
KH		 531#ifdef HAVE_LIBOTF
532 ftfont_otf_capability,
533#else /* not HAVE_LIBOTF */
c2f5bfd6 534 NULL,
e302a291 535#endif /* not HAVE_LIBOTF */
2b33f1ef
KH		 536 NULL, /* otf_drive */
537 NULL, /* start_for_frame */
538 NULL, /* end_for_frame */
637ac44c 539#if defined (HAVE_M17N_FLT) && defined (HAVE_LIBOTF)
2b33f1ef 540 ftfont_shape,
637ac44c 541#else /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
2b33f1ef 542 NULL,
637ac44c 543#endif /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
2b33f1ef 544 NULL, /* check */
3ce80cbe 545
e3869731 546#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
2b33f1ef
KH		 547 ftfont_variation_glyphs
548#else
549 NULL
550#endif
c2f5bfd6
KH		 551 };
552
c2f5bfd6
KH		 553extern Lisp_Object QCname;
554
555static Lisp_Object
77175228
KH		 556ftfont_get_cache (f)
557 FRAME_PTR f;
c2f5bfd6 558{
c2f5bfd6
KH		 559 return freetype_font_cache;
560}
561
21988a08
KH		 562static int
563ftfont_get_charset (registry)
564 Lisp_Object registry;
565{
e302a291
KH		 566 char *str = (char *) SDATA (SYMBOL_NAME (registry));
567 char *re = alloca (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
568 Lisp_Object regexp;
21988a08
KH		 569 int i, j;
570
e302a291
KH		 571 for (i = j = 0; i < SBYTES (SYMBOL_NAME (registry)); i++, j++)
572 {
573 if (str[i] == '.')
574 re[j++] = '\\';
575 else if (str[i] == '*')
576 re[j++] = '.';
577 re[j] = str[i];
578 if (re[j] == '?')
579 re[j] = '.';
580 }
581 re[j] = '\0';
582 regexp = make_unibyte_string (re, j);
21988a08 583 for (i = 0; fc_charset_table[i].name; i++)
e302a291 584 if (fast_c_string_match_ignore_case (regexp, fc_charset_table[i].name) >= 0)
21988a08
KH		 585 break;
586 if (! fc_charset_table[i].name)
587 return -1;
588 if (! fc_charset_table[i].fc_charset)
589 {
d7782105
KH		 590 FcCharSet *charset = FcCharSetCreate ();
591 int *uniquifier = fc_charset_table[i].uniquifier;
21988a08 592
d7782105
KH		 593 if (! charset)
594 return -1;
595 for (j = 0; uniquifier[j]; j++)
596 if (! FcCharSetAddChar (charset, uniquifier[j]))
597 {
598 FcCharSetDestroy (charset);
21988a08 599 return -1;
d7782105
KH		 600 }
601 fc_charset_table[i].fc_charset = charset;
21988a08
KH		 602 }
603 return i;
604}
605
cc63eaf9
KH		 606struct OpenTypeSpec
607{
16963817
KH		 608 Lisp_Object script;
609 unsigned int script_tag, langsys_tag;
cc63eaf9
KH		 610 int nfeatures[2];
611 unsigned int *features[2];
612};
613
7eb5d3d7 614#define OTF_SYM_TAG(SYM, TAG) \
cc63eaf9 615 do { \
7eb5d3d7
KH		 616 unsigned char *p = SDATA (SYMBOL_NAME (SYM)); \
617 TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; \
cc63eaf9
KH		 618 } while (0)
619
7eb5d3d7 620#define OTF_TAG_STR(TAG, P) \
cc63eaf9 621 do { \
7eb5d3d7
KH		 622 (P)[0] = (char) (TAG >> 24); \
623 (P)[1] = (char) ((TAG >> 16) & 0xFF); \
624 (P)[2] = (char) ((TAG >> 8) & 0xFF); \
625 (P)[3] = (char) (TAG & 0xFF); \
16963817 626 (P)[4] = '\0'; \
cc63eaf9
KH		 627 } while (0)
628
e302a291
KH		 629#define OTF_TAG_SYM(SYM, TAG) \
630 do { \
631 char str[5]; \
632 \
633 OTF_TAG_STR (TAG, str); \
634 (SYM) = font_intern_prop (str, 4, 1); \
635 } while (0)
636
637
cc63eaf9
KH		 638static struct OpenTypeSpec *
639ftfont_get_open_type_spec (Lisp_Object otf_spec)
640{
641 struct OpenTypeSpec *spec = malloc (sizeof (struct OpenTypeSpec));
642 Lisp_Object val;
643 int i, j, negative;
644
645 if (! spec)
646 return NULL;
16963817 647 spec->script = XCAR (otf_spec);
43f4f91c 648 if (! NILP (spec->script))
16963817
KH		 649 {
650 OTF_SYM_TAG (spec->script, spec->script_tag);
651 val = assq_no_quit (spec->script, Votf_script_alist);
652 if (CONSP (val) && SYMBOLP (XCDR (val)))
653 spec->script = XCDR (val);
654 else
655 spec->script = Qnil;
656 }
cc63eaf9 657 else
16963817 658 spec->script_tag = 0x44464C54; /* "DFLT" */
cc63eaf9
KH		 659 otf_spec = XCDR (otf_spec);
660 val = XCAR (otf_spec);
661 if (! NILP (val))
16963817 662 OTF_SYM_TAG (val, spec->langsys_tag);
cc63eaf9 663 else
16963817 664 spec->langsys_tag = 0;
cc63eaf9
KH		 665 spec->nfeatures[0] = spec->nfeatures[1] = 0;
666 for (i = 0; i < 2; i++)
667 {
668 Lisp_Object len;
669
2a46904e 670 otf_spec = XCDR (otf_spec);
cc63eaf9
KH		 671 if (NILP (otf_spec))
672 break;
673 val = XCAR (otf_spec);
674 if (NILP (val))
675 continue;
676 len = Flength (val);
677 spec->features[i] = malloc (sizeof (int) * XINT (len));
678 if (! spec->features[i])
679 {
680 if (i > 0 && spec->features[0])
681 free (spec->features[0]);
682 free (spec);
683 return NULL;
684 }
685 for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
686 {
687 if (NILP (XCAR (val)))
688 negative = 1;
689 else
690 {
691 unsigned int tag;
692
693 OTF_SYM_TAG (XCAR (val), tag);
694 spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
695 }
696 }
697 spec->nfeatures[i] = j;
698 }
699 return spec;
700}
701
e302a291 702static FcPattern *ftfont_spec_pattern P_ ((Lisp_Object, char *,
21988a08
KH		 703 struct OpenTypeSpec **));
704
42984a74 705static FcPattern *
e302a291 706ftfont_spec_pattern (spec, otlayout, otspec)
42984a74
KH		 707 Lisp_Object spec;
708 char *otlayout;
709 struct OpenTypeSpec **otspec;
c2f5bfd6 710{
21988a08 711 Lisp_Object tmp, extra;
c2f5bfd6
KH		 712 FcPattern *pattern = NULL;
713 FcCharSet *charset = NULL;
714 FcLangSet *langset = NULL;
42984a74
KH		 715 int n;
716 int dpi = -1;
bc9a2afe 717 int scalable = -1;
42984a74 718 Lisp_Object script = Qnil;
21988a08 719 Lisp_Object registry;
e302a291 720 int fc_charset_idx;
c2f5bfd6 721
42984a74
KH		 722 if ((n = FONT_SLANT_NUMERIC (spec)) >= 0
723 && n < 100)
63565713 724 /* Fontconfig doesn't support reverse-italic/obligue. */
42984a74
KH		 725 return NULL;
726
727 if (INTEGERP (AREF (spec, FONT_DPI_INDEX)))
728 dpi = XINT (AREF (spec, FONT_DPI_INDEX));
42984a74
KH		 729 if (INTEGERP (AREF (spec, FONT_AVGWIDTH_INDEX))
730 && XINT (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
731 scalable = 1;
63565713 732
21988a08
KH		 733 registry = AREF (spec, FONT_REGISTRY_INDEX);
734 if (NILP (registry)
770835fd 735 || EQ (registry, Qascii_0)
21988a08 736 || EQ (registry, Qiso10646_1)
7b649478 737 || EQ (registry, Qunicode_bmp))
e302a291 738 fc_charset_idx = -1;
21988a08 739 else
c2f5bfd6 740 {
7d7ad10e
KH		 741 FcChar8 *lang;
742
e302a291
KH		 743 fc_charset_idx = ftfont_get_charset (registry);
744 if (fc_charset_idx < 0)
42984a74 745 return NULL;
e302a291
KH		 746 charset = fc_charset_table[fc_charset_idx].fc_charset;
747 lang = (FcChar8 *) fc_charset_table[fc_charset_idx].lang;
7d7ad10e
KH		 748 if (lang)
749 {
750 langset = FcLangSetCreate ();
751 if (! langset)
752 goto err;
753 FcLangSetAdd (langset, lang);
754 }
c2f5bfd6
KH		 755 }
756
cc63eaf9 757 otlayout[0] = '\0';
8daf5667
KH		 758 for (extra = AREF (spec, FONT_EXTRA_INDEX);
759 CONSP (extra); extra = XCDR (extra))
c2f5bfd6 760 {
8daf5667
KH		 761 Lisp_Object key, val;
762
42984a74
KH		 763 key = XCAR (XCAR (extra)), val = XCDR (XCAR (extra));
764 if (EQ (key, QCdpi))
765 dpi = XINT (val);
42984a74 766 else if (EQ (key, QClang))
c2f5bfd6 767 {
7d7ad10e
KH		 768 if (! langset)
769 langset = FcLangSetCreate ();
c2f5bfd6
KH		 770 if (! langset)
771 goto err;
8daf5667 772 if (SYMBOLP (val))
c2f5bfd6 773 {
8daf5667 774 if (! FcLangSetAdd (langset, SYMBOL_FcChar8 (val)))
c2f5bfd6
KH		 775 goto err;
776 }
777 else
8daf5667
KH		 778 for (; CONSP (val); val = XCDR (val))
779 if (SYMBOLP (XCAR (val))
780 && ! FcLangSetAdd (langset, SYMBOL_FcChar8 (XCAR (val))))
781 goto err;
c2f5bfd6 782 }
42984a74
KH		 783 else if (EQ (key, QCotf))
784 {
785 *otspec = ftfont_get_open_type_spec (val);
786 if (! *otspec)
787 return NULL;
788 strcat (otlayout, "otlayout:");
789 OTF_TAG_STR ((*otspec)->script_tag, otlayout + 9);
790 script = (*otspec)->script;
791 }
8daf5667
KH		 792 else if (EQ (key, QCscript))
793 script = val;
8daf5667
KH		 794 else if (EQ (key, QCscalable))
795 scalable = ! NILP (val);
796 }
c2f5bfd6 797
8daf5667
KH		 798 if (! NILP (script) && ! charset)
799 {
800 Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
801
7c4bd58d 802 if (CONSP (chars) && CONSP (CDR (chars)))
8daf5667
KH		 803 {
804 charset = FcCharSetCreate ();
805 if (! charset)
806 goto err;
807 for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
808 if (CHARACTERP (XCAR (chars))
809 && ! FcCharSetAddChar (charset, XUINT (XCAR (chars))))
810 goto err;
c2f5bfd6
KH		 811 }
812 }
813
4ffe34a4 814 pattern = FcPatternCreate ();
706b6995
KH		 815 if (! pattern)
816 goto err;
706b6995 817 tmp = AREF (spec, FONT_FOUNDRY_INDEX);
42984a74 818 if (! NILP (tmp)
706b6995
KH		 819 && ! FcPatternAddString (pattern, FC_FOUNDRY, SYMBOL_FcChar8 (tmp)))
820 goto err;
318548be
KH		 821 tmp = AREF (spec, FONT_FAMILY_INDEX);
822 if (! NILP (tmp)
823 && ! FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (tmp)))
824 goto err;
c2f5bfd6
KH		 825 if (charset
826 && ! FcPatternAddCharSet (pattern, FC_CHARSET, charset))
827 goto err;
828 if (langset
829 && ! FcPatternAddLangSet (pattern, FC_LANG, langset))
830 goto err;
bc9a2afe
KH		 831 if (dpi >= 0
832 && ! FcPatternAddDouble (pattern, FC_DPI, dpi))
833 goto err;
bc9a2afe 834 if (scalable >= 0
25a5d05b 835 && ! FcPatternAddBool (pattern, FC_SCALABLE, scalable ? FcTrue : FcFalse))
bc9a2afe 836 goto err;
7d7ad10e 837
42984a74 838 goto finish;
c2f5bfd6 839
42984a74
KH		 840 err:
841 /* We come here because of unexpected error in fontconfig API call
842 (usually insufficient memory). */
843 if (pattern)
844 {
845 FcPatternDestroy (pattern);
846 pattern = NULL;
847 }
848 if (*otspec)
849 {
850 if ((*otspec)->nfeatures[0] > 0)
851 free ((*otspec)->features[0]);
852 if ((*otspec)->nfeatures[1] > 0)
853 free ((*otspec)->features[1]);
854 free (*otspec);
855 *otspec = NULL;
856 }
857
858 finish:
42984a74 859 if (langset) FcLangSetDestroy (langset);
e302a291 860 if (charset && fc_charset_idx < 0) FcCharSetDestroy (charset);
42984a74
KH		 861 return pattern;
862}
863
864static Lisp_Object
865ftfont_list (frame, spec)
866 Lisp_Object frame, spec;
867{
99c4d65d 868 Lisp_Object val = Qnil, family, adstyle;
42984a74
KH		 869 int i;
870 FcPattern *pattern;
871 FcFontSet *fontset = NULL;
872 FcObjectSet *objset = NULL;
7c4bd58d
KH		 873 FcCharSet *charset;
874 Lisp_Object chars = Qnil;
875 FcResult result;
42984a74
KH		 876 char otlayout[15]; /* For "otlayout:XXXX" */
877 struct OpenTypeSpec *otspec = NULL;
5d376f74 878 int spacing = -1;
2a46904e 879
42984a74
KH		 880 if (! fc_initialized)
881 {
882 FcInit ();
883 fc_initialized = 1;
884 }
885
e302a291 886 pattern = ftfont_spec_pattern (spec, otlayout, &otspec);
42984a74
KH		 887 if (! pattern)
888 return Qnil;
7c4bd58d
KH		 889 if (FcPatternGetCharSet (pattern, FC_CHARSET, 0, &charset) != FcResultMatch)
890 {
891 val = assq_no_quit (QCscript, AREF (spec, FONT_EXTRA_INDEX));
892 if (! NILP (val))
893 {
894 val = assq_no_quit (XCDR (val), Vscript_representative_chars);
895 if (CONSP (val) && VECTORP (XCDR (val)))
896 chars = XCDR (val);
897 }
898 val = Qnil;
899 }
5d376f74
KH		 900 if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
901 spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
318548be
KH		 902 family = AREF (spec, FONT_FAMILY_INDEX);
903 if (! NILP (family))
904 {
905 Lisp_Object resolved;
906
7d7ad10e 907 resolved = ftfont_resolve_generic_family (family, pattern);
318548be
KH		 908 if (! NILP (resolved))
909 {
910 FcPatternDel (pattern, FC_FAMILY);
911 if (! FcPatternAddString (pattern, FC_FAMILY,
912 SYMBOL_FcChar8 (resolved)))
913 goto err;
914 }
915 }
99c4d65d
KH		 916 adstyle = AREF (spec, FONT_ADSTYLE_INDEX);
917 if (! NILP (adstyle) && SBYTES (SYMBOL_NAME (adstyle)) == 0)
918 adstyle = Qnil;
706b6995 919 objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
42984a74 920 FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING, FC_SCALABLE,
99c4d65d 921 FC_STYLE, FC_FILE, FC_INDEX,
42984a74
KH		 922#ifdef FC_CAPABILITY
923 FC_CAPABILITY,
924#endif /* FC_CAPABILITY */
4ffe34a4
KH		 925#ifdef FC_FONTFORMAT
926 FC_FONTFORMAT,
927#endif
e907d979 928 NULL);
706b6995
KH		 929 if (! objset)
930 goto err;
7c4bd58d
KH		 931 if (! NILP (chars))
932 FcObjectSetAdd (objset, FC_CHARSET);
42984a74 933
318548be 934 fontset = FcFontList (NULL, pattern, objset);
7c4bd58d
KH		 935 if (! fontset || fontset->nfont == 0)
936 goto finish;
770835fd
KH		 937#if 0
938 /* Need fix because this finds any fonts. */
939 if (fontset->nfont == 0 && ! NILP (family))
940 {
941 /* Try maching with configuration. For instance, the
942 configuration may specify "Nimbus Mono L" as an alias of
943 "Courier". */
944 FcPattern *pat = FcPatternBuild (0, FC_FAMILY, FcTypeString,
945 SYMBOL_FcChar8 (family), NULL);
946 FcChar8 *fam;
947
948 if (FcConfigSubstitute (NULL, pat, FcMatchPattern) == FcTrue)
949 {
950 for (i = 0;
951 FcPatternGetString (pat, FC_FAMILY, i, &fam) == FcResultMatch;
952 i++)
953 {
954 FcPatternDel (pattern, FC_FAMILY);
955 FcPatternAddString (pattern, FC_FAMILY, fam);
956 FcFontSetDestroy (fontset);
957 fontset = FcFontList (NULL, pattern, objset);
1c0db158 958 if (fontset && fontset->nfont > 0)
770835fd
KH		 959 break;
960 }
961 }
962 }
963#endif
318548be 964 for (i = 0; i < fontset->nfont; i++)
bc5f6c42 965 {
318548be 966 Lisp_Object entity;
f63d54dc 967
5d376f74
KH		 968 if (spacing >= 0)
969 {
970 int this;
971
972 if ((FcPatternGetInteger (fontset->fonts[i], FC_SPACING, 0, &this)
973 == FcResultMatch)
974 && spacing != this)
975 continue;
976 }
977
bc5f6c42 978#ifdef FC_CAPABILITY
318548be
KH		 979 if (otlayout[0])
980 {
981 FcChar8 *this;
a85f724a 982
7c4bd58d
KH		 983 if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0, &this)
984 != FcResultMatch
318548be
KH		 985 || ! strstr ((char *) this, otlayout))
986 continue;
987 }
bc5f6c42 988#endif /* FC_CAPABILITY */
cc63eaf9 989#ifdef HAVE_LIBOTF
318548be
KH		 990 if (otspec)
991 {
992 FcChar8 *file;
993 OTF *otf;
994
995 if (FcPatternGetString (fontset->fonts[i], FC_FILE, 0, &file)
996 != FcResultMatch)
997 continue;
998 otf = OTF_open ((char *) file);
999 if (! otf)
1000 continue;
1001 if (OTF_check_features (otf, 1,
1002 otspec->script_tag, otspec->langsys_tag,
1003 otspec->features[0],
1004 otspec->nfeatures[0]) != 1
1005 || OTF_check_features (otf, 0,
1006 otspec->script_tag, otspec->langsys_tag,
1007 otspec->features[1],
1008 otspec->nfeatures[1]) != 1)
1009 continue;
c2f5bfd6 1010 }
318548be 1011#endif /* HAVE_LIBOTF */
7c4bd58d
KH		 1012 if (VECTORP (chars))
1013 {
1014 int j;
1015
1016 if (FcPatternGetCharSet (fontset->fonts[i], FC_CHARSET, 0, &charset)
1017 != FcResultMatch)
1018 continue;
1019 for (j = 0; j < ASIZE (chars); j++)
1020 if (NATNUMP (AREF (chars, j))
1021 && FcCharSetHasChar (charset, XFASTINT (AREF (chars, j))))
1022 break;
1023 if (j == ASIZE (chars))
1024 continue;
1025 }
99c4d65d
KH		 1026 if (! NILP (adstyle))
1027 {
1028 Lisp_Object this_adstyle = get_adstyle_property (fontset->fonts[i]);
1029
1030 if (NILP (this_adstyle)
1031 || xstrcasecmp (SDATA (SYMBOL_NAME (adstyle)),
1032 SDATA (SYMBOL_NAME (this_adstyle))) != 0)
1033 continue;
1034 }
e302a291
KH		 1035 entity = ftfont_pattern_entity (fontset->fonts[i],
1036 AREF (spec, FONT_EXTRA_INDEX));
318548be
KH		 1037 if (! NILP (entity))
1038 val = Fcons (entity, val);
c2f5bfd6 1039 }
7c4bd58d 1040 val = Fnreverse (val);
c2f5bfd6
KH		 1041 goto finish;
1042
1043 err:
1044 /* We come here because of unexpected error in fontconfig API call
706b6995 1045 (usually insufficient memory). */
c2f5bfd6
KH		 1046 val = Qnil;
1047
1048 finish:
678dca3d 1049 FONT_ADD_LOG ("ftfont-list", spec, val);
c2f5bfd6
KH		 1050 if (objset) FcObjectSetDestroy (objset);
1051 if (fontset) FcFontSetDestroy (fontset);
c2f5bfd6 1052 if (pattern) FcPatternDestroy (pattern);
c2f5bfd6
KH		 1053 return val;
1054}
1055
8daf5667
KH		 1056static Lisp_Object
1057ftfont_match (frame, spec)
1058 Lisp_Object frame, spec;
1059{
a3c15670 1060 Lisp_Object entity = Qnil;
42984a74 1061 FcPattern *pattern, *match = NULL;
8daf5667 1062 FcResult result;
42984a74
KH		 1063 char otlayout[15]; /* For "otlayout:XXXX" */
1064 struct OpenTypeSpec *otspec = NULL;
8daf5667
KH		 1065
1066 if (! fc_initialized)
1067 {
1068 FcInit ();
1069 fc_initialized = 1;
1070 }
1071
e302a291 1072 pattern = ftfont_spec_pattern (spec, otlayout, &otspec);
42984a74 1073 if (! pattern)
8daf5667
KH		 1074 return Qnil;
1075
42984a74 1076 if (INTEGERP (AREF (spec, FONT_SIZE_INDEX)))
8daf5667 1077 {
42984a74 1078 FcValue value;
55082642 1079
42984a74
KH		 1080 value.type = FcTypeDouble;
1081 value.u.d = XINT (AREF (spec, FONT_SIZE_INDEX));
1082 FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse);
1083 }
1084 if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
1085 {
1086 FcDefaultSubstitute (pattern);
1087 match = FcFontMatch (NULL, pattern, &result);
1088 if (match)
8daf5667 1089 {
e302a291 1090 entity = ftfont_pattern_entity (match, AREF (spec, FONT_EXTRA_INDEX));
42984a74
KH		 1091 FcPatternDestroy (match);
1092 if (! NILP (AREF (spec, FONT_FAMILY_INDEX))
1093 && NILP (assq_no_quit (AREF (spec, FONT_FAMILY_INDEX),
1094 ftfont_generic_family_list))
1095 && NILP (Fstring_equal (AREF (spec, FONT_FAMILY_INDEX),
1096 AREF (entity, FONT_FAMILY_INDEX))))
1097 entity = Qnil;
8daf5667 1098 }
8daf5667 1099 }
42984a74 1100 FcPatternDestroy (pattern);
8daf5667 1101
678dca3d 1102 FONT_ADD_LOG ("ftfont-match", spec, entity);
8daf5667
KH		 1103 return entity;
1104}
1105
c2f5bfd6
KH		 1106static Lisp_Object
1107ftfont_list_family (frame)
1108 Lisp_Object frame;
1109{
76d126ec 1110 Lisp_Object list = Qnil;
c2f5bfd6
KH		 1111 FcPattern *pattern = NULL;
1112 FcFontSet *fontset = NULL;
1113 FcObjectSet *objset = NULL;
1114 int i;
1115
1116 if (! fc_initialized)
1117 {
1118 FcInit ();
1119 fc_initialized = 1;
1120 }
1121
1122 pattern = FcPatternCreate ();
1123 if (! pattern)
1124 goto finish;
706b6995 1125 objset = FcObjectSetBuild (FC_FAMILY, NULL);
c2f5bfd6
KH		 1126 if (! objset)
1127 goto finish;
1128 fontset = FcFontList (NULL, pattern, objset);
1129 if (! fontset)
1130 goto finish;
1131
c2f5bfd6
KH		 1132 for (i = 0; i < fontset->nfont; i++)
1133 {
1134 FcPattern *pat = fontset->fonts[i];
1135 FcChar8 *str;
1136
1137 if (FcPatternGetString (pat, FC_FAMILY, 0, &str) == FcResultMatch)
42984a74 1138 list = Fcons (intern ((char *) str), list);
c2f5bfd6
KH		 1139 }
1140
1141 finish:
1142 if (objset) FcObjectSetDestroy (objset);
1143 if (fontset) FcFontSetDestroy (fontset);
1144 if (pattern) FcPatternDestroy (pattern);
1145
1146 return list;
1147}
1148
1149
42984a74 1150static Lisp_Object
c2f5bfd6
KH		 1151ftfont_open (f, entity, pixel_size)
1152 FRAME_PTR f;
1153 Lisp_Object entity;
1154 int pixel_size;
1155{
1156 struct ftfont_info *ftfont_info;
1157 struct font *font;
e302a291 1158 struct ftfont_cache_data *cache_data;
c2f5bfd6
KH		 1159 FT_Face ft_face;
1160 FT_Size ft_size;
1161 FT_UInt size;
e302a291 1162 Lisp_Object val, filename, index, cache, font_object;
21988a08 1163 int scalable;
c2f5bfd6 1164 int spacing;
42984a74
KH		 1165 char name[256];
1166 int i, len;
1167 int upEM;
c2f5bfd6 1168
42984a74
KH		 1169 val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
1170 if (! CONSP (val))
1171 return Qnil;
1172 val = XCDR (val);
d7782105 1173 cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_FACE);
21988a08
KH		 1174 if (NILP (cache))
1175 return Qnil;
e302a291
KH		 1176 filename = XCAR (val);
1177 index = XCDR (val);
21988a08 1178 val = XCDR (cache);
e302a291
KH		 1179 cache_data = XSAVE_VALUE (XCDR (cache))->pointer;
1180 ft_face = cache_data->ft_face;
21988a08 1181 if (XSAVE_VALUE (val)->integer > 0)
c2f5bfd6 1182 {
21988a08 1183 /* FT_Face in this cache is already used by the different size. */
c2f5bfd6 1184 if (FT_New_Size (ft_face, &ft_size) != 0)
42984a74 1185 return Qnil;
c2f5bfd6
KH		 1186 if (FT_Activate_Size (ft_size) != 0)
1187 {
1188 FT_Done_Size (ft_size);
42984a74 1189 return Qnil;
c2f5bfd6 1190 }
21988a08
KH		 1191 }
1192 XSAVE_VALUE (val)->integer++;
c2f5bfd6
KH		 1193 size = XINT (AREF (entity, FONT_SIZE_INDEX));
1194 if (size == 0)
1195 size = pixel_size;
1196 if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
1197 {
1198 if (XSAVE_VALUE (val)->integer == 0)
1199 FT_Done_Face (ft_face);
42984a74 1200 return Qnil;
c2f5bfd6
KH		 1201 }
1202
e302a291 1203 font_object = font_make_object (VECSIZE (struct ftfont_info), entity, size);
42984a74 1204 ASET (font_object, FONT_TYPE_INDEX, Qfreetype);
42984a74
KH		 1205 len = font_unparse_xlfd (entity, size, name, 256);
1206 if (len > 0)
3299c552 1207 ASET (font_object, FONT_NAME_INDEX, make_string (name, len));
42984a74
KH		 1208 len = font_unparse_fcname (entity, size, name, 256);
1209 if (len > 0)
3299c552 1210 ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len));
42984a74
KH		 1211 else
1212 ASET (font_object, FONT_FULLNAME_INDEX,
1213 AREF (font_object, FONT_NAME_INDEX));
21988a08 1214 ASET (font_object, FONT_FILE_INDEX, filename);
7d7ad10e 1215 ASET (font_object, FONT_FORMAT_INDEX, ftfont_font_format (NULL, filename));
42984a74
KH		 1216 font = XFONT_OBJECT (font_object);
1217 ftfont_info = (struct ftfont_info *) font;
21988a08 1218 ftfont_info->ft_size = ft_face->size;
e302a291 1219 ftfont_info->index = XINT (index);
0d674a05 1220#ifdef HAVE_LIBOTF
de023c40
KH		 1221 ftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
1222 ftfont_info->otf = NULL;
0d674a05 1223#endif /* HAVE_LIBOTF */
c2f5bfd6
KH		 1224 font->pixel_size = size;
1225 font->driver = &ftfont_driver;
42984a74 1226 font->encoding_charset = font->repertory_charset = -1;
c9c0c429 1227
42984a74 1228 upEM = ft_face->units_per_EM;
21988a08
KH		 1229 scalable = (INTEGERP (AREF (entity, FONT_AVGWIDTH_INDEX))
1230 && XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
42984a74
KH		 1231 if (scalable)
1232 {
1233 font->ascent = ft_face->ascender * size / upEM;
1234 font->descent = - ft_face->descender * size / upEM;
1235 font->height = ft_face->height * size / upEM;
1236 }
1237 else
1238 {
1239 font->ascent = ft_face->size->metrics.ascender >> 6;
1240 font->descent = - ft_face->size->metrics.descender >> 6;
1241 font->height = ft_face->size->metrics.height >> 6;
c9c0c429 1242 }
21988a08
KH		 1243 if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
1244 spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
1245 else
c9c0c429
KH		 1246 spacing = FC_PROPORTIONAL;
1247 if (spacing != FC_PROPORTIONAL)
42984a74
KH		 1248 font->min_width = font->average_width = font->space_width
1249 = (scalable ? ft_face->max_advance_width * size / upEM
1250 : ft_face->size->metrics.max_advance >> 6);
c2f5bfd6
KH		 1251 else
1252 {
42984a74 1253 int n;
c2f5bfd6 1254
42984a74
KH		 1255 font->min_width = font->average_width = font->space_width = 0;
1256 for (i = 32, n = 0; i < 127; i++)
0c26f026 1257 if (FT_Load_Char (ft_face, i, FT_LOAD_DEFAULT) == 0)
42984a74
KH		 1258 {
1259 int this_width = ft_face->glyph->metrics.horiAdvance >> 6;
1260
1261 if (this_width > 0
1262 && (! font->min_width || font->min_width > this_width))
1263 font->min_width = this_width;
1264 if (i == 32)
1265 font->space_width = this_width;
1266 font->average_width += this_width;
1267 n++;
1268 }
1269 if (n > 0)
1270 font->average_width /= n;
c2f5bfd6
KH		 1271 }
1272
42984a74
KH		 1273 font->baseline_offset = 0;
1274 font->relative_compose = 0;
1275 font->default_ascent = 0;
1276 font->vertical_centering = 0;
1277 if (scalable)
1278 {
1279 font->underline_position = -ft_face->underline_position * size / upEM;
0c26f026 1280 font->underline_thickness = ft_face->underline_thickness * size / upEM;
42984a74
KH		 1281 }
1282 else
1283 {
1284 font->underline_position = -1;
1285 font->underline_thickness = 0;
1286 }
c2f5bfd6 1287
42984a74 1288 return font_object;
c2f5bfd6
KH		 1289}
1290
1291static void
1292ftfont_close (f, font)
1293 FRAME_PTR f;
1294 struct font *font;
1295{
1296 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
21988a08 1297 Lisp_Object val, cache;
c2f5bfd6 1298
e302a291 1299 val = Fcons (font->props[FONT_FILE_INDEX], make_number (ftfont_info->index));
d7782105 1300 cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
e302a291 1301 xassert (CONSP (cache));
21988a08 1302 val = XCDR (cache);
c2f5bfd6
KH		 1303 (XSAVE_VALUE (val)->integer)--;
1304 if (XSAVE_VALUE (val)->integer == 0)
de023c40 1305 {
e302a291 1306 struct ftfont_cache_data *cache_data = XSAVE_VALUE (val)->pointer;
21988a08 1307
e302a291 1308 FT_Done_Face (cache_data->ft_face);
de023c40
KH		 1309#ifdef HAVE_LIBOTF
1310 if (ftfont_info->otf)
1311 OTF_close (ftfont_info->otf);
1312#endif
e302a291 1313 cache_data->ft_face = NULL;
de023c40 1314 }
c2f5bfd6
KH		 1315 else
1316 FT_Done_Size (ftfont_info->ft_size);
c2f5bfd6
KH		 1317}
1318
2a46904e 1319static int
7179ce7b
KH		 1320ftfont_has_char (font, c)
1321 Lisp_Object font;
c2f5bfd6
KH		 1322 int c;
1323{
d7782105
KH		 1324 struct charset *cs = NULL;
1325
1326 if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qja)
1327 && charset_jisx0208 >= 0)
1328 cs = CHARSET_FROM_ID (charset_jisx0208);
1329 else if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qko)
1330 && charset_ksc5601 >= 0)
1331 cs = CHARSET_FROM_ID (charset_ksc5601);
1332 if (cs)
1333 return (ENCODE_CHAR (cs, c) != CHARSET_INVALID_CODE (cs));
1334
7179ce7b
KH		 1335 if (FONT_ENTITY_P (font))
1336 {
1337 FcCharSet *charset = ftfont_get_fc_charset (font);
c2f5bfd6 1338
7179ce7b
KH		 1339 return (FcCharSetHasChar (charset, c) == FcTrue);
1340 }
1341 else
1342 {
1343 struct ftfont_info *ftfont_info;
1344
1345 ftfont_info = (struct ftfont_info *) XFONT_OBJECT (font);
1346 return (FT_Get_Char_Index (ftfont_info->ft_size->face, (FT_ULong) c)
1347 != 0);
1348 }
c2f5bfd6
KH		 1349}
1350
1351static unsigned
1352ftfont_encode_char (font, c)
1353 struct font *font;
1354 int c;
1355{
1356 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1357 FT_Face ft_face = ftfont_info->ft_size->face;
1358 FT_ULong charcode = c;
1359 FT_UInt code = FT_Get_Char_Index (ft_face, charcode);
1360
4cec6061 1361 return (code > 0 ? code : FONT_INVALID_CODE);
c2f5bfd6
KH		 1362}
1363
1364static int
1365ftfont_text_extents (font, code, nglyphs, metrics)
1366 struct font *font;
1367 unsigned *code;
1368 int nglyphs;
1369 struct font_metrics *metrics;
1370{
1371 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1372 FT_Face ft_face = ftfont_info->ft_size->face;
1373 int width = 0;
e5d05978 1374 int i, first;
c2f5bfd6
KH		 1375
1376 if (ftfont_info->ft_size != ft_face->size)
1377 FT_Activate_Size (ftfont_info->ft_size);
1378 if (metrics)
1379 bzero (metrics, sizeof (struct font_metrics));
e5d05978 1380 for (i = 0, first = 1; i < nglyphs; i++)
c2f5bfd6
KH		 1381 {
1382 if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)
1383 {
1384 FT_Glyph_Metrics *m = &ft_face->glyph->metrics;
1385
e5d05978
KH		 1386 if (first)
1387 {
1388 if (metrics)
1389 {
1390 metrics->lbearing = m->horiBearingX >> 6;
1391 metrics->rbearing = (m->horiBearingX + m->width) >> 6;
1392 metrics->ascent = m->horiBearingY >> 6;
57d3b93b 1393 metrics->descent = (m->height - m->horiBearingY) >> 6;
e5d05978
KH		 1394 }
1395 first = 0;
1396 }
c2f5bfd6
KH		 1397 if (metrics)
1398 {
1399 if (metrics->lbearing > width + (m->horiBearingX >> 6))
1400 metrics->lbearing = width + (m->horiBearingX >> 6);
1401 if (metrics->rbearing
1402 < width + ((m->horiBearingX + m->width) >> 6))
1403 metrics->rbearing
1404 = width + ((m->horiBearingX + m->width) >> 6);
1405 if (metrics->ascent < (m->horiBearingY >> 6))
1406 metrics->ascent = m->horiBearingY >> 6;
57d3b93b
KH		 1407 if (metrics->descent > ((m->height - m->horiBearingY) >> 6))
1408 metrics->descent = (m->height - m->horiBearingY) >> 6;
c2f5bfd6
KH		 1409 }
1410 width += m->horiAdvance >> 6;
1411 }
1412 else
1413 {
42984a74 1414 width += font->space_width;
c2f5bfd6
KH		 1415 }
1416 }
1417 if (metrics)
1418 metrics->width = width;
1419
1420 return width;
1421}
1422
1423static int
1424ftfont_get_bitmap (font, code, bitmap, bits_per_pixel)
1425 struct font *font;
1426 unsigned code;
1427 struct font_bitmap *bitmap;
1428 int bits_per_pixel;
1429{
1430 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1431 FT_Face ft_face = ftfont_info->ft_size->face;
1432 FT_Int32 load_flags = FT_LOAD_RENDER;
1433
1434 if (ftfont_info->ft_size != ft_face->size)
1435 FT_Activate_Size (ftfont_info->ft_size);
1436 if (bits_per_pixel == 1)
1437 {
1438#ifdef FT_LOAD_TARGET_MONO
1439 load_flags |= FT_LOAD_TARGET_MONO;
1440#else
1441 load_flags |= FT_LOAD_MONOCHROME;
1442#endif
1443 }
1444 else if (bits_per_pixel != 8)
1445 /* We don't support such a rendering. */
1446 return -1;
1447
1448 if (FT_Load_Glyph (ft_face, code, load_flags) != 0)
1449 return -1;
b51e5112
KH		 1450 bitmap->bits_per_pixel
1451 = (ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 1
1452 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY ? 8
1453 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD ? 8
1454 : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V ? 8
1455 : -1);
1456 if (bitmap->bits_per_pixel < 0)
1457 /* We don't suport that kind of pixel mode. */
1458 return -1;
c2f5bfd6
KH		 1459 bitmap->rows = ft_face->glyph->bitmap.rows;
1460 bitmap->width = ft_face->glyph->bitmap.width;
1461 bitmap->pitch = ft_face->glyph->bitmap.pitch;
1462 bitmap->buffer = ft_face->glyph->bitmap.buffer;
1463 bitmap->left = ft_face->glyph->bitmap_left;
1464 bitmap->top = ft_face->glyph->bitmap_top;
1465 bitmap->advance = ft_face->glyph->metrics.horiAdvance >> 6;
1466 bitmap->extra = NULL;
1467
1468 return 0;
1469}
1470
1471static int
1472ftfont_anchor_point (font, code, index, x, y)
1473 struct font *font;
1474 unsigned code;
1475 int index;
1476 int *x, *y;
1477{
1478 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1479 FT_Face ft_face = ftfont_info->ft_size->face;
1480
1481 if (ftfont_info->ft_size != ft_face->size)
1482 FT_Activate_Size (ftfont_info->ft_size);
1483 if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
1484 return -1;
1485 if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
1486 return -1;
1487 if (index >= ft_face->glyph->outline.n_points)
1488 return -1;
1489 *x = ft_face->glyph->outline.points[index].x;
1490 *y = ft_face->glyph->outline.points[index].y;
1491 return 0;
1492}
1493
de023c40 1494#ifdef HAVE_LIBOTF
e302a291
KH		 1495
1496static Lisp_Object
1497ftfont_otf_features (gsub_gpos)
1498 OTF_GSUB_GPOS *gsub_gpos;
1499{
1500 Lisp_Object scripts, langsyses, features, sym;
39356621 1501 int i, j, k, l;
e302a291
KH		 1502
1503 for (scripts = Qnil, i = gsub_gpos->ScriptList.ScriptCount - 1; i >= 0; i--)
1504 {
1505 OTF_Script *otf_script = gsub_gpos->ScriptList.Script + i;
1506
1507 for (langsyses = Qnil, j = otf_script->LangSysCount - 1; j >= -1; j--)
1508 {
1509 OTF_LangSys *otf_langsys;
1510
1511 if (j >= 0)
1512 otf_langsys = otf_script->LangSys + j;
1513 else if (otf_script->DefaultLangSysOffset)
1514 otf_langsys = &otf_script->DefaultLangSys;
1515 else
1516 break;
1517
1518 for (features = Qnil, k = otf_langsys->FeatureCount - 1; k >= 0; k--)
1519 {
39356621 1520 l = otf_langsys->FeatureIndex[k];
064766f2 1521 if (l >= gsub_gpos->FeatureList.FeatureCount)
39356621
KH		 1522 continue;
1523 OTF_TAG_SYM (sym, gsub_gpos->FeatureList.Feature[l].FeatureTag);
e302a291
KH		 1524 features = Fcons (sym, features);
1525 }
1526 if (j >= 0)
1527 OTF_TAG_SYM (sym, otf_script->LangSysRecord[j].LangSysTag);
1528 else
1529 sym = Qnil;
1530 langsyses = Fcons (Fcons (sym, features), langsyses);
1531 }
8510724d 1532
e302a291
KH		 1533 OTF_TAG_SYM (sym, gsub_gpos->ScriptList.Script[i].ScriptTag);
1534 scripts = Fcons (Fcons (sym, langsyses), scripts);
1535 }
1536 return scripts;
1537
1538}
1539
1540
1541static Lisp_Object
1542ftfont_otf_capability (font)
1543 struct font *font;
1544{
1545 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1546 OTF *otf = ftfont_get_otf (ftfont_info);
1547 Lisp_Object gsub_gpos;
1548
1549 if (! otf)
1550 return Qnil;
1551 gsub_gpos = Fcons (Qnil, Qnil);
064766f2
KH		 1552 if (OTF_get_table (otf, "GSUB") == 0
1553 && otf->gsub->FeatureList.FeatureCount > 0)
e302a291 1554 XSETCAR (gsub_gpos, ftfont_otf_features (otf->gsub));
064766f2
KH		 1555 if (OTF_get_table (otf, "GPOS") == 0
1556 && otf->gpos->FeatureList.FeatureCount > 0)
e302a291
KH		 1557 XSETCDR (gsub_gpos, ftfont_otf_features (otf->gpos));
1558 return gsub_gpos;
1559}
1560
de023c40
KH		 1561#ifdef HAVE_M17N_FLT
1562
1563struct MFLTFontFT
1564{
1565 MFLTFont flt_font;
1566 struct font *font;
1567 FT_Face ft_face;
1568 OTF *otf;
1569};
1570
1571static int
1572ftfont_get_glyph_id (font, gstring, from, to)
1573 MFLTFont *font;
1574 MFLTGlyphString *gstring;
1575 int from, to;
1576{
1577 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1578 FT_Face ft_face = flt_font_ft->ft_face;
1579 MFLTGlyph *g;
1580
1581 for (g = gstring->glyphs + from; from < to; g++, from++)
1582 if (! g->encoded)
1583 {
1584 FT_UInt code = FT_Get_Char_Index (ft_face, g->code);
1585
1586 g->code = code > 0 ? code : FONT_INVALID_CODE;
1587 g->encoded = 1;
1588 }
1589 return 0;
1590}
1591
1592static int
1593ftfont_get_metrics (font, gstring, from, to)
1594 MFLTFont *font;
1595 MFLTGlyphString *gstring;
1596 int from, to;
1597{
1598 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1599 FT_Face ft_face = flt_font_ft->ft_face;
1600 MFLTGlyph *g;
1601
1602 for (g = gstring->glyphs + from; from < to; g++, from++)
1603 if (! g->measured)
1604 {
1605 if (g->code != FONT_INVALID_CODE)
1606 {
1607 FT_Glyph_Metrics *m;
1608
1609 if (FT_Load_Glyph (ft_face, g->code, FT_LOAD_DEFAULT) != 0)
1610 abort ();
1611 m = &ft_face->glyph->metrics;
1612
1613 g->lbearing = m->horiBearingX;
1614 g->rbearing = m->horiBearingX + m->width;
1615 g->ascent = m->horiBearingY;
1616 g->descent = m->height - m->horiBearingY;
1617 g->xadv = m->horiAdvance;
1618 }
1619 else
1620 {
1621 g->lbearing = 0;
42984a74 1622 g->rbearing = g->xadv = flt_font_ft->font->space_width << 6;
de023c40
KH		 1623 g->ascent = flt_font_ft->font->ascent << 6;
1624 g->descent = flt_font_ft->font->descent << 6;
1625 }
1626 g->yadv = 0;
1627 g->measured = 1;
1628 }
1629 return 0;
1630}
1631
2a46904e 1632static int
de023c40
KH		 1633ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
1634{
1635 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1636 OTF *otf = flt_font_ft->otf;
1637 OTF_Tag *tags;
1638 int i, n, negative;
1639
1640 for (i = 0; i < 2; i++)
1641 {
1642 if (! spec->features[i])
1643 continue;
1644 for (n = 0; spec->features[i][n]; n++);
1645 tags = alloca (sizeof (OTF_Tag) * n);
1646 for (n = 0, negative = 0; spec->features[i][n]; n++)
1647 {
1648 if (spec->features[i][n] == 0xFFFFFFFF)
1649 negative = 1;
1650 else if (negative)
1651 tags[n - 1] = spec->features[i][n] | 0x80000000;
1652 else
1653 tags[n] = spec->features[i][n];
1654 }
1655 if (n - negative > 0
1656 && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
1657 tags, n - negative) != 1)
1658 return 0;
1659 }
1660 return 1;
1661}
1662
1663#define DEVICE_DELTA(table, size) \
1664 (((size) >= (table).StartSize && (size) <= (table).EndSize) \
1665 ? (table).DeltaValue[(size) - (table).StartSize] << 6 \
1666 : 0)
1667
1668static void
1669adjust_anchor (FT_Face ft_face, OTF_Anchor *anchor,
1670 unsigned code, int x_ppem, int y_ppem, int *x, int *y)
1671{
1672 if (anchor->AnchorFormat == 2)
1673 {
1674 FT_Outline *outline;
1675 int ap = anchor->f.f1.AnchorPoint;
1676
1677 FT_Load_Glyph (ft_face, (FT_UInt) code, FT_LOAD_MONOCHROME);
1678 outline = &ft_face->glyph->outline;
1679 if (ap < outline->n_points)
1680 {
1681 *x = outline->points[ap].x << 6;
1682 *y = outline->points[ap].y << 6;
1683 }
1684 }
1685 else if (anchor->AnchorFormat == 3)
1686 {
d90bfd1c
KH		 1687 if (anchor->f.f2.XDeviceTable.offset
1688 && anchor->f.f2.XDeviceTable.DeltaValue)
de023c40 1689 *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, x_ppem);
d90bfd1c
KH		 1690 if (anchor->f.f2.YDeviceTable.offset
1691 && anchor->f.f2.YDeviceTable.DeltaValue)
de023c40
KH		 1692 *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, y_ppem);
1693 }
1694}
1695
1696static OTF_GlyphString otf_gstring;
1697
2b33f1ef
KH		 1698static void
1699setup_otf_gstring (int size)
1700{
1701 if (otf_gstring.size == 0)
1702 {
c6da7cd2 1703 otf_gstring.glyphs = (OTF_Glyph *) xmalloc (sizeof (OTF_Glyph) * size);
2b33f1ef
KH		 1704 otf_gstring.size = size;
1705 }
1706 else if (otf_gstring.size < size)
1707 {
c6da7cd2
JM		 1708 otf_gstring.glyphs = xrealloc (otf_gstring.glyphs,
1709 sizeof (OTF_Glyph) * size);
2b33f1ef
KH		 1710 otf_gstring.size = size;
1711 }
1712 otf_gstring.used = size;
1713 memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * size);
1714}
1715
1716
2a46904e 1717static int
de023c40
KH		 1718ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
1719 MFLTFont *font;
1720 MFLTOtfSpec *spec;
1721 MFLTGlyphString *in;
1722 int from, to;
1723 MFLTGlyphString *out;
1724 MFLTGlyphAdjustment *adjustment;
1725{
1726 struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1727 FT_Face ft_face = flt_font_ft->ft_face;
1728 OTF *otf = flt_font_ft->otf;
1729 int len = to - from;
1730 int i, j, gidx;
1731 OTF_Glyph *otfg;
1732 char script[5], *langsys = NULL;
1733 char *gsub_features = NULL, *gpos_features = NULL;
1734
1735 if (len == 0)
1736 return from;
1737 OTF_tag_name (spec->script, script);
1738 if (spec->langsys)
1739 {
1740 langsys = alloca (5);
1741 OTF_tag_name (spec->langsys, langsys);
1742 }
1743 for (i = 0; i < 2; i++)
1744 {
1745 char *p;
1746
1747 if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
1748 {
1749 for (j = 0; spec->features[i][j]; j++);
1750 if (i == 0)
1751 p = gsub_features = alloca (6 * j);
1752 else
1753 p = gpos_features = alloca (6 * j);
1754 for (j = 0; spec->features[i][j]; j++)
1755 {
1756 if (spec->features[i][j] == 0xFFFFFFFF)
1757 *p++ = '*', *p++ = ',';
1758 else
1759 {
1760 OTF_tag_name (spec->features[i][j], p);
1761 p[4] = ',';
1762 p += 5;
1763 }
1764 }
1765 *--p = '\0';
1766 }
1767 }
1768
2b33f1ef 1769 setup_otf_gstring (len);
de023c40
KH		 1770 for (i = 0; i < len; i++)
1771 {
1772 otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
1773 otf_gstring.glyphs[i].glyph_id = in->glyphs[from + i].code;
1774 }
1775
1776 OTF_drive_gdef (otf, &otf_gstring);
1777 gidx = out->used;
1778
1779 if (gsub_features)
1780 {
1781 if (OTF_drive_gsub (otf, &otf_gstring, script, langsys, gsub_features)
1782 < 0)
1783 goto simple_copy;
1784 if (out->allocated < out->used + otf_gstring.used)
1785 return -2;
7d2fd545 1786 for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; )
de023c40 1787 {
7d2fd545
KH		 1788 MFLTGlyph *g;
1789 int min_from, max_to;
de023c40
KH		 1790 int j;
1791
7d2fd545 1792 g = out->glyphs + out->used;
de023c40 1793 *g = in->glyphs[from + otfg->f.index.from];
de023c40
KH		 1794 if (g->code != otfg->glyph_id)
1795 {
7d2fd545 1796 g->c = 0;
de023c40
KH		 1797 g->code = otfg->glyph_id;
1798 g->measured = 0;
1799 }
1800 out->used++;
7d2fd545
KH		 1801 min_from = g->from;
1802 max_to = g->to;
1803 if (otfg->f.index.from < otfg->f.index.to)
1804 {
1805 /* OTFG substitutes multiple glyphs in IN. */
1806 for (j = from + otfg->f.index.from + 1;
1807 j <= from + otfg->f.index.to; j++)
1808 {
1809 if (min_from > in->glyphs[j].from)
1810 min_from = in->glyphs[j].from;
1811 if (max_to < in->glyphs[j].to)
1812 max_to = in->glyphs[j].to;
1813 }
1814 g->from = min_from;
1815 g->to = max_to;
1816 }
1817 for (i++, otfg++; (i < otf_gstring.used
1818 && otfg->f.index.from == otfg[-1].f.index.from);
1819 i++, otfg++)
1820 {
1821 g = out->glyphs + out->used;
1822 *g = in->glyphs[from + otfg->f.index.to];
1823 if (g->code != otfg->glyph_id)
1824 {
1825 g->c = 0;
1826 g->code = otfg->glyph_id;
1827 g->measured = 0;
1828 }
1829 out->used++;
1830 }
de023c40
KH		 1831 }
1832 }
1833 else
1834 {
1835 if (out->allocated < out->used + len)
1836 return -2;
1837 for (i = 0; i < len; i++)
1838 out->glyphs[out->used++] = in->glyphs[from + i];
1839 }
1840
1841 if (gpos_features)
1842 {
1843 MFLTGlyph *base = NULL, *mark = NULL, *g;
1844 int x_ppem, y_ppem, x_scale, y_scale;
1845
1846 if (OTF_drive_gpos (otf, &otf_gstring, script, langsys, gpos_features)
1847 < 0)
1848 return to;
1849
1850 x_ppem = ft_face->size->metrics.x_ppem;
1851 y_ppem = ft_face->size->metrics.y_ppem;
1852 x_scale = ft_face->size->metrics.x_scale;
1853 y_scale = ft_face->size->metrics.y_scale;
1854
1855 for (i = 0, otfg = otf_gstring.glyphs, g = out->glyphs + gidx;
1856 i < otf_gstring.used; i++, otfg++, g++)
1857 {
1858 MFLTGlyph *prev;
1859
1860 if (! otfg->glyph_id)
1861 continue;
1862 switch (otfg->positioning_type)
1863 {
1864 case 0:
1865 break;
1866 case 1: /* Single */
1867 case 2: /* Pair */
1868 {
1869 int format = otfg->f.f1.format;
1870
1871 if (format & OTF_XPlacement)
1872 adjustment[i].xoff
1873 = otfg->f.f1.value->XPlacement * x_scale / 0x10000;
1874 if (format & OTF_XPlaDevice)
1875 adjustment[i].xoff
1876 += DEVICE_DELTA (otfg->f.f1.value->XPlaDevice, x_ppem);
1877 if (format & OTF_YPlacement)
1878 adjustment[i].yoff
1879 = - (otfg->f.f1.value->YPlacement * y_scale / 0x10000);
1880 if (format & OTF_YPlaDevice)
1881 adjustment[i].yoff
1882 -= DEVICE_DELTA (otfg->f.f1.value->YPlaDevice, y_ppem);
1883 if (format & OTF_XAdvance)
1884 adjustment[i].xadv
1885 += otfg->f.f1.value->XAdvance * x_scale / 0x10000;
1886 if (format & OTF_XAdvDevice)
1887 adjustment[i].xadv
1888 += DEVICE_DELTA (otfg->f.f1.value->XAdvDevice, x_ppem);
1889 if (format & OTF_YAdvance)
1890 adjustment[i].yadv
1891 += otfg->f.f1.value->YAdvance * y_scale / 0x10000;
1892 if (format & OTF_YAdvDevice)
1893 adjustment[i].yadv
1894 += DEVICE_DELTA (otfg->f.f1.value->YAdvDevice, y_ppem);
1895 adjustment[i].set = 1;
1896 }
1897 break;
1898 case 3: /* Cursive */
1899 /* Not yet supported. */
1900 break;
1901 case 4: /* Mark-to-Base */
1902 case 5: /* Mark-to-Ligature */
1903 if (! base)
1904 break;
1905 prev = base;
1906 goto label_adjust_anchor;
1907 default: /* i.e. case 6 Mark-to-Mark */
1908 if (! mark)
1909 break;
1910 prev = mark;
1911
1912 label_adjust_anchor:
1913 {
1914 int base_x, base_y, mark_x, mark_y;
1915 int this_from, this_to;
1916
1917 base_x = otfg->f.f4.base_anchor->XCoordinate * x_scale / 0x10000;
1918 base_y = otfg->f.f4.base_anchor->YCoordinate * y_scale / 0x10000;
1919 mark_x = otfg->f.f4.mark_anchor->XCoordinate * x_scale / 0x10000;
8510724d 1920 mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;
de023c40
KH		 1921
1922 if (otfg->f.f4.base_anchor->AnchorFormat != 1)
1923 adjust_anchor (ft_face, otfg->f.f4.base_anchor,
1924 prev->code, x_ppem, y_ppem, &base_x, &base_y);
1925 if (otfg->f.f4.mark_anchor->AnchorFormat != 1)
1926 adjust_anchor (ft_face, otfg->f.f4.mark_anchor, g->code,
1927 x_ppem, y_ppem, &mark_x, &mark_y);
1928 adjustment[i].xoff = (base_x - mark_x);
1929 adjustment[i].yoff = - (base_y - mark_y);
1930 adjustment[i].back = (g - prev);
1931 adjustment[i].xadv = 0;
1932 adjustment[i].advance_is_absolute = 1;
1933 adjustment[i].set = 1;
1934 this_from = g->from;
1935 this_to = g->to;
1936 for (j = 0; prev + j < g; j++)
1937 {
1938 if (this_from > prev[j].from)
1939 this_from = prev[j].from;
1940 if (this_to < prev[j].to)
1941 this_to = prev[j].to;
1942 }
1943 for (; prev <= g; prev++)
1944 {
1945 prev->from = this_from;
1946 prev->to = this_to;
1947 }
1948 }
1949 }
1950 if (otfg->GlyphClass == OTF_GlyphClass0)
1951 base = mark = g;
1952 else if (otfg->GlyphClass == OTF_GlyphClassMark)
1953 mark = g;
1954 else
1955 base = g;
1956 }
1957 }
1958 return to;
1959
1960 simple_copy:
1961 if (out->allocated < out->used + len)
1962 return -2;
1963 font->get_metrics (font, in, from, to);
1964 memcpy (out->glyphs + out->used, in->glyphs + from,
1965 sizeof (MFLTGlyph) * len);
1966 out->used += len;
1967 return to;
1968}
1969
1970static MFLTGlyphString gstring;
1971
1972static int m17n_flt_initialized;
1973
1974extern Lisp_Object QCfamily;
1975
990a73f0 1976static Lisp_Object
de023c40
KH		 1977ftfont_shape_by_flt (lgstring, font, ft_face, otf)
1978 Lisp_Object lgstring;
1979 struct font *font;
1980 FT_Face ft_face;
1981 OTF *otf;
1982{
89a95b7c 1983 EMACS_UINT len = LGSTRING_GLYPH_LEN (lgstring);
de023c40
KH		 1984 EMACS_UINT i;
1985 struct MFLTFontFT flt_font_ft;
da2cf488 1986 MFLT *flt = NULL;
2b33f1ef 1987 int with_variation_selector = 0;
de023c40
KH		 1988
1989 if (! m17n_flt_initialized)
1990 {
1991 M17N_INIT ();
1992 m17n_flt_initialized = 1;
1993 }
1994
1995 for (i = 0; i < len; i++)
2b33f1ef
KH		 1996 {
1997 Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
1998 int c;
1999
2000 if (NILP (g))
2001 break;
2002 c = LGLYPH_CHAR (g);
2003 if (CHAR_VARIATION_SELECTOR_P (c))
2004 with_variation_selector++;
2005 }
de023c40 2006 len = i;
2b33f1ef
KH		 2007 if (with_variation_selector)
2008 {
2009 setup_otf_gstring (len);
2010 for (i = 0; i < len; i++)
2011 {
2012 Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
2013
2014 otf_gstring.glyphs[i].c = LGLYPH_CHAR (g);
2015 otf_gstring.glyphs[i].f.index.from = LGLYPH_FROM (g);
2016 otf_gstring.glyphs[i].f.index.to = LGLYPH_TO (g);
2017 }
2018 OTF_drive_cmap (otf, &otf_gstring);
2019 for (i = 0; i < otf_gstring.used; i++)
2020 {
2021 OTF_Glyph *otfg = otf_gstring.glyphs + i;
2022 Lisp_Object g0 = LGSTRING_GLYPH (lgstring, otfg->f.index.from);
2023 Lisp_Object g1 = LGSTRING_GLYPH (lgstring, otfg->f.index.to);
2024
2025 LGLYPH_SET_CODE (g0, otfg->glyph_id);
2026 LGLYPH_SET_TO (g0, LGLYPH_TO (g1));
2027 LGSTRING_SET_GLYPH (lgstring, i, g0);
2028 }
2029 if (len > otf_gstring.used)
2030 {
2031 len = otf_gstring.used;
2032 LGSTRING_SET_GLYPH (lgstring, len, Qnil);
2033 }
2034 }
de023c40
KH		 2035
2036 if (gstring.allocated == 0)
2037 {
2038 gstring.allocated = len * 2;
2039 gstring.glyph_size = sizeof (MFLTGlyph);
c6da7cd2 2040 gstring.glyphs = xmalloc (sizeof (MFLTGlyph) * gstring.allocated);
de023c40
KH		 2041 }
2042 else if (gstring.allocated < len * 2)
2043 {
2044 gstring.allocated = len * 2;
c6da7cd2
JM		 2045 gstring.glyphs = xrealloc (gstring.glyphs,
2046 sizeof (MFLTGlyph) * gstring.allocated);
de023c40 2047 }
2b33f1ef 2048 memset (gstring.glyphs, 0, sizeof (MFLTGlyph) * len);
de023c40 2049 for (i = 0; i < len; i++)
2b33f1ef
KH		 2050 {
2051 Lisp_Object g = LGSTRING_GLYPH (lgstring, i);
2052
2053 gstring.glyphs[i].c = LGLYPH_CHAR (g);
2054 if (with_variation_selector)
2055 {
2056 gstring.glyphs[i].code = LGLYPH_CODE (g);
2057 gstring.glyphs[i].encoded = 1;
2058 }
2059 }
2060
de023c40
KH		 2061 gstring.used = len;
2062 gstring.r2l = 0;
2063
2064 {
2065 Lisp_Object family = Ffont_get (LGSTRING_FONT (lgstring), QCfamily);
2066
2067 if (NILP (family))
2068 flt_font_ft.flt_font.family = Mnil;
2069 else
21988a08 2070 flt_font_ft.flt_font.family
fdf90679 2071 = msymbol ((char *) SDATA (Fdowncase (SYMBOL_NAME (family))));
de023c40
KH		 2072 }
2073 flt_font_ft.flt_font.x_ppem = ft_face->size->metrics.x_ppem;
2074 flt_font_ft.flt_font.y_ppem = ft_face->size->metrics.y_ppem;
2075 flt_font_ft.flt_font.get_glyph_id = ftfont_get_glyph_id;
2076 flt_font_ft.flt_font.get_metrics = ftfont_get_metrics;
2077 flt_font_ft.flt_font.check_otf = ftfont_check_otf;
2078 flt_font_ft.flt_font.drive_otf = ftfont_drive_otf;
2079 flt_font_ft.flt_font.internal = NULL;
2080 flt_font_ft.font = font;
2081 flt_font_ft.ft_face = ft_face;
2082 flt_font_ft.otf = otf;
7bf1bb21
KH		 2083 if (len > 1
2084 && gstring.glyphs[1].c >= 0x300 && gstring.glyphs[1].c <= 0x36F)
da2cf488
KH		 2085 /* A little bit ad hoc. Perhaps, shaper must get script and
2086 language information, and select a proper flt for them
2087 here. */
2088 flt = mflt_get (msymbol ("combining"));
de023c40
KH		 2089 for (i = 0; i < 3; i++)
2090 {
da2cf488 2091 int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, flt);
de023c40
KH		 2092 if (result != -2)
2093 break;
2094 gstring.allocated += gstring.allocated;
c6da7cd2
JM		 2095 gstring.glyphs = xrealloc (gstring.glyphs,
2096 sizeof (MFLTGlyph) * gstring.allocated);
de023c40 2097 }
89a95b7c 2098 if (gstring.used > LGSTRING_GLYPH_LEN (lgstring))
de023c40
KH		 2099 return Qnil;
2100 for (i = 0; i < gstring.used; i++)
2101 {
2102 MFLTGlyph *g = gstring.glyphs + i;
2103
2104 g->from = LGLYPH_FROM (LGSTRING_GLYPH (lgstring, g->from));
2105 g->to = LGLYPH_TO (LGSTRING_GLYPH (lgstring, g->to));
2106 }
2107
2108 for (i = 0; i < gstring.used; i++)
2109 {
2110 Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
2111 MFLTGlyph *g = gstring.glyphs + i;
2112
4cec6061
KH		 2113 if (NILP (lglyph))
2114 {
2115 lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
2116 LGSTRING_SET_GLYPH (lgstring, i, lglyph);
2117 }
de023c40
KH		 2118 LGLYPH_SET_FROM (lglyph, g->from);
2119 LGLYPH_SET_TO (lglyph, g->to);
2120 LGLYPH_SET_CHAR (lglyph, g->c);
2121 LGLYPH_SET_CODE (lglyph, g->code);
2122 LGLYPH_SET_WIDTH (lglyph, g->xadv >> 6);
2123 LGLYPH_SET_LBEARING (lglyph, g->lbearing >> 6);
2124 LGLYPH_SET_RBEARING (lglyph, g->rbearing >> 6);
2125 LGLYPH_SET_ASCENT (lglyph, g->ascent >> 6);
2126 LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
2127 if (g->adjusted)
2128 {
2129 Lisp_Object vec;
2130
2131 vec = Fmake_vector (make_number (3), Qnil);
2132 ASET (vec, 0, make_number (g->xoff >> 6));
2133 ASET (vec, 1, make_number (g->yoff >> 6));
2134 ASET (vec, 2, make_number (g->xadv >> 6));
2135 LGLYPH_SET_ADJUSTMENT (lglyph, vec);
2136 }
2137 }
2138 return make_number (i);
2139}
2140
2141Lisp_Object
2142ftfont_shape (lgstring)
2143 Lisp_Object lgstring;
2144{
2145 struct font *font;
2146 struct ftfont_info *ftfont_info;
e302a291 2147 OTF *otf;
de023c40
KH		 2148
2149 CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
2150 ftfont_info = (struct ftfont_info *) font;
e302a291
KH		 2151 otf = ftfont_get_otf (ftfont_info);
2152 if (! otf)
4cc1c806 2153 return make_number (0);
e302a291 2154 return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face, otf);
de023c40
KH		 2155}
2156
e3869731
KH		 2157#endif /* HAVE_M17N_FLT */
2158
2b33f1ef
KH		 2159#ifdef HAVE_OTF_GET_VARIATION_GLYPHS
2160
2161static int
2162ftfont_variation_glyphs (font, c, variations)
2163 struct font *font;
2164 int c;
2165 unsigned variations[256];
2166{
2167 struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
2168 OTF *otf = ftfont_get_otf (ftfont_info);
2169
2170 if (! otf)
2171 return 0;
2172 return OTF_get_variation_glyphs (otf, c, variations);
2173}
2174
2175#endif /* HAVE_OTF_GET_VARIATION_GLYPHS */
de023c40
KH		 2176#endif /* HAVE_LIBOTF */
2177
0b966021 2178Lisp_Object
7d7ad10e 2179ftfont_font_format (FcPattern *pattern, Lisp_Object filename)
0b966021 2180{
e907d979 2181 FcChar8 *str;
0b966021 2182
e907d979 2183#ifdef FC_FONTFORMAT
7d7ad10e 2184 if (pattern)
719b3d63 2185 {
7d7ad10e
KH		 2186 if (FcPatternGetString (pattern, FC_FONTFORMAT, 0, &str) != FcResultMatch)
2187 return Qnil;
2188 if (strcmp ((char *) str, "TrueType") == 0)
719b3d63 2189 return intern ("truetype");
7d7ad10e 2190 if (strcmp ((char *) str, "Type 1") == 0)
719b3d63 2191 return intern ("type1");
7d7ad10e 2192 if (strcmp ((char *) str, "PCF") == 0)
719b3d63 2193 return intern ("pcf");
7d7ad10e 2194 if (strcmp ((char *) str, "BDF") == 0)
719b3d63
KH		 2195 return intern ("bdf");
2196 }
7d7ad10e
KH		 2197#endif /* FC_FONTFORMAT */
2198 if (STRINGP (filename))
2199 {
2200 int len = SBYTES (filename);
2201
2202 if (len >= 4)
2203 {
2204 str = (FcChar8 *) (SDATA (filename) + len - 4);
2205 if (xstrcasecmp ((char *) str, ".ttf") == 0)
2206 return intern ("truetype");
2207 if (xstrcasecmp ((char *) str, ".pfb") == 0)
2208 return intern ("type1");
2209 if (xstrcasecmp ((char *) str, ".pcf") == 0)
2210 return intern ("pcf");
2211 if (xstrcasecmp ((char *) str, ".bdf") == 0)
2212 return intern ("bdf");
2213 }
2214 }
0b966021
KH		 2215 return intern ("unknown");
2216}
2217
c2f5bfd6
KH		 2218\f
2219void
2220syms_of_ftfont ()
2221{
706b6995
KH		 2222 DEFSYM (Qfreetype, "freetype");
2223 DEFSYM (Qmonospace, "monospace");
2224 DEFSYM (Qsans_serif, "sans-serif");
2225 DEFSYM (Qserif, "serif");
2226 DEFSYM (Qmono, "mono");
2227 DEFSYM (Qsans, "sans");
2228 DEFSYM (Qsans__serif, "sans serif");
2229
c2f5bfd6 2230 staticpro (&freetype_font_cache);
c2801c99 2231 freetype_font_cache = Fcons (Qt, Qnil);
c2f5bfd6 2232
706b6995
KH		 2233 staticpro (&ftfont_generic_family_list);
2234 ftfont_generic_family_list
2235 = Fcons (Fcons (Qmonospace, Qt),
2236 Fcons (Fcons (Qsans_serif, Qt),
2237 Fcons (Fcons (Qsans, Qt), Qnil)));
c2f5bfd6 2238
21988a08
KH		 2239 staticpro (&ft_face_cache);
2240 ft_face_cache = Qnil;
2241
c2f5bfd6
KH		 2242 ftfont_driver.type = Qfreetype;
2243 register_font_driver (&ftfont_driver, NULL);
2244}
885b7d09
MB		 2245
2246/* arch-tag: 7cfa432c-33a6-4988-83d2-a82ed8604aca
2247 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.