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