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