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