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