]> 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
Skip bitmap fonts which can't even get it together enough to declare a
[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 /*
26 Copyright © 2002-2003 by Juliusz Chroboczek
27
28 Permission is hereby granted, free of charge, to any person obtaining a copy
29 of this software and associated documentation files (the "Software"), to deal
30 in the Software without restriction, including without limitation the rights
31 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
32 copies of the Software, and to permit persons to whom the Software is
33 furnished to do so, subject to the following conditions:
34
35 The above copyright notice and this permission notice shall be included in
36 all copies or substantial portions of the Software.
37
38 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
39 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
40 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
41 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
42 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
43 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
44 THE SOFTWARE.
45 */
46
47 #include <stdlib.h>
48 #include <stdio.h>
49 #include <string.h>
50 #include <libgen.h>
51 #include "fcint.h"
52 #include <ft2build.h>
53 #include FT_FREETYPE_H
54 #include FT_TRUETYPE_TABLES_H
55 #include FT_SFNT_NAMES_H
56 #include FT_TRUETYPE_IDS_H
57 #include FT_TYPE1_TABLES_H
58 #if HAVE_FT_GET_X11_FONT_FORMAT
59 #include FT_XFREE86_H
60 #endif
61 #if HAVE_FT_GET_BDF_PROPERTY
62 #include FT_BDF_H
63 #include FT_MODULE_H
64 #endif
65
66 #include "ftglue.h"
67
68 #if !HAVE_FT_GET_BDF_PROPERTY
69 #warning "No FT_Get_BDF_Property: Please install freetype 2.1.4 or later"
70 #endif
71
72 #if !HAVE_FT_GET_PS_FONT_INFO
73 #warning "No FT_Get_PS_Font_Info: Please install freetype 2.1.1 or later"
74 #endif
75
76 /*
77 * Keep Han languages separated by eliminating languages
78 * that the codePageRange bits says aren't supported
79 */
80
81 static const struct {
82 int bit;
83 const FcChar8 *lang;
84 } FcCodePageRange[] = {
85 { 17, (const FcChar8 *) "ja" },
86 { 18, (const FcChar8 *) "zh-cn" },
87 { 19, (const FcChar8 *) "ko" },
88 { 20, (const FcChar8 *) "zh-tw" },
89 };
90
91 #define NUM_CODE_PAGE_RANGE (int) (sizeof FcCodePageRange / sizeof FcCodePageRange[0])
92
93 FcBool
94 FcFreeTypeIsExclusiveLang (const FcChar8 *lang)
95 {
96 int i;
97
98 for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
99 {
100 if (FcLangCompare (lang, FcCodePageRange[i].lang) == FcLangEqual)
101 return FcTrue;
102 }
103 return FcFalse;
104 }
105
106 typedef struct {
107 const FT_UShort platform_id;
108 const FT_UShort encoding_id;
109 const char fromcode[12];
110 } FcFtEncoding;
111
112 #define TT_ENCODING_DONT_CARE 0xffff
113 #define FC_ENCODING_MAC_ROMAN "MACINTOSH"
114
115 static const FcFtEncoding fcFtEncoding[] = {
116 { TT_PLATFORM_APPLE_UNICODE, TT_ENCODING_DONT_CARE, "UCS-2BE" },
117 { TT_PLATFORM_MACINTOSH, TT_MAC_ID_ROMAN, "MACINTOSH" },
118 { TT_PLATFORM_MACINTOSH, TT_MAC_ID_JAPANESE, "SJIS" },
119 { TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, "UTF-16BE" },
120 { TT_PLATFORM_MICROSOFT, TT_MS_ID_SJIS, "SJIS-WIN" },
121 { TT_PLATFORM_MICROSOFT, TT_MS_ID_GB2312, "GB3212" },
122 { TT_PLATFORM_MICROSOFT, TT_MS_ID_BIG_5, "BIG-5" },
123 { TT_PLATFORM_MICROSOFT, TT_MS_ID_WANSUNG, "Wansung" },
124 { TT_PLATFORM_MICROSOFT, TT_MS_ID_JOHAB, "Johab" },
125 { TT_PLATFORM_MICROSOFT, TT_MS_ID_UCS_4, "UCS4" },
126 { TT_PLATFORM_ISO, TT_ISO_ID_7BIT_ASCII, "ASCII" },
127 { TT_PLATFORM_ISO, TT_ISO_ID_10646, "UCS-2BE" },
128 { TT_PLATFORM_ISO, TT_ISO_ID_8859_1, "ISO-8859-1" },
129 };
130
131 #define NUM_FC_FT_ENCODING (int) (sizeof (fcFtEncoding) / sizeof (fcFtEncoding[0]))
132
133 typedef struct {
134 const FT_UShort platform_id;
135 const FT_UShort language_id;
136 const char lang[8];
137 } FcFtLanguage;
138
139 #define TT_LANGUAGE_DONT_CARE 0xffff
140
141 static const FcFtLanguage fcFtLanguage[] = {
142 { TT_PLATFORM_APPLE_UNICODE, TT_LANGUAGE_DONT_CARE, "" },
143 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ENGLISH, "en" },
144 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_FRENCH, "fr" },
145 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GERMAN, "de" },
146 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ITALIAN, "it" },
147 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_DUTCH, "nl" },
148 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SWEDISH, "sv" },
149 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SPANISH, "es" },
150 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_DANISH, "da" },
151 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_PORTUGUESE, "pt" },
152 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_NORWEGIAN, "no" },
153 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_HEBREW, "he" },
154 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_JAPANESE, "ja" },
155 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ARABIC, "ar" },
156 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_FINNISH, "fi" },
157 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GREEK, "el" },
158 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ICELANDIC, "is" },
159 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MALTESE, "mt" },
160 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TURKISH, "tr" },
161 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CROATIAN, "hr" },
162 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CHINESE_TRADITIONAL, "zh-tw" },
163 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_URDU, "ur" },
164 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_HINDI, "hi" },
165 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_THAI, "th" },
166 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KOREAN, "ko" },
167 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_LITHUANIAN, "lt" },
168 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_POLISH, "pl" },
169 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_HUNGARIAN, "hu" },
170 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ESTONIAN, "et" },
171 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_LETTISH, "lv" },
172 /* { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SAAMISK, ??? */
173 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_FAEROESE, "fo" },
174 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_FARSI, "fa" },
175 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_RUSSIAN, "ru" },
176 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CHINESE_SIMPLIFIED, "zh-cn" },
177 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_FLEMISH, "nl" },
178 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_IRISH, "ga" },
179 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ALBANIAN, "sq" },
180 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ROMANIAN, "ro" },
181 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CZECH, "cs" },
182 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SLOVAK, "sk" },
183 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SLOVENIAN, "sl" },
184 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_YIDDISH, "yi" },
185 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SERBIAN, "sr" },
186 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MACEDONIAN, "mk" },
187 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BULGARIAN, "bg" },
188 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_UKRAINIAN, "uk" },
189 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BYELORUSSIAN, "be" },
190 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_UZBEK, "uz" },
191 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KAZAKH, "kk" },
192 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AZERBAIJANI, "az" },
193 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT, "az" },
194 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT, "ar" },
195 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ARMENIAN, "hy" },
196 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GEORGIAN, "ka" },
197 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MOLDAVIAN, "mo" },
198 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KIRGHIZ, "ky" },
199 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TAJIKI, "tg" },
200 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TURKMEN, "tk" },
201 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MONGOLIAN, "mo" },
202 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT,"mo" },
203 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT, "mo" },
204 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_PASHTO, "ps" },
205 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KURDISH, "ku" },
206 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KASHMIRI, "ks" },
207 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SINDHI, "sd" },
208 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TIBETAN, "bo" },
209 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_NEPALI, "ne" },
210 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SANSKRIT, "sa" },
211 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MARATHI, "mr" },
212 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BENGALI, "bn" },
213 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ASSAMESE, "as" },
214 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GUJARATI, "gu" },
215 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_PUNJABI, "pa" },
216 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ORIYA, "or" },
217 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MALAYALAM, "ml" },
218 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KANNADA, "kn" },
219 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TAMIL, "ta" },
220 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TELUGU, "te" },
221 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SINHALESE, "si" },
222 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BURMESE, "my" },
223 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_KHMER, "km" },
224 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_LAO, "lo" },
225 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_VIETNAMESE, "vi" },
226 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_INDONESIAN, "id" },
227 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TAGALOG, "tl" },
228 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MALAY_ROMAN_SCRIPT, "ms" },
229 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MALAY_ARABIC_SCRIPT, "ms" },
230 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AMHARIC, "am" },
231 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TIGRINYA, "ti" },
232 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GALLA, "om" },
233 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SOMALI, "so" },
234 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SWAHILI, "sw" },
235 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_RUANDA, "rw" },
236 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_RUNDI, "rn" },
237 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CHEWA, "ny" },
238 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MALAGASY, "mg" },
239 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_ESPERANTO, "eo" },
240 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_WELSH, "cy" },
241 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BASQUE, "eu" },
242 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_CATALAN, "ca" },
243 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_LATIN, "la" },
244 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_QUECHUA, "qu" },
245 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GUARANI, "gn" },
246 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AYMARA, "ay" },
247 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TATAR, "tt" },
248 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_UIGHUR, "ug" },
249 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_DZONGKHA, "dz" },
250 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_JAVANESE, "jw" },
251 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SUNDANESE, "su" },
252
253 #if 0 /* these seem to be errors that have been dropped */
254
255 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SCOTTISH_GAELIC },
256 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_IRISH_GAELIC },
257
258 #endif
259
260 /* The following codes are new as of 2000-03-10 */
261 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GALICIAN, "gl" },
262 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AFRIKAANS, "af" },
263 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_BRETON, "br" },
264 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_INUKTITUT, "iu" },
265 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_SCOTTISH_GAELIC, "gd" },
266 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_MANX_GAELIC, "gv" },
267 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_IRISH_GAELIC, "ga" },
268 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_TONGAN, "to" },
269 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GREEK_POLYTONIC, "el" },
270 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_GREELANDIC, "ik" },
271 { TT_PLATFORM_MACINTOSH, TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT,"az" },
272
273 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_SAUDI_ARABIA, "ar" },
274 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_IRAQ, "ar" },
275 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_EGYPT, "ar" },
276 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_LIBYA, "ar" },
277 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_ALGERIA, "ar" },
278 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_MOROCCO, "ar" },
279 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_TUNISIA, "ar" },
280 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_OMAN, "ar" },
281 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_YEMEN, "ar" },
282 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_SYRIA, "ar" },
283 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_JORDAN, "ar" },
284 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_LEBANON, "ar" },
285 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_KUWAIT, "ar" },
286 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_UAE, "ar" },
287 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_BAHRAIN, "ar" },
288 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_QATAR, "ar" },
289 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BULGARIAN_BULGARIA, "bg" },
290 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CATALAN_SPAIN, "ca" },
291 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_TAIWAN, "zh-tw" },
292 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_PRC, "zh-cn" },
293 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_HONG_KONG, "zh-hk" },
294 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_SINGAPORE, "zh-sg" },
295
296 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_MACAU, "zh-mo" },
297
298 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CZECH_CZECH_REPUBLIC, "cs" },
299 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_DANISH_DENMARK, "da" },
300 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GERMAN_GERMANY, "de" },
301 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GERMAN_SWITZERLAND, "de" },
302 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GERMAN_AUSTRIA, "de" },
303 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GERMAN_LUXEMBOURG, "de" },
304 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GERMAN_LIECHTENSTEI, "de" },
305 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GREEK_GREECE, "el" },
306 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_UNITED_STATES, "en" },
307 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_UNITED_KINGDOM, "en" },
308 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_AUSTRALIA, "en" },
309 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_CANADA, "en" },
310 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_NEW_ZEALAND, "en" },
311 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_IRELAND, "en" },
312 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_SOUTH_AFRICA, "en" },
313 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_JAMAICA, "en" },
314 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_CARIBBEAN, "en" },
315 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_BELIZE, "en" },
316 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_TRINIDAD, "en" },
317 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_ZIMBABWE, "en" },
318 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_PHILIPPINES, "en" },
319 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT,"es" },
320 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_MEXICO, "es" },
321 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT,"es" },
322 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_GUATEMALA, "es" },
323 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_COSTA_RICA, "es" },
324 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_PANAMA, "es" },
325 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC,"es" },
326 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_VENEZUELA, "es" },
327 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_COLOMBIA, "es" },
328 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_PERU, "es" },
329 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_ARGENTINA, "es" },
330 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_ECUADOR, "es" },
331 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_CHILE, "es" },
332 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_URUGUAY, "es" },
333 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_PARAGUAY, "es" },
334 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_BOLIVIA, "es" },
335 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_EL_SALVADOR, "es" },
336 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_HONDURAS, "es" },
337 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_NICARAGUA, "es" },
338 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_PUERTO_RICO, "es" },
339 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FINNISH_FINLAND, "fi" },
340 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_FRANCE, "fr" },
341 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_BELGIUM, "fr" },
342 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_CANADA, "fr" },
343 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_SWITZERLAND, "fr" },
344 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_LUXEMBOURG, "fr" },
345 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_MONACO, "fr" },
346 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_HEBREW_ISRAEL, "he" },
347 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_HUNGARIAN_HUNGARY, "hu" },
348 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ICELANDIC_ICELAND, "is" },
349 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ITALIAN_ITALY, "it" },
350 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ITALIAN_SWITZERLAND, "it" },
351 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_JAPANESE_JAPAN, "ja" },
352 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA,"ko" },
353 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KOREAN_JOHAB_KOREA, "ko" },
354 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_DUTCH_NETHERLANDS, "nl" },
355 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_DUTCH_BELGIUM, "nl" },
356 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL, "no" },
357 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK, "nn" },
358 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_POLISH_POLAND, "pl" },
359 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PORTUGUESE_BRAZIL, "pt" },
360 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PORTUGUESE_PORTUGAL, "pt" },
361 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND,"rm" },
362 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ROMANIAN_ROMANIA, "ro" },
363 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MOLDAVIAN_MOLDAVIA, "mo" },
364 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_RUSSIAN_RUSSIA, "ru" },
365 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_RUSSIAN_MOLDAVIA, "ru" },
366 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CROATIAN_CROATIA, "hr" },
367 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SERBIAN_SERBIA_LATIN, "sr" },
368 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC, "sr" },
369 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SLOVAK_SLOVAKIA, "sk" },
370 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ALBANIAN_ALBANIA, "sq" },
371 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SWEDISH_SWEDEN, "sv" },
372 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SWEDISH_FINLAND, "sv" },
373 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_THAI_THAILAND, "th" },
374 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TURKISH_TURKEY, "tr" },
375 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_URDU_PAKISTAN, "ur" },
376 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_INDONESIAN_INDONESIA, "id" },
377 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_UKRAINIAN_UKRAINE, "uk" },
378 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BELARUSIAN_BELARUS, "be" },
379 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SLOVENE_SLOVENIA, "sl" },
380 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ESTONIAN_ESTONIA, "et" },
381 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_LATVIAN_LATVIA, "lv" },
382 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_LITHUANIAN_LITHUANIA, "lt" },
383 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA,"lt" },
384
385 #ifdef TT_MS_LANGID_MAORI_NEW_ZELAND
386 /* this seems to be an error that have been dropped */
387 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MAORI_NEW_ZEALAND, "mi" },
388 #endif
389
390 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FARSI_IRAN, "fa" },
391 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_VIETNAMESE_VIET_NAM, "vi" },
392 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARMENIAN_ARMENIA, "hy" },
393 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN, "az" },
394 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC, "az" },
395 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BASQUE_SPAIN, "eu" },
396 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SORBIAN_GERMANY, "wen" },
397 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MACEDONIAN_MACEDONIA, "mk" },
398 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SUTU_SOUTH_AFRICA, "st" },
399 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TSONGA_SOUTH_AFRICA, "ts" },
400 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TSWANA_SOUTH_AFRICA, "tn" },
401 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_VENDA_SOUTH_AFRICA, "ven" },
402 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_XHOSA_SOUTH_AFRICA, "xh" },
403 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ZULU_SOUTH_AFRICA, "zu" },
404 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA, "af" },
405 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GEORGIAN_GEORGIA, "ka" },
406 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS, "fo" },
407 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_HINDI_INDIA, "hi" },
408 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MALTESE_MALTA, "mt" },
409 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SAAMI_LAPONIA, "se" },
410
411 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM,"gd" },
412 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_IRISH_GAELIC_IRELAND, "ga" },
413
414 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MALAY_MALAYSIA, "ms" },
415 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM, "ms" },
416 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KAZAK_KAZAKSTAN, "kk" },
417 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SWAHILI_KENYA, "sw" },
418 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN, "uz" },
419 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC, "uz" },
420 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TATAR_TATARSTAN, "tt" },
421 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BENGALI_INDIA, "bn" },
422 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PUNJABI_INDIA, "pa" },
423 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GUJARATI_INDIA, "gu" },
424 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ORIYA_INDIA, "or" },
425 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TAMIL_INDIA, "ta" },
426 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TELUGU_INDIA, "te" },
427 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KANNADA_INDIA, "kn" },
428 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MALAYALAM_INDIA, "ml" },
429 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ASSAMESE_INDIA, "as" },
430 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MARATHI_INDIA, "mr" },
431 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SANSKRIT_INDIA, "sa" },
432 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KONKANI_INDIA, "kok" },
433
434 /* new as of 2001-01-01 */
435 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ARABIC_GENERAL, "ar" },
436 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHINESE_GENERAL, "zh" },
437 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_GENERAL, "en" },
438 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_WEST_INDIES, "fr" },
439 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_REUNION, "fr" },
440 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_CONGO, "fr" },
441
442 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_SENEGAL, "fr" },
443 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_CAMEROON, "fr" },
444 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_COTE_D_IVOIRE, "fr" },
445 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_MALI, "fr" },
446 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA,"bs" },
447 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_URDU_INDIA, "ur" },
448 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TAJIK_TAJIKISTAN, "tg" },
449 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_YIDDISH_GERMANY, "yi" },
450 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN, "ky" },
451
452 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TURKMEN_TURKMENISTAN, "tk" },
453 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MONGOLIAN_MONGOLIA, "mn" },
454
455 /* the following seems to be inconsistent;
456 here is the current "official" way: */
457 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TIBETAN_BHUTAN, "bo" },
458 /* and here is what is used by Passport SDK */
459 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TIBETAN_CHINA, "bo" },
460 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_DZONGHKA_BHUTAN, "dz" },
461 /* end of inconsistency */
462
463 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_WELSH_WALES, "cy" },
464 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KHMER_CAMBODIA, "km" },
465 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_LAO_LAOS, "lo" },
466 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BURMESE_MYANMAR, "my" },
467 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GALICIAN_SPAIN, "gl" },
468 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MANIPURI_INDIA, "mni" },
469 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SINDHI_INDIA, "sd" },
470 /* the following one is only encountered in Microsoft RTF specification */
471 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KASHMIRI_PAKISTAN, "ks" },
472 /* the following one is not in the Passport list, looks like an omission */
473 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KASHMIRI_INDIA, "ks" },
474 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_NEPALI_NEPAL, "ne" },
475 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_NEPALI_INDIA, "ne" },
476 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRISIAN_NETHERLANDS, "fy" },
477
478 /* new as of 2001-03-01 (from Office Xp) */
479 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_HONG_KONG, "en" },
480 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_INDIA, "en" },
481 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_MALAYSIA, "en" },
482 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_ENGLISH_SINGAPORE, "en" },
483 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SYRIAC_SYRIA, "syr" },
484 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SINHALESE_SRI_LANKA, "si" },
485 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_CHEROKEE_UNITED_STATES, "chr" },
486 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_INUKTITUT_CANADA, "iu" },
487 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_AMHARIC_ETHIOPIA, "am" },
488 #if 0
489 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TAMAZIGHT_MOROCCO },
490 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN },
491 #endif
492 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PASHTO_AFGHANISTAN, "ps" },
493 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FILIPINO_PHILIPPINES, "phi" },
494 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_DHIVEHI_MALDIVES, "div" },
495
496 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_OROMO_ETHIOPIA, "om" },
497 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TIGRIGNA_ETHIOPIA, "ti" },
498 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_TIGRIGNA_ERYTHREA, "ti" },
499
500 /* New additions from Windows Xp/Passport SDK 2001-11-10. */
501
502 /* don't ask what this one means... It is commented out currently. */
503 #if 0
504 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GREEK_GREECE2 },
505 #endif
506
507 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_UNITED_STATES, "es" },
508 /* The following two IDs blatantly violate MS specs by using a */
509 /* sublanguage >,. */
510 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SPANISH_LATIN_AMERICA, "es" },
511 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_NORTH_AFRICA, "fr" },
512
513 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_MOROCCO, "fr" },
514 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FRENCH_HAITI, "fr" },
515 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_BENGALI_BANGLADESH, "bn" },
516 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN, "ar" },
517 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN,"mn" },
518 #if 0
519 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_EDO_NIGERIA },
520 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_FULFULDE_NIGERIA },
521 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_IBIBIO_NIGERIA },
522 #endif
523 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_HAUSA_NIGERIA, "ha" },
524 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_YORUBA_NIGERIA, "yo" },
525 /* language codes from, to, are (still) unknown. */
526 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_IGBO_NIGERIA, "ibo" },
527 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_KANURI_NIGERIA, "kau" },
528 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_GUARANI_PARAGUAY, "gn" },
529 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_HAWAIIAN_UNITED_STATES, "haw" },
530 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_LATIN, "la" },
531 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_SOMALI_SOMALIA, "so" },
532 #if 0
533 /* Note: Yi does not have a (proper) ISO 639-2 code, since it is mostly */
534 /* not written (but OTOH the peculiar writing system is worth */
535 /* studying). */
536 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_YI_CHINA },
537 #endif
538 { TT_PLATFORM_MICROSOFT, TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES,"pap" },
539 };
540
541 #define NUM_FC_FT_LANGUAGE (int) (sizeof (fcFtLanguage) / sizeof (fcFtLanguage[0]))
542
543 typedef struct {
544 FT_UShort language_id;
545 char fromcode[12];
546 } FcMacRomanFake;
547
548 static const FcMacRomanFake fcMacRomanFake[] = {
549 { TT_MS_LANGID_JAPANESE_JAPAN, "SJIS-WIN" },
550 { TT_MS_LANGID_ENGLISH_UNITED_STATES, "ASCII" },
551 };
552
553 static FcChar8 *
554 FcFontCapabilities(FT_Face face);
555
556 #define NUM_FC_MAC_ROMAN_FAKE (int) (sizeof (fcMacRomanFake) / sizeof (fcMacRomanFake[0]))
557
558 #if HAVE_ICONV && HAVE_ICONV_H
559 #define USE_ICONV 1
560 #include <iconv.h>
561 #endif
562
563 static FcChar8 *
564 FcSfntNameTranscode (FT_SfntName *sname)
565 {
566 int i;
567 const char *fromcode;
568 #if USE_ICONV
569 iconv_t cd;
570 #endif
571 FcChar8 *utf8;
572
573 for (i = 0; i < NUM_FC_FT_ENCODING; i++)
574 if (fcFtEncoding[i].platform_id == sname->platform_id &&
575 (fcFtEncoding[i].encoding_id == TT_ENCODING_DONT_CARE ||
576 fcFtEncoding[i].encoding_id == sname->encoding_id))
577 break;
578 if (i == NUM_FC_FT_ENCODING)
579 return 0;
580 fromcode = fcFtEncoding[i].fromcode;
581
582 /*
583 * "real" Mac language IDs are all less than 150.
584 * Names using one of the MS language IDs are assumed
585 * to use an associated encoding (Yes, this is a kludge)
586 */
587 if (!strcmp (fromcode, FC_ENCODING_MAC_ROMAN) &&
588 sname->language_id >= 0x100)
589 {
590 int f;
591
592 fromcode = NULL;
593 for (f = 0; f < NUM_FC_MAC_ROMAN_FAKE; f++)
594 if (fcMacRomanFake[f].language_id == sname->language_id)
595 {
596 fromcode = fcMacRomanFake[f].fromcode;
597 break;
598 }
599 if (!fromcode)
600 return 0;
601 }
602 if (!strcmp (fromcode, "UCS-2BE") || !strcmp (fromcode, "UTF-16BE"))
603 {
604 FcChar8 *src = sname->string;
605 int src_len = sname->string_len;
606 int len;
607 int wchar;
608 int ilen, olen;
609 FcChar8 *u8;
610 FcChar32 ucs4;
611
612 /*
613 * Convert Utf16 to Utf8
614 */
615
616 if (!FcUtf16Len (src, FcEndianBig, src_len, &len, &wchar))
617 return 0;
618
619 /*
620 * Allocate plenty of space. Freed below
621 */
622 utf8 = malloc (len * FC_UTF8_MAX_LEN + 1);
623 if (!utf8)
624 return 0;
625
626 u8 = utf8;
627
628 while ((ilen = FcUtf16ToUcs4 (src, FcEndianBig, &ucs4, src_len)) > 0)
629 {
630 src_len -= ilen;
631 src += ilen;
632 olen = FcUcs4ToUtf8 (ucs4, u8);
633 u8 += olen;
634 }
635 *u8 = '\0';
636 goto done;
637 }
638 if (!strcmp (fromcode, "ASCII") || !strcmp (fromcode, "ISO-8859-1"))
639 {
640 FcChar8 *src = sname->string;
641 int src_len = sname->string_len;
642 int olen;
643 FcChar8 *u8;
644 FcChar32 ucs4;
645
646 /*
647 * Convert Latin1 to Utf8. Freed below
648 */
649 utf8 = malloc (src_len * 2 + 1);
650 if (!utf8)
651 return 0;
652
653 u8 = utf8;
654 while (src_len > 0)
655 {
656 ucs4 = *src++;
657 src_len--;
658 olen = FcUcs4ToUtf8 (ucs4, u8);
659 u8 += olen;
660 }
661 *u8 = '\0';
662 goto done;
663 }
664 if (!strcmp (fromcode, FC_ENCODING_MAC_ROMAN))
665 {
666 FcChar8 *u8;
667 const FcCharMap *map = FcFreeTypeGetPrivateMap (ft_encoding_apple_roman);
668 FcChar8 *src = (FcChar8 *) sname->string;
669 int src_len = sname->string_len;
670
671 /*
672 * Convert AppleRoman to Utf8
673 */
674 if (!map)
675 return 0;
676
677 utf8 = malloc (sname->string_len * 3 + 1);
678 if (!utf8)
679 return 0;
680
681 u8 = utf8;
682 while (src_len > 0)
683 {
684 FcChar32 ucs4 = FcFreeTypePrivateToUcs4 (*src++, map);
685 int olen = FcUcs4ToUtf8 (ucs4, u8);
686 src_len--;
687 u8 += olen;
688 }
689 *u8 = '\0';
690 goto done;
691 }
692 #if USE_ICONV
693 cd = iconv_open ("UTF-8", fromcode);
694 if (cd && cd != (iconv_t) (-1))
695 {
696 size_t in_bytes_left = sname->string_len;
697 size_t out_bytes_left = sname->string_len * FC_UTF8_MAX_LEN;
698 char *inbuf, *outbuf;
699
700 utf8 = malloc (out_bytes_left + 1);
701 if (!utf8)
702 {
703 iconv_close (cd);
704 return 0;
705 }
706
707 outbuf = (char *) utf8;
708 inbuf = (char *) sname->string;
709
710 while (in_bytes_left)
711 {
712 size_t did = iconv (cd,
713 &inbuf, &in_bytes_left,
714 &outbuf, &out_bytes_left);
715 if (did == (size_t) (-1))
716 {
717 iconv_close (cd);
718 free (utf8);
719 return 0;
720 }
721 }
722 iconv_close (cd);
723 *outbuf = '\0';
724 goto done;
725 }
726 #endif
727 return 0;
728 done:
729 if (FcStrCmpIgnoreBlanksAndCase (utf8, (FcChar8 *) "") == 0)
730 {
731 free (utf8);
732 return 0;
733 }
734 return utf8;
735 }
736
737 static const FcChar8 *
738 FcSfntNameLanguage (FT_SfntName *sname)
739 {
740 int i;
741 for (i = 0; i < NUM_FC_FT_LANGUAGE; i++)
742 if (fcFtLanguage[i].platform_id == sname->platform_id &&
743 (fcFtLanguage[i].language_id == TT_LANGUAGE_DONT_CARE ||
744 fcFtLanguage[i].language_id == sname->language_id))
745 {
746 if (fcFtLanguage[i].lang[0] == '\0')
747 return NULL;
748 else
749 return (FcChar8 *) fcFtLanguage[i].lang;
750 }
751 return 0;
752 }
753
754 /* Order is significant. For example, some B&H fonts are hinted by
755 URW++, and both strings appear in the notice. */
756
757 static const struct {
758 const FT_String *notice;
759 const FcChar8 *foundry;
760 } FcNoticeFoundries[] = {
761 { (const FT_String *) "Bigelow", (const FcChar8 *) "b&h" },
762 { (const FT_String *) "Adobe", (const FcChar8 *) "adobe" },
763 { (const FT_String *) "Bitstream", (const FcChar8 *) "bitstream" },
764 { (const FT_String *) "Monotype", (const FcChar8 *) "monotype" },
765 { (const FT_String *) "Linotype", (const FcChar8 *) "linotype" },
766 { (const FT_String *) "LINOTYPE-HELL",
767 (const FcChar8 *) "linotype" },
768 { (const FT_String *) "IBM", (const FcChar8 *) "ibm" },
769 { (const FT_String *) "URW", (const FcChar8 *) "urw" },
770 { (const FT_String *) "International Typeface Corporation",
771 (const FcChar8 *) "itc" },
772 { (const FT_String *) "Tiro Typeworks",
773 (const FcChar8 *) "tiro" },
774 { (const FT_String *) "XFree86", (const FcChar8 *) "xfree86" },
775 { (const FT_String *) "Microsoft", (const FcChar8 *) "microsoft" },
776 { (const FT_String *) "Omega", (const FcChar8 *) "omega" },
777 { (const FT_String *) "Font21", (const FcChar8 *) "hwan" },
778 { (const FT_String *) "HanYang System",
779 (const FcChar8 *) "hanyang" }
780 };
781
782 #define NUM_NOTICE_FOUNDRIES (int) (sizeof (FcNoticeFoundries) / sizeof (FcNoticeFoundries[0]))
783
784 static const FcChar8 *
785 FcNoticeFoundry(const FT_String *notice)
786 {
787 int i;
788
789 if (notice)
790 for(i = 0; i < NUM_NOTICE_FOUNDRIES; i++)
791 if (strstr ((const char *) notice, (const char *) FcNoticeFoundries[i].notice))
792 return FcNoticeFoundries[i].foundry;
793 return 0;
794 }
795
796 static FcBool
797 FcVendorMatch(const FT_Char vendor[4], const FT_Char *vendor_string)
798 {
799 /* vendor is not necessarily NUL-terminated. */
800 int i, len;
801
802 len = strlen((char *) vendor_string);
803 if (memcmp(vendor, vendor_string, len) != 0)
804 return FcFalse;
805 for (i = len; i < 4; i++)
806 if (vendor[i] != ' ' && vendor[i] != '\0')
807 return FcFalse;
808 return FcTrue;
809 }
810
811 /* This table is partly taken from ttmkfdir by Joerg Pommnitz. */
812
813 /* It should not contain useless entries (such as UNKN) nor duplicate
814 entries for padding both with spaces and NULs. */
815
816 static const struct {
817 const FT_Char *vendor;
818 const FcChar8 *foundry;
819 } FcVendorFoundries[] = {
820 { (const FT_Char *) "ADBE", (const FcChar8 *) "adobe"},
821 { (const FT_Char *) "AGFA", (const FcChar8 *) "agfa"},
822 { (const FT_Char *) "ALTS", (const FcChar8 *) "altsys"},
823 { (const FT_Char *) "APPL", (const FcChar8 *) "apple"},
824 { (const FT_Char *) "ARPH", (const FcChar8 *) "arphic"},
825 { (const FT_Char *) "ATEC", (const FcChar8 *) "alltype"},
826 { (const FT_Char *) "B&H", (const FcChar8 *) "b&h"},
827 { (const FT_Char *) "BITS", (const FcChar8 *) "bitstream"},
828 { (const FT_Char *) "CANO", (const FcChar8 *) "cannon"},
829 { (const FT_Char *) "DYNA", (const FcChar8 *) "dynalab"},
830 { (const FT_Char *) "EPSN", (const FcChar8 *) "epson"},
831 { (const FT_Char *) "FJ", (const FcChar8 *) "fujitsu"},
832 { (const FT_Char *) "IBM", (const FcChar8 *) "ibm"},
833 { (const FT_Char *) "ITC", (const FcChar8 *) "itc"},
834 { (const FT_Char *) "IMPR", (const FcChar8 *) "impress"},
835 { (const FT_Char *) "LARA", (const FcChar8 *) "larabiefonts"},
836 { (const FT_Char *) "LEAF", (const FcChar8 *) "interleaf"},
837 { (const FT_Char *) "LETR", (const FcChar8 *) "letraset"},
838 { (const FT_Char *) "LINO", (const FcChar8 *) "linotype"},
839 { (const FT_Char *) "MACR", (const FcChar8 *) "macromedia"},
840 { (const FT_Char *) "MONO", (const FcChar8 *) "monotype"},
841 { (const FT_Char *) "MS", (const FcChar8 *) "microsoft"},
842 { (const FT_Char *) "MT", (const FcChar8 *) "monotype"},
843 { (const FT_Char *) "NEC", (const FcChar8 *) "nec"},
844 { (const FT_Char *) "PARA", (const FcChar8 *) "paratype"},
845 { (const FT_Char *) "QMSI", (const FcChar8 *) "qms"},
846 { (const FT_Char *) "RICO", (const FcChar8 *) "ricoh"},
847 { (const FT_Char *) "URW", (const FcChar8 *) "urw"},
848 { (const FT_Char *) "Y&Y", (const FcChar8 *) "y&y"}
849 };
850
851 #define NUM_VENDOR_FOUNDRIES (int) (sizeof (FcVendorFoundries) / sizeof (FcVendorFoundries[0]))
852
853 static const FcChar8 *
854 FcVendorFoundry(const FT_Char vendor[4])
855 {
856 int i;
857
858 if (vendor)
859 for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++)
860 if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor))
861 return FcVendorFoundries[i].foundry;
862 return 0;
863 }
864
865 typedef struct _FcStringConst {
866 const FcChar8 *name;
867 int value;
868 } FcStringConst;
869
870 static int
871 FcStringIsConst (const FcChar8 *string,
872 const FcStringConst *c,
873 int nc)
874 {
875 int i;
876
877 for (i = 0; i < nc; i++)
878 if (FcStrCmpIgnoreBlanksAndCase (string, c[i].name) == 0)
879 return c[i].value;
880 return -1;
881 }
882
883 static int
884 FcStringContainsConst (const FcChar8 *string,
885 const FcStringConst *c,
886 int nc)
887 {
888 int i;
889
890 for (i = 0; i < nc; i++)
891 if (FcStrContainsIgnoreBlanksAndCase (string, c[i].name))
892 return c[i].value;
893 return -1;
894 }
895
896 typedef FcChar8 *FC8;
897
898 static const FcStringConst weightConsts[] = {
899 { (FC8) "thin", FC_WEIGHT_THIN },
900 { (FC8) "extralight", FC_WEIGHT_EXTRALIGHT },
901 { (FC8) "ultralight", FC_WEIGHT_ULTRALIGHT },
902 { (FC8) "light", FC_WEIGHT_LIGHT },
903 { (FC8) "book", FC_WEIGHT_BOOK },
904 { (FC8) "regular", FC_WEIGHT_REGULAR },
905 { (FC8) "normal", FC_WEIGHT_NORMAL },
906 { (FC8) "medium", FC_WEIGHT_MEDIUM },
907 { (FC8) "demibold", FC_WEIGHT_DEMIBOLD },
908 { (FC8) "demi", FC_WEIGHT_DEMIBOLD },
909 { (FC8) "semibold", FC_WEIGHT_SEMIBOLD },
910 { (FC8) "bold", FC_WEIGHT_BOLD },
911 { (FC8) "extrabold", FC_WEIGHT_EXTRABOLD },
912 { (FC8) "ultrabold", FC_WEIGHT_ULTRABOLD },
913 { (FC8) "black", FC_WEIGHT_BLACK },
914 { (FC8) "heavy", FC_WEIGHT_HEAVY },
915 };
916
917 #define NUM_WEIGHT_CONSTS (int) (sizeof (weightConsts) / sizeof (weightConsts[0]))
918
919 #define FcIsWeight(s) FcStringIsConst(s,weightConsts,NUM_WEIGHT_CONSTS)
920 #define FcContainsWeight(s) FcStringContainsConst (s,weightConsts,NUM_WEIGHT_CONSTS)
921
922 static const FcStringConst widthConsts[] = {
923 { (FC8) "ultracondensed", FC_WIDTH_ULTRACONDENSED },
924 { (FC8) "extracondensed", FC_WIDTH_EXTRACONDENSED },
925 { (FC8) "semicondensed", FC_WIDTH_SEMICONDENSED },
926 { (FC8) "condensed", FC_WIDTH_CONDENSED }, /* must be after *condensed */
927 { (FC8) "normal", FC_WIDTH_NORMAL },
928 { (FC8) "semiexpanded", FC_WIDTH_SEMIEXPANDED },
929 { (FC8) "extraexpanded", FC_WIDTH_EXTRAEXPANDED },
930 { (FC8) "ultraexpanded", FC_WIDTH_ULTRAEXPANDED },
931 { (FC8) "expanded", FC_WIDTH_EXPANDED }, /* must be after *expanded */
932 };
933
934 #define NUM_WIDTH_CONSTS (int) (sizeof (widthConsts) / sizeof (widthConsts[0]))
935
936 #define FcIsWidth(s) FcStringIsConst(s,widthConsts,NUM_WIDTH_CONSTS)
937 #define FcContainsWidth(s) FcStringContainsConst (s,widthConsts,NUM_WIDTH_CONSTS)
938
939 static const FcStringConst slantConsts[] = {
940 { (FC8) "italic", FC_SLANT_ITALIC },
941 { (FC8) "oblique", FC_SLANT_OBLIQUE },
942 };
943
944 #define NUM_SLANT_CONSTS (int) (sizeof (slantConsts) / sizeof (slantConsts[0]))
945
946 #define FcIsSlant(s) FcStringIsConst(s,slantConsts,NUM_SLANT_CONSTS)
947 #define FcContainsSlant(s) FcStringContainsConst (s,slantConsts,NUM_SLANT_CONSTS)
948
949 static double
950 FcGetPixelSize (FT_Face face, int i)
951 {
952 #if HAVE_FT_GET_BDF_PROPERTY
953 if (face->num_fixed_sizes == 1)
954 {
955 BDF_PropertyRec prop;
956 int rc;
957
958 rc = FT_Get_BDF_Property (face, "PIXEL_SIZE", &prop);
959 if (rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
960 return (double) prop.u.integer;
961 }
962 #endif
963 #if HAVE_FT_BITMAP_SIZE_Y_PPEM
964 return (double) face->available_sizes[i].y_ppem / 64.0;
965 #else
966 return (double) face->available_sizes[i].height;
967 #endif
968 }
969
970 static FcBool
971 FcStringInPatternElement (FcPattern *pat, const char *elt, FcChar8 *string)
972 {
973 int e;
974 FcChar8 *old;
975 for (e = 0; FcPatternGetString (pat, elt, e, &old) == FcResultMatch; e++)
976 if (!FcStrCmpIgnoreBlanksAndCase (old, string))
977 {
978 return FcTrue;
979 break;
980 }
981 return FcFalse;
982 }
983
984 FcPattern *
985 FcFreeTypeQuery (const FcChar8 *file,
986 int id,
987 FcBlanks *blanks,
988 int *count)
989 {
990 FT_Face face;
991 FcPattern *pat;
992 int slant = -1;
993 int weight = -1;
994 int width = -1;
995 int i;
996 FcCharSet *cs;
997 FcLangSet *ls;
998 FT_Library ftLibrary;
999 #if 0
1000 FcChar8 *family = 0;
1001 #endif
1002 FcChar8 *complex;
1003 FcChar8 *file2;
1004 const FcChar8 *foundry = 0;
1005 int spacing;
1006 TT_OS2 *os2;
1007 #if HAVE_FT_GET_PS_FONT_INFO
1008 PS_FontInfoRec psfontinfo;
1009 #endif
1010 #if HAVE_FT_GET_BDF_PROPERTY
1011 BDF_PropertyRec prop;
1012 #endif
1013 TT_Header *head;
1014 const FcChar8 *exclusiveLang = 0;
1015 FT_SfntName sname;
1016 FT_UInt snamei, snamec;
1017
1018 int nfamily = 0;
1019 int nfamily_lang = 0;
1020 int nstyle = 0;
1021 int nstyle_lang = 0;
1022 int nfullname = 0;
1023 int nfullname_lang = 0;
1024
1025 FcChar8 *style = 0;
1026 int st;
1027
1028 if (FT_Init_FreeType (&ftLibrary))
1029 return 0;
1030
1031 if (FT_New_Face (ftLibrary, (char *) file, id, &face))
1032 goto bail;
1033
1034 *count = face->num_faces;
1035
1036 pat = FcPatternCreate ();
1037 if (!pat)
1038 goto bail0;
1039
1040 if (!FcPatternAddBool (pat, FC_OUTLINE,
1041 (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
1042 goto bail1;
1043
1044 if (!FcPatternAddBool (pat, FC_SCALABLE,
1045 (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
1046 goto bail1;
1047
1048
1049 /*
1050 * Get the OS/2 table
1051 */
1052 os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
1053
1054 /*
1055 * Look first in the OS/2 table for the foundry, if
1056 * not found here, the various notices will be searched for
1057 * that information, either from the sfnt name tables or
1058 * the Postscript FontInfo dictionary. Finally, the
1059 * BDF properties will queried.
1060 */
1061
1062 if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
1063 foundry = FcVendorFoundry(os2->achVendID);
1064
1065 if (FcDebug () & FC_DBG_SCANV)
1066 printf ("\n");
1067 /*
1068 * Grub through the name table looking for family
1069 * and style names. FreeType makes quite a hash
1070 * of them
1071 */
1072 snamec = FT_Get_Sfnt_Name_Count (face);
1073 for (snamei = 0; snamei < snamec; snamei++)
1074 {
1075 FcChar8 *utf8;
1076 const FcChar8 *lang;
1077 const char *elt = 0, *eltlang = 0;
1078 int *np = 0, *nlangp = 0;
1079
1080 if (FT_Get_Sfnt_Name (face, snamei, &sname) != 0)
1081 continue;
1082
1083 utf8 = FcSfntNameTranscode (&sname);
1084 lang = FcSfntNameLanguage (&sname);
1085
1086 if (!utf8)
1087 continue;
1088
1089 switch (sname.name_id) {
1090 case TT_NAME_ID_FONT_FAMILY:
1091 #if 0
1092 case TT_NAME_ID_PS_NAME:
1093 case TT_NAME_ID_UNIQUE_ID:
1094 #endif
1095 if (FcDebug () & FC_DBG_SCANV)
1096 printf ("found family (n %2d p %d e %d l 0x%04x) %s\n",
1097 sname.name_id, sname.platform_id,
1098 sname.encoding_id, sname.language_id,
1099 utf8);
1100
1101 elt = FC_FAMILY;
1102 eltlang = FC_FAMILYLANG;
1103 np = &nfamily;
1104 nlangp = &nfamily_lang;
1105 break;
1106 case TT_NAME_ID_FULL_NAME:
1107 case TT_NAME_ID_MAC_FULL_NAME:
1108 if (FcDebug () & FC_DBG_SCANV)
1109 printf ("found full (n %2d p %d e %d l 0x%04x) %s\n",
1110 sname.name_id, sname.platform_id,
1111 sname.encoding_id, sname.language_id,
1112 utf8);
1113
1114 elt = FC_FULLNAME;
1115 eltlang = FC_FULLNAMELANG;
1116 np = &nfullname;
1117 nlangp = &nfullname_lang;
1118 break;
1119 case TT_NAME_ID_FONT_SUBFAMILY:
1120 if (FcDebug () & FC_DBG_SCANV)
1121 printf ("found style (n %2d p %d e %d l 0x%04x) %s\n",
1122 sname.name_id, sname.platform_id,
1123 sname.encoding_id, sname.language_id,
1124 utf8);
1125
1126 elt = FC_STYLE;
1127 eltlang = FC_STYLELANG;
1128 np = &nstyle;
1129 nlangp = &nstyle_lang;
1130 break;
1131 case TT_NAME_ID_TRADEMARK:
1132 case TT_NAME_ID_MANUFACTURER:
1133 /* If the foundry wasn't found in the OS/2 table, look here */
1134 if(!foundry)
1135 foundry = FcNoticeFoundry((FT_String *) utf8);
1136 break;
1137 }
1138 if (elt)
1139 {
1140 if (FcStringInPatternElement (pat, elt, utf8))
1141 {
1142 free (utf8);
1143 continue;
1144 }
1145
1146 /* add new element */
1147 if (!FcPatternAddString (pat, elt, utf8))
1148 {
1149 free (utf8);
1150 goto bail1;
1151 }
1152 free (utf8);
1153 if (lang)
1154 {
1155 /* pad lang list with 'xx' to line up with elt */
1156 while (*nlangp < *np)
1157 {
1158 if (!FcPatternAddString (pat, eltlang, (FcChar8 *) "xx"))
1159 goto bail1;
1160 ++*nlangp;
1161 }
1162 if (!FcPatternAddString (pat, eltlang, lang))
1163 goto bail1;
1164 ++*nlangp;
1165 }
1166 ++*np;
1167 }
1168 else
1169 free (utf8);
1170 }
1171
1172 if (!nfamily && face->family_name &&
1173 FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->family_name, (FcChar8 *) "") != 0)
1174 {
1175 if (FcDebug () & FC_DBG_SCANV)
1176 printf ("using FreeType family \"%s\"\n", face->family_name);
1177 if (!FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) face->family_name))
1178 goto bail1;
1179 ++nfamily;
1180 }
1181
1182 if (!nstyle && face->style_name &&
1183 FcStrCmpIgnoreBlanksAndCase ((FcChar8 *) face->style_name, (FcChar8 *) "") != 0)
1184 {
1185 if (FcDebug () & FC_DBG_SCANV)
1186 printf ("using FreeType style \"%s\"\n", face->style_name);
1187 if (!FcPatternAddString (pat, FC_STYLE, (FcChar8 *) face->style_name))
1188 goto bail1;
1189 ++nstyle;
1190 }
1191
1192 if (!nfamily)
1193 {
1194 FcChar8 *start, *end;
1195 FcChar8 *family;
1196
1197 start = (FcChar8 *) strrchr ((char *) file, '/');
1198 if (start)
1199 start++;
1200 else
1201 start = (FcChar8 *) file;
1202 end = (FcChar8 *) strrchr ((char *) start, '.');
1203 if (!end)
1204 end = start + strlen ((char *) start);
1205 /* freed below */
1206 family = malloc (end - start + 1);
1207 strncpy ((char *) family, (char *) start, end - start);
1208 family[end - start] = '\0';
1209 if (FcDebug () & FC_DBG_SCANV)
1210 printf ("using filename for family %s\n", family);
1211 if (!FcPatternAddString (pat, FC_FAMILY, family))
1212 {
1213 free (family);
1214 goto bail1;
1215 }
1216 free (family);
1217 ++nfamily;
1218 }
1219
1220 /*
1221 * Walk through FC_FULLNAME entries eliding those in FC_FAMILY
1222 * or which are simply a FC_FAMILY and FC_STYLE glued together
1223 */
1224 {
1225 int fn, fa, st;
1226 FcChar8 *full;
1227 FcChar8 *fam;
1228 FcChar8 *style;
1229
1230 for (fn = 0; FcPatternGetString (pat, FC_FULLNAME, fn, &full) == FcResultMatch; fn++)
1231 {
1232 FcBool remove = FcFalse;
1233 /*
1234 * Check each family
1235 */
1236 for (fa = 0; !remove &&
1237 FcPatternGetString (pat, FC_FAMILY,
1238 fa, &fam) == FcResultMatch;
1239 fa++)
1240 {
1241 /*
1242 * for exact match
1243 */
1244 if (!FcStrCmpIgnoreBlanksAndCase (full, fam))
1245 {
1246 remove = FcTrue;
1247 break;
1248 }
1249 /*
1250 * If the family is in the full name, check the
1251 * combination of this family with every style
1252 */
1253 if (!FcStrContainsIgnoreBlanksAndCase (full, fam))
1254 continue;
1255 for (st = 0; !remove &&
1256 FcPatternGetString (pat, FC_STYLE,
1257 st, &style) == FcResultMatch;
1258 st++)
1259 {
1260 FcChar8 *both = FcStrPlus (fam, style);
1261
1262 if (both)
1263 {
1264 if (FcStrCmpIgnoreBlanksAndCase (full, both) == 0)
1265 remove = FcTrue;
1266 free (both);
1267 }
1268 }
1269 }
1270 if (remove)
1271 {
1272 FcPatternRemove (pat, FC_FULLNAME, fn);
1273 FcPatternRemove (pat, FC_FULLNAMELANG, fn);
1274 fn--;
1275 nfullname--;
1276 nfullname_lang--;
1277 }
1278 }
1279 if (FcDebug () & FC_DBG_SCANV)
1280 for (fn = 0; FcPatternGetString (pat, FC_FULLNAME, fn, &full) == FcResultMatch; fn++)
1281 printf ("Saving unique fullname %s\n", full);
1282 }
1283
1284 file2 = FcStrCopy (file);
1285 if (!FcPatternAddString (pat, FC_FILE, (FcChar8 *)basename((char *)file2)))
1286 {
1287 FcStrFree (file2);
1288 goto bail1;
1289 }
1290 FcStrFree (file2);
1291
1292 FcPatternAddFullFname (pat, (const char *)FcStrCopy (file));
1293
1294 if (!FcPatternAddInteger (pat, FC_INDEX, id))
1295 goto bail1;
1296
1297 #if 0
1298 /*
1299 * don't even try this -- CJK 'monospace' fonts are really
1300 * dual width, and most other fonts don't bother to set
1301 * the attribute. Sigh.
1302 */
1303 if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
1304 if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO))
1305 goto bail1;
1306 #endif
1307
1308 /*
1309 * Find the font revision (if available)
1310 */
1311 head = (TT_Header *) FT_Get_Sfnt_Table (face, ft_sfnt_head);
1312 if (head)
1313 {
1314 if (!FcPatternAddInteger (pat, FC_FONTVERSION, head->Font_Revision))
1315 goto bail1;
1316 }
1317 else
1318 {
1319 if (!FcPatternAddInteger (pat, FC_FONTVERSION, 0))
1320 goto bail1;
1321 }
1322
1323 if (os2 && os2->version >= 0x0001 && os2->version != 0xffff)
1324 {
1325 for (i = 0; i < NUM_CODE_PAGE_RANGE; i++)
1326 {
1327 FT_ULong bits;
1328 int bit;
1329 if (FcCodePageRange[i].bit < 32)
1330 {
1331 bits = os2->ulCodePageRange1;
1332 bit = FcCodePageRange[i].bit;
1333 }
1334 else
1335 {
1336 bits = os2->ulCodePageRange2;
1337 bit = FcCodePageRange[i].bit - 32;
1338 }
1339 if (bits & (1 << bit))
1340 {
1341 /*
1342 * If the font advertises support for multiple
1343 * "exclusive" languages, then include support
1344 * for any language found to have coverage
1345 */
1346 if (exclusiveLang)
1347 {
1348 exclusiveLang = 0;
1349 break;
1350 }
1351 exclusiveLang = FcCodePageRange[i].lang;
1352 }
1353 }
1354 }
1355
1356 if (os2 && os2->version != 0xffff)
1357 {
1358 if (os2->usWeightClass == 0)
1359 ;
1360 else if (os2->usWeightClass < 150)
1361 weight = FC_WEIGHT_THIN;
1362 else if (os2->usWeightClass < 250)
1363 weight = FC_WEIGHT_EXTRALIGHT;
1364 else if (os2->usWeightClass < 350)
1365 weight = FC_WEIGHT_LIGHT;
1366 else if (os2->usWeightClass < 450)
1367 weight = FC_WEIGHT_REGULAR;
1368 else if (os2->usWeightClass < 550)
1369 weight = FC_WEIGHT_MEDIUM;
1370 else if (os2->usWeightClass < 650)
1371 weight = FC_WEIGHT_SEMIBOLD;
1372 else if (os2->usWeightClass < 750)
1373 weight = FC_WEIGHT_BOLD;
1374 else if (os2->usWeightClass < 850)
1375 weight = FC_WEIGHT_EXTRABOLD;
1376 else if (os2->usWeightClass < 950)
1377 weight = FC_WEIGHT_BLACK;
1378
1379 switch (os2->usWidthClass) {
1380 case 1: width = FC_WIDTH_ULTRACONDENSED; break;
1381 case 2: width = FC_WIDTH_EXTRACONDENSED; break;
1382 case 3: width = FC_WIDTH_CONDENSED; break;
1383 case 4: width = FC_WIDTH_SEMICONDENSED; break;
1384 case 5: width = FC_WIDTH_NORMAL; break;
1385 case 6: width = FC_WIDTH_SEMIEXPANDED; break;
1386 case 7: width = FC_WIDTH_EXPANDED; break;
1387 case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
1388 case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
1389 }
1390 }
1391 if (os2 && (complex = FcFontCapabilities(face)))
1392 {
1393 if (!FcPatternAddString (pat, FC_CAPABILITY, complex))
1394 {
1395 free (complex);
1396 goto bail1;
1397 }
1398 free (complex);
1399 }
1400
1401 /*
1402 * Type 1: Check for FontInfo dictionary information
1403 * Code from g2@magestudios.net (Gerard Escalante)
1404 */
1405
1406 #if HAVE_FT_GET_PS_FONT_INFO
1407 if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0)
1408 {
1409 if (weight == -1 && psfontinfo.weight)
1410 {
1411 weight = FcIsWeight ((FcChar8 *) psfontinfo.weight);
1412 if (FcDebug() & FC_DBG_SCANV)
1413 printf ("\tType1 weight %s maps to %d\n",
1414 psfontinfo.weight, weight);
1415 }
1416
1417 #if 0
1418 /*
1419 * Don't bother with italic_angle; FreeType already extracts that
1420 * information for us and sticks it into style_flags
1421 */
1422 if (psfontinfo.italic_angle)
1423 slant = FC_SLANT_ITALIC;
1424 else
1425 slant = FC_SLANT_ROMAN;
1426 #endif
1427
1428 if(!foundry)
1429 foundry = FcNoticeFoundry(psfontinfo.notice);
1430 }
1431 #endif /* HAVE_FT_GET_PS_FONT_INFO */
1432
1433 #if HAVE_FT_GET_BDF_PROPERTY
1434 /*
1435 * Finally, look for a FOUNDRY BDF property if no other
1436 * mechanism has managed to locate a foundry
1437 */
1438
1439 if (!foundry)
1440 {
1441 int rc;
1442 BDF_PropertyRec prop;
1443 rc = FT_Get_BDF_Property(face, "FOUNDRY", &prop);
1444 if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM)
1445 foundry = (FcChar8 *) prop.u.atom;
1446 }
1447
1448 if (width == -1)
1449 {
1450 if (FT_Get_BDF_Property(face, "RELATIVE_SETWIDTH", &prop) == 0 &&
1451 (prop.type == BDF_PROPERTY_TYPE_INTEGER ||
1452 prop.type == BDF_PROPERTY_TYPE_CARDINAL))
1453 {
1454 FT_Int32 value;
1455
1456 if (prop.type == BDF_PROPERTY_TYPE_INTEGER)
1457 value = prop.u.integer;
1458 else
1459 value = (FT_Int32) prop.u.cardinal;
1460 switch ((value + 5) / 10) {
1461 case 1: width = FC_WIDTH_ULTRACONDENSED; break;
1462 case 2: width = FC_WIDTH_EXTRACONDENSED; break;
1463 case 3: width = FC_WIDTH_CONDENSED; break;
1464 case 4: width = FC_WIDTH_SEMICONDENSED; break;
1465 case 5: width = FC_WIDTH_NORMAL; break;
1466 case 6: width = FC_WIDTH_SEMIEXPANDED; break;
1467 case 7: width = FC_WIDTH_EXPANDED; break;
1468 case 8: width = FC_WIDTH_EXTRAEXPANDED; break;
1469 case 9: width = FC_WIDTH_ULTRAEXPANDED; break;
1470 }
1471 }
1472 if (width == -1 &&
1473 FT_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 &&
1474 prop.type == BDF_PROPERTY_TYPE_ATOM)
1475 {
1476 width = FcIsWidth ((FcChar8 *) prop.u.atom);
1477 if (FcDebug () & FC_DBG_SCANV)
1478 printf ("\tsetwidth %s maps to %d\n", prop.u.atom, width);
1479 }
1480 }
1481 #endif
1482
1483 /*
1484 * Look for weight, width and slant names in the style value
1485 */
1486 for (st = 0; FcPatternGetString (pat, FC_STYLE, st, &style) == FcResultMatch; st++)
1487 {
1488 if (weight == -1)
1489 {
1490 weight = FcContainsWeight (style);
1491 if (FcDebug() & FC_DBG_SCANV)
1492 printf ("\tStyle %s maps to weight %d\n", style, weight);
1493 }
1494 if (width == -1)
1495 {
1496 width = FcContainsWidth (style);
1497 if (FcDebug() & FC_DBG_SCANV)
1498 printf ("\tStyle %s maps to width %d\n", style, width);
1499 }
1500 if (slant == -1)
1501 {
1502 slant = FcContainsSlant (style);
1503 if (FcDebug() & FC_DBG_SCANV)
1504 printf ("\tStyle %s maps to slant %d\n", style, slant);
1505 }
1506 }
1507 /*
1508 * Pull default values from the FreeType flags if more
1509 * specific values not found above
1510 */
1511 if (slant == -1)
1512 {
1513 slant = FC_SLANT_ROMAN;
1514 if (face->style_flags & FT_STYLE_FLAG_ITALIC)
1515 slant = FC_SLANT_ITALIC;
1516 }
1517
1518 if (weight == -1)
1519 {
1520 weight = FC_WEIGHT_MEDIUM;
1521 if (face->style_flags & FT_STYLE_FLAG_BOLD)
1522 weight = FC_WEIGHT_BOLD;
1523 }
1524
1525 if (width == -1)
1526 width = FC_WIDTH_NORMAL;
1527
1528 if (foundry == 0)
1529 foundry = (FcChar8 *) "unknown";
1530
1531 if (!FcPatternAddInteger (pat, FC_SLANT, slant))
1532 goto bail1;
1533
1534 if (!FcPatternAddInteger (pat, FC_WEIGHT, weight))
1535 goto bail1;
1536
1537 if (!FcPatternAddInteger (pat, FC_WIDTH, width))
1538 goto bail1;
1539
1540 if (!FcPatternAddString (pat, FC_FOUNDRY, foundry))
1541 goto bail1;
1542
1543 /*
1544 * Compute the unicode coverage for the font
1545 */
1546 cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
1547 if (!cs)
1548 goto bail1;
1549
1550 #if HAVE_FT_GET_BDF_PROPERTY
1551 /* For PCF fonts, override the computed spacing with the one from
1552 the property */
1553 if(FT_Get_BDF_Property(face, "SPACING", &prop) == 0 &&
1554 prop.type == BDF_PROPERTY_TYPE_ATOM) {
1555 if(!strcmp(prop.u.atom, "c") || !strcmp(prop.u.atom, "C"))
1556 spacing = FC_CHARCELL;
1557 else if(!strcmp(prop.u.atom, "m") || !strcmp(prop.u.atom, "M"))
1558 spacing = FC_MONO;
1559 else if(!strcmp(prop.u.atom, "p") || !strcmp(prop.u.atom, "P"))
1560 spacing = FC_PROPORTIONAL;
1561 }
1562 #endif
1563
1564 /*
1565 * Skip over PCF fonts that have no encoded characters; they're
1566 * usually just Unicode fonts transcoded to some legacy encoding
1567 * ftglue.c forces us to approximate whether a font is a PCF font
1568 * or not by whether it has any BDF properties. Try PIXEL_SIZE;
1569 * I don't know how to get a list of BDF properties on the font. -PL
1570 */
1571 if (FcCharSetCount (cs) == 0)
1572 {
1573 #if HAVE_FT_GET_BDF_PROPERTY
1574 if(FT_Get_BDF_Property(face, "PIXEL_SIZE", &prop) == 0)
1575 goto bail2;
1576 #endif
1577 }
1578
1579 if (!FcPatternAddCharSet (pat, FC_CHARSET, cs))
1580 goto bail2;
1581
1582 ls = FcFreeTypeLangSet (cs, exclusiveLang);
1583 if (!ls)
1584 goto bail2;
1585
1586 if (!FcPatternAddLangSet (pat, FC_LANG, ls))
1587 {
1588 FcLangSetDestroy (ls);
1589 goto bail2;
1590 }
1591
1592 FcLangSetDestroy (ls);
1593
1594 if (spacing != FC_PROPORTIONAL)
1595 if (!FcPatternAddInteger (pat, FC_SPACING, spacing))
1596 goto bail2;
1597
1598 if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
1599 {
1600 for (i = 0; i < face->num_fixed_sizes; i++)
1601 if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE,
1602 FcGetPixelSize (face, i)))
1603 goto bail1;
1604 if (!FcPatternAddBool (pat, FC_ANTIALIAS, FcFalse))
1605 goto bail1;
1606 #if HAVE_FT_GET_BDF_PROPERTY
1607 if(face->num_fixed_sizes == 1) {
1608 int rc;
1609 int value;
1610 BDF_PropertyRec prop;
1611
1612 /* skip bitmap fonts which do not even have a family name */
1613 rc = FT_Get_BDF_Property(face, "FAMILY_NAME", &prop);
1614 if (rc != 0 || prop.type != BDF_PROPERTY_TYPE_ATOM)
1615 goto bail2;
1616
1617 rc = FT_Get_BDF_Property(face, "POINT_SIZE", &prop);
1618 if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1619 value = prop.u.integer;
1620 else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1621 value = prop.u.cardinal;
1622 else
1623 goto nevermind;
1624 if(!FcPatternAddDouble(pat, FC_SIZE, value / 10.0))
1625 goto nevermind;
1626
1627 rc = FT_Get_BDF_Property(face, "RESOLUTION_Y", &prop);
1628 if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_INTEGER)
1629 value = prop.u.integer;
1630 else if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_CARDINAL)
1631 value = prop.u.cardinal;
1632 else
1633 goto nevermind;
1634 if(!FcPatternAddDouble(pat, FC_DPI, (double)value))
1635 goto nevermind;
1636
1637 }
1638 nevermind:
1639 ;
1640 #endif
1641 }
1642 #if HAVE_FT_GET_X11_FONT_FORMAT
1643 /*
1644 * Use the (not well documented or supported) X-specific function
1645 * from FreeType to figure out the font format
1646 */
1647 {
1648 const char *font_format = FT_Get_X11_Font_Format (face);
1649 if (font_format)
1650 FcPatternAddString (pat, FC_FONTFORMAT, (FcChar8 *) font_format);
1651 }
1652 #endif
1653
1654 /*
1655 * Drop our reference to the charset
1656 */
1657 FcCharSetDestroy (cs);
1658
1659 /*
1660 * Deallocate family/style values
1661 */
1662
1663 FT_Done_Face (face);
1664 FT_Done_FreeType (ftLibrary);
1665 return pat;
1666
1667 bail2:
1668 FcCharSetDestroy (cs);
1669 bail1:
1670 FcPatternDestroy (pat);
1671 bail0:
1672 FT_Done_Face (face);
1673 bail:
1674 FT_Done_FreeType (ftLibrary);
1675 return 0;
1676 }
1677
1678
1679 /*
1680 * For our purposes, this approximation is sufficient
1681 */
1682 #if !HAVE_FT_GET_NEXT_CHAR
1683 #define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
1684 (*(gi) = 0), 0 : \
1685 (*(gi) = 1), (ucs4) + 1)
1686 #warning "No FT_Get_Next_Char: Please install freetype version 2.1.0 or newer"
1687 #endif
1688
1689 typedef struct _FcCharEnt {
1690 FcChar16 bmp;
1691 unsigned char encode;
1692 } FcCharEnt;
1693
1694 struct _FcCharMap {
1695 const FcCharEnt *ent;
1696 int nent;
1697 };
1698
1699 typedef struct _FcFontDecode {
1700 FT_Encoding encoding;
1701 const FcCharMap *map;
1702 FcChar32 max;
1703 } FcFontDecode;
1704
1705 static const FcCharEnt AppleRomanEnt[] = {
1706 { 0x0020, 0x20 }, /* SPACE */
1707 { 0x0021, 0x21 }, /* EXCLAMATION MARK */
1708 { 0x0022, 0x22 }, /* QUOTATION MARK */
1709 { 0x0023, 0x23 }, /* NUMBER SIGN */
1710 { 0x0024, 0x24 }, /* DOLLAR SIGN */
1711 { 0x0025, 0x25 }, /* PERCENT SIGN */
1712 { 0x0026, 0x26 }, /* AMPERSAND */
1713 { 0x0027, 0x27 }, /* APOSTROPHE */
1714 { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
1715 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
1716 { 0x002A, 0x2A }, /* ASTERISK */
1717 { 0x002B, 0x2B }, /* PLUS SIGN */
1718 { 0x002C, 0x2C }, /* COMMA */
1719 { 0x002D, 0x2D }, /* HYPHEN-MINUS */
1720 { 0x002E, 0x2E }, /* FULL STOP */
1721 { 0x002F, 0x2F }, /* SOLIDUS */
1722 { 0x0030, 0x30 }, /* DIGIT ZERO */
1723 { 0x0031, 0x31 }, /* DIGIT ONE */
1724 { 0x0032, 0x32 }, /* DIGIT TWO */
1725 { 0x0033, 0x33 }, /* DIGIT THREE */
1726 { 0x0034, 0x34 }, /* DIGIT FOUR */
1727 { 0x0035, 0x35 }, /* DIGIT FIVE */
1728 { 0x0036, 0x36 }, /* DIGIT SIX */
1729 { 0x0037, 0x37 }, /* DIGIT SEVEN */
1730 { 0x0038, 0x38 }, /* DIGIT EIGHT */
1731 { 0x0039, 0x39 }, /* DIGIT NINE */
1732 { 0x003A, 0x3A }, /* COLON */
1733 { 0x003B, 0x3B }, /* SEMICOLON */
1734 { 0x003C, 0x3C }, /* LESS-THAN SIGN */
1735 { 0x003D, 0x3D }, /* EQUALS SIGN */
1736 { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
1737 { 0x003F, 0x3F }, /* QUESTION MARK */
1738 { 0x0040, 0x40 }, /* COMMERCIAL AT */
1739 { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
1740 { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
1741 { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
1742 { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
1743 { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
1744 { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
1745 { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
1746 { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
1747 { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
1748 { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
1749 { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
1750 { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
1751 { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
1752 { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
1753 { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
1754 { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
1755 { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
1756 { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
1757 { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
1758 { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
1759 { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
1760 { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
1761 { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
1762 { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
1763 { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
1764 { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
1765 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
1766 { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
1767 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
1768 { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
1769 { 0x005F, 0x5F }, /* LOW LINE */
1770 { 0x0060, 0x60 }, /* GRAVE ACCENT */
1771 { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
1772 { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
1773 { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
1774 { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
1775 { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
1776 { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
1777 { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
1778 { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
1779 { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
1780 { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
1781 { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
1782 { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
1783 { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
1784 { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
1785 { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
1786 { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
1787 { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
1788 { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
1789 { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
1790 { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
1791 { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
1792 { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
1793 { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
1794 { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
1795 { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
1796 { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
1797 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
1798 { 0x007C, 0x7C }, /* VERTICAL LINE */
1799 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
1800 { 0x007E, 0x7E }, /* TILDE */
1801 { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
1802 { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
1803 { 0x00A2, 0xA2 }, /* CENT SIGN */
1804 { 0x00A3, 0xA3 }, /* POUND SIGN */
1805 { 0x00A5, 0xB4 }, /* YEN SIGN */
1806 { 0x00A7, 0xA4 }, /* SECTION SIGN */
1807 { 0x00A8, 0xAC }, /* DIAERESIS */
1808 { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
1809 { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
1810 { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
1811 { 0x00AC, 0xC2 }, /* NOT SIGN */
1812 { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
1813 { 0x00AF, 0xF8 }, /* MACRON */
1814 { 0x00B0, 0xA1 }, /* DEGREE SIGN */
1815 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
1816 { 0x00B4, 0xAB }, /* ACUTE ACCENT */
1817 { 0x00B5, 0xB5 }, /* MICRO SIGN */
1818 { 0x00B6, 0xA6 }, /* PILCROW SIGN */
1819 { 0x00B7, 0xE1 }, /* MIDDLE DOT */
1820 { 0x00B8, 0xFC }, /* CEDILLA */
1821 { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
1822 { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
1823 { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
1824 { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
1825 { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
1826 { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
1827 { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
1828 { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
1829 { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
1830 { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
1831 { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
1832 { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
1833 { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
1834 { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
1835 { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
1836 { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
1837 { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
1838 { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
1839 { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
1840 { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
1841 { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
1842 { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
1843 { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
1844 { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
1845 { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
1846 { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
1847 { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
1848 { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
1849 { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
1850 { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
1851 { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
1852 { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
1853 { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
1854 { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
1855 { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
1856 { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
1857 { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
1858 { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
1859 { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
1860 { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
1861 { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
1862 { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
1863 { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
1864 { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
1865 { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
1866 { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
1867 { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
1868 { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
1869 { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
1870 { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
1871 { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
1872 { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
1873 { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
1874 { 0x00F7, 0xD6 }, /* DIVISION SIGN */
1875 { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
1876 { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
1877 { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
1878 { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
1879 { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
1880 { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
1881 { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
1882 { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
1883 { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
1884 { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
1885 { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
1886 { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
1887 { 0x02C7, 0xFF }, /* CARON */
1888 { 0x02D8, 0xF9 }, /* BREVE */
1889 { 0x02D9, 0xFA }, /* DOT ABOVE */
1890 { 0x02DA, 0xFB }, /* RING ABOVE */
1891 { 0x02DB, 0xFE }, /* OGONEK */
1892 { 0x02DC, 0xF7 }, /* SMALL TILDE */
1893 { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
1894 { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
1895 { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
1896 { 0x2013, 0xD0 }, /* EN DASH */
1897 { 0x2014, 0xD1 }, /* EM DASH */
1898 { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
1899 { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
1900 { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
1901 { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
1902 { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
1903 { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
1904 { 0x2020, 0xA0 }, /* DAGGER */
1905 { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
1906 { 0x2022, 0xA5 }, /* BULLET */
1907 { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
1908 { 0x2030, 0xE4 }, /* PER MILLE SIGN */
1909 { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
1910 { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
1911 { 0x2044, 0xDA }, /* FRACTION SLASH */
1912 { 0x20AC, 0xDB }, /* EURO SIGN */
1913 { 0x2122, 0xAA }, /* TRADE MARK SIGN */
1914 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
1915 { 0x2206, 0xC6 }, /* INCREMENT */
1916 { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
1917 { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
1918 { 0x221A, 0xC3 }, /* SQUARE ROOT */
1919 { 0x221E, 0xB0 }, /* INFINITY */
1920 { 0x222B, 0xBA }, /* INTEGRAL */
1921 { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
1922 { 0x2260, 0xAD }, /* NOT EQUAL TO */
1923 { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
1924 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
1925 { 0x25CA, 0xD7 }, /* LOZENGE */
1926 { 0xF8FF, 0xF0 }, /* Apple logo */
1927 { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
1928 { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
1929 };
1930
1931 static const FcCharMap AppleRoman = {
1932 AppleRomanEnt,
1933 sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
1934 };
1935
1936 static const FcCharEnt AdobeSymbolEnt[] = {
1937 { 0x0020, 0x20 }, /* SPACE # space */
1938 { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */
1939 { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */
1940 { 0x0025, 0x25 }, /* PERCENT SIGN # percent */
1941 { 0x0026, 0x26 }, /* AMPERSAND # ampersand */
1942 { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */
1943 { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */
1944 { 0x002B, 0x2B }, /* PLUS SIGN # plus */
1945 { 0x002C, 0x2C }, /* COMMA # comma */
1946 { 0x002E, 0x2E }, /* FULL STOP # period */
1947 { 0x002F, 0x2F }, /* SOLIDUS # slash */
1948 { 0x0030, 0x30 }, /* DIGIT ZERO # zero */
1949 { 0x0031, 0x31 }, /* DIGIT ONE # one */
1950 { 0x0032, 0x32 }, /* DIGIT TWO # two */
1951 { 0x0033, 0x33 }, /* DIGIT THREE # three */
1952 { 0x0034, 0x34 }, /* DIGIT FOUR # four */
1953 { 0x0035, 0x35 }, /* DIGIT FIVE # five */
1954 { 0x0036, 0x36 }, /* DIGIT SIX # six */
1955 { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */
1956 { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */
1957 { 0x0039, 0x39 }, /* DIGIT NINE # nine */
1958 { 0x003A, 0x3A }, /* COLON # colon */
1959 { 0x003B, 0x3B }, /* SEMICOLON # semicolon */
1960 { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
1961 { 0x003D, 0x3D }, /* EQUALS SIGN # equal */
1962 { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */
1963 { 0x003F, 0x3F }, /* QUESTION MARK # question */
1964 { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */
1965 { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */
1966 { 0x005F, 0x5F }, /* LOW LINE # underscore */
1967 { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */
1968 { 0x007C, 0x7C }, /* VERTICAL LINE # bar */
1969 { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */
1970 { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
1971 { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */
1972 { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */
1973 { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */
1974 { 0x00B5, 0x6D }, /* MICRO SIGN # mu */
1975 { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */
1976 { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */
1977 { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
1978 { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */
1979 { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */
1980 { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */
1981 { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */
1982 { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */
1983 { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */
1984 { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */
1985 { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */
1986 { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */
1987 { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */
1988 { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */
1989 { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */
1990 { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */
1991 { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */
1992 { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */
1993 { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */
1994 { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */
1995 { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */
1996 { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */
1997 { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */
1998 { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */
1999 { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */
2000 { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */
2001 { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */
2002 { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */
2003 { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */
2004 { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */
2005 { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */
2006 { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */
2007 { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */
2008 { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
2009 { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */
2010 { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */
2011 { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */
2012 { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */
2013 { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */
2014 { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */
2015 { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */
2016 { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */
2017 { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */
2018 { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
2019 { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
2020 { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */
2021 { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
2022 { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */
2023 { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
2024 { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
2025 { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
2026 { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */
2027 { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */
2028 { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
2029 { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */
2030 { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */
2031 { 0x2022, 0xB7 }, /* BULLET # bullet */
2032 { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */
2033 { 0x2032, 0xA2 }, /* PRIME # minute */
2034 { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */
2035 { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
2036 { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */
2037 { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
2038 { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */
2039 { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
2040 { 0x2126, 0x57 }, /* OHM SIGN # Omega */
2041 { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */
2042 { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */
2043 { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */
2044 { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */
2045 { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */
2046 { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */
2047 { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */
2048 { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
2049 { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */
2050 { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */
2051 { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
2052 { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */
2053 { 0x2200, 0x22 }, /* FOR ALL # universal */
2054 { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */
2055 { 0x2203, 0x24 }, /* THERE EXISTS # existential */
2056 { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */
2057 { 0x2206, 0x44 }, /* INCREMENT # Delta */
2058 { 0x2207, 0xD1 }, /* NABLA # gradient */
2059 { 0x2208, 0xCE }, /* ELEMENT OF # element */
2060 { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */
2061 { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */
2062 { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */
2063 { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */
2064 { 0x2212, 0x2D }, /* MINUS SIGN # minus */
2065 { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
2066 { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */
2067 { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */
2068 { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */
2069 { 0x221E, 0xA5 }, /* INFINITY # infinity */
2070 { 0x2220, 0xD0 }, /* ANGLE # angle */
2071 { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */
2072 { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */
2073 { 0x2229, 0xC7 }, /* INTERSECTION # intersection */
2074 { 0x222A, 0xC8 }, /* UNION # union */
2075 { 0x222B, 0xF2 }, /* INTEGRAL # integral */
2076 { 0x2234, 0x5C }, /* THEREFORE # therefore */
2077 { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
2078 { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
2079 { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */
2080 { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */
2081 { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */
2082 { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */
2083 { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */
2084 { 0x2282, 0xCC }, /* SUBSET OF # propersubset */
2085 { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */
2086 { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */
2087 { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */
2088 { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */
2089 { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */
2090 { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */
2091 { 0x22A5, 0x5E }, /* UP TACK # perpendicular */
2092 { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */
2093 { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */
2094 { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */
2095 { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */
2096 { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */
2097 { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */
2098 { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */
2099 { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */
2100 { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */
2101 { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */
2102 { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */
2103 { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */
2104 { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */
2105 { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */
2106 { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */
2107 { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */
2108 { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */
2109 { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */
2110 { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */
2111 { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
2112 { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */
2113 { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */
2114 { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */
2115 { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */
2116 { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */
2117 { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
2118 { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
2119 { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */
2120 { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
2121 { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */
2122 { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */
2123 { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */
2124 { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */
2125 { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */
2126 { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */
2127 { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */
2128 { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */
2129 { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */
2130 { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */
2131 };
2132
2133 static const FcCharMap AdobeSymbol = {
2134 AdobeSymbolEnt,
2135 sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
2136 };
2137
2138 static const FcFontDecode fcFontDecoders[] = {
2139 { ft_encoding_unicode, 0, (1 << 21) - 1 },
2140 { ft_encoding_symbol, &AdobeSymbol, (1 << 16) - 1 },
2141 { ft_encoding_apple_roman, &AppleRoman, (1 << 16) - 1 },
2142 };
2143
2144 #define NUM_DECODE (int) (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
2145
2146 static const FcChar32 prefer_unicode[] = {
2147 0x20ac, /* EURO SIGN */
2148 };
2149
2150 #define NUM_PREFER_UNICODE (int) (sizeof (prefer_unicode) / sizeof (prefer_unicode[0]))
2151
2152 FcChar32
2153 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
2154 {
2155 int low, high, mid;
2156 FcChar16 bmp;
2157
2158 low = 0;
2159 high = map->nent - 1;
2160 if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
2161 return ~0;
2162 while (low <= high)
2163 {
2164 mid = (high + low) >> 1;
2165 bmp = map->ent[mid].bmp;
2166 if (ucs4 == bmp)
2167 return (FT_ULong) map->ent[mid].encode;
2168 if (ucs4 < bmp)
2169 high = mid - 1;
2170 else
2171 low = mid + 1;
2172 }
2173 return ~0;
2174 }
2175
2176 FcChar32
2177 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
2178 {
2179 int i;
2180
2181 for (i = 0; i < map->nent; i++)
2182 if (map->ent[i].encode == private)
2183 return (FcChar32) map->ent[i].bmp;
2184 return ~0;
2185 }
2186
2187 const FcCharMap *
2188 FcFreeTypeGetPrivateMap (FT_Encoding encoding)
2189 {
2190 int i;
2191
2192 for (i = 0; i < NUM_DECODE; i++)
2193 if (fcFontDecoders[i].encoding == encoding)
2194 return fcFontDecoders[i].map;
2195 return 0;
2196 }
2197
2198 #include "../fc-glyphname/fcglyphname.h"
2199
2200 static FcChar32
2201 FcHashGlyphName (const FcChar8 *name)
2202 {
2203 FcChar32 h = 0;
2204 FcChar8 c;
2205
2206 while ((c = *name++))
2207 {
2208 h = ((h << 1) | (h >> 31)) ^ c;
2209 }
2210 return h;
2211 }
2212
2213 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2214 /*
2215 * Use Type1 glyph names for fonts which have reliable names
2216 * and which export an Adobe Custom mapping
2217 */
2218 static FcBool
2219 FcFreeTypeUseNames (FT_Face face)
2220 {
2221 FT_Int map;
2222
2223 if (!FT_Has_PS_Glyph_Names (face))
2224 return FcFalse;
2225 for (map = 0; map < face->num_charmaps; map++)
2226 if (face->charmaps[map]->encoding == ft_encoding_adobe_custom)
2227 return FcTrue;
2228 return FcFalse;
2229 }
2230
2231 static const FcChar8 *
2232 FcUcs4ToGlyphName (FcChar32 ucs4)
2233 {
2234 int i = (int) (ucs4 % FC_GLYPHNAME_HASH);
2235 int r = 0;
2236 const FcGlyphName *gn;
2237
2238 while ((gn = ucs_to_name[i]))
2239 {
2240 if (gn->ucs == ucs4)
2241 return gn->name;
2242 if (!r)
2243 {
2244 r = (int) (ucs4 % FC_GLYPHNAME_REHASH);
2245 if (!r)
2246 r = 1;
2247 }
2248 i += r;
2249 if (i >= FC_GLYPHNAME_HASH)
2250 i -= FC_GLYPHNAME_HASH;
2251 }
2252 return 0;
2253 }
2254
2255 static FcChar32
2256 FcGlyphNameToUcs4 (FcChar8 *name)
2257 {
2258 FcChar32 h = FcHashGlyphName (name);
2259 int i = (int) (h % FC_GLYPHNAME_HASH);
2260 int r = 0;
2261 const FcGlyphName *gn;
2262
2263 while ((gn = name_to_ucs[i]))
2264 {
2265 if (!strcmp ((char *) name, (char *) gn->name))
2266 return gn->ucs;
2267 if (!r)
2268 {
2269 r = (int) (h % FC_GLYPHNAME_REHASH);
2270 if (!r)
2271 r = 1;
2272 }
2273 i += r;
2274 if (i >= FC_GLYPHNAME_HASH)
2275 i -= FC_GLYPHNAME_HASH;
2276 }
2277 return 0xffff;
2278 }
2279
2280 /*
2281 * Search through a font for a glyph by name. This is
2282 * currently a linear search as there doesn't appear to be
2283 * any defined order within the font
2284 */
2285 static FT_UInt
2286 FcFreeTypeGlyphNameIndex (FT_Face face, const FcChar8 *name)
2287 {
2288 FT_UInt gindex;
2289 FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
2290
2291 for (gindex = 0; gindex < (FT_UInt) face->num_glyphs; gindex++)
2292 {
2293 if (FT_Get_Glyph_Name (face, gindex, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
2294 if (!strcmp ((char *) name, (char *) name_buf))
2295 return gindex;
2296 }
2297 return 0;
2298 }
2299 #endif
2300
2301 /*
2302 * Map a UCS4 glyph to a glyph index. Use all available encoding
2303 * tables to try and find one that works. This information is expected
2304 * to be cached by higher levels, so performance isn't critical
2305 */
2306
2307 FT_UInt
2308 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
2309 {
2310 int initial, offset, decode;
2311 FT_UInt glyphindex;
2312 FcChar32 charcode;
2313 int p;
2314
2315 initial = 0;
2316 /*
2317 * Find the current encoding
2318 */
2319 if (face->charmap)
2320 {
2321 for (; initial < NUM_DECODE; initial++)
2322 if (fcFontDecoders[initial].encoding == face->charmap->encoding)
2323 break;
2324 if (initial == NUM_DECODE)
2325 initial = 0;
2326 }
2327 for (p = 0; p < NUM_PREFER_UNICODE; p++)
2328 if (ucs4 == prefer_unicode[p])
2329 {
2330 initial = 0;
2331 break;
2332 }
2333 /*
2334 * Check each encoding for the glyph, starting with the current one
2335 */
2336 for (offset = 0; offset < NUM_DECODE; offset++)
2337 {
2338 decode = (initial + offset) % NUM_DECODE;
2339 if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
2340 if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
2341 continue;
2342 if (fcFontDecoders[decode].map)
2343 {
2344 charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
2345 if (charcode == ~0U)
2346 continue;
2347 }
2348 else
2349 charcode = ucs4;
2350 glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
2351 if (glyphindex)
2352 return glyphindex;
2353 }
2354 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2355 /*
2356 * Check postscript name table if present
2357 */
2358 if (FcFreeTypeUseNames (face))
2359 {
2360 const FcChar8 *name = FcUcs4ToGlyphName (ucs4);
2361 if (name)
2362 {
2363 glyphindex = FcFreeTypeGlyphNameIndex (face, name);
2364 if (glyphindex)
2365 return glyphindex;
2366 }
2367 }
2368 #endif
2369 return 0;
2370 }
2371
2372 static FcBool
2373 FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
2374 FT_UInt glyph, FcBlanks *blanks,
2375 FT_Pos *advance)
2376 {
2377 FT_Int load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
2378 FT_GlyphSlot slot;
2379
2380 /*
2381 * When using scalable fonts, only report those glyphs
2382 * which can be scaled; otherwise those fonts will
2383 * only be available at some sizes, and never when
2384 * transformed. Avoid this by simply reporting bitmap-only
2385 * glyphs as missing
2386 */
2387 if (face->face_flags & FT_FACE_FLAG_SCALABLE)
2388 load_flags |= FT_LOAD_NO_BITMAP;
2389
2390 if (FT_Load_Glyph (face, glyph, load_flags))
2391 return FcFalse;
2392
2393 slot = face->glyph;
2394 if (!glyph)
2395 return FcFalse;
2396
2397 *advance = slot->metrics.horiAdvance;
2398
2399 switch (slot->format) {
2400 case ft_glyph_format_bitmap:
2401 /*
2402 * Bitmaps are assumed to be reasonable; if
2403 * this proves to be a rash assumption, this
2404 * code can be easily modified
2405 */
2406 return FcTrue;
2407 case ft_glyph_format_outline:
2408 /*
2409 * Glyphs with contours are always OK
2410 */
2411 if (slot->outline.n_contours != 0)
2412 return FcTrue;
2413 /*
2414 * Glyphs with no contours are only OK if
2415 * they're members of the Blanks set specified
2416 * in the configuration. If blanks isn't set,
2417 * then allow any glyph to be blank
2418 */
2419 if (!blanks || FcBlanksIsMember (blanks, ucs4))
2420 return FcTrue;
2421 /* fall through ... */
2422 default:
2423 break;
2424 }
2425 return FcFalse;
2426 }
2427
2428 #define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
2429 #define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
2430 #define FC_ABS(a) ((a) < 0 ? -(a) : (a))
2431 #define APPROXIMATELY_EQUAL(x,y) (FC_ABS ((x) - (y)) <= FC_MAX (FC_ABS (x), FC_ABS (y)) / 33)
2432
2433 FcCharSet *
2434 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing)
2435 {
2436 FcChar32 page, off, max, ucs4;
2437 #ifdef CHECK
2438 FcChar32 font_max = 0;
2439 #endif
2440 FcCharSet *fcs;
2441 FcCharLeaf *leaf;
2442 const FcCharMap *map;
2443 int o;
2444 int i;
2445 FT_UInt glyph;
2446 FT_Pos advance, advance_one = 0, advance_two = 0;
2447 FcBool has_advance = FcFalse, fixed_advance = FcTrue, dual_advance = FcFalse;
2448
2449 fcs = FcCharSetCreate ();
2450 if (!fcs)
2451 goto bail0;
2452
2453 #ifdef CHECK
2454 printf ("Family %s style %s\n", face->family_name, face->style_name);
2455 #endif
2456 for (o = 0; o < NUM_DECODE; o++)
2457 {
2458 if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
2459 continue;
2460 map = fcFontDecoders[o].map;
2461 if (map)
2462 {
2463 /*
2464 * Non-Unicode tables are easy; there's a list of all possible
2465 * characters
2466 */
2467 for (i = 0; i < map->nent; i++)
2468 {
2469 ucs4 = map->ent[i].bmp;
2470 glyph = FT_Get_Char_Index (face, map->ent[i].encode);
2471 if (glyph &&
2472 FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2473 {
2474 /*
2475 * ignore glyphs with zero advance. They’re
2476 * combining characters, and while their behaviour
2477 * isn’t well defined for monospaced applications in
2478 * Unicode, there are many fonts which include
2479 * zero-width combining characters in otherwise
2480 * monospaced fonts.
2481 */
2482 if (advance)
2483 {
2484 if (!has_advance)
2485 {
2486 has_advance = FcTrue;
2487 advance_one = advance;
2488 }
2489 else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2490 {
2491 if (fixed_advance)
2492 {
2493 dual_advance = FcTrue;
2494 fixed_advance = FcFalse;
2495 advance_two = advance;
2496 }
2497 else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2498 dual_advance = FcFalse;
2499 }
2500 }
2501
2502 leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2503 if (!leaf)
2504 goto bail1;
2505 leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
2506 #ifdef CHECK
2507 if (ucs4 > font_max)
2508 font_max = ucs4;
2509 #endif
2510 }
2511 }
2512 }
2513 else
2514 {
2515 FT_UInt gindex;
2516
2517 max = fcFontDecoders[o].max;
2518 /*
2519 * Find the first encoded character in the font
2520 */
2521 if (FT_Get_Char_Index (face, 0))
2522 {
2523 ucs4 = 0;
2524 gindex = 1;
2525 }
2526 else
2527 {
2528 ucs4 = FT_Get_Next_Char (face, 0, &gindex);
2529 if (!ucs4)
2530 gindex = 0;
2531 }
2532
2533 while (gindex)
2534 {
2535 page = ucs4 >> 8;
2536 leaf = 0;
2537 while ((ucs4 >> 8) == page)
2538 {
2539 glyph = FT_Get_Char_Index (face, ucs4);
2540 if (glyph && FcFreeTypeCheckGlyph (face, ucs4,
2541 glyph, blanks, &advance))
2542 {
2543 if (advance)
2544 {
2545 if (!has_advance)
2546 {
2547 has_advance = FcTrue;
2548 advance_one = advance;
2549 }
2550 else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2551 {
2552 if (fixed_advance)
2553 {
2554 dual_advance = FcTrue;
2555 fixed_advance = FcFalse;
2556 advance_two = advance;
2557 }
2558 else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2559 dual_advance = FcFalse;
2560 }
2561 }
2562
2563 if (!leaf)
2564 {
2565 leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2566 if (!leaf)
2567 goto bail1;
2568 }
2569 off = ucs4 & 0xff;
2570 leaf->map[off >> 5] |= (1 << (off & 0x1f));
2571 #ifdef CHECK
2572 if (ucs4 > font_max)
2573 font_max = ucs4;
2574 #endif
2575 }
2576 ucs4++;
2577 }
2578 ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
2579 if (!ucs4)
2580 gindex = 0;
2581 }
2582 #ifdef CHECK
2583 for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
2584 {
2585 FcBool FT_Has, FC_Has;
2586
2587 FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
2588 FC_Has = FcCharSetHasChar (fcs, ucs4);
2589 if (FT_Has != FC_Has)
2590 {
2591 printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
2592 }
2593 }
2594 #endif
2595 }
2596 }
2597 #if HAVE_FT_HAS_PS_GLYPH_NAMES
2598 /*
2599 * Add mapping from PS glyph names if available
2600 */
2601 if (FcFreeTypeUseNames (face))
2602 {
2603 FcChar8 name_buf[FC_GLYPHNAME_MAXLEN + 2];
2604
2605 for (glyph = 0; glyph < (FT_UInt) face->num_glyphs; glyph++)
2606 {
2607 if (FT_Get_Glyph_Name (face, glyph, name_buf, FC_GLYPHNAME_MAXLEN+1) == 0)
2608 {
2609 ucs4 = FcGlyphNameToUcs4 (name_buf);
2610 if (ucs4 != 0xffff &&
2611 FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2612 {
2613 if (advance)
2614 {
2615 if (!has_advance)
2616 {
2617 has_advance = FcTrue;
2618 advance_one = advance;
2619 }
2620 else if (!APPROXIMATELY_EQUAL (advance, advance_one))
2621 {
2622 if (fixed_advance)
2623 {
2624 dual_advance = FcTrue;
2625 fixed_advance = FcFalse;
2626 advance_two = advance;
2627 }
2628 else if (!APPROXIMATELY_EQUAL (advance, advance_two))
2629 dual_advance = FcFalse;
2630 }
2631 }
2632 leaf = FcCharSetFindLeafCreate (fcs, ucs4);
2633 if (!leaf)
2634 goto bail1;
2635 leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
2636 #ifdef CHECK
2637 if (ucs4 > font_max)
2638 font_max = ucs4;
2639 #endif
2640 }
2641 }
2642 }
2643 }
2644 #endif
2645 #ifdef CHECK
2646 printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
2647 for (ucs4 = 0; ucs4 <= font_max; ucs4++)
2648 {
2649 FcBool has_char = (glyph = FcFreeTypeCharIndex (face, ucs4)) != 0;
2650 FcBool has_bit = FcCharSetHasChar (fcs, ucs4);
2651
2652 if (has_char && !has_bit)
2653 {
2654 if (!FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance))
2655 printf ("Bitmap missing broken char 0x%x\n", ucs4);
2656 else
2657 printf ("Bitmap missing char 0x%x\n", ucs4);
2658 }
2659 else if (!has_char && has_bit)
2660 printf ("Bitmap extra char 0x%x\n", ucs4);
2661 }
2662 #endif
2663 if (fixed_advance)
2664 *spacing = FC_MONO;
2665 else if (dual_advance && APPROXIMATELY_EQUAL (2 * FC_MIN (advance_one, advance_two), FC_MAX (advance_one, advance_two)))
2666 *spacing = FC_DUAL;
2667 else
2668 *spacing = FC_PROPORTIONAL;
2669 return fcs;
2670 bail1:
2671 FcCharSetDestroy (fcs);
2672 bail0:
2673 return 0;
2674 }
2675
2676 FcCharSet *
2677 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
2678 {
2679 int spacing;
2680
2681 return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing);
2682 }
2683
2684
2685 #define TTAG_GPOS FT_MAKE_TAG( 'G', 'P', 'O', 'S' )
2686 #define TTAG_GSUB FT_MAKE_TAG( 'G', 'S', 'U', 'B' )
2687 #define TTAG_SILF FT_MAKE_TAG( 'S', 'i', 'l', 'f')
2688 #define TT_Err_Ok FT_Err_Ok
2689 #define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle
2690 #define TTO_Err_Empty_Script 0x1005
2691 #define TTO_Err_Invalid_SubTable 0x1001
2692
2693 #define OTLAYOUT_HEAD "otlayout:"
2694 #define OTLAYOUT_HEAD_LEN 9
2695 #define OTLAYOUT_ID_LEN 4
2696 /* space + head + id */
2697 #define OTLAYOUT_LEN (1 + OTLAYOUT_HEAD_LEN + OTLAYOUT_ID_LEN)
2698
2699 /*
2700 * This is a bit generous; the registry has only lower case and space
2701 * except for 'DFLT'.
2702 */
2703 #define FcIsSpace(x) (040 == (x))
2704 #define FcIsValidScript(x) (FcIsLower(x) || FcIsUpper (x) || FcIsSpace(x))
2705
2706 static void
2707 addtag(FcChar8 *complex, FT_ULong tag)
2708 {
2709 FcChar8 tagstring[OTLAYOUT_ID_LEN + 1];
2710
2711 tagstring[0] = (FcChar8)(tag >> 24),
2712 tagstring[1] = (FcChar8)(tag >> 16),
2713 tagstring[2] = (FcChar8)(tag >> 8),
2714 tagstring[3] = (FcChar8)(tag);
2715 tagstring[4] = '\0';
2716
2717 /* skip tags which aren't alphabetic, under the assumption that
2718 * they're probably broken
2719 */
2720 if (!FcIsValidScript(tagstring[0]) ||
2721 !FcIsValidScript(tagstring[1]) ||
2722 !FcIsValidScript(tagstring[2]) ||
2723 !FcIsValidScript(tagstring[3]))
2724 return;
2725
2726 if (*complex != '\0')
2727 strcat ((char *) complex, " ");
2728 strcat ((char *) complex, "otlayout:");
2729 strcat ((char *) complex, (char *) tagstring);
2730 }
2731
2732 static int
2733 compareulong (const void *a, const void *b)
2734 {
2735 const FT_ULong *ua = (const FT_ULong *) a;
2736 const FT_ULong *ub = (const FT_ULong *) b;
2737 return *ua - *ub;
2738 }
2739
2740
2741 static FT_Error
2742 GetScriptTags(FT_Face face, FT_ULong tabletag, FT_ULong **stags, FT_UShort *script_count)
2743 {
2744 FT_ULong cur_offset, new_offset, base_offset;
2745 FT_Stream stream = face->stream;
2746 FT_Error error;
2747 FT_UShort n, p;
2748 FT_Memory memory = stream->memory;
2749
2750 if ( !stream )
2751 return TT_Err_Invalid_Face_Handle;
2752
2753 if (( error = ftglue_face_goto_table( face, tabletag, stream ) ))
2754 return error;
2755
2756 base_offset = ftglue_stream_pos ( stream );
2757
2758 /* skip version */
2759
2760 if ( ftglue_stream_seek ( stream, base_offset + 4L ) || ftglue_stream_frame_enter( stream, 2L ) )
2761 return error;
2762
2763 new_offset = ((FT_UShort)ftglue_stream_get_short ( stream )) + base_offset;
2764
2765 ftglue_stream_frame_exit( stream );
2766
2767 cur_offset = ftglue_stream_pos( stream );
2768
2769 if ( ftglue_stream_seek( stream, new_offset ) != TT_Err_Ok )
2770 return error;
2771
2772 base_offset = ftglue_stream_pos( stream );
2773
2774 if ( ftglue_stream_frame_enter( stream, 2L ) )
2775 return error;
2776
2777 *script_count = ((FT_UShort)ftglue_stream_get_short ( stream ));
2778
2779 ftglue_stream_frame_exit( stream );
2780
2781 *stags = ftglue_alloc(memory, *script_count * sizeof( FT_ULong ), &error);
2782
2783 if (error)
2784 return error;
2785
2786 p = 0;
2787 for ( n = 0; n < *script_count; n++ )
2788 {
2789 if ( ftglue_stream_frame_enter( stream, 6L ) )
2790 goto Fail;
2791
2792 (*stags)[p] = ((FT_ULong)ftglue_stream_get_long ( stream ));
2793 new_offset = ((FT_UShort)ftglue_stream_get_short ( stream )) + base_offset;
2794
2795 ftglue_stream_frame_exit( stream );
2796
2797 cur_offset = ftglue_stream_pos( stream );
2798
2799 if ( ftglue_stream_seek( stream, new_offset ) )
2800 goto Fail;
2801
2802 if ( error == TT_Err_Ok )
2803 p++;
2804 else if ( error != TTO_Err_Empty_Script )
2805 goto Fail;
2806
2807 (void)ftglue_stream_seek( stream, cur_offset );
2808 }
2809
2810 if (!p)
2811 {
2812 error = TTO_Err_Invalid_SubTable;
2813 goto Fail;
2814 }
2815
2816 // sort the tag list before returning it
2817 qsort(*stags, *script_count, sizeof(FT_ULong), compareulong);
2818
2819 return TT_Err_Ok;
2820
2821 Fail:
2822 *script_count = 0;
2823 ftglue_free( memory, *stags );
2824 return error;
2825 }
2826
2827 static FcChar8 *
2828 FcFontCapabilities(FT_Face face)
2829 {
2830 FcBool issilgraphitefont = 0;
2831 FT_Error err;
2832 FT_ULong len = 0;
2833 FT_ULong *gsubtags=NULL, *gpostags=NULL;
2834 FT_UShort gsub_count=0, gpos_count=0;
2835 FT_ULong maxsize;
2836 FT_Memory memory = face->stream->memory;
2837 FcChar8 *complex = NULL;
2838 int indx1 = 0, indx2 = 0;
2839
2840 err = FT_Load_Sfnt_Table(face, TTAG_SILF, 0, 0, &len);
2841 issilgraphitefont = ( err == FT_Err_Ok);
2842
2843 if (GetScriptTags(face, TTAG_GPOS, &gpostags, &gpos_count) != FT_Err_Ok)
2844 gpos_count = 0;
2845 if (GetScriptTags(face, TTAG_GSUB, &gsubtags, &gsub_count) != FT_Err_Ok)
2846 gsub_count = 0;
2847
2848 if (!issilgraphitefont && !gsub_count && !gpos_count)
2849 goto bail;
2850
2851 maxsize = (((FT_ULong) gpos_count + (FT_ULong) gsub_count) * OTLAYOUT_LEN +
2852 (issilgraphitefont ? 13 : 0));
2853 complex = malloc (sizeof (FcChar8) * maxsize);
2854 if (!complex)
2855 goto bail;
2856
2857 complex[0] = '\0';
2858 if (issilgraphitefont)
2859 strcpy((char *) complex, "ttable:Silf ");
2860
2861 while ((indx1 < gsub_count) || (indx2 < gpos_count)) {
2862 if (indx1 == gsub_count) {
2863 addtag(complex, gpostags[indx2]);
2864 indx2++;
2865 } else if ((indx2 == gpos_count) || (gsubtags[indx1] < gpostags[indx2])) {
2866 addtag(complex, gsubtags[indx1]);
2867 indx1++;
2868 } else if (gsubtags[indx1] == gpostags[indx2]) {
2869 addtag(complex, gsubtags[indx1]);
2870 indx1++;
2871 indx2++;
2872 } else {
2873 addtag(complex, gpostags[indx2]);
2874 indx2++;
2875 }
2876 }
2877 if (FcDebug () & FC_DBG_SCANV)
2878 printf("complex features in this font: %s\n", complex);
2879 bail:
2880 ftglue_free(memory, gsubtags);
2881 ftglue_free(memory, gpostags);
2882 return complex;
2883 }
http://fontconfig.org/