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