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