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