1
2
3#![allow(non_camel_case_types)]
4#![allow(non_upper_case_globals)]
5
6
7extern crate libc;
8
9
10pub type FcChar8 = ::libc::c_uchar;
13pub type FcChar16 = ::libc::c_ushort;
14pub type FcChar32 = ::libc::c_uint;
15pub type FcBool = ::libc::c_int;
16pub type Enum__FcType = ::libc::c_int;
17pub const FcTypeUnknown: ::libc::c_int = -1;
18pub const FcTypeVoid: ::libc::c_int = 0;
19pub const FcTypeInteger: ::libc::c_int = 1;
20pub const FcTypeDouble: ::libc::c_int = 2;
21pub const FcTypeString: ::libc::c_int = 3;
22pub const FcTypeBool: ::libc::c_int = 4;
23pub const FcTypeMatrix: ::libc::c_int = 5;
24pub const FcTypeCharSet: ::libc::c_int = 6;
25pub const FcTypeFTFace: ::libc::c_int = 7;
26pub const FcTypeLangSet: ::libc::c_int = 8;
27pub type FcType = Enum__FcType;
28#[repr(C)]
29#[derive(Copy)]
30pub struct Struct__FcMatrix {
31 pub xx: ::libc::c_double,
32 pub xy: ::libc::c_double,
33 pub yx: ::libc::c_double,
34 pub yy: ::libc::c_double,
35}
36impl ::std::clone::Clone for Struct__FcMatrix {
37 fn clone(&self) -> Self { *self }
38}
39impl ::std::default::Default for Struct__FcMatrix {
40 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
41}
42pub type FcMatrix = Struct__FcMatrix;
43pub enum Struct__FcCharSet { }
44pub type FcCharSet = Struct__FcCharSet;
45#[repr(C)]
46#[derive(Copy)]
47pub struct Struct__FcObjectType {
48 pub object: *const ::libc::c_char,
49 pub _type: FcType,
50}
51impl ::std::clone::Clone for Struct__FcObjectType {
52 fn clone(&self) -> Self { *self }
53}
54impl ::std::default::Default for Struct__FcObjectType {
55 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
56}
57pub type FcObjectType = Struct__FcObjectType;
58#[repr(C)]
59#[derive(Copy)]
60pub struct Struct__FcConstant {
61 pub name: *const FcChar8,
62 pub object: *const ::libc::c_char,
63 pub value: ::libc::c_int,
64}
65impl ::std::clone::Clone for Struct__FcConstant {
66 fn clone(&self) -> Self { *self }
67}
68impl ::std::default::Default for Struct__FcConstant {
69 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
70}
71pub type FcConstant = Struct__FcConstant;
72pub type Enum__FcResult = ::libc::c_uint;
73pub const FcResultMatch: ::libc::c_uint = 0;
74pub const FcResultNoMatch: ::libc::c_uint = 1;
75pub const FcResultTypeMismatch: ::libc::c_uint = 2;
76pub const FcResultNoId: ::libc::c_uint = 3;
77pub const FcResultOutOfMemory: ::libc::c_uint = 4;
78pub type FcResult = Enum__FcResult;
79pub enum Struct__FcPattern { }
80pub type FcPattern = Struct__FcPattern;
81pub enum Struct__FcLangSet { }
82pub type FcLangSet = Struct__FcLangSet;
83#[repr(C)]
84#[derive(Copy)]
85pub struct Struct__FcValue {
86 pub _type: FcType,
87 pub u: Union_Unnamed1,
88}
89impl ::std::clone::Clone for Struct__FcValue {
90 fn clone(&self) -> Self { *self }
91}
92impl ::std::default::Default for Struct__FcValue {
93 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
94}
95#[repr(C)]
96#[derive(Copy)]
97pub struct Union_Unnamed1 {
98 pub _bindgen_data_: [u64; 1usize],
99}
100impl Union_Unnamed1 {
101 pub unsafe fn s(&mut self) -> *mut *const FcChar8 {
102 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
103 ::std::mem::transmute(raw.offset(0))
104 }
105 pub unsafe fn i(&mut self) -> *mut ::libc::c_int {
106 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
107 ::std::mem::transmute(raw.offset(0))
108 }
109 pub unsafe fn b(&mut self) -> *mut FcBool {
110 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
111 ::std::mem::transmute(raw.offset(0))
112 }
113 pub unsafe fn d(&mut self) -> *mut ::libc::c_double {
114 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
115 ::std::mem::transmute(raw.offset(0))
116 }
117 pub unsafe fn m(&mut self) -> *mut *const FcMatrix {
118 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
119 ::std::mem::transmute(raw.offset(0))
120 }
121 pub unsafe fn c(&mut self) -> *mut *const FcCharSet {
122 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
123 ::std::mem::transmute(raw.offset(0))
124 }
125 pub unsafe fn f(&mut self) -> *mut *mut ::libc::c_void {
126 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
127 ::std::mem::transmute(raw.offset(0))
128 }
129 pub unsafe fn l(&mut self) -> *mut *const FcLangSet {
130 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
131 ::std::mem::transmute(raw.offset(0))
132 }
133}
134impl ::std::clone::Clone for Union_Unnamed1 {
135 fn clone(&self) -> Self { *self }
136}
137impl ::std::default::Default for Union_Unnamed1 {
138 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
139}
140pub type FcValue = Struct__FcValue;
141#[repr(C)]
142#[derive(Copy)]
143pub struct Struct__FcFontSet {
144 pub nfont: ::libc::c_int,
145 pub sfont: ::libc::c_int,
146 pub fonts: *mut *mut FcPattern,
147}
148impl ::std::clone::Clone for Struct__FcFontSet {
149 fn clone(&self) -> Self { *self }
150}
151impl ::std::default::Default for Struct__FcFontSet {
152 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
153}
154pub type FcFontSet = Struct__FcFontSet;
155#[repr(C)]
156#[derive(Copy)]
157pub struct Struct__FcObjectSet {
158 pub nobject: ::libc::c_int,
159 pub sobject: ::libc::c_int,
160 pub objects: *mut *const ::libc::c_char,
161}
162impl ::std::clone::Clone for Struct__FcObjectSet {
163 fn clone(&self) -> Self { *self }
164}
165impl ::std::default::Default for Struct__FcObjectSet {
166 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
167}
168pub type FcObjectSet = Struct__FcObjectSet;
169pub type Enum__FcMatchKind = ::libc::c_uint;
170pub const FcMatchPattern: ::libc::c_uint = 0;
171pub const FcMatchFont: ::libc::c_uint = 1;
172pub const FcMatchScan: ::libc::c_uint = 2;
173pub type FcMatchKind = Enum__FcMatchKind;
174pub type Enum__FcLangResult = ::libc::c_uint;
175pub const FcLangEqual: ::libc::c_uint = 0;
176pub const FcLangDifferentCountry: ::libc::c_uint = 1;
177pub const FcLangDifferentTerritory: ::libc::c_uint = 1;
178pub const FcLangDifferentLang: ::libc::c_uint = 2;
179pub type FcLangResult = Enum__FcLangResult;
180pub type Enum__FcSetName = ::libc::c_uint;
181pub const FcSetSystem: ::libc::c_uint = 0;
182pub const FcSetApplication: ::libc::c_uint = 1;
183pub type FcSetName = Enum__FcSetName;
184pub enum Struct__FcAtomic { }
185pub type FcAtomic = Struct__FcAtomic;
186pub type Enum_Unnamed2 = ::libc::c_uint;
187pub const FcEndianBig: ::libc::c_uint = 0;
188pub const FcEndianLittle: ::libc::c_uint = 1;
189pub type FcEndian = Enum_Unnamed2;
190pub enum Struct__FcConfig { }
191pub type FcConfig = Struct__FcConfig;
192pub enum Struct__FcGlobalCache { }
193pub type FcFileCache = Struct__FcGlobalCache;
194pub enum Struct__FcBlanks { }
195pub type FcBlanks = Struct__FcBlanks;
196pub enum Struct__FcStrList { }
197pub type FcStrList = Struct__FcStrList;
198pub enum Struct__FcStrSet { }
199pub type FcStrSet = Struct__FcStrSet;
200pub enum Struct__FcCache { }
201pub type FcCache = Struct__FcCache;
202extern "C" {
203 pub fn FcBlanksCreate() -> *mut FcBlanks;
204 pub fn FcBlanksDestroy(b: *mut FcBlanks);
205 pub fn FcBlanksAdd(b: *mut FcBlanks, ucs4: FcChar32) -> FcBool;
206 pub fn FcBlanksIsMember(b: *mut FcBlanks, ucs4: FcChar32) -> FcBool;
207 pub fn FcCacheDir(c: *const FcCache) -> *const FcChar8;
208 pub fn FcCacheCopySet(c: *const FcCache) -> *mut FcFontSet;
209 pub fn FcCacheSubdir(c: *const FcCache, i: ::libc::c_int)
210 -> *const FcChar8;
211 pub fn FcCacheNumSubdir(c: *const FcCache) -> ::libc::c_int;
212 pub fn FcCacheNumFont(c: *const FcCache) -> ::libc::c_int;
213 pub fn FcDirCacheUnlink(dir: *const FcChar8, config: *mut FcConfig)
214 -> FcBool;
215 pub fn FcDirCacheValid(cache_file: *const FcChar8) -> FcBool;
216 pub fn FcDirCacheClean(cache_dir: *const FcChar8, verbose: FcBool)
217 -> FcBool;
218 pub fn FcCacheCreateTagFile(config: *const FcConfig);
219 pub fn FcConfigHome() -> *mut FcChar8;
220 pub fn FcConfigEnableHome(enable: FcBool) -> FcBool;
221 pub fn FcConfigFilename(url: *const FcChar8) -> *mut FcChar8;
222 pub fn FcConfigCreate() -> *mut FcConfig;
223 pub fn FcConfigReference(config: *mut FcConfig) -> *mut FcConfig;
224 pub fn FcConfigDestroy(config: *mut FcConfig);
225 pub fn FcConfigSetCurrent(config: *mut FcConfig) -> FcBool;
226 pub fn FcConfigGetCurrent() -> *mut FcConfig;
227 pub fn FcConfigUptoDate(config: *mut FcConfig) -> FcBool;
228 pub fn FcConfigBuildFonts(config: *mut FcConfig) -> FcBool;
229 pub fn FcConfigGetFontDirs(config: *mut FcConfig) -> *mut FcStrList;
230 pub fn FcConfigGetConfigDirs(config: *mut FcConfig) -> *mut FcStrList;
231 pub fn FcConfigGetConfigFiles(config: *mut FcConfig) -> *mut FcStrList;
232 pub fn FcConfigGetCache(config: *mut FcConfig) -> *mut FcChar8;
233 pub fn FcConfigGetBlanks(config: *mut FcConfig) -> *mut FcBlanks;
234 pub fn FcConfigGetCacheDirs(config: *const FcConfig) -> *mut FcStrList;
235 pub fn FcConfigGetRescanInterval(config: *mut FcConfig) -> ::libc::c_int;
236 pub fn FcConfigSetRescanInterval(config: *mut FcConfig,
237 rescanInterval: ::libc::c_int) -> FcBool;
238 pub fn FcConfigGetFonts(config: *mut FcConfig, set: FcSetName)
239 -> *mut FcFontSet;
240 pub fn FcConfigAppFontAddFile(config: *mut FcConfig, file: *const FcChar8)
241 -> FcBool;
242 pub fn FcConfigAppFontAddDir(config: *mut FcConfig, dir: *const FcChar8)
243 -> FcBool;
244 pub fn FcConfigAppFontClear(config: *mut FcConfig);
245 pub fn FcConfigSubstituteWithPat(config: *mut FcConfig, p: *mut FcPattern,
246 p_pat: *mut FcPattern, kind: FcMatchKind)
247 -> FcBool;
248 pub fn FcConfigSubstitute(config: *mut FcConfig, p: *mut FcPattern,
249 kind: FcMatchKind) -> FcBool;
250 pub fn FcConfigGetSysRoot(config: *const FcConfig) -> *const FcChar8;
251 pub fn FcConfigSetSysRoot(config: *mut FcConfig, sysroot: *const FcChar8)
252 ;
253 pub fn FcCharSetCreate() -> *mut FcCharSet;
254 pub fn FcCharSetNew() -> *mut FcCharSet;
255 pub fn FcCharSetDestroy(fcs: *mut FcCharSet);
256 pub fn FcCharSetAddChar(fcs: *mut FcCharSet, ucs4: FcChar32) -> FcBool;
257 pub fn FcCharSetDelChar(fcs: *mut FcCharSet, ucs4: FcChar32) -> FcBool;
258 pub fn FcCharSetCopy(src: *mut FcCharSet) -> *mut FcCharSet;
259 pub fn FcCharSetEqual(a: *const FcCharSet, b: *const FcCharSet) -> FcBool;
260 pub fn FcCharSetIntersect(a: *const FcCharSet, b: *const FcCharSet)
261 -> *mut FcCharSet;
262 pub fn FcCharSetUnion(a: *const FcCharSet, b: *const FcCharSet)
263 -> *mut FcCharSet;
264 pub fn FcCharSetSubtract(a: *const FcCharSet, b: *const FcCharSet)
265 -> *mut FcCharSet;
266 pub fn FcCharSetMerge(a: *mut FcCharSet, b: *const FcCharSet,
267 changed: *mut FcBool) -> FcBool;
268 pub fn FcCharSetHasChar(fcs: *const FcCharSet, ucs4: FcChar32) -> FcBool;
269 pub fn FcCharSetCount(a: *const FcCharSet) -> FcChar32;
270 pub fn FcCharSetIntersectCount(a: *const FcCharSet, b: *const FcCharSet)
271 -> FcChar32;
272 pub fn FcCharSetSubtractCount(a: *const FcCharSet, b: *const FcCharSet)
273 -> FcChar32;
274 pub fn FcCharSetIsSubset(a: *const FcCharSet, b: *const FcCharSet)
275 -> FcBool;
276 pub fn FcCharSetFirstPage(a: *const FcCharSet, map: *mut FcChar32,
277 next: *mut FcChar32) -> FcChar32;
278 pub fn FcCharSetNextPage(a: *const FcCharSet, map: *mut FcChar32,
279 next: *mut FcChar32) -> FcChar32;
280 pub fn FcCharSetCoverage(a: *const FcCharSet, page: FcChar32,
281 result: *mut FcChar32) -> FcChar32;
282 pub fn FcValuePrint(v: FcValue);
283 pub fn FcPatternPrint(p: *const FcPattern);
284 pub fn FcFontSetPrint(s: *const FcFontSet);
285 pub fn FcGetDefaultLangs() -> *mut FcStrSet;
286 pub fn FcDefaultSubstitute(pattern: *mut FcPattern);
287 pub fn FcFileIsDir(file: *const FcChar8) -> FcBool;
288 pub fn FcFileScan(set: *mut FcFontSet, dirs: *mut FcStrSet,
289 cache: *mut FcFileCache, blanks: *mut FcBlanks,
290 file: *const FcChar8, force: FcBool) -> FcBool;
291 pub fn FcDirScan(set: *mut FcFontSet, dirs: *mut FcStrSet,
292 cache: *mut FcFileCache, blanks: *mut FcBlanks,
293 dir: *const FcChar8, force: FcBool) -> FcBool;
294 pub fn FcDirSave(set: *mut FcFontSet, dirs: *mut FcStrSet,
295 dir: *const FcChar8) -> FcBool;
296 pub fn FcDirCacheLoad(dir: *const FcChar8, config: *mut FcConfig,
297 cache_file: *mut *mut FcChar8) -> *mut FcCache;
298 pub fn FcDirCacheRescan(dir: *const FcChar8, config: *mut FcConfig)
299 -> *mut FcCache;
300 pub fn FcDirCacheRead(dir: *const FcChar8, force: FcBool,
301 config: *mut FcConfig) -> *mut FcCache;
302 pub fn FcDirCacheLoadFile(cache_file: *const FcChar8,
303 file_stat: *mut ::libc::stat) -> *mut FcCache;
304 pub fn FcDirCacheUnload(cache: *mut FcCache);
305 pub fn FcFreeTypeQuery(file: *const FcChar8, id: ::libc::c_int,
306 blanks: *mut FcBlanks, count: *mut ::libc::c_int)
307 -> *mut FcPattern;
308 pub fn FcFontSetCreate() -> *mut FcFontSet;
309 pub fn FcFontSetDestroy(s: *mut FcFontSet);
310 pub fn FcFontSetAdd(s: *mut FcFontSet, font: *mut FcPattern) -> FcBool;
311 pub fn FcInitLoadConfig() -> *mut FcConfig;
312 pub fn FcInitLoadConfigAndFonts() -> *mut FcConfig;
313 pub fn FcInit() -> FcBool;
314 pub fn FcFini();
315 pub fn FcGetVersion() -> ::libc::c_int;
316 pub fn FcInitReinitialize() -> FcBool;
317 pub fn FcInitBringUptoDate() -> FcBool;
318 pub fn FcGetLangs() -> *mut FcStrSet;
319 pub fn FcLangNormalize(lang: *const FcChar8) -> *mut FcChar8;
320 pub fn FcLangGetCharSet(lang: *const FcChar8) -> *const FcCharSet;
321 pub fn FcLangSetCreate() -> *mut FcLangSet;
322 pub fn FcLangSetDestroy(ls: *mut FcLangSet);
323 pub fn FcLangSetCopy(ls: *const FcLangSet) -> *mut FcLangSet;
324 pub fn FcLangSetAdd(ls: *mut FcLangSet, lang: *const FcChar8) -> FcBool;
325 pub fn FcLangSetDel(ls: *mut FcLangSet, lang: *const FcChar8) -> FcBool;
326 pub fn FcLangSetHasLang(ls: *const FcLangSet, lang: *const FcChar8)
327 -> FcLangResult;
328 pub fn FcLangSetCompare(lsa: *const FcLangSet, lsb: *const FcLangSet)
329 -> FcLangResult;
330 pub fn FcLangSetContains(lsa: *const FcLangSet, lsb: *const FcLangSet)
331 -> FcBool;
332 pub fn FcLangSetEqual(lsa: *const FcLangSet, lsb: *const FcLangSet)
333 -> FcBool;
334 pub fn FcLangSetHash(ls: *const FcLangSet) -> FcChar32;
335 pub fn FcLangSetGetLangs(ls: *const FcLangSet) -> *mut FcStrSet;
336 pub fn FcLangSetUnion(a: *const FcLangSet, b: *const FcLangSet)
337 -> *mut FcLangSet;
338 pub fn FcLangSetSubtract(a: *const FcLangSet, b: *const FcLangSet)
339 -> *mut FcLangSet;
340 pub fn FcObjectSetCreate() -> *mut FcObjectSet;
341 pub fn FcObjectSetAdd(os: *mut FcObjectSet, object: *const ::libc::c_char)
342 -> FcBool;
343 pub fn FcObjectSetDestroy(os: *mut FcObjectSet);
344 pub fn FcObjectSetBuild(first: *const ::libc::c_char, ...)
347 -> *mut FcObjectSet;
348 pub fn FcFontSetList(config: *mut FcConfig, sets: *mut *mut FcFontSet,
349 nsets: ::libc::c_int, p: *mut FcPattern,
350 os: *mut FcObjectSet) -> *mut FcFontSet;
351 pub fn FcFontList(config: *mut FcConfig, p: *mut FcPattern,
352 os: *mut FcObjectSet) -> *mut FcFontSet;
353 pub fn FcAtomicCreate(file: *const FcChar8) -> *mut FcAtomic;
354 pub fn FcAtomicLock(atomic: *mut FcAtomic) -> FcBool;
355 pub fn FcAtomicNewFile(atomic: *mut FcAtomic) -> *mut FcChar8;
356 pub fn FcAtomicOrigFile(atomic: *mut FcAtomic) -> *mut FcChar8;
357 pub fn FcAtomicReplaceOrig(atomic: *mut FcAtomic) -> FcBool;
358 pub fn FcAtomicDeleteNew(atomic: *mut FcAtomic);
359 pub fn FcAtomicUnlock(atomic: *mut FcAtomic);
360 pub fn FcAtomicDestroy(atomic: *mut FcAtomic);
361 pub fn FcFontSetMatch(config: *mut FcConfig, sets: *mut *mut FcFontSet,
362 nsets: ::libc::c_int, p: *mut FcPattern,
363 result: *mut FcResult) -> *mut FcPattern;
364 pub fn FcFontMatch(config: *mut FcConfig, p: *mut FcPattern,
365 result: *mut FcResult) -> *mut FcPattern;
366 pub fn FcFontRenderPrepare(config: *mut FcConfig, pat: *mut FcPattern,
367 font: *mut FcPattern) -> *mut FcPattern;
368 pub fn FcFontSetSort(config: *mut FcConfig, sets: *mut *mut FcFontSet,
369 nsets: ::libc::c_int, p: *mut FcPattern,
370 trim: FcBool, csp: *mut *mut FcCharSet,
371 result: *mut FcResult) -> *mut FcFontSet;
372 pub fn FcFontSort(config: *mut FcConfig, p: *mut FcPattern, trim: FcBool,
373 csp: *mut *mut FcCharSet, result: *mut FcResult)
374 -> *mut FcFontSet;
375 pub fn FcFontSetSortDestroy(fs: *mut FcFontSet);
376 pub fn FcMatrixCopy(mat: *const FcMatrix) -> *mut FcMatrix;
377 pub fn FcMatrixEqual(mat1: *const FcMatrix, mat2: *const FcMatrix)
378 -> FcBool;
379 pub fn FcMatrixMultiply(result: *mut FcMatrix, a: *const FcMatrix,
380 b: *const FcMatrix);
381 pub fn FcMatrixRotate(m: *mut FcMatrix, c: ::libc::c_double,
382 s: ::libc::c_double);
383 pub fn FcMatrixScale(m: *mut FcMatrix, sx: ::libc::c_double,
384 sy: ::libc::c_double);
385 pub fn FcMatrixShear(m: *mut FcMatrix, sh: ::libc::c_double,
386 sv: ::libc::c_double);
387 pub fn FcNameRegisterObjectTypes(types: *const FcObjectType,
388 ntype: ::libc::c_int) -> FcBool;
389 pub fn FcNameUnregisterObjectTypes(types: *const FcObjectType,
390 ntype: ::libc::c_int) -> FcBool;
391 pub fn FcNameGetObjectType(object: *const ::libc::c_char)
392 -> *const FcObjectType;
393 pub fn FcNameRegisterConstants(consts: *const FcConstant,
394 nconsts: ::libc::c_int) -> FcBool;
395 pub fn FcNameUnregisterConstants(consts: *const FcConstant,
396 nconsts: ::libc::c_int) -> FcBool;
397 pub fn FcNameGetConstant(string: *const FcChar8) -> *const FcConstant;
398 pub fn FcNameConstant(string: *const FcChar8, result: *mut ::libc::c_int)
399 -> FcBool;
400 pub fn FcNameParse(name: *const FcChar8) -> *mut FcPattern;
401 pub fn FcNameUnparse(pat: *mut FcPattern) -> *mut FcChar8;
402 pub fn FcPatternCreate() -> *mut FcPattern;
403 pub fn FcPatternDuplicate(p: *const FcPattern) -> *mut FcPattern;
404 pub fn FcPatternReference(p: *mut FcPattern);
405 pub fn FcPatternFilter(p: *mut FcPattern, os: *const FcObjectSet)
406 -> *mut FcPattern;
407 pub fn FcValueDestroy(v: FcValue);
408 pub fn FcValueEqual(va: FcValue, vb: FcValue) -> FcBool;
409 pub fn FcValueSave(v: FcValue) -> FcValue;
410 pub fn FcPatternDestroy(p: *mut FcPattern);
411 pub fn FcPatternEqual(pa: *const FcPattern, pb: *const FcPattern)
412 -> FcBool;
413 pub fn FcPatternEqualSubset(pa: *const FcPattern, pb: *const FcPattern,
414 os: *const FcObjectSet) -> FcBool;
415 pub fn FcPatternHash(p: *const FcPattern) -> FcChar32;
416 pub fn FcPatternAdd(p: *mut FcPattern, object: *const ::libc::c_char,
417 value: FcValue, append: FcBool) -> FcBool;
418 pub fn FcPatternAddWeak(p: *mut FcPattern, object: *const ::libc::c_char,
419 value: FcValue, append: FcBool) -> FcBool;
420 pub fn FcPatternGet(p: *const FcPattern, object: *const ::libc::c_char,
421 id: ::libc::c_int, v: *mut FcValue) -> FcResult;
422 pub fn FcPatternDel(p: *mut FcPattern, object: *const ::libc::c_char)
423 -> FcBool;
424 pub fn FcPatternRemove(p: *mut FcPattern, object: *const ::libc::c_char,
425 id: ::libc::c_int) -> FcBool;
426 pub fn FcPatternAddInteger(p: *mut FcPattern,
427 object: *const ::libc::c_char,
428 i: ::libc::c_int) -> FcBool;
429 pub fn FcPatternAddDouble(p: *mut FcPattern,
430 object: *const ::libc::c_char,
431 d: ::libc::c_double) -> FcBool;
432 pub fn FcPatternAddString(p: *mut FcPattern,
433 object: *const ::libc::c_char,
434 s: *const FcChar8) -> FcBool;
435 pub fn FcPatternAddMatrix(p: *mut FcPattern,
436 object: *const ::libc::c_char,
437 s: *const FcMatrix) -> FcBool;
438 pub fn FcPatternAddCharSet(p: *mut FcPattern,
439 object: *const ::libc::c_char,
440 c: *const FcCharSet) -> FcBool;
441 pub fn FcPatternAddBool(p: *mut FcPattern, object: *const ::libc::c_char,
442 b: FcBool) -> FcBool;
443 pub fn FcPatternAddLangSet(p: *mut FcPattern,
444 object: *const ::libc::c_char,
445 ls: *const FcLangSet) -> FcBool;
446 pub fn FcPatternGetInteger(p: *const FcPattern,
447 object: *const ::libc::c_char,
448 n: ::libc::c_int, i: *mut ::libc::c_int)
449 -> FcResult;
450 pub fn FcPatternGetDouble(p: *const FcPattern,
451 object: *const ::libc::c_char, n: ::libc::c_int,
452 d: *mut ::libc::c_double) -> FcResult;
453 pub fn FcPatternGetString(p: *const FcPattern,
454 object: *const ::libc::c_char, n: ::libc::c_int,
455 s: *mut *mut FcChar8) -> FcResult;
456 pub fn FcPatternGetMatrix(p: *const FcPattern,
457 object: *const ::libc::c_char, n: ::libc::c_int,
458 s: *mut *mut FcMatrix) -> FcResult;
459 pub fn FcPatternGetCharSet(p: *const FcPattern,
460 object: *const ::libc::c_char,
461 n: ::libc::c_int, c: *mut *mut FcCharSet)
462 -> FcResult;
463 pub fn FcPatternGetBool(p: *const FcPattern,
464 object: *const ::libc::c_char, n: ::libc::c_int,
465 b: *mut FcBool) -> FcResult;
466 pub fn FcPatternGetLangSet(p: *const FcPattern,
467 object: *const ::libc::c_char,
468 n: ::libc::c_int, ls: *mut *mut FcLangSet)
469 -> FcResult;
470 pub fn FcPatternBuild(p: *mut FcPattern, ...) -> *mut FcPattern;
472 pub fn FcPatternFormat(pat: *mut FcPattern, format: *const FcChar8)
473 -> *mut FcChar8;
474 pub fn FcStrCopy(s: *const FcChar8) -> *mut FcChar8;
475 pub fn FcStrCopyFilename(s: *const FcChar8) -> *mut FcChar8;
476 pub fn FcStrPlus(s1: *const FcChar8, s2: *const FcChar8) -> *mut FcChar8;
477 pub fn FcStrFree(s: *mut FcChar8);
478 pub fn FcStrDowncase(s: *const FcChar8) -> *mut FcChar8;
479 pub fn FcStrCmpIgnoreCase(s1: *const FcChar8, s2: *const FcChar8)
480 -> ::libc::c_int;
481 pub fn FcStrCmp(s1: *const FcChar8, s2: *const FcChar8) -> ::libc::c_int;
482 pub fn FcStrStrIgnoreCase(s1: *const FcChar8, s2: *const FcChar8)
483 -> *const FcChar8;
484 pub fn FcStrStr(s1: *const FcChar8, s2: *const FcChar8) -> *const FcChar8;
485 pub fn FcUtf8ToUcs4(src_orig: *const FcChar8, dst: *mut FcChar32,
486 len: ::libc::c_int) -> ::libc::c_int;
487 pub fn FcUtf8Len(string: *const FcChar8, len: ::libc::c_int,
488 nchar: *mut ::libc::c_int, wchar: *mut ::libc::c_int)
489 -> FcBool;
490 pub fn FcUcs4ToUtf8(ucs4: FcChar32, dest: *mut FcChar8) -> ::libc::c_int;
491 pub fn FcUtf16ToUcs4(src_orig: *const FcChar8, endian: FcEndian,
492 dst: *mut FcChar32, len: ::libc::c_int)
493 -> ::libc::c_int;
494 pub fn FcUtf16Len(string: *const FcChar8, endian: FcEndian,
495 len: ::libc::c_int, nchar: *mut ::libc::c_int,
496 wchar: *mut ::libc::c_int) -> FcBool;
497 pub fn FcStrDirname(file: *const FcChar8) -> *mut FcChar8;
498 pub fn FcStrBasename(file: *const FcChar8) -> *mut FcChar8;
499 pub fn FcStrSetCreate() -> *mut FcStrSet;
500 pub fn FcStrSetMember(set: *mut FcStrSet, s: *const FcChar8) -> FcBool;
501 pub fn FcStrSetEqual(sa: *mut FcStrSet, sb: *mut FcStrSet) -> FcBool;
502 pub fn FcStrSetAdd(set: *mut FcStrSet, s: *const FcChar8) -> FcBool;
503 pub fn FcStrSetAddFilename(set: *mut FcStrSet, s: *const FcChar8)
504 -> FcBool;
505 pub fn FcStrSetDel(set: *mut FcStrSet, s: *const FcChar8) -> FcBool;
506 pub fn FcStrSetDestroy(set: *mut FcStrSet);
507 pub fn FcStrListCreate(set: *mut FcStrSet) -> *mut FcStrList;
508 pub fn FcStrListFirst(list: *mut FcStrList);
509 pub fn FcStrListNext(list: *mut FcStrList) -> *mut FcChar8;
510 pub fn FcStrListDone(list: *mut FcStrList);
511 pub fn FcConfigParseAndLoad(config: *mut FcConfig, file: *const FcChar8,
512 complain: FcBool) -> FcBool;
513}