]> git.wh0rd.org - fontconfig.git/blob - src/fcfreetype.c
git.wh0rd.org / fontconfig.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Bug #46, #47 fontconfig should retrieve type 1 font information from
[fontconfig.git] / src / fcfreetype.c
1 /*
2 * $RCSId: xc/lib/fontconfig/src/fcfreetype.c,v 1.11 2002/08/31 22:17:32 keithp Exp $
3 *
4 * Copyright © 2001 Keith Packard
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of Keith Packard not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. Keith Packard makes no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
15 *
16 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
23 */
24
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include "fcint.h"
29 #include <freetype/freetype.h>
30 #include <freetype/internal/ftobjs.h>
31 #include <freetype/tttables.h>
32 #include <freetype/ftsnames.h>
33 #include <freetype/ttnameid.h>
34 #include <freetype/t1tables.h>
35
36 /*
37 * Keep Han languages separated by eliminating languages
38 * that the codePageRange bits says aren't supported
39 */
40
41 static const struct {
42 int bit;
43 const FcChar8 *lang;
44 } FcCodePageRange[] = {
45 { 17, (const FcChar8 *) "ja" },
46 { 18, (const FcChar8 *) "zh-cn" },
47 { 19, (const FcChar8 *) "ko" },
48 { 20, (const FcChar8 *) "zh-tw" },
49 };
50
51 #define NUM_CODE_PAGE_RANGE (sizeof FcCodePageRange / sizeof FcCodePageRange[0])
52
53 FcBool
54 FcFreeTypeIsExclusiveLang (const FcChar8 *lang)
55 {
56 int i;
57
58 for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
59 {
60 if (FcLangCompare (lang, FcCodePageRange[i].lang) != FcLangDifferentLang)
61 return FcTrue;
62 }
63 return FcFalse;
64 }
65
66 #define FC_NAME_PRIO_LANG 0x0f00
67 #define FC_NAME_PRIO_LANG_ENGLISH 0x0200
68 #define FC_NAME_PRIO_LANG_LATIN 0x0100
69 #define FC_NAME_PRIO_LANG_NONE 0x0000
70
71 #define FC_NAME_PRIO_ENC 0x00f0
72 #define FC_NAME_PRIO_ENC_UNICODE 0x0010
73 #define FC_NAME_PRIO_ENC_NONE 0x0000
74
75 #define FC_NAME_PRIO_NAME 0x000f
76 #define FC_NAME_PRIO_NAME_FAMILY 0x0002
77 #define FC_NAME_PRIO_NAME_PS 0x0001
78 #define FC_NAME_PRIO_NAME_NONE 0x0000
79
80 static FcBool
81 FcUcs4IsLatin (FcChar32 ucs4)
82 {
83 FcChar32 page = ucs4 >> 8;
84
85 if (page <= 2)
86 return FcTrue;
87 if (page == 0x1e)
88 return FcTrue;
89 if (0x20 <= page && page <= 0x23)
90 return FcTrue;
91 if (page == 0xfb)
92 return FcTrue;
93 if (page == 0xff)
94 return FcTrue;
95 return FcFalse;
96 }
97
98 static FcBool
99 FcUtf8IsLatin (FcChar8 *str, int len)
100 {
101 while (len)
102 {
103 FcChar32 ucs4;
104 int clen = FcUtf8ToUcs4 (str, &ucs4, len);
105 if (clen <= 0)
106 return FcFalse;
107 if (!FcUcs4IsLatin (ucs4))
108 return FcFalse;
109 len -= clen;
110 str += clen;
111 }
112 return FcTrue;
113 }
114
115 FcPattern *
116 FcFreeTypeQuery (const FcChar8 *file,
117 int id,
118 FcBlanks *blanks,
119 int *count)
120 {
121 FT_Face face;
122 FcPattern *pat;
123 int slant;
124 int weight;
125 int width = -1;
126 int i;
127 FcCharSet *cs;
128 FcLangSet *ls;
129 FT_Library ftLibrary;
130 FcChar8 *family;
131 FcChar8 *style;
132 int spacing;
133 TT_OS2 *os2;
134 PS_FontInfoRec psfontinfo;
135 TT_Header *head;
136 const FcChar8 *exclusiveLang = 0;
137 FT_SfntName sname;
138 FT_UInt snamei, snamec;
139 FcBool family_allocated = FcFalse;
140 FcBool style_allocated = FcFalse;
141 int family_prio = 0;
142 int style_prio = 0;
143
144 if (FT_Init_FreeType (&ftLibrary))
145 return 0;
146
147 if (FT_New_Face (ftLibrary, (char *) file, id, &face))
148 goto bail;
149
150 *count = face->num_faces;
151
152 pat = FcPatternCreate ();
153 if (!pat)
154 goto bail0;
155
156 if (!FcPatternAddBool (pat, FC_OUTLINE,
157 (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
158 goto bail1;
159
160 if (!FcPatternAddBool (pat, FC_SCALABLE,
161 (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
162 goto bail1;
163
164
165 slant = FC_SLANT_ROMAN;
166 if (face->style_flags & FT_STYLE_FLAG_ITALIC)
167 slant = FC_SLANT_ITALIC;
168
169
170 weight = FC_WEIGHT_MEDIUM;
171 if (face->style_flags & FT_STYLE_FLAG_BOLD)
172 weight = FC_WEIGHT_BOLD;
173
174 /*
175 * Grub through the name table looking for family
176 * and style names. FreeType makes quite a hash
177 * of them
178 */
179 family = 0;
180 style = 0;
181 snamec = FT_Get_Sfnt_Name_Count (face);
182 for (snamei = 0; snamei < snamec; snamei++)
183 {
184 FcChar8 *utf8;
185 int len;
186 int wchar;
187 FcChar8 *src;
188 int src_len;
189 FcChar8 *u8;
190 FcChar32 ucs4;
191 int ilen, olen;
192 int prio = 0;
193
194 const FcCharMap *map;
195 enum {
196 FcNameEncodingUtf16,
197 FcNameEncodingAppleRoman,
198 FcNameEncodingLatin1
199 } encoding;
200
201
202 if (FT_Get_Sfnt_Name (face, snamei, &sname) != 0)
203 break;
204
205 /*
206 * Look for Unicode strings
207 */
208 switch (sname.platform_id) {
209 case TT_PLATFORM_APPLE_UNICODE:
210 /*
211 * All APPLE_UNICODE encodings are Utf16 BE
212 *
213 * Because there's no language id for Unicode,
214 * assume it's English
215 */
216 prio |= FC_NAME_PRIO_LANG_ENGLISH;
217 prio |= FC_NAME_PRIO_ENC_UNICODE;
218 encoding = FcNameEncodingUtf16;
219 break;
220 case TT_PLATFORM_MACINTOSH:
221 switch (sname.encoding_id) {
222 case TT_MAC_ID_ROMAN:
223 encoding = FcNameEncodingAppleRoman;
224 break;
225 default:
226 continue;
227 }
228 switch (sname.language_id) {
229 case TT_MAC_LANGID_ENGLISH:
230 prio |= FC_NAME_PRIO_LANG_ENGLISH;
231 break;
232 default:
233 /*
234 * Sometimes Microsoft language ids
235 * end up in the macintosh table. This
236 * is often accompanied by data in
237 * some mystic encoding. Ignore these names
238 */
239 if (sname.language_id >= 0x100)
240 continue;
241 break;
242 }
243 break;
244 case TT_PLATFORM_MICROSOFT:
245 switch (sname.encoding_id) {
246 case TT_MS_ID_UNICODE_CS:
247 encoding = FcNameEncodingUtf16;
248 prio |= FC_NAME_PRIO_ENC_UNICODE;
249 break;
250 default:
251 continue;
252 }
253 switch (sname.language_id & 0xff) {
254 case 0x09:
255 prio |= FC_NAME_PRIO_LANG_ENGLISH;
256 break;
257 default:
258 break;
259 }
260 break;
261 case TT_PLATFORM_ISO:
262 switch (sname.encoding_id) {
263 case TT_ISO_ID_10646:
264 encoding = FcNameEncodingUtf16;
265 prio |= FC_NAME_PRIO_ENC_UNICODE;
266 break;
267 case TT_ISO_ID_7BIT_ASCII:
268 case TT_ISO_ID_8859_1:
269 encoding = FcNameEncodingLatin1;
270 break;
271 default:
272 continue;
273 }
274 break;
275 default:
276 continue;
277 }
278
279 /*
280 * Look for family and style names
281 */
282 switch (sname.name_id) {
283 case TT_NAME_ID_FONT_FAMILY:
284 prio |= FC_NAME_PRIO_NAME_FAMILY;
285 break;
286 case TT_NAME_ID_PS_NAME:
287 prio |= FC_NAME_PRIO_NAME_PS;
288 break;
289 case TT_NAME_ID_FONT_SUBFAMILY:
290 break;
291 default:
292 continue;
293 }
294
295 src = (FcChar8 *) sname.string;
296 src_len = sname.string_len;
297
298 switch (encoding) {
299 case FcNameEncodingUtf16:
300 /*
301 * Convert Utf16 to Utf8
302 */
303
304 if (!FcUtf16Len (src, FcEndianBig, src_len, &len, &wchar))
305 continue;
306
307 /*
308 * Allocate plenty of space. Freed below
309 */
310 utf8 = malloc (len * FC_UTF8_MAX_LEN + 1);
311 if (!utf8)
312 continue;
313
314 u8 = utf8;
315
316 while ((ilen = FcUtf16ToUcs4 (src, FcEndianBig, &ucs4, src_len)) > 0)
317 {
318 src_len -= ilen;
319 src += ilen;
320 olen = FcUcs4ToUtf8 (ucs4, u8);
321 u8 += olen;
322 }
323 *u8 = '\0';
324 break;
325 case FcNameEncodingLatin1:
326 /*
327 * Convert Latin1 to Utf8. Freed below
328 */
329 utf8 = malloc (src_len * 2 + 1);
330 if (!utf8)
331 continue;
332
333 u8 = utf8;
334 while (src_len > 0)
335 {
336 ucs4 = *src++;
337 src_len--;
338 olen = FcUcs4ToUtf8 (ucs4, u8);
339 u8 += olen;
340 }
341 *u8 = '\0';
342 break;
343 case FcNameEncodingAppleRoman:
344 /*
345 * Convert AppleRoman to Utf8
346 */
347 map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
348 if (!map)
349 continue;
350
351 /* freed below */
352 utf8 = malloc (src_len * 3 + 1);
353 if (!utf8)
354 continue;
355
356 u8 = utf8;
357 while (src_len > 0)
358 {
359 ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
360 src_len--;
361 olen = FcUcs4ToUtf8 (ucs4, u8);
362 u8 += olen;
363 }
364 *u8 = '\0';
365 break;
366 default:
367 continue;
368 }
369 if ((prio & FC_NAME_PRIO_LANG) == FC_NAME_PRIO_LANG_NONE)
370 if (FcUtf8IsLatin (utf8, strlen ((char *) utf8)))
371 prio |= FC_NAME_PRIO_LANG_LATIN;
372
373 if (FcDebug () & FC_DBG_SCANV)
374 printf ("\nfound name (name %d platform %d encoding %d language 0x%x prio 0x%x) %s\n",
375 sname.name_id, sname.platform_id,
376 sname.encoding_id, sname.language_id,
377 prio, utf8);
378
379 switch (sname.name_id) {
380 case TT_NAME_ID_FONT_FAMILY:
381 case TT_NAME_ID_PS_NAME:
382 if (!family || prio > family_prio)
383 {
384 if (family)
385 free (family);
386 family = utf8;
387 utf8 = 0;
388 family_allocated = FcTrue;
389 family_prio = prio;
390 }
391 break;
392 case TT_NAME_ID_FONT_SUBFAMILY:
393 if (!style || prio > style_prio)
394 {
395 if (style)
396 free (style);
397 style = utf8;
398 utf8 = 0;
399 style_allocated = FcTrue;
400 style_prio = prio;
401 }
402 break;
403 }
404 if (utf8)
405 free (utf8);
406 }
407
408 if (!family)
409 family = (FcChar8 *) face->family_name;
410
411 if (!style)
412 style = (FcChar8 *) face->style_name;
413
414 if (!family)
415 {
416 FcChar8 *start, *end;
417
418 start = (FcChar8 *) strrchr ((char *) file, '/');
419 if (start)
420 start++;
421 else
422 start = (FcChar8 *) file;
423 end = (FcChar8 *) strrchr ((char *) start, '.');
424 if (!end)
425 end = start + strlen ((char *) start);
426 /* freed below */
427 family = malloc (end - start + 1);
428 strncpy ((char *) family, (char *) start, end - start);
429 family[end - start] = '\0';
430 family_allocated = FcTrue;
431 }
432
433 if (FcDebug() & FC_DBG_SCAN)
434 printf ("\"%s\" \"%s\" ", family, style ? style : (FcChar8 *) "<none>");
435
436 if (!FcPatternAddString (pat, FC_FAMILY, family))
437 {
438 if (family_allocated)
439 free (family);
440 if (style_allocated)
441 free (style);
442 goto bail1;
443 }
444
445 if (family_allocated)
446 free (family);
447
448 if (style)
449 {
450 if (!FcPatternAddString (pat, FC_STYLE, style))
451 {
452 if (style_allocated)
453 free (style);
454 goto bail1;
455 }
456 if (style_allocated)
457 free (style);
458 }
459
460 if (!FcPatternAddString (pat, FC_FILE, file))
461 goto bail1;
462
463 if (!FcPatternAddInteger (pat, FC_INDEX, id))
464 goto bail1;
465
466 if (!FcPatternAddString (pat, FC_SOURCE, (FcChar8 *) "FreeType"))
467 goto bail1;
468
469 #if 0
470 /*
471 * don't even try this -- CJK 'monospace' fonts are really
472 * dual width, and most other fonts don't bother to set
473 * the attribute. Sigh.
474 */
475 if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
476 if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
477 goto bail1;
478 #endif
479
480 /*
481 * Find the font revision (if available)
482 */
483 head = (TT_Header *) FT_Get_Sfnt_Table (face, ft_sfnt_head);
484 if (head)
485 {
486 if (!FcPatternAddInteger (pat, FC_FONTVERSION, head->Font_Revision))
487 goto bail1;
488 }
489 else
490 {
491 if (!FcPatternAddInteger (pat, FC_FONTVERSION, 0))
492 goto bail1;
493 }
494
495 /*
496 * Get the OS/2 table and poke about
497 */
498 os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
499 if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
500 {
501 for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
502 {
503 FT_ULong bits;
504 int bit;
505 if (FcCodePageRange[i].bit < 32)
506 {
507 bits = os2->ulCodePageRange1;
508 bit = FcCodePageRange[i].bit;
509 }
510 else
511 {
512 bits = os2->ulCodePageRange2;
513 bit = FcCodePageRange[i].bit - 32;
514 }
515 if (bits & (1 << bit))
516 {
517 /*
518 * If the font advertises support for multiple
519 * "exclusive" languages, then include support
520 * for any language found to have coverage
521 */
522 if (exclusiveLang)
523 {
524 exclusiveLang = 0;
525 break;
526 }
527 exclusiveLang = FcCodePageRange[i].lang;
528 }
529 }
530 }
531
532 if (os2 && os2->version != 0xffff)
533 {
534 if (os2->usWeightClass == 0)
535 weight = -1;
536 else if (os2->usWeightClass < 150)
537 weight = FC_WEIGHT_THIN;
538 else if (os2->usWeightClass < 250)
539 weight = FC_WEIGHT_EXTRALIGHT;
540 else if (os2->usWeightClass < 350)
541 weight = FC_WEIGHT_LIGHT;
542 else if (os2->usWeightClass < 450)
543 weight = FC_WEIGHT_REGULAR;
544 else if (os2->usWeightClass < 550)
545 weight = FC_WEIGHT_MEDIUM;
546 else if (os2->usWeightClass < 650)
547 weight = FC_WEIGHT_SEMIBOLD;
548 else if (os2->usWeightClass < 750)
549 weight = FC_WEIGHT_BOLD;
550 else if (os2->usWeightClass < 850)
551 weight = FC_WEIGHT_EXTRABOLD;
552 else if (os2->usWeightClass < 950)
553 weight = FC_WEIGHT_BLACK;
554 else
555 weight = FC_WEIGHT_MEDIUM;
556
557 switch (os2->usWidthClass) {
558 case 1: width = FC_WIDTH_ULTRACONDENSED; break;
559 case 2: width = FC_WIDTH_EXTRACONDENSED; break;
560 case 3: width = FC_WIDTH_CONDENSED; break;
561 case 4: width = FC_WIDTH_SEMICONDENSED; break;
562 case 5: width = FC_WIDTH_NORMAL; break;
563 case 6: width = FC_WIDTH_SEMIEXPANDED; break;
564 case 7: width = FC_WIDTH_EXPANDED; break;
565 case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
566 case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
567 }
568 }
569
570 /*
571 * Type 1: Check for FontInfo dictionary information
572 * Code from g2@magestudios.net (Gerard Escalante)
573 */
574
575 if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
576 {
577 if (strcasecmp("thin", psfontinfo.weight) == 0)
578 weight = FC_WEIGHT_THIN;
579 else if (strcasecmp("extralight", psfontinfo.weight) == 0)
580 weight = FC_WEIGHT_EXTRALIGHT;
581 else if (strcasecmp("ultralight", psfontinfo.weight) == 0)
582 weight = FC_WEIGHT_ULTRALIGHT;
583 else if (strcasecmp("light", psfontinfo.weight) == 0)
584 weight = FC_WEIGHT_LIGHT;
585 else if (strcasecmp("regular", psfontinfo.weight) == 0)
586 weight = FC_WEIGHT_REGULAR;
587 else if (strcasecmp("normal", psfontinfo.weight) == 0)
588 weight = FC_WEIGHT_NORMAL;
589 else if (strcasecmp("medium", psfontinfo.weight) == 0)
590 weight = FC_WEIGHT_MEDIUM;
591 else if (strcasecmp("demibold", psfontinfo.weight) == 0)
592 weight = FC_WEIGHT_DEMIBOLD;
593 else if (strcasecmp("semibold", psfontinfo.weight) == 0)
594 weight = FC_WEIGHT_SEMIBOLD;
595 else if (strcasecmp("extrabold", psfontinfo.weight) == 0)
596 weight = FC_WEIGHT_EXTRABOLD;
597 else if (strcasecmp("ultrabold", psfontinfo.weight) == 0)
598 weight = FC_WEIGHT_EXTRABOLD;
599 else if (strcasecmp("bold", psfontinfo.weight) == 0)
600 weight = FC_WEIGHT_BOLD;
601 else if (strcasecmp("black", psfontinfo.weight) == 0)
602 weight = FC_WEIGHT_BLACK;
603 else if (strcasecmp("heavy", psfontinfo.weight) == 0)
604 weight = FC_WEIGHT_BLACK;
605
606 if (psfontinfo.italic_angle < 0)
607 slant = FC_SLANT_ITALIC;
608 else if (psfontinfo.italic_angle >= 0)
609 slant = FC_SLANT_ROMAN;
610 }
611
612 if (!FcPatternAddInteger (pat, FC_SLANT, slant))
613 goto bail1;
614
615 if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
616 goto bail1;
617
618 if (width != -1)
619 if (!FcPatternAddInteger (pat, FC_WIDTH, width))
620 goto bail1;
621
622 /*
623 * Compute the unicode coverage for the font
624 */
625 cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
626 if (!cs)
627 goto bail1;
628
629 /*
630 * Skip over PCF fonts that have no encoded characters; they're
631 * usually just Unicode fonts transcoded to some legacy encoding
632 */
633 if (FcCharSetCount (cs) == 0)
634 {
635 if (!strcmp(FT_MODULE_CLASS(&face->driver->root)->module_name, "pcf"))
636 goto bail2;
637 }
638
639 if (!FcPatternAddCharSet (pat, FC_CHARSET, cs))
640 goto bail2;
641
642 ls = FcFreeTypeLangSet (cs, exclusiveLang);
643 if (!ls)
644 goto bail2;
645
646 if (!FcPatternAddLangSet (pat, FC_LANG, ls))
647 goto bail2;
648
649 if (spacing != FC_PROPORTIONAL)
650 if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
651 goto bail2;
652
653 /*
654 * Drop our reference to the charset
655 */
656 FcCharSetDestroy (cs);
657
658 if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
659 {
660 for (i = 0; i < face->num_fixed_sizes; i++)
661 if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE,
662 (double) face->available_sizes[i].height))
663 goto bail1;
664 if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
665 goto bail1;
666 }
667
668 FT_Done_Face (face);
669 FT_Done_FreeType (ftLibrary);
670 return pat;
671
672 bail2:
673 FcCharSetDestroy (cs);
674 bail1:
675 FcPatternDestroy (pat);
676 bail0:
677 FT_Done_Face (face);
678 bail:
679 FT_Done_FreeType (ftLibrary);
680 return 0;
681 }
682
683
684 /*
685 * Figure out whether the available freetype has FT_Get_Next_Char
686 */
687
688 #if FREETYPE_MAJOR > 2
689 # define HAS_NEXT_CHAR
690 #else
691 # if FREETYPE_MAJOR == 2
692 # if FREETYPE_MINOR > 0
693 # define HAS_NEXT_CHAR
694 # else
695 # if FREETYPE_MINOR == 0
696 # if FREETYPE_PATCH >= 9
697 # define HAS_NEXT_CHAR
698 # endif
699 # endif
700 # endif
701 # endif
702 #endif
703
704 /*
705 * For our purposes, this approximation is sufficient
706 */
707 #ifndef HAS_NEXT_CHAR
708 #define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
709 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
710 (*(gi) = 0), 0 : \
711 (*(gi) = 1), (ucs4) + 1)
712 #warning "No FT_Get_Next_Char"
713 #endif
714
715 typedef struct _FcCharEnt {
716 FcChar16 bmp;
717 unsigned char encode;
718 } FcCharEnt;
719
720 struct _FcCharMap {
721 const FcCharEnt *ent;
722 int nent;
723 };
724
725 typedef struct _FcFontDecode {
726 FT_Encoding encoding;
727 const FcCharMap *map;
728 FcChar32 max;
729 } FcFontDecode;
730
731 static const FcCharEnt AppleRomanEnt[] = {
732 { 0x0020, 0x20 }, /* SPACE */
733 { 0x0021, 0x21 }, /* EXCLAMATION MARK */
734 { 0x0022, 0x22 }, /* QUOTATION MARK */
735 { 0x0023, 0x23 }, /* NUMBER SIGN */
736 { 0x0024, 0x24 }, /* DOLLAR SIGN */
737 { 0x0025, 0x25 }, /* PERCENT SIGN */
738 { 0x0026, 0x26 }, /* AMPERSAND */
739 { 0x0027, 0x27 }, /* APOSTROPHE */
740 { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
741 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
742 { 0x002A, 0x2A }, /* ASTERISK */
743 { 0x002B, 0x2B }, /* PLUS SIGN */
744 { 0x002C, 0x2C }, /* COMMA */
745 { 0x002D, 0x2D }, /* HYPHEN-MINUS */
746 { 0x002E, 0x2E }, /* FULL STOP */
747 { 0x002F, 0x2F }, /* SOLIDUS */
748 { 0x0030, 0x30 }, /* DIGIT ZERO */
749 { 0x0031, 0x31 }, /* DIGIT ONE */
750 { 0x0032, 0x32 }, /* DIGIT TWO */
751 { 0x0033, 0x33 }, /* DIGIT THREE */
752 { 0x0034, 0x34 }, /* DIGIT FOUR */
753 { 0x0035, 0x35 }, /* DIGIT FIVE */
754 { 0x0036, 0x36 }, /* DIGIT SIX */
755 { 0x0037, 0x37 }, /* DIGIT SEVEN */
756 { 0x0038, 0x38 }, /* DIGIT EIGHT */
757 { 0x0039, 0x39 }, /* DIGIT NINE */
758 { 0x003A, 0x3A }, /* COLON */
759 { 0x003B, 0x3B }, /* SEMICOLON */
760 { 0x003C, 0x3C }, /* LESS-THAN SIGN */
761 { 0x003D, 0x3D }, /* EQUALS SIGN */
762 { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
763 { 0x003F, 0x3F }, /* QUESTION MARK */
764 { 0x0040, 0x40 }, /* COMMERCIAL AT */
765 { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
766 { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
767 { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
768 { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
769 { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
770 { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
771 { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
772 { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
773 { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
774 { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
775 { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
776 { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
777 { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
778 { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
779 { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
780 { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
781 { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
782 { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
783 { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
784 { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
785 { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
786 { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
787 { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
788 { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
789 { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
790 { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
791 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
792 { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
793 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
794 { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
795 { 0x005F, 0x5F }, /* LOW LINE */
796 { 0x0060, 0x60 }, /* GRAVE ACCENT */
797 { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
798 { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
799 { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
800 { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
801 { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
802 { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
803 { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
804 { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
805 { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
806 { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
807 { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
808 { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
809 { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
810 { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
811 { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
812 { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
813 { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
814 { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
815 { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
816 { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
817 { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
818 { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
819 { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
820 { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
821 { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
822 { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
823 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
824 { 0x007C, 0x7C }, /* VERTICAL LINE */
825 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
826 { 0x007E, 0x7E }, /* TILDE */
827 { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
828 { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
829 { 0x00A2, 0xA2 }, /* CENT SIGN */
830 { 0x00A3, 0xA3 }, /* POUND SIGN */
831 { 0x00A5, 0xB4 }, /* YEN SIGN */
832 { 0x00A7, 0xA4 }, /* SECTION SIGN */
833 { 0x00A8, 0xAC }, /* DIAERESIS */
834 { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
835 { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
836 { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
837 { 0x00AC, 0xC2 }, /* NOT SIGN */
838 { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
839 { 0x00AF, 0xF8 }, /* MACRON */
840 { 0x00B0, 0xA1 }, /* DEGREE SIGN */
841 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
842 { 0x00B4, 0xAB }, /* ACUTE ACCENT */
843 { 0x00B5, 0xB5 }, /* MICRO SIGN */
844 { 0x00B6, 0xA6 }, /* PILCROW SIGN */
845 { 0x00B7, 0xE1 }, /* MIDDLE DOT */
846 { 0x00B8, 0xFC }, /* CEDILLA */
847 { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
848 { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
849 { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
850 { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
851 { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
852 { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
853 { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
854 { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
855 { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
856 { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
857 { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
858 { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
859 { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
860 { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
861 { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
862 { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
863 { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
864 { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
865 { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
866 { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
867 { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
868 { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
869 { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
870 { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
871 { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
872 { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
873 { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
874 { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
875 { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
876 { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
877 { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
878 { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
879 { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
880 { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
881 { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
882 { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
883 { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
884 { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
885 { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
886 { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
887 { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
888 { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
889 { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
890 { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
891 { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
892 { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
893 { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
894 { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
895 { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
896 { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
897 { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
898 { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
899 { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
900 { 0x00F7, 0xD6 }, /* DIVISION SIGN */
901 { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
902 { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
903 { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
904 { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
905 { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
906 { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
907 { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
908 { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
909 { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
910 { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
911 { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
912 { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
913 { 0x02C7, 0xFF }, /* CARON */
914 { 0x02D8, 0xF9 }, /* BREVE */
915 { 0x02D9, 0xFA }, /* DOT ABOVE */
916 { 0x02DA, 0xFB }, /* RING ABOVE */
917 { 0x02DB, 0xFE }, /* OGONEK */
918 { 0x02DC, 0xF7 }, /* SMALL TILDE */
919 { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
920 { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
921 { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
922 { 0x2013, 0xD0 }, /* EN DASH */
923 { 0x2014, 0xD1 }, /* EM DASH */
924 { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
925 { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
926 { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
927 { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
928 { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
929 { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
930 { 0x2020, 0xA0 }, /* DAGGER */
931 { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
932 { 0x2022, 0xA5 }, /* BULLET */
933 { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
934 { 0x2030, 0xE4 }, /* PER MILLE SIGN */
935 { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
936 { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
937 { 0x2044, 0xDA }, /* FRACTION SLASH */
938 { 0x20AC, 0xDB }, /* EURO SIGN */
939 { 0x2122, 0xAA }, /* TRADE MARK SIGN */
940 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
941 { 0x2206, 0xC6 }, /* INCREMENT */
942 { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
943 { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
944 { 0x221A, 0xC3 }, /* SQUARE ROOT */
945 { 0x221E, 0xB0 }, /* INFINITY */
946 { 0x222B, 0xBA }, /* INTEGRAL */
947 { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
948 { 0x2260, 0xAD }, /* NOT EQUAL TO */
949 { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
950 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
951 { 0x25CA, 0xD7 }, /* LOZENGE */
952 { 0xF8FF, 0xF0 }, /* Apple logo */
953 { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
954 { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
955 };
956
957 static const FcCharMap AppleRoman = {
958 AppleRomanEnt,
959 sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
960 };
961
962 static const FcCharEnt AdobeSymbolEnt[] = {
963 { 0x0020, 0x20 }, /* SPACE # space */
964 { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */
965 { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */
966 { 0x0025, 0x25 }, /* PERCENT SIGN # percent */
967 { 0x0026, 0x26 }, /* AMPERSAND # ampersand */
968 { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */
969 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */
970 { 0x002B, 0x2B }, /* PLUS SIGN # plus */
971 { 0x002C, 0x2C }, /* COMMA # comma */
972 { 0x002E, 0x2E }, /* FULL STOP # period */
973 { 0x002F, 0x2F }, /* SOLIDUS # slash */
974 { 0x0030, 0x30 }, /* DIGIT ZERO # zero */
975 { 0x0031, 0x31 }, /* DIGIT ONE # one */
976 { 0x0032, 0x32 }, /* DIGIT TWO # two */
977 { 0x0033, 0x33 }, /* DIGIT THREE # three */
978 { 0x0034, 0x34 }, /* DIGIT FOUR # four */
979 { 0x0035, 0x35 }, /* DIGIT FIVE # five */
980 { 0x0036, 0x36 }, /* DIGIT SIX # six */
981 { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */
982 { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */
983 { 0x0039, 0x39 }, /* DIGIT NINE # nine */
984 { 0x003A, 0x3A }, /* COLON # colon */
985 { 0x003B, 0x3B }, /* SEMICOLON # semicolon */
986 { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
987 { 0x003D, 0x3D }, /* EQUALS SIGN # equal */
988 { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */
989 { 0x003F, 0x3F }, /* QUESTION MARK # question */
990 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */
991 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */
992 { 0x005F, 0x5F }, /* LOW LINE # underscore */
993 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */
994 { 0x007C, 0x7C }, /* VERTICAL LINE # bar */
995 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */
996 { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
997 { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */
998 { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */
999 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */
1000 { 0x00B5, 0x6D }, /* MICRO SIGN # mu */
1001 { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */
1002 { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */
1003 { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
1004 { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */
1005 { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */
1006 { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */
1007 { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */
1008 { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */
1009 { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */
1010 { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */
1011 { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */
1012 { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */
1013 { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */
1014 { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */
1015 { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */
1016 { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */
1017 { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */
1018 { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */
1019 { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */
1020 { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */
1021 { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */
1022 { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */
1023 { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */
1024 { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */
1025 { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */
1026 { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */
1027 { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */
1028 { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */
1029 { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */
1030 { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */
1031 { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */
1032 { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */
1033 { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */
1034 { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
1035 { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */
1036 { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */
1037 { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */
1038 { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */
1039 { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */
1040 { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */
1041 { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */
1042 { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */
1043 { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */
1044 { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
1045 { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
1046 { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */
1047 { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
1048 { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */
1049 { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
1050 { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
1051 { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
1052 { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */
1053 { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */
1054 { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
1055 { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */
1056 { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */
1057 { 0x2022, 0xB7 }, /* BULLET # bullet */
1058 { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */
1059 { 0x2032, 0xA2 }, /* PRIME # minute */
1060 { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */
1061 { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
1062 { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */
1063 { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
1064 { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */
1065 { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
1066 { 0x2126, 0x57 }, /* OHM SIGN # Omega */
1067 { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */
1068 { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */
1069 { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */
1070 { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */
1071 { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */
1072 { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */
1073 { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */
1074 { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
1075 { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */
1076 { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */
1077 { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
1078 { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */
1079 { 0x2200, 0x22 }, /* FOR ALL # universal */
1080 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */
1081 { 0x2203, 0x24 }, /* THERE EXISTS # existential */
1082 { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */
1083 { 0x2206, 0x44 }, /* INCREMENT # Delta */
1084 { 0x2207, 0xD1 }, /* NABLA # gradient */
1085 { 0x2208, 0xCE }, /* ELEMENT OF # element */
1086 { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */
1087 { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */
1088 { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */
1089 { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */
1090 { 0x2212, 0x2D }, /* MINUS SIGN # minus */
1091 { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
1092 { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */
1093 { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */
1094 { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */
1095 { 0x221E, 0xA5 }, /* INFINITY # infinity */
1096 { 0x2220, 0xD0 }, /* ANGLE # angle */
1097 { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */
1098 { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */
1099 { 0x2229, 0xC7 }, /* INTERSECTION # intersection */
1100 { 0x222A, 0xC8 }, /* UNION # union */
1101 { 0x222B, 0xF2 }, /* INTEGRAL # integral */
1102 { 0x2234, 0x5C }, /* THEREFORE # therefore */
1103 { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
1104 { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
1105 { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */
1106 { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */
1107 { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */
1108 { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */
1109 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */
1110 { 0x2282, 0xCC }, /* SUBSET OF # propersubset */
1111 { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */
1112 { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */
1113 { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */
1114 { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */
1115 { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */
1116 { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */
1117 { 0x22A5, 0x5E }, /* UP TACK # perpendicular */
1118 { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */
1119 { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */
1120 { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */
1121 { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */
1122 { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */
1123 { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */
1124 { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */
1125 { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */
1126 { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */
1127 { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */
1128 { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */
1129 { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */
1130 { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */
1131 { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */
1132 { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */
1133 { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */
1134 { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */
1135 { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */
1136 { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */
1137 { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
1138 { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */
1139 { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */
1140 { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */
1141 { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */
1142 { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */
1143 { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
1144 { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
1145 { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */
1146 { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
1147 { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */
1148 { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */
1149 { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */
1150 { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */
1151 { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */
1152 { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */
1153 { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */
1154 { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */
1155 { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */
1156 { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */
1157 };
1158
1159 static const FcCharMap AdobeSymbol = {
1160 AdobeSymbolEnt,
1161 sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
1162 };
1163
1164 static const FcFontDecode fcFontDecoders[] = {
1165 { ft_encoding_unicode, 0, (1 << 21) - 1 },
1166 { ft_encoding_symbol, &AdobeSymbol, (1 << 16) - 1 },
1167 { ft_encoding_apple_roman, &AppleRoman, (1 << 16) - 1 },
1168 };
1169
1170 #define NUM_DECODE (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
1171
1172 FcChar32
1173 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
1174 {
1175 int low, high, mid;
1176 FcChar16 bmp;
1177
1178 low = 0;
1179 high = map->nent - 1;
1180 if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
1181 return ~0;
1182 while (low <= high)
1183 {
1184 mid = (high + low) >> 1;
1185 bmp = map->ent[mid].bmp;
1186 if (ucs4 == bmp)
1187 return (FT_ULong) map->ent[mid].encode;
1188 if (ucs4 < bmp)
1189 high = mid - 1;
1190 else
1191 low = mid + 1;
1192 }
1193 return ~0;
1194 }
1195
1196 FcChar32
1197 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
1198 {
1199 int i;
1200
1201 for (i = 0; i < map->nent; i++)
1202 if (map->ent[i].encode == private)
1203 return (FcChar32) map->ent[i].bmp;
1204 return ~0;
1205 }
1206
1207 const FcCharMap *
1208 FcFreeTypeGetPrivateMap (FT_Encoding encoding)
1209 {
1210 int i;
1211
1212 for (i = 0; i < NUM_DECODE; i++)
1213 if (fcFontDecoders[i].encoding == encoding)
1214 return fcFontDecoders[i].map;
1215 return 0;
1216 }
1217
1218 /*
1219 * Map a UCS4 glyph to a glyph index. Use all available encoding
1220 * tables to try and find one that works. This information is expected
1221 * to be cached by higher levels, so performance isn't critical
1222 */
1223
1224 FT_UInt
1225 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
1226 {
1227 int initial, offset, decode;
1228 FT_UInt glyphindex;
1229 FcChar32 charcode;
1230
1231 initial = 0;
1232 /*
1233 * Find the current encoding
1234 */
1235 if (face->charmap)
1236 {
1237 for (; initial < NUM_DECODE; initial++)
1238 if (fcFontDecoders[initial].encoding == face->charmap->encoding)
1239 break;
1240 if (initial == NUM_DECODE)
1241 initial = 0;
1242 }
1243 /*
1244 * Check each encoding for the glyph, starting with the current one
1245 */
1246 for (offset = 0; offset < NUM_DECODE; offset++)
1247 {
1248 decode = (initial + offset) % NUM_DECODE;
1249 if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
1250 if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
1251 continue;
1252 if (fcFontDecoders[decode].map)
1253 {
1254 charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
1255 if (charcode == ~0)
1256 continue;
1257 }
1258 else
1259 charcode = ucs4;
1260 glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
1261 if (glyphindex)
1262 return glyphindex;
1263 }
1264 return 0;
1265 }
1266
1267 static FcBool
1268 FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
1269 FT_UInt glyph, FcBlanks *blanks,
1270 FT_Pos *advance)
1271 {
1272 FT_Int load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
1273 FT_GlyphSlot slot;
1274
1275 /*
1276 * When using scalable fonts, only report those glyphs
1277 * which can be scaled; otherwise those fonts will
1278 * only be available at some sizes, and never when
1279 * transformed. Avoid this by simply reporting bitmap-only
1280 * glyphs as missing
1281 */
1282 if (face->face_flags & FT_FACE_FLAG_SCALABLE)
1283 load_flags |= FT_LOAD_NO_BITMAP;
1284
1285 if (FT_Load_Glyph (face, glyph, load_flags))
1286 return FcFalse;
1287
1288 slot = face->glyph;
1289 if (!glyph)
1290 return FcFalse;
1291
1292 *advance = slot->metrics.horiAdvance;
1293
1294 switch (slot->format) {
1295 case ft_glyph_format_bitmap:
1296 /*
1297 * Bitmaps are assumed to be reasonable; if
1298 * this proves to be a rash assumption, this
1299 * code can be easily modified
1300 */
1301 return FcTrue;
1302 case ft_glyph_format_outline:
1303 /*
1304 * Glyphs with contours are always OK
1305 */
1306 if (slot->outline.n_contours != 0)
1307 return FcTrue;
1308 /*
1309 * Glyphs with no contours are only OK if
1310 * they're members of the Blanks set specified
1311 * in the configuration. If blanks isn't set,
1312 * then allow any glyph to be blank
1313 */
1314 if (!blanks || FcBlanksIsMember (blanks, ucs4))
1315 return FcTrue;
1316 /* fall through ... */
1317 default:
1318 break;
1319 }
1320 return FcFalse;
1321 }
1322
1323 FcCharSet *
1324 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
1325 {
1326 FcChar32 page, off, max, ucs4;
1327 #ifdef CHECK
1328 FcChar32 font_max = 0;
1329 #endif
1330 FcCharSet *fcs;
1331 FcCharLeaf *leaf;
1332 const FcCharMap *map;
1333 int o;
1334 int i;
1335 FT_UInt glyph;
1336 FT_Pos advance, all_advance = 0;
1337 FcBool has_advance = FcFalse, fixed_advance = FcTrue;
1338
1339 fcs = FcCharSetCreate ();
1340 if (!fcs)
1341 goto bail0;
1342
1343 for (o = 0; o < NUM_DECODE; o++)
1344 {
1345 if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
1346 continue;
1347 map = fcFontDecoders[o].map;
1348 if (map)
1349 {
1350 /*
1351 * Non-Unicode tables are easy; there's a list of all possible
1352 * characters
1353 */
1354 for (i = 0; i < map->nent; i++)
1355 {
1356 ucs4 = map->ent[i].bmp;
1357 glyph = FT_Get_Char_Index (face, map->ent[i].encode);
1358 if (glyph &&
1359 FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
1360 {
1361 if (!has_advance)
1362 {
1363 has_advance = FcTrue;
1364 all_advance = advance;
1365 }
1366 else if (advance != all_advance)
1367 fixed_advance = FcFalse;
1368 leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1369 if (!leaf)
1370 goto bail1;
1371 leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
1372 #ifdef CHECK
1373 if (ucs4 > font_max)
1374 font_max = ucs4;
1375 #endif
1376 }
1377 }
1378 }
1379 else
1380 {
1381 FT_UInt gindex;
1382
1383 max = fcFontDecoders[o].max;
1384 /*
1385 * Find the first encoded character in the font
1386 */
1387 if (FT_Get_Char_Index (face, 0))
1388 {
1389 ucs4 = 0;
1390 gindex = 1;
1391 }
1392 else
1393 {
1394 ucs4 = FT_Get_Next_Char (face, 0, &gindex);
1395 if (!ucs4)
1396 gindex = 0;
1397 }
1398
1399 while (gindex)
1400 {
1401 page = ucs4 >> 8;
1402 leaf = 0;
1403 while ((ucs4 >> 8) == page)
1404 {
1405 glyph = FT_Get_Char_Index (face, ucs4);
1406 if (glyph && FcFreeTypeCheckGlyph (face, ucs4,
1407 glyph, blanks, &advance))
1408 {
1409 if (!has_advance)
1410 {
1411 has_advance = FcTrue;
1412 all_advance = advance;
1413 }
1414 else if (advance != all_advance)
1415 fixed_advance = FcFalse;
1416 if (!leaf)
1417 {
1418 leaf = FcCharSetFindLeafCreate (fcs, ucs4);
1419 if (!leaf)
1420 goto bail1;
1421 }
1422 off = ucs4 & 0xff;
1423 leaf->map[off >> 5] |= (1 << (off & 0x1f));
1424 #ifdef CHECK
1425 if (ucs4 > font_max)
1426 font_max = ucs4;
1427 #endif
1428 }
1429 ucs4++;
1430 }
1431 ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
1432 if (!ucs4)
1433 gindex = 0;
1434 }
1435 #ifdef CHECK
1436 for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
1437 {
1438 FcBool FT_Has, FC_Has;
1439
1440 FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
1441 FC_Has = FcCharSetHasChar (fcs, ucs4);
1442 if (FT_Has != FC_Has)
1443 {
1444 printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
1445 }
1446 }
1447 #endif
1448 }
1449 }
1450 #ifdef CHECK
1451 printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
1452 for (ucs4 = 0; ucs4 <= font_max; ucs4++)
1453 {
1454 FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
1455 FcBool has_bit = FcCharSetHasChar (fcs, ucs4);
1456
1457 if (has_char && !has_bit)
1458 printf ("Bitmap missing char 0x%x\n", ucs4);
1459 else if (!has_char && has_bit)
1460 printf ("Bitmap extra char 0x%x\n", ucs4);
1461 }
1462 #endif
1463 if (fixed_advance)
1464 *spacing = FC_MONO;
1465 else
1466 *spacing = FC_PROPORTIONAL;
1467 return fcs;
1468 bail1:
1469 FcCharSetDestroy (fcs);
1470 bail0:
1471 return 0;
1472 }
1473
1474 FcCharSet *
1475 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
1476 {
1477 int spacing;
1478
1479 return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
1480 }
http://fontconfig.org/