doc/fontconfig-devel.txt

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