1 /* ftfont.c -- FreeType font driver.
2 Copyright (C) 2006-2014 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
7 This file is part of GNU Emacs.
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
12 (at your option) any later version.
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.
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/>. */
24 #include <fontconfig/fontconfig.h>
25 #include <fontconfig/fcfreetype.h>
28 #include "dispextern.h"
30 #include "blockinput.h"
31 #include "character.h"
34 #include "composite.h"
39 /* Symbolic type of this font-driver. */
40 static Lisp_Object Qfreetype
;
42 /* Fontconfig's generic families and their aliases. */
43 static Lisp_Object Qmonospace
, Qsans_serif
, Qserif
, Qmono
, Qsans
, Qsans__serif
;
45 /* Flag to tell if FcInit is already called or not. */
46 static bool fc_initialized
;
48 /* Handle to a FreeType library instance. */
49 static FT_Library ft_library
;
51 /* Cache for FreeType fonts. */
52 static Lisp_Object freetype_font_cache
;
54 /* Cache for FT_Face and FcCharSet. */
55 static Lisp_Object ft_face_cache
;
57 /* The actual structure for FreeType font that can be cast to struct
64 /* The following four members must be here in this order to be
65 compatible with struct xftfont_info (in xftfont.c). */
66 bool maybe_otf
; /* Flag to tell if this may be OTF or not. */
68 #endif /* HAVE_LIBOTF */
76 FTFONT_CACHE_FOR_FACE
,
77 FTFONT_CACHE_FOR_CHARSET
,
78 FTFONT_CACHE_FOR_ENTITY
81 static Lisp_Object
ftfont_pattern_entity (FcPattern
*, Lisp_Object
);
83 static Lisp_Object
ftfont_resolve_generic_family (Lisp_Object
,
85 static Lisp_Object
ftfont_lookup_cache (Lisp_Object
,
86 enum ftfont_cache_for
);
88 static void ftfont_filter_properties (Lisp_Object font
, Lisp_Object alist
);
90 #define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))
96 /* characters to distinguish the charset from the others */
98 /* additional constraint by language */
101 FcCharSet
*fc_charset
;
102 } fc_charset_table
[] =
103 { { "iso8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 } },
104 { "iso8859-2", { 0x00A0, 0x010E }},
105 { "iso8859-3", { 0x00A0, 0x0108 }},
106 { "iso8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }},
107 { "iso8859-5", { 0x00A0, 0x0401 }},
108 { "iso8859-6", { 0x00A0, 0x060C }},
109 { "iso8859-7", { 0x00A0, 0x0384 }},
110 { "iso8859-8", { 0x00A0, 0x05D0 }},
111 { "iso8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }},
112 { "iso8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }},
113 { "iso8859-11", { 0x00A0, 0x0E01 }},
114 { "iso8859-13", { 0x00A0, 0x201C }},
115 { "iso8859-14", { 0x00A0, 0x0174 }},
116 { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
117 { "iso8859-16", { 0x00A0, 0x0218}},
118 { "gb2312.1980-0", { 0x4E13 }, "zh-cn"},
119 { "big5-0", { 0xF6B1 }, "zh-tw" },
120 { "jisx0208.1983-0", { 0x4E55 }, "ja"},
121 { "ksc5601.1985-0", { 0xAC00 }, "ko"},
122 { "cns11643.1992-1", { 0xFE32 }, "zh-tw"},
123 { "cns11643.1992-2", { 0x4E33, 0x7934 }},
124 { "cns11643.1992-3", { 0x201A9 }},
125 { "cns11643.1992-4", { 0x20057 }},
126 { "cns11643.1992-5", { 0x20000 }},
127 { "cns11643.1992-6", { 0x20003 }},
128 { "cns11643.1992-7", { 0x20055 }},
129 { "gbk-0", { 0x4E06 }, "zh-cn"},
130 { "jisx0212.1990-0", { 0x4E44 }},
131 { "jisx0213.2000-1", { 0xFA10 }, "ja"},
132 { "jisx0213.2000-2", { 0xFA49 }},
133 { "jisx0213.2004-1", { 0x20B9F }},
134 { "viscii1.1-1", { 0x1EA0, 0x1EAE, 0x1ED2 }, "vi"},
135 { "tis620.2529-1", { 0x0E01 }, "th"},
136 { "windows-1251", { 0x0401, 0x0490 }, "ru"},
137 { "koi8-r", { 0x0401, 0x2219 }, "ru"},
138 { "mulelao-1", { 0x0E81 }, "lo"},
139 { "unicode-sip", { 0x20000 }},
143 /* Dirty hack for handing ADSTYLE property.
145 Fontconfig (actually the underlying FreeType) gives such ADSTYLE
146 font property of PCF/BDF fonts in FC_STYLE. And, "Bold",
147 "Oblique", "Italic", or any non-normal SWIDTH property names
148 (e.g. SemiCondensed) are appended. In addition, if there's no
149 ADSTYLE property nor non-normal WEIGHT/SLANT/SWIDTH properties,
150 "Regular" is used for FC_STYLE (see the function
151 pcf_interpret_style in src/pcf/pcfread.c of FreeType).
153 Unfortunately this behavior is not documented, so the following
154 code may fail if FreeType changes the behavior in the future. */
157 get_adstyle_property (FcPattern
*p
)
164 if ((FcPatternGetString (p
, FC_FONTFORMAT
, 0, &fcstr
) == FcResultMatch
)
165 && xstrcasecmp ((char *) fcstr
, "bdf") != 0
166 && xstrcasecmp ((char *) fcstr
, "pcf") != 0)
167 /* Not a BDF nor PCF font. */
170 if (FcPatternGetString (p
, FC_STYLE
, 0, &fcstr
) != FcResultMatch
)
172 str
= (char *) fcstr
;
173 for (end
= str
; *end
&& *end
!= ' '; end
++);
176 char *newstr
= alloca (end
- str
+ 1);
177 memcpy (newstr
, str
, end
- str
);
178 newstr
[end
- str
] = '\0';
179 end
= newstr
+ (end
- str
);
182 if (xstrcasecmp (str
, "Regular") == 0
183 || xstrcasecmp (str
, "Bold") == 0
184 || xstrcasecmp (str
, "Oblique") == 0
185 || xstrcasecmp (str
, "Italic") == 0)
187 adstyle
= font_intern_prop (str
, end
- str
, 1);
188 if (font_style_to_value (FONT_WIDTH_INDEX
, adstyle
, 0) >= 0)
194 ftfont_pattern_entity (FcPattern
*p
, Lisp_Object extra
)
196 Lisp_Object key
, cache
, entity
;
204 if (FcPatternGetString (p
, FC_FILE
, 0, &str
) != FcResultMatch
)
206 if (FcPatternGetInteger (p
, FC_INDEX
, 0, &idx
) != FcResultMatch
)
210 key
= Fcons (build_unibyte_string (file
), make_number (idx
));
211 cache
= ftfont_lookup_cache (key
, FTFONT_CACHE_FOR_ENTITY
);
212 entity
= XCAR (cache
);
215 Lisp_Object val
= font_make_entity ();
218 for (i
= 0; i
< FONT_OBJLIST_INDEX
; i
++)
219 ASET (val
, i
, AREF (entity
, i
));
221 ASET (val
, FONT_EXTRA_INDEX
, Fcopy_sequence (extra
));
222 font_put_extra (val
, QCfont_entity
, key
);
226 entity
= font_make_entity ();
227 XSETCAR (cache
, entity
);
229 ASET (entity
, FONT_TYPE_INDEX
, Qfreetype
);
230 ASET (entity
, FONT_REGISTRY_INDEX
, Qiso10646_1
);
232 if (FcPatternGetString (p
, FC_FOUNDRY
, 0, &str
) == FcResultMatch
)
234 char *s
= (char *) str
;
235 ASET (entity
, FONT_FOUNDRY_INDEX
, font_intern_prop (s
, strlen (s
), 1));
237 if (FcPatternGetString (p
, FC_FAMILY
, 0, &str
) == FcResultMatch
)
239 char *s
= (char *) str
;
240 ASET (entity
, FONT_FAMILY_INDEX
, font_intern_prop (s
, strlen (s
), 1));
242 if (FcPatternGetInteger (p
, FC_WEIGHT
, 0, &numeric
) == FcResultMatch
)
244 if (numeric
>= FC_WEIGHT_REGULAR
&& numeric
< FC_WEIGHT_MEDIUM
)
245 numeric
= FC_WEIGHT_MEDIUM
;
246 FONT_SET_STYLE (entity
, FONT_WEIGHT_INDEX
, make_number (numeric
));
248 if (FcPatternGetInteger (p
, FC_SLANT
, 0, &numeric
) == FcResultMatch
)
251 FONT_SET_STYLE (entity
, FONT_SLANT_INDEX
, make_number (numeric
));
253 if (FcPatternGetInteger (p
, FC_WIDTH
, 0, &numeric
) == FcResultMatch
)
255 FONT_SET_STYLE (entity
, FONT_WIDTH_INDEX
, make_number (numeric
));
257 if (FcPatternGetDouble (p
, FC_PIXEL_SIZE
, 0, &dbl
) == FcResultMatch
)
259 ASET (entity
, FONT_SIZE_INDEX
, make_number (dbl
));
262 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
263 if (FcPatternGetInteger (p
, FC_SPACING
, 0, &numeric
) == FcResultMatch
)
264 ASET (entity
, FONT_SPACING_INDEX
, make_number (numeric
));
265 if (FcPatternGetDouble (p
, FC_DPI
, 0, &dbl
) == FcResultMatch
)
268 ASET (entity
, FONT_DPI_INDEX
, make_number (dpi
));
270 if (FcPatternGetBool (p
, FC_SCALABLE
, 0, &b
) == FcResultMatch
273 ASET (entity
, FONT_SIZE_INDEX
, make_number (0));
274 ASET (entity
, FONT_AVGWIDTH_INDEX
, make_number (0));
278 /* As this font is not scalable, perhaps this is a BDF or PCF
282 ASET (entity
, FONT_ADSTYLE_INDEX
, get_adstyle_property (p
));
283 if ((ft_library
|| FT_Init_FreeType (&ft_library
) == 0)
284 && FT_New_Face (ft_library
, file
, idx
, &ft_face
) == 0)
288 if (FT_Get_BDF_Property (ft_face
, "AVERAGE_WIDTH", &rec
) == 0
289 && rec
.type
== BDF_PROPERTY_TYPE_INTEGER
)
290 ASET (entity
, FONT_AVGWIDTH_INDEX
, make_number (rec
.u
.integer
));
291 FT_Done_Face (ft_face
);
295 ASET (entity
, FONT_EXTRA_INDEX
, Fcopy_sequence (extra
));
296 font_put_extra (entity
, QCfont_entity
, key
);
301 static Lisp_Object ftfont_generic_family_list
;
304 ftfont_resolve_generic_family (Lisp_Object family
, FcPattern
*pattern
)
311 family
= Fintern (Fdowncase (SYMBOL_NAME (family
)), Qnil
);
312 if (EQ (family
, Qmono
))
314 else if (EQ (family
, Qsans
) || EQ (family
, Qsans__serif
))
315 family
= Qsans_serif
;
316 slot
= assq_no_quit (family
, ftfont_generic_family_list
);
319 if (! EQ (XCDR (slot
), Qt
))
321 pattern
= FcPatternDuplicate (pattern
);
324 FcPatternDel (pattern
, FC_FOUNDRY
);
325 FcPatternDel (pattern
, FC_FAMILY
);
326 FcPatternAddString (pattern
, FC_FAMILY
, SYMBOL_FcChar8 (family
));
327 if (FcPatternGetLangSet (pattern
, FC_LANG
, 0, &langset
) != FcResultMatch
)
329 /* This is to avoid the effect of locale. */
330 static const FcChar8 lang
[] = "en";
331 langset
= FcLangSetCreate ();
332 FcLangSetAdd (langset
, lang
);
333 FcPatternAddLangSet (pattern
, FC_LANG
, langset
);
334 FcLangSetDestroy (langset
);
336 FcConfigSubstitute (NULL
, pattern
, FcMatchPattern
);
337 FcDefaultSubstitute (pattern
);
338 match
= FcFontMatch (NULL
, pattern
, &result
);
343 if (FcPatternGetString (match
, FC_FAMILY
, 0, &fam
) == FcResultMatch
)
344 family
= intern ((char *) fam
);
348 XSETCDR (slot
, family
);
349 if (match
) FcPatternDestroy (match
);
351 if (pattern
) FcPatternDestroy (pattern
);
355 struct ftfont_cache_data
358 FcCharSet
*fc_charset
;
362 ftfont_lookup_cache (Lisp_Object key
, enum ftfont_cache_for cache_for
)
364 Lisp_Object cache
, val
, entity
;
365 struct ftfont_cache_data
*cache_data
;
367 if (FONT_ENTITY_P (key
))
370 val
= assq_no_quit (QCfont_entity
, AREF (entity
, FONT_EXTRA_INDEX
));
371 eassert (CONSP (val
));
377 if (NILP (ft_face_cache
))
380 cache
= Fgethash (key
, ft_face_cache
, Qnil
);
383 if (NILP (ft_face_cache
))
389 ft_face_cache
= Fmake_hash_table (2, args
);
391 cache_data
= xmalloc (sizeof *cache_data
);
392 cache_data
->ft_face
= NULL
;
393 cache_data
->fc_charset
= NULL
;
394 val
= make_save_ptr_int (cache_data
, 0);
395 cache
= Fcons (Qnil
, val
);
396 Fputhash (key
, cache
, ft_face_cache
);
401 cache_data
= XSAVE_POINTER (val
, 0);
404 if (cache_for
== FTFONT_CACHE_FOR_ENTITY
)
407 if (cache_for
== FTFONT_CACHE_FOR_FACE
408 ? ! cache_data
->ft_face
: ! cache_data
->fc_charset
)
410 char *filename
= SSDATA (XCAR (key
));
411 int idx
= XINT (XCDR (key
));
413 if (cache_for
== FTFONT_CACHE_FOR_FACE
)
416 && FT_Init_FreeType (&ft_library
) != 0)
418 if (FT_New_Face (ft_library
, filename
, idx
, &cache_data
->ft_face
)
424 FcPattern
*pat
= NULL
;
425 FcFontSet
*fontset
= NULL
;
426 FcObjectSet
*objset
= NULL
;
427 FcCharSet
*charset
= NULL
;
429 pat
= FcPatternBuild (0, FC_FILE
, FcTypeString
, (FcChar8
*) filename
,
430 FC_INDEX
, FcTypeInteger
, idx
, NULL
);
433 objset
= FcObjectSetBuild (FC_CHARSET
, FC_STYLE
, NULL
);
436 fontset
= FcFontList (NULL
, pat
, objset
);
439 if (fontset
&& fontset
->nfont
> 0
440 && (FcPatternGetCharSet (fontset
->fonts
[0], FC_CHARSET
, 0,
443 cache_data
->fc_charset
= FcCharSetCopy (charset
);
445 cache_data
->fc_charset
= FcCharSetCreate ();
449 FcFontSetDestroy (fontset
);
451 FcObjectSetDestroy (objset
);
453 FcPatternDestroy (pat
);
460 ftfont_get_fc_charset (Lisp_Object entity
)
462 Lisp_Object val
, cache
;
463 struct ftfont_cache_data
*cache_data
;
465 cache
= ftfont_lookup_cache (entity
, FTFONT_CACHE_FOR_CHARSET
);
467 cache_data
= XSAVE_POINTER (val
, 0);
468 return cache_data
->fc_charset
;
473 ftfont_get_otf (struct ftfont_info
*ftfont_info
)
477 if (ftfont_info
->otf
)
478 return ftfont_info
->otf
;
479 if (! ftfont_info
->maybe_otf
)
481 otf
= OTF_open_ft_face (ftfont_info
->ft_size
->face
);
482 if (! otf
|| OTF_get_table (otf
, "head") < 0)
486 ftfont_info
->maybe_otf
= 0;
489 ftfont_info
->otf
= otf
;
492 #endif /* HAVE_LIBOTF */
494 static Lisp_Object
ftfont_get_cache (struct frame
*);
495 static Lisp_Object
ftfont_list (struct frame
*, Lisp_Object
);
496 static Lisp_Object
ftfont_match (struct frame
*, Lisp_Object
);
497 static Lisp_Object
ftfont_list_family (struct frame
*);
498 static Lisp_Object
ftfont_open (struct frame
*, Lisp_Object
, int);
499 static void ftfont_close (struct font
*);
500 static int ftfont_has_char (Lisp_Object
, int);
501 static unsigned ftfont_encode_char (struct font
*, int);
502 static int ftfont_text_extents (struct font
*, unsigned *, int,
503 struct font_metrics
*);
504 static int ftfont_get_bitmap (struct font
*, unsigned,
505 struct font_bitmap
*, int);
506 static int ftfont_anchor_point (struct font
*, unsigned, int,
509 static Lisp_Object
ftfont_otf_capability (struct font
*);
510 # ifdef HAVE_M17N_FLT
511 static Lisp_Object
ftfont_shape (Lisp_Object
);
515 #ifdef HAVE_OTF_GET_VARIATION_GLYPHS
516 static int ftfont_variation_glyphs (struct font
*, int c
,
517 unsigned variations
[256]);
518 #endif /* HAVE_OTF_GET_VARIATION_GLYPHS */
520 struct font_driver ftfont_driver
=
522 LISP_INITIALLY_ZERO
, /* Qfreetype */
523 0, /* case insensitive */
528 NULL
, /* free_entity */
531 /* We can't draw a text without device dependent functions. */
532 NULL
, /* prepare_face */
533 NULL
, /* done_face */
537 /* We can't draw a text without device dependent functions. */
540 NULL
, /* free_bitmap */
543 ftfont_otf_capability
,
544 #else /* not HAVE_LIBOTF */
546 #endif /* not HAVE_LIBOTF */
547 NULL
, /* otf_drive */
548 NULL
, /* start_for_frame */
549 NULL
, /* end_for_frame */
550 #if defined (HAVE_M17N_FLT) && defined (HAVE_LIBOTF)
552 #else /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
554 #endif /* not (HAVE_M17N_FLT && HAVE_LIBOTF) */
557 #ifdef HAVE_OTF_GET_VARIATION_GLYPHS
558 ftfont_variation_glyphs
,
563 ftfont_filter_properties
, /* filter_properties */
567 ftfont_get_cache (struct frame
*f
)
569 return freetype_font_cache
;
573 ftfont_get_charset (Lisp_Object registry
)
575 char *str
= SSDATA (SYMBOL_NAME (registry
));
576 char *re
= alloca (SBYTES (SYMBOL_NAME (registry
)) * 2 + 1);
580 for (i
= j
= 0; i
< SBYTES (SYMBOL_NAME (registry
)); i
++, j
++)
584 else if (str
[i
] == '*')
591 regexp
= make_unibyte_string (re
, j
);
592 for (i
= 0; fc_charset_table
[i
].name
; i
++)
593 if (fast_c_string_match_ignore_case
594 (regexp
, fc_charset_table
[i
].name
,
595 strlen (fc_charset_table
[i
].name
)) >= 0)
597 if (! fc_charset_table
[i
].name
)
599 if (! fc_charset_table
[i
].fc_charset
)
601 FcCharSet
*charset
= FcCharSetCreate ();
602 int *uniquifier
= fc_charset_table
[i
].uniquifier
;
606 for (j
= 0; uniquifier
[j
]; j
++)
607 if (! FcCharSetAddChar (charset
, uniquifier
[j
]))
609 FcCharSetDestroy (charset
);
612 fc_charset_table
[i
].fc_charset
= charset
;
620 unsigned int script_tag
, langsys_tag
;
622 unsigned int *features
[2];
625 #define OTF_SYM_TAG(SYM, TAG) \
627 unsigned char *p = SDATA (SYMBOL_NAME (SYM)); \
628 TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; \
631 #define OTF_TAG_STR(TAG, P) \
633 (P)[0] = (char) (TAG >> 24); \
634 (P)[1] = (char) ((TAG >> 16) & 0xFF); \
635 (P)[2] = (char) ((TAG >> 8) & 0xFF); \
636 (P)[3] = (char) (TAG & 0xFF); \
641 #define OTF_TAG_SYM(SYM, TAG) \
645 OTF_TAG_STR (TAG, str); \
646 (SYM) = font_intern_prop (str, 4, 1); \
651 static struct OpenTypeSpec
*
652 ftfont_get_open_type_spec (Lisp_Object otf_spec
)
654 struct OpenTypeSpec
*spec
= malloc (sizeof *spec
);
661 spec
->script
= XCAR (otf_spec
);
662 if (! NILP (spec
->script
))
664 OTF_SYM_TAG (spec
->script
, spec
->script_tag
);
665 val
= assq_no_quit (spec
->script
, Votf_script_alist
);
666 if (CONSP (val
) && SYMBOLP (XCDR (val
)))
667 spec
->script
= XCDR (val
);
672 spec
->script_tag
= 0x44464C54; /* "DFLT" */
673 otf_spec
= XCDR (otf_spec
);
674 spec
->langsys_tag
= 0;
675 if (! NILP (otf_spec
))
677 val
= XCAR (otf_spec
);
679 OTF_SYM_TAG (val
, spec
->langsys_tag
);
680 otf_spec
= XCDR (otf_spec
);
682 spec
->nfeatures
[0] = spec
->nfeatures
[1] = 0;
683 for (i
= 0; i
< 2 && ! NILP (otf_spec
); i
++, otf_spec
= XCDR (otf_spec
))
687 val
= XCAR (otf_spec
);
692 (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (int) < XINT (len
)
694 : malloc (XINT (len
) * sizeof *spec
->features
[i
]));
695 if (! spec
->features
[i
])
697 if (i
> 0 && spec
->features
[0])
698 free (spec
->features
[0]);
702 for (j
= 0, negative
= 0; CONSP (val
); val
= XCDR (val
))
704 if (NILP (XCAR (val
)))
710 OTF_SYM_TAG (XCAR (val
), tag
);
711 spec
->features
[i
][j
++] = negative
? tag
& 0x80000000 : tag
;
714 spec
->nfeatures
[i
] = j
;
720 ftfont_spec_pattern (Lisp_Object spec
, char *otlayout
, struct OpenTypeSpec
**otspec
, const char **langname
)
722 Lisp_Object tmp
, extra
;
723 FcPattern
*pattern
= NULL
;
724 FcCharSet
*charset
= NULL
;
725 FcLangSet
*langset
= NULL
;
729 Lisp_Object script
= Qnil
;
730 Lisp_Object registry
;
733 if ((n
= FONT_SLANT_NUMERIC (spec
)) >= 0
735 /* Fontconfig doesn't support reverse-italic/oblique. */
738 if (INTEGERP (AREF (spec
, FONT_DPI_INDEX
)))
739 dpi
= XINT (AREF (spec
, FONT_DPI_INDEX
));
740 if (INTEGERP (AREF (spec
, FONT_AVGWIDTH_INDEX
))
741 && XINT (AREF (spec
, FONT_AVGWIDTH_INDEX
)) == 0)
744 registry
= AREF (spec
, FONT_REGISTRY_INDEX
);
746 || EQ (registry
, Qascii_0
)
747 || EQ (registry
, Qiso10646_1
)
748 || EQ (registry
, Qunicode_bmp
))
754 fc_charset_idx
= ftfont_get_charset (registry
);
755 if (fc_charset_idx
< 0)
757 charset
= fc_charset_table
[fc_charset_idx
].fc_charset
;
758 *langname
= fc_charset_table
[fc_charset_idx
].lang
;
759 lang
= (FcChar8
*) *langname
;
762 langset
= FcLangSetCreate ();
765 FcLangSetAdd (langset
, lang
);
770 for (extra
= AREF (spec
, FONT_EXTRA_INDEX
);
771 CONSP (extra
); extra
= XCDR (extra
))
773 Lisp_Object key
, val
;
775 key
= XCAR (XCAR (extra
)), val
= XCDR (XCAR (extra
));
781 else if (EQ (key
, QClang
))
784 langset
= FcLangSetCreate ();
789 if (! FcLangSetAdd (langset
, SYMBOL_FcChar8 (val
)))
793 for (; CONSP (val
); val
= XCDR (val
))
794 if (SYMBOLP (XCAR (val
))
795 && ! FcLangSetAdd (langset
, SYMBOL_FcChar8 (XCAR (val
))))
798 else if (EQ (key
, QCotf
))
802 *otspec
= ftfont_get_open_type_spec (val
);
805 strcat (otlayout
, "otlayout:");
806 OTF_TAG_STR ((*otspec
)->script_tag
, otlayout
+ 9);
807 script
= (*otspec
)->script
;
810 else if (EQ (key
, QCscript
))
812 else if (EQ (key
, QCscalable
))
813 scalable
= ! NILP (val
);
816 if (! NILP (script
) && ! charset
)
818 Lisp_Object chars
= assq_no_quit (script
, Vscript_representative_chars
);
820 if (CONSP (chars
) && CONSP (CDR (chars
)))
822 charset
= FcCharSetCreate ();
825 for (chars
= XCDR (chars
); CONSP (chars
); chars
= XCDR (chars
))
826 if (CHARACTERP (XCAR (chars
))
827 && ! FcCharSetAddChar (charset
, XFASTINT (XCAR (chars
))))
832 pattern
= FcPatternCreate ();
835 tmp
= AREF (spec
, FONT_FOUNDRY_INDEX
);
837 && ! FcPatternAddString (pattern
, FC_FOUNDRY
, SYMBOL_FcChar8 (tmp
)))
839 tmp
= AREF (spec
, FONT_FAMILY_INDEX
);
841 && ! FcPatternAddString (pattern
, FC_FAMILY
, SYMBOL_FcChar8 (tmp
)))
844 && ! FcPatternAddCharSet (pattern
, FC_CHARSET
, charset
))
847 && ! FcPatternAddLangSet (pattern
, FC_LANG
, langset
))
850 && ! FcPatternAddDouble (pattern
, FC_DPI
, dpi
))
853 && ! FcPatternAddBool (pattern
, FC_SCALABLE
, scalable
? FcTrue
: FcFalse
))
859 /* We come here because of unexpected error in fontconfig API call
860 (usually insufficient memory). */
863 FcPatternDestroy (pattern
);
868 if ((*otspec
)->nfeatures
[0] > 0)
869 free ((*otspec
)->features
[0]);
870 if ((*otspec
)->nfeatures
[1] > 0)
871 free ((*otspec
)->features
[1]);
877 if (langset
) FcLangSetDestroy (langset
);
878 if (charset
&& fc_charset_idx
< 0) FcCharSetDestroy (charset
);
883 ftfont_list (struct frame
*f
, Lisp_Object spec
)
885 Lisp_Object val
= Qnil
, family
, adstyle
;
888 FcFontSet
*fontset
= NULL
;
889 FcObjectSet
*objset
= NULL
;
891 Lisp_Object chars
= Qnil
;
892 char otlayout
[15]; /* For "otlayout:XXXX" */
893 struct OpenTypeSpec
*otspec
= NULL
;
895 const char *langname
= NULL
;
897 if (! fc_initialized
)
903 pattern
= ftfont_spec_pattern (spec
, otlayout
, &otspec
, &langname
);
906 if (FcPatternGetCharSet (pattern
, FC_CHARSET
, 0, &charset
) != FcResultMatch
)
908 val
= assq_no_quit (QCscript
, AREF (spec
, FONT_EXTRA_INDEX
));
911 val
= assq_no_quit (XCDR (val
), Vscript_representative_chars
);
912 if (CONSP (val
) && VECTORP (XCDR (val
)))
917 if (INTEGERP (AREF (spec
, FONT_SPACING_INDEX
)))
918 spacing
= XINT (AREF (spec
, FONT_SPACING_INDEX
));
919 family
= AREF (spec
, FONT_FAMILY_INDEX
);
922 Lisp_Object resolved
;
924 resolved
= ftfont_resolve_generic_family (family
, pattern
);
925 if (! NILP (resolved
))
927 FcPatternDel (pattern
, FC_FAMILY
);
928 if (! FcPatternAddString (pattern
, FC_FAMILY
,
929 SYMBOL_FcChar8 (resolved
)))
933 adstyle
= AREF (spec
, FONT_ADSTYLE_INDEX
);
934 if (! NILP (adstyle
) && SBYTES (SYMBOL_NAME (adstyle
)) == 0)
936 objset
= FcObjectSetBuild (FC_FOUNDRY
, FC_FAMILY
, FC_WEIGHT
, FC_SLANT
,
937 FC_WIDTH
, FC_PIXEL_SIZE
, FC_SPACING
, FC_SCALABLE
,
938 FC_STYLE
, FC_FILE
, FC_INDEX
,
941 #endif /* FC_CAPABILITY */
949 FcObjectSetAdd (objset
, FC_CHARSET
);
951 fontset
= FcFontList (NULL
, pattern
, objset
);
952 if (! fontset
|| fontset
->nfont
== 0)
955 /* Need fix because this finds any fonts. */
956 if (fontset
->nfont
== 0 && ! NILP (family
))
958 /* Try matching with configuration. For instance, the
959 configuration may specify "Nimbus Mono L" as an alias of
961 FcPattern
*pat
= FcPatternBuild (0, FC_FAMILY
, FcTypeString
,
962 SYMBOL_FcChar8 (family
), NULL
);
965 if (FcConfigSubstitute (NULL
, pat
, FcMatchPattern
) == FcTrue
)
968 FcPatternGetString (pat
, FC_FAMILY
, i
, &fam
) == FcResultMatch
;
971 FcPatternDel (pattern
, FC_FAMILY
);
972 FcPatternAddString (pattern
, FC_FAMILY
, fam
);
973 FcFontSetDestroy (fontset
);
974 fontset
= FcFontList (NULL
, pattern
, objset
);
975 if (fontset
&& fontset
->nfont
> 0)
981 for (i
= 0; i
< fontset
->nfont
; i
++)
989 if ((FcPatternGetInteger (fontset
->fonts
[i
], FC_SPACING
, 0, &this)
1000 if (FcPatternGetString (fontset
->fonts
[i
], FC_CAPABILITY
, 0, &this)
1002 || ! strstr ((char *) this, otlayout
))
1005 #endif /* FC_CAPABILITY */
1013 if (FcPatternGetString (fontset
->fonts
[i
], FC_FILE
, 0, &file
)
1016 otf
= OTF_open ((char *) file
);
1019 passed
= (OTF_check_features (otf
, 1, otspec
->script_tag
,
1020 otspec
->langsys_tag
,
1021 otspec
->features
[0],
1022 otspec
->nfeatures
[0]) == 1
1023 && OTF_check_features (otf
, 0, otspec
->script_tag
,
1024 otspec
->langsys_tag
,
1025 otspec
->features
[1],
1026 otspec
->nfeatures
[1]) == 1);
1031 #endif /* HAVE_LIBOTF */
1032 if (VECTORP (chars
))
1036 if (FcPatternGetCharSet (fontset
->fonts
[i
], FC_CHARSET
, 0, &charset
)
1039 for (j
= 0; j
< ASIZE (chars
); j
++)
1040 if (TYPE_RANGED_INTEGERP (FcChar32
, AREF (chars
, j
))
1041 && FcCharSetHasChar (charset
, XFASTINT (AREF (chars
, j
))))
1043 if (j
== ASIZE (chars
))
1046 if (! NILP (adstyle
) || langname
)
1048 Lisp_Object this_adstyle
= get_adstyle_property (fontset
->fonts
[i
]);
1050 if (! NILP (adstyle
)
1051 && (NILP (this_adstyle
)
1052 || xstrcasecmp (SSDATA (SYMBOL_NAME (adstyle
)),
1053 SSDATA (SYMBOL_NAME (this_adstyle
))) != 0))
1056 && ! NILP (this_adstyle
)
1057 && xstrcasecmp (langname
, SSDATA (SYMBOL_NAME (this_adstyle
))))
1060 entity
= ftfont_pattern_entity (fontset
->fonts
[i
],
1061 AREF (spec
, FONT_EXTRA_INDEX
));
1062 if (! NILP (entity
))
1063 val
= Fcons (entity
, val
);
1065 val
= Fnreverse (val
);
1069 /* We come here because of unexpected error in fontconfig API call
1070 (usually insufficient memory). */
1074 FONT_ADD_LOG ("ftfont-list", spec
, val
);
1075 if (objset
) FcObjectSetDestroy (objset
);
1076 if (fontset
) FcFontSetDestroy (fontset
);
1077 if (pattern
) FcPatternDestroy (pattern
);
1082 ftfont_match (struct frame
*f
, Lisp_Object spec
)
1084 Lisp_Object entity
= Qnil
;
1085 FcPattern
*pattern
, *match
= NULL
;
1087 char otlayout
[15]; /* For "otlayout:XXXX" */
1088 struct OpenTypeSpec
*otspec
= NULL
;
1089 const char *langname
= NULL
;
1091 if (! fc_initialized
)
1097 pattern
= ftfont_spec_pattern (spec
, otlayout
, &otspec
, &langname
);
1101 if (INTEGERP (AREF (spec
, FONT_SIZE_INDEX
)))
1105 value
.type
= FcTypeDouble
;
1106 value
.u
.d
= XINT (AREF (spec
, FONT_SIZE_INDEX
));
1107 FcPatternAdd (pattern
, FC_PIXEL_SIZE
, value
, FcFalse
);
1109 if (FcConfigSubstitute (NULL
, pattern
, FcMatchPattern
) == FcTrue
)
1111 FcDefaultSubstitute (pattern
);
1112 match
= FcFontMatch (NULL
, pattern
, &result
);
1115 entity
= ftfont_pattern_entity (match
, AREF (spec
, FONT_EXTRA_INDEX
));
1116 FcPatternDestroy (match
);
1117 if (! NILP (AREF (spec
, FONT_FAMILY_INDEX
))
1118 && NILP (assq_no_quit (AREF (spec
, FONT_FAMILY_INDEX
),
1119 ftfont_generic_family_list
))
1120 && NILP (Fstring_equal (AREF (spec
, FONT_FAMILY_INDEX
),
1121 AREF (entity
, FONT_FAMILY_INDEX
))))
1125 FcPatternDestroy (pattern
);
1127 FONT_ADD_LOG ("ftfont-match", spec
, entity
);
1132 ftfont_list_family (struct frame
*f
)
1134 Lisp_Object list
= Qnil
;
1135 FcPattern
*pattern
= NULL
;
1136 FcFontSet
*fontset
= NULL
;
1137 FcObjectSet
*objset
= NULL
;
1140 if (! fc_initialized
)
1146 pattern
= FcPatternCreate ();
1149 objset
= FcObjectSetBuild (FC_FAMILY
, NULL
);
1152 fontset
= FcFontList (NULL
, pattern
, objset
);
1156 for (i
= 0; i
< fontset
->nfont
; i
++)
1158 FcPattern
*pat
= fontset
->fonts
[i
];
1161 if (FcPatternGetString (pat
, FC_FAMILY
, 0, &str
) == FcResultMatch
)
1162 list
= Fcons (intern ((char *) str
), list
);
1166 if (objset
) FcObjectSetDestroy (objset
);
1167 if (fontset
) FcFontSetDestroy (fontset
);
1168 if (pattern
) FcPatternDestroy (pattern
);
1175 ftfont_open (struct frame
*f
, Lisp_Object entity
, int pixel_size
)
1177 struct ftfont_info
*ftfont_info
;
1179 struct ftfont_cache_data
*cache_data
;
1183 Lisp_Object val
, filename
, idx
, cache
, font_object
;
1189 val
= assq_no_quit (QCfont_entity
, AREF (entity
, FONT_EXTRA_INDEX
));
1193 cache
= ftfont_lookup_cache (entity
, FTFONT_CACHE_FOR_FACE
);
1196 filename
= XCAR (val
);
1199 cache_data
= XSAVE_POINTER (XCDR (cache
), 0);
1200 ft_face
= cache_data
->ft_face
;
1201 if (XSAVE_INTEGER (val
, 1) > 0)
1203 /* FT_Face in this cache is already used by the different size. */
1204 if (FT_New_Size (ft_face
, &ft_size
) != 0)
1206 if (FT_Activate_Size (ft_size
) != 0)
1208 FT_Done_Size (ft_size
);
1212 set_save_integer (val
, 1, XSAVE_INTEGER (val
, 1) + 1);
1213 size
= XINT (AREF (entity
, FONT_SIZE_INDEX
));
1216 if (FT_Set_Pixel_Sizes (ft_face
, size
, size
) != 0)
1218 if (XSAVE_INTEGER (val
, 1) == 0)
1219 FT_Done_Face (ft_face
);
1223 font_object
= font_build_object (VECSIZE (struct ftfont_info
),
1224 Qfreetype
, entity
, size
);
1225 ASET (font_object
, FONT_FILE_INDEX
, filename
);
1226 font
= XFONT_OBJECT (font_object
);
1227 ftfont_info
= (struct ftfont_info
*) font
;
1228 ftfont_info
->ft_size
= ft_face
->size
;
1229 ftfont_info
->index
= XINT (idx
);
1231 ftfont_info
->maybe_otf
= (ft_face
->face_flags
& FT_FACE_FLAG_SFNT
) != 0;
1232 ftfont_info
->otf
= NULL
;
1233 #endif /* HAVE_LIBOTF */
1234 /* This means that there's no need of transformation. */
1235 ftfont_info
->matrix
.xx
= 0;
1236 font
->pixel_size
= size
;
1237 font
->driver
= &ftfont_driver
;
1238 font
->encoding_charset
= font
->repertory_charset
= -1;
1240 upEM
= ft_face
->units_per_EM
;
1241 scalable
= (INTEGERP (AREF (entity
, FONT_AVGWIDTH_INDEX
))
1242 && XINT (AREF (entity
, FONT_AVGWIDTH_INDEX
)) == 0);
1245 font
->ascent
= ft_face
->ascender
* size
/ upEM
;
1246 font
->descent
= - ft_face
->descender
* size
/ upEM
;
1247 font
->height
= ft_face
->height
* size
/ upEM
;
1251 font
->ascent
= ft_face
->size
->metrics
.ascender
>> 6;
1252 font
->descent
= - ft_face
->size
->metrics
.descender
>> 6;
1253 font
->height
= ft_face
->size
->metrics
.height
>> 6;
1255 if (INTEGERP (AREF (entity
, FONT_SPACING_INDEX
)))
1256 spacing
= XINT (AREF (entity
, FONT_SPACING_INDEX
));
1258 spacing
= FC_PROPORTIONAL
;
1259 if (spacing
!= FC_PROPORTIONAL
1261 && spacing
!= FC_DUAL
1262 #endif /* FC_DUAL */
1264 font
->min_width
= font
->average_width
= font
->space_width
1265 = (scalable
? ft_face
->max_advance_width
* size
/ upEM
1266 : ft_face
->size
->metrics
.max_advance
>> 6);
1271 font
->min_width
= font
->average_width
= font
->space_width
= 0;
1272 for (i
= 32, n
= 0; i
< 127; i
++)
1273 if (FT_Load_Char (ft_face
, i
, FT_LOAD_DEFAULT
) == 0)
1275 int this_width
= ft_face
->glyph
->metrics
.horiAdvance
>> 6;
1278 && (! font
->min_width
|| font
->min_width
> this_width
))
1279 font
->min_width
= this_width
;
1281 font
->space_width
= this_width
;
1282 font
->average_width
+= this_width
;
1286 font
->average_width
/= n
;
1289 font
->baseline_offset
= 0;
1290 font
->relative_compose
= 0;
1291 font
->default_ascent
= 0;
1292 font
->vertical_centering
= 0;
1295 font
->underline_position
= -ft_face
->underline_position
* size
/ upEM
;
1296 font
->underline_thickness
= ft_face
->underline_thickness
* size
/ upEM
;
1300 font
->underline_position
= -1;
1301 font
->underline_thickness
= 0;
1308 ftfont_close (struct font
*font
)
1310 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1311 Lisp_Object val
, cache
;
1313 val
= Fcons (font
->props
[FONT_FILE_INDEX
], make_number (ftfont_info
->index
));
1314 cache
= ftfont_lookup_cache (val
, FTFONT_CACHE_FOR_FACE
);
1315 eassert (CONSP (cache
));
1317 set_save_integer (val
, 1, XSAVE_INTEGER (val
, 1) - 1);
1318 if (XSAVE_INTEGER (val
, 1) == 0)
1320 struct ftfont_cache_data
*cache_data
= XSAVE_POINTER (val
, 0);
1322 FT_Done_Face (cache_data
->ft_face
);
1324 if (ftfont_info
->otf
)
1325 OTF_close (ftfont_info
->otf
);
1327 cache_data
->ft_face
= NULL
;
1330 FT_Done_Size (ftfont_info
->ft_size
);
1334 ftfont_has_char (Lisp_Object font
, int c
)
1336 struct charset
*cs
= NULL
;
1338 if (EQ (AREF (font
, FONT_ADSTYLE_INDEX
), Qja
)
1339 && charset_jisx0208
>= 0)
1340 cs
= CHARSET_FROM_ID (charset_jisx0208
);
1341 else if (EQ (AREF (font
, FONT_ADSTYLE_INDEX
), Qko
)
1342 && charset_ksc5601
>= 0)
1343 cs
= CHARSET_FROM_ID (charset_ksc5601
);
1345 return (ENCODE_CHAR (cs
, c
) != CHARSET_INVALID_CODE (cs
));
1347 if (FONT_ENTITY_P (font
))
1349 FcCharSet
*charset
= ftfont_get_fc_charset (font
);
1351 return (FcCharSetHasChar (charset
, c
) == FcTrue
);
1355 struct ftfont_info
*ftfont_info
;
1357 ftfont_info
= (struct ftfont_info
*) XFONT_OBJECT (font
);
1358 return (FT_Get_Char_Index (ftfont_info
->ft_size
->face
, (FT_ULong
) c
)
1364 ftfont_encode_char (struct font
*font
, int c
)
1366 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1367 FT_Face ft_face
= ftfont_info
->ft_size
->face
;
1368 FT_ULong charcode
= c
;
1369 FT_UInt code
= FT_Get_Char_Index (ft_face
, charcode
);
1371 return (code
> 0 ? code
: FONT_INVALID_CODE
);
1375 ftfont_text_extents (struct font
*font
, unsigned int *code
, int nglyphs
, struct font_metrics
*metrics
)
1377 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1378 FT_Face ft_face
= ftfont_info
->ft_size
->face
;
1383 if (ftfont_info
->ft_size
!= ft_face
->size
)
1384 FT_Activate_Size (ftfont_info
->ft_size
);
1386 memset (metrics
, 0, sizeof (struct font_metrics
));
1387 for (i
= 0, first
= 1; i
< nglyphs
; i
++)
1389 if (FT_Load_Glyph (ft_face
, code
[i
], FT_LOAD_DEFAULT
) == 0)
1391 FT_Glyph_Metrics
*m
= &ft_face
->glyph
->metrics
;
1397 metrics
->lbearing
= m
->horiBearingX
>> 6;
1398 metrics
->rbearing
= (m
->horiBearingX
+ m
->width
) >> 6;
1399 metrics
->ascent
= m
->horiBearingY
>> 6;
1400 metrics
->descent
= (m
->height
- m
->horiBearingY
) >> 6;
1406 if (metrics
->lbearing
> width
+ (m
->horiBearingX
>> 6))
1407 metrics
->lbearing
= width
+ (m
->horiBearingX
>> 6);
1408 if (metrics
->rbearing
1409 < width
+ ((m
->horiBearingX
+ m
->width
) >> 6))
1411 = width
+ ((m
->horiBearingX
+ m
->width
) >> 6);
1412 if (metrics
->ascent
< (m
->horiBearingY
>> 6))
1413 metrics
->ascent
= m
->horiBearingY
>> 6;
1414 if (metrics
->descent
> ((m
->height
- m
->horiBearingY
) >> 6))
1415 metrics
->descent
= (m
->height
- m
->horiBearingY
) >> 6;
1417 width
+= m
->horiAdvance
>> 6;
1421 width
+= font
->space_width
;
1425 metrics
->width
= width
;
1431 ftfont_get_bitmap (struct font
*font
, unsigned int code
, struct font_bitmap
*bitmap
, int bits_per_pixel
)
1433 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1434 FT_Face ft_face
= ftfont_info
->ft_size
->face
;
1435 FT_Int32 load_flags
= FT_LOAD_RENDER
;
1437 if (ftfont_info
->ft_size
!= ft_face
->size
)
1438 FT_Activate_Size (ftfont_info
->ft_size
);
1439 if (bits_per_pixel
== 1)
1441 #ifdef FT_LOAD_TARGET_MONO
1442 load_flags
|= FT_LOAD_TARGET_MONO
;
1444 load_flags
|= FT_LOAD_MONOCHROME
;
1447 else if (bits_per_pixel
!= 8)
1448 /* We don't support such a rendering. */
1451 if (FT_Load_Glyph (ft_face
, code
, load_flags
) != 0)
1453 bitmap
->bits_per_pixel
1454 = (ft_face
->glyph
->bitmap
.pixel_mode
== FT_PIXEL_MODE_MONO
? 1
1455 : ft_face
->glyph
->bitmap
.pixel_mode
== FT_PIXEL_MODE_GRAY
? 8
1456 : ft_face
->glyph
->bitmap
.pixel_mode
== FT_PIXEL_MODE_LCD
? 8
1457 : ft_face
->glyph
->bitmap
.pixel_mode
== FT_PIXEL_MODE_LCD_V
? 8
1459 if (bitmap
->bits_per_pixel
< 0)
1460 /* We don't support that kind of pixel mode. */
1462 bitmap
->rows
= ft_face
->glyph
->bitmap
.rows
;
1463 bitmap
->width
= ft_face
->glyph
->bitmap
.width
;
1464 bitmap
->pitch
= ft_face
->glyph
->bitmap
.pitch
;
1465 bitmap
->buffer
= ft_face
->glyph
->bitmap
.buffer
;
1466 bitmap
->left
= ft_face
->glyph
->bitmap_left
;
1467 bitmap
->top
= ft_face
->glyph
->bitmap_top
;
1468 bitmap
->advance
= ft_face
->glyph
->metrics
.horiAdvance
>> 6;
1474 ftfont_anchor_point (struct font
*font
, unsigned int code
, int idx
,
1477 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1478 FT_Face ft_face
= ftfont_info
->ft_size
->face
;
1480 if (ftfont_info
->ft_size
!= ft_face
->size
)
1481 FT_Activate_Size (ftfont_info
->ft_size
);
1482 if (FT_Load_Glyph (ft_face
, code
, FT_LOAD_DEFAULT
) != 0)
1484 if (ft_face
->glyph
->format
!= FT_GLYPH_FORMAT_OUTLINE
)
1486 if (idx
>= ft_face
->glyph
->outline
.n_points
)
1488 *x
= ft_face
->glyph
->outline
.points
[idx
].x
;
1489 *y
= ft_face
->glyph
->outline
.points
[idx
].y
;
1496 ftfont_otf_features (OTF_GSUB_GPOS
*gsub_gpos
)
1498 Lisp_Object scripts
, langsyses
, features
, sym
;
1501 for (scripts
= Qnil
, i
= gsub_gpos
->ScriptList
.ScriptCount
- 1; i
>= 0; i
--)
1503 OTF_Script
*otf_script
= gsub_gpos
->ScriptList
.Script
+ i
;
1505 for (langsyses
= Qnil
, j
= otf_script
->LangSysCount
- 1; j
>= -1; j
--)
1507 OTF_LangSys
*otf_langsys
;
1510 otf_langsys
= otf_script
->LangSys
+ j
;
1511 else if (otf_script
->DefaultLangSysOffset
)
1512 otf_langsys
= &otf_script
->DefaultLangSys
;
1516 for (features
= Qnil
, k
= otf_langsys
->FeatureCount
- 1; k
>= 0; k
--)
1518 l
= otf_langsys
->FeatureIndex
[k
];
1519 if (l
>= gsub_gpos
->FeatureList
.FeatureCount
)
1521 OTF_TAG_SYM (sym
, gsub_gpos
->FeatureList
.Feature
[l
].FeatureTag
);
1522 features
= Fcons (sym
, features
);
1525 OTF_TAG_SYM (sym
, otf_script
->LangSysRecord
[j
].LangSysTag
);
1528 langsyses
= Fcons (Fcons (sym
, features
), langsyses
);
1531 OTF_TAG_SYM (sym
, gsub_gpos
->ScriptList
.Script
[i
].ScriptTag
);
1532 scripts
= Fcons (Fcons (sym
, langsyses
), scripts
);
1540 ftfont_otf_capability (struct font
*font
)
1542 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
1543 OTF
*otf
= ftfont_get_otf (ftfont_info
);
1544 Lisp_Object gsub_gpos
;
1548 gsub_gpos
= Fcons (Qnil
, Qnil
);
1549 if (OTF_get_table (otf
, "GSUB") == 0
1550 && otf
->gsub
->FeatureList
.FeatureCount
> 0)
1551 XSETCAR (gsub_gpos
, ftfont_otf_features (otf
->gsub
));
1552 if (OTF_get_table (otf
, "GPOS") == 0
1553 && otf
->gpos
->FeatureList
.FeatureCount
> 0)
1554 XSETCDR (gsub_gpos
, ftfont_otf_features (otf
->gpos
));
1558 #ifdef HAVE_M17N_FLT
1560 #if (((LIBOTF_MAJOR_VERSION > 1) || (LIBOTF_RELEASE_NUMBER >= 10)) \
1561 && ((M17NLIB_MAJOR_VERSION > 1) || (M17NLIB_MINOR_VERSION >= 6)))
1562 /* We can use the new feature of libotf and m17n-flt to handle the
1563 character encoding scheme introduced in Unicode 5.1 and 5.2 for
1564 some Agian scripts. */
1565 #define M17N_FLT_USE_NEW_FEATURE
1578 ftfont_get_glyph_id (MFLTFont
*font
, MFLTGlyphString
*gstring
,
1581 struct MFLTFontFT
*flt_font_ft
= (struct MFLTFontFT
*) font
;
1582 FT_Face ft_face
= flt_font_ft
->ft_face
;
1585 for (g
= gstring
->glyphs
+ from
; from
< to
; g
++, from
++)
1588 FT_UInt code
= FT_Get_Char_Index (ft_face
, g
->code
);
1590 g
->code
= code
> 0 ? code
: FONT_INVALID_CODE
;
1596 /* Operators for 26.6 fixed fractional pixel format */
1598 #define FLOOR(x) ((x) & -64)
1599 #define CEIL(x) (((x)+63) & -64)
1600 #define ROUND(x) (((x)+32) & -64)
1603 ftfont_get_metrics (MFLTFont
*font
, MFLTGlyphString
*gstring
,
1606 struct MFLTFontFT
*flt_font_ft
= (struct MFLTFontFT
*) font
;
1607 FT_Face ft_face
= flt_font_ft
->ft_face
;
1610 for (g
= gstring
->glyphs
+ from
; from
< to
; g
++, from
++)
1613 if (g
->code
!= FONT_INVALID_CODE
)
1615 FT_Glyph_Metrics
*m
;
1617 if (FT_Load_Glyph (ft_face
, g
->code
, FT_LOAD_DEFAULT
) != 0)
1619 m
= &ft_face
->glyph
->metrics
;
1620 if (flt_font_ft
->matrix
)
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
);
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
);
1643 g
->xadv
= ROUND (ft_face
->glyph
->advance
.x
);
1648 g
->rbearing
= g
->xadv
= flt_font_ft
->font
->space_width
<< 6;
1649 g
->ascent
= flt_font_ft
->font
->ascent
<< 6;
1650 g
->descent
= flt_font_ft
->font
->descent
<< 6;
1659 ftfont_check_otf (MFLTFont
*font
, MFLTOtfSpec
*spec
)
1661 #define FEATURE_NONE(IDX) (! spec->features[IDX])
1663 #define FEATURE_ANY(IDX) \
1664 (spec->features[IDX] \
1665 && spec->features[IDX][0] == 0xFFFFFFFF && spec->features[IDX][1] == 0)
1667 struct MFLTFontFT
*flt_font_ft
= (struct MFLTFontFT
*) font
;
1668 OTF
*otf
= flt_font_ft
->otf
;
1673 if (FEATURE_ANY (0) && FEATURE_ANY (1))
1674 /* Return true iff any of GSUB or GPOS support the script (and
1677 && (OTF_check_features (otf
, 0, spec
->script
, spec
->langsys
,
1679 || OTF_check_features (otf
, 1, spec
->script
, spec
->langsys
,
1682 for (i
= 0; i
< 2; i
++)
1683 if (! FEATURE_ANY (i
))
1685 if (FEATURE_NONE (i
))
1688 && OTF_check_features (otf
, i
== 0, spec
->script
, spec
->langsys
,
1693 if (spec
->features
[i
][0] == 0xFFFFFFFF)
1696 || OTF_check_features (otf
, i
== 0, spec
->script
, spec
->langsys
,
1702 for (n
= 1; spec
->features
[i
][n
]; n
++);
1703 tags
= alloca (sizeof (OTF_Tag
) * n
);
1704 for (n
= 0, negative
= 0; spec
->features
[i
][n
]; n
++)
1706 if (spec
->features
[i
][n
] == 0xFFFFFFFF)
1709 tags
[n
- 1] = spec
->features
[i
][n
] | 0x80000000;
1711 tags
[n
] = spec
->features
[i
][n
];
1713 #ifdef M17N_FLT_USE_NEW_FEATURE
1714 if (OTF_check_features (otf
, i
== 0, spec
->script
, spec
->langsys
,
1715 tags
, n
- negative
) != 1)
1717 #else /* not M17N_FLT_USE_NEW_FEATURE */
1718 if (n
- negative
> 0
1719 && OTF_check_features (otf
, i
== 0, spec
->script
, spec
->langsys
,
1720 tags
, n
- negative
) != 1)
1722 #endif /* not M17N_FLT_USE_NEW_FEATURE */
1729 #define DEVICE_DELTA(table, size) \
1730 (((size) >= (table).StartSize && (size) <= (table).EndSize) \
1731 ? (table).DeltaValue[(size) - (table).StartSize] << 6 \
1735 adjust_anchor (FT_Face ft_face
, OTF_Anchor
*anchor
,
1736 unsigned code
, int x_ppem
, int y_ppem
, int *x
, int *y
)
1738 if (anchor
->AnchorFormat
== 2)
1740 FT_Outline
*outline
;
1741 int ap
= anchor
->f
.f1
.AnchorPoint
;
1743 FT_Load_Glyph (ft_face
, (FT_UInt
) code
, FT_LOAD_MONOCHROME
);
1744 outline
= &ft_face
->glyph
->outline
;
1745 if (ap
< outline
->n_points
)
1747 *x
= outline
->points
[ap
].x
<< 6;
1748 *y
= outline
->points
[ap
].y
<< 6;
1751 else if (anchor
->AnchorFormat
== 3)
1753 if (anchor
->f
.f2
.XDeviceTable
.offset
1754 && anchor
->f
.f2
.XDeviceTable
.DeltaValue
)
1755 *x
+= DEVICE_DELTA (anchor
->f
.f2
.XDeviceTable
, x_ppem
);
1756 if (anchor
->f
.f2
.YDeviceTable
.offset
1757 && anchor
->f
.f2
.YDeviceTable
.DeltaValue
)
1758 *y
+= DEVICE_DELTA (anchor
->f
.f2
.YDeviceTable
, y_ppem
);
1762 static OTF_GlyphString otf_gstring
;
1765 setup_otf_gstring (int size
)
1767 if (otf_gstring
.size
< size
)
1769 otf_gstring
.glyphs
= xnrealloc (otf_gstring
.glyphs
,
1770 size
, sizeof (OTF_Glyph
));
1771 otf_gstring
.size
= size
;
1773 otf_gstring
.used
= size
;
1774 memset (otf_gstring
.glyphs
, 0, sizeof (OTF_Glyph
) * size
);
1777 #ifdef M17N_FLT_USE_NEW_FEATURE
1779 /* Pack 32-bit OTF tag (0x7F7F7F7F) into 28-bit (0x0FFFFFFF). */
1780 #define PACK_OTF_TAG(TAG) \
1781 ((((TAG) & 0x7F000000) >> 3) \
1782 | (((TAG) & 0x7F0000) >> 2) \
1783 | (((TAG) & 0x7F00) >> 1) \
1786 /* Assuming that FONT is an OpenType font, apply OpenType features
1787 specified in SPEC on glyphs between FROM and TO of IN, and record
1788 the lastly applied feature in each glyph of IN. If OUT is not
1789 NULL, append the resulting glyphs to OUT while storing glyph
1790 position adjustment information in ADJUSTMENT. */
1793 ftfont_drive_otf (MFLTFont
*font
,
1795 MFLTGlyphString
*in
,
1798 MFLTGlyphString
*out
,
1799 MFLTGlyphAdjustment
*adjustment
)
1801 struct MFLTFontFT
*flt_font_ft
= (struct MFLTFontFT
*) font
;
1802 FT_Face ft_face
= flt_font_ft
->ft_face
;
1803 OTF
*otf
= flt_font_ft
->otf
;
1804 int len
= to
- from
;
1807 char script
[5], *langsys
= NULL
;
1808 char *gsub_features
= NULL
, *gpos_features
= NULL
;
1809 OTF_Feature
*features
;
1813 OTF_tag_name (spec
->script
, script
);
1816 langsys
= alloca (5);
1817 OTF_tag_name (spec
->langsys
, langsys
);
1819 for (i
= 0; i
< 2; i
++)
1823 if (spec
->features
[i
] && spec
->features
[i
][1] != 0xFFFFFFFF)
1825 for (j
= 0; spec
->features
[i
][j
]; j
++);
1827 p
= gsub_features
= alloca (6 * j
);
1829 p
= gpos_features
= alloca (6 * j
);
1830 for (j
= 0; spec
->features
[i
][j
]; j
++)
1832 if (spec
->features
[i
][j
] == 0xFFFFFFFF)
1833 *p
++ = '*', *p
++ = ',';
1836 OTF_tag_name (spec
->features
[i
][j
], p
);
1845 setup_otf_gstring (len
);
1846 for (i
= 0; i
< len
; i
++)
1848 otf_gstring
.glyphs
[i
].c
= in
->glyphs
[from
+ i
].c
& 0x11FFFF;
1849 otf_gstring
.glyphs
[i
].glyph_id
= in
->glyphs
[from
+ i
].code
;
1852 OTF_drive_gdef (otf
, &otf_gstring
);
1853 gidx
= out
? out
->used
: from
;
1855 if (gsub_features
&& out
)
1857 if (OTF_drive_gsub_with_log (otf
, &otf_gstring
, script
, langsys
,
1860 if (out
->allocated
< out
->used
+ otf_gstring
.used
)
1862 features
= otf
->gsub
->FeatureList
.Feature
;
1863 for (i
= 0, otfg
= otf_gstring
.glyphs
; i
< otf_gstring
.used
; )
1866 int min_from
, max_to
;
1867 int feature_idx
= otfg
->positioning_type
>> 4;
1869 g
= out
->glyphs
+ out
->used
;
1870 *g
= in
->glyphs
[from
+ otfg
->f
.index
.from
];
1871 if (g
->code
!= otfg
->glyph_id
)
1874 g
->code
= otfg
->glyph_id
;
1880 if (otfg
->f
.index
.from
< otfg
->f
.index
.to
)
1882 /* OTFG substitutes multiple glyphs in IN. */
1883 for (j
= from
+ otfg
->f
.index
.from
+ 1;
1884 j
<= from
+ otfg
->f
.index
.to
; j
++)
1886 if (min_from
> in
->glyphs
[j
].from
)
1887 min_from
= in
->glyphs
[j
].from
;
1888 if (max_to
< in
->glyphs
[j
].to
)
1889 max_to
= in
->glyphs
[j
].to
;
1896 unsigned int tag
= features
[feature_idx
- 1].FeatureTag
;
1897 tag
= PACK_OTF_TAG (tag
);
1898 g
->internal
= (g
->internal
& ~0x1FFFFFFF) | tag
;
1900 for (i
++, otfg
++; (i
< otf_gstring
.used
1901 && otfg
->f
.index
.from
== otfg
[-1].f
.index
.from
);
1904 g
= out
->glyphs
+ out
->used
;
1905 *g
= in
->glyphs
[from
+ otfg
->f
.index
.to
];
1906 if (g
->code
!= otfg
->glyph_id
)
1909 g
->code
= otfg
->glyph_id
;
1912 feature_idx
= otfg
->positioning_type
>> 4;
1915 unsigned int tag
= features
[feature_idx
- 1].FeatureTag
;
1916 tag
= PACK_OTF_TAG (tag
);
1917 g
->internal
= (g
->internal
& ~0x1FFFFFFF) | tag
;
1923 else if (gsub_features
)
1925 /* Just for checking which features will be applied. */
1926 if (OTF_drive_gsub_with_log (otf
, &otf_gstring
, script
, langsys
,
1929 features
= otf
->gsub
->FeatureList
.Feature
;
1930 for (i
= 0, otfg
= otf_gstring
.glyphs
; i
< otf_gstring
.used
; i
++,
1933 int feature_idx
= otfg
->positioning_type
>> 4;
1937 unsigned int tag
= features
[feature_idx
- 1].FeatureTag
;
1938 tag
= PACK_OTF_TAG (tag
);
1939 for (j
= otfg
->f
.index
.from
; j
<= otfg
->f
.index
.to
; j
++)
1941 MFLTGlyph
*g
= in
->glyphs
+ (from
+ j
);
1942 g
->internal
= (g
->internal
& ~0x1FFFFFFF) | tag
;
1949 if (out
->allocated
< out
->used
+ len
)
1951 for (i
= 0; i
< len
; i
++)
1952 out
->glyphs
[out
->used
++] = in
->glyphs
[from
+ i
];
1955 if (gpos_features
&& out
)
1957 MFLTGlyph
*base
= NULL
, *mark
= NULL
, *g
;
1958 int x_ppem
, y_ppem
, x_scale
, y_scale
;
1960 if (OTF_drive_gpos_with_log (otf
, &otf_gstring
, script
, langsys
,
1963 features
= otf
->gpos
->FeatureList
.Feature
;
1964 x_ppem
= ft_face
->size
->metrics
.x_ppem
;
1965 y_ppem
= ft_face
->size
->metrics
.y_ppem
;
1966 x_scale
= ft_face
->size
->metrics
.x_scale
;
1967 y_scale
= ft_face
->size
->metrics
.y_scale
;
1969 for (i
= 0, otfg
= otf_gstring
.glyphs
, g
= out
->glyphs
+ gidx
;
1970 i
< otf_gstring
.used
; i
++, otfg
++, g
++)
1973 int feature_idx
= otfg
->positioning_type
>> 4;
1977 unsigned int tag
= features
[feature_idx
- 1].FeatureTag
;
1978 tag
= PACK_OTF_TAG (tag
);
1979 g
->internal
= (g
->internal
& ~0x1FFFFFFF) | tag
;
1982 if (! otfg
->glyph_id
)
1984 switch (otfg
->positioning_type
& 0xF)
1988 case 1: /* Single */
1991 int format
= otfg
->f
.f1
.format
;
1993 if (format
& OTF_XPlacement
)
1995 = otfg
->f
.f1
.value
->XPlacement
* x_scale
/ 0x10000;
1996 if (format
& OTF_XPlaDevice
)
1998 += DEVICE_DELTA (otfg
->f
.f1
.value
->XPlaDevice
, x_ppem
);
1999 if (format
& OTF_YPlacement
)
2001 = - (otfg
->f
.f1
.value
->YPlacement
* y_scale
/ 0x10000);
2002 if (format
& OTF_YPlaDevice
)
2004 -= DEVICE_DELTA (otfg
->f
.f1
.value
->YPlaDevice
, y_ppem
);
2005 if (format
& OTF_XAdvance
)
2007 += otfg
->f
.f1
.value
->XAdvance
* x_scale
/ 0x10000;
2008 if (format
& OTF_XAdvDevice
)
2010 += DEVICE_DELTA (otfg
->f
.f1
.value
->XAdvDevice
, x_ppem
);
2011 if (format
& OTF_YAdvance
)
2013 += otfg
->f
.f1
.value
->YAdvance
* y_scale
/ 0x10000;
2014 if (format
& OTF_YAdvDevice
)
2016 += DEVICE_DELTA (otfg
->f
.f1
.value
->YAdvDevice
, y_ppem
);
2017 adjustment
[i
].set
= 1;
2020 case 3: /* Cursive */
2021 /* Not yet supported. */
2023 case 4: /* Mark-to-Base */
2024 case 5: /* Mark-to-Ligature */
2028 goto label_adjust_anchor
;
2029 default: /* i.e. case 6 Mark-to-Mark */
2034 label_adjust_anchor
:
2036 int base_x
, base_y
, mark_x
, mark_y
;
2037 int this_from
, this_to
;
2039 base_x
= otfg
->f
.f4
.base_anchor
->XCoordinate
* x_scale
/ 0x10000;
2040 base_y
= otfg
->f
.f4
.base_anchor
->YCoordinate
* y_scale
/ 0x10000;
2041 mark_x
= otfg
->f
.f4
.mark_anchor
->XCoordinate
* x_scale
/ 0x10000;
2042 mark_y
= otfg
->f
.f4
.mark_anchor
->YCoordinate
* y_scale
/ 0x10000;
2044 if (otfg
->f
.f4
.base_anchor
->AnchorFormat
!= 1)
2045 adjust_anchor (ft_face
, otfg
->f
.f4
.base_anchor
,
2046 prev
->code
, x_ppem
, y_ppem
, &base_x
, &base_y
);
2047 if (otfg
->f
.f4
.mark_anchor
->AnchorFormat
!= 1)
2048 adjust_anchor (ft_face
, otfg
->f
.f4
.mark_anchor
, g
->code
,
2049 x_ppem
, y_ppem
, &mark_x
, &mark_y
);
2050 adjustment
[i
].xoff
= (base_x
- mark_x
);
2051 adjustment
[i
].yoff
= - (base_y
- mark_y
);
2052 adjustment
[i
].back
= (g
- prev
);
2053 adjustment
[i
].xadv
= 0;
2054 adjustment
[i
].advance_is_absolute
= 1;
2055 adjustment
[i
].set
= 1;
2056 this_from
= g
->from
;
2058 for (j
= 0; prev
+ j
< g
; j
++)
2060 if (this_from
> prev
[j
].from
)
2061 this_from
= prev
[j
].from
;
2062 if (this_to
< prev
[j
].to
)
2063 this_to
= prev
[j
].to
;
2065 for (; prev
<= g
; prev
++)
2067 prev
->from
= this_from
;
2072 if (otfg
->GlyphClass
== OTF_GlyphClass0
)
2074 else if (otfg
->GlyphClass
== OTF_GlyphClassMark
)
2080 else if (gpos_features
)
2082 if (OTF_drive_gpos_with_log (otf
, &otf_gstring
, script
, langsys
,
2085 features
= otf
->gpos
->FeatureList
.Feature
;
2086 for (i
= 0, otfg
= otf_gstring
.glyphs
; i
< otf_gstring
.used
;
2088 if (otfg
->positioning_type
& 0xF)
2090 int feature_idx
= otfg
->positioning_type
>> 4;
2094 unsigned int tag
= features
[feature_idx
- 1].FeatureTag
;
2095 tag
= PACK_OTF_TAG (tag
);
2096 for (j
= otfg
->f
.index
.from
; j
<= otfg
->f
.index
.to
; j
++)
2098 MFLTGlyph
*g
= in
->glyphs
+ (from
+ j
);
2099 g
->internal
= (g
->internal
& ~0x1FFFFFFF) | tag
;
2109 if (out
->allocated
< out
->used
+ len
)
2111 font
->get_metrics (font
, in
, from
, to
);
2112 memcpy (out
->glyphs
+ out
->used
, in
->glyphs
+ from
,
2113 sizeof (MFLTGlyph
) * len
);
2119 ftfont_try_otf (MFLTFont
*font
, MFLTOtfSpec
*spec
,
2120 MFLTGlyphString
*in
, int from
, int to
)
2122 return ftfont_drive_otf (font
, spec
, in
, from
, to
, NULL
, NULL
);
2125 #else /* not M17N_FLT_USE_NEW_FEATURE */
2128 ftfont_drive_otf (MFLTFont
*font
, MFLTOtfSpec
*spec
, MFLTGlyphString
*in
,
2130 MFLTGlyphString
*out
, MFLTGlyphAdjustment
*adjustment
)
2132 struct MFLTFontFT
*flt_font_ft
= (struct MFLTFontFT
*) font
;
2133 FT_Face ft_face
= flt_font_ft
->ft_face
;
2134 OTF
*otf
= flt_font_ft
->otf
;
2135 int len
= to
- from
;
2138 char script
[5], *langsys
= NULL
;
2139 char *gsub_features
= NULL
, *gpos_features
= NULL
;
2143 OTF_tag_name (spec
->script
, script
);
2146 langsys
= alloca (5);
2147 OTF_tag_name (spec
->langsys
, langsys
);
2149 for (i
= 0; i
< 2; i
++)
2153 if (spec
->features
[i
] && spec
->features
[i
][1] != 0xFFFFFFFF)
2155 for (j
= 0; spec
->features
[i
][j
]; j
++);
2157 p
= gsub_features
= alloca (6 * j
);
2159 p
= gpos_features
= alloca (6 * j
);
2160 for (j
= 0; spec
->features
[i
][j
]; j
++)
2162 if (spec
->features
[i
][j
] == 0xFFFFFFFF)
2163 *p
++ = '*', *p
++ = ',';
2166 OTF_tag_name (spec
->features
[i
][j
], p
);
2175 setup_otf_gstring (len
);
2176 for (i
= 0; i
< len
; i
++)
2178 otf_gstring
.glyphs
[i
].c
= in
->glyphs
[from
+ i
].c
;
2179 otf_gstring
.glyphs
[i
].glyph_id
= in
->glyphs
[from
+ i
].code
;
2182 OTF_drive_gdef (otf
, &otf_gstring
);
2187 if (OTF_drive_gsub (otf
, &otf_gstring
, script
, langsys
, gsub_features
)
2190 if (out
->allocated
< out
->used
+ otf_gstring
.used
)
2192 for (i
= 0, otfg
= otf_gstring
.glyphs
; i
< otf_gstring
.used
; )
2195 int min_from
, max_to
;
2198 g
= out
->glyphs
+ out
->used
;
2199 *g
= in
->glyphs
[from
+ otfg
->f
.index
.from
];
2200 if (g
->code
!= otfg
->glyph_id
)
2203 g
->code
= otfg
->glyph_id
;
2209 if (otfg
->f
.index
.from
< otfg
->f
.index
.to
)
2211 /* OTFG substitutes multiple glyphs in IN. */
2212 for (j
= from
+ otfg
->f
.index
.from
+ 1;
2213 j
<= from
+ otfg
->f
.index
.to
; j
++)
2215 if (min_from
> in
->glyphs
[j
].from
)
2216 min_from
= in
->glyphs
[j
].from
;
2217 if (max_to
< in
->glyphs
[j
].to
)
2218 max_to
= in
->glyphs
[j
].to
;
2223 for (i
++, otfg
++; (i
< otf_gstring
.used
2224 && otfg
->f
.index
.from
== otfg
[-1].f
.index
.from
);
2227 g
= out
->glyphs
+ out
->used
;
2228 *g
= in
->glyphs
[from
+ otfg
->f
.index
.to
];
2229 if (g
->code
!= otfg
->glyph_id
)
2232 g
->code
= otfg
->glyph_id
;
2241 if (out
->allocated
< out
->used
+ len
)
2243 for (i
= 0; i
< len
; i
++)
2244 out
->glyphs
[out
->used
++] = in
->glyphs
[from
+ i
];
2249 MFLTGlyph
*base
= NULL
, *mark
= NULL
, *g
;
2250 int x_ppem
, y_ppem
, x_scale
, y_scale
;
2252 if (OTF_drive_gpos (otf
, &otf_gstring
, script
, langsys
, gpos_features
)
2256 x_ppem
= ft_face
->size
->metrics
.x_ppem
;
2257 y_ppem
= ft_face
->size
->metrics
.y_ppem
;
2258 x_scale
= ft_face
->size
->metrics
.x_scale
;
2259 y_scale
= ft_face
->size
->metrics
.y_scale
;
2261 for (i
= 0, otfg
= otf_gstring
.glyphs
, g
= out
->glyphs
+ gidx
;
2262 i
< otf_gstring
.used
; i
++, otfg
++, g
++)
2266 if (! otfg
->glyph_id
)
2268 switch (otfg
->positioning_type
)
2272 case 1: /* Single */
2275 int format
= otfg
->f
.f1
.format
;
2277 if (format
& OTF_XPlacement
)
2279 = otfg
->f
.f1
.value
->XPlacement
* x_scale
/ 0x10000;
2280 if (format
& OTF_XPlaDevice
)
2282 += DEVICE_DELTA (otfg
->f
.f1
.value
->XPlaDevice
, x_ppem
);
2283 if (format
& OTF_YPlacement
)
2285 = - (otfg
->f
.f1
.value
->YPlacement
* y_scale
/ 0x10000);
2286 if (format
& OTF_YPlaDevice
)
2288 -= DEVICE_DELTA (otfg
->f
.f1
.value
->YPlaDevice
, y_ppem
);
2289 if (format
& OTF_XAdvance
)
2291 += otfg
->f
.f1
.value
->XAdvance
* x_scale
/ 0x10000;
2292 if (format
& OTF_XAdvDevice
)
2294 += DEVICE_DELTA (otfg
->f
.f1
.value
->XAdvDevice
, x_ppem
);
2295 if (format
& OTF_YAdvance
)
2297 += otfg
->f
.f1
.value
->YAdvance
* y_scale
/ 0x10000;
2298 if (format
& OTF_YAdvDevice
)
2300 += DEVICE_DELTA (otfg
->f
.f1
.value
->YAdvDevice
, y_ppem
);
2301 adjustment
[i
].set
= 1;
2304 case 3: /* Cursive */
2305 /* Not yet supported. */
2307 case 4: /* Mark-to-Base */
2308 case 5: /* Mark-to-Ligature */
2312 goto label_adjust_anchor
;
2313 default: /* i.e. case 6 Mark-to-Mark */
2318 label_adjust_anchor
:
2320 int base_x
, base_y
, mark_x
, mark_y
;
2321 int this_from
, this_to
;
2323 base_x
= otfg
->f
.f4
.base_anchor
->XCoordinate
* x_scale
/ 0x10000;
2324 base_y
= otfg
->f
.f4
.base_anchor
->YCoordinate
* y_scale
/ 0x10000;
2325 mark_x
= otfg
->f
.f4
.mark_anchor
->XCoordinate
* x_scale
/ 0x10000;
2326 mark_y
= otfg
->f
.f4
.mark_anchor
->YCoordinate
* y_scale
/ 0x10000;
2328 if (otfg
->f
.f4
.base_anchor
->AnchorFormat
!= 1)
2329 adjust_anchor (ft_face
, otfg
->f
.f4
.base_anchor
,
2330 prev
->code
, x_ppem
, y_ppem
, &base_x
, &base_y
);
2331 if (otfg
->f
.f4
.mark_anchor
->AnchorFormat
!= 1)
2332 adjust_anchor (ft_face
, otfg
->f
.f4
.mark_anchor
, g
->code
,
2333 x_ppem
, y_ppem
, &mark_x
, &mark_y
);
2334 adjustment
[i
].xoff
= (base_x
- mark_x
);
2335 adjustment
[i
].yoff
= - (base_y
- mark_y
);
2336 adjustment
[i
].back
= (g
- prev
);
2337 adjustment
[i
].xadv
= 0;
2338 adjustment
[i
].advance_is_absolute
= 1;
2339 adjustment
[i
].set
= 1;
2340 this_from
= g
->from
;
2342 for (j
= 0; prev
+ j
< g
; j
++)
2344 if (this_from
> prev
[j
].from
)
2345 this_from
= prev
[j
].from
;
2346 if (this_to
< prev
[j
].to
)
2347 this_to
= prev
[j
].to
;
2349 for (; prev
<= g
; prev
++)
2351 prev
->from
= this_from
;
2356 if (otfg
->GlyphClass
== OTF_GlyphClass0
)
2358 else if (otfg
->GlyphClass
== OTF_GlyphClassMark
)
2367 if (out
->allocated
< out
->used
+ len
)
2369 font
->get_metrics (font
, in
, from
, to
);
2370 memcpy (out
->glyphs
+ out
->used
, in
->glyphs
+ from
,
2371 sizeof (MFLTGlyph
) * len
);
2376 #endif /* not M17N_FLT_USE_NEW_FEATURE */
2378 static MFLTGlyphString gstring
;
2380 static bool m17n_flt_initialized
;
2383 ftfont_shape_by_flt (Lisp_Object lgstring
, struct font
*font
,
2384 FT_Face ft_face
, OTF
*otf
, FT_Matrix
*matrix
)
2386 ptrdiff_t len
= LGSTRING_GLYPH_LEN (lgstring
);
2388 struct MFLTFontFT flt_font_ft
;
2390 bool with_variation_selector
= 0;
2392 if (! m17n_flt_initialized
)
2395 #ifdef M17N_FLT_USE_NEW_FEATURE
2396 mflt_enable_new_feature
= 1;
2397 mflt_try_otf
= ftfont_try_otf
;
2398 #endif /* M17N_FLT_USE_NEW_FEATURE */
2399 m17n_flt_initialized
= 1;
2402 for (i
= 0; i
< len
; i
++)
2404 Lisp_Object g
= LGSTRING_GLYPH (lgstring
, i
);
2409 c
= LGLYPH_CHAR (g
);
2410 if (CHAR_VARIATION_SELECTOR_P (c
))
2411 with_variation_selector
= 1;
2416 if (with_variation_selector
)
2418 setup_otf_gstring (len
);
2419 for (i
= 0; i
< len
; i
++)
2421 Lisp_Object g
= LGSTRING_GLYPH (lgstring
, i
);
2423 otf_gstring
.glyphs
[i
].c
= LGLYPH_CHAR (g
);
2424 otf_gstring
.glyphs
[i
].f
.index
.from
= LGLYPH_FROM (g
);
2425 otf_gstring
.glyphs
[i
].f
.index
.to
= LGLYPH_TO (g
);
2427 OTF_drive_cmap (otf
, &otf_gstring
);
2428 for (i
= 0; i
< otf_gstring
.used
; i
++)
2430 OTF_Glyph
*otfg
= otf_gstring
.glyphs
+ i
;
2431 Lisp_Object g0
= LGSTRING_GLYPH (lgstring
, otfg
->f
.index
.from
);
2432 Lisp_Object g1
= LGSTRING_GLYPH (lgstring
, otfg
->f
.index
.to
);
2434 LGLYPH_SET_CODE (g0
, otfg
->glyph_id
);
2435 LGLYPH_SET_TO (g0
, LGLYPH_TO (g1
));
2436 LGSTRING_SET_GLYPH (lgstring
, i
, g0
);
2438 if (len
> otf_gstring
.used
)
2440 len
= otf_gstring
.used
;
2441 LGSTRING_SET_GLYPH (lgstring
, len
, Qnil
);
2445 if (INT_MAX
/ 2 < len
)
2446 memory_full (SIZE_MAX
);
2448 if (gstring
.allocated
== 0)
2450 gstring
.glyph_size
= sizeof (MFLTGlyph
);
2451 gstring
.glyphs
= xnmalloc (len
* 2, sizeof *gstring
.glyphs
);
2452 gstring
.allocated
= len
* 2;
2454 else if (gstring
.allocated
< len
* 2)
2456 gstring
.glyphs
= xnrealloc (gstring
.glyphs
, len
* 2,
2457 sizeof *gstring
.glyphs
);
2458 gstring
.allocated
= len
* 2;
2460 memset (gstring
.glyphs
, 0, len
* sizeof *gstring
.glyphs
);
2461 for (i
= 0; i
< len
; i
++)
2463 Lisp_Object g
= LGSTRING_GLYPH (lgstring
, i
);
2465 gstring
.glyphs
[i
].c
= LGLYPH_CHAR (g
);
2466 if (with_variation_selector
)
2468 gstring
.glyphs
[i
].code
= LGLYPH_CODE (g
);
2469 gstring
.glyphs
[i
].encoded
= 1;
2477 Lisp_Object family
= Ffont_get (LGSTRING_FONT (lgstring
), QCfamily
);
2480 flt_font_ft
.flt_font
.family
= Mnil
;
2482 flt_font_ft
.flt_font
.family
2483 = msymbol (SSDATA (Fdowncase (SYMBOL_NAME (family
))));
2485 flt_font_ft
.flt_font
.x_ppem
= ft_face
->size
->metrics
.x_ppem
;
2486 flt_font_ft
.flt_font
.y_ppem
= ft_face
->size
->metrics
.y_ppem
;
2487 flt_font_ft
.flt_font
.get_glyph_id
= ftfont_get_glyph_id
;
2488 flt_font_ft
.flt_font
.get_metrics
= ftfont_get_metrics
;
2489 flt_font_ft
.flt_font
.check_otf
= ftfont_check_otf
;
2490 flt_font_ft
.flt_font
.drive_otf
= ftfont_drive_otf
;
2491 flt_font_ft
.flt_font
.internal
= NULL
;
2492 flt_font_ft
.font
= font
;
2493 flt_font_ft
.ft_face
= ft_face
;
2494 flt_font_ft
.otf
= otf
;
2495 flt_font_ft
.matrix
= matrix
->xx
!= 0 ? matrix
: 0;
2497 && gstring
.glyphs
[1].c
>= 0x300 && gstring
.glyphs
[1].c
<= 0x36F)
2498 /* A little bit ad hoc. Perhaps, shaper must get script and
2499 language information, and select a proper flt for them
2501 flt
= mflt_get (msymbol ("combining"));
2502 for (i
= 0; i
< 3; i
++)
2504 int result
= mflt_run (&gstring
, 0, len
, &flt_font_ft
.flt_font
, flt
);
2507 if (INT_MAX
/ 2 < gstring
.allocated
)
2508 memory_full (SIZE_MAX
);
2509 gstring
.glyphs
= xnrealloc (gstring
.glyphs
,
2510 gstring
.allocated
, 2 * sizeof (MFLTGlyph
));
2511 gstring
.allocated
*= 2;
2513 if (gstring
.used
> LGSTRING_GLYPH_LEN (lgstring
))
2515 for (i
= 0; i
< gstring
.used
; i
++)
2517 MFLTGlyph
*g
= gstring
.glyphs
+ i
;
2519 g
->from
= LGLYPH_FROM (LGSTRING_GLYPH (lgstring
, g
->from
));
2520 g
->to
= LGLYPH_TO (LGSTRING_GLYPH (lgstring
, g
->to
));
2523 for (i
= 0; i
< gstring
.used
; i
++)
2525 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
2526 MFLTGlyph
*g
= gstring
.glyphs
+ i
;
2530 lglyph
= LGLYPH_NEW ();
2531 LGSTRING_SET_GLYPH (lgstring
, i
, lglyph
);
2533 LGLYPH_SET_FROM (lglyph
, g
->from
);
2534 LGLYPH_SET_TO (lglyph
, g
->to
);
2535 LGLYPH_SET_CHAR (lglyph
, g
->c
);
2536 LGLYPH_SET_CODE (lglyph
, g
->code
);
2537 LGLYPH_SET_WIDTH (lglyph
, g
->xadv
>> 6);
2538 LGLYPH_SET_LBEARING (lglyph
, g
->lbearing
>> 6);
2539 LGLYPH_SET_RBEARING (lglyph
, g
->rbearing
>> 6);
2540 LGLYPH_SET_ASCENT (lglyph
, g
->ascent
>> 6);
2541 LGLYPH_SET_DESCENT (lglyph
, g
->descent
>> 6);
2544 Lisp_Object vec
= make_uninit_vector (3);
2546 ASET (vec
, 0, make_number (g
->xoff
>> 6));
2547 ASET (vec
, 1, make_number (g
->yoff
>> 6));
2548 ASET (vec
, 2, make_number (g
->xadv
>> 6));
2549 LGLYPH_SET_ADJUSTMENT (lglyph
, vec
);
2552 return make_number (i
);
2556 ftfont_shape (Lisp_Object lgstring
)
2559 struct ftfont_info
*ftfont_info
;
2562 CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring
), font
);
2563 ftfont_info
= (struct ftfont_info
*) font
;
2564 otf
= ftfont_get_otf (ftfont_info
);
2566 return make_number (0);
2567 return ftfont_shape_by_flt (lgstring
, font
, ftfont_info
->ft_size
->face
, otf
,
2568 &ftfont_info
->matrix
);
2571 #endif /* HAVE_M17N_FLT */
2573 #ifdef HAVE_OTF_GET_VARIATION_GLYPHS
2576 ftfont_variation_glyphs (struct font
*font
, int c
, unsigned variations
[256])
2578 struct ftfont_info
*ftfont_info
= (struct ftfont_info
*) font
;
2579 OTF
*otf
= ftfont_get_otf (ftfont_info
);
2583 return OTF_get_variation_glyphs (otf
, c
, variations
);
2586 #endif /* HAVE_OTF_GET_VARIATION_GLYPHS */
2587 #endif /* HAVE_LIBOTF */
2589 static const char *const ftfont_booleans
[] = {
2602 static const char *const ftfont_non_booleans
[] = {
2634 ftfont_filter_properties (Lisp_Object font
, Lisp_Object alist
)
2636 font_filter_properties (font
, alist
, ftfont_booleans
, ftfont_non_booleans
);
2641 syms_of_ftfont (void)
2643 DEFSYM (Qfreetype
, "freetype");
2644 DEFSYM (Qmonospace
, "monospace");
2645 DEFSYM (Qsans_serif
, "sans-serif");
2646 DEFSYM (Qserif
, "serif");
2647 DEFSYM (Qmono
, "mono");
2648 DEFSYM (Qsans
, "sans");
2649 DEFSYM (Qsans__serif
, "sans serif");
2651 staticpro (&freetype_font_cache
);
2652 freetype_font_cache
= list1 (Qt
);
2654 staticpro (&ftfont_generic_family_list
);
2655 ftfont_generic_family_list
= list3 (Fcons (Qmonospace
, Qt
),
2656 Fcons (Qsans_serif
, Qt
),
2659 staticpro (&ft_face_cache
);
2660 ft_face_cache
= Qnil
;
2662 ftfont_driver
.type
= Qfreetype
;
2663 register_font_driver (&ftfont_driver
, NULL
);