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