[fontconfig.git] / fontconfig / fontconfig.h

/*
 * $RCSId: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.30 2002/09/26 00:17:27 keithp Exp $
 *
 * Copyright © 2001 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _FONTCONFIG_H_
#define _FONTCONFIG_H_

#include <stdarg.h>

typedef unsigned char	FcChar8;
typedef unsigned short	FcChar16;
typedef unsigned int	FcChar32;
typedef int		FcBool;

/*
 * Current Fontconfig version number.  This same number
 * must appear in the fontconfig configure.in file. Yes,
 * it'a a pain to synchronize version numbers like this.
 */

#define FC_MAJOR	2
#define FC_MINOR	3
#define FC_REVISION	91

#define FC_VERSION	((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))

/*
 * Current font cache file format version
 * This is appended to the cache files so that multiple
 * versions of the library will peacefully coexist
 *
 * Change this value whenever the disk format for the cache file
 * changes in any non-compatible way.  Try to avoid such changes as
 * it means multiple copies of the font information.
 */

#define FC_CACHE_VERSION    "2"

#define FcTrue		1
#define FcFalse		0

#define FC_FAMILY	    "family"		/* String */
#define FC_STYLE	    "style"		/* String */
#define FC_SLANT	    "slant"		/* Int */
#define FC_WEIGHT	    "weight"		/* Int */
#define FC_SIZE		    "size"		/* Double */
#define FC_ASPECT	    "aspect"		/* Double */
#define FC_PIXEL_SIZE	    "pixelsize"		/* Double */
#define FC_SPACING	    "spacing"		/* Int */
#define FC_FOUNDRY	    "foundry"		/* String */
#define FC_ANTIALIAS	    "antialias"		/* Bool (depends) */
#define FC_HINTING	    "hinting"		/* Bool (true) */
#define FC_HINT_STYLE	    "hintstyle"		/* Int */
#define FC_VERTICAL_LAYOUT  "verticallayout"	/* Bool (false) */
#define FC_AUTOHINT	    "autohint"		/* Bool (false) */
#define FC_GLOBAL_ADVANCE   "globaladvance"	/* Bool (true) */
#define FC_WIDTH	    "width"		/* Int */
#define FC_FILE		    "file"		/* String */
#define FC_INDEX	    "index"		/* Int */
#define FC_FT_FACE	    "ftface"		/* FT_Face */
#define FC_RASTERIZER	    "rasterizer"	/* String */
#define FC_OUTLINE	    "outline"		/* Bool */
#define FC_SCALABLE	    "scalable"		/* Bool */
#define FC_SCALE	    "scale"		/* double */
#define FC_DPI		    "dpi"		/* double */
#define FC_RGBA		    "rgba"		/* Int */
#define FC_MINSPACE	    "minspace"		/* Bool use minimum line spacing */
#define FC_SOURCE	    "source"		/* String (deprecated) */
#define FC_CHARSET	    "charset"		/* CharSet */
#define FC_LANG		    "lang"		/* String RFC 3066 langs */
#define FC_FONTVERSION	    "fontversion"	/* Int from 'head' table */
#define FC_FULLNAME	    "fullname"		/* String */
#define FC_FAMILYLANG	    "familylang"	/* String RFC 3066 langs */
#define FC_STYLELANG	    "stylelang"		/* String RFC 3066 langs */
#define FC_FULLNAMELANG	    "fullnamelang"	/* String RFC 3066 langs */
#define FC_CAPABILITY       "capability"	/* String */
#define FC_FONTFORMAT	    "fontformat"	/* String */
#define FC_EMBOLDEN	    "embolden"		/* Bool - true if emboldening needed*/

#define FC_DIR_CACHE_FILE	    "fonts.cache-"FC_CACHE_VERSION
#define FC_USER_CACHE_FILE	    ".fonts.cache-"FC_CACHE_VERSION

/* Adjust outline rasterizer */
#define FC_CHAR_WIDTH	    "charwidth"	/* Int */
#define FC_CHAR_HEIGHT	    "charheight"/* Int */
#define FC_MATRIX	    "matrix"    /* FcMatrix */

#define FC_WEIGHT_THIN		    0
#define FC_WEIGHT_EXTRALIGHT	    40
#define FC_WEIGHT_ULTRALIGHT	    FC_WEIGHT_EXTRALIGHT
#define FC_WEIGHT_LIGHT		    50
#define FC_WEIGHT_BOOK		    75
#define FC_WEIGHT_REGULAR	    80
#define FC_WEIGHT_NORMAL	    FC_WEIGHT_REGULAR
#define FC_WEIGHT_MEDIUM	    100
#define FC_WEIGHT_DEMIBOLD	    180
#define FC_WEIGHT_SEMIBOLD	    FC_WEIGHT_DEMIBOLD
#define FC_WEIGHT_BOLD		    200
#define FC_WEIGHT_EXTRABOLD	    205
#define FC_WEIGHT_ULTRABOLD	    FC_WEIGHT_EXTRABOLD
#define FC_WEIGHT_BLACK		    210
#define FC_WEIGHT_HEAVY		    FC_WEIGHT_BLACK

#define FC_SLANT_ROMAN		    0
#define FC_SLANT_ITALIC		    100
#define FC_SLANT_OBLIQUE	    110

#define FC_WIDTH_ULTRACONDENSED	    50
#define FC_WIDTH_EXTRACONDENSED	    63
#define FC_WIDTH_CONDENSED	    75
#define FC_WIDTH_SEMICONDENSED	    87
#define FC_WIDTH_NORMAL		    100
#define FC_WIDTH_SEMIEXPANDED	    113
#define FC_WIDTH_EXPANDED	    125
#define FC_WIDTH_EXTRAEXPANDED	    150
#define FC_WIDTH_ULTRAEXPANDED	    200

#define FC_PROPORTIONAL		    0
#define FC_DUAL			    90
#define FC_MONO			    100
#define FC_CHARCELL		    110

/* sub-pixel order */
#define FC_RGBA_UNKNOWN	    0
#define FC_RGBA_RGB	    1
#define FC_RGBA_BGR	    2
#define FC_RGBA_VRGB	    3
#define FC_RGBA_VBGR	    4
#define FC_RGBA_NONE	    5

/* hinting style */
#define FC_HINT_NONE        0
#define FC_HINT_SLIGHT      1
#define FC_HINT_MEDIUM      2
#define FC_HINT_FULL        3
 
typedef enum _FcType {
    FcTypeVoid, 
    FcTypeInteger, 
    FcTypeDouble, 
    FcTypeString, 
    FcTypeBool,
    FcTypeMatrix,
    FcTypeCharSet,
    FcTypeFTFace,
    FcTypeLangSet
} FcType;

typedef struct _FcMatrix {
    double xx, xy, yx, yy;
} FcMatrix;

#define FcMatrixInit(m)	((m)->xx = (m)->yy = 1, \
			 (m)->xy = (m)->yx = 0)

/*
 * A data structure to represent the available glyphs in a font.
 * This is represented as a sparse boolean btree.
 */

typedef struct _FcCharSet FcCharSet;

typedef struct _FcObjectType {
    const char	*object;
    FcType	type;
} FcObjectType;

typedef struct _FcConstant {
    const FcChar8  *name;
    const char	*object;
    int		value;
} FcConstant;

typedef enum _FcResult {
    FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId,
    FcResultOutOfMemory
} FcResult;

typedef struct _FcPattern   FcPattern;

typedef struct _FcLangSet   FcLangSet;

#define FC_BANK_DYNAMIC 0
#define FC_BANK_FIRST 1

typedef struct _FcValue {
    FcType	type;
    union {
	const FcChar8  *s;
	int             s_off;
	int		i;
	FcBool		b;
	double		d;
	const FcMatrix  *m;
	const FcCharSet *c;
	int		c_off;
	void		*f;
	const FcPattern	*p;
	const FcLangSet *l;
	int		l_off; // this is a difference of char *s
    } u;
} FcValue;

typedef struct _FcFontSet {
    int		nfont;
    int		sfont;
    FcPattern	**fonts;
} FcFontSet;

typedef struct _FcObjectSet {
    int		nobject;
    int		sobject;
    const char	**objects;
} FcObjectSet;
    
typedef enum _FcMatchKind {
    FcMatchPattern, FcMatchFont
} FcMatchKind;

typedef enum _FcLangResult {
    FcLangEqual, FcLangDifferentCountry, FcLangDifferentLang
} FcLangResult;

typedef enum _FcSetName {
    FcSetSystem = 0,
    FcSetApplication = 1
} FcSetName;

typedef struct _FcAtomic FcAtomic;

#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
#define _FCFUNCPROTOBEGIN extern "C" {	/* do not leave open across includes */
#define _FCFUNCPROTOEND }
#else
#define _FCFUNCPROTOBEGIN
#define _FCFUNCPROTOEND
#endif

typedef enum { FcEndianBig, FcEndianLittle } FcEndian;

typedef struct _FcConfig    FcConfig;

typedef struct _FcGlobalCache	FcFileCache;

typedef struct _FcBlanks    FcBlanks;

typedef struct _FcStrList   FcStrList;

typedef struct _FcStrSet    FcStrSet;

_FCFUNCPROTOBEGIN

FcBool
FcDirCacheValid (const FcChar8 *cache_file);

/* fcblanks.c */
FcBlanks *
FcBlanksCreate (void);

void
FcBlanksDestroy (FcBlanks *b);

FcBool
FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);

FcBool
FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);

/* fccfg.c */
FcChar8 *
FcConfigHome (void);

FcBool
FcConfigEnableHome (FcBool enable);

FcChar8 *
FcConfigFilename (const FcChar8 *url);
    
FcConfig *
FcConfigCreate (void);

void
FcConfigDestroy (FcConfig *config);

FcBool
FcConfigSetCurrent (FcConfig *config);

FcConfig *
FcConfigGetCurrent (void);

FcBool
FcConfigUptoDate (FcConfig *config);
    
FcBool
FcConfigBuildFonts (FcConfig *config);

FcStrList *
FcConfigGetFontDirs (FcConfig   *config);

FcStrList *
FcConfigGetConfigDirs (FcConfig   *config);

FcStrList *
FcConfigGetConfigFiles (FcConfig    *config);

FcChar8 *
FcConfigGetCache (FcConfig  *config);

FcBlanks *
FcConfigGetBlanks (FcConfig *config);

int
FcConfigGetRescanInverval (FcConfig *config);

FcBool
FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);

FcFontSet *
FcConfigGetFonts (FcConfig	*config,
		  FcSetName	set);

FcBool
FcConfigAppFontAddFile (FcConfig    *config,
			const FcChar8  *file);

FcBool
FcConfigAppFontAddDir (FcConfig	    *config,
		       const FcChar8   *dir);

void
FcConfigAppFontClear (FcConfig	    *config);

FcBool
FcConfigSubstituteWithPat (FcConfig	*config,
			   FcPattern	*p,
			   FcPattern	*p_pat,
			   FcMatchKind	kind);

FcBool
FcConfigSubstitute (FcConfig	*config,
		    FcPattern	*p,
		    FcMatchKind	kind);

/* fccharset.c */
FcCharSet *
FcCharSetCreate (void);

void
FcCharSetDestroy (FcCharSet *fcs);

FcBool
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);

FcCharSet *
FcCharSetCopy (FcCharSet *src);

FcBool
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);

FcCharSet *
FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);

FcBool
FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);

FcChar32
FcCharSetCount (const FcCharSet *a);

FcChar32
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);

FcChar32
FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);

FcBool
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);

#define FC_CHARSET_MAP_SIZE (256/32)
#define FC_CHARSET_DONE	((FcChar32) -1)

FcChar32
FcCharSetFirstPage (const FcCharSet *a, 
		    FcChar32	    map[FC_CHARSET_MAP_SIZE],
		    FcChar32	    *next);

FcChar32
FcCharSetNextPage (const FcCharSet  *a, 
		   FcChar32	    map[FC_CHARSET_MAP_SIZE],
		   FcChar32	    *next);


/* fcdbg.c */
void
FcValuePrint (const FcValue v);

void
FcPatternPrint (const FcPattern *p);

void
FcFontSetPrint (const FcFontSet *s);

/* fcdefault.c */
void
FcDefaultSubstitute (FcPattern *pattern);

/* fcdir.c */
FcBool
FcFileScan (FcFontSet	    *set,
	    FcStrSet	    *dirs,
	    FcFileCache	    *cache,
	    FcBlanks	    *blanks,
	    const FcChar8   *file,
	    FcBool	    force);

FcBool
FcDirScan (FcFontSet	    *set,
	   FcStrSet	    *dirs,
	   FcFileCache	    *cache,
	   FcBlanks	    *blanks,
	   const FcChar8    *dir,
	   FcBool	    force);

FcBool
FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);

/* fcfreetype.c */
FcPattern *
FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);

/* fcfs.c */

FcFontSet *
FcFontSetCreate (void);

void
FcFontSetDestroy (FcFontSet *s);

FcBool
FcFontSetAdd (FcFontSet *s, FcPattern *font);

/* fcinit.c */
FcConfig *
FcInitLoadConfig (void);

FcConfig *
FcInitLoadConfigAndFonts (void);

FcBool
FcInit (void);

void
FcFini (void);

int
FcGetVersion (void);

FcBool
FcInitReinitialize (void);

FcBool
FcInitBringUptoDate (void);

/* fclang.c */
FcLangSet *
FcLangSetCreate (void);

void
FcLangSetDestroy (FcLangSet *ls);

FcLangSet *
FcLangSetCopy (const FcLangSet *ls);

FcBool
FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);

FcLangResult
FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);

FcLangResult
FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);

FcBool
FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);

FcBool
FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);

FcChar32
FcLangSetHash (const FcLangSet *ls);

/* fclist.c */
FcObjectSet *
FcObjectSetCreate (void);

FcBool
FcObjectSetAdd (FcObjectSet *os, const char *object);

void
FcObjectSetDestroy (FcObjectSet *os);

FcObjectSet *
FcObjectSetVaBuild (const char *first, va_list va);

FcObjectSet *
FcObjectSetBuild (const char *first, ...);

FcFontSet *
FcFontSetList (FcConfig	    *config,
	       FcFontSet    **sets,
	       int	    nsets,
	       FcPattern    *p,
	       FcObjectSet  *os);

FcFontSet *
FcFontList (FcConfig	*config,
	    FcPattern	*p,
	    FcObjectSet *os);

/* fcatomic.c */

FcAtomic *
FcAtomicCreate (const FcChar8   *file);

FcBool
FcAtomicLock (FcAtomic *atomic);

FcChar8 *
FcAtomicNewFile (FcAtomic *atomic);

FcChar8 *
FcAtomicOrigFile (FcAtomic *atomic);

FcBool
FcAtomicReplaceOrig (FcAtomic *atomic);

void
FcAtomicDeleteNew (FcAtomic *atomic);

void
FcAtomicUnlock (FcAtomic *atomic);

void
FcAtomicDestroy (FcAtomic *atomic);

/* fcmatch.c */
FcPattern *
FcFontSetMatch (FcConfig    *config,
		FcFontSet   **sets,
		int	    nsets,
		FcPattern   *p,
		FcResult    *result);

FcPattern *
FcFontMatch (FcConfig	*config,
	     FcPattern	*p, 
	     FcResult	*result);

FcPattern *
FcFontRenderPrepare (FcConfig	    *config,
		     FcPattern	    *pat,
		     FcPattern	    *font);

FcFontSet *
FcFontSetSort (FcConfig	    *config,
	       FcFontSet    **sets,
	       int	    nsets,
	       FcPattern    *p,
	       FcBool	    trim,
	       FcCharSet    **csp,
	       FcResult	    *result);

FcFontSet *
FcFontSort (FcConfig	 *config,
	    FcPattern    *p,
	    FcBool	 trim,
	    FcCharSet    **csp,
	    FcResult	 *result);

void
FcFontSetSortDestroy (FcFontSet *fs);

/* fcmatrix.c */
FcMatrix *
FcMatrixCopy (const FcMatrix *mat);

FcBool
FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);

void
FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);

void
FcMatrixRotate (FcMatrix *m, double c, double s);

void
FcMatrixScale (FcMatrix *m, double sx, double sy);

void
FcMatrixShear (FcMatrix *m, double sh, double sv);

/* fcname.c */

FcBool
FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);

FcBool
FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
    
const FcObjectType *
FcNameGetObjectType (const char *object);

FcBool
FcNameRegisterConstants (const FcConstant *consts, int nconsts);

FcBool
FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
    
const FcConstant *
FcNameGetConstant (FcChar8 *string);

FcBool
FcNameConstant (FcChar8 *string, int *result);

FcPattern *
FcNameParse (const FcChar8 *name);

FcChar8 *
FcNameUnparse (FcPattern *pat);

/* fcpat.c */
FcPattern *
FcPatternCreate (void);

FcPattern *
FcPatternDuplicate (const FcPattern *p);

void
FcPatternReference (FcPattern *p);

void
FcValueDestroy (FcValue v);

FcBool
FcValueEqual (FcValue va, FcValue vb);

FcValue
FcValueSave (FcValue v);

void
FcPatternDestroy (FcPattern *p);

FcBool
FcPatternEqual (const FcPattern *pa, const FcPattern *pb);

FcBool
FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);

FcChar32
FcPatternHash (const FcPattern *p);

FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
    
FcBool
FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
    
FcResult
FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
    
FcBool
FcPatternDel (FcPattern *p, const char *object);

FcBool
FcPatternRemove (FcPattern *p, const char *object, int id);

FcBool
FcPatternAddInteger (FcPattern *p, const char *object, int i);

FcBool
FcPatternAddDouble (FcPattern *p, const char *object, double d);

FcBool
FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);

FcBool
FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);

FcBool
FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);

FcBool
FcPatternAddBool (FcPattern *p, const char *object, FcBool b);

FcBool
FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);

FcResult
FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);

FcResult
FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);

FcResult
FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);

FcResult
FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);

FcResult
FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);

FcResult
FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);

FcResult
FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);

FcPattern *
FcPatternVaBuild (FcPattern *orig, va_list va);
    
FcPattern *
FcPatternBuild (FcPattern *orig, ...);

/* fcstr.c */

FcChar8 *
FcStrCopy (const FcChar8 *s);

FcChar8 *
FcStrCopyFilename (const FcChar8 *s);
    
/* These are ASCII only, suitable only for pattern element names */
#define FcIsUpper(c)	((0101 <= (c) && (c) <= 0132))
#define FcIsLower(c)	((0141 <= (c) && (c) <= 0172))
#define FcToLower(c)	(FcIsUpper(c) ? (c) - 0101 + 0141 : (c))

FcChar8 *
FcStrDowncase (const FcChar8 *s);

int
FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);

int
FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);

const FcChar8 *
FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);

const FcChar8 *
FcStrStr (const FcChar8 *s1, const FcChar8 *s2);

int
FcUtf8ToUcs4 (const FcChar8 *src_orig,
	      FcChar32	    *dst,
	      int	    len);

FcBool
FcUtf8Len (const FcChar8    *string,
	   int		    len,
	   int		    *nchar,
	   int		    *wchar);

#define FC_UTF8_MAX_LEN	6

int
FcUcs4ToUtf8 (FcChar32	ucs4,
	      FcChar8	dest[FC_UTF8_MAX_LEN]);

int
FcUtf16ToUcs4 (const FcChar8	*src_orig,
	       FcEndian		endian,
	       FcChar32		*dst,
	       int		len);	    /* in bytes */

FcBool
FcUtf16Len (const FcChar8   *string,
	    FcEndian	    endian,
	    int		    len,	    /* in bytes */
	    int		    *nchar,
	    int		    *wchar);

FcChar8 *
FcStrDirname (const FcChar8 *file);

FcChar8 *
FcStrBasename (const FcChar8 *file);

FcStrSet *
FcStrSetCreate (void);

FcBool
FcStrSetMember (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);

FcBool
FcStrSetAdd (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);

FcBool
FcStrSetDel (FcStrSet *set, const FcChar8 *s);

void
FcStrSetDestroy (FcStrSet *set);

FcStrList *
FcStrListCreate (FcStrSet *set);

FcChar8 *
FcStrListNext (FcStrList *list);

void
FcStrListDone (FcStrList *list);

/* fcxml.c */
FcBool
FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);

_FCFUNCPROTOEND

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