doc/fontconfig-devel.txt

   1                 Fontconfig Developers Reference, Version 2.13.1
   2
   3    Copyright © 2002 Keith Packard
   4
   5    Permission to use, copy, modify, distribute, and sell this software and
   6    its documentation for any purpose is hereby granted without fee, provided
   7    that the above copyright notice appear in all copies and that both that
   8    copyright notice and this permission notice appear in supporting
   9    documentation, and that the name of the author(s) not be used in
  10    advertising or publicity pertaining to distribution of the software
  11    without specific, written prior permission. The authors make no
  12    representations about the suitability of this software for any purpose. It
  13    is provided "as is" without express or implied warranty.
  14
  15    THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16    INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17    EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18    CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  19    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  20    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21    PERFORMANCE OF THIS SOFTWARE.
  22
  23             -------------------------------------------------------
  24
  25    Table of Contents
  26
  27    [1]DESCRIPTION
  28
  29    [2]FUNCTIONAL OVERVIEW
  30
  31    [3]Datatypes
  32
  33    [4]FUNCTIONS
  34
  35 DESCRIPTION
  36
  37    Fontconfig is a library designed to provide system-wide font
  38    configuration, customization and application access.
  39
  40    --------------------------------------------------------------------------
  41
  42 FUNCTIONAL OVERVIEW
  43
  44    Fontconfig contains two essential modules, the configuration module which
  45    builds an internal configuration from XML files and the matching module
  46    which accepts font patterns and returns the nearest matching font.
  47
  48    --------------------------------------------------------------------------
  49
  50   FONT CONFIGURATION
  51
  52    The configuration module consists of the FcConfig datatype, libexpat and
  53    FcConfigParse which walks over an XML tree and amends a configuration with
  54    data found within. From an external perspective, configuration of the
  55    library consists of generating a valid XML tree and feeding that to
  56    FcConfigParse. The only other mechanism provided to applications for
  57    changing the running configuration is to add fonts and directories to the
  58    list of application-provided font files.
  59
  60    The intent is to make font configurations relatively static, and shared by
  61    as many applications as possible. It is hoped that this will lead to more
  62    stable font selection when passing names from one application to another.
  63    XML was chosen as a configuration file format because it provides a format
  64    which is easy for external agents to edit while retaining the correct
  65    structure and syntax.
  66
  67    Font configuration is separate from font matching; applications needing to
  68    do their own matching can access the available fonts from the library and
  69    perform private matching. The intent is to permit applications to pick and
  70    choose appropriate functionality from the library instead of forcing them
  71    to choose between this library and a private configuration mechanism. The
  72    hope is that this will ensure that configuration of fonts for all
  73    applications can be centralized in one place. Centralizing font
  74    configuration will simplify and regularize font installation and
  75    customization.
  76
  77    --------------------------------------------------------------------------
  78
  79   FONT PROPERTIES
  80
  81    While font patterns may contain essentially any properties, there are some
  82    well known properties with associated types. Fontconfig uses some of these
  83    properties for font matching and font completion. Others are provided as a
  84    convenience for the application's rendering mechanism.
  85
  86                  Property Definitions
  87
  88     Property       C Preprocessor Symbol  Type    Description
  89     ----------------------------------------------------
  90     family         FC_FAMILY              String  Font family names
  91     familylang     FC_FAMILYLANG          String  Language corresponding to
  92                                                   each family name
  93     style          FC_STYLE               String  Font style. Overrides weight
  94                                                   and slant
  95     stylelang      FC_STYLELANG           String  Language corresponding to
  96                                                   each style name
  97     fullname       FC_FULLNAME            String  Font face full name where
  98                                                   different from family and
  99                                                   family + style
 100     fullnamelang   FC_FULLNAMELANG        String  Language corresponding to
 101                                                   each fullname
 102     slant          FC_SLANT               Int     Italic, oblique or roman
 103     weight         FC_WEIGHT              Int     Light, medium, demibold,
 104                                                   bold or black
 105     size           FC_SIZE                Double  Point size
 106     width          FC_WIDTH               Int     Condensed, normal or expanded
 107     aspect         FC_ASPECT              Double  Stretches glyphs horizontally
 108                                                   before hinting
 109     pixelsize      FC_PIXEL_SIZE          Double  Pixel size
 110     spacing        FC_SPACING             Int     Proportional, dual-width,
 111                                                   monospace or charcell
 112     foundry        FC_FOUNDRY             String  Font foundry name
 113     antialias      FC_ANTIALIAS           Bool    Whether glyphs can be
 114                                                   antialiased
 115     hinting        FC_HINTING             Bool    Whether the rasterizer should
 116                                                   use hinting
 117     hintstyle      FC_HINT_STYLE          Int     Automatic hinting style
 118     verticallayout FC_VERTICAL_LAYOUT     Bool    Use vertical layout
 119     autohint       FC_AUTOHINT            Bool    Use autohinter instead of
 120                                                   normal hinter
 121     globaladvance  FC_GLOBAL_ADVANCE      Bool    Use font global advance data (deprecated)
 122     file           FC_FILE                String  The filename holding the font
 123     index          FC_INDEX               Int     The index of the font within
 124                                                   the file
 125     ftface         FC_FT_FACE             FT_Face Use the specified FreeType
 126                                                   face object
 127     rasterizer     FC_RASTERIZER          String  Which rasterizer is in use (deprecated)
 128     outline        FC_OUTLINE             Bool    Whether the glyphs are outlines
 129     scalable       FC_SCALABLE            Bool    Whether glyphs can be scaled
 130     scale          FC_SCALE               Double  Scale factor for point->pixel
 131                                                   conversions (deprecated)
 132     symbol         FC_SYMBOL              Bool    Whether font uses MS symbol-font encoding
 133     color          FC_COLOR               Bool    Whether any glyphs have color
 134     dpi            FC_DPI                 Double  Target dots per inch
 135     rgba           FC_RGBA                Int     unknown, rgb, bgr, vrgb,
 136                                                   vbgr, none - subpixel geometry
 137     lcdfilter      FC_LCD_FILTER          Int     Type of LCD filter
 138     minspace       FC_MINSPACE            Bool    Eliminate leading from line
 139                                                   spacing
 140     charset        FC_CHARSET             CharSet Unicode chars encoded by
 141                                                   the font
 142     lang           FC_LANG                LangSet Set of RFC-3066-style
 143                                                   languages this font supports
 144     fontversion    FC_FONTVERSION         Int     Version number of the font
 145     capability     FC_CAPABILITY          String  List of layout capabilities in
 146                                                   the font
 147     fontformat     FC_FONTFORMAT          String  String name of the font format
 148     embolden       FC_EMBOLDEN            Bool    Rasterizer should
 149                                                   synthetically embolden the font
 150     embeddedbitmap FC_EMBEDDED_BITMAP     Bool    Use the embedded bitmap instead
 151                                                   of the outline
 152     decorative     FC_DECORATIVE          Bool    Whether the style is a decorative
 153                                                   variant
 154     fontfeatures   FC_FONT_FEATURES       String  List of extra feature tags in
 155                                                   OpenType to be enabled
 156     namelang       FC_NAMELANG            String  Language name to be used for the
 157                                                   default value of familylang,
 158                                                   stylelang and fullnamelang
 159     prgname        FC_PRGNAME             String  Name of the running program
 160     hash           FC_HASH                String  SHA256 hash value of the font data
 161                                                   with "sha256:" prefix (deprecated)
 162     postscriptname FC_POSTSCRIPT_NAME     String  Font name in PostScript
 163
 164
 165    --------------------------------------------------------------------------
 166
 167 Datatypes
 168
 169    Fontconfig uses abstract data types to hide internal implementation
 170    details for most data structures. A few structures are exposed where
 171    appropriate.
 172
 173    --------------------------------------------------------------------------
 174
 175   FcChar8, FcChar16, FcChar32, FcBool
 176
 177    These are primitive data types; the FcChar* types hold precisely the
 178    number of bits stated (if supported by the C implementation). FcBool holds
 179    one of two C preprocessor symbols: FcFalse or FcTrue.
 180
 181    --------------------------------------------------------------------------
 182
 183   FcMatrix
 184
 185    An FcMatrix holds an affine transformation, usually used to reshape
 186    glyphs. A small set of matrix operations are provided to manipulate these.
 187
 188            typedef struct _FcMatrix {
 189                    double xx, xy, yx, yy;
 190            } FcMatrix;
 191
 192
 193    --------------------------------------------------------------------------
 194
 195   FcCharSet
 196
 197    An FcCharSet is an abstract type that holds the set of encoded Unicode
 198    chars in a font. Operations to build and compare these sets are provided.
 199
 200    --------------------------------------------------------------------------
 201
 202   FcLangSet
 203
 204    An FcLangSet is an abstract type that holds the set of languages supported
 205    by a font. Operations to build and compare these sets are provided. These
 206    are computed for a font based on orthographic information built into the
 207    fontconfig library. Fontconfig has orthographies for all of the ISO 639-1
 208    languages except for MS, NA, PA, PS, QU, RN, RW, SD, SG, SN, SU and ZA. If
 209    you have orthographic information for any of these languages, please
 210    submit them.
 211
 212    --------------------------------------------------------------------------
 213
 214   FcLangResult
 215
 216    An FcLangResult is an enumeration used to return the results of comparing
 217    two language strings or FcLangSet objects. FcLangEqual means the objects
 218    match language and territory. FcLangDifferentTerritory means the objects
 219    match in language but differ in territory. FcLangDifferentLang means the
 220    objects differ in language.
 221
 222    --------------------------------------------------------------------------
 223
 224   FcType
 225
 226    Tags the kind of data stored in an FcValue.
 227
 228    --------------------------------------------------------------------------
 229
 230   FcValue
 231
 232    An FcValue object holds a single value with one of a number of different
 233    types. The 'type' tag indicates which member is valid.
 234
 235            typedef struct _FcValue {
 236                    FcType type;
 237                    union {
 238                            const FcChar8 *s;
 239                            int i;
 240                            FcBool b;
 241                            double d;
 242                            const FcMatrix *m;
 243                            const FcCharSet *c;
 244                            void *f;
 245                            const FcLangSet *l;
 246                    } u;
 247            } FcValue;
 248
 249
 250                      FcValue Members
 251
 252            Type            Union member    Datatype
 253            --------------------------------
 254            FcTypeVoid      (none)          (none)
 255            FcTypeInteger   i               int
 256            FcTypeDouble    d               double
 257            FcTypeString    s               FcChar8 *
 258            FcTypeBool      b               b
 259            FcTypeMatrix    m               FcMatrix *
 260            FcTypeCharSet   c               FcCharSet *
 261            FcTypeFTFace    f               void * (FT_Face)
 262            FcTypeLangSet   l               FcLangSet *
 263
 264
 265    --------------------------------------------------------------------------
 266
 267   FcPattern
 268
 269    holds a set of names with associated value lists; each name refers to a
 270    property of a font. FcPatterns are used as inputs to the matching code as
 271    well as holding information about specific fonts. Each property can hold
 272    one or more values; conventionally all of the same type, although the
 273    interface doesn't demand that.
 274
 275    --------------------------------------------------------------------------
 276
 277   FcFontSet
 278
 279            typedef struct _FcFontSet {
 280                    int nfont;
 281                    int sfont;
 282                    FcPattern **fonts;
 283            } FcFontSet;
 284
 285
 286    An FcFontSet contains a list of FcPatterns. Internally fontconfig uses
 287    this data structure to hold sets of fonts. Externally, fontconfig returns
 288    the results of listing fonts in this format. 'nfont' holds the number of
 289    patterns in the 'fonts' array; 'sfont' is used to indicate the size of
 290    that array.
 291
 292    --------------------------------------------------------------------------
 293
 294   FcStrSet, FcStrList
 295
 296    FcStrSet holds a list of strings that can be appended to and enumerated.
 297    Its unique characteristic is that the enumeration works even while strings
 298    are appended during enumeration. FcStrList is used during enumeration to
 299    safely and correctly walk the list of strings even while that list is
 300    edited in the middle of enumeration.
 301
 302    --------------------------------------------------------------------------
 303
 304   FcObjectSet
 305
 306            typedef struct _FcObjectSet {
 307                    int nobject;
 308                    int sobject;
 309                    const char **objects;
 310            } FcObjectSet;
 311
 312
 313    holds a set of names and is used to specify which fields from fonts are
 314    placed in the the list of returned patterns when listing fonts.
 315
 316    --------------------------------------------------------------------------
 317
 318   FcObjectType
 319
 320            typedef struct _FcObjectType {
 321                    const char *object;
 322                    FcType type;
 323            } FcObjectType;
 324
 325
 326    marks the type of a pattern element generated when parsing font names.
 327    Applications can add new object types so that font names may contain the
 328    new elements.
 329
 330    --------------------------------------------------------------------------
 331
 332   FcConstant
 333
 334            typedef struct _FcConstant {
 335                const FcChar8 *name;
 336                const char *object;
 337                int value;
 338            } FcConstant;
 339
 340
 341    Provides for symbolic constants for new pattern elements. When 'name' is
 342    seen in a font name, an 'object' element is created with value 'value'.
 343
 344    --------------------------------------------------------------------------
 345
 346   FcBlanks
 347
 348    holds a list of Unicode chars which are expected to be blank; unexpectedly
 349    blank chars are assumed to be invalid and are elided from the charset
 350    associated with the font.
 351
 352    FcBlanks is deprecated and should not be used in newly written code. It is
 353    still accepted by some functions for compatibility with older code but
 354    will be removed in the future.
 355
 356    --------------------------------------------------------------------------
 357
 358   FcFileCache
 359
 360    holds the per-user cache information for use while loading the font
 361    database. This is built automatically for the current configuration when
 362    that is loaded. Applications must always pass '0' when one is requested.
 363
 364    --------------------------------------------------------------------------
 365
 366   FcConfig
 367
 368    holds a complete configuration of the library; there is one default
 369    configuration, other can be constructed from XML data structures. All
 370    public entry points that need global data can take an optional FcConfig*
 371    argument; passing 0 uses the default configuration. FcConfig objects hold
 372    two sets of fonts, the first contains those specified by the
 373    configuration, the second set holds those added by the application at
 374    run-time. Interfaces that need to reference a particular set use one of
 375    the FcSetName enumerated values.
 376
 377    --------------------------------------------------------------------------
 378
 379   FcSetName
 380
 381    Specifies one of the two sets of fonts available in a configuration;
 382    FcSetSystem for those fonts specified in the configuration and
 383    FcSetApplication which holds fonts provided by the application.
 384
 385    --------------------------------------------------------------------------
 386
 387   FcResult
 388
 389    Used as a return type for functions manipulating FcPattern objects.
 390
 391          FcResult Values
 392            Result Code             Meaning
 393            -----------------------------------------------------------
 394            FcResultMatch           Object exists with the specified ID
 395            FcResultNoMatch         Object doesn't exist at all
 396            FcResultTypeMismatch    Object exists, but the type doesn't match
 397            FcResultNoId            Object exists, but has fewer values
 398                                    than specified
 399            FcResultOutOfMemory     malloc failed
 400
 401
 402    --------------------------------------------------------------------------
 403
 404   FcAtomic
 405
 406    Used for locking access to configuration files. Provides a safe way to
 407    update configuration files.
 408
 409    --------------------------------------------------------------------------
 410
 411   FcCache
 412
 413    Holds information about the fonts contained in a single directory. Normal
 414    applications need not worry about this as caches for font access are
 415    automatically managed by the library. Applications dealing with cache
 416    management may want to use some of these objects in their work, however
 417    the included 'fc-cache' program generally suffices for all of that.
 418
 419    --------------------------------------------------------------------------
 420
 421 FUNCTIONS
 422
 423    These are grouped by functionality, often using the main data type being
 424    manipulated.
 425
 426    --------------------------------------------------------------------------
 427
 428   Initialization
 429
 430    Table of Contents
 431
 432    [5]FcInitLoadConfig -- load configuration
 433
 434    [6]FcInitLoadConfigAndFonts -- load configuration and font data
 435
 436    [7]FcInit -- initialize fontconfig library
 437
 438    [8]FcFini -- finalize fontconfig library
 439
 440    [9]FcGetVersion -- library version number
 441
 442    [10]FcInitReinitialize -- re-initialize library
 443
 444    [11]FcInitBringUptoDate -- reload configuration files if needed
 445
 446    These functions provide some control over how the library is initialized.
 447
 448                                 FcInitLoadConfig
 449
 450 Name
 451
 452    FcInitLoadConfig -- load configuration
 453
 454 Synopsis
 455
 456    #include <fontconfig/fontconfig.h>
 457
 458
 459    FcConfig * FcInitLoadConfig(void);
 460
 461 Description
 462
 463    Loads the default configuration file and returns the resulting
 464    configuration. Does not load any font information.
 465
 466                             FcInitLoadConfigAndFonts
 467
 468 Name
 469
 470    FcInitLoadConfigAndFonts -- load configuration and font data
 471
 472 Synopsis
 473
 474    #include <fontconfig/fontconfig.h>
 475
 476
 477    FcConfig * FcInitLoadConfigAndFonts(void);
 478
 479 Description
 480
 481    Loads the default configuration file and builds information about the
 482    available fonts. Returns the resulting configuration.
 483
 484                                      FcInit
 485
 486 Name
 487
 488    FcInit -- initialize fontconfig library
 489
 490 Synopsis
 491
 492    #include <fontconfig/fontconfig.h>
 493
 494
 495    FcBool FcInit(void);
 496
 497 Description
 498
 499    Loads the default configuration file and the fonts referenced therein and
 500    sets the default configuration to that result. Returns whether this
 501    process succeeded or not. If the default configuration has already been
 502    loaded, this routine does nothing and returns FcTrue.
 503
 504                                      FcFini
 505
 506 Name
 507
 508    FcFini -- finalize fontconfig library
 509
 510 Synopsis
 511
 512    #include <fontconfig/fontconfig.h>
 513
 514
 515    void FcFini(void);
 516
 517 Description
 518
 519    Frees all data structures allocated by previous calls to fontconfig
 520    functions. Fontconfig returns to an uninitialized state, requiring a new
 521    call to one of the FcInit functions before any other fontconfig function
 522    may be called.
 523
 524                                   FcGetVersion
 525
 526 Name
 527
 528    FcGetVersion -- library version number
 529
 530 Synopsis
 531
 532    #include <fontconfig/fontconfig.h>
 533
 534
 535    int FcGetVersion(void);
 536
 537 Description
 538
 539    Returns the version number of the library.
 540
 541                                FcInitReinitialize
 542
 543 Name
 544
 545    FcInitReinitialize -- re-initialize library
 546
 547 Synopsis
 548
 549    #include <fontconfig/fontconfig.h>
 550
 551
 552    FcBool FcInitReinitialize(void);
 553
 554 Description
 555
 556    Forces the default configuration file to be reloaded and resets the
 557    default configuration. Returns FcFalse if the configuration cannot be
 558    reloaded (due to configuration file errors, allocation failures or other
 559    issues) and leaves the existing configuration unchanged. Otherwise returns
 560    FcTrue.
 561
 562                               FcInitBringUptoDate
 563
 564 Name
 565
 566    FcInitBringUptoDate -- reload configuration files if needed
 567
 568 Synopsis
 569
 570    #include <fontconfig/fontconfig.h>
 571
 572
 573    FcBool FcInitBringUptoDate(void);
 574
 575 Description
 576
 577    Checks the rescan interval in the default configuration, checking the
 578    configuration if the interval has passed and reloading the configuration
 579    if when any changes are detected. Returns FcFalse if the configuration
 580    cannot be reloaded (see FcInitReinitialize). Otherwise returns FcTrue.
 581
 582    --------------------------------------------------------------------------
 583
 584   FcPattern
 585
 586    Table of Contents
 587
 588    [12]FcPatternCreate -- Create a pattern
 589
 590    [13]FcPatternDuplicate -- Copy a pattern
 591
 592    [14]FcPatternReference -- Increment pattern reference count
 593
 594    [15]FcPatternDestroy -- Destroy a pattern
 595
 596    [16]FcPatternObjectCount -- Returns the number of the object
 597
 598    [17]FcPatternEqual -- Compare patterns
 599
 600    [18]FcPatternEqualSubset -- Compare portions of patterns
 601
 602    [19]FcPatternFilter -- Filter the objects of pattern
 603
 604    [20]FcPatternHash -- Compute a pattern hash value
 605
 606    [21]FcPatternAdd -- Add a value to a pattern
 607
 608    [22]FcPatternAddWeak -- Add a value to a pattern with weak binding
 609
 610    [23]FcPatternAdd-Type -- Add a typed value to a pattern
 611
 612    [24]FcPatternGetWithBinding -- Return a value with binding from a pattern
 613
 614    [25]FcPatternGet -- Return a value from a pattern
 615
 616    [26]FcPatternGet-Type -- Return a typed value from a pattern
 617
 618    [27]FcPatternBuild -- Create patterns from arguments
 619
 620    [28]FcPatternDel -- Delete a property from a pattern
 621
 622    [29]FcPatternRemove -- Remove one object of the specified type from the
 623    pattern
 624
 625    [30]FcPatternIterStart -- Initialize the iterator with the first iterator
 626    in the pattern
 627
 628    [31]FcPatternIterNext --
 629
 630    [32]FcPatternIterEqual -- Compare iterators
 631
 632    [33]FcPatternFindIter -- Set the iterator to point to the object in the
 633    pattern
 634
 635    [34]FcPatternIterIsValid -- Check whether the iterator is valid or not
 636
 637    [35]FcPatternIterGetObject -- Returns an object name which the iterator
 638    point to
 639
 640    [36]FcPatternIterValueCount -- Returns the number of the values which the
 641    iterator point to
 642
 643    [37]FcPatternIterGetValue -- Returns a value which the iterator point to
 644
 645    [38]FcPatternPrint -- Print a pattern for debugging
 646
 647    [39]FcDefaultSubstitute -- Perform default substitutions in a pattern
 648
 649    [40]FcNameParse -- Parse a pattern string
 650
 651    [41]FcNameUnparse -- Convert a pattern back into a string that can be
 652    parsed
 653
 654    [42]FcPatternFormat -- Format a pattern into a string according to a
 655    format specifier
 656
 657    An FcPattern is an opaque type that holds both patterns to match against
 658    the available fonts, as well as the information about each font.
 659
 660                                 FcPatternCreate
 661
 662 Name
 663
 664    FcPatternCreate -- Create a pattern
 665
 666 Synopsis
 667
 668    #include <fontconfig/fontconfig.h>
 669
 670
 671    FcPattern * FcPatternCreate(void);
 672
 673 Description
 674
 675    Creates a pattern with no properties; used to build patterns from scratch.
 676
 677                                FcPatternDuplicate
 678
 679 Name
 680
 681    FcPatternDuplicate -- Copy a pattern
 682
 683 Synopsis
 684
 685    #include <fontconfig/fontconfig.h>
 686
 687
 688    FcPattern * FcPatternDuplicate(const FcPattern *p);
 689
 690 Description
 691
 692    Copy a pattern, returning a new pattern that matches p. Each pattern may
 693    be modified without affecting the other.
 694
 695                                FcPatternReference
 696
 697 Name
 698
 699    FcPatternReference -- Increment pattern reference count
 700
 701 Synopsis
 702
 703    #include <fontconfig/fontconfig.h>
 704
 705
 706    void FcPatternReference(FcPattern *p);
 707
 708 Description
 709
 710    Add another reference to p. Patterns are freed only when the reference
 711    count reaches zero.
 712
 713                                 FcPatternDestroy
 714
 715 Name
 716
 717    FcPatternDestroy -- Destroy a pattern
 718
 719 Synopsis
 720
 721    #include <fontconfig/fontconfig.h>
 722
 723
 724    void FcPatternDestroy(FcPattern *p);
 725
 726 Description
 727
 728    Decrement the pattern reference count. If all references are gone,
 729    destroys the pattern, in the process destroying all related values.
 730
 731                               FcPatternObjectCount
 732
 733 Name
 734
 735    FcPatternObjectCount -- Returns the number of the object
 736
 737 Synopsis
 738
 739    #include <fontconfig/fontconfig.h>
 740
 741
 742    int FcPatternObjectCount(const FcPattern *p);
 743
 744 Description
 745
 746    Returns the number of the object p has.
 747
 748 Since
 749
 750    version 2.13.1
 751
 752                                  FcPatternEqual
 753
 754 Name
 755
 756    FcPatternEqual -- Compare patterns
 757
 758 Synopsis
 759
 760    #include <fontconfig/fontconfig.h>
 761
 762
 763    FcBool FcPatternEqual(const FcPattern *pa, const FcPattern *pb);
 764
 765 Description
 766
 767    Returns whether pa and pb are exactly alike.
 768
 769                               FcPatternEqualSubset
 770
 771 Name
 772
 773    FcPatternEqualSubset -- Compare portions of patterns
 774
 775 Synopsis
 776
 777    #include <fontconfig/fontconfig.h>
 778
 779
 780    FcBool FcPatternEqualSubset(const FcPattern *pa, const FcPattern *pb,
 781    const FcObjectSet *os);
 782
 783 Description
 784
 785    Returns whether pa and pb have exactly the same values for all of the
 786    objects in os.
 787
 788                                 FcPatternFilter
 789
 790 Name
 791
 792    FcPatternFilter -- Filter the objects of pattern
 793
 794 Synopsis
 795
 796    #include <fontconfig/fontconfig.h>
 797
 798
 799    FcPattern * FcPatternFilter(FcPattern *p, const FcObjectSet *);
 800
 801 Description
 802
 803    Returns a new pattern that only has those objects from p that are in os.
 804    If os is NULL, a duplicate of p is returned.
 805
 806                                  FcPatternHash
 807
 808 Name
 809
 810    FcPatternHash -- Compute a pattern hash value
 811
 812 Synopsis
 813
 814    #include <fontconfig/fontconfig.h>
 815
 816
 817    FcChar32 FcPatternHash(const FcPattern *p);
 818
 819 Description
 820
 821    Returns a 32-bit number which is the same for any two patterns which are
 822    equal.
 823
 824                                   FcPatternAdd
 825
 826 Name
 827
 828    FcPatternAdd -- Add a value to a pattern
 829
 830 Synopsis
 831
 832    #include <fontconfig/fontconfig.h>
 833
 834
 835    FcBool FcPatternAdd(FcPattern *p, const char *object, FcValue value,
 836    FcBool append);
 837
 838 Description
 839
 840    Adds a single value to the list of values associated with the property
 841    named `object. If `append is FcTrue, the value is added at the end of any
 842    existing list, otherwise it is inserted at the beginning. `value' is saved
 843    (with FcValueSave) when inserted into the pattern so that the library
 844    retains no reference to any application-supplied data structure.
 845
 846                                 FcPatternAddWeak
 847
 848 Name
 849
 850    FcPatternAddWeak -- Add a value to a pattern with weak binding
 851
 852 Synopsis
 853
 854    #include <fontconfig/fontconfig.h>
 855
 856
 857    FcBool FcPatternAddWeak(FcPattern *p, const char *object, FcValue value,
 858    FcBool append);
 859
 860 Description
 861
 862    FcPatternAddWeak is essentially the same as FcPatternAdd except that any
 863    values added to the list have binding weak instead of strong.
 864
 865                                FcPatternAdd-Type
 866
 867 Name
 868
 869    FcPatternAddInteger, FcPatternAddDouble, FcPatternAddString,
 870    FcPatternAddMatrix, FcPatternAddCharSet, FcPatternAddBool,
 871    FcPatternAddFTFace, FcPatternAddLangSet, FcPatternAddRange -- Add a typed
 872    value to a pattern
 873
 874 Synopsis
 875
 876    #include <fontconfig/fontconfig.h>
 877
 878
 879    FcBool FcPatternAddInteger(FcPattern *p, const char *object, int i);
 880
 881    FcBool FcPatternAddDouble(FcPattern *p, const char *object, double d);
 882
 883    FcBool FcPatternAddString(FcPattern *p, const char *object, const FcChar8
 884    *s);
 885
 886    FcBool FcPatternAddMatrix(FcPattern *p, const char *object, const FcMatrix
 887    *m);
 888
 889    FcBool FcPatternAddCharSet(FcPattern *p, const char *object, const
 890    FcCharSet *c);
 891
 892    FcBool FcPatternAddBool(FcPattern *p, const char *object, FcBool b);
 893
 894    FcBool FcPatternAddFTFace(FcPattern *p, const char *object, const
 895    FT_Facef);
 896
 897    FcBool FcPatternAddLangSet(FcPattern *p, const char *object, const
 898    FcLangSet *l);
 899
 900    FcBool FcPatternAddRange(FcPattern *p, const char *object, const FcRange
 901    *r);
 902
 903 Description
 904
 905    These are all convenience functions that insert objects of the specified
 906    type into the pattern. Use these in preference to FcPatternAdd as they
 907    will provide compile-time typechecking. These all append values to any
 908    existing list of values. FcPatternAddRange are available since 2.11.91.
 909
 910                             FcPatternGetWithBinding
 911
 912 Name
 913
 914    FcPatternGetWithBinding -- Return a value with binding from a pattern
 915
 916 Synopsis
 917
 918    #include <fontconfig/fontconfig.h>
 919
 920
 921    FcResult FcPatternGetWithBinding(FcPattern *p, const char *object, int id,
 922    FcValue *v, FcValueBinding *b);
 923
 924 Description
 925
 926    Returns in v the id'th value and b binding for that associated with the
 927    property object. The Value returned is not a copy, but rather refers to
 928    the data stored within the pattern directly. Applications must not free
 929    this value.
 930
 931 Since
 932
 933    version 2.12.5
 934
 935                                   FcPatternGet
 936
 937 Name
 938
 939    FcPatternGet -- Return a value from a pattern
 940
 941 Synopsis
 942
 943    #include <fontconfig/fontconfig.h>
 944
 945
 946    FcResult FcPatternGet(FcPattern *p, const char *object, int id, FcValue
 947    *v);
 948
 949 Description
 950
 951    Returns in v the id'th value associated with the property object. The
 952    value returned is not a copy, but rather refers to the data stored within
 953    the pattern directly. Applications must not free this value.
 954
 955                                FcPatternGet-Type
 956
 957 Name
 958
 959    FcPatternGetInteger, FcPatternGetDouble, FcPatternGetString,
 960    FcPatternGetMatrix, FcPatternGetCharSet, FcPatternGetBool,
 961    FcPatternGetFTFace, FcPatternGetLangSet, FcPatternGetRange -- Return a
 962    typed value from a pattern
 963
 964 Synopsis
 965
 966    #include <fontconfig/fontconfig.h>
 967
 968
 969    FcResult FcPatternGetInteger(FcPattern *p, const char *object, int n, int
 970    *i);
 971
 972    FcResult FcPatternGetDouble(FcPattern *p, const char *object, int n,
 973    double *d);
 974
 975    FcResult FcPatternGetString(FcPattern *p, const char *object, int n,
 976    FcChar8 **s);
 977
 978    FcResult FcPatternGetMatrix(FcPattern *p, const char *object, int n,
 979    FcMatrix **s);
 980
 981    FcResult FcPatternGetCharSet(FcPattern *p, const char *object, int n,
 982    FcCharSet **c);
 983
 984    FcResult FcPatternGetBool(FcPattern *p, const char *object, int n, FcBool
 985    *b);
 986
 987    FcResult FcPatternGetFTFace(FcPattern *p, const char *object, int n,
 988    FT_Face *f);
 989
 990    FcResult FcPatternGetLangSet(FcPattern *p, const char *object, int n,
 991    FcLangSet **l);
 992
 993    FcResult FcPatternGetRange(FcPattern *p, const char *object, int n,
 994    FcRange **r);
 995
 996 Description
 997
 998    These are convenience functions that call FcPatternGet and verify that the
 999    returned data is of the expected type. They return FcResultTypeMismatch if
1000    this is not the case. Note that these (like FcPatternGet) do not make a
1001    copy of any data structure referenced by the return value. Use these in
1002    preference to FcPatternGet to provide compile-time typechecking.
1003    FcPatternGetRange are available since 2.11.91.
1004
1005                                  FcPatternBuild
1006
1007 Name
1008
1009    FcPatternBuild, FcPatternVaBuild, FcPatternVapBuild -- Create patterns
1010    from arguments
1011
1012 Synopsis
1013
1014    #include <fontconfig/fontconfig.h>
1015
1016
1017    FcPattern * FcPatternBuild(FcPattern *pattern, ...);
1018
1019    FcPattern * FcPatternVaBuild(FcPattern *pattern, va_list va);
1020
1021    void FcPatternVapBuild(FcPattern *result, FcPattern *pattern, va_list va);
1022
1023 Description
1024
1025    Builds a pattern using a list of objects, types and values. Each value to
1026    be entered in the pattern is specified with three arguments:
1027
1028     1. Object name, a string describing the property to be added.
1029
1030     2. Object type, one of the FcType enumerated values
1031
1032     3. Value, not an FcValue, but the raw type as passed to any of the
1033        FcPatternAdd<type> functions. Must match the type of the second
1034        argument.
1035
1036    The argument list is terminated by a null object name, no object type nor
1037    value need be passed for this. The values are added to `pattern', if
1038    `pattern' is null, a new pattern is created. In either case, the pattern
1039    is returned. Example
1040
1041    pattern = FcPatternBuild (0, FC_FAMILY, FcTypeString, "Times", (char *) 0);
1042
1043    FcPatternVaBuild is used when the arguments are already in the form of a
1044    varargs value. FcPatternVapBuild is a macro version of FcPatternVaBuild
1045    which returns its result directly in the result variable.
1046
1047                                   FcPatternDel
1048
1049 Name
1050
1051    FcPatternDel -- Delete a property from a pattern
1052
1053 Synopsis
1054
1055    #include <fontconfig/fontconfig.h>
1056
1057
1058    FcBool FcPatternDel(FcPattern *p, const char *object);
1059
1060 Description
1061
1062    Deletes all values associated with the property `object', returning
1063    whether the property existed or not.
1064
1065                                 FcPatternRemove
1066
1067 Name
1068
1069    FcPatternRemove -- Remove one object of the specified type from the
1070    pattern
1071
1072 Synopsis
1073
1074    #include <fontconfig/fontconfig.h>
1075
1076
1077    FcBool FcPatternRemove(FcPattern *p, const char *object, int id);
1078
1079 Description
1080
1081    Removes the value associated with the property `object' at position `id',
1082    returning whether the property existed and had a value at that position or
1083    not.
1084
1085                                FcPatternIterStart
1086
1087 Name
1088
1089    FcPatternIterStart -- Initialize the iterator with the first iterator in
1090    the pattern
1091
1092 Synopsis
1093
1094    #include <fontconfig/fontconfig.h>
1095
1096
1097    void FcPatternIterStart(const FcPattern *p, FcPatternIter *iter);
1098
1099 Description
1100
1101    Initialize iter with the first iterator in p. If there are no objects in
1102    p, iter will not have any valid data.
1103
1104 Since
1105
1106    version 2.13.1
1107
1108                                FcPatternIterNext
1109
1110 Name
1111
1112    FcPatternIterNext --
1113
1114 Synopsis
1115
1116    #include <fontconfig/fontconfig.h>
1117
1118
1119    FcBool FcPatternIterNext(const FcPattern *p, FcPatternIter *iter);
1120
1121 Description
1122
1123    Set iter to point to the next object in p and returns FcTrue if iter has
1124    been changed to the next object. returns FcFalse otherwise.
1125
1126 Since
1127
1128    version 2.13.1
1129
1130                                FcPatternIterEqual
1131
1132 Name
1133
1134    FcPatternIterEqual -- Compare iterators
1135
1136 Synopsis
1137
1138    #include <fontconfig/fontconfig.h>
1139
1140
1141    FcBool FcPatternIterEqual(const FcPattern *p1, FcPatternIter *i1, const
1142    FcPattern *p2, FcPatternIter *i2);
1143
1144 Description
1145
1146    Return FcTrue if both i1 and i2 point to same object and contains same
1147    values. return FcFalse otherwise.
1148
1149 Since
1150
1151    version 2.13.1
1152
1153                                FcPatternFindIter
1154
1155 Name
1156
1157    FcPatternFindIter -- Set the iterator to point to the object in the
1158    pattern
1159
1160 Synopsis
1161
1162    #include <fontconfig/fontconfig.h>
1163
1164
1165    FcBool FcPatternFindIter(const FcPattern *p, FcPatternIter *iter, const
1166    char *object);
1167
1168 Description
1169
1170    Set iter to point to object in p if any and returns FcTrue. returns
1171    FcFalse otherwise.
1172
1173 Since
1174
1175    version 2.13.1
1176
1177                               FcPatternIterIsValid
1178
1179 Name
1180
1181    FcPatternIterIsValid -- Check whether the iterator is valid or not
1182
1183 Synopsis
1184
1185    #include <fontconfig/fontconfig.h>
1186
1187
1188    FcBool FcPatternIterIsValid(const FcPattern *p, FcPatternIter :iter);
1189
1190 Description
1191
1192    Returns FcTrue if iter point to the valid entry in p. returns FcFalse
1193    otherwise.
1194
1195 Since
1196
1197    version 2.13.1
1198
1199                              FcPatternIterGetObject
1200
1201 Name
1202
1203    FcPatternIterGetObject -- Returns an object name which the iterator point
1204    to
1205
1206 Synopsis
1207
1208    #include <fontconfig/fontconfig.h>
1209
1210
1211    const char * FcPatternIterGetObject(const FcPattern *p, FcPatternIter
1212    *iter);
1213
1214 Description
1215
1216    Returns an object name in p which iter point to. returns NULL if iter
1217    isn't valid.
1218
1219 Since
1220
1221    version 2.13.1
1222
1223                             FcPatternIterValueCount
1224
1225 Name
1226
1227    FcPatternIterValueCount -- Returns the number of the values which the
1228    iterator point to
1229
1230 Synopsis
1231
1232    #include <fontconfig/fontconfig.h>
1233
1234
1235    int FcPatternIterValueCount(const FcPattern *p, FcPatternIter *iter);
1236
1237 Description
1238
1239    Returns the number of the values in the object which iter point to. if
1240    iter isn't valid, returns 0.
1241
1242 Since
1243
1244    version 2.13.1
1245
1246                              FcPatternIterGetValue
1247
1248 Name
1249
1250    FcPatternIterGetValue -- Returns a value which the iterator point to
1251
1252 Synopsis
1253
1254    #include <fontconfig/fontconfig.h>
1255
1256
1257    FcResult FcPatternIterGetValue(const FcPattern *p, FcPatternIter *iter,
1258    intid, FcValue *v, FcValueBinding *b);
1259
1260 Description
1261
1262    Returns in v the id'th value which iter point to. also binding to b if
1263    given. The value returned is not a copy, but rather refers to the data
1264    stored within the pattern directly. Applications must not free this value.
1265
1266 Since
1267
1268    version 2.13.1
1269
1270                                  FcPatternPrint
1271
1272 Name
1273
1274    FcPatternPrint -- Print a pattern for debugging
1275
1276 Synopsis
1277
1278    #include <fontconfig/fontconfig.h>
1279
1280
1281    void FcPatternPrint(const FcPattern *p);
1282
1283 Description
1284
1285    Prints an easily readable version of the pattern to stdout. There is no
1286    provision for reparsing data in this format, it's just for diagnostics and
1287    debugging.
1288
1289                               FcDefaultSubstitute
1290
1291 Name
1292
1293    FcDefaultSubstitute -- Perform default substitutions in a pattern
1294
1295 Synopsis
1296
1297    #include <fontconfig/fontconfig.h>
1298
1299
1300    void FcDefaultSubstitute(FcPattern *pattern);
1301
1302 Description
1303
1304    Supplies default values for underspecified font patterns:
1305
1306      * Patterns without a specified style or weight are set to Medium
1307
1308      * Patterns without a specified style or slant are set to Roman
1309
1310      * Patterns without a specified pixel size are given one computed from
1311        any specified point size (default 12), dpi (default 75) and scale
1312        (default 1).
1313
1314                                   FcNameParse
1315
1316 Name
1317
1318    FcNameParse -- Parse a pattern string
1319
1320 Synopsis
1321
1322    #include <fontconfig/fontconfig.h>
1323
1324
1325    FcPattern * FcNameParse(const FcChar8 *name);
1326
1327 Description
1328
1329    Converts name from the standard text format described above into a
1330    pattern.
1331
1332                                  FcNameUnparse
1333
1334 Name
1335
1336    FcNameUnparse -- Convert a pattern back into a string that can be parsed
1337
1338 Synopsis
1339
1340    #include <fontconfig/fontconfig.h>
1341
1342
1343    FcChar8 * FcNameUnparse(FcPattern *pat);
1344
1345 Description
1346
1347    Converts the given pattern into the standard text format described above.
1348    The return value is not static, but instead refers to newly allocated
1349    memory which should be freed by the caller using free().
1350
1351                                 FcPatternFormat
1352
1353 Name
1354
1355    FcPatternFormat -- Format a pattern into a string according to a format
1356    specifier
1357
1358 Synopsis
1359
1360    #include <fontconfig/fontconfig.h>
1361
1362
1363    FcChar8 * FcPatternFormat(FcPattern *pat, const FcChar8 *format);
1364
1365 Description
1366
1367    Converts given pattern pat into text described by the format specifier
1368    format. The return value refers to newly allocated memory which should be
1369    freed by the caller using free(), or NULL if format is invalid.
1370
1371     The format is loosely modeled after printf-style format string. The
1372    format string is composed of zero or more directives: ordinary characters
1373    (not "%"), which are copied unchanged to the output stream; and tags which
1374    are interpreted to construct text from the pattern in a variety of ways
1375    (explained below). Special characters can be escaped using backslash.
1376    C-string style special characters like \n and \r are also supported (this
1377    is useful when the format string is not a C string literal). It is
1378    advisable to always escape curly braces that are meant to be copied to the
1379    output as ordinary characters.
1380
1381     Each tag is introduced by the character "%", followed by an optional
1382    minimum field width, followed by tag contents in curly braces ({}). If the
1383    minimum field width value is provided the tag will be expanded and the
1384    result padded to achieve the minimum width. If the minimum field width is
1385    positive, the padding will right-align the text. Negative field width will
1386    left-align. The rest of this section describes various supported tag
1387    contents and their expansion.
1388
1389     A simple tag is one where the content is an identifier. When simple tags
1390    are expanded, the named identifier will be looked up in pattern and the
1391    resulting list of values returned, joined together using comma. For
1392    example, to print the family name and style of the pattern, use the format
1393    "%{family} %{style}\n". To extend the family column to forty characters
1394    use "%-40{family}%{style}\n".
1395
1396     Simple tags expand to list of all values for an element. To only choose
1397    one of the values, one can index using the syntax "%{elt[idx]}". For
1398    example, to get the first family name only, use "%{family[0]}".
1399
1400     If a simple tag ends with "=" and the element is found in the pattern,
1401    the name of the element followed by "=" will be output before the list of
1402    values. For example, "%{weight=}" may expand to the string "weight=80". Or
1403    to the empty string if pattern does not have weight set.
1404
1405     If a simple tag starts with ":" and the element is found in the pattern,
1406    ":" will be printed first. For example, combining this with the =, the
1407    format "%{:weight=}" may expand to ":weight=80" or to the empty string if
1408    pattern does not have weight set.
1409
1410     If a simple tag contains the string ":-", the rest of the the tag
1411    contents will be used as a default string. The default string is output if
1412    the element is not found in the pattern. For example, the format
1413    "%{:weight=:-123}" may expand to ":weight=80" or to the string
1414    ":weight=123" if pattern does not have weight set.
1415
1416     A count tag is one that starts with the character "#" followed by an
1417    element name, and expands to the number of values for the element in the
1418    pattern. For example, "%{#family}" expands to the number of family names
1419    pattern has set, which may be zero.
1420
1421     A sub-expression tag is one that expands a sub-expression. The tag
1422    contents are the sub-expression to expand placed inside another set of
1423    curly braces. Sub-expression tags are useful for aligning an entire
1424    sub-expression, or to apply converters (explained later) to the entire
1425    sub-expression output. For example, the format "%40{{%{family} %{style}}}"
1426    expands the sub-expression to construct the family name followed by the
1427    style, then takes the entire string and pads it on the left to be at least
1428    forty characters.
1429
1430     A filter-out tag is one starting with the character "-" followed by a
1431    comma-separated list of element names, followed by a sub-expression
1432    enclosed in curly braces. The sub-expression will be expanded but with a
1433    pattern that has the listed elements removed from it. For example, the
1434    format "%{-size,pixelsize{sub-expr}}" will expand "sub-expr" with pattern
1435    sans the size and pixelsize elements.
1436
1437     A filter-in tag is one starting with the character "+" followed by a
1438    comma-separated list of element names, followed by a sub-expression
1439    enclosed in curly braces. The sub-expression will be expanded but with a
1440    pattern that only has the listed elements from the surrounding pattern.
1441    For example, the format "%{+family,familylang{sub-expr}}" will expand
1442    "sub-expr" with a sub-pattern consisting only the family and family lang
1443    elements of pattern.
1444
1445     A conditional tag is one starting with the character "?" followed by a
1446    comma-separated list of element conditions, followed by two sub-expression
1447    enclosed in curly braces. An element condition can be an element name, in
1448    which case it tests whether the element is defined in pattern, or the
1449    character "!" followed by an element name, in which case the test is
1450    negated. The conditional passes if all the element conditions pass. The
1451    tag expands the first sub-expression if the conditional passes, and
1452    expands the second sub-expression otherwise. For example, the format
1453    "%{?size,dpi,!pixelsize{pass}{fail}}" will expand to "pass" if pattern has
1454    size and dpi elements but no pixelsize element, and to "fail" otherwise.
1455
1456     An enumerate tag is one starting with the string "[]" followed by a
1457    comma-separated list of element names, followed by a sub-expression
1458    enclosed in curly braces. The list of values for the named elements are
1459    walked in parallel and the sub-expression expanded each time with a
1460    pattern just having a single value for those elements, starting from the
1461    first value and continuing as long as any of those elements has a value.
1462    For example, the format "%{[]family,familylang{%{family}
1463    (%{familylang})\n}}" will expand the pattern "%{family} (%{familylang})\n"
1464    with a pattern having only the first value of the family and familylang
1465    elements, then expands it with the second values, then the third, etc.
1466
1467     As a special case, if an enumerate tag has only one element, and that
1468    element has only one value in the pattern, and that value is of type
1469    FcLangSet, the individual languages in the language set are enumerated.
1470
1471     A builtin tag is one starting with the character "=" followed by a
1472    builtin name. The following builtins are defined:
1473
1474    unparse
1475
1476            Expands to the result of calling FcNameUnparse() on the pattern.
1477
1478    fcmatch
1479
1480            Expands to the output of the default output format of the fc-match
1481            command on the pattern, without the final newline.
1482
1483    fclist
1484
1485            Expands to the output of the default output format of the fc-list
1486            command on the pattern, without the final newline.
1487
1488    fccat
1489
1490            Expands to the output of the default output format of the fc-cat
1491            command on the pattern, without the final newline.
1492
1493    pkgkit
1494
1495            Expands to the list of PackageKit font() tags for the pattern.
1496            Currently this includes tags for each family name, and each
1497            language from the pattern, enumerated and sanitized into a set of
1498            tags terminated by newline. Package management systems can use
1499            these tags to tag their packages accordingly.
1500
1501    For example, the format "%{+family,style{%{=unparse}}}\n" will expand to
1502    an unparsed name containing only the family and style element values from
1503    pattern.
1504
1505     The contents of any tag can be followed by a set of zero or more
1506    converters. A converter is specified by the character "|" followed by the
1507    converter name and arguments. The following converters are defined:
1508
1509    basename
1510
1511            Replaces text with the results of calling FcStrBasename() on it.
1512
1513    dirname
1514
1515            Replaces text with the results of calling FcStrDirname() on it.
1516
1517    downcase
1518
1519            Replaces text with the results of calling FcStrDowncase() on it.
1520
1521    shescape
1522
1523            Escapes text for one level of shell expansion. (Escapes
1524            single-quotes, also encloses text in single-quotes.)
1525
1526    cescape
1527
1528            Escapes text such that it can be used as part of a C string
1529            literal. (Escapes backslash and double-quotes.)
1530
1531    xmlescape
1532
1533            Escapes text such that it can be used in XML and HTML. (Escapes
1534            less-than, greater-than, and ampersand.)
1535
1536    delete(chars)
1537
1538            Deletes all occurrences of each of the characters in chars from
1539            the text. FIXME: This converter is not UTF-8 aware yet.
1540
1541    escape(chars)
1542
1543            Escapes all occurrences of each of the characters in chars by
1544            prepending it by the first character in chars. FIXME: This
1545            converter is not UTF-8 aware yet.
1546
1547    translate(from,to)
1548
1549            Translates all occurrences of each of the characters in from by
1550            replacing them with their corresponding character in to. If to has
1551            fewer characters than from, it will be extended by repeating its
1552            last character. FIXME: This converter is not UTF-8 aware yet.
1553
1554    For example, the format "%{family|downcase|delete( )}\n" will expand to
1555    the values of the family element in pattern, lower-cased and with spaces
1556    removed.
1557
1558 Since
1559
1560    version 2.9.0
1561
1562    --------------------------------------------------------------------------
1563
1564   FcFontSet
1565
1566    Table of Contents
1567
1568    [43]FcFontSetCreate -- Create a font set
1569
1570    [44]FcFontSetDestroy -- Destroy a font set
1571
1572    [45]FcFontSetAdd -- Add to a font set
1573
1574    [46]FcFontSetList -- List fonts from a set of font sets
1575
1576    [47]FcFontSetMatch -- Return the best font from a set of font sets
1577
1578    [48]FcFontSetPrint -- Print a set of patterns to stdout
1579
1580    [49]FcFontSetSort -- Add to a font set
1581
1582    [50]FcFontSetSortDestroy -- DEPRECATED destroy a font set
1583
1584    An FcFontSet simply holds a list of patterns; these are used to return the
1585    results of listing available fonts.
1586
1587                                 FcFontSetCreate
1588
1589 Name
1590
1591    FcFontSetCreate -- Create a font set
1592
1593 Synopsis
1594
1595    #include <fontconfig/fontconfig.h>
1596
1597
1598    FcFontSet * FcFontSetCreate(void);
1599
1600 Description
1601
1602    Creates an empty font set.
1603
1604                                 FcFontSetDestroy
1605
1606 Name
1607
1608    FcFontSetDestroy -- Destroy a font set
1609
1610 Synopsis
1611
1612    #include <fontconfig/fontconfig.h>
1613
1614
1615    void FcFontSetDestroy(FcFontSet *s);
1616
1617 Description
1618
1619    Destroys a font set. Note that this destroys any referenced patterns as
1620    well.
1621
1622                                   FcFontSetAdd
1623
1624 Name
1625
1626    FcFontSetAdd -- Add to a font set
1627
1628 Synopsis
1629
1630    #include <fontconfig/fontconfig.h>
1631
1632
1633    FcBool FcFontSetAdd(FcFontSet *s, FcPattern *font);
1634
1635 Description
1636
1637    Adds a pattern to a font set. Note that the pattern is not copied before
1638    being inserted into the set. Returns FcFalse if the pattern cannot be
1639    inserted into the set (due to allocation failure). Otherwise returns
1640    FcTrue.
1641
1642                                  FcFontSetList
1643
1644 Name
1645
1646    FcFontSetList -- List fonts from a set of font sets
1647
1648 Synopsis
1649
1650    #include <fontconfig/fontconfig.h>
1651
1652
1653    FcFontSet * FcFontSetList(FcConfig *config, FcFontSet **sets, intnsets,
1654    FcPattern *pattern, FcObjectSet *object_set);
1655
1656 Description
1657
1658    Selects fonts matching pattern from sets, creates patterns from those
1659    fonts containing only the objects in object_set and returns the set of
1660    unique such patterns. If config is NULL, the default configuration is
1661    checked to be up to date, and used.
1662
1663                                  FcFontSetMatch
1664
1665 Name
1666
1667    FcFontSetMatch -- Return the best font from a set of font sets
1668
1669 Synopsis
1670
1671    #include <fontconfig/fontconfig.h>
1672
1673
1674    FcPattern * FcFontSetMatch(FcConfig *config, FcFontSet **sets, intnsets,
1675    FcPattern *pattern, FcResult *result);
1676
1677 Description
1678
1679    Finds the font in sets most closely matching pattern and returns the
1680    result of FcFontRenderPrepare for that font and the provided pattern. This
1681    function should be called only after FcConfigSubstitute and
1682    FcDefaultSubstitute have been called for pattern; otherwise the results
1683    will not be correct. If config is NULL, the current configuration is used.
1684    Returns NULL if an error occurs during this process.
1685
1686                                  FcFontSetPrint
1687
1688 Name
1689
1690    FcFontSetPrint -- Print a set of patterns to stdout
1691
1692 Synopsis
1693
1694    #include <fontconfig/fontconfig.h>
1695
1696
1697    void FcFontSetPrint(FcFontSet *set);
1698
1699 Description
1700
1701    This function is useful for diagnosing font related issues, printing the
1702    complete contents of every pattern in set. The format of the output is
1703    designed to be of help to users and developers, and may change at any
1704    time.
1705
1706                                  FcFontSetSort
1707
1708 Name
1709
1710    FcFontSetSort -- Add to a font set
1711
1712 Synopsis
1713
1714    #include <fontconfig/fontconfig.h>
1715
1716
1717    FcFontSetSort(FcConfig *config, FcFontSet **sets, intnsets, FcPattern
1718    *pattern, FcBool trim, FcCharSet **csp, FcResult *result);
1719
1720 Description
1721
1722    Returns the list of fonts from sets sorted by closeness to pattern. If
1723    trim is FcTrue, elements in the list which don't include Unicode coverage
1724    not provided by earlier elements in the list are elided. The union of
1725    Unicode coverage of all of the fonts is returned in csp, if csp is not
1726    NULL. This function should be called only after FcConfigSubstitute and
1727    FcDefaultSubstitute have been called for p; otherwise the results will not
1728    be correct.
1729
1730    The returned FcFontSet references FcPattern structures which may be shared
1731    by the return value from multiple FcFontSort calls, applications cannot
1732    modify these patterns. Instead, they should be passed, along with pattern
1733    to FcFontRenderPrepare which combines them into a complete pattern.
1734
1735    The FcFontSet returned by FcFontSetSort is destroyed by calling
1736    FcFontSetDestroy.
1737
1738                               FcFontSetSortDestroy
1739
1740 Name
1741
1742    FcFontSetSortDestroy -- DEPRECATED destroy a font set
1743
1744 Synopsis
1745
1746    #include <fontconfig/fontconfig.h>
1747
1748
1749    FcFontSetSortDestroy(FcFontSet *set);
1750
1751 Description
1752
1753    This function is DEPRECATED. FcFontSetSortDestroy destroys set by calling
1754    FcFontSetDestroy. Applications should use FcFontSetDestroy directly
1755    instead.
1756
1757    --------------------------------------------------------------------------
1758
1759   FcObjectSet
1760
1761    Table of Contents
1762
1763    [51]FcObjectSetCreate -- Create an object set
1764
1765    [52]FcObjectSetAdd -- Add to an object set
1766
1767    [53]FcObjectSetDestroy -- Destroy an object set
1768
1769    [54]FcObjectSetBuild -- Build object set from args
1770
1771    An FcObjectSet holds a list of pattern property names; it is used to
1772    indicate which properties are to be returned in the patterns from
1773    FcFontList.
1774
1775                                FcObjectSetCreate
1776
1777 Name
1778
1779    FcObjectSetCreate -- Create an object set
1780
1781 Synopsis
1782
1783    #include <fontconfig/fontconfig.h>
1784
1785
1786    FcObjectSet * FcObjectSetCreate(void);
1787
1788 Description
1789
1790    Creates an empty set.
1791
1792                                  FcObjectSetAdd
1793
1794 Name
1795
1796    FcObjectSetAdd -- Add to an object set
1797
1798 Synopsis
1799
1800    #include <fontconfig/fontconfig.h>
1801
1802
1803    FcBool FcObjectSetAdd(FcObjectSet *os, const char *object);
1804
1805 Description
1806
1807    Adds a property name to the set. Returns FcFalse if the property name
1808    cannot be inserted into the set (due to allocation failure). Otherwise
1809    returns FcTrue.
1810
1811                                FcObjectSetDestroy
1812
1813 Name
1814
1815    FcObjectSetDestroy -- Destroy an object set
1816
1817 Synopsis
1818
1819    #include <fontconfig/fontconfig.h>
1820
1821
1822    void FcObjectSetDestroy(FcObjectSet *os);
1823
1824 Description
1825
1826    Destroys an object set.
1827
1828                                 FcObjectSetBuild
1829
1830 Name
1831
1832    FcObjectSetBuild, FcObjectSetVaBuild, FcObjectSetVapBuild -- Build object
1833    set from args
1834
1835 Synopsis
1836
1837    #include <fontconfig/fontconfig.h>
1838
1839
1840    FcObjectSet * FcObjectSetBuild(const char *first, ...);
1841
1842    FcObjectSet * FcObjectSetVaBuild(const char *first, va_list va);
1843
1844    void FcObjectSetVapBuild(FcObjectSet *result, const char *first, va_list
1845    va);
1846
1847 Description
1848
1849    These build an object set from a null-terminated list of property names.
1850    FcObjectSetVapBuild is a macro version of FcObjectSetVaBuild which returns
1851    the result in the result variable directly.
1852
1853    --------------------------------------------------------------------------
1854
1855   FreeType specific functions
1856
1857    Table of Contents
1858
1859    [55]FcFreeTypeCharIndex -- map Unicode to glyph id
1860
1861    [56]FcFreeTypeCharSet -- compute Unicode coverage
1862
1863    [57]FcFreeTypeCharSetAndSpacing -- compute Unicode coverage and spacing
1864    type
1865
1866    [58]FcFreeTypeQuery -- compute pattern from font file (and index)
1867
1868    [59]FcFreeTypeQueryAll -- compute all patterns from font file (and index)
1869
1870    [60]FcFreeTypeQueryFace -- compute pattern from FT_Face
1871
1872    While the fontconfig library doesn't insist that FreeType be used as the
1873    rasterization mechanism for fonts, it does provide some convenience
1874    functions.
1875
1876                               FcFreeTypeCharIndex
1877
1878 Name
1879
1880    FcFreeTypeCharIndex -- map Unicode to glyph id
1881
1882 Synopsis
1883
1884    #include <fontconfig.h>
1885    #include <fcfreetype.h>
1886
1887
1888    FT_UInt FcFreeTypeCharIndex(FT_Face face, FcChar32 ucs4);
1889
1890 Description
1891
1892    Maps a Unicode char to a glyph index. This function uses information from
1893    several possible underlying encoding tables to work around broken fonts.
1894    As a result, this function isn't designed to be used in performance
1895    sensitive areas; results from this function are intended to be cached by
1896    higher level functions.
1897
1898                                FcFreeTypeCharSet
1899
1900 Name
1901
1902    FcFreeTypeCharSet -- compute Unicode coverage
1903
1904 Synopsis
1905
1906    #include <fontconfig.h>
1907    #include <fcfreetype.h>
1908
1909
1910    FcCharSet * FcFreeTypeCharSet(FT_Face face, FcBlanks *blanks);
1911
1912 Description
1913
1914    Scans a FreeType face and returns the set of encoded Unicode chars.
1915    FcBlanks is deprecated, blanks is ignored and accepted only for
1916    compatibility with older code.
1917
1918                           FcFreeTypeCharSetAndSpacing
1919
1920 Name
1921
1922    FcFreeTypeCharSetAndSpacing -- compute Unicode coverage and spacing type
1923
1924 Synopsis
1925
1926    #include <fontconfig.h>
1927    #include <fcfreetype.h>
1928
1929
1930    FcCharSet * FcFreeTypeCharSetAndSpacing(FT_Face face, FcBlanks *blanks,
1931    int *spacing);
1932
1933 Description
1934
1935    Scans a FreeType face and returns the set of encoded Unicode chars.
1936    FcBlanks is deprecated, blanks is ignored and accepted only for
1937    compatibility with older code. spacing receives the computed spacing type
1938    of the font, one of FC_MONO for a font where all glyphs have the same
1939    width, FC_DUAL, where the font has glyphs in precisely two widths, one
1940    twice as wide as the other, or FC_PROPORTIONAL where the font has glyphs
1941    of many widths.
1942
1943                                 FcFreeTypeQuery
1944
1945 Name
1946
1947    FcFreeTypeQuery -- compute pattern from font file (and index)
1948
1949 Synopsis
1950
1951    #include <fontconfig.h>
1952    #include <fcfreetype.h>
1953
1954
1955    FcPattern * FcFreeTypeQuery(const FcChar8 *file, int id, FcBlanks *blanks,
1956    int *count);
1957
1958 Description
1959
1960    Constructs a pattern representing the 'id'th face in 'file'. The number of
1961    faces in 'file' is returned in 'count'. FcBlanks is deprecated, blanks is
1962    ignored and accepted only for compatibility with older code.
1963
1964                                FcFreeTypeQueryAll
1965
1966 Name
1967
1968    FcFreeTypeQueryAll -- compute all patterns from font file (and index)
1969
1970 Synopsis
1971
1972    #include <fontconfig.h>
1973    #include <fcfreetype.h>
1974
1975
1976    unsigned int FcFreeTypeQueryAll(const FcChar8 *file, int id, FcBlanks
1977    *blanks, int *count, FcFontSet *set);
1978
1979 Description
1980
1981    Constructs patterns found in 'file'. If id is -1, then all patterns found
1982    in 'file' are added to 'set'. Otherwise, this function works exactly like
1983    FcFreeTypeQuery(). The number of faces in 'file' is returned in 'count'.
1984    The number of patterns added to 'set' is returned. FcBlanks is deprecated,
1985    blanks is ignored and accepted only for compatibility with older code.
1986
1987 Since
1988
1989    version 2.12.91
1990
1991                               FcFreeTypeQueryFace
1992
1993 Name
1994
1995    FcFreeTypeQueryFace -- compute pattern from FT_Face
1996
1997 Synopsis
1998
1999    #include <fontconfig.h>
2000    #include <fcfreetype.h>
2001
2002
2003    FcPattern * FcFreeTypeQueryFace(const FT_Face face, const FcChar8 *file,
2004    int id, FcBlanks *blanks);
2005
2006 Description
2007
2008    Constructs a pattern representing 'face'. 'file' and 'id' are used solely
2009    as data for pattern elements (FC_FILE, FC_INDEX and sometimes FC_FAMILY).
2010    FcBlanks is deprecated, blanks is ignored and accepted only for
2011    compatibility with older code.
2012
2013    --------------------------------------------------------------------------
2014
2015   FcValue
2016
2017    Table of Contents
2018
2019    [61]FcValueDestroy -- Free a value
2020
2021    [62]FcValueSave -- Copy a value
2022
2023    [63]FcValuePrint -- Print a value to stdout
2024
2025    [64]FcValueEqual -- Test two values for equality
2026
2027    FcValue is a structure containing a type tag and a union of all possible
2028    datatypes. The tag is an enum of type FcType and is intended to provide a
2029    measure of run-time typechecking, although that depends on careful
2030    programming.
2031
2032                                  FcValueDestroy
2033
2034 Name
2035
2036    FcValueDestroy -- Free a value
2037
2038 Synopsis
2039
2040    #include <fontconfig/fontconfig.h>
2041
2042
2043    void FcValueDestroy(FcValue v);
2044
2045 Description
2046
2047    Frees any memory referenced by v. Values of type FcTypeString,
2048    FcTypeMatrix and FcTypeCharSet reference memory, the other types do not.
2049
2050                                   FcValueSave
2051
2052 Name
2053
2054    FcValueSave -- Copy a value
2055
2056 Synopsis
2057
2058    #include <fontconfig/fontconfig.h>
2059
2060
2061    FcValue FcValueSave(FcValue v);
2062
2063 Description
2064
2065    Returns a copy of v duplicating any object referenced by it so that v may
2066    be safely destroyed without harming the new value.
2067
2068                                   FcValuePrint
2069
2070 Name
2071
2072    FcValuePrint -- Print a value to stdout
2073
2074 Synopsis
2075
2076    #include <fontconfig/fontconfig.h>
2077
2078
2079    void FcValuePrint(FcValue v);
2080
2081 Description
2082
2083    Prints a human-readable representation of v to stdout. The format should
2084    not be considered part of the library specification as it may change in
2085    the future.
2086
2087                                   FcValueEqual
2088
2089 Name
2090
2091    FcValueEqual -- Test two values for equality
2092
2093 Synopsis
2094
2095    #include <fontconfig/fontconfig.h>
2096
2097
2098    FcBool FcValueEqual(FcValue v_a, FcValue v_b);
2099
2100 Description
2101
2102    Compares two values. Integers and Doubles are compared as numbers;
2103    otherwise the two values have to be the same type to be considered equal.
2104    Strings are compared ignoring case.
2105
2106    --------------------------------------------------------------------------
2107
2108   FcCharSet
2109
2110    Table of Contents
2111
2112    [65]FcCharSetCreate -- Create an empty character set
2113
2114    [66]FcCharSetDestroy -- Destroy a character set
2115
2116    [67]FcCharSetAddChar -- Add a character to a charset
2117
2118    [68]FcCharSetDelChar -- Add a character to a charset
2119
2120    [69]FcCharSetCopy -- Copy a charset
2121
2122    [70]FcCharSetEqual -- Compare two charsets
2123
2124    [71]FcCharSetIntersect -- Intersect charsets
2125
2126    [72]FcCharSetUnion -- Add charsets
2127
2128    [73]FcCharSetSubtract -- Subtract charsets
2129
2130    [74]FcCharSetMerge -- Merge charsets
2131
2132    [75]FcCharSetHasChar -- Check a charset for a char
2133
2134    [76]FcCharSetCount -- Count entries in a charset
2135
2136    [77]FcCharSetIntersectCount -- Intersect and count charsets
2137
2138    [78]FcCharSetSubtractCount -- Subtract and count charsets
2139
2140    [79]FcCharSetIsSubset -- Test for charset inclusion
2141
2142    [80]FcCharSetFirstPage -- Start enumerating charset contents
2143
2144    [81]FcCharSetNextPage -- Continue enumerating charset contents
2145
2146    [82]FcCharSetCoverage -- DEPRECATED return coverage for a Unicode page
2147
2148    [83]FcCharSetNew -- DEPRECATED alias for FcCharSetCreate
2149
2150    An FcCharSet is a boolean array indicating a set of Unicode chars. Those
2151    associated with a font are marked constant and cannot be edited.
2152    FcCharSets may be reference counted internally to reduce memory
2153    consumption; this may be visible to applications as the result of
2154    FcCharSetCopy may return it's argument, and that CharSet may remain
2155    unmodifiable.
2156
2157                                 FcCharSetCreate
2158
2159 Name
2160
2161    FcCharSetCreate -- Create an empty character set
2162
2163 Synopsis
2164
2165    #include <fontconfig/fontconfig.h>
2166
2167
2168    FcCharSet * FcCharSetCreate(void);
2169
2170 Description
2171
2172    FcCharSetCreate allocates and initializes a new empty character set
2173    object.
2174
2175                                 FcCharSetDestroy
2176
2177 Name
2178
2179    FcCharSetDestroy -- Destroy a character set
2180
2181 Synopsis
2182
2183    #include <fontconfig/fontconfig.h>
2184
2185
2186    void FcCharSetDestroy(FcCharSet *fcs);
2187
2188 Description
2189
2190    FcCharSetDestroy decrements the reference count fcs. If the reference
2191    count becomes zero, all memory referenced is freed.
2192
2193                                 FcCharSetAddChar
2194
2195 Name
2196
2197    FcCharSetAddChar -- Add a character to a charset
2198
2199 Synopsis
2200
2201    #include <fontconfig/fontconfig.h>
2202
2203
2204    FcBool FcCharSetAddChar(FcCharSet *fcs, FcChar32 ucs4);
2205
2206 Description
2207
2208    FcCharSetAddChar adds a single Unicode char to the set, returning FcFalse
2209    on failure, either as a result of a constant set or from running out of
2210    memory.
2211
2212                                 FcCharSetDelChar
2213
2214 Name
2215
2216    FcCharSetDelChar -- Add a character to a charset
2217
2218 Synopsis
2219
2220    #include <fontconfig/fontconfig.h>
2221
2222
2223    FcBool FcCharSetDelChar(FcCharSet *fcs, FcChar32 ucs4);
2224
2225 Description
2226
2227    FcCharSetDelChar deletes a single Unicode char from the set, returning
2228    FcFalse on failure, either as a result of a constant set or from running
2229    out of memory.
2230
2231 Since
2232
2233    version 2.9.0
2234
2235                                  FcCharSetCopy
2236
2237 Name
2238
2239    FcCharSetCopy -- Copy a charset
2240
2241 Synopsis
2242
2243    #include <fontconfig/fontconfig.h>
2244
2245
2246    FcCharSet * FcCharSetCopy(FcCharSet *src);
2247
2248 Description
2249
2250    Makes a copy of src; note that this may not actually do anything more than
2251    increment the reference count on src.
2252
2253                                  FcCharSetEqual
2254
2255 Name
2256
2257    FcCharSetEqual -- Compare two charsets
2258
2259 Synopsis
2260
2261    #include <fontconfig/fontconfig.h>
2262
2263
2264    FcBool FcCharSetEqual(const FcCharSet *a, const FcCharSet *b);
2265
2266 Description
2267
2268    Returns whether a and b contain the same set of Unicode chars.
2269
2270                                FcCharSetIntersect
2271
2272 Name
2273
2274    FcCharSetIntersect -- Intersect charsets
2275
2276 Synopsis
2277
2278    #include <fontconfig/fontconfig.h>
2279
2280
2281    FcCharSet * FcCharSetIntersect(const FcCharSet *a, const FcCharSet *b);
2282
2283 Description
2284
2285    Returns a set including only those chars found in both a and b.
2286
2287                                  FcCharSetUnion
2288
2289 Name
2290
2291    FcCharSetUnion -- Add charsets
2292
2293 Synopsis
2294
2295    #include <fontconfig/fontconfig.h>
2296
2297
2298    FcCharSet * FcCharSetUnion(const FcCharSet *a, const FcCharSet *b);
2299
2300 Description
2301
2302    Returns a set including only those chars found in either a or b.
2303
2304                                FcCharSetSubtract
2305
2306 Name
2307
2308    FcCharSetSubtract -- Subtract charsets
2309
2310 Synopsis
2311
2312    #include <fontconfig/fontconfig.h>
2313
2314
2315    FcCharSet * FcCharSetSubtract(const FcCharSet *a, const FcCharSet *b);
2316
2317 Description
2318
2319    Returns a set including only those chars found in a but not b.
2320
2321                                  FcCharSetMerge
2322
2323 Name
2324
2325    FcCharSetMerge -- Merge charsets
2326
2327 Synopsis
2328
2329    #include <fontconfig/fontconfig.h>
2330
2331
2332    FcBool FcCharSetMerge(FcCharSet *a, const FcCharSet *b, FcBool *changed);
2333
2334 Description
2335
2336    Adds all chars in b to a. In other words, this is an in-place version of
2337    FcCharSetUnion. If changed is not NULL, then it returns whether any new
2338    chars from b were added to a. Returns FcFalse on failure, either when a is
2339    a constant set or from running out of memory.
2340
2341                                 FcCharSetHasChar
2342
2343 Name
2344
2345    FcCharSetHasChar -- Check a charset for a char
2346
2347 Synopsis
2348
2349    #include <fontconfig/fontconfig.h>
2350
2351
2352    FcBool FcCharSetHasChar(const FcCharSet *fcs, FcChar32 ucs4);
2353
2354 Description
2355
2356    Returns whether fcs contains the char ucs4.
2357
2358                                  FcCharSetCount
2359
2360 Name
2361
2362    FcCharSetCount -- Count entries in a charset
2363
2364 Synopsis
2365
2366    #include <fontconfig/fontconfig.h>
2367
2368
2369    FcChar32 FcCharSetCount(const FcCharSet *a);
2370
2371 Description
2372
2373    Returns the total number of Unicode chars in a.
2374
2375                             FcCharSetIntersectCount
2376
2377 Name
2378
2379    FcCharSetIntersectCount -- Intersect and count charsets
2380
2381 Synopsis
2382
2383    #include <fontconfig/fontconfig.h>
2384
2385
2386    FcChar32 FcCharSetIntersectCount(const FcCharSet *a, const FcCharSet *b);
2387
2388 Description
2389
2390    Returns the number of chars that are in both a and b.
2391
2392                              FcCharSetSubtractCount
2393
2394 Name
2395
2396    FcCharSetSubtractCount -- Subtract and count charsets
2397
2398 Synopsis
2399
2400    #include <fontconfig/fontconfig.h>
2401
2402
2403    FcChar32 FcCharSetSubtractCount(const FcCharSet *a, const FcCharSet *b);
2404
2405 Description
2406
2407    Returns the number of chars that are in a but not in b.
2408
2409                                FcCharSetIsSubset
2410
2411 Name
2412
2413    FcCharSetIsSubset -- Test for charset inclusion
2414
2415 Synopsis
2416
2417    #include <fontconfig/fontconfig.h>
2418
2419
2420    FcBool FcCharSetIsSubset(const FcCharSet *a, const FcCharSet *b);
2421
2422 Description
2423
2424    Returns whether a is a subset of b.
2425
2426                                FcCharSetFirstPage
2427
2428 Name
2429
2430    FcCharSetFirstPage -- Start enumerating charset contents
2431
2432 Synopsis
2433
2434    #include <fontconfig/fontconfig.h>
2435
2436
2437    FcChar32 FcCharSetFirstPage(const FcCharSet *a,
2438    FcChar32[FC_CHARSET_MAP_SIZE] map, FcChar32 *next);
2439
2440 Description
2441
2442    Builds an array of bits in map marking the first page of Unicode coverage
2443    of a. *next is set to contains the base code point for the next page in a.
2444    Returns the base code point for the page, or FC_CHARSET_DONE if a contains
2445    no pages. As an example, if FcCharSetFirstPage returns 0x300 and fills map
2446    with
2447
2448 0xffffffff 0xffffffff 0x01000008 0x44300002 0xffffd7f0 0xfffffffb 0xffff7fff 0xffff0003
2449
2450    Then the page contains code points 0x300 through 0x33f (the first 64 code
2451    points on the page) because map[0] and map[1] both have all their bits
2452    set. It also contains code points 0x343 (0x300 + 32*2 + (4-1)) and 0x35e
2453    (0x300 + 32*2 + (31-1)) because map[2] has the 4th and 31st bits set. The
2454    code points represented by map[3] and later are left as an excercise for
2455    the reader ;).
2456
2457                                FcCharSetNextPage
2458
2459 Name
2460
2461    FcCharSetNextPage -- Continue enumerating charset contents
2462
2463 Synopsis
2464
2465    #include <fontconfig/fontconfig.h>
2466
2467
2468    FcChar32 FcCharSetNextPage(const FcCharSet *a,
2469    FcChar32[FC_CHARSET_MAP_SIZE] map, FcChar32 *next);
2470
2471 Description
2472
2473    Builds an array of bits in map marking the Unicode coverage of a for page
2474    containing *next (see the FcCharSetFirstPage description for details).
2475    *next is set to contains the base code point for the next page in a.
2476    Returns the base of code point for the page, or FC_CHARSET_DONE if a does
2477    not contain *next.
2478
2479                                FcCharSetCoverage
2480
2481 Name
2482
2483    FcCharSetCoverage -- DEPRECATED return coverage for a Unicode page
2484
2485 Synopsis
2486
2487    #include <fontconfig/fontconfig.h>
2488
2489
2490    FcChar32 FcCharSetCoverage(const FcCharSet *a, FcChar32page,
2491    FcChar32[8]result);
2492
2493 Description
2494
2495    DEPRECATED This function returns a bitmask in result which indicates which
2496    code points in page are included in a. FcCharSetCoverage returns the next
2497    page in the charset which has any coverage.
2498
2499                                   FcCharSetNew
2500
2501 Name
2502
2503    FcCharSetNew -- DEPRECATED alias for FcCharSetCreate
2504
2505 Synopsis
2506
2507    #include <fontconfig/fontconfig.h>
2508
2509
2510    FcCharSet * FcCharSetNew(void);
2511
2512 Description
2513
2514    FcCharSetNew is a DEPRECATED alias for FcCharSetCreate.
2515
2516    --------------------------------------------------------------------------
2517
2518   FcLangSet
2519
2520    Table of Contents
2521
2522    [84]FcLangSetCreate -- create a langset object
2523
2524    [85]FcLangSetDestroy -- destroy a langset object
2525
2526    [86]FcLangSetCopy -- copy a langset object
2527
2528    [87]FcLangSetAdd -- add a language to a langset
2529
2530    [88]FcLangSetDel -- delete a language from a langset
2531
2532    [89]FcLangSetUnion -- Add langsets
2533
2534    [90]FcLangSetSubtract -- Subtract langsets
2535
2536    [91]FcLangSetCompare -- compare language sets
2537
2538    [92]FcLangSetContains -- check langset subset relation
2539
2540    [93]FcLangSetEqual -- test for matching langsets
2541
2542    [94]FcLangSetHash -- return a hash value for a langset
2543
2544    [95]FcLangSetHasLang -- test langset for language support
2545
2546    [96]FcGetDefaultLangs -- Get the default languages list
2547
2548    [97]FcLangSetGetLangs -- get the list of languages in the langset
2549
2550    [98]FcGetLangs -- Get list of languages
2551
2552    [99]FcLangNormalize -- Normalize the language string
2553
2554    [100]FcLangGetCharSet -- Get character map for a language
2555
2556    An FcLangSet is a set of language names (each of which include language
2557    and an optional territory). They are used when selecting fonts to indicate
2558    which languages the fonts need to support. Each font is marked, using
2559    language orthography information built into fontconfig, with the set of
2560    supported languages.
2561
2562                                 FcLangSetCreate
2563
2564 Name
2565
2566    FcLangSetCreate -- create a langset object
2567
2568 Synopsis
2569
2570    #include <fontconfig/fontconfig.h>
2571
2572
2573    FcLangSet * FcLangSetCreate(void);
2574
2575 Description
2576
2577    FcLangSetCreate creates a new FcLangSet object.
2578
2579                                 FcLangSetDestroy
2580
2581 Name
2582
2583    FcLangSetDestroy -- destroy a langset object
2584
2585 Synopsis
2586
2587    #include <fontconfig/fontconfig.h>
2588
2589
2590    void FcLangSetDestroy(FcLangSet *ls);
2591
2592 Description
2593
2594    FcLangSetDestroy destroys a FcLangSet object, freeing all memory
2595    associated with it.
2596
2597                                  FcLangSetCopy
2598
2599 Name
2600
2601    FcLangSetCopy -- copy a langset object
2602
2603 Synopsis
2604
2605    #include <fontconfig/fontconfig.h>
2606
2607
2608    FcLangSet * FcLangSetCopy(const FcLangSet *ls);
2609
2610 Description
2611
2612    FcLangSetCopy creates a new FcLangSet object and populates it with the
2613    contents of ls.
2614
2615                                   FcLangSetAdd
2616
2617 Name
2618
2619    FcLangSetAdd -- add a language to a langset
2620
2621 Synopsis
2622
2623    #include <fontconfig/fontconfig.h>
2624
2625
2626    FcBool FcLangSetAdd(FcLangSet *ls, const FcChar8 *lang);
2627
2628 Description
2629
2630    lang is added to ls. lang should be of the form Ll-Tt where Ll is a two or
2631    three letter language from ISO 639 and Tt is a territory from ISO 3166.
2632
2633                                   FcLangSetDel
2634
2635 Name
2636
2637    FcLangSetDel -- delete a language from a langset
2638
2639 Synopsis
2640
2641    #include <fontconfig/fontconfig.h>
2642
2643
2644    FcBool FcLangSetDel(FcLangSet *ls, const FcChar8 *lang);
2645
2646 Description
2647
2648    lang is removed from ls. lang should be of the form Ll-Tt where Ll is a
2649    two or three letter language from ISO 639 and Tt is a territory from ISO
2650    3166.
2651
2652 Since
2653
2654    version 2.9.0
2655
2656                                  FcLangSetUnion
2657
2658 Name
2659
2660    FcLangSetUnion -- Add langsets
2661
2662 Synopsis
2663
2664    #include <fontconfig/fontconfig.h>
2665
2666
2667    FcLangSet * FcLangSetUnion(const FcLangSet *ls_a, const FcLangSet *ls_b);
2668
2669 Description
2670
2671    Returns a set including only those languages found in either ls_a or ls_b.
2672
2673 Since
2674
2675    version 2.9.0
2676
2677                                FcLangSetSubtract
2678
2679 Name
2680
2681    FcLangSetSubtract -- Subtract langsets
2682
2683 Synopsis
2684
2685    #include <fontconfig/fontconfig.h>
2686
2687
2688    FcLangSet * FcLangSetSubtract(const FcLangSet *ls_a, const FcLangSet
2689    *ls_b);
2690
2691 Description
2692
2693    Returns a set including only those languages found in ls_a but not in
2694    ls_b.
2695
2696 Since
2697
2698    version 2.9.0
2699
2700                                 FcLangSetCompare
2701
2702 Name
2703
2704    FcLangSetCompare -- compare language sets
2705
2706 Synopsis
2707
2708    #include <fontconfig/fontconfig.h>
2709
2710
2711    FcLangResult FcLangSetCompare(const FcLangSet *ls_a, const FcLangSet
2712    *ls_b);
2713
2714 Description
2715
2716    FcLangSetCompare compares language coverage for ls_a and ls_b. If they
2717    share any language and territory pair, this function returns FcLangEqual.
2718    If they share a language but differ in which territory that language is
2719    for, this function returns FcLangDifferentTerritory. If they share no
2720    languages in common, this function returns FcLangDifferentLang.
2721
2722                                FcLangSetContains
2723
2724 Name
2725
2726    FcLangSetContains -- check langset subset relation
2727
2728 Synopsis
2729
2730    #include <fontconfig/fontconfig.h>
2731
2732
2733    FcBool FcLangSetContains(const FcLangSet *ls_a, const FcLangSet *ls_b);
2734
2735 Description
2736
2737    FcLangSetContains returns FcTrue if ls_a contains every language in ls_b.
2738    ls_a will 'contain' a language from ls_b if ls_a has exactly the language,
2739    or either the language or ls_a has no territory.
2740
2741                                  FcLangSetEqual
2742
2743 Name
2744
2745    FcLangSetEqual -- test for matching langsets
2746
2747 Synopsis
2748
2749    #include <fontconfig/fontconfig.h>
2750
2751
2752    FcBool FcLangSetEqual(const FcLangSet *ls_a, const FcLangSet *ls_b);
2753
2754 Description
2755
2756    Returns FcTrue if and only if ls_a supports precisely the same language
2757    and territory combinations as ls_b.
2758
2759                                  FcLangSetHash
2760
2761 Name
2762
2763    FcLangSetHash -- return a hash value for a langset
2764
2765 Synopsis
2766
2767    #include <fontconfig/fontconfig.h>
2768
2769
2770    FcChar32 FcLangSetHash(const FcLangSet *ls);
2771
2772 Description
2773
2774    This function returns a value which depends solely on the languages
2775    supported by ls. Any language which equals ls will have the same result
2776    from FcLangSetHash. However, two langsets with the same hash value may not
2777    be equal.
2778
2779                                 FcLangSetHasLang
2780
2781 Name
2782
2783    FcLangSetHasLang -- test langset for language support
2784
2785 Synopsis
2786
2787    #include <fontconfig/fontconfig.h>
2788
2789
2790    FcLangResult FcLangSetHasLang(const FcLangSet *ls, const FcChar8 *lang);
2791
2792 Description
2793
2794    FcLangSetHasLang checks whether ls supports lang. If ls has a matching
2795    language and territory pair, this function returns FcLangEqual. If ls has
2796    a matching language but differs in which territory that language is for,
2797    this function returns FcLangDifferentTerritory. If ls has no matching
2798    language, this function returns FcLangDifferentLang.
2799
2800                                FcGetDefaultLangs
2801
2802 Name
2803
2804    FcGetDefaultLangs -- Get the default languages list
2805
2806 Synopsis
2807
2808    #include <fontconfig/fontconfig.h>
2809
2810
2811    FcStrSet * FcGetDefaultLangs(void);
2812
2813 Description
2814
2815    Returns a string set of the default languages according to the environment
2816    variables on the system. This function looks for them in order of FC_LANG,
2817    LC_ALL, LC_CTYPE and LANG then. If there are no valid values in those
2818    environment variables, "en" will be set as fallback.
2819
2820 Since
2821
2822    version 2.9.91
2823
2824                                FcLangSetGetLangs
2825
2826 Name
2827
2828    FcLangSetGetLangs -- get the list of languages in the langset
2829
2830 Synopsis
2831
2832    #include <fontconfig/fontconfig.h>
2833
2834
2835    FcStrSet * FcLangSetGetLangs(const FcLangSet *ls);
2836
2837 Description
2838
2839    Returns a string set of all languages in langset.
2840
2841                                    FcGetLangs
2842
2843 Name
2844
2845    FcGetLangs -- Get list of languages
2846
2847 Synopsis
2848
2849    #include <fontconfig/fontconfig.h>
2850
2851
2852    FcStrSet * FcGetLangs(void);
2853
2854 Description
2855
2856    Returns a string set of all known languages.
2857
2858                                 FcLangNormalize
2859
2860 Name
2861
2862    FcLangNormalize -- Normalize the language string
2863
2864 Synopsis
2865
2866    #include <fontconfig/fontconfig.h>
2867
2868
2869    FcChar8 * FcLangNormalize(const FcChar8 *lang);
2870
2871 Description
2872
2873    Returns a string to make lang suitable on fontconfig.
2874
2875 Since
2876
2877    version 2.10.91
2878
2879                                 FcLangGetCharSet
2880
2881 Name
2882
2883    FcLangGetCharSet -- Get character map for a language
2884
2885 Synopsis
2886
2887    #include <fontconfig/fontconfig.h>
2888
2889
2890    const FcCharSet * FcLangGetCharSet(const FcChar8 *lang);
2891
2892 Description
2893
2894    Returns the FcCharMap for a language.
2895
2896    --------------------------------------------------------------------------
2897
2898   FcMatrix
2899
2900    Table of Contents
2901
2902    [101]FcMatrixInit -- initialize an FcMatrix structure
2903
2904    [102]FcMatrixCopy -- Copy a matrix
2905
2906    [103]FcMatrixEqual -- Compare two matrices
2907
2908    [104]FcMatrixMultiply -- Multiply matrices
2909
2910    [105]FcMatrixRotate -- Rotate a matrix
2911
2912    [106]FcMatrixScale -- Scale a matrix
2913
2914    [107]FcMatrixShear -- Shear a matrix
2915
2916    FcMatrix structures hold an affine transformation in matrix form.
2917
2918                                   FcMatrixInit
2919
2920 Name
2921
2922    FcMatrixInit -- initialize an FcMatrix structure
2923
2924 Synopsis
2925
2926    #include <fontconfig/fontconfig.h>
2927
2928
2929    void FcMatrixInit(FcMatrix *matrix);
2930
2931 Description
2932
2933    FcMatrixInit initializes matrix to the identity matrix.
2934
2935                                   FcMatrixCopy
2936
2937 Name
2938
2939    FcMatrixCopy -- Copy a matrix
2940
2941 Synopsis
2942
2943    #include <fontconfig/fontconfig.h>
2944
2945
2946    void FcMatrixCopy(const FcMatrix *matrix);
2947
2948 Description
2949
2950    FcMatrixCopy allocates a new FcMatrix and copies mat into it.
2951
2952                                  FcMatrixEqual
2953
2954 Name
2955
2956    FcMatrixEqual -- Compare two matrices
2957
2958 Synopsis
2959
2960    #include <fontconfig/fontconfig.h>
2961
2962
2963    void FcMatrixEqual(const FcMatrix *matrix1, const FcMatrix *matrix2);
2964
2965 Description
2966
2967    FcMatrixEqual compares matrix1 and matrix2 returning FcTrue when they are
2968    equal and FcFalse when they are not.
2969
2970                                 FcMatrixMultiply
2971
2972 Name
2973
2974    FcMatrixMultiply -- Multiply matrices
2975
2976 Synopsis
2977
2978    #include <fontconfig/fontconfig.h>
2979
2980
2981    void FcMatrixMultiply(FcMatrix *result, const FcMatrix *matrix1, const
2982    FcMatrix *matrix2);
2983
2984 Description
2985
2986    FcMatrixMultiply multiplies matrix1 and matrix2 storing the result in
2987    result.
2988
2989                                  FcMatrixRotate
2990
2991 Name
2992
2993    FcMatrixRotate -- Rotate a matrix
2994
2995 Synopsis
2996
2997    #include <fontconfig/fontconfig.h>
2998
2999
3000    void FcMatrixRotate(FcMatrix *matrix, double cos, double sin);
3001
3002 Description
3003
3004    FcMatrixRotate rotates matrix by the angle who's sine is sin and cosine is
3005    cos. This is done by multiplying by the matrix:
3006
3007      cos -sin
3008      sin  cos
3009
3010                                  FcMatrixScale
3011
3012 Name
3013
3014    FcMatrixScale -- Scale a matrix
3015
3016 Synopsis
3017
3018    #include <fontconfig/fontconfig.h>
3019
3020
3021    void FcMatrixScale(FcMatrix *matrix, double sx, double dy);
3022
3023 Description
3024
3025    FcMatrixScale multiplies matrix x values by sx and y values by dy. This is
3026    done by multiplying by the matrix:
3027
3028       sx  0
3029       0   dy
3030
3031                                  FcMatrixShear
3032
3033 Name
3034
3035    FcMatrixShear -- Shear a matrix
3036
3037 Synopsis
3038
3039    #include <fontconfig/fontconfig.h>
3040
3041
3042    void FcMatrixShear(FcMatrix *matrix, double sh, double sv);
3043
3044 Description
3045
3046    FcMatrixShare shears matrix horizontally by sh and vertically by sv. This
3047    is done by multiplying by the matrix:
3048
3049      1  sh
3050      sv  1
3051
3052    --------------------------------------------------------------------------
3053
3054   FcRange
3055
3056    Table of Contents
3057
3058    [108]FcRangeCopy -- Copy a range object
3059
3060    [109]FcRangeCreateDouble -- create a range object for double
3061
3062    [110]FcRangeCreateInteger -- create a range object for integer
3063
3064    [111]FcRangeDestroy -- destroy a range object
3065
3066    [112]FcRangeGetDouble -- Get the range in double
3067
3068    An FcRange holds two variables to indicate a range in between.
3069
3070                                   FcRangeCopy
3071
3072 Name
3073
3074    FcRangeCopy -- Copy a range object
3075
3076 Synopsis
3077
3078    #include <fontconfig/fontconfig.h>
3079
3080
3081    FcRange * FcRangeCopy(const FcRange *range);
3082
3083 Description
3084
3085    FcRangeCopy creates a new FcRange object and populates it with the
3086    contents of range.
3087
3088 Since
3089
3090    version 2.11.91
3091
3092                               FcRangeCreateDouble
3093
3094 Name
3095
3096    FcRangeCreateDouble -- create a range object for double
3097
3098 Synopsis
3099
3100    #include <fontconfig/fontconfig.h>
3101
3102
3103    FcRange * FcRangeCreateDouble(doublebegin, doubleend);
3104
3105 Description
3106
3107    FcRangeCreateDouble creates a new FcRange object with double sized value.
3108
3109 Since
3110
3111    version 2.11.91
3112
3113                               FcRangeCreateInteger
3114
3115 Name
3116
3117    FcRangeCreateInteger -- create a range object for integer
3118
3119 Synopsis
3120
3121    #include <fontconfig/fontconfig.h>
3122
3123
3124    FcRange * FcRangeCreateInteger(intbegin, intend);
3125
3126 Description
3127
3128    FcRangeCreateInteger creates a new FcRange object with integer sized
3129    value.
3130
3131 Since
3132
3133    version 2.11.91
3134
3135                                  FcRangeDestroy
3136
3137 Name
3138
3139    FcRangeDestroy -- destroy a range object
3140
3141 Synopsis
3142
3143    #include <fontconfig/fontconfig.h>
3144
3145
3146    void FcRangeDestroy(FcRange *range);
3147
3148 Description
3149
3150    FcRangeDestroy destroys a FcRange object, freeing all memory associated
3151    with it.
3152
3153 Since
3154
3155    version 2.11.91
3156
3157                                 FcRangeGetDouble
3158
3159 Name
3160
3161    FcRangeGetDouble -- Get the range in double
3162
3163 Synopsis
3164
3165    #include <fontconfig/fontconfig.h>
3166
3167
3168    FcBool FcRangeGetDouble(const FcRange *range, double *begin, double *end);
3169
3170 Description
3171
3172    Returns in begin and end as the range.
3173
3174 Since
3175
3176    version 2.11.91
3177
3178    --------------------------------------------------------------------------
3179
3180   FcConfig
3181
3182    Table of Contents
3183
3184    [113]FcConfigCreate -- Create a configuration
3185
3186    [114]FcConfigReference -- Increment config reference count
3187
3188    [115]FcConfigDestroy -- Destroy a configuration
3189
3190    [116]FcConfigSetCurrent -- Set configuration as default
3191
3192    [117]FcConfigGetCurrent -- Return current configuration
3193
3194    [118]FcConfigUptoDate -- Check timestamps on config files
3195
3196    [119]FcConfigHome -- return the current home directory.
3197
3198    [120]FcConfigEnableHome -- controls use of the home directory.
3199
3200    [121]FcConfigBuildFonts -- Build font database
3201
3202    [122]FcConfigGetConfigDirs -- Get config directories
3203
3204    [123]FcConfigGetFontDirs -- Get font directories
3205
3206    [124]FcConfigGetConfigFiles -- Get config files
3207
3208    [125]FcConfigGetCache -- DEPRECATED used to return per-user cache filename
3209
3210    [126]FcConfigGetCacheDirs -- return the list of directories searched for
3211    cache files
3212
3213    [127]FcConfigGetFonts -- Get config font set
3214
3215    [128]FcConfigGetBlanks -- Get config blanks
3216
3217    [129]FcConfigGetRescanInterval -- Get config rescan interval
3218
3219    [130]FcConfigSetRescanInterval -- Set config rescan interval
3220
3221    [131]FcConfigAppFontAddFile -- Add font file to font database
3222
3223    [132]FcConfigAppFontAddDir -- Add fonts from directory to font database
3224
3225    [133]FcConfigAppFontClear -- Remove all app fonts from font database
3226
3227    [134]FcConfigSubstituteWithPat -- Execute substitutions
3228
3229    [135]FcConfigSubstitute -- Execute substitutions
3230
3231    [136]FcFontMatch -- Return best font
3232
3233    [137]FcFontSort -- Return list of matching fonts
3234
3235    [138]FcFontRenderPrepare -- Prepare pattern for loading font file
3236
3237    [139]FcFontList -- List fonts
3238
3239    [140]FcConfigFilename -- Find a config file
3240
3241    [141]FcConfigParseAndLoad -- load a configuration file
3242
3243    [142]FcConfigParseAndLoadFromMemory -- load a configuration from memory
3244
3245    [143]FcConfigGetSysRoot -- Obtain the system root directory
3246
3247    [144]FcConfigSetSysRoot -- Set the system root directory
3248
3249    [145]FcConfigFileInfoIterInit -- Initialize the iterator
3250
3251    [146]FcConfigFileInfoIterNext -- Set the iterator to point to the next
3252    list
3253
3254    [147]FcConfigFileInfoIterGet -- Obtain the configuration file information
3255
3256    An FcConfig object holds the internal representation of a configuration.
3257    There is a default configuration which applications may use by passing 0
3258    to any function using the data within an FcConfig.
3259
3260                                  FcConfigCreate
3261
3262 Name
3263
3264    FcConfigCreate -- Create a configuration
3265
3266 Synopsis
3267
3268    #include <fontconfig/fontconfig.h>
3269
3270
3271    FcConfig * FcConfigCreate(void);
3272
3273 Description
3274
3275    Creates an empty configuration.
3276
3277                                FcConfigReference
3278
3279 Name
3280
3281    FcConfigReference -- Increment config reference count
3282
3283 Synopsis
3284
3285    #include <fontconfig/fontconfig.h>
3286
3287
3288    FcConfig * FcConfigReference(FcConfig *config);
3289
3290 Description
3291
3292    Add another reference to config. Configs are freed only when the reference
3293    count reaches zero. If config is NULL, the current configuration is used.
3294    In that case this function will be similar to FcConfigGetCurrent() except
3295    that it increments the reference count before returning and the user is
3296    responsible for destroying the configuration when not needed anymore.
3297
3298                                 FcConfigDestroy
3299
3300 Name
3301
3302    FcConfigDestroy -- Destroy a configuration
3303
3304 Synopsis
3305
3306    #include <fontconfig/fontconfig.h>
3307
3308
3309    void FcConfigDestroy(FcConfig *config);
3310
3311 Description
3312
3313    Decrements the config reference count. If all references are gone,
3314    destroys the configuration and any data associated with it. Note that
3315    calling this function with the return from FcConfigGetCurrent will cause a
3316    new configuration to be created for use as current configuration.
3317
3318                                FcConfigSetCurrent
3319
3320 Name
3321
3322    FcConfigSetCurrent -- Set configuration as default
3323
3324 Synopsis
3325
3326    #include <fontconfig/fontconfig.h>
3327
3328
3329    FcBool FcConfigSetCurrent(FcConfig *config);
3330
3331 Description
3332
3333    Sets the current default configuration to config. Implicitly calls
3334    FcConfigBuildFonts if necessary, and FcConfigReference() to inrease the
3335    reference count in config since 2.12.0, returning FcFalse if that call
3336    fails.
3337
3338                                FcConfigGetCurrent
3339
3340 Name
3341
3342    FcConfigGetCurrent -- Return current configuration
3343
3344 Synopsis
3345
3346    #include <fontconfig/fontconfig.h>
3347
3348
3349    FcConfig * FcConfigGetCurrent(void);
3350
3351 Description
3352
3353    Returns the current default configuration.
3354
3355                                 FcConfigUptoDate
3356
3357 Name
3358
3359    FcConfigUptoDate -- Check timestamps on config files
3360
3361 Synopsis
3362
3363    #include <fontconfig/fontconfig.h>
3364
3365
3366    FcBool FcConfigUptoDate(FcConfig *config);
3367
3368 Description
3369
3370    Checks all of the files related to config and returns whether any of them
3371    has been modified since the configuration was created. If config is NULL,
3372    the current configuration is used.
3373
3374                                   FcConfigHome
3375
3376 Name
3377
3378    FcConfigHome -- return the current home directory.
3379
3380 Synopsis
3381
3382    #include <fontconfig/fontconfig.h>
3383
3384
3385    FcChar8 * FcConfigHome(void);
3386
3387 Description
3388
3389    Return the current user's home directory, if it is available, and if using
3390    it is enabled, and NULL otherwise. See also FcConfigEnableHome).
3391
3392                                FcConfigEnableHome
3393
3394 Name
3395
3396    FcConfigEnableHome -- controls use of the home directory.
3397
3398 Synopsis
3399
3400    #include <fontconfig/fontconfig.h>
3401
3402
3403    FcBool FcConfigEnableHome(FcBool enable);
3404
3405 Description
3406
3407    If enable is FcTrue, then Fontconfig will use various files which are
3408    specified relative to the user's home directory (using the ~ notation in
3409    the configuration). When enable is FcFalse, then all use of the home
3410    directory in these contexts will be disabled. The previous setting of the
3411    value is returned.
3412
3413                                FcConfigBuildFonts
3414
3415 Name
3416
3417    FcConfigBuildFonts -- Build font database
3418
3419 Synopsis
3420
3421    #include <fontconfig/fontconfig.h>
3422
3423
3424    FcBool FcConfigBuildFonts(FcConfig *config);
3425
3426 Description
3427
3428    Builds the set of available fonts for the given configuration. Note that
3429    any changes to the configuration after this call have indeterminate
3430    effects. Returns FcFalse if this operation runs out of memory. If config
3431    is NULL, the current configuration is used.
3432
3433                              FcConfigGetConfigDirs
3434
3435 Name
3436
3437    FcConfigGetConfigDirs -- Get config directories
3438
3439 Synopsis
3440
3441    #include <fontconfig/fontconfig.h>
3442
3443
3444    FcStrList * FcConfigGetConfigDirs(FcConfig *config);
3445
3446 Description
3447
3448    Returns the list of font directories specified in the configuration files
3449    for config. Does not include any subdirectories. If config is NULL, the
3450    current configuration is used.
3451
3452                               FcConfigGetFontDirs
3453
3454 Name
3455
3456    FcConfigGetFontDirs -- Get font directories
3457
3458 Synopsis
3459
3460    #include <fontconfig/fontconfig.h>
3461
3462
3463    FcStrList * FcConfigGetFontDirs(FcConfig *config);
3464
3465 Description
3466
3467    Returns the list of font directories in config. This includes the
3468    configured font directories along with any directories below those in the
3469    filesystem. If config is NULL, the current configuration is used.
3470
3471                              FcConfigGetConfigFiles
3472
3473 Name
3474
3475    FcConfigGetConfigFiles -- Get config files
3476
3477 Synopsis
3478
3479    #include <fontconfig/fontconfig.h>
3480
3481
3482    FcStrList * FcConfigGetConfigFiles(FcConfig *config);
3483
3484 Description
3485
3486    Returns the list of known configuration files used to generate config. If
3487    config is NULL, the current configuration is used.
3488
3489                                 FcConfigGetCache
3490
3491 Name
3492
3493    FcConfigGetCache -- DEPRECATED used to return per-user cache filename
3494
3495 Synopsis
3496
3497    #include <fontconfig/fontconfig.h>
3498
3499
3500    FcChar8 * FcConfigGetCache(FcConfig *config);
3501
3502 Description
3503
3504    With fontconfig no longer using per-user cache files, this function now
3505    simply returns NULL to indicate that no per-user file exists.
3506
3507                               FcConfigGetCacheDirs
3508
3509 Name
3510
3511    FcConfigGetCacheDirs -- return the list of directories searched for cache
3512    files
3513
3514 Synopsis
3515
3516    #include <fontconfig/fontconfig.h>
3517
3518
3519    FcStrList * FcConfigGetCacheDirs(const FcConfig *config);
3520
3521 Description
3522
3523    FcConfigGetCacheDirs returns a string list containing all of the
3524    directories that fontconfig will search when attempting to load a cache
3525    file for a font directory. If config is NULL, the current configuration is
3526    used.
3527
3528                                 FcConfigGetFonts
3529
3530 Name
3531
3532    FcConfigGetFonts -- Get config font set
3533
3534 Synopsis
3535
3536    #include <fontconfig/fontconfig.h>
3537
3538
3539    FcFontSet * FcConfigGetFonts(FcConfig *config, FcSetName set);
3540
3541 Description
3542
3543    Returns one of the two sets of fonts from the configuration as specified
3544    by set. This font set is owned by the library and must not be modified or
3545    freed. If config is NULL, the current configuration is used.
3546
3547                                FcConfigGetBlanks
3548
3549 Name
3550
3551    FcConfigGetBlanks -- Get config blanks
3552
3553 Synopsis
3554
3555    #include <fontconfig/fontconfig.h>
3556
3557
3558    FcBlanks * FcConfigGetBlanks(FcConfig *config);
3559
3560 Description
3561
3562    FcBlanks is deprecated. This function always returns NULL.
3563
3564                            FcConfigGetRescanInterval
3565
3566 Name
3567
3568    FcConfigGetRescanInterval -- Get config rescan interval
3569
3570 Synopsis
3571
3572    #include <fontconfig/fontconfig.h>
3573
3574
3575    int FcConfigGetRescanInterval(FcConfig *config);
3576
3577 Description
3578
3579    Returns the interval between automatic checks of the configuration (in
3580    seconds) specified in config. The configuration is checked during a call
3581    to FcFontList when this interval has passed since the last check. An
3582    interval setting of zero disables automatic checks. If config is NULL, the
3583    current configuration is used.
3584
3585                            FcConfigSetRescanInterval
3586
3587 Name
3588
3589    FcConfigSetRescanInterval -- Set config rescan interval
3590
3591 Synopsis
3592
3593    #include <fontconfig/fontconfig.h>
3594
3595
3596    FcBool FcConfigSetRescanInterval(FcConfig *config, int rescanInterval);
3597
3598 Description
3599
3600    Sets the rescan interval. Returns FcFalse if the interval cannot be set
3601    (due to allocation failure). Otherwise returns FcTrue. An interval setting
3602    of zero disables automatic checks. If config is NULL, the current
3603    configuration is used.
3604
3605                              FcConfigAppFontAddFile
3606
3607 Name
3608
3609    FcConfigAppFontAddFile -- Add font file to font database
3610
3611 Synopsis
3612
3613    #include <fontconfig/fontconfig.h>
3614
3615
3616    FcBool FcConfigAppFontAddFile(FcConfig *config, const FcChar8 *file);
3617
3618 Description
3619
3620    Adds an application-specific font to the configuration. Returns FcFalse if
3621    the fonts cannot be added (due to allocation failure or no fonts found).
3622    Otherwise returns FcTrue. If config is NULL, the current configuration is
3623    used.
3624
3625                              FcConfigAppFontAddDir
3626
3627 Name
3628
3629    FcConfigAppFontAddDir -- Add fonts from directory to font database
3630
3631 Synopsis
3632
3633    #include <fontconfig/fontconfig.h>
3634
3635
3636    FcBool FcConfigAppFontAddDir(FcConfig *config, const FcChar8 *dir);
3637
3638 Description
3639
3640    Scans the specified directory for fonts, adding each one found to the
3641    application-specific set of fonts. Returns FcFalse if the fonts cannot be
3642    added (due to allocation failure). Otherwise returns FcTrue. If config is
3643    NULL, the current configuration is used.
3644
3645                               FcConfigAppFontClear
3646
3647 Name
3648
3649    FcConfigAppFontClear -- Remove all app fonts from font database
3650
3651 Synopsis
3652
3653    #include <fontconfig/fontconfig.h>
3654
3655
3656    void FcConfigAppFontClear(FcConfig *config);
3657
3658 Description
3659
3660    Clears the set of application-specific fonts. If config is NULL, the
3661    current configuration is used.
3662
3663                            FcConfigSubstituteWithPat
3664
3665 Name
3666
3667    FcConfigSubstituteWithPat -- Execute substitutions
3668
3669 Synopsis
3670
3671    #include <fontconfig/fontconfig.h>
3672
3673
3674    FcBool FcConfigSubstituteWithPat(FcConfig *config, FcPattern *p, FcPattern
3675    *p_pat, FcMatchKind kind);
3676
3677 Description
3678
3679    Performs the sequence of pattern modification operations, if kind is
3680    FcMatchPattern, then those tagged as pattern operations are applied, else
3681    if kind is FcMatchFont, those tagged as font operations are applied and
3682    p_pat is used for <test> elements with target=pattern. Returns FcFalse if
3683    the substitution cannot be performed (due to allocation failure).
3684    Otherwise returns FcTrue. If config is NULL, the current configuration is
3685    used.
3686
3687                                FcConfigSubstitute
3688
3689 Name
3690
3691    FcConfigSubstitute -- Execute substitutions
3692
3693 Synopsis
3694
3695    #include <fontconfig/fontconfig.h>
3696
3697
3698    FcBool FcConfigSubstitute(FcConfig *config, FcPattern *p, FcMatchKind
3699    kind);
3700
3701 Description
3702
3703    Calls FcConfigSubstituteWithPat setting p_pat to NULL. Returns FcFalse if
3704    the substitution cannot be performed (due to allocation failure).
3705    Otherwise returns FcTrue. If config is NULL, the current configuration is
3706    used.
3707
3708                                   FcFontMatch
3709
3710 Name
3711
3712    FcFontMatch -- Return best font
3713
3714 Synopsis
3715
3716    #include <fontconfig/fontconfig.h>
3717
3718
3719    FcPattern * FcFontMatch(FcConfig *config, FcPattern *p, FcResult *result);
3720
3721 Description
3722
3723    Finds the font in sets most closely matching pattern and returns the
3724    result of FcFontRenderPrepare for that font and the provided pattern. This
3725    function should be called only after FcConfigSubstitute and
3726    FcDefaultSubstitute have been called for p; otherwise the results will not
3727    be correct. If config is NULL, the current configuration is used.
3728
3729                                    FcFontSort
3730
3731 Name
3732
3733    FcFontSort -- Return list of matching fonts
3734
3735 Synopsis
3736
3737    #include <fontconfig/fontconfig.h>
3738
3739
3740    FcFontSet * FcFontSort(FcConfig *config, FcPattern *p, FcBool trim,
3741    FcCharSet **csp, FcResult *result);
3742
3743 Description
3744
3745    Returns the list of fonts sorted by closeness to p. If trim is FcTrue,
3746    elements in the list which don't include Unicode coverage not provided by
3747    earlier elements in the list are elided. The union of Unicode coverage of
3748    all of the fonts is returned in csp, if csp is not NULL. This function
3749    should be called only after FcConfigSubstitute and FcDefaultSubstitute
3750    have been called for p; otherwise the results will not be correct.
3751
3752    The returned FcFontSet references FcPattern structures which may be shared
3753    by the return value from multiple FcFontSort calls, applications must not
3754    modify these patterns. Instead, they should be passed, along with p to
3755    FcFontRenderPrepare which combines them into a complete pattern.
3756
3757    The FcFontSet returned by FcFontSort is destroyed by calling
3758    FcFontSetDestroy. If config is NULL, the current configuration is used.
3759
3760                               FcFontRenderPrepare
3761
3762 Name
3763
3764    FcFontRenderPrepare -- Prepare pattern for loading font file
3765
3766 Synopsis
3767
3768    #include <fontconfig/fontconfig.h>
3769
3770
3771    FcPattern * FcFontRenderPrepare(FcConfig *config, FcPattern *pat,
3772    FcPattern *font);
3773
3774 Description
3775
3776    Creates a new pattern consisting of elements of font not appearing in pat,
3777    elements of pat not appearing in font and the best matching value from pat
3778    for elements appearing in both. The result is passed to
3779    FcConfigSubstituteWithPat with kind FcMatchFont and then returned.
3780
3781                                    FcFontList
3782
3783 Name
3784
3785    FcFontList -- List fonts
3786
3787 Synopsis
3788
3789    #include <fontconfig/fontconfig.h>
3790
3791
3792    FcFontSet * FcFontList(FcConfig *config, FcPattern *p, FcObjectSet *os);
3793
3794 Description
3795
3796    Selects fonts matching p, creates patterns from those fonts containing
3797    only the objects in os and returns the set of unique such patterns. If
3798    config is NULL, the default configuration is checked to be up to date, and
3799    used.
3800
3801                                 FcConfigFilename
3802
3803 Name
3804
3805    FcConfigFilename -- Find a config file
3806
3807 Synopsis
3808
3809    #include <fontconfig/fontconfig.h>
3810
3811
3812    FcChar8 * FcConfigFilename(const FcChar8 *name);
3813
3814 Description
3815
3816    Given the specified external entity name, return the associated filename.
3817    This provides applications a way to convert various configuration file
3818    references into filename form.
3819
3820    A null or empty name indicates that the default configuration file should
3821    be used; which file this references can be overridden with the
3822    FONTCONFIG_FILE environment variable. Next, if the name starts with ~, it
3823    refers to a file in the current users home directory. Otherwise if the
3824    name doesn't start with '/', it refers to a file in the default
3825    configuration directory; the built-in default directory can be overridden
3826    with the FONTCONFIG_PATH environment variable.
3827
3828                               FcConfigParseAndLoad
3829
3830 Name
3831
3832    FcConfigParseAndLoad -- load a configuration file
3833
3834 Synopsis
3835
3836    #include <fontconfig/fontconfig.h>
3837
3838
3839    FcBool FcConfigParseAndLoad(FcConfig *config, const FcChar8 *file, FcBool
3840    complain);
3841
3842 Description
3843
3844    Walks the configuration in 'file' and constructs the internal
3845    representation in 'config'. Any include files referenced from within
3846    'file' will be loaded and parsed. If 'complain' is FcFalse, no warning
3847    will be displayed if 'file' does not exist. Error and warning messages
3848    will be output to stderr. Returns FcFalse if some error occurred while
3849    loading the file, either a parse error, semantic error or allocation
3850    failure. Otherwise returns FcTrue.
3851
3852                          FcConfigParseAndLoadFromMemory
3853
3854 Name
3855
3856    FcConfigParseAndLoadFromMemory -- load a configuration from memory
3857
3858 Synopsis
3859
3860    #include <fontconfig/fontconfig.h>
3861
3862
3863    FcBool FcConfigParseAndLoadFromMemory(FcConfig *config, const FcChar8
3864    *buffer, FcBool complain);
3865
3866 Description
3867
3868    Walks the configuration in 'memory' and constructs the internal
3869    representation in 'config'. Any includes files referenced from within
3870    'memory' will be loaded and dparsed. If 'complain' is FcFalse, no warning
3871    will be displayed if 'file' does not exist. Error and warning messages
3872    will be output to stderr. Returns FcFalse if fsome error occurred while
3873    loading the file, either a parse error, semantic error or allocation
3874    failure. Otherwise returns FcTrue.
3875
3876 Since
3877
3878    version 2.12.5
3879
3880                                FcConfigGetSysRoot
3881
3882 Name
3883
3884    FcConfigGetSysRoot -- Obtain the system root directory
3885
3886 Synopsis
3887
3888    #include <fontconfig/fontconfig.h>
3889
3890
3891    const FcChar8 * FcConfigGetSysRoot(const FcConfig *config);
3892
3893 Description
3894
3895    Obtrains the system root directory in 'config' if available.
3896
3897 Since
3898
3899    version 2.10.92
3900
3901                                FcConfigSetSysRoot
3902
3903 Name
3904
3905    FcConfigSetSysRoot -- Set the system root directory
3906
3907 Synopsis
3908
3909    #include <fontconfig/fontconfig.h>
3910
3911
3912    void FcConfigSetSysRoot(FcConfig *config, const FcChar8 *sysroot);
3913
3914 Description
3915
3916    Set 'sysroot' as the system root directory. fontconfig prepend 'sysroot'
3917    to the cache directories in order to allow people to generate caches at
3918    the build time. Note that this causes changing current config. i.e. this
3919    function calls FcConfigSetCurrent() internally.
3920
3921 Since
3922
3923    version 2.10.92
3924
3925                             FcConfigFileInfoIterInit
3926
3927 Name
3928
3929    FcConfigFileInfoIterInit -- Initialize the iterator
3930
3931 Synopsis
3932
3933    #include <fontconfig/fontconfig.h>
3934
3935
3936    void FcConfigFileInfoIterInit(FcConfig *config, FcConfigFileInfoIter
3937    *iter);
3938
3939 Description
3940
3941    Initialize 'iter' with the first iterator in the config file information
3942    list.
3943
3944 Since
3945
3946    version 2.12.91
3947
3948                             FcConfigFileInfoIterNext
3949
3950 Name
3951
3952    FcConfigFileInfoIterNext -- Set the iterator to point to the next list
3953
3954 Synopsis
3955
3956    #include <fontconfig/fontconfig.h>
3957
3958
3959    FcBool FcConfigFileInfoIterNext(FcConfig *config, FcConfigFileInfoIter
3960    *iter);
3961
3962 Description
3963
3964    Set 'iter' to point to the next node in the config file information list.
3965    If there is no next node, FcFalse is returned.
3966
3967 Since
3968
3969    version 2.12.91
3970
3971                             FcConfigFileInfoIterGet
3972
3973 Name
3974
3975    FcConfigFileInfoIterGet -- Obtain the configuration file information
3976
3977 Synopsis
3978
3979    #include <fontconfig/fontconfig.h>
3980
3981
3982    FcBool FcConfigFileInfoIterGet(FcConfig *config, FcConfigFileInfoIter
3983    *iter, FcChar8 **name, FcChar8 **description, FcBool *enabled);
3984
3985 Description
3986
3987    Obtain the filename, the description and the flag whether it is enabled or
3988    not for 'iter' where points to current configuration file information. If
3989    the iterator is invalid, FcFalse is returned.
3990
3991 Since
3992
3993    version 2.12.91
3994
3995    --------------------------------------------------------------------------
3996
3997   FcObjectType
3998
3999    Table of Contents
4000
4001    [148]FcNameRegisterObjectTypes -- Register object types
4002
4003    [149]FcNameUnregisterObjectTypes -- Unregister object types
4004
4005    [150]FcNameGetObjectType -- Lookup an object type
4006
4007    Provides for application-specified font name object types so that new
4008    pattern elements can be generated from font names.
4009
4010                            FcNameRegisterObjectTypes
4011
4012 Name
4013
4014    FcNameRegisterObjectTypes -- Register object types
4015
4016 Synopsis
4017
4018    #include <fontconfig/fontconfig.h>
4019
4020
4021    FcBool FcNameRegisterObjectTypes(const FcObjectType *types, int ntype);
4022
4023 Description
4024
4025    Deprecated. Does nothing. Returns FcFalse.
4026
4027                           FcNameUnregisterObjectTypes
4028
4029 Name
4030
4031    FcNameUnregisterObjectTypes -- Unregister object types
4032
4033 Synopsis
4034
4035    #include <fontconfig/fontconfig.h>
4036
4037
4038    FcBool FcNameUnregisterObjectTypes(const FcObjectType *types, int ntype);
4039
4040 Description
4041
4042    Deprecated. Does nothing. Returns FcFalse.
4043
4044                               FcNameGetObjectType
4045
4046 Name
4047
4048    FcNameGetObjectType -- Lookup an object type
4049
4050 Synopsis
4051
4052    #include <fontconfig/fontconfig.h>
4053
4054
4055    const FcObjectType * FcNameGetObjectType(const char *object);
4056
4057 Description
4058
4059    Return the object type for the pattern element named object.
4060
4061    --------------------------------------------------------------------------
4062
4063   FcConstant
4064
4065    Table of Contents
4066
4067    [151]FcNameRegisterConstants -- Register symbolic constants
4068
4069    [152]FcNameUnregisterConstants -- Unregister symbolic constants
4070
4071    [153]FcNameGetConstant -- Lookup symbolic constant
4072
4073    [154]FcNameConstant -- Get the value for a symbolic constant
4074
4075    Provides for application-specified symbolic constants for font names.
4076
4077                             FcNameRegisterConstants
4078
4079 Name
4080
4081    FcNameRegisterConstants -- Register symbolic constants
4082
4083 Synopsis
4084
4085    #include <fontconfig/fontconfig.h>
4086
4087
4088    FcBool FcNameRegisterConstants(const FcConstant *consts, int nconsts);
4089
4090 Description
4091
4092    Deprecated. Does nothing. Returns FcFalse.
4093
4094                            FcNameUnregisterConstants
4095
4096 Name
4097
4098    FcNameUnregisterConstants -- Unregister symbolic constants
4099
4100 Synopsis
4101
4102    #include <fontconfig/fontconfig.h>
4103
4104
4105    FcBool FcNameUnregisterConstants(const FcConstant *consts, int nconsts);
4106
4107 Description
4108
4109    Deprecated. Does nothing. Returns FcFalse.
4110
4111                                FcNameGetConstant
4112
4113 Name
4114
4115    FcNameGetConstant -- Lookup symbolic constant
4116
4117 Synopsis
4118
4119    #include <fontconfig/fontconfig.h>
4120
4121
4122    const FcConstant * FcNameGetConstant(FcChar8 *string);
4123
4124 Description
4125
4126    Return the FcConstant structure related to symbolic constant string.
4127
4128                                  FcNameConstant
4129
4130 Name
4131
4132    FcNameConstant -- Get the value for a symbolic constant
4133
4134 Synopsis
4135
4136    #include <fontconfig/fontconfig.h>
4137
4138
4139    FcBool FcNameConstant(FcChar8 *string, int *result);
4140
4141 Description
4142
4143    Returns whether a symbolic constant with name string is registered,
4144    placing the value of the constant in result if present.
4145
4146    --------------------------------------------------------------------------
4147
4148   FcWeight
4149
4150    Table of Contents
4151
4152    [155]FcWeightFromOpenTypeDouble -- Convert from OpenType weight values to
4153    fontconfig ones
4154
4155    [156]FcWeightToOpenTypeDouble -- Convert from fontconfig weight values to
4156    OpenType ones
4157
4158    [157]FcWeightFromOpenType -- Convert from OpenType weight values to
4159    fontconfig ones
4160
4161    [158]FcWeightToOpenType -- Convert from fontconfig weight values to
4162    OpenType ones
4163
4164    Maps weights to and from OpenType weights.
4165
4166                            FcWeightFromOpenTypeDouble
4167
4168 Name
4169
4170    FcWeightFromOpenTypeDouble -- Convert from OpenType weight values to
4171    fontconfig ones
4172
4173 Synopsis
4174
4175    #include <fontconfig/fontconfig.h>
4176
4177
4178    double FcWeightFromOpenTypeDouble(doubleot_weight);
4179
4180 Description
4181
4182    FcWeightFromOpenTypeDouble returns an double value to use with FC_WEIGHT,
4183    from an double in the 1..1000 range, resembling the numbers from OpenType
4184    specification's OS/2 usWeight numbers, which are also similar to CSS
4185    font-weight numbers. If input is negative, zero, or greater than 1000,
4186    returns -1. This function linearly doubleerpolates between various
4187    FC_WEIGHT_* constants. As such, the returned value does not necessarily
4188    match any of the predefined constants.
4189
4190 Since
4191
4192    version 2.12.92
4193
4194                             FcWeightToOpenTypeDouble
4195
4196 Name
4197
4198    FcWeightToOpenTypeDouble -- Convert from fontconfig weight values to
4199    OpenType ones
4200
4201 Synopsis
4202
4203    #include <fontconfig/fontconfig.h>
4204
4205
4206    double FcWeightToOpenTypeDouble(doubleot_weight);
4207
4208 Description
4209
4210    FcWeightToOpenTypeDouble is the inverse of FcWeightFromOpenType. If the
4211    input is less than FC_WEIGHT_THIN or greater than FC_WEIGHT_EXTRABLACK,
4212    returns -1. Otherwise returns a number in the range 1 to 1000.
4213
4214 Since
4215
4216    version 2.12.92
4217
4218                               FcWeightFromOpenType
4219
4220 Name
4221
4222    FcWeightFromOpenType -- Convert from OpenType weight values to fontconfig
4223    ones
4224
4225 Synopsis
4226
4227    #include <fontconfig/fontconfig.h>
4228
4229
4230    int FcWeightFromOpenType(intot_weight);
4231
4232 Description
4233
4234    FcWeightFromOpenType is like FcWeightFromOpenTypeDouble but with integer
4235    arguments. Use the other function instead.
4236
4237 Since
4238
4239    version 2.11.91
4240
4241                                FcWeightToOpenType
4242
4243 Name
4244
4245    FcWeightToOpenType -- Convert from fontconfig weight values to OpenType
4246    ones
4247
4248 Synopsis
4249
4250    #include <fontconfig/fontconfig.h>
4251
4252
4253    int FcWeightToOpenType(intot_weight);
4254
4255 Description
4256
4257    FcWeightToOpenType is like FcWeightToOpenTypeDouble but with integer
4258    arguments. Use the other function instead.
4259
4260 Since
4261
4262    version 2.11.91
4263
4264    --------------------------------------------------------------------------
4265
4266   FcBlanks
4267
4268    Table of Contents
4269
4270    [159]FcBlanksCreate -- Create an FcBlanks
4271
4272    [160]FcBlanksDestroy -- Destroy and FcBlanks
4273
4274    [161]FcBlanksAdd -- Add a character to an FcBlanks
4275
4276    [162]FcBlanksIsMember -- Query membership in an FcBlanks
4277
4278    An FcBlanks object holds a list of Unicode chars which are expected to be
4279    blank when drawn. When scanning new fonts, any glyphs which are empty and
4280    not in this list will be assumed to be broken and not placed in the
4281    FcCharSet associated with the font. This provides a significantly more
4282    accurate CharSet for applications.
4283
4284    FcBlanks is deprecated and should not be used in newly written code. It is
4285    still accepted by some functions for compatibility with older code but
4286    will be removed in the future.
4287
4288                                  FcBlanksCreate
4289
4290 Name
4291
4292    FcBlanksCreate -- Create an FcBlanks
4293
4294 Synopsis
4295
4296    #include <fontconfig/fontconfig.h>
4297
4298
4299    FcBlanks * FcBlanksCreate(void);
4300
4301 Description
4302
4303    FcBlanks is deprecated. This function always returns NULL.
4304
4305                                 FcBlanksDestroy
4306
4307 Name
4308
4309    FcBlanksDestroy -- Destroy and FcBlanks
4310
4311 Synopsis
4312
4313    #include <fontconfig/fontconfig.h>
4314
4315
4316    void FcBlanksDestroy(FcBlanks *b);
4317
4318 Description
4319
4320    FcBlanks is deprecated. This function does nothing.
4321
4322                                   FcBlanksAdd
4323
4324 Name
4325
4326    FcBlanksAdd -- Add a character to an FcBlanks
4327
4328 Synopsis
4329
4330    #include <fontconfig/fontconfig.h>
4331
4332
4333    FcBool FcBlanksAdd(FcBlanks *b, FcChar32 ucs4);
4334
4335 Description
4336
4337    FcBlanks is deprecated. This function always returns FALSE.
4338
4339                                 FcBlanksIsMember
4340
4341 Name
4342
4343    FcBlanksIsMember -- Query membership in an FcBlanks
4344
4345 Synopsis
4346
4347    #include <fontconfig/fontconfig.h>
4348
4349
4350    FcBool FcBlanksIsMember(FcBlanks *b, FcChar32 ucs4);
4351
4352 Description
4353
4354    FcBlanks is deprecated. This function always returns FALSE.
4355
4356    --------------------------------------------------------------------------
4357
4358   FcAtomic
4359
4360    Table of Contents
4361
4362    [163]FcAtomicCreate -- create an FcAtomic object
4363
4364    [164]FcAtomicLock -- lock a file
4365
4366    [165]FcAtomicNewFile -- return new temporary file name
4367
4368    [166]FcAtomicOrigFile -- return original file name
4369
4370    [167]FcAtomicReplaceOrig -- replace original with new
4371
4372    [168]FcAtomicDeleteNew -- delete new file
4373
4374    [169]FcAtomicUnlock -- unlock a file
4375
4376    [170]FcAtomicDestroy -- destroy an FcAtomic object
4377
4378    These functions provide a safe way to update configuration files, allowing
4379    ongoing reading of the old configuration file while locked for writing and
4380    ensuring that a consistent and complete version of the configuration file
4381    is always available.
4382
4383                                  FcAtomicCreate
4384
4385 Name
4386
4387    FcAtomicCreate -- create an FcAtomic object
4388
4389 Synopsis
4390
4391    #include <fontconfig/fontconfig.h>
4392
4393
4394    FcAtomic * FcAtomicCreate(const FcChar8 *file);
4395
4396 Description
4397
4398    Creates a data structure containing data needed to control access to file.
4399    Writing is done to a separate file. Once that file is complete, the
4400    original configuration file is atomically replaced so that reading process
4401    always see a consistent and complete file without the need to lock for
4402    reading.
4403
4404                                   FcAtomicLock
4405
4406 Name
4407
4408    FcAtomicLock -- lock a file
4409
4410 Synopsis
4411
4412    #include <fontconfig/fontconfig.h>
4413
4414
4415    FcBool FcAtomicLock(FcAtomic *atomic);
4416
4417 Description
4418
4419    Attempts to lock the file referenced by atomic. Returns FcFalse if the
4420    file is already locked, else returns FcTrue and leaves the file locked.
4421
4422                                 FcAtomicNewFile
4423
4424 Name
4425
4426    FcAtomicNewFile -- return new temporary file name
4427
4428 Synopsis
4429
4430    #include <fontconfig/fontconfig.h>
4431
4432
4433    FcChar8 * FcAtomicNewFile(FcAtomic *atomic);
4434
4435 Description
4436
4437    Returns the filename for writing a new version of the file referenced by
4438    atomic.
4439
4440                                 FcAtomicOrigFile
4441
4442 Name
4443
4444    FcAtomicOrigFile -- return original file name
4445
4446 Synopsis
4447
4448    #include <fontconfig/fontconfig.h>
4449
4450
4451    FcChar8 * FcAtomicOrigFile(FcAtomic *atomic);
4452
4453 Description
4454
4455    Returns the file referenced by atomic.
4456
4457                               FcAtomicReplaceOrig
4458
4459 Name
4460
4461    FcAtomicReplaceOrig -- replace original with new
4462
4463 Synopsis
4464
4465    #include <fontconfig/fontconfig.h>
4466
4467
4468    FcBool FcAtomicReplaceOrig(FcAtomic *atomic);
4469
4470 Description
4471
4472    Replaces the original file referenced by atomic with the new file. Returns
4473    FcFalse if the file cannot be replaced due to permission issues in the
4474    filesystem. Otherwise returns FcTrue.
4475
4476                                FcAtomicDeleteNew
4477
4478 Name
4479
4480    FcAtomicDeleteNew -- delete new file
4481
4482 Synopsis
4483
4484    #include <fontconfig/fontconfig.h>
4485
4486
4487    void FcAtomicDeleteNew(FcAtomic *atomic);
4488
4489 Description
4490
4491    Deletes the new file. Used in error recovery to back out changes.
4492
4493                                  FcAtomicUnlock
4494
4495 Name
4496
4497    FcAtomicUnlock -- unlock a file
4498
4499 Synopsis
4500
4501    #include <fontconfig/fontconfig.h>
4502
4503
4504    void FcAtomicUnlock(FcAtomic *atomic);
4505
4506 Description
4507
4508    Unlocks the file.
4509
4510                                 FcAtomicDestroy
4511
4512 Name
4513
4514    FcAtomicDestroy -- destroy an FcAtomic object
4515
4516 Synopsis
4517
4518    #include <fontconfig/fontconfig.h>
4519
4520
4521    void FcAtomicDestroy(FcAtomic *atomic);
4522
4523 Description
4524
4525    Destroys atomic.
4526
4527    --------------------------------------------------------------------------
4528
4529   File and Directory routines
4530
4531    Table of Contents
4532
4533    [171]FcFileScan -- scan a font file
4534
4535    [172]FcFileIsDir -- check whether a file is a directory
4536
4537    [173]FcDirScan -- scan a font directory without caching it
4538
4539    [174]FcDirSave -- DEPRECATED: formerly used to save a directory cache
4540
4541    [175]FcDirCacheUnlink -- Remove all caches related to dir
4542
4543    [176]FcDirCacheValid -- check directory cache
4544
4545    [177]FcDirCacheLoad -- load a directory cache
4546
4547    [178]FcDirCacheRescan -- Re-scan a directory cache
4548
4549    [179]FcDirCacheRead -- read or construct a directory cache
4550
4551    [180]FcDirCacheLoadFile -- load a cache file
4552
4553    [181]FcDirCacheUnload -- unload a cache file
4554
4555    These routines work with font files and directories, including font
4556    directory cache files.
4557
4558                                    FcFileScan
4559
4560 Name
4561
4562    FcFileScan -- scan a font file
4563
4564 Synopsis
4565
4566    #include <fontconfig/fontconfig.h>
4567
4568
4569    FcBool FcFileScan(FcFontSet *set, FcStrSet *dirs, FcFileCache *cache,
4570    FcBlanks *blanks, const FcChar8 *file, FcBool force);
4571
4572 Description
4573
4574    Scans a single file and adds all fonts found to set. If force is FcTrue,
4575    then the file is scanned even if associated information is found in cache.
4576    If file is a directory, it is added to dirs. Whether fonts are found
4577    depends on fontconfig policy as well as the current configuration.
4578    Internally, fontconfig will ignore BDF and PCF fonts which are not in
4579    Unicode (or the effectively equivalent ISO Latin-1) encoding as those are
4580    not usable by Unicode-based applications. The configuration can ignore
4581    fonts based on filename or contents of the font file itself. Returns
4582    FcFalse if any of the fonts cannot be added (due to allocation failure).
4583    Otherwise returns FcTrue.
4584
4585                                   FcFileIsDir
4586
4587 Name
4588
4589    FcFileIsDir -- check whether a file is a directory
4590
4591 Synopsis
4592
4593    #include <fontconfig/fontconfig.h>
4594
4595
4596    FcBool FcFileIsDir(const FcChar8 *file);
4597
4598 Description
4599
4600    Returns FcTrue if file is a directory, otherwise returns FcFalse.
4601
4602                                    FcDirScan
4603
4604 Name
4605
4606    FcDirScan -- scan a font directory without caching it
4607
4608 Synopsis
4609
4610    #include <fontconfig/fontconfig.h>
4611
4612
4613    FcBool FcDirScan(FcFontSet *set, FcStrSet *dirs, FcFileCache *cache,
4614    FcBlanks *blanks, const FcChar8 *dir, FcBool force);
4615
4616 Description
4617
4618    If cache is not zero or if force is FcFalse, this function currently
4619    returns FcFalse. Otherwise, it scans an entire directory and adds all
4620    fonts found to set. Any subdirectories found are added to dirs. Calling
4621    this function does not create any cache files. Use FcDirCacheRead() if
4622    caching is desired.
4623
4624                                    FcDirSave
4625
4626 Name
4627
4628    FcDirSave -- DEPRECATED: formerly used to save a directory cache
4629
4630 Synopsis
4631
4632    #include <fontconfig/fontconfig.h>
4633
4634
4635    FcBool FcDirSave(FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
4636
4637 Description
4638
4639    This function now does nothing aside from returning FcFalse. It used to
4640    creates the per-directory cache file for dir and populates it with the
4641    fonts in set and subdirectories in dirs. All of this functionality is now
4642    automatically managed by FcDirCacheLoad and FcDirCacheRead.
4643
4644                                 FcDirCacheUnlink
4645
4646 Name
4647
4648    FcDirCacheUnlink -- Remove all caches related to dir
4649
4650 Synopsis
4651
4652    #include <fontconfig/fontconfig.h>
4653
4654
4655    FcBool FcDirCacheUnlink(const FcChar8 *dir, FcConfig *config);
4656
4657 Description
4658
4659    Scans the cache directories in config, removing any instances of the cache
4660    file for dir. Returns FcFalse when some internal error occurs (out of
4661    memory, etc). Errors actually unlinking any files are ignored.
4662
4663                                 FcDirCacheValid
4664
4665 Name
4666
4667    FcDirCacheValid -- check directory cache
4668
4669 Synopsis
4670
4671    #include <fontconfig/fontconfig.h>
4672
4673
4674    FcBool FcDirCacheValid(const FcChar8 *dir);
4675
4676 Description
4677
4678    Returns FcTrue if dir has an associated valid cache file, else returns
4679    FcFalse
4680
4681                                  FcDirCacheLoad
4682
4683 Name
4684
4685    FcDirCacheLoad -- load a directory cache
4686
4687 Synopsis
4688
4689    #include <fontconfig/fontconfig.h>
4690
4691
4692    FcCache * FcDirCacheLoad(const FcChar8 *dir, FcConfig *config, FcChar8
4693    **cache_file);
4694
4695 Description
4696
4697    Loads the cache related to dir. If no cache file exists, returns NULL. The
4698    name of the cache file is returned in cache_file, unless that is NULL. See
4699    also FcDirCacheRead.
4700
4701                                 FcDirCacheRescan
4702
4703 Name
4704
4705    FcDirCacheRescan -- Re-scan a directory cache
4706
4707 Synopsis
4708
4709    #include <fontconfig/fontconfig.h>
4710
4711
4712    FcCache * FcDirCacheRescan(const FcChar8 *dir, FcConfig *config);
4713
4714 Description
4715
4716    Re-scan directories only at dir and update the cache. returns NULL if
4717    failed.
4718
4719 Since
4720
4721    version 2.11.1
4722
4723                                  FcDirCacheRead
4724
4725 Name
4726
4727    FcDirCacheRead -- read or construct a directory cache
4728
4729 Synopsis
4730
4731    #include <fontconfig/fontconfig.h>
4732
4733
4734    FcCache * FcDirCacheRead(const FcChar8 *dir, FcBool force, FcConfig
4735    *config);
4736
4737 Description
4738
4739    This returns a cache for dir. If force is FcFalse, then an existing, valid
4740    cache file will be used. Otherwise, a new cache will be created by
4741    scanning the directory and that returned.
4742
4743                                FcDirCacheLoadFile
4744
4745 Name
4746
4747    FcDirCacheLoadFile -- load a cache file
4748
4749 Synopsis
4750
4751    #include <fontconfig/fontconfig.h>
4752
4753
4754    FcCache * FcDirCacheLoadFile(const FcChar8 *cache_file, struct stat
4755    *file_stat);
4756
4757 Description
4758
4759    This function loads a directory cache from cache_file. If file_stat is
4760    non-NULL, it will be filled with the results of stat(2) on the cache file.
4761
4762                                 FcDirCacheUnload
4763
4764 Name
4765
4766    FcDirCacheUnload -- unload a cache file
4767
4768 Synopsis
4769
4770    #include <fontconfig/fontconfig.h>
4771
4772
4773    void FcDirCacheUnload(FcCache *cache);
4774
4775 Description
4776
4777    This function dereferences cache. When no other references to it remain,
4778    all memory associated with the cache will be freed.
4779
4780    --------------------------------------------------------------------------
4781
4782   FcCache routines
4783
4784    Table of Contents
4785
4786    [182]FcCacheDir -- Return directory of cache
4787
4788    [183]FcCacheCopySet -- Returns a copy of the fontset from cache
4789
4790    [184]FcCacheSubdir -- Return the i'th subdirectory.
4791
4792    [185]FcCacheNumSubdir -- Return the number of subdirectories in cache.
4793
4794    [186]FcCacheNumFont -- Returns the number of fonts in cache.
4795
4796    [187]FcDirCacheClean -- Clean up a cache directory
4797
4798    [188]FcCacheCreateTagFile -- Create CACHEDIR.TAG at cache directory.
4799
4800    [189]FcDirCacheCreateUUID -- Create .uuid file at a directory
4801
4802    [190]FcDirCacheDeleteUUID -- Delete .uuid file
4803
4804    These routines work with font directory caches, accessing their contents
4805    in limited ways. It is not expected that normal applications will need to
4806    use these functions.
4807
4808                                    FcCacheDir
4809
4810 Name
4811
4812    FcCacheDir -- Return directory of cache
4813
4814 Synopsis
4815
4816    #include <fontconfig/fontconfig.h>
4817
4818
4819    const FcChar8 * FcCacheDir(const FcCache *cache);
4820
4821 Description
4822
4823    This function returns the directory from which the cache was constructed.
4824
4825                                  FcCacheCopySet
4826
4827 Name
4828
4829    FcCacheCopySet -- Returns a copy of the fontset from cache
4830
4831 Synopsis
4832
4833    #include <fontconfig/fontconfig.h>
4834
4835
4836    FcFontSet * FcCacheCopySet(const FcCache *cache);
4837
4838 Description
4839
4840    The returned fontset contains each of the font patterns from cache. This
4841    fontset may be modified, but the patterns from the cache are read-only.
4842
4843                                  FcCacheSubdir
4844
4845 Name
4846
4847    FcCacheSubdir -- Return the i'th subdirectory.
4848
4849 Synopsis
4850
4851    #include <fontconfig/fontconfig.h>
4852
4853
4854    const FcChar8 * FcCacheSubdir(const FcCache *cache, inti);
4855
4856 Description
4857
4858    The set of subdirectories stored in a cache file are indexed by this
4859    function, i should range from 0 to n-1, where n is the return value from
4860    FcCacheNumSubdir.
4861
4862                                 FcCacheNumSubdir
4863
4864 Name
4865
4866    FcCacheNumSubdir -- Return the number of subdirectories in cache.
4867
4868 Synopsis
4869
4870    #include <fontconfig/fontconfig.h>
4871
4872
4873    int FcCacheNumSubdir(const FcCache *cache);
4874
4875 Description
4876
4877    This returns the total number of subdirectories in the cache.
4878
4879                                  FcCacheNumFont
4880
4881 Name
4882
4883    FcCacheNumFont -- Returns the number of fonts in cache.
4884
4885 Synopsis
4886
4887    #include <fontconfig/fontconfig.h>
4888
4889
4890    int FcCacheNumFont(const FcCache *cache);
4891
4892 Description
4893
4894    This returns the number of fonts which would be included in the return
4895    from FcCacheCopySet.
4896
4897                                 FcDirCacheClean
4898
4899 Name
4900
4901    FcDirCacheClean -- Clean up a cache directory
4902
4903 Synopsis
4904
4905    #include <fontconfig/fontconfig.h>
4906
4907
4908    FcBool FcDirCacheClean(const FcChar8 *cache_dir, FcBoolverbose);
4909
4910 Description
4911
4912    This tries to clean up the cache directory of cache_dir. This returns
4913    FcTrue if the operation is successfully complete. otherwise FcFalse.
4914
4915 Since
4916
4917    version 2.9.91
4918
4919                               FcCacheCreateTagFile
4920
4921 Name
4922
4923    FcCacheCreateTagFile -- Create CACHEDIR.TAG at cache directory.
4924
4925 Synopsis
4926
4927    #include <fontconfig/fontconfig.h>
4928
4929
4930    void FcCacheCreateTagFile(const FcConfig *config);
4931
4932 Description
4933
4934    This tries to create CACHEDIR.TAG file at the cache directory registered
4935    to config.
4936
4937 Since
4938
4939    version 2.9.91
4940
4941                               FcDirCacheCreateUUID
4942
4943 Name
4944
4945    FcDirCacheCreateUUID -- Create .uuid file at a directory
4946
4947 Synopsis
4948
4949    #include <fontconfig/fontconfig.h>
4950
4951
4952    FcBool FcDirCacheCreateUUID(FcChar8 *dir, FcBoolforce, FcConfig *config);
4953
4954 Description
4955
4956    This is to create .uuid file containing an UUID at a font directory of
4957    dir. The UUID will be used to identify the font directory and is used to
4958    determine the cache filename if available.
4959
4960 Since
4961
4962    version 2.12.92
4963
4964                               FcDirCacheDeleteUUID
4965
4966 Name
4967
4968    FcDirCacheDeleteUUID -- Delete .uuid file
4969
4970 Synopsis
4971
4972    #include <fontconfig/fontconfig.h>
4973
4974
4975    FcBool FcDirCacheDeleteUUID(const FcChar8 *dir, FcConfig *config);
4976
4977 Description
4978
4979    This is to delete .uuid file containing an UUID at a font directory of
4980    dir.
4981
4982 Since
4983
4984    version 2.13.1
4985
4986    --------------------------------------------------------------------------
4987
4988   FcStrSet and FcStrList
4989
4990    Table of Contents
4991
4992    [191]FcStrSetCreate -- create a string set
4993
4994    [192]FcStrSetMember -- check set for membership
4995
4996    [193]FcStrSetEqual -- check sets for equality
4997
4998    [194]FcStrSetAdd -- add to a string set
4999
5000    [195]FcStrSetAddFilename -- add a filename to a string set
5001
5002    [196]FcStrSetDel -- delete from a string set
5003
5004    [197]FcStrSetDestroy -- destroy a string set
5005
5006    [198]FcStrListCreate -- create a string iterator
5007
5008    [199]FcStrListFirst -- get first string in iteration
5009
5010    [200]FcStrListNext -- get next string in iteration
5011
5012    [201]FcStrListDone -- destroy a string iterator
5013
5014    A data structure for enumerating strings, used to list directories while
5015    scanning the configuration as directories are added while scanning.
5016
5017                                  FcStrSetCreate
5018
5019 Name
5020
5021    FcStrSetCreate -- create a string set
5022
5023 Synopsis
5024
5025    #include <fontconfig/fontconfig.h>
5026
5027
5028    FcStrSet * FcStrSetCreate(void);
5029
5030 Description
5031
5032    Create an empty set.
5033
5034                                  FcStrSetMember
5035
5036 Name
5037
5038    FcStrSetMember -- check set for membership
5039
5040 Synopsis
5041
5042    #include <fontconfig/fontconfig.h>
5043
5044
5045    FcBool FcStrSetMember(FcStrSet *set, const FcChar8 *s);
5046
5047 Description
5048
5049    Returns whether s is a member of set.
5050
5051                                  FcStrSetEqual
5052
5053 Name
5054
5055    FcStrSetEqual -- check sets for equality
5056
5057 Synopsis
5058
5059    #include <fontconfig/fontconfig.h>
5060
5061
5062    FcBool FcStrSetEqual(FcStrSet *set_a, FcStrSet *set_b);
5063
5064 Description
5065
5066    Returns whether set_a contains precisely the same strings as set_b.
5067    Ordering of strings within the two sets is not considered.
5068
5069                                   FcStrSetAdd
5070
5071 Name
5072
5073    FcStrSetAdd -- add to a string set
5074
5075 Synopsis
5076
5077    #include <fontconfig/fontconfig.h>
5078
5079
5080    FcBool FcStrSetAdd(FcStrSet *set, const FcChar8 *s);
5081
5082 Description
5083
5084    Adds a copy of s to set.
5085
5086                               FcStrSetAddFilename
5087
5088 Name
5089
5090    FcStrSetAddFilename -- add a filename to a string set
5091
5092 Synopsis
5093
5094    #include <fontconfig/fontconfig.h>
5095
5096
5097    FcBool FcStrSetAddFilename(FcStrSet *set, const FcChar8 *s);
5098
5099 Description
5100
5101    Adds a copy s to set, The copy is created with FcStrCopyFilename so that
5102    leading '~' values are replaced with the value of the HOME environment
5103    variable.
5104
5105                                   FcStrSetDel
5106
5107 Name
5108
5109    FcStrSetDel -- delete from a string set
5110
5111 Synopsis
5112
5113    #include <fontconfig/fontconfig.h>
5114
5115
5116    FcBool FcStrSetDel(FcStrSet *set, const FcChar8 *s);
5117
5118 Description
5119
5120    Removes s from set, returning FcTrue if s was a member else FcFalse.
5121
5122                                 FcStrSetDestroy
5123
5124 Name
5125
5126    FcStrSetDestroy -- destroy a string set
5127
5128 Synopsis
5129
5130    #include <fontconfig/fontconfig.h>
5131
5132
5133    void FcStrSetDestroy(FcStrSet *set);
5134
5135 Description
5136
5137    Destroys set.
5138
5139                                 FcStrListCreate
5140
5141 Name
5142
5143    FcStrListCreate -- create a string iterator
5144
5145 Synopsis
5146
5147    #include <fontconfig/fontconfig.h>
5148
5149
5150    FcStrList * FcStrListCreate(FcStrSet *set);
5151
5152 Description
5153
5154    Creates an iterator to list the strings in set.
5155
5156                                  FcStrListFirst
5157
5158 Name
5159
5160    FcStrListFirst -- get first string in iteration
5161
5162 Synopsis
5163
5164    #include <fontconfig/fontconfig.h>
5165
5166
5167    void FcStrListFirst(FcStrList *list);
5168
5169 Description
5170
5171    Returns the first string in list.
5172
5173 Since
5174
5175    version 2.11.0
5176
5177                                  FcStrListNext
5178
5179 Name
5180
5181    FcStrListNext -- get next string in iteration
5182
5183 Synopsis
5184
5185    #include <fontconfig/fontconfig.h>
5186
5187
5188    FcChar8 * FcStrListNext(FcStrList *list);
5189
5190 Description
5191
5192    Returns the next string in list.
5193
5194                                  FcStrListDone
5195
5196 Name
5197
5198    FcStrListDone -- destroy a string iterator
5199
5200 Synopsis
5201
5202    #include <fontconfig/fontconfig.h>
5203
5204
5205    void FcStrListDone(FcStrList *list);
5206
5207 Description
5208
5209    Destroys the enumerator list.
5210
5211    --------------------------------------------------------------------------
5212
5213   String utilities
5214
5215    Table of Contents
5216
5217    [202]FcUtf8ToUcs4 -- convert UTF-8 to UCS4
5218
5219    [203]FcUcs4ToUtf8 -- convert UCS4 to UTF-8
5220
5221    [204]FcUtf8Len -- count UTF-8 encoded chars
5222
5223    [205]FcUtf16ToUcs4 -- convert UTF-16 to UCS4
5224
5225    [206]FcUtf16Len -- count UTF-16 encoded chars
5226
5227    [207]FcIsLower -- check for lower case ASCII character
5228
5229    [208]FcIsUpper -- check for upper case ASCII character
5230
5231    [209]FcToLower -- convert upper case ASCII to lower case
5232
5233    [210]FcStrCopy -- duplicate a string
5234
5235    [211]FcStrDowncase -- create a lower case translation of a string
5236
5237    [212]FcStrCopyFilename -- create a complete path from a filename
5238
5239    [213]FcStrCmp -- compare UTF-8 strings
5240
5241    [214]FcStrCmpIgnoreCase -- compare UTF-8 strings ignoring case
5242
5243    [215]FcStrStr -- locate UTF-8 substring
5244
5245    [216]FcStrStrIgnoreCase -- locate UTF-8 substring ignoring ASCII case
5246
5247    [217]FcStrPlus -- concatenate two strings
5248
5249    [218]FcStrFree -- free a string
5250
5251    [219]FcStrDirname -- directory part of filename
5252
5253    [220]FcStrBasename -- last component of filename
5254
5255    Fontconfig manipulates many UTF-8 strings represented with the FcChar8
5256    type. These functions are exposed to help applications deal with these
5257    UTF-8 strings in a locale-insensitive manner.
5258
5259                                   FcUtf8ToUcs4
5260
5261 Name
5262
5263    FcUtf8ToUcs4 -- convert UTF-8 to UCS4
5264
5265 Synopsis
5266
5267    #include <fontconfig/fontconfig.h>
5268
5269
5270    int FcUtf8ToUcs4(FcChar8 *src, FcChar32 *dst, int len);
5271
5272 Description
5273
5274    Converts the next Unicode char from src into dst and returns the number of
5275    bytes containing the char. src must be at least len bytes long.
5276
5277                                   FcUcs4ToUtf8
5278
5279 Name
5280
5281    FcUcs4ToUtf8 -- convert UCS4 to UTF-8
5282
5283 Synopsis
5284
5285    #include <fontconfig/fontconfig.h>
5286
5287
5288    int FcUcs4ToUtf8(FcChar32 src, FcChar8 dst[FC_UTF8_MAX_LEN]);
5289
5290 Description
5291
5292    Converts the Unicode char from src into dst and returns the number of
5293    bytes needed to encode the char.
5294
5295                                    FcUtf8Len
5296
5297 Name
5298
5299    FcUtf8Len -- count UTF-8 encoded chars
5300
5301 Synopsis
5302
5303    #include <fontconfig/fontconfig.h>
5304
5305
5306    FcBool FcUtf8Len(FcChar8 *src, int len, int *nchar, int *wchar);
5307
5308 Description
5309
5310    Counts the number of Unicode chars in len bytes of src. Places that count
5311    in nchar. wchar contains 1, 2 or 4 depending on the number of bytes needed
5312    to hold the largest Unicode char counted. The return value indicates
5313    whether src is a well-formed UTF8 string.
5314
5315                                  FcUtf16ToUcs4
5316
5317 Name
5318
5319    FcUtf16ToUcs4 -- convert UTF-16 to UCS4
5320
5321 Synopsis
5322
5323    #include <fontconfig/fontconfig.h>
5324
5325
5326    int FcUtf16ToUcs4(FcChar8 *src, FcEndian endian, FcChar32 *dst, int len);
5327
5328 Description
5329
5330    Converts the next Unicode char from src into dst and returns the number of
5331    bytes containing the char. src must be at least len bytes long. Bytes of
5332    src are combined into 16-bit units according to endian.
5333
5334                                    FcUtf16Len
5335
5336 Name
5337
5338    FcUtf16Len -- count UTF-16 encoded chars
5339
5340 Synopsis
5341
5342    #include <fontconfig/fontconfig.h>
5343
5344
5345    FcBool FcUtf16Len(FcChar8 *src, FcEndian endian, int len, int *nchar, int
5346    *wchar);
5347
5348 Description
5349
5350    Counts the number of Unicode chars in len bytes of src. Bytes of src are
5351    combined into 16-bit units according to endian. Places that count in
5352    nchar. wchar contains 1, 2 or 4 depending on the number of bytes needed to
5353    hold the largest Unicode char counted. The return value indicates whether
5354    string is a well-formed UTF16 string.
5355
5356                                    FcIsLower
5357
5358 Name
5359
5360    FcIsLower -- check for lower case ASCII character
5361
5362 Synopsis
5363
5364    #include <fontconfig/fontconfig.h>
5365
5366
5367    FcBool FcIsLower(FcChar8c);
5368
5369 Description
5370
5371    This macro checks whether c is an lower case ASCII letter.
5372
5373                                    FcIsUpper
5374
5375 Name
5376
5377    FcIsUpper -- check for upper case ASCII character
5378
5379 Synopsis
5380
5381    #include <fontconfig/fontconfig.h>
5382
5383
5384    FcBool FcIsUpper(FcChar8c);
5385
5386 Description
5387
5388    This macro checks whether c is a upper case ASCII letter.
5389
5390                                    FcToLower
5391
5392 Name
5393
5394    FcToLower -- convert upper case ASCII to lower case
5395
5396 Synopsis
5397
5398    #include <fontconfig/fontconfig.h>
5399
5400
5401    FcChar8 FcToLower(FcChar8c);
5402
5403 Description
5404
5405    This macro converts upper case ASCII c to the equivalent lower case
5406    letter.
5407
5408                                    FcStrCopy
5409
5410 Name
5411
5412    FcStrCopy -- duplicate a string
5413
5414 Synopsis
5415
5416    #include <fontconfig/fontconfig.h>
5417
5418
5419    FcChar8 * FcStrCopy(const FcChar8 *s);
5420
5421 Description
5422
5423    Allocates memory, copies s and returns the resulting buffer. Yes, this is
5424    strdup, but that function isn't available on every platform.
5425
5426                                  FcStrDowncase
5427
5428 Name
5429
5430    FcStrDowncase -- create a lower case translation of a string
5431
5432 Synopsis
5433
5434    #include <fontconfig/fontconfig.h>
5435
5436
5437    FcChar8 * FcStrDowncase(const FcChar8 *s);
5438
5439 Description
5440
5441    Allocates memory, copies s, converting upper case letters to lower case
5442    and returns the allocated buffer.
5443
5444                                FcStrCopyFilename
5445
5446 Name
5447
5448    FcStrCopyFilename -- create a complete path from a filename
5449
5450 Synopsis
5451
5452    #include <fontconfig/fontconfig.h>
5453
5454
5455    FcChar8 * FcStrCopyFilename(const FcChar8 *s);
5456
5457 Description
5458
5459    FcStrCopyFilename constructs an absolute pathname from s. It converts any
5460    leading '~' characters in to the value of the HOME environment variable,
5461    and any relative paths are converted to absolute paths using the current
5462    working directory. Sequences of '/' characters are converted to a single
5463    '/', and names containing the current directory '.' or parent directory
5464    '..' are correctly reconstructed. Returns NULL if '~' is the leading
5465    character and HOME is unset or disabled (see FcConfigEnableHome).
5466
5467                                     FcStrCmp
5468
5469 Name
5470
5471    FcStrCmp -- compare UTF-8 strings
5472
5473 Synopsis
5474
5475    #include <fontconfig/fontconfig.h>
5476
5477
5478    int FcStrCmp(const FcChar8 *s1, const FcChar8 *s2);
5479
5480 Description
5481
5482    Returns the usual <0, 0, >0 result of comparing s1 and s2.
5483
5484                                FcStrCmpIgnoreCase
5485
5486 Name
5487
5488    FcStrCmpIgnoreCase -- compare UTF-8 strings ignoring case
5489
5490 Synopsis
5491
5492    #include <fontconfig/fontconfig.h>
5493
5494
5495    int FcStrCmpIgnoreCase(const FcChar8 *s1, const FcChar8 *s2);
5496
5497 Description
5498
5499    Returns the usual <0, 0, >0 result of comparing s1 and s2. This test is
5500    case-insensitive for all proper UTF-8 encoded strings.
5501
5502                                     FcStrStr
5503
5504 Name
5505
5506    FcStrStr -- locate UTF-8 substring
5507
5508 Synopsis
5509
5510    #include <fontconfig/fontconfig.h>
5511
5512
5513    FcChar8 * FcStrStr(const FcChar8 *s1, const FcChar8 *s2);
5514
5515 Description
5516
5517    Returns the location of s2 in s1. Returns NULL if s2 is not present in s1.
5518    This test will operate properly with UTF8 encoded strings.
5519
5520                                FcStrStrIgnoreCase
5521
5522 Name
5523
5524    FcStrStrIgnoreCase -- locate UTF-8 substring ignoring ASCII case
5525
5526 Synopsis
5527
5528    #include <fontconfig/fontconfig.h>
5529
5530
5531    FcChar8 * FcStrStrIgnoreCase(const FcChar8 *s1, const FcChar8 *s2);
5532
5533 Description
5534
5535    Returns the location of s2 in s1, ignoring case. Returns NULL if s2 is not
5536    present in s1. This test is case-insensitive for all proper UTF-8 encoded
5537    strings.
5538
5539                                    FcStrPlus
5540
5541 Name
5542
5543    FcStrPlus -- concatenate two strings
5544
5545 Synopsis
5546
5547    #include <fontconfig/fontconfig.h>
5548
5549
5550    FcChar8 * FcStrPlus(const FcChar8 *s1, const FcChar8 *s2);
5551
5552 Description
5553
5554    This function allocates new storage and places the concatenation of s1 and
5555    s2 there, returning the new string.
5556
5557                                    FcStrFree
5558
5559 Name
5560
5561    FcStrFree -- free a string
5562
5563 Synopsis
5564
5565    #include <fontconfig/fontconfig.h>
5566
5567
5568    void FcStrFree(FcChar8 *s);
5569
5570 Description
5571
5572    This is just a wrapper around free(3) which helps track memory usage of
5573    strings within the fontconfig library.
5574
5575                                   FcStrDirname
5576
5577 Name
5578
5579    FcStrDirname -- directory part of filename
5580
5581 Synopsis
5582
5583    #include <fontconfig/fontconfig.h>
5584
5585
5586    FcChar8 * FcStrDirname(const FcChar8 *file);
5587
5588 Description
5589
5590    Returns the directory containing file. This is returned in newly allocated
5591    storage which should be freed when no longer needed.
5592
5593                                  FcStrBasename
5594
5595 Name
5596
5597    FcStrBasename -- last component of filename
5598
5599 Synopsis
5600
5601    #include <fontconfig/fontconfig.h>
5602
5603
5604    FcChar8 * FcStrBasename(const FcChar8 *file);
5605
5606 Description
5607
5608    Returns the filename of file stripped of any leading directory names. This
5609    is returned in newly allocated storage which should be freed when no
5610    longer needed.
5611
5612 References
5613
5614    Visible links
5615    1. file:///tmp/html-am902r#AEN16
5616    2. file:///tmp/html-am902r#AEN19
5617    3. file:///tmp/html-am902r#AEN31
5618    4. file:///tmp/html-am902r#AEN103
5619    5. file:///tmp/html-am902r#FCINITLOADCONFIG
5620    6. file:///tmp/html-am902r#FCINITLOADCONFIGANDFONTS
5621    7. file:///tmp/html-am902r#FCINIT
5622    8. file:///tmp/html-am902r#FCFINI
5623    9. file:///tmp/html-am902r#FCGETVERSION
5624   10. file:///tmp/html-am902r#FCINITREINITIALIZE
5625   11. file:///tmp/html-am902r#FCINITBRINGUPTODATE
5626   12. file:///tmp/html-am902r#FCPATTERNCREATE
5627   13. file:///tmp/html-am902r#FCPATTERNDUPLICATE
5628   14. file:///tmp/html-am902r#FCPATTERNREFERENCE
5629   15. file:///tmp/html-am902r#FCPATTERNDESTROY
5630   16. file:///tmp/html-am902r#FCPATTERNOBJECTCOUNT
5631   17. file:///tmp/html-am902r#FCPATTERNEQUAL
5632   18. file:///tmp/html-am902r#FCPATTERNEQUALSUBSET
5633   19. file:///tmp/html-am902r#FCPATTERNFILTER
5634   20. file:///tmp/html-am902r#FCPATTERNHASH
5635   21. file:///tmp/html-am902r#FCPATTERNADD
5636   22. file:///tmp/html-am902r#FCPATTERNADDWEAK
5637   23. file:///tmp/html-am902r#FCPATTERNADD-TYPE
5638   24. file:///tmp/html-am902r#FCPATTERNGETWITHBINDING
5639   25. file:///tmp/html-am902r#FCPATTERNGET
5640   26. file:///tmp/html-am902r#FCPATTERNGET-TYPE
5641   27. file:///tmp/html-am902r#FCPATTERNBUILD
5642   28. file:///tmp/html-am902r#FCPATTERNDEL
5643   29. file:///tmp/html-am902r#FCPATTERNREMOVE
5644   30. file:///tmp/html-am902r#FCPATTERNITERSTART
5645   31. file:///tmp/html-am902r#FCPATTERNITERNEXT
5646   32. file:///tmp/html-am902r#FCPATTERNITEREQUAL
5647   33. file:///tmp/html-am902r#FCPATTERNFINDITER
5648   34. file:///tmp/html-am902r#FCPATTERNITERISVALID
5649   35. file:///tmp/html-am902r#FCPATTERNITERGETOBJECT
5650   36. file:///tmp/html-am902r#FCPATTERNITERVALUECOUNT
5651   37. file:///tmp/html-am902r#FCPATTERNITERGETVALUE
5652   38. file:///tmp/html-am902r#FCPATTERNPRINT
5653   39. file:///tmp/html-am902r#FCDEFAULTSUBSTITUTE
5654   40. file:///tmp/html-am902r#FCNAMEPARSE
5655   41. file:///tmp/html-am902r#FCNAMEUNPARSE
5656   42. file:///tmp/html-am902r#FCPATTERNFORMAT
5657   43. file:///tmp/html-am902r#FCFONTSETCREATE
5658   44. file:///tmp/html-am902r#FCFONTSETDESTROY
5659   45. file:///tmp/html-am902r#FCFONTSETADD
5660   46. file:///tmp/html-am902r#FCFONTSETLIST
5661   47. file:///tmp/html-am902r#FCFONTSETMATCH
5662   48. file:///tmp/html-am902r#FCFONTSETPRINT
5663   49. file:///tmp/html-am902r#FCFONTSETSORT
5664   50. file:///tmp/html-am902r#FCFONTSETSORTDESTROY
5665   51. file:///tmp/html-am902r#FCOBJECTSETCREATE
5666   52. file:///tmp/html-am902r#FCOBJECTSETADD
5667   53. file:///tmp/html-am902r#FCOBJECTSETDESTROY
5668   54. file:///tmp/html-am902r#FCOBJECTSETBUILD
5669   55. file:///tmp/html-am902r#FCFREETYPECHARINDEX
5670   56. file:///tmp/html-am902r#FCFREETYPECHARSET
5671   57. file:///tmp/html-am902r#FCFREETYPECHARSETANDSPACING
5672   58. file:///tmp/html-am902r#FCFREETYPEQUERY
5673   59. file:///tmp/html-am902r#FCFREETYPEQUERYALL
5674   60. file:///tmp/html-am902r#FCFREETYPEQUERYFACE
5675   61. file:///tmp/html-am902r#FCVALUEDESTROY
5676   62. file:///tmp/html-am902r#FCVALUESAVE
5677   63. file:///tmp/html-am902r#FCVALUEPRINT
5678   64. file:///tmp/html-am902r#FCVALUEEQUAL
5679   65. file:///tmp/html-am902r#FCCHARSETCREATE
5680   66. file:///tmp/html-am902r#FCCHARSETDESTROY
5681   67. file:///tmp/html-am902r#FCCHARSETADDCHAR
5682   68. file:///tmp/html-am902r#FCCHARSETDELCHAR
5683   69. file:///tmp/html-am902r#FCCHARSETCOPY
5684   70. file:///tmp/html-am902r#FCCHARSETEQUAL
5685   71. file:///tmp/html-am902r#FCCHARSETINTERSECT
5686   72. file:///tmp/html-am902r#FCCHARSETUNION
5687   73. file:///tmp/html-am902r#FCCHARSETSUBTRACT
5688   74. file:///tmp/html-am902r#FCCHARSETMERGE
5689   75. file:///tmp/html-am902r#FCCHARSETHASCHAR
5690   76. file:///tmp/html-am902r#FCCHARSETCOUNT
5691   77. file:///tmp/html-am902r#FCCHARSETINTERSECTCOUNT
5692   78. file:///tmp/html-am902r#FCCHARSETSUBTRACTCOUNT
5693   79. file:///tmp/html-am902r#FCCHARSETISSUBSET
5694   80. file:///tmp/html-am902r#FCCHARSETFIRSTPAGE
5695   81. file:///tmp/html-am902r#FCCHARSETNEXTPAGE
5696   82. file:///tmp/html-am902r#FCCHARSETCOVERAGE
5697   83. file:///tmp/html-am902r#FCCHARSETNEW
5698   84. file:///tmp/html-am902r#FCLANGSETCREATE
5699   85. file:///tmp/html-am902r#FCLANGSETDESTROY
5700   86. file:///tmp/html-am902r#FCLANGSETCOPY
5701   87. file:///tmp/html-am902r#FCLANGSETADD
5702   88. file:///tmp/html-am902r#FCLANGSETDEL
5703   89. file:///tmp/html-am902r#FCLANGSETUNION
5704   90. file:///tmp/html-am902r#FCLANGSETSUBTRACT
5705   91. file:///tmp/html-am902r#FCLANGSETCOMPARE
5706   92. file:///tmp/html-am902r#FCLANGSETCONTAINS
5707   93. file:///tmp/html-am902r#FCLANGSETEQUAL
5708   94. file:///tmp/html-am902r#FCLANGSETHASH
5709   95. file:///tmp/html-am902r#FCLANGSETHASLANG
5710   96. file:///tmp/html-am902r#FCGETDEFAULTLANGS
5711   97. file:///tmp/html-am902r#FCLANGSETGETLANGS
5712   98. file:///tmp/html-am902r#FCGETLANGS
5713   99. file:///tmp/html-am902r#FCLANGNORMALIZE
5714  100. file:///tmp/html-am902r#FCLANGGETCHARSET
5715  101. file:///tmp/html-am902r#FCMATRIXINIT
5716  102. file:///tmp/html-am902r#FCMATRIXCOPY
5717  103. file:///tmp/html-am902r#FCMATRIXEQUAL
5718  104. file:///tmp/html-am902r#FCMATRIXMULTIPLY
5719  105. file:///tmp/html-am902r#FCMATRIXROTATE
5720  106. file:///tmp/html-am902r#FCMATRIXSCALE
5721  107. file:///tmp/html-am902r#FCMATRIXSHEAR
5722  108. file:///tmp/html-am902r#FCRANGECOPY
5723  109. file:///tmp/html-am902r#FCRANGECREATEDOUBLE
5724  110. file:///tmp/html-am902r#FCRANGECREATEINTEGER
5725  111. file:///tmp/html-am902r#FCRANGEDESTROY
5726  112. file:///tmp/html-am902r#FCRANGEGETDOUBLE
5727  113. file:///tmp/html-am902r#FCCONFIGCREATE
5728  114. file:///tmp/html-am902r#FCCONFIGREFERENCE
5729  115. file:///tmp/html-am902r#FCCONFIGDESTROY
5730  116. file:///tmp/html-am902r#FCCONFIGSETCURRENT
5731  117. file:///tmp/html-am902r#FCCONFIGGETCURRENT
5732  118. file:///tmp/html-am902r#FCCONFIGUPTODATE
5733  119. file:///tmp/html-am902r#FCCONFIGHOME
5734  120. file:///tmp/html-am902r#FCCONFIGENABLEHOME
5735  121. file:///tmp/html-am902r#FCCONFIGBUILDFONTS
5736  122. file:///tmp/html-am902r#FCCONFIGGETCONFIGDIRS
5737  123. file:///tmp/html-am902r#FCCONFIGGETFONTDIRS
5738  124. file:///tmp/html-am902r#FCCONFIGGETCONFIGFILES
5739  125. file:///tmp/html-am902r#FCCONFIGGETCACHE
5740  126. file:///tmp/html-am902r#FCCONFIGGETCACHEDIRS
5741  127. file:///tmp/html-am902r#FCCONFIGGETFONTS
5742  128. file:///tmp/html-am902r#FCCONFIGGETBLANKS
5743  129. file:///tmp/html-am902r#FCCONFIGGETRESCANINTERVAL
5744  130. file:///tmp/html-am902r#FCCONFIGSETRESCANINTERVAL
5745  131. file:///tmp/html-am902r#FCCONFIGAPPFONTADDFILE
5746  132. file:///tmp/html-am902r#FCCONFIGAPPFONTADDDIR
5747  133. file:///tmp/html-am902r#FCCONFIGAPPFONTCLEAR
5748  134. file:///tmp/html-am902r#FCCONFIGSUBSTITUTEWITHPAT
5749  135. file:///tmp/html-am902r#FCCONFIGSUBSTITUTE
5750  136. file:///tmp/html-am902r#FCFONTMATCH
5751  137. file:///tmp/html-am902r#FCFONTSORT
5752  138. file:///tmp/html-am902r#FCFONTRENDERPREPARE
5753  139. file:///tmp/html-am902r#FCFONTLIST
5754  140. file:///tmp/html-am902r#FCCONFIGFILENAME
5755  141. file:///tmp/html-am902r#FCCONFIGPARSEANDLOAD
5756  142. file:///tmp/html-am902r#FCCONFIGPARSEANDLOADFROMMEMORY
5757  143. file:///tmp/html-am902r#FCCONFIGGETSYSROOT
5758  144. file:///tmp/html-am902r#FCCONFIGSETSYSROOT
5759  145. file:///tmp/html-am902r#FCCONFIGFILEINFOITERINIT
5760  146. file:///tmp/html-am902r#FCCONFIGFILEINFOITERNEXT
5761  147. file:///tmp/html-am902r#FCCONFIGFILEINFOITERGET
5762  148. file:///tmp/html-am902r#FCNAMEREGISTEROBJECTTYPES
5763  149. file:///tmp/html-am902r#FCNAMEUNREGISTEROBJECTTYPES
5764  150. file:///tmp/html-am902r#FCNAMEGETOBJECTTYPE
5765  151. file:///tmp/html-am902r#FCNAMEREGISTERCONSTANTS
5766  152. file:///tmp/html-am902r#FCNAMEUNREGISTERCONSTANTS
5767  153. file:///tmp/html-am902r#FCNAMEGETCONSTANT
5768  154. file:///tmp/html-am902r#FCNAMECONSTANT
5769  155. file:///tmp/html-am902r#FCWEIGHTFROMOPENTYPEDOUBLE
5770  156. file:///tmp/html-am902r#FCWEIGHTTOOPENTYPEDOUBLE
5771  157. file:///tmp/html-am902r#FCWEIGHTFROMOPENTYPE
5772  158. file:///tmp/html-am902r#FCWEIGHTTOOPENTYPE
5773  159. file:///tmp/html-am902r#FCBLANKSCREATE
5774  160. file:///tmp/html-am902r#FCBLANKSDESTROY
5775  161. file:///tmp/html-am902r#FCBLANKSADD
5776  162. file:///tmp/html-am902r#FCBLANKSISMEMBER
5777  163. file:///tmp/html-am902r#FCATOMICCREATE
5778  164. file:///tmp/html-am902r#FCATOMICLOCK
5779  165. file:///tmp/html-am902r#FCATOMICNEWFILE
5780  166. file:///tmp/html-am902r#FCATOMICORIGFILE
5781  167. file:///tmp/html-am902r#FCATOMICREPLACEORIG
5782  168. file:///tmp/html-am902r#FCATOMICDELETENEW
5783  169. file:///tmp/html-am902r#FCATOMICUNLOCK
5784  170. file:///tmp/html-am902r#FCATOMICDESTROY
5785  171. file:///tmp/html-am902r#FCFILESCAN
5786  172. file:///tmp/html-am902r#FCFILEISDIR
5787  173. file:///tmp/html-am902r#FCDIRSCAN
5788  174. file:///tmp/html-am902r#FCDIRSAVE
5789  175. file:///tmp/html-am902r#FCDIRCACHEUNLINK
5790  176. file:///tmp/html-am902r#FCDIRCACHEVALID
5791  177. file:///tmp/html-am902r#FCDIRCACHELOAD
5792  178. file:///tmp/html-am902r#FCDIRCACHERESCAN
5793  179. file:///tmp/html-am902r#FCDIRCACHEREAD
5794  180. file:///tmp/html-am902r#FCDIRCACHELOADFILE
5795  181. file:///tmp/html-am902r#FCDIRCACHEUNLOAD
5796  182. file:///tmp/html-am902r#FCCACHEDIR
5797  183. file:///tmp/html-am902r#FCCACHECOPYSET
5798  184. file:///tmp/html-am902r#FCCACHESUBDIR
5799  185. file:///tmp/html-am902r#FCCACHENUMSUBDIR
5800  186. file:///tmp/html-am902r#FCCACHENUMFONT
5801  187. file:///tmp/html-am902r#FCDIRCACHECLEAN
5802  188. file:///tmp/html-am902r#FCCACHECREATETAGFILE
5803  189. file:///tmp/html-am902r#FCDIRCACHECREATEUUID
5804  190. file:///tmp/html-am902r#FCDIRCACHEDELETEUUID
5805  191. file:///tmp/html-am902r#FCSTRSETCREATE
5806  192. file:///tmp/html-am902r#FCSTRSETMEMBER
5807  193. file:///tmp/html-am902r#FCSTRSETEQUAL
5808  194. file:///tmp/html-am902r#FCSTRSETADD
5809  195. file:///tmp/html-am902r#FCSTRSETADDFILENAME
5810  196. file:///tmp/html-am902r#FCSTRSETDEL
5811  197. file:///tmp/html-am902r#FCSTRSETDESTROY
5812  198. file:///tmp/html-am902r#FCSTRLISTCREATE
5813  199. file:///tmp/html-am902r#FCSTRLISTFIRST
5814  200. file:///tmp/html-am902r#FCSTRLISTNEXT
5815  201. file:///tmp/html-am902r#FCSTRLISTDONE
5816  202. file:///tmp/html-am902r#FCUTF8TOUCS4
5817  203. file:///tmp/html-am902r#FCUCS4TOUTF8
5818  204. file:///tmp/html-am902r#FCUTF8LEN
5819  205. file:///tmp/html-am902r#FCUTF16TOUCS4
5820  206. file:///tmp/html-am902r#FCUTF16LEN
5821  207. file:///tmp/html-am902r#FCISLOWER
5822  208. file:///tmp/html-am902r#FCISUPPER
5823  209. file:///tmp/html-am902r#FCTOLOWER
5824  210. file:///tmp/html-am902r#FCSTRCOPY
5825  211. file:///tmp/html-am902r#FCSTRDOWNCASE
5826  212. file:///tmp/html-am902r#FCSTRCOPYFILENAME
5827  213. file:///tmp/html-am902r#FCSTRCMP
5828  214. file:///tmp/html-am902r#FCSTRCMPIGNORECASE
5829  215. file:///tmp/html-am902r#FCSTRSTR
5830  216. file:///tmp/html-am902r#FCSTRSTRIGNORECASE
5831  217. file:///tmp/html-am902r#FCSTRPLUS
5832  218. file:///tmp/html-am902r#FCSTRFREE
5833  219. file:///tmp/html-am902r#FCSTRDIRNAME
5834  220. file:///tmp/html-am902r#FCSTRBASENAME