← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/poppler/fontconfig/fontconfig.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/fontconfig/fontconfig.h
 
1
/*
 
2
 * fontconfig/fontconfig/fontconfig.h
 
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
 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 
17
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 
18
 * EVENT SHALL THE AUTHOR(S) 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
#ifndef _FONTCONFIG_H_
 
26
#define _FONTCONFIG_H_
 
27
 
 
28
#include <sys/types.h>
 
29
#include <sys/stat.h>
 
30
#include <unistd.h>
 
31
#include <stdarg.h>
 
32
 
 
33
#if defined(__GNUC__) && (__GNUC__ >= 4)
 
34
#define FC_ATTRIBUTE_SENTINEL(x) __attribute__((__sentinel__(0)))
 
35
#else
 
36
#define FC_ATTRIBUTE_SENTINEL(x)
 
37
#endif
 
38
 
 
39
#ifndef FcPublic
 
40
#define FcPublic
 
41
#endif
 
42
 
 
43
typedef unsigned char   FcChar8;
 
44
typedef unsigned short  FcChar16;
 
45
typedef unsigned int    FcChar32;
 
46
typedef int             FcBool;
 
47
 
 
48
/*
 
49
 * Current Fontconfig version number.  This same number
 
50
 * must appear in the fontconfig configure.in file. Yes,
 
51
 * it'a a pain to synchronize version numbers like this.
 
52
 */
 
53
 
 
54
#define FC_MAJOR        2
 
55
#define FC_MINOR        8
 
56
#define FC_REVISION     0
 
57
 
 
58
#define FC_VERSION      ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))
 
59
 
 
60
/*
 
61
 * Current font cache file format version
 
62
 * This is appended to the cache files so that multiple
 
63
 * versions of the library will peacefully coexist
 
64
 *
 
65
 * Change this value whenever the disk format for the cache file
 
66
 * changes in any non-compatible way.  Try to avoid such changes as
 
67
 * it means multiple copies of the font information.
 
68
 */
 
69
 
 
70
#define FC_CACHE_VERSION    "3"
 
71
 
 
72
#define FcTrue          1
 
73
#define FcFalse         0
 
74
 
 
75
#define FC_FAMILY           "family"            /* String */
 
76
#define FC_STYLE            "style"             /* String */
 
77
#define FC_SLANT            "slant"             /* Int */
 
78
#define FC_WEIGHT           "weight"            /* Int */
 
79
#define FC_SIZE             "size"              /* Double */
 
80
#define FC_ASPECT           "aspect"            /* Double */
 
81
#define FC_PIXEL_SIZE       "pixelsize"         /* Double */
 
82
#define FC_SPACING          "spacing"           /* Int */
 
83
#define FC_FOUNDRY          "foundry"           /* String */
 
84
#define FC_ANTIALIAS        "antialias"         /* Bool (depends) */
 
85
#define FC_HINTING          "hinting"           /* Bool (true) */
 
86
#define FC_HINT_STYLE       "hintstyle"         /* Int */
 
87
#define FC_VERTICAL_LAYOUT  "verticallayout"    /* Bool (false) */
 
88
#define FC_AUTOHINT         "autohint"          /* Bool (false) */
 
89
#define FC_GLOBAL_ADVANCE   "globaladvance"     /* Bool (true) */
 
90
#define FC_WIDTH            "width"             /* Int */
 
91
#define FC_FILE             "file"              /* String */
 
92
#define FC_INDEX            "index"             /* Int */
 
93
#define FC_FT_FACE          "ftface"            /* FT_Face */
 
94
#define FC_RASTERIZER       "rasterizer"        /* String */
 
95
#define FC_OUTLINE          "outline"           /* Bool */
 
96
#define FC_SCALABLE         "scalable"          /* Bool */
 
97
#define FC_SCALE            "scale"             /* double */
 
98
#define FC_DPI              "dpi"               /* double */
 
99
#define FC_RGBA             "rgba"              /* Int */
 
100
#define FC_MINSPACE         "minspace"          /* Bool use minimum line spacing */
 
101
#define FC_SOURCE           "source"            /* String (deprecated) */
 
102
#define FC_CHARSET          "charset"           /* CharSet */
 
103
#define FC_LANG             "lang"              /* String RFC 3066 langs */
 
104
#define FC_FONTVERSION      "fontversion"       /* Int from 'head' table */
 
105
#define FC_FULLNAME         "fullname"          /* String */
 
106
#define FC_FAMILYLANG       "familylang"        /* String RFC 3066 langs */
 
107
#define FC_STYLELANG        "stylelang"         /* String RFC 3066 langs */
 
108
#define FC_FULLNAMELANG     "fullnamelang"      /* String RFC 3066 langs */
 
109
#define FC_CAPABILITY       "capability"        /* String */
 
110
#define FC_FONTFORMAT       "fontformat"        /* String */
 
111
#define FC_EMBOLDEN         "embolden"          /* Bool - true if emboldening needed*/
 
112
#define FC_EMBEDDED_BITMAP  "embeddedbitmap"    /* Bool - true to enable embedded bitmaps */
 
113
#define FC_DECORATIVE       "decorative"        /* Bool - true if style is a decorative variant */
 
114
#define FC_LCD_FILTER       "lcdfilter"         /* Int */
 
115
 
 
116
#define FC_CACHE_SUFFIX             ".cache-"FC_CACHE_VERSION
 
117
#define FC_DIR_CACHE_FILE           "fonts.cache-"FC_CACHE_VERSION
 
118
#define FC_USER_CACHE_FILE          ".fonts.cache-"FC_CACHE_VERSION
 
119
 
 
120
/* Adjust outline rasterizer */
 
121
#define FC_CHAR_WIDTH       "charwidth" /* Int */
 
122
#define FC_CHAR_HEIGHT      "charheight"/* Int */
 
123
#define FC_MATRIX           "matrix"    /* FcMatrix */
 
124
 
 
125
#define FC_WEIGHT_THIN              0
 
126
#define FC_WEIGHT_EXTRALIGHT        40
 
127
#define FC_WEIGHT_ULTRALIGHT        FC_WEIGHT_EXTRALIGHT
 
128
#define FC_WEIGHT_LIGHT             50
 
129
#define FC_WEIGHT_BOOK              75
 
130
#define FC_WEIGHT_REGULAR           80
 
131
#define FC_WEIGHT_NORMAL            FC_WEIGHT_REGULAR
 
132
#define FC_WEIGHT_MEDIUM            100
 
133
#define FC_WEIGHT_DEMIBOLD          180
 
134
#define FC_WEIGHT_SEMIBOLD          FC_WEIGHT_DEMIBOLD
 
135
#define FC_WEIGHT_BOLD              200
 
136
#define FC_WEIGHT_EXTRABOLD         205
 
137
#define FC_WEIGHT_ULTRABOLD         FC_WEIGHT_EXTRABOLD
 
138
#define FC_WEIGHT_BLACK             210
 
139
#define FC_WEIGHT_HEAVY             FC_WEIGHT_BLACK
 
140
#define FC_WEIGHT_EXTRABLACK        215
 
141
#define FC_WEIGHT_ULTRABLACK        FC_WEIGHT_EXTRABLACK
 
142
 
 
143
#define FC_SLANT_ROMAN              0
 
144
#define FC_SLANT_ITALIC             100
 
145
#define FC_SLANT_OBLIQUE            110
 
146
 
 
147
#define FC_WIDTH_ULTRACONDENSED     50
 
148
#define FC_WIDTH_EXTRACONDENSED     63
 
149
#define FC_WIDTH_CONDENSED          75
 
150
#define FC_WIDTH_SEMICONDENSED      87
 
151
#define FC_WIDTH_NORMAL             100
 
152
#define FC_WIDTH_SEMIEXPANDED       113
 
153
#define FC_WIDTH_EXPANDED           125
 
154
#define FC_WIDTH_EXTRAEXPANDED      150
 
155
#define FC_WIDTH_ULTRAEXPANDED      200
 
156
 
 
157
#define FC_PROPORTIONAL             0
 
158
#define FC_DUAL                     90
 
159
#define FC_MONO                     100
 
160
#define FC_CHARCELL                 110
 
161
 
 
162
/* sub-pixel order */
 
163
#define FC_RGBA_UNKNOWN     0
 
164
#define FC_RGBA_RGB         1
 
165
#define FC_RGBA_BGR         2
 
166
#define FC_RGBA_VRGB        3
 
167
#define FC_RGBA_VBGR        4
 
168
#define FC_RGBA_NONE        5
 
169
 
 
170
/* hinting style */
 
171
#define FC_HINT_NONE        0
 
172
#define FC_HINT_SLIGHT      1
 
173
#define FC_HINT_MEDIUM      2
 
174
#define FC_HINT_FULL        3
 
175
 
 
176
/* LCD filter */
 
177
#define FC_LCD_NONE         0
 
178
#define FC_LCD_DEFAULT      1
 
179
#define FC_LCD_LIGHT        2
 
180
#define FC_LCD_LEGACY       3
 
181
 
 
182
typedef enum _FcType {
 
183
    FcTypeVoid, 
 
184
    FcTypeInteger, 
 
185
    FcTypeDouble, 
 
186
    FcTypeString, 
 
187
    FcTypeBool,
 
188
    FcTypeMatrix,
 
189
    FcTypeCharSet,
 
190
    FcTypeFTFace,
 
191
    FcTypeLangSet
 
192
} FcType;
 
193
 
 
194
typedef struct _FcMatrix {
 
195
    double xx, xy, yx, yy;
 
196
} FcMatrix;
 
197
 
 
198
#define FcMatrixInit(m) ((m)->xx = (m)->yy = 1, \
 
199
                         (m)->xy = (m)->yx = 0)
 
200
 
 
201
/*
 
202
 * A data structure to represent the available glyphs in a font.
 
203
 * This is represented as a sparse boolean btree.
 
204
 */
 
205
 
 
206
typedef struct _FcCharSet FcCharSet;
 
207
 
 
208
typedef struct _FcObjectType {
 
209
    const char  *object;
 
210
    FcType      type;
 
211
} FcObjectType;
 
212
 
 
213
typedef struct _FcConstant {
 
214
    const FcChar8  *name;
 
215
    const char  *object;
 
216
    int         value;
 
217
} FcConstant;
 
218
 
 
219
typedef enum _FcResult {
 
220
    FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId,
 
221
    FcResultOutOfMemory
 
222
} FcResult;
 
223
 
 
224
typedef struct _FcPattern   FcPattern;
 
225
 
 
226
typedef struct _FcLangSet   FcLangSet;
 
227
 
 
228
typedef struct _FcValue {
 
229
    FcType      type;
 
230
    union {
 
231
        const FcChar8   *s;
 
232
        int             i;
 
233
        FcBool          b;
 
234
        double          d;
 
235
        const FcMatrix  *m;
 
236
        const FcCharSet *c;
 
237
        void            *f;
 
238
        const FcLangSet *l;
 
239
    } u;
 
240
} FcValue;
 
241
 
 
242
typedef struct _FcFontSet {
 
243
    int         nfont;
 
244
    int         sfont;
 
245
    FcPattern   **fonts;
 
246
} FcFontSet;
 
247
 
 
248
typedef struct _FcObjectSet {
 
249
    int         nobject;
 
250
    int         sobject;
 
251
    const char  **objects;
 
252
} FcObjectSet;
 
253
    
 
254
typedef enum _FcMatchKind {
 
255
    FcMatchPattern, FcMatchFont, FcMatchScan
 
256
} FcMatchKind;
 
257
 
 
258
typedef enum _FcLangResult {
 
259
    FcLangEqual = 0,
 
260
    FcLangDifferentCountry = 1,
 
261
    FcLangDifferentTerritory = 1,
 
262
    FcLangDifferentLang = 2
 
263
} FcLangResult;
 
264
 
 
265
typedef enum _FcSetName {
 
266
    FcSetSystem = 0,
 
267
    FcSetApplication = 1
 
268
} FcSetName;
 
269
 
 
270
typedef struct _FcAtomic FcAtomic;
 
271
 
 
272
#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
 
273
#define _FCFUNCPROTOBEGIN extern "C" {  /* do not leave open across includes */
 
274
#define _FCFUNCPROTOEND }
 
275
#else
 
276
#define _FCFUNCPROTOBEGIN
 
277
#define _FCFUNCPROTOEND
 
278
#endif
 
279
 
 
280
typedef enum { FcEndianBig, FcEndianLittle } FcEndian;
 
281
 
 
282
typedef struct _FcConfig    FcConfig;
 
283
 
 
284
typedef struct _FcGlobalCache   FcFileCache;
 
285
 
 
286
typedef struct _FcBlanks    FcBlanks;
 
287
 
 
288
typedef struct _FcStrList   FcStrList;
 
289
 
 
290
typedef struct _FcStrSet    FcStrSet;
 
291
 
 
292
typedef struct _FcCache     FcCache;
 
293
 
 
294
_FCFUNCPROTOBEGIN
 
295
 
 
296
/* fcblanks.c */
 
297
FcPublic FcBlanks *
 
298
FcBlanksCreate (void);
 
299
 
 
300
FcPublic void
 
301
FcBlanksDestroy (FcBlanks *b);
 
302
 
 
303
FcPublic FcBool
 
304
FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
 
305
 
 
306
FcPublic FcBool
 
307
FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);
 
308
 
 
309
/* fccache.c */
 
310
 
 
311
FcPublic const FcChar8 *
 
312
FcCacheDir(const FcCache *c);
 
313
 
 
314
FcPublic FcFontSet *
 
315
FcCacheCopySet(const FcCache *c);
 
316
 
 
317
FcPublic const FcChar8 *
 
318
FcCacheSubdir (const FcCache *c, int i);
 
319
 
 
320
FcPublic int
 
321
FcCacheNumSubdir (const FcCache *c);
 
322
 
 
323
FcPublic int
 
324
FcCacheNumFont (const FcCache *c);
 
325
 
 
326
FcPublic FcBool
 
327
FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
 
328
 
 
329
FcPublic FcBool
 
330
FcDirCacheValid (const FcChar8 *cache_file);
 
331
 
 
332
/* fccfg.c */
 
333
FcPublic FcChar8 *
 
334
FcConfigHome (void);
 
335
 
 
336
FcPublic FcBool
 
337
FcConfigEnableHome (FcBool enable);
 
338
 
 
339
FcPublic FcChar8 *
 
340
FcConfigFilename (const FcChar8 *url);
 
341
    
 
342
FcPublic FcConfig *
 
343
FcConfigCreate (void);
 
344
 
 
345
FcPublic FcConfig *
 
346
FcConfigReference (FcConfig *config);
 
347
 
 
348
FcPublic void
 
349
FcConfigDestroy (FcConfig *config);
 
350
 
 
351
FcPublic FcBool
 
352
FcConfigSetCurrent (FcConfig *config);
 
353
 
 
354
FcPublic FcConfig *
 
355
FcConfigGetCurrent (void);
 
356
 
 
357
FcPublic FcBool
 
358
FcConfigUptoDate (FcConfig *config);
 
359
    
 
360
FcPublic FcBool
 
361
FcConfigBuildFonts (FcConfig *config);
 
362
 
 
363
FcPublic FcStrList *
 
364
FcConfigGetFontDirs (FcConfig   *config);
 
365
 
 
366
FcPublic FcStrList *
 
367
FcConfigGetConfigDirs (FcConfig   *config);
 
368
 
 
369
FcPublic FcStrList *
 
370
FcConfigGetConfigFiles (FcConfig    *config);
 
371
 
 
372
FcPublic FcChar8 *
 
373
FcConfigGetCache (FcConfig  *config);
 
374
 
 
375
FcPublic FcBlanks *
 
376
FcConfigGetBlanks (FcConfig *config);
 
377
 
 
378
FcPublic FcStrList *
 
379
FcConfigGetCacheDirs (FcConfig  *config);
 
380
 
 
381
FcPublic int
 
382
FcConfigGetRescanInterval (FcConfig *config);
 
383
 
 
384
FcPublic FcBool
 
385
FcConfigSetRescanInterval (FcConfig *config, int rescanInterval);
 
386
 
 
387
FcPublic FcFontSet *
 
388
FcConfigGetFonts (FcConfig      *config,
 
389
                  FcSetName     set);
 
390
 
 
391
FcPublic FcBool
 
392
FcConfigAppFontAddFile (FcConfig    *config,
 
393
                        const FcChar8  *file);
 
394
 
 
395
FcPublic FcBool
 
396
FcConfigAppFontAddDir (FcConfig     *config,
 
397
                       const FcChar8   *dir);
 
398
 
 
399
FcPublic void
 
400
FcConfigAppFontClear (FcConfig      *config);
 
401
 
 
402
FcPublic FcBool
 
403
FcConfigSubstituteWithPat (FcConfig     *config,
 
404
                           FcPattern    *p,
 
405
                           FcPattern    *p_pat,
 
406
                           FcMatchKind  kind);
 
407
 
 
408
FcPublic FcBool
 
409
FcConfigSubstitute (FcConfig    *config,
 
410
                    FcPattern   *p,
 
411
                    FcMatchKind kind);
 
412
 
 
413
/* fccharset.c */
 
414
FcPublic FcCharSet*
 
415
FcCharSetCreate (void);
 
416
 
 
417
/* deprecated alias for FcCharSetCreate */
 
418
FcPublic FcCharSet *
 
419
FcCharSetNew (void);
 
420
    
 
421
FcPublic void
 
422
FcCharSetDestroy (FcCharSet *fcs);
 
423
 
 
424
FcPublic FcBool
 
425
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
 
426
 
 
427
FcPublic FcCharSet*
 
428
FcCharSetCopy (FcCharSet *src);
 
429
 
 
430
FcPublic FcBool
 
431
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
 
432
 
 
433
FcPublic FcCharSet*
 
434
FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
 
435
 
 
436
FcPublic FcCharSet*
 
437
FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
 
438
 
 
439
FcPublic FcCharSet*
 
440
FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
 
441
 
 
442
FcPublic FcBool
 
443
FcCharSetMerge (FcCharSet *a, const FcCharSet *b, FcBool *changed);
 
444
 
 
445
FcPublic FcBool
 
446
FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
 
447
 
 
448
FcPublic FcChar32
 
449
FcCharSetCount (const FcCharSet *a);
 
450
 
 
451
FcPublic FcChar32
 
452
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
 
453
 
 
454
FcPublic FcChar32
 
455
FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);
 
456
 
 
457
FcPublic FcBool
 
458
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);
 
459
 
 
460
#define FC_CHARSET_MAP_SIZE (256/32)
 
461
#define FC_CHARSET_DONE ((FcChar32) -1)
 
462
 
 
463
FcPublic FcChar32
 
464
FcCharSetFirstPage (const FcCharSet *a, 
 
465
                    FcChar32        map[FC_CHARSET_MAP_SIZE],
 
466
                    FcChar32        *next);
 
467
 
 
468
FcPublic FcChar32
 
469
FcCharSetNextPage (const FcCharSet  *a, 
 
470
                   FcChar32         map[FC_CHARSET_MAP_SIZE],
 
471
                   FcChar32         *next);
 
472
 
 
473
/*
 
474
 * old coverage API, rather hard to use correctly
 
475
 */
 
476
 
 
477
FcPublic FcChar32
 
478
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
 
479
 
 
480
/* fcdbg.c */
 
481
FcPublic void
 
482
FcValuePrint (const FcValue v);
 
483
 
 
484
FcPublic void
 
485
FcPatternPrint (const FcPattern *p);
 
486
 
 
487
FcPublic void
 
488
FcFontSetPrint (const FcFontSet *s);
 
489
 
 
490
/* fcdefault.c */
 
491
FcPublic void
 
492
FcDefaultSubstitute (FcPattern *pattern);
 
493
 
 
494
/* fcdir.c */
 
495
FcPublic FcBool
 
496
FcFileIsDir (const FcChar8 *file);
 
497
 
 
498
FcPublic FcBool
 
499
FcFileScan (FcFontSet       *set,
 
500
            FcStrSet        *dirs,
 
501
            FcFileCache     *cache,
 
502
            FcBlanks        *blanks,
 
503
            const FcChar8   *file,
 
504
            FcBool          force);
 
505
 
 
506
FcPublic FcBool
 
507
FcDirScan (FcFontSet        *set,
 
508
           FcStrSet         *dirs,
 
509
           FcFileCache      *cache,
 
510
           FcBlanks         *blanks,
 
511
           const FcChar8    *dir,
 
512
           FcBool           force);
 
513
 
 
514
FcPublic FcBool
 
515
FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
 
516
 
 
517
FcPublic FcCache *
 
518
FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
 
519
    
 
520
FcPublic FcCache *
 
521
FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
 
522
 
 
523
FcPublic FcCache *
 
524
FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
 
525
 
 
526
FcPublic void
 
527
FcDirCacheUnload (FcCache *cache);
 
528
 
 
529
/* fcfreetype.c */
 
530
FcPublic FcPattern *
 
531
FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
 
532
 
 
533
/* fcfs.c */
 
534
 
 
535
FcPublic FcFontSet *
 
536
FcFontSetCreate (void);
 
537
 
 
538
FcPublic void
 
539
FcFontSetDestroy (FcFontSet *s);
 
540
 
 
541
FcPublic FcBool
 
542
FcFontSetAdd (FcFontSet *s, FcPattern *font);
 
543
 
 
544
/* fcinit.c */
 
545
FcPublic FcConfig *
 
546
FcInitLoadConfig (void);
 
547
 
 
548
FcPublic FcConfig *
 
549
FcInitLoadConfigAndFonts (void);
 
550
 
 
551
FcPublic FcBool
 
552
FcInit (void);
 
553
 
 
554
FcPublic void
 
555
FcFini (void);
 
556
 
 
557
FcPublic int
 
558
FcGetVersion (void);
 
559
 
 
560
FcPublic FcBool
 
561
FcInitReinitialize (void);
 
562
 
 
563
FcPublic FcBool
 
564
FcInitBringUptoDate (void);
 
565
 
 
566
/* fclang.c */
 
567
FcPublic FcStrSet *
 
568
FcGetLangs (void);
 
569
 
 
570
FcPublic const FcCharSet *
 
571
FcLangGetCharSet (const FcChar8 *lang);
 
572
 
 
573
FcPublic FcLangSet*
 
574
FcLangSetCreate (void);
 
575
 
 
576
FcPublic void
 
577
FcLangSetDestroy (FcLangSet *ls);
 
578
 
 
579
FcPublic FcLangSet*
 
580
FcLangSetCopy (const FcLangSet *ls);
 
581
 
 
582
FcPublic FcBool
 
583
FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
 
584
 
 
585
FcPublic FcLangResult
 
586
FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
 
587
 
 
588
FcPublic FcLangResult
 
589
FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
 
590
 
 
591
FcPublic FcBool
 
592
FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
 
593
 
 
594
FcPublic FcBool
 
595
FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
 
596
 
 
597
FcPublic FcChar32
 
598
FcLangSetHash (const FcLangSet *ls);
 
599
 
 
600
FcPublic FcStrSet *
 
601
FcLangSetGetLangs (const FcLangSet *ls);
 
602
 
 
603
/* fclist.c */
 
604
FcPublic FcObjectSet *
 
605
FcObjectSetCreate (void);
 
606
 
 
607
FcPublic FcBool
 
608
FcObjectSetAdd (FcObjectSet *os, const char *object);
 
609
 
 
610
FcPublic void
 
611
FcObjectSetDestroy (FcObjectSet *os);
 
612
 
 
613
FcPublic FcObjectSet *
 
614
FcObjectSetVaBuild (const char *first, va_list va);
 
615
 
 
616
FcPublic FcObjectSet *
 
617
FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
 
618
 
 
619
FcPublic FcFontSet *
 
620
FcFontSetList (FcConfig     *config,
 
621
               FcFontSet    **sets,
 
622
               int          nsets,
 
623
               FcPattern    *p,
 
624
               FcObjectSet  *os);
 
625
 
 
626
FcPublic FcFontSet *
 
627
FcFontList (FcConfig    *config,
 
628
            FcPattern   *p,
 
629
            FcObjectSet *os);
 
630
 
 
631
/* fcatomic.c */
 
632
 
 
633
FcPublic FcAtomic *
 
634
FcAtomicCreate (const FcChar8   *file);
 
635
 
 
636
FcPublic FcBool
 
637
FcAtomicLock (FcAtomic *atomic);
 
638
 
 
639
FcPublic FcChar8 *
 
640
FcAtomicNewFile (FcAtomic *atomic);
 
641
 
 
642
FcPublic FcChar8 *
 
643
FcAtomicOrigFile (FcAtomic *atomic);
 
644
 
 
645
FcPublic FcBool
 
646
FcAtomicReplaceOrig (FcAtomic *atomic);
 
647
 
 
648
FcPublic void
 
649
FcAtomicDeleteNew (FcAtomic *atomic);
 
650
 
 
651
FcPublic void
 
652
FcAtomicUnlock (FcAtomic *atomic);
 
653
 
 
654
FcPublic void
 
655
FcAtomicDestroy (FcAtomic *atomic);
 
656
 
 
657
/* fcmatch.c */
 
658
FcPublic FcPattern *
 
659
FcFontSetMatch (FcConfig    *config,
 
660
                FcFontSet   **sets,
 
661
                int         nsets,
 
662
                FcPattern   *p,
 
663
                FcResult    *result);
 
664
 
 
665
FcPublic FcPattern *
 
666
FcFontMatch (FcConfig   *config,
 
667
             FcPattern  *p, 
 
668
             FcResult   *result);
 
669
 
 
670
FcPublic FcPattern *
 
671
FcFontRenderPrepare (FcConfig       *config,
 
672
                     FcPattern      *pat,
 
673
                     FcPattern      *font);
 
674
 
 
675
FcPublic FcFontSet *
 
676
FcFontSetSort (FcConfig     *config,
 
677
               FcFontSet    **sets,
 
678
               int          nsets,
 
679
               FcPattern    *p,
 
680
               FcBool       trim,
 
681
               FcCharSet    **csp,
 
682
               FcResult     *result);
 
683
 
 
684
FcPublic FcFontSet *
 
685
FcFontSort (FcConfig     *config,
 
686
            FcPattern    *p,
 
687
            FcBool       trim,
 
688
            FcCharSet    **csp,
 
689
            FcResult     *result);
 
690
 
 
691
FcPublic void
 
692
FcFontSetSortDestroy (FcFontSet *fs);
 
693
 
 
694
/* fcmatrix.c */
 
695
FcPublic FcMatrix *
 
696
FcMatrixCopy (const FcMatrix *mat);
 
697
 
 
698
FcPublic FcBool
 
699
FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
 
700
 
 
701
FcPublic void
 
702
FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
 
703
 
 
704
FcPublic void
 
705
FcMatrixRotate (FcMatrix *m, double c, double s);
 
706
 
 
707
FcPublic void
 
708
FcMatrixScale (FcMatrix *m, double sx, double sy);
 
709
 
 
710
FcPublic void
 
711
FcMatrixShear (FcMatrix *m, double sh, double sv);
 
712
 
 
713
/* fcname.c */
 
714
 
 
715
FcPublic FcBool
 
716
FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
 
717
 
 
718
FcPublic FcBool
 
719
FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
 
720
    
 
721
FcPublic const FcObjectType *
 
722
FcNameGetObjectType (const char *object);
 
723
 
 
724
FcPublic FcBool
 
725
FcNameRegisterConstants (const FcConstant *consts, int nconsts);
 
726
 
 
727
FcPublic FcBool
 
728
FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
 
729
    
 
730
FcPublic const FcConstant *
 
731
FcNameGetConstant (FcChar8 *string);
 
732
 
 
733
FcPublic FcBool
 
734
FcNameConstant (FcChar8 *string, int *result);
 
735
 
 
736
FcPublic FcPattern *
 
737
FcNameParse (const FcChar8 *name);
 
738
 
 
739
FcPublic FcChar8 *
 
740
FcNameUnparse (FcPattern *pat);
 
741
 
 
742
/* fcpat.c */
 
743
FcPublic FcPattern *
 
744
FcPatternCreate (void);
 
745
 
 
746
FcPublic FcPattern *
 
747
FcPatternDuplicate (const FcPattern *p);
 
748
 
 
749
FcPublic void
 
750
FcPatternReference (FcPattern *p);
 
751
 
 
752
FcPublic FcPattern *
 
753
FcPatternFilter (FcPattern *p, const FcObjectSet *os);
 
754
 
 
755
FcPublic void
 
756
FcValueDestroy (FcValue v);
 
757
 
 
758
FcPublic FcBool
 
759
FcValueEqual (FcValue va, FcValue vb);
 
760
 
 
761
FcPublic FcValue
 
762
FcValueSave (FcValue v);
 
763
 
 
764
FcPublic void
 
765
FcPatternDestroy (FcPattern *p);
 
766
 
 
767
FcPublic FcBool
 
768
FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
 
769
 
 
770
FcPublic FcBool
 
771
FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
 
772
 
 
773
FcPublic FcChar32
 
774
FcPatternHash (const FcPattern *p);
 
775
 
 
776
FcPublic FcBool
 
777
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
 
778
    
 
779
FcPublic FcBool
 
780
FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
 
781
    
 
782
FcPublic FcResult
 
783
FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
 
784
    
 
785
FcPublic FcBool
 
786
FcPatternDel (FcPattern *p, const char *object);
 
787
 
 
788
FcPublic FcBool
 
789
FcPatternRemove (FcPattern *p, const char *object, int id);
 
790
 
 
791
FcPublic FcBool
 
792
FcPatternAddInteger (FcPattern *p, const char *object, int i);
 
793
 
 
794
FcPublic FcBool
 
795
FcPatternAddDouble (FcPattern *p, const char *object, double d);
 
796
 
 
797
FcPublic FcBool
 
798
FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
 
799
 
 
800
FcPublic FcBool
 
801
FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
 
802
 
 
803
FcPublic FcBool
 
804
FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
 
805
 
 
806
FcPublic FcBool
 
807
FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
 
808
 
 
809
FcPublic FcBool
 
810
FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
 
811
 
 
812
FcPublic FcResult
 
813
FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
 
814
 
 
815
FcPublic FcResult
 
816
FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);
 
817
 
 
818
FcPublic FcResult
 
819
FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);
 
820
 
 
821
FcPublic FcResult
 
822
FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);
 
823
 
 
824
FcPublic FcResult
 
825
FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);
 
826
 
 
827
FcPublic FcResult
 
828
FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);
 
829
 
 
830
FcPublic FcResult
 
831
FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
 
832
 
 
833
FcPublic FcPattern *
 
834
FcPatternVaBuild (FcPattern *p, va_list va);
 
835
    
 
836
FcPublic FcPattern *
 
837
FcPatternBuild (FcPattern *p, ...) FC_ATTRIBUTE_SENTINEL(0);
 
838
 
 
839
FcPublic FcChar8 *
 
840
FcPatternFormat (FcPattern *pat, const FcChar8 *format);
 
841
 
 
842
/* fcstr.c */
 
843
 
 
844
FcPublic FcChar8 *
 
845
FcStrCopy (const FcChar8 *s);
 
846
 
 
847
FcPublic FcChar8 *
 
848
FcStrCopyFilename (const FcChar8 *s);
 
849
    
 
850
FcPublic FcChar8 *
 
851
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
 
852
    
 
853
FcPublic void
 
854
FcStrFree (FcChar8 *s);
 
855
 
 
856
/* These are ASCII only, suitable only for pattern element names */
 
857
#define FcIsUpper(c)    ((0101 <= (c) && (c) <= 0132))
 
858
#define FcIsLower(c)    ((0141 <= (c) && (c) <= 0172))
 
859
#define FcToLower(c)    (FcIsUpper(c) ? (c) - 0101 + 0141 : (c))
 
860
 
 
861
FcPublic FcChar8 *
 
862
FcStrDowncase (const FcChar8 *s);
 
863
 
 
864
FcPublic int
 
865
FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
866
 
 
867
FcPublic int
 
868
FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
 
869
 
 
870
FcPublic const FcChar8 *
 
871
FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
872
 
 
873
FcPublic const FcChar8 *
 
874
FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
 
875
 
 
876
FcPublic int
 
877
FcUtf8ToUcs4 (const FcChar8 *src_orig,
 
878
              FcChar32      *dst,
 
879
              int           len);
 
880
 
 
881
FcPublic FcBool
 
882
FcUtf8Len (const FcChar8    *string,
 
883
           int              len,
 
884
           int              *nchar,
 
885
           int              *wchar);
 
886
 
 
887
#define FC_UTF8_MAX_LEN 6
 
888
 
 
889
FcPublic int
 
890
FcUcs4ToUtf8 (FcChar32  ucs4,
 
891
              FcChar8   dest[FC_UTF8_MAX_LEN]);
 
892
 
 
893
FcPublic int
 
894
FcUtf16ToUcs4 (const FcChar8    *src_orig,
 
895
               FcEndian         endian,
 
896
               FcChar32         *dst,
 
897
               int              len);       /* in bytes */
 
898
 
 
899
FcPublic FcBool
 
900
FcUtf16Len (const FcChar8   *string,
 
901
            FcEndian        endian,
 
902
            int             len,            /* in bytes */
 
903
            int             *nchar,
 
904
            int             *wchar);
 
905
 
 
906
FcPublic FcChar8 *
 
907
FcStrDirname (const FcChar8 *file);
 
908
 
 
909
FcPublic FcChar8 *
 
910
FcStrBasename (const FcChar8 *file);
 
911
 
 
912
FcPublic FcStrSet *
 
913
FcStrSetCreate (void);
 
914
 
 
915
FcPublic FcBool
 
916
FcStrSetMember (FcStrSet *set, const FcChar8 *s);
 
917
 
 
918
FcPublic FcBool
 
919
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);
 
920
 
 
921
FcPublic FcBool
 
922
FcStrSetAdd (FcStrSet *set, const FcChar8 *s);
 
923
 
 
924
FcPublic FcBool
 
925
FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);
 
926
 
 
927
FcPublic FcBool
 
928
FcStrSetDel (FcStrSet *set, const FcChar8 *s);
 
929
 
 
930
FcPublic void
 
931
FcStrSetDestroy (FcStrSet *set);
 
932
 
 
933
FcPublic FcStrList *
 
934
FcStrListCreate (FcStrSet *set);
 
935
 
 
936
FcPublic FcChar8 *
 
937
FcStrListNext (FcStrList *list);
 
938
 
 
939
FcPublic void
 
940
FcStrListDone (FcStrList *list);
 
941
 
 
942
/* fcxml.c */
 
943
FcPublic FcBool
 
944
FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
 
945
 
 
946
_FCFUNCPROTOEND
 
947
 
 
948
#undef FC_ATTRIBUTE_SENTINEL
 
949
 
 
950
 
 
951
#ifndef _FCINT_H_
 
952
 
 
953
/*
 
954
 * Deprecated functions are placed here to help users fix their code without
 
955
 * digging through documentation
 
956
 */
 
957
 
 
958
#define FcConfigGetRescanInverval   FcConfigGetRescanInverval_REPLACE_BY_FcConfigGetRescanInterval
 
959
#define FcConfigSetRescanInverval   FcConfigSetRescanInverval_REPLACE_BY_FcConfigSetRescanInterval
 
960
 
 
961
#endif
 
962
 
 
963
#endif /* _FONTCONFIG_H_ */