Data type for booleans. Data type for holding Unicode codepoints. Also used to hold glyph IDs. Data type for holding color values. Colors are eight bits per channel RGB plus alpha transparency. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the extents for a font, for horizontal-direction text segments. Extents must be returned in an #hb_glyph_extents output parameter. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the extents for a font, for vertical-direction text segments. Extents must be returned in an #hb_glyph_extents output parameter. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advance for a specified glyph, in horizontal-direction text segments. Advances must be returned in an #hb_position_t output parameter. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advances for a sequence of glyphs, in horizontal-direction text segments. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the kerning-adjustment value for a glyph-pair in the specified font, for horizontal text segments. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the (X,Y) coordinates (in font units) of the origin for a glyph, for horizontal-direction text segments. Each coordinate must be returned in an #hb_position_t output parameter. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advance for a specified glyph, in vertical-direction text segments. Advances must be returned in an #hb_position_t output parameter. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advances for a sequence of glyphs, in vertical-direction text segments. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the kerning-adjustment value for a glyph-pair in the specified font, for vertical text segments. A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the (X,Y) coordinates (in font units) of the origin for a glyph, for vertical-direction text segments. Each coordinate must be returned in an #hb_position_t output parameter. Data type for bitmasks. An integral type representing an OpenType 'name' table name identifier. There are predefined name IDs, as well as name IDs return from other API. These can be used to fetch name strings from a font face. For more information on these fields, see the [OpenType spec](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids). Data type for holding a single coordinate value. Contour points and other multi-dimensional data are stored as tuples of #hb_position_t's. Data type for tag identifiers. Tags are four byte integers, each byte representing a character. Tags are used to identify tables, design-variation axes, scripts, languages, font features, and baselines with human-readable names. Used when getting or setting AAT feature selectors. Indicates that there is no selector index corresponding to the selector of interest. The default code point for replacing invalid characters in a given encoding. Set to U+FFFD REPLACEMENT CHARACTER. Constructs an #hb_color_t from four integers. blue channel value green channel value red channel value alpha channel value Tests whether a text direction moves backward (from right to left, or from bottom to top). Requires that the direction be valid. #hb_direction_t to test Tests whether a text direction moves forward (from left to right, or from top to bottom). Requires that the direction be valid. #hb_direction_t to test Tests whether a text direction is horizontal. Requires that the direction be valid. #hb_direction_t to test Tests whether a text direction is valid. #hb_direction_t to test Tests whether a text direction is vertical. Requires that the direction be valid. #hb_direction_t to test Reverses a text direction. Requires that the direction be valid. #hb_direction_t to reverse Special setting for #hb_feature_t.start to apply the feature from the start of the buffer. An unset #hb_language_t. Unset #hb_map_t value. Special value for language index indicating default or unsupported language. Special value for feature index indicating unsupported feature. Special value for script index indicating unsupported script. Special value for variations index indicating unsupported variation. Maximum number of OpenType tags that can correspond to a give #hb_language_t. Maximum number of OpenType tags that can correspond to a give #hb_script_t. Do not use. Unset #hb_set_t value. Constructs an #hb_tag_t from four character literals. 1st character of the tag 2nd character of the tag 3rd character of the tag 4th character of the tag Maximum valid Unicode code point. See Unicode 6.1 for details on the maximum decomposition length. Extracts four character literals from an #hb_tag_t. an #hb_tag_t Structure representing a setting for an #hb_aat_layout_feature_type_t. The selector's name identifier The value to turn the selector on The value to turn the selector off The selectors defined for specifying AAT feature settings. Initial, unset feature selector for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES Deprecated Deprecated Deprecated Deprecated Deprecated Deprecated for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_OFF instead Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_ON instead for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_OFF instead Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_ON instead for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE Fetches the name identifier of the specified feature type in the face's `name` table. Name identifier of the requested feature type #hb_face_t to work upon The #hb_aat_layout_feature_type_t of the requested feature type Fetches a list of the selectors available for the specified feature in the given face. If upon return, @default_index is set to #HB_AAT_LAYOUT_NO_SELECTOR_INDEX, then the feature type is non-exclusive. Otherwise, @default_index is the index of the selector that is selected by default. Number of all available feature selectors #hb_face_t to work upon The #hb_aat_layout_feature_type_t of the requested feature type offset of the first feature type to retrieve Input = the maximum number of selectors to return; Output = the actual number of selectors returned (may be zero) A buffer pointer. The selectors available for the feature type queries. The index of the feature's default selector, if any The possible feature types defined for AAT shaping, from Apple [Font Feature Registry](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html). Initial, unset feature type [All Typographic Features](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type0) [Ligatures](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type1) [Cursive Connection](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type2) [Letter Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type3) [Vertical Substitution](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type4) [Linguistic Rearrangement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type5) [Number Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type6) [Smart Swash](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type8) [Diacritics](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type9) [Vertical Position](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type10) [Fractions](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type11) [Overlapping Characters](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type13) [Typographic Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type14) [Mathematical Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type15) [Ornament Sets](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type16) [Character Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type17) [Design Complexity](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type18) [Style Options](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type19) [Character Shape](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type20) [Number Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type21) [Text Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type22) [Transliteration](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type23) [Annotation](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type24) [Kana Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type25) [Ideographic Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type26) [Unicode Decomposition](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type27) [Ruby Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type28) [CJK Symbol Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type29) [Ideographic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type30) [CJK Vertical Roman Placement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type31) [Italic CJK Roman](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type32) [Case Sensitive Layout](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type33) [Alternate Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type34) [Stylistic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type35) [Contextual Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type36) [Lower Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type37) [Upper Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type38) [Language Tag](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type39) [CJK Roman Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type103) Fetches a list of the AAT feature types included in the specified face. Number of all available feature types. #hb_face_t to work upon offset of the first feature type to retrieve Input = the maximum number of feature types to return; Output = the actual number of feature types returned (may be zero) Array of feature types found Tests whether the specified face includes any positioning information in the `kerx` table. <note>Note: does not examine the `GPOS` table.</note> `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether the specified face includes any substitutions in the `morx` or `mort` tables. <note>Note: does not examine the `GSUB` table.</note> `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether the specified face includes any tracking information in the `trak` table. `true` if data found, `false` otherwise #hb_face_t to work upon Makes a writable copy of @blob. The new blob, or nullptr if allocation failed A blob. Creates a new "blob" object wrapping @data. The @mode parameter is used to negotiate ownership and lifecycle of @data. New blob, or the empty blob if something failed or if @length is zero. Destroy with hb_blob_destroy(). Pointer to blob data. Length of @data in bytes. Memory mode for @data. Data parameter to pass to @destroy. Callback to call when @data is not needed anymore. Creates a new blob containing the data from the specified binary font file. An #hb_blob_t pointer with the content of the file, or hb_blob_get_empty() if failed. A font filename Creates a new blob containing the data from the specified binary font file. An #hb_blob_t pointer with the content of the file, or `NULL` if failed. A font filename Creates a new "blob" object wrapping @data. The @mode parameter is used to negotiate ownership and lifecycle of @data. Note that this function returns a freshly-allocated empty blob even if @length is zero. This is in contrast to hb_blob_create(), which returns the singleton empty blob (as returned by hb_blob_get_empty()) if @length is zero. New blob, or `NULL` if failed. Destroy with hb_blob_destroy(). Pointer to blob data. Length of @data in bytes. Memory mode for @data. Data parameter to pass to @destroy. Callback to call when @data is not needed anymore. Returns a blob that represents a range of bytes in @parent. The new blob is always created with #HB_MEMORY_MODE_READONLY, meaning that it will never modify data in the parent blob. The parent data is not expected to be modified, and will result in undefined behavior if it is. Makes @parent immutable. New blob, or the empty blob if something failed or if @length is zero or @offset is beyond the end of @parent's data. Destroy with hb_blob_destroy(). Parent blob. Start offset of sub-blob within @parent, in bytes. Length of sub-blob. Decreases the reference count on @blob, and if it reaches zero, destroys @blob, freeing all memory, possibly calling the destroy-callback the blob was created for if it has not been called already. See TODO:link object types for more information. a blob. Fetches the data from a blob. the byte data of @blob. a blob. The length in bytes of the data retrieved Tries to make blob data writable (possibly copying it) and return pointer to data. Fails if blob has been made immutable, or if memory allocation fails. Writable blob data, or `NULL` if failed. a blob. output length of the writable data. Returns the singleton empty blob. See TODO:link object types for more information. The empty blob. Fetches the length of a blob's data. the length of @blob data in bytes. a blob. Fetches the user data associated with the specified key, attached to the specified font-functions structure. A pointer to the user data a blob The user-data key to query Tests whether a blob is immutable. `true` if @blob is immutable, `false` otherwise a blob. Makes a blob immutable. a blob Increases the reference count on @blob. See TODO:link object types for more information. @blob. a blob. Attaches a user-data key/data pair to the specified blob. `true` if success, `false` otherwise An #hb_blob_t The user-data key to set A pointer to the user data to set A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Data type for blobs. A blob wraps a chunk of binary data and facilitates its lifecycle management between a client program and HarfBuzz. Appends a character with the Unicode value of @codepoint to @buffer, and gives it the initial cluster value of @cluster. Clusters can be any thing the client wants, they are usually used to refer to the index of the character in the input text stream and are output in #hb_glyph_info_t.cluster field. This function does not check the validity of @codepoint, it is up to the caller to ensure it is a valid Unicode code point. An #hb_buffer_t A Unicode code point. The cluster value of @codepoint. Appends characters from @text array to @buffer. The @item_offset is the position of the first character from @text that will be appended, and @item_length is the number of character. When shaping part of a larger text (e.g. a run of text from a paragraph), instead of passing just the substring corresponding to the run, it is preferable to pass the whole paragraph and specify the run start and length as @item_offset and @item_length, respectively, to give HarfBuzz the full context to be able, for example, to do cross-run Arabic shaping or properly handle combining marks at stat of run. This function does not check the validity of @text, it is up to the caller to ensure it contains a valid Unicode code points. a #hb_buffer_t to append characters to. an array of Unicode code points to append. the length of the @text, or -1 if it is `NULL` terminated. the offset of the first code point to add to the @buffer. the number of code points to add to the @buffer, or -1 for the end of @text (assuming it is `NULL` terminated). Similar to hb_buffer_add_codepoints(), but allows only access to first 256 Unicode code points that can fit in 8-bit strings. <note>Has nothing to do with non-Unicode Latin-1 encoding.</note> An #hb_buffer_t an array of UTF-8 characters to append the length of the @text, or -1 if it is `NULL` terminated the offset of the first character to add to the @buffer the number of characters to add to the @buffer, or -1 for the end of @text (assuming it is `NULL` terminated) See hb_buffer_add_codepoints(). Replaces invalid UTF-16 characters with the @buffer replacement code point, see hb_buffer_set_replacement_codepoint(). An #hb_buffer_t An array of UTF-16 characters to append The length of the @text, or -1 if it is `NULL` terminated The offset of the first character to add to the @buffer The number of characters to add to the @buffer, or -1 for the end of @text (assuming it is `NULL` terminated) See hb_buffer_add_codepoints(). Replaces invalid UTF-32 characters with the @buffer replacement code point, see hb_buffer_set_replacement_codepoint(). An #hb_buffer_t An array of UTF-32 characters to append The length of the @text, or -1 if it is `NULL` terminated The offset of the first character to add to the @buffer The number of characters to add to the @buffer, or -1 for the end of @text (assuming it is `NULL` terminated) See hb_buffer_add_codepoints(). Replaces invalid UTF-8 characters with the @buffer replacement code point, see hb_buffer_set_replacement_codepoint(). An #hb_buffer_t An array of UTF-8 characters to append. The length of the @text, or -1 if it is `NULL` terminated. The offset of the first character to add to the @buffer. The number of characters to add to the @buffer, or -1 for the end of @text (assuming it is `NULL` terminated). Check if allocating memory for the buffer succeeded. `true` if @buffer memory allocation succeeded, `false` otherwise. An #hb_buffer_t Append (part of) contents of another buffer to this buffer. An #hb_buffer_t source #hb_buffer_t start index into source buffer to copy. Use 0 to copy from start of buffer. end index into source buffer to copy. Use @HB_FEATURE_GLOBAL_END to copy to end of buffer. Similar to hb_buffer_reset(), but does not clear the Unicode functions and the replacement code point. An #hb_buffer_t Data type for holding HarfBuzz's clustering behavior options. The cluster level dictates one aspect of how HarfBuzz will treat non-base characters during shaping. In @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES, non-base characters are merged into the cluster of the base character that precedes them. In @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS, non-base characters are initially assigned their own cluster values, which are not merged into preceding base clusters. This allows HarfBuzz to perform additional operations like reorder sequences of adjacent marks. @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES is the default, because it maintains backward compatibility with older versions of HarfBuzz. New client programs that do not need to maintain such backward compatibility are recommended to use @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS instead of the default. Return cluster values grouped by graphemes into monotone order. Return cluster values grouped into monotone order. Don't group cluster values. Default cluster level, equal to @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES. The type of #hb_buffer_t contents. Initial value for new buffer. The buffer contains input characters (before shaping). The buffer contains output glyphs (after shaping). Creates a new #hb_buffer_t with all properties to defaults. A newly allocated #hb_buffer_t with a reference count of 1. The initial reference count should be released with hb_buffer_destroy() when you are done using the #hb_buffer_t. This function never returns `NULL`. If memory cannot be allocated, a special #hb_buffer_t object will be returned on which hb_buffer_allocation_successful() returns `false`. Creates a new #hb_buffer_t, similar to hb_buffer_create(). The only difference is that the buffer is configured similarly to @src. A newly allocated #hb_buffer_t, similar to hb_buffer_create(). An #hb_buffer_t Deserializes glyphs @buffer from textual representation in the format produced by hb_buffer_serialize_glyphs(). `true` if @buf is not fully consumed, `false` otherwise. an #hb_buffer_t buffer. string to deserialize the size of @buf, or -1 if it is `NULL`-terminated output pointer to the character after last consumed one. font for getting glyph IDs the #hb_buffer_serialize_format_t of the input @buf Deserializes Unicode @buffer from textual representation in the format produced by hb_buffer_serialize_unicode(). `true` if @buf is not fully consumed, `false` otherwise. an #hb_buffer_t buffer. string to deserialize the size of @buf, or -1 if it is `NULL`-terminated output pointer to the character after last consumed one. the #hb_buffer_serialize_format_t of the input @buf Deallocate the @buffer. Decreases the reference count on @buffer by one. If the result is zero, then @buffer and all associated resources are freed. See hb_buffer_reference(). An #hb_buffer_t If dottedcircle_glyph is (hb_codepoint_t) -1 then #HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT and #HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT are never returned. This should be used by most callers if just comparing two buffers is needed. a buffer. other buffer to compare to. glyph id of U+25CC DOTTED CIRCLE, or (hb_codepont_t) -1. allowed absolute difference in position values. Flags from comparing two #hb_buffer_t's. Buffer with different #hb_buffer_content_type_t cannot be meaningfully compared in any further detail. For buffers with differing length, the per-glyph comparison is not attempted, though we do still scan reference buffer for dotted circle and `.notdef` glyphs. If the buffers have the same length, we compare them glyph-by-glyph and report which aspect(s) of the glyph info/position are different. equal buffers. buffers with different #hb_buffer_content_type_t. buffers with differing length. `.notdef` glyph is present in the reference buffer. dotted circle glyph is present in the reference buffer. difference in #hb_glyph_info_t.codepoint difference in #hb_glyph_info_t.cluster difference in #hb_glyph_flags_t. difference in #hb_glyph_position_t. Flags for #hb_buffer_t. the default buffer flag. flag indicating that special handling of the beginning of text paragraph can be applied to this buffer. Should usually be set, unless you are passing to the buffer only part of the text without the full context. flag indicating that special handling of the end of text paragraph can be applied to this buffer, similar to @HB_BUFFER_FLAG_BOT. flag indication that character with Default_Ignorable Unicode property should use the corresponding glyph from the font, instead of hiding them (done by replacing them with the space glyph and zeroing the advance width.) This flag takes precedence over @HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES. flag indication that character with Default_Ignorable Unicode property should be removed from glyph string instead of hiding them (done by replacing them with the space glyph and zeroing the advance width.) @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES takes precedence over this flag. Since: 1.8.0 flag indicating that a dotted circle should not be inserted in the rendering of incorrect character sequences (such at <0905 093E>). Since: 2.4.0 flag indicating that the hb_shape() call and its variants should perform various verification processes on the results of the shaping operation on the buffer. If the verification fails, then either a buffer message is sent, if a message handler is installed on the buffer, or a message is written to standard error. In either case, the shaping result might be modified to show the failed output. Since: 3.4.0 flag indicating that the @HB_GLYPH_FLAG_UNSAFE_TO_CONCAT glyph-flag should be produced by the shaper. By default it will not be produced since it incurs a cost. Since: 4.0.0 flag indicating that the @HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL glyph-flag should be produced by the shaper. By default it will not be produced. Since: 5.1.0 All currently defined flags: Since: 4.4.0 Fetches the cluster level of a buffer. The #hb_buffer_cluster_level_t dictates one aspect of how HarfBuzz will treat non-base characters during shaping. The cluster level of @buffer An #hb_buffer_t Fetches the type of @buffer contents. Buffers are either empty, contain characters (before shaping), or contain glyphs (the result of shaping). The type of @buffer contents An #hb_buffer_t See hb_buffer_set_direction() The direction of the @buffer. An #hb_buffer_t Fetches an empty #hb_buffer_t. The empty buffer Fetches the #hb_buffer_flags_t of @buffer. The @buffer flags An #hb_buffer_t Returns @buffer glyph information array. Returned pointer is valid as long as @buffer contents are not modified. The @buffer glyph information array. The value valid as long as buffer has not been modified. An #hb_buffer_t The output-array length. Returns @buffer glyph position array. Returned pointer is valid as long as @buffer contents are not modified. If buffer did not have positions before, the positions will be initialized to zeros, unless this function is called from within a buffer message callback (see hb_buffer_set_message_func()), in which case `NULL` is returned. The @buffer glyph position array. The value valid as long as buffer has not been modified. An #hb_buffer_t The output length See hb_buffer_set_invisible_glyph(). The @buffer invisible #hb_codepoint_t An #hb_buffer_t See hb_buffer_set_language(). The #hb_language_t of the buffer. Must not be freed by the caller. An #hb_buffer_t Returns the number of items in the buffer. The @buffer length. The value valid as long as buffer has not been modified. An #hb_buffer_t See hb_buffer_set_not_found_glyph(). The @buffer not-found #hb_codepoint_t An #hb_buffer_t Fetches the #hb_codepoint_t that replaces invalid entries for a given encoding when adding text to @buffer. The @buffer replacement #hb_codepoint_t An #hb_buffer_t Fetches the script of @buffer. The #hb_script_t of the @buffer An #hb_buffer_t Sets @props to the #hb_segment_properties_t of @buffer. An #hb_buffer_t The output #hb_segment_properties_t Fetches the Unicode-functions structure of a buffer. The Unicode-functions structure An #hb_buffer_t Fetches the user data associated with the specified key, attached to the specified buffer. A pointer to the user data An #hb_buffer_t The user-data key to query Sets unset buffer segment properties based on buffer Unicode contents. If buffer is not empty, it must have content type #HB_BUFFER_CONTENT_TYPE_UNICODE. If buffer script is not set (ie. is #HB_SCRIPT_INVALID), it will be set to the Unicode script of the first character in the buffer that has a script other than #HB_SCRIPT_COMMON, #HB_SCRIPT_INHERITED, and #HB_SCRIPT_UNKNOWN. Next, if buffer direction is not set (ie. is #HB_DIRECTION_INVALID), it will be set to the natural horizontal direction of the buffer script as returned by hb_script_get_horizontal_direction(). If hb_script_get_horizontal_direction() returns #HB_DIRECTION_INVALID, then #HB_DIRECTION_LTR is used. Finally, if buffer language is not set (ie. is #HB_LANGUAGE_INVALID), it will be set to the process's default language as returned by hb_language_get_default(). This may change in the future by taking buffer script into consideration when choosing a language. Note that hb_language_get_default() is NOT threadsafe the first time it is called. See documentation for that function for details. An #hb_buffer_t Returns whether @buffer has glyph position data. A buffer gains position data when hb_buffer_get_glyph_positions() is called on it, and cleared of position data when hb_buffer_clear_contents() is called. `true` if the @buffer has position array, `false` otherwise. an #hb_buffer_t. A callback method for #hb_buffer_t. The method gets called with the #hb_buffer_t it was set on, the #hb_font_t the buffer is shaped with and a message describing what step of the shaping process will be performed. Returning `false` from this method will skip this shaping step and move to the next one. `true` to perform the shaping step, `false` to skip it. An #hb_buffer_t to work upon The #hb_font_t the @buffer is shaped with `NULL`-terminated message passed to the function User data pointer passed by the caller Reorders a glyph buffer to have canonical in-cluster glyph order / position. The resulting clusters should behave identical to pre-reordering clusters. <note>This has nothing to do with Unicode normalization.</note> An #hb_buffer_t Pre allocates memory for @buffer to fit at least @size number of items. `true` if @buffer memory allocation succeeded, `false` otherwise An #hb_buffer_t Number of items to pre allocate. Increases the reference count on @buffer by one. This prevents @buffer from being destroyed until a matching call to hb_buffer_destroy() is made. The referenced #hb_buffer_t. An #hb_buffer_t Resets the buffer to its initial status, as if it was just newly created with hb_buffer_create(). An #hb_buffer_t Reverses buffer contents. An #hb_buffer_t Reverses buffer clusters. That is, the buffer contents are reversed, then each cluster (consecutive items having the same cluster number) are reversed again. An #hb_buffer_t Reverses buffer contents between @start and @end. An #hb_buffer_t start index end index Serializes @buffer into a textual representation of its content, whether Unicode codepoints or glyph identifiers and positioning information. This is useful for showing the contents of the buffer, for example during debugging. See the documentation of hb_buffer_serialize_unicode() and hb_buffer_serialize_glyphs() for a description of the output format. The number of serialized items. an #hb_buffer_t buffer. the first item in @buffer to serialize. the last item in @buffer to serialize. output string to write serialized buffer into. the size of @buf. if not `NULL`, will be set to the number of bytes written into @buf. the #hb_font_t used to shape this buffer, needed to read glyph names and extents. If `NULL`, an empty font will be used. the #hb_buffer_serialize_format_t to use for formatting the output. the #hb_buffer_serialize_flags_t that control what glyph properties to serialize. Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs(). serialize glyph names, clusters and positions. do not serialize glyph cluster. do not serialize glyph position information. do no serialize glyph name. serialize glyph extents. serialize glyph flags. Since: 1.5.0 do not serialize glyph advances, glyph offsets will reflect absolute glyph positions. Since: 1.8.0 All currently defined flags. Since: 4.4.0 Parses a string into an #hb_buffer_serialize_format_t. Does not check if @str is a valid buffer serialization format, use hb_buffer_serialize_list_formats() to get the list of supported formats. The parsed #hb_buffer_serialize_format_t. a string to parse length of @str, or -1 if string is `NULL` terminated The buffer serialization and de-serialization format used in hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs(). a human-readable, plain text format. a machine-readable JSON format. invalid format. Converts @format to the string corresponding it, or `NULL` if it is not a valid #hb_buffer_serialize_format_t. A `NULL` terminated string corresponding to @format. Should not be freed. an #hb_buffer_serialize_format_t to convert. Serializes @buffer into a textual representation of its glyph content, useful for showing the contents of the buffer, for example during debugging. There are currently two supported serialization formats: ## text A human-readable, plain text format. The serialized glyphs will look something like: ``` [uni0651=0@518,0+0|uni0628=0+1897] ``` - The serialized glyphs are delimited with `[` and `]`. - Glyphs are separated with `|` - Each glyph starts with glyph name, or glyph index if #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. Then, - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, `=` then #hb_glyph_info_t.cluster. - If #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set, the #hb_glyph_position_t in the format: - If both #hb_glyph_position_t.x_offset and #hb_glyph_position_t.y_offset are not 0, `@x_offset,y_offset`. Then, - `+x_advance`, then `,y_advance` if #hb_glyph_position_t.y_advance is not 0. Then, - If #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set, the #hb_glyph_extents_t in the format `<x_bearing,y_bearing,width,height>` ## json A machine-readable, structured format. The serialized glyphs will look something like: ``` [{"g":"uni0651","cl":0,"dx":518,"dy":0,"ax":0,"ay":0}, {"g":"uni0628","cl":0,"dx":0,"dy":0,"ax":1897,"ay":0}] ``` Each glyph is a JSON object, with the following properties: - `g`: the glyph name or glyph index if #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. - `cl`: #hb_glyph_info_t.cluster if #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set. - `dx`,`dy`,`ax`,`ay`: #hb_glyph_position_t.x_offset, #hb_glyph_position_t.y_offset, #hb_glyph_position_t.x_advance and #hb_glyph_position_t.y_advance respectively, if #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set. - `xb`,`yb`,`w`,`h`: #hb_glyph_extents_t.x_bearing, #hb_glyph_extents_t.y_bearing, #hb_glyph_extents_t.width and #hb_glyph_extents_t.height respectively if #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set. The number of serialized items. an #hb_buffer_t buffer. the first item in @buffer to serialize. the last item in @buffer to serialize. output string to write serialized buffer into. the size of @buf. if not `NULL`, will be set to the number of bytes written into @buf. the #hb_font_t used to shape this buffer, needed to read glyph names and extents. If `NULL`, an empty font will be used. the #hb_buffer_serialize_format_t to use for formatting the output. the #hb_buffer_serialize_flags_t that control what glyph properties to serialize. Returns a list of supported buffer serialization formats. A string array of buffer serialization formats. Should not be freed. Serializes @buffer into a textual representation of its content, when the buffer contains Unicode codepoints (i.e., before shaping). This is useful for showing the contents of the buffer, for example during debugging. There are currently two supported serialization formats: ## text A human-readable, plain text format. The serialized codepoints will look something like: ```  <U+0651=0|U+0628=1> ``` - Glyphs are separated with `|` - Unicode codepoints are expressed as zero-padded four (or more) digit hexadecimal numbers preceded by `U+` - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, the cluster will be indicated with a `=` then #hb_glyph_info_t.cluster. ## json A machine-readable, structured format. The serialized codepoints will be a list of objects with the following properties: - `u`: the Unicode codepoint as a decimal integer - `cl`: #hb_glyph_info_t.cluster if #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set. For example: ``` [{u:1617,cl:0},{u:1576,cl:1}] ``` The number of serialized items. an #hb_buffer_t buffer. the first item in @buffer to serialize. the last item in @buffer to serialize. output string to write serialized buffer into. the size of @buf. if not `NULL`, will be set to the number of bytes written into @buf. the #hb_buffer_serialize_format_t to use for formatting the output. the #hb_buffer_serialize_flags_t that control what glyph properties to serialize. Sets the cluster level of a buffer. The #hb_buffer_cluster_level_t dictates one aspect of how HarfBuzz will treat non-base characters during shaping. An #hb_buffer_t The cluster level to set on the buffer Sets the type of @buffer contents. Buffers are either empty, contain characters (before shaping), or contain glyphs (the result of shaping). An #hb_buffer_t The type of buffer contents to set Set the text flow direction of the buffer. No shaping can happen without setting @buffer direction, and it controls the visual direction for the output glyphs; for RTL direction the glyphs will be reversed. Many layout features depend on the proper setting of the direction, for example, reversing RTL text before shaping, then shaping with LTR direction is not the same as keeping the text in logical order and shaping with RTL direction. An #hb_buffer_t the #hb_direction_t of the @buffer Sets @buffer flags to @flags. See #hb_buffer_flags_t. An #hb_buffer_t The buffer flags to set Sets the #hb_codepoint_t that replaces invisible characters in the shaping result. If set to zero (default), the glyph for the U+0020 SPACE character is used. Otherwise, this value is used verbatim. An #hb_buffer_t the invisible #hb_codepoint_t Sets the language of @buffer to @language. Languages are crucial for selecting which OpenType feature to apply to the buffer which can result in applying language-specific behaviour. Languages are orthogonal to the scripts, and though they are related, they are different concepts and should not be confused with each other. Use hb_language_from_string() to convert from BCP 47 language tags to #hb_language_t. An #hb_buffer_t An hb_language_t to set Similar to hb_buffer_pre_allocate(), but clears any new items added at the end. `true` if @buffer memory allocation succeeded, `false` otherwise. An #hb_buffer_t The new length of @buffer Sets the implementation function for #hb_buffer_message_func_t. An #hb_buffer_t Callback function Data to pass to @func The function to call when @user_data is not needed anymore Sets the #hb_codepoint_t that replaces characters not found in the font during shaping. The not-found glyph defaults to zero, sometimes knows as the ".notdef" glyph. This API allows for differentiating the two. An #hb_buffer_t the not-found #hb_codepoint_t Sets the #hb_codepoint_t that replaces invalid entries for a given encoding when adding text to @buffer. Default is #HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT. An #hb_buffer_t the replacement #hb_codepoint_t Sets the script of @buffer to @script. Script is crucial for choosing the proper shaping behaviour for scripts that require it (e.g. Arabic) and the which OpenType features defined in the font to be applied. You can pass one of the predefined #hb_script_t values, or use hb_script_from_string() or hb_script_from_iso15924_tag() to get the corresponding script from an ISO 15924 script tag. An #hb_buffer_t An #hb_script_t to set. Sets the segment properties of the buffer, a shortcut for calling hb_buffer_set_direction(), hb_buffer_set_script() and hb_buffer_set_language() individually. An #hb_buffer_t An #hb_segment_properties_t to use Sets the Unicode-functions structure of a buffer to @unicode_funcs. An #hb_buffer_t The Unicode-functions structure Attaches a user-data key/data pair to the specified buffer. `true` if success, `false` otherwise An #hb_buffer_t The user-data key A pointer to the user data A callback to call when @data is not needed anymore Whether to replace an existing data with the same key The main structure holding the input text and its properties before shaping, and output glyphs and their information after shaping. Fetches the alpha channel of the given @color. Alpha channel value an #hb_color_t we are interested in its channels. Fetches the blue channel of the given @color. Blue channel value an #hb_color_t we are interested in its channels. Fetches the green channel of the given @color. Green channel value an #hb_color_t we are interested in its channels. Fetches the red channel of the given @color. Red channel value an #hb_color_t we are interested in its channels. A virtual method for destroy user-data callbacks. the data to be destroyed Converts a string to an #hb_direction_t. Matching is loose and applies only to the first letter. For examples, "LTR" and "left-to-right" will both return #HB_DIRECTION_LTR. Unmatched strings will return #HB_DIRECTION_INVALID. The #hb_direction_t matching @str String to convert Length of @str, or -1 if it is `NULL`-terminated The direction of a text segment or buffer. A segment can also be tested for horizontal or vertical orientation (irrespective of specific direction) with HB_DIRECTION_IS_HORIZONTAL() or HB_DIRECTION_IS_VERTICAL(). Initial, unset direction. Text is set horizontally from left to right. Text is set horizontally from right to left. Text is set vertically from top to bottom. Text is set vertically from bottom to top. Converts an #hb_direction_t to a string. The string corresponding to @direction The #hb_direction_t to convert Perform a "close-path" draw operation. draw functions associated draw data passed by the caller current draw state A virtual method for the #hb_draw_funcs_t to perform a "close-path" draw operation. draw functions object The data accompanying the draw functions current draw state User data pointer passed by the caller Perform a "cubic-to" draw operation. draw functions associated draw data passed by the caller current draw state X component of first control point Y component of first control point X component of second control point Y component of second control point X component of target point Y component of target point A virtual method for the #hb_draw_funcs_t to perform a "cubic-to" draw operation. draw functions object The data accompanying the draw functions current draw state X component of first control point Y component of first control point X component of second control point Y component of second control point X component of target point Y component of target point User data pointer passed by the caller Creates a new draw callbacks object. A newly allocated #hb_draw_funcs_t with a reference count of 1. The initial reference count should be released with hb_draw_funcs_destroy when you are done using the #hb_draw_funcs_t. This function never returns `NULL`. If memory cannot be allocated, a special singleton #hb_draw_funcs_t object will be returned. Deallocate the @dfuncs. Decreases the reference count on @dfuncs by one. If the result is zero, then @dfuncs and all associated resources are freed. See hb_draw_funcs_reference(). draw functions Checks whether @dfuncs is immutable. `true` if @dfuncs is immutable, `false` otherwise draw functions Makes @dfuncs object immutable. draw functions Increases the reference count on @dfuncs by one. This prevents @buffer from being destroyed until a matching call to hb_draw_funcs_destroy() is made. The referenced #hb_draw_funcs_t. draw functions Sets close-path callback to the draw functions object. draw functions object close-path callback Data to pass to @func The function to call when @user_data is not needed anymore Sets cubic-to callback to the draw functions object. draw functions cubic-to callback Data to pass to @func The function to call when @user_data is not needed anymore Sets line-to callback to the draw functions object. draw functions object line-to callback Data to pass to @func The function to call when @user_data is not needed anymore Sets move-to callback to the draw functions object. draw functions object move-to callback Data to pass to @func The function to call when @user_data is not needed anymore Sets quadratic-to callback to the draw functions object. draw functions object quadratic-to callback Data to pass to @func The function to call when @user_data is not needed anymore Glyph draw callbacks. #hb_draw_move_to_func_t, #hb_draw_line_to_func_t and #hb_draw_cubic_to_func_t calls are necessary to be defined but we translate #hb_draw_quadratic_to_func_t calls to #hb_draw_cubic_to_func_t if the callback isn't defined. Perform a "line-to" draw operation. draw functions associated draw data passed by the caller current draw state X component of target point Y component of target point A virtual method for the #hb_draw_funcs_t to perform a "line-to" draw operation. draw functions object The data accompanying the draw functions current draw state X component of target point Y component of target point User data pointer passed by the caller Perform a "move-to" draw operation. draw functions associated draw data passed by the caller current draw state X component of target point Y component of target point A virtual method for the #hb_draw_funcs_t to perform a "move-to" draw operation. draw functions object The data accompanying the draw functions current draw state X component of target point Y component of target point User data pointer passed by the caller Perform a "quadratic-to" draw operation. draw functions associated draw data passed by the caller current draw state X component of control point Y component of control point X component of target point Y component of target point A virtual method for the #hb_draw_funcs_t to perform a "quadratic-to" draw operation. draw functions object The data accompanying the draw functions current draw state X component of control point Y component of control point X component of target point Y component of target point User data pointer passed by the caller Current drawing state. Whether there is an open path X component of the start of current path Y component of the start of current path X component of current point Y component of current point Add table for @tag with data provided by @blob to the face. @face must be created using hb_face_builder_create(). A face object created with hb_face_builder_create() The #hb_tag_t of the table to add The blob containing the table data to add Creates a #hb_face_t that can be used with hb_face_builder_add_table(). After tables are added to the face, it can be compiled to a binary font file by calling hb_face_reference_blob(). New face. Collects all of the Unicode characters covered by @face and adds them to the #hb_set_t set @out. A face object The set to add Unicode characters to Collects all Unicode "Variation Selector" characters covered by @face and adds them to the #hb_set_t set @out. A face object The set to add Variation Selector characters to Collects all Unicode characters for @variation_selector covered by @face and adds them to the #hb_set_t set @out. A face object The Variation Selector to query The set to add Unicode characters to Fetches the number of faces in a blob. Number of faces in @blob a blob. Constructs a new face object from the specified blob and a face index into that blob. The face index is used for blobs of file formats such as TTC and and DFont that can contain more than one face. Face indices within such collections are zero-based. <note>Note: If the blob font format is not a collection, @index is ignored. Otherwise, only the lower 16-bits of @index are used. The unmodified @index can be accessed via hb_face_get_index().</note> <note>Note: The high 16-bits of @index, if non-zero, are used by hb_font_create() to load named-instances in variable fonts. See hb_font_create() for details.</note> The new face object #hb_blob_t to work upon The index of the face within @blob Variant of hb_face_create(), built for those cases where it is more convenient to provide data for individual tables instead of the whole font data. With the caveat that hb_face_get_table_tags() does not currently work with faces created this way. Creates a new face object from the specified @user_data and @reference_table_func, with the @destroy callback. The new face object Table-referencing function A pointer to the user data A callback to call when @data is not needed anymore Decreases the reference count on a face object. When the reference count reaches zero, the face is destroyed, freeing all memory. A face object Fetches the singleton empty face object. The empty face object Fetches the glyph-count value of the specified face object. The glyph-count value of @face A face object Fetches the face-index corresponding to the given face. <note>Note: face indices within a collection are zero-based.</note> The index of @face. A face object Fetches a list of all table tags for a face, if possible. The list returned will begin at the offset provided Total number of tables, or zero if it is not possible to list A face object The index of first table tag to retrieve Input = the maximum number of table tags to return; Output = the actual number of table tags returned (may be zero) The array of table tags found Fetches the units-per-em (upem) value of the specified face object. The upem value of @face A face object Fetches the user data associated with the specified key, attached to the specified face object. A pointer to the user data A face object The user-data key to query Tests whether the given face object is immutable. `true` is @face is immutable, `false` otherwise A face object Makes the given face object immutable. A face object Increases the reference count on a face object. The @face object A face object Fetches a pointer to the binary blob that contains the specified face. Returns an empty blob if referencing face data is not possible. A pointer to the blob for @face A face object Fetches a reference to the specified table within the specified face. A pointer to the @tag table within @face A face object The #hb_tag_t of the table to query Sets the glyph count for a face object to the specified value. A face object The glyph-count value to assign Assigns the specified face-index to @face. Fails if the face is immutable. <note>Note: changing the index has no effect on the face itself This only changes the value returned by hb_face_get_index().</note> A face object The index to assign Sets the units-per-em (upem) for a face object to the specified value. A face object The units-per-em value to assign Attaches a user-data key/data pair to the given face object. `true` if success, `false` otherwise A face object The user-data key to set A pointer to the user data A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Data type for holding font faces. Parses a string into a #hb_feature_t. The format for specifying feature strings follows. All valid CSS font-feature-settings values other than 'normal' and the global values are also accepted, though not documented below. CSS string escapes are not supported. The range indices refer to the positions between Unicode characters. The position before the first character is always 0. The format is Python-esque. Here is how it all works: <informaltable pgwide='1' align='left' frame='none'> <tgroup cols='5'> <thead> <row><entry>Syntax</entry> <entry>Value</entry> <entry>Start</entry> <entry>End</entry></row> </thead> <tbody> <row><entry>Setting value:</entry></row> <row><entry>kern</entry> <entry>1</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature on</entry></row> <row><entry>+kern</entry> <entry>1</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature on</entry></row> <row><entry>-kern</entry> <entry>0</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature off</entry></row> <row><entry>kern=0</entry> <entry>0</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature off</entry></row> <row><entry>kern=1</entry> <entry>1</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature on</entry></row> <row><entry>aalt=2</entry> <entry>2</entry> <entry>0</entry> <entry>∞</entry> <entry>Choose 2nd alternate</entry></row> <row><entry>Setting index:</entry></row> <row><entry>kern[]</entry> <entry>1</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature on</entry></row> <row><entry>kern[:]</entry> <entry>1</entry> <entry>0</entry> <entry>∞</entry> <entry>Turn feature on</entry></row> <row><entry>kern[5:]</entry> <entry>1</entry> <entry>5</entry> <entry>∞</entry> <entry>Turn feature on, partial</entry></row> <row><entry>kern[:5]</entry> <entry>1</entry> <entry>0</entry> <entry>5</entry> <entry>Turn feature on, partial</entry></row> <row><entry>kern[3:5]</entry> <entry>1</entry> <entry>3</entry> <entry>5</entry> <entry>Turn feature on, range</entry></row> <row><entry>kern[3]</entry> <entry>1</entry> <entry>3</entry> <entry>3+1</entry> <entry>Turn feature on, single char</entry></row> <row><entry>Mixing it all:</entry></row> <row><entry>aalt[3:5]=2</entry> <entry>2</entry> <entry>3</entry> <entry>5</entry> <entry>Turn 2nd alternate on for range</entry></row> </tbody> </tgroup> </informaltable> `true` if @str is successfully parsed, `false` otherwise a string to parse length of @str, or -1 if string is `NULL` terminated the #hb_feature_t to initialize with the parsed values The #hb_feature_t is the structure that holds information about requested feature application. The feature will be applied with the given value to all glyphs which are in clusters between @start (inclusive) and @end (exclusive). Setting start to #HB_FEATURE_GLOBAL_START and end to #HB_FEATURE_GLOBAL_END specifies that the feature always applies to the entire buffer. The #hb_tag_t tag of the feature The value of the feature. 0 disables the feature, non-zero (usually 1) enables the feature. For features implemented as lookup type 3 (like 'salt') the @value is a one based index into the alternates. the cluster to start applying this feature setting (inclusive). the cluster to end applying this feature setting (exclusive). Converts a #hb_feature_t into a `NULL`-terminated string in the format understood by hb_feature_from_string(). The client in responsible for allocating big enough size for @buf, 128 bytes is more than enough. an #hb_feature_t to convert output string the allocated size of @buf Converts a #hb_feature_t into a `NULL`-terminated string in the format understood by hb_feature_from_string(). The client in responsible for allocating big enough size for @buf, 128 bytes is more than enough. an #hb_feature_t to convert output string the allocated size of @buf Adds the origin coordinates to an (X,Y) point coordinate, in the specified glyph ID in the specified font. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The glyph ID to query The direction of the text segment Input = The original X coordinate Output = The X coordinate plus the X-coordinate of the origin Input = The original Y coordinate Output = The Y coordinate plus the Y-coordinate of the origin Notifies the @font that underlying font data has changed. This has the effect of increasing the serial as returned by hb_font_get_serial(), which invalidates internal caches. #hb_font_t to work upon Constructs a new font object from the specified face. <note>Note: If @face's index value (as passed to hb_face_create() has non-zero top 16-bits, those bits minus one are passed to hb_font_set_var_named_instance(), effectively loading a named-instance of a variable font, instead of the default-instance. This allows specifying which named-instance to load by default when creating the face.</note> The new font object a face. Constructs a sub-font font object from the specified @parent font, replicating the parent's properties. The new sub-font font object The parent font object Decreases the reference count on the given font object. When the reference count reaches zero, the font is destroyed, freeing all memory. #hb_font_t to work upon Font-wide extent values, measured in font units. Note that typically @ascender is positive and @descender negative, in coordinate systems that grow up. The height of typographic ascenders. The depth of typographic descenders. The suggested line-spacing gap. Creates a new #hb_font_funcs_t structure of font functions. The font-functions structure Decreases the reference count on a font-functions structure. When the reference count reaches zero, the font-functions structure is destroyed, freeing all memory. The font-functions structure Fetches an empty font-functions structure. The font-functions structure Fetches the user data associated with the specified key, attached to the specified font-functions structure. A pointer to the user data The font-functions structure The user-data key to query Tests whether a font-functions structure is immutable. `true` if @ffuncs is immutable, `false` otherwise The font-functions structure Makes a font-functions structure immutable. The font-functions structure Increases the reference count on a font-functions structure. The font-functions structure The font-functions structure Sets the implementation function for #hb_font_get_font_h_extents_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_font_v_extents_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_contour_point_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_extents_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_from_name_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Deprecated. Use hb_font_funcs_set_nominal_glyph_func() and hb_font_funcs_set_variation_glyph_func() instead. The font-functions structure callback function data to pass to @func function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_h_advance_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_h_advances_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_h_kerning_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_h_origin_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_name_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_shape_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_v_advance_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_v_advances_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_v_kerning_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_glyph_v_origin_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_nominal_glyph_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_font_get_nominal_glyphs_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Attaches a user-data key/data pair to the specified font-functions structure. `true` if success, `false` otherwise The font-functions structure The user-data key to set A pointer to the user data set A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Sets the implementation function for #hb_font_get_variation_glyph_func_t. A font-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Data type containing a set of virtual methods used for working on #hb_font_t font objects. HarfBuzz provides a lightweight default function for each of the methods in #hb_font_funcs_t. Client programs can implement their own replacements for the individual font functions, as needed, and replace the default by calling the setter for a method. Fetches the empty font object. The empty font object Fetches the extents for a font in a text segment of the specified direction. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The direction of the text segment The #hb_font_extents_t retrieved Fetches the face associated with the specified font object. The #hb_face_t value #hb_font_t to work upon This method should retrieve the extents for a font. #hb_font_t to work upon @font user data pointer The font extents retrieved User data pointer passed by the caller Fetches the glyph ID for a Unicode code point in the specified font, with an optional variation selector. If @variation_selector is 0, calls hb_font_get_nominal_glyph(); otherwise calls hb_font_get_variation_glyph(). `true` if data found, `false` otherwise #hb_font_t to work upon The Unicode code point to query A variation-selector code point The glyph ID retrieved Fetches the advance for a glyph ID from the specified font, in a text segment of the specified direction. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The glyph ID to query The direction of the text segment The horizontal advance retrieved The vertical advance retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advance for a specified glyph. The method must return an #hb_position_t. The advance of @glyph within @font #hb_font_t to work upon @font user data pointer The glyph ID to query User data pointer passed by the caller Fetches the advances for a sequence of glyph IDs in the specified font, in a text segment of the specified direction. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The direction of the text segment The number of glyph IDs in the sequence queried The first glyph ID to query The stride between successive glyph IDs The first advance retrieved The stride between successive advances A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the advances for a sequence of glyphs. #hb_font_t to work upon @font user data pointer The number of glyph IDs in the sequence queried The first glyph ID to query The stride between successive glyph IDs The first advance retrieved The stride between successive advances User data pointer passed by the caller Fetches the (x,y) coordinates of a specified contour-point index in the specified glyph, within the specified font. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The contour-point index to query The X value retrieved for the contour point The Y value retrieved for the contour point Fetches the (X,Y) coordinates of a specified contour-point index in the specified glyph ID in the specified font, with respect to the origin in a text segment in the specified direction. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The contour-point index to query The direction of the text segment The X value retrieved for the contour point The Y value retrieved for the contour point A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the (X,Y) coordinates (in font units) for a specified contour point in a glyph. Each coordinate must be returned as an #hb_position_t output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The glyph ID to query The contour-point index to query The X value retrieved for the contour point The Y value retrieved for the contour point User data pointer passed by the caller Fetches the #hb_glyph_extents_t data for a glyph ID in the specified font. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The #hb_glyph_extents_t retrieved Fetches the #hb_glyph_extents_t data for a glyph ID in the specified font, with respect to the origin in a text segment in the specified direction. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The direction of the text segment The #hb_glyph_extents_t retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the extents for a specified glyph. Extents must be returned in an #hb_glyph_extents output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The glyph ID to query The #hb_glyph_extents_t retrieved User data pointer passed by the caller Fetches the glyph ID that corresponds to a name string in the specified @font. <note>Note: @len == -1 means the name string is null-terminated.</note> `true` if data found, `false` otherwise #hb_font_t to work upon The name string to query The length of the name queried The glyph ID retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the glyph ID that corresponds to a glyph-name string. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The name string to query The length of the name queried The glyph ID retrieved User data pointer passed by the caller A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the glyph ID for a specified Unicode code point font, with an optional variation selector. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The Unicode code point to query The variation-selector code point to query The glyph ID retrieved User data pointer passed by the caller Fetches the advance for a glyph ID in the specified font, for horizontal text segments. The advance of @glyph within @font #hb_font_t to work upon The glyph ID to query Fetches the advances for a sequence of glyph IDs in the specified font, for horizontal text segments. #hb_font_t to work upon The number of glyph IDs in the sequence queried The first glyph ID to query The stride between successive glyph IDs The first advance retrieved The stride between successive advances Fetches the kerning-adjustment value for a glyph-pair in the specified font, for horizontal text segments. <note>It handles legacy kerning only (as returned by the corresponding #hb_font_funcs_t function).</note> The kerning adjustment value #hb_font_t to work upon The glyph ID of the left glyph in the glyph pair The glyph ID of the right glyph in the glyph pair Fetches the (X,Y) coordinates of the origin for a glyph ID in the specified font, for horizontal text segments. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The X coordinate of the origin The Y coordinate of the origin Fetches the kerning-adjustment value for a glyph-pair in the specified font. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The glyph ID of the first glyph in the glyph pair to query The glyph ID of the second glyph in the glyph pair to query The direction of the text segment The horizontal kerning-adjustment value retrieved The vertical kerning-adjustment value retrieved This method should retrieve the kerning-adjustment value for a glyph-pair in the specified font, for horizontal text segments. #hb_font_t to work upon @font user data pointer The glyph ID of the first glyph in the glyph pair The glyph ID of the second glyph in the glyph pair User data pointer passed by the caller Fetches the glyph-name string for a glyph ID in the specified @font. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query Name string retrieved for the glyph ID Length of the glyph-name string retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the glyph name that corresponds to a glyph ID. The name should be returned in a string output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The glyph ID to query Name string retrieved for the glyph ID Length of the glyph-name string retrieved User data pointer passed by the caller Fetches the (X,Y) coordinates of the origin for a glyph in the specified font. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The glyph ID to query The direction of the text segment The X coordinate retrieved for the origin The Y coordinate retrieved for the origin A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the (X,Y) coordinates (in font units) of the origin for a glyph. Each coordinate must be returned in an #hb_position_t output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The glyph ID to query The X coordinate of the origin The Y coordinate of the origin User data pointer passed by the caller Fetches the glyph shape that corresponds to a glyph in the specified @font. The shape is returned by way of calls to the callsbacks of the @dfuncs objects, with @draw_data passed to them. #hb_font_t to work upon The glyph ID #hb_draw_funcs_t to draw to User data to pass to draw callbacks A virtual method for the #hb_font_funcs_t of an #hb_font_t object. #hb_font_t to work upon @font user data pointer The glyph ID to query The draw functions to send the shape data to The data accompanying the draw functions User data pointer passed by the caller Fetches the advance for a glyph ID in the specified font, for vertical text segments. The advance of @glyph within @font #hb_font_t to work upon The glyph ID to query Fetches the advances for a sequence of glyph IDs in the specified font, for vertical text segments. #hb_font_t to work upon The number of glyph IDs in the sequence queried The first glyph ID to query The stride between successive glyph IDs The first advance retrieved The stride between successive advances Fetches the kerning-adjustment value for a glyph-pair in the specified font, for vertical text segments. <note>It handles legacy kerning only (as returned by the corresponding #hb_font_funcs_t function).</note> The kerning adjustment value #hb_font_t to work upon The glyph ID of the top glyph in the glyph pair The glyph ID of the bottom glyph in the glyph pair Fetches the (X,Y) coordinates of the origin for a glyph ID in the specified font, for vertical text segments. `true` if data found, `false` otherwise #hb_font_t to work upon The glyph ID to query The X coordinate of the origin The Y coordinate of the origin Fetches the extents for a specified font, for horizontal text segments. `true` if data found, `false` otherwise #hb_font_t to work upon The font extents retrieved Fetches the nominal glyph ID for a Unicode code point in the specified font. This version of the function should not be used to fetch glyph IDs for code points modified by variation selectors. For variation-selector support, user hb_font_get_variation_glyph() or use hb_font_get_glyph(). `true` if data found, `false` otherwise #hb_font_t to work upon The Unicode code point to query The glyph ID retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the nominal glyph ID for a specified Unicode code point. Glyph IDs must be returned in a #hb_codepoint_t output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The Unicode code point to query The glyph ID retrieved User data pointer passed by the caller Fetches the nominal glyph IDs for a sequence of Unicode code points. Glyph IDs must be returned in a #hb_codepoint_t output parameter. the number of code points processed #hb_font_t to work upon number of code points to query The first Unicode code point to query The stride between successive code points The first glyph ID retrieved The stride between successive glyph IDs A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the nominal glyph IDs for a sequence of Unicode code points. Glyph IDs must be returned in a #hb_codepoint_t output parameter. the number of code points processed #hb_font_t to work upon @font user data pointer number of code points to query The first Unicode code point to query The stride between successive code points The first glyph ID retrieved The stride between successive glyph IDs User data pointer passed by the caller Fetches the parent font of @font. The parent font object #hb_font_t to work upon Fetches the horizontal and vertical points-per-em (ppem) of a font. #hb_font_t to work upon Horizontal ppem value Vertical ppem value Fetches the "point size" of a font. Used in CoreText to implement optical sizing. Point size. A value of zero means "not set." #hb_font_t to work upon Fetches the horizontal and vertical scale of a font. #hb_font_t to work upon Horizontal scale value Vertical scale value Returns the internal serial number of the font. The serial number is increased every time a setting on the font is changed, using a setter function. serial number #hb_font_t to work upon Fetches the "synthetic slant" of a font. Synthetic slant. By default is zero. #hb_font_t to work upon Fetches the user-data object associated with the specified key, attached to the specified font object. Pointer to the user data #hb_font_t to work upon The user-data key to query Fetches the extents for a specified font, for vertical text segments. `true` if data found, `false` otherwise #hb_font_t to work upon The font extents retrieved Fetches the list of variation coordinates (in design-space units) currently set on a font. Note that this returned array may only contain values for some (or none) of the axes; omitted axes effectively have their default values. Return value is valid as long as variation coordinates of the font are not modified. coordinates array #hb_font_t to work upon Number of coordinates retrieved Fetches the list of normalized variation coordinates currently set on a font. Note that this returned array may only contain values for some (or none) of the axes; omitted axes effectively have zero values. Return value is valid as long as variation coordinates of the font are not modified. coordinates array #hb_font_t to work upon Number of coordinates retrieved Fetches the glyph ID for a Unicode code point when followed by by the specified variation-selector code point, in the specified font. `true` if data found, `false` otherwise #hb_font_t to work upon The Unicode code point to query The variation-selector code point to query The glyph ID retrieved A virtual method for the #hb_font_funcs_t of an #hb_font_t object. This method should retrieve the glyph ID for a specified Unicode code point followed by a specified Variation Selector code point. Glyph IDs must be returned in a #hb_codepoint_t output parameter. `true` if data found, `false` otherwise #hb_font_t to work upon @font user data pointer The Unicode code point to query The variation-selector code point to query The glyph ID retrieved User data pointer passed by the caller Fetches the glyph ID from @font that matches the specified string. Strings of the format `gidDDD` or `uniUUUU` are parsed automatically. <note>Note: @len == -1 means the string is null-terminated.</note> `true` if data found, `false` otherwise #hb_font_t to work upon string to query The length of the string @s The glyph ID corresponding to the string requested Fetches the name of the specified glyph ID in @font and returns it in string @s. If the glyph ID has no name in @font, a string of the form `gidDDD` is generated, with `DDD` being the glyph ID. #hb_font_t to work upon The glyph ID to query The string containing the glyph name Length of string @s Tests whether a font object is immutable. `true` if @font is immutable, `false` otherwise #hb_font_t to work upon Makes @font immutable. #hb_font_t to work upon Increases the reference count on the given font object. The @font object #hb_font_t to work upon Sets @face as the font-face value of @font. #hb_font_t to work upon The #hb_face_t to assign Replaces the font-functions structure attached to a font, updating the font's user-data with @font-data and the @destroy callback. #hb_font_t to work upon The font-functions structure. Data to attach to @font The function to call when @font_data is not needed anymore Replaces the user data attached to a font, updating the font's @destroy callback. #hb_font_t to work upon Data to attach to @font The function to call when @font_data is not needed anymore Sets the parent font of @font. #hb_font_t to work upon The parent font object to assign Sets the horizontal and vertical pixels-per-em (ppem) of a font. #hb_font_t to work upon Horizontal ppem value to assign Vertical ppem value to assign Sets the "point size" of a font. Set to zero to unset. Used in CoreText to implement optical sizing. <note>Note: There are 72 points in an inch.</note> #hb_font_t to work upon font size in points. Sets the horizontal and vertical scale of a font. #hb_font_t to work upon Horizontal scale value to assign Vertical scale value to assign Sets the "synthetic slant" of a font. By default is zero. Synthetic slant is the graphical skew applied to the font at rendering time. HarfBuzz needs to know this value to adjust shaping results, metrics, and style values to match the slanted rendering. <note>Note: The glyph shape fetched via the hb_font_get_glyph_shape() is slanted to reflect this value as well.</note> <note>Note: The slant value is a ratio. For example, a 20% slant would be represented as a 0.2 value.</note> #hb_font_t to work upon synthetic slant value. Attaches a user-data key/data pair to the specified font object. `true` if success, `false` otherwise #hb_font_t to work upon The user-data key A pointer to the user data A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Applies a list of variation coordinates (in design-space units) to a font. Note that this overrides all existing variations set on @font. Axes not included in @coords will be effectively set to their default values. #hb_font_t to work upon Array of variation coordinates to apply Number of coordinates to apply Applies a list of variation coordinates (in normalized units) to a font. Note that this overrides all existing variations set on @font. Axes not included in @coords will be effectively set to their default values. <note>Note: Coordinates should be normalized to 2.14.</note> #hb_font_t to work upon Array of variation coordinates to apply Number of coordinates to apply Sets design coords of a font from a named instance index. a font. named instance index. Applies a list of font-variation settings to a font. Note that this overrides all existing variations set on @font. Axes not included in @variations will be effectively set to their default values. #hb_font_t to work upon Array of variation settings to apply Number of variations to apply Subtracts the origin coordinates from an (X,Y) point coordinate, in the specified glyph ID in the specified font. Calls the appropriate direction-specific variant (horizontal or vertical) depending on the value of @direction. #hb_font_t to work upon The glyph ID to query The direction of the text segment Input = The original X coordinate Output = The X coordinate minus the X-coordinate of the origin Input = The original Y coordinate Output = The Y coordinate minus the Y-coordinate of the origin Data type for holding fonts. Creates an #hb_face_t face object from the specified FT_Face. This variant of the function does not provide any life-cycle management. Most client programs should use hb_ft_face_create_referenced() (or, perhaps, hb_ft_face_create_cached()) instead. If you know you have valid reasons not to use hb_ft_face_create_referenced(), then it is the client program's responsibility to destroy @ft_face after the #hb_face_t face object has been destroyed. the new #hb_face_t face object FT_Face to work upon A callback to call when the face object is not needed anymore Creates an #hb_face_t face object from the specified FT_Face. This variant of the function caches the newly created #hb_face_t face object, using the @generic pointer of @ft_face. Subsequent function calls that are passed the same @ft_face parameter will have the same #hb_face_t returned to them, and that #hb_face_t will be correctly reference counted. However, client programs are still responsible for destroying @ft_face after the last #hb_face_t face object has been destroyed. the new #hb_face_t face object FT_Face to work upon Creates an #hb_face_t face object from the specified FT_Face. This is the preferred variant of the hb_ft_face_create* function family, because it calls FT_Reference_Face() on @ft_face, ensuring that @ft_face remains alive as long as the resulting #hb_face_t face object remains alive. Also calls FT_Done_Face() when the #hb_face_t face object is destroyed. Use this version unless you know you have good reasons not to. the new #hb_face_t face object FT_Face to work upon Refreshes the state of @font when the underlying FT_Face has changed. This function should be called after changing the size or variation-axis settings on the FT_Face. #hb_font_t to work upon Creates an #hb_font_t font object from the specified FT_Face. <note>Note: You must set the face size on @ft_face before calling hb_ft_font_create() on it. HarfBuzz assumes size is always set and will access `size` member of FT_Face unconditionally.</note> This variant of the function does not provide any life-cycle management. Most client programs should use hb_ft_font_create_referenced() instead. If you know you have valid reasons not to use hb_ft_font_create_referenced(), then it is the client program's responsibility to destroy @ft_face after the #hb_font_t font object has been destroyed. HarfBuzz will use the @destroy callback on the #hb_font_t font object if it is supplied when you use this function. However, even if @destroy is provided, it is the client program's responsibility to destroy @ft_face, and it is the client program's responsibility to ensure that @ft_face is destroyed only after the #hb_font_t font object has been destroyed. the new #hb_font_t font object FT_Face to work upon A callback to call when the font object is not needed anymore Creates an #hb_font_t font object from the specified FT_Face. <note>Note: You must set the face size on @ft_face before calling hb_ft_font_create_referenced() on it. HarfBuzz assumes size is always set and will access `size` member of FT_Face unconditionally.</note> This is the preferred variant of the hb_ft_font_create* function family, because it calls FT_Reference_Face() on @ft_face, ensuring that @ft_face remains alive as long as the resulting #hb_font_t font object remains alive. Use this version unless you know you have good reasons not to. the new #hb_font_t font object FT_Face to work upon Fetches the FT_Face associated with the specified #hb_font_t font object. the FT_Face found or `NULL` #hb_font_t to work upon Fetches the FT_Load_Glyph load flags of the specified #hb_font_t. For more information, see https://www.freetype.org/freetype2/docs/reference/ft2-base_interface.html#ft_load_xxx FT_Load_Glyph flags found #hb_font_t to work upon Gets the FT_Face associated with @font, This face will be kept around until you call hb_ft_font_unlock_face(). the FT_Face associated with @font or `NULL` #hb_font_t to work upon Configures the font-functions structure of the specified #hb_font_t font object to use FreeType font functions. In particular, you can use this function to configure an existing #hb_face_t face object for use with FreeType font functions even if that #hb_face_t face object was initially created with hb_face_create(), and therefore was not initially configured to use FreeType font functions. An #hb_face_t face object created with hb_ft_face_create() is preconfigured for FreeType font functions and does not require this function to be used. <note>Note: Internally, this function creates an FT_Face. </note> #hb_font_t to work upon Sets the FT_Load_Glyph load flags for the specified #hb_font_t. For more information, see https://www.freetype.org/freetype2/docs/reference/ft2-base_interface.html#ft_load_xxx #hb_font_t to work upon The FreeType load flags to set Releases an FT_Face previously obtained with hb_ft_font_lock_face(). #hb_font_t to work upon Refreshes the state of the underlying FT_Face of @font when the hb_font_t @font has changed. This function should be called after changing the size or variation-axis settings on the @font. This call is fast if nothing has changed on @font. true if changed, false otherwise #hb_font_t to work upon Creates an #hb_blob_t blob from the specified GBytes data structure. the new #hb_blob_t blob object the GBytes structure to work upon Fetches a Unicode-functions structure that is populated with the appropriate GLib function for each method. a pointer to the #hb_unicode_funcs_t Unicode-functions structure Fetches the GUnicodeScript identifier that corresponds to the specified #hb_script_t script. the GUnicodeScript identifier found The #hb_script_t to query Fetches the #hb_script_t script that corresponds to the specified GUnicodeScript identifier. the #hb_script_t script found The GUnicodeScript identifier to query Glyph extent values, measured in font units. Note that @height is negative, in coordinate systems that grow up. Distance from the x-origin to the left extremum of the glyph. Distance from the top extremum of the glyph to the y-origin. Distance from the left extremum of the glyph to the right extremum. Distance from the top extremum of the glyph to the bottom extremum. Flags for #hb_glyph_info_t. Indicates that if input text is broken at the beginning of the cluster this glyph is part of, then both sides need to be re-shaped, as the result might be different. On the flip side, it means that when this flag is not present, then it is safe to break the glyph-run at the beginning of this cluster, and the two sides will represent the exact same result one would get if breaking input text at the beginning of this cluster and shaping the two sides separately. This can be used to optimize paragraph layout, by avoiding re-shaping of each line after line-breaking. Indicates that if input text is changed on one side of the beginning of the cluster this glyph is part of, then the shaping results for the other side might change. Note that the absence of this flag will NOT by itself mean that it IS safe to concat text. Only two pieces of text both of which clear of this flag can be concatenated safely. This can be used to optimize paragraph layout, by avoiding re-shaping of each line after line-breaking, by limiting the reshaping to a small piece around the breaking positin only, even if the breaking position carries the #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when hyphenation or other text transformation happens at line-break position, in the following way: 1. Iterate back from the line-break position until the first cluster start position that is NOT unsafe-to-concat, 2. shape the segment from there till the end of line, 3. check whether the resulting glyph-run also is clear of the unsafe-to-concat at its start-of-text position; if it is, just splice it into place and the line is shaped; If not, move on to a position further back that is clear of unsafe-to-concat and retry from there, and repeat. At the start of next line a similar algorithm can be implemented. That is: 1. Iterate forward from the line-break position until the first cluster start position that is NOT unsafe-to-concat, 2. shape the segment from beginning of the line to that position, 3. check whether the resulting glyph-run also is clear of the unsafe-to-concat at its end-of-text position; if it is, just splice it into place and the beginning is shaped; If not, move on to a position further forward that is clear of unsafe-to-concat and retry up to there, and repeat. A slight complication will arise in the implementation of the algorithm above, because while our buffer API has a way to return flags for position corresponding to start-of-text, there is currently no position corresponding to end-of-text. This limitation can be alleviated by shaping more text than needed and looking for unsafe-to-concat flag within text clusters. The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will always imply this flag. To use this flag, you must enable the buffer flag @HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT during shaping, otherwise the buffer flag will not be reliably produced. Since: 4.0.0 In scripts that use elongation (Arabic, Mongolian, Syriac, etc.), this flag signifies that it is safe to insert a U+0640 TATWEEL character before this cluster for elongation. This flag does not determine the script-specific elongation places, but only when it is safe to do the elongation without interrupting text shaping. Since: 5.1.0 All the currently defined flags. Returns glyph flags encoded within a #hb_glyph_info_t. The #hb_glyph_flags_t encoded within @info a #hb_glyph_info_t The #hb_glyph_info_t is the structure that holds information about the glyphs and their relation to input text. either a Unicode code point (before shaping) or a glyph index (after shaping). the index of the character in the original text that corresponds to this #hb_glyph_info_t, or whatever the client passes to hb_buffer_add(). More than one #hb_glyph_info_t can have the same @cluster value, if they resulted from the same character (e.g. one to many glyph substitution), and when more than one character gets merged in the same glyph (e.g. many to one glyph substitution) the #hb_glyph_info_t will have the smallest cluster value of them. By default some characters are merged into the same cluster (e.g. combining marks have the same cluster as their bases) even if they are separate glyphs, hb_buffer_set_cluster_level() allow selecting more fine-grained cluster handling. The #hb_glyph_position_t is the structure that holds the positions of the glyph in both horizontal and vertical directions. All positions in #hb_glyph_position_t are relative to the current point. how much the line advances after drawing this glyph when setting text in horizontal direction. how much the line advances after drawing this glyph when setting text in vertical direction. how much the glyph moves on the X-axis before drawing it, this should not affect how much the line advances. how much the glyph moves on the Y-axis before drawing it, this should not affect how much the line advances. Fetches the Graphite2 gr_face corresponding to the specified #hb_face_t face object. the gr_face found @hb_face_t to query Always returns `NULL`. Use hb_graphite2_face_get_gr_face() instead. Graphite2 font associated with @font. An #hb_font_t Functions for querying AAT Layout features in the font face. HarfBuzz supports all of the AAT tables used to implement shaping. Other AAT tables and their associated features are not supported. Blobs wrap a chunk of binary data to handle lifecycle management of data while it is passed between client and HarfBuzz. Blobs are primarily used to create font faces, but also to access font face tables, as well as pass around other binary data. Buffers serve a dual role in HarfBuzz; before shaping, they hold the input characters that are passed to hb_shape(), and after shaping they hold the output glyphs. Common data types used across HarfBuzz are defined here. These API have been deprecated in favor of newer API, or because they were deemed unnecessary. Functions for drawing (extracting) glyph shapes. A font face is an object that represents a single face from within a font family. More precisely, a font face represents a single face in a binary font file. Font faces are typically built from a binary blob and a face index. Font faces are used to create fonts. Functions for working with font objects. A font object represents a font face at a specific size and with certain other parameters (pixels-per-em, points-per-em, variation settings) specified. Font objects are created from font face objects, and are used as input to hb_shape(), among other things. Client programs can optionally pass in their own functions that implement the basic, lower-level queries of font objects. This set of font functions is defined by the virtual methods in #hb_font_funcs_t. HarfBuzz provides a built-in set of lightweight default functions for each method in #hb_font_funcs_t. Functions for using HarfBuzz with the FreeType library. HarfBuzz supports using FreeType to provide face and font data. <note>Note that FreeType is not thread-safe, therefore these functions are not thread-safe either.</note> Functions for using HarfBuzz with the GLib library. HarfBuzz supports using GLib to provide Unicode data, by attaching GLib functions to the virtual methods in a #hb_unicode_funcs_t function structure. Support for using HarfBuzz with the GObject library to provide type data. The types and functions listed here are solely a linkage between HarfBuzz's public data types and the GTypes used by the GObject framework. HarfBuzz uses GObject introspection to generate its Python bindings (and potentially other language bindings); client programs should never need to access the GObject-integration mechanics. For client programs using the GNOME and GTK software stack, please see the GLib and FreeType integration pages. Functions for using HarfBuzz with fonts that include Graphite features. For Graphite features to work, you must be sure that HarfBuzz was compiled with the `graphite2` shaping engine enabled. Currently, the default is to not enable `graphite2` shaping. Map objects are integer-to-integer hash-maps. Currently they are not used in the HarfBuzz public API, but are provided for client's use if desired. Functions for fetching color-font information from OpenType font faces. HarfBuzz supports `COLR`/`CPAL`, `sbix`, `CBDT`, and `SVG` color fonts. Functions for using OpenType fonts with hb_shape(). Note that fonts returned by hb_font_create() default to using these functions, so most clients would never need to call these functions directly. Functions for querying OpenType Layout features in the font face. Functions for fetching mathematics layout data from OpenType fonts. HarfBuzz itself does not implement a math layout solution. The functions and types provided can be used by client programs to access the font data necessary for typesetting OpenType Math layout. Functions for fetching metadata from fonts. Functions for fetching metrics from fonts. Functions for fetching name strings from OpenType fonts. Support functions for OpenType shaping related queries. Functions for fetching information about OpenType Variable Fonts. Set objects represent a mathematical set of integer values. They are used in non-shaping APIs to query certain sets of characters or glyphs, or other integer values. Shaping is the central operation of HarfBuzz. Shaping operates on buffers, which are sequences of Unicode characters that use the same font and have the same text direction, script, and language. After shaping the buffer contains the output glyphs and their positions. Shape plans are an internal mechanism. Each plan contains state describing how HarfBuzz will shape a particular text segment, based on the combination of segment properties and the capabilities in the font face in use. Shape plans are not used for shaping directly, but can be queried to access certain information about how shaping will perform, given a set of specific input parameters (script, language, direction, features, etc.). Most client programs will not need to deal with shape plans directly. Functions for fetching style information from fonts. Unicode functions are used to access Unicode character properties. With these functions, client programs can query various properties from the Unicode Character Database for any code point, such as General Category (gc), Script (sc), Canonical Combining Class (ccc), etc. Client programs can optionally pass in their own Unicode functions that implement the same queries. The set of functions available is defined by the virtual methods in #hb_unicode_funcs_t. HarfBuzz provides built-in default functions for each method in #hb_unicode_funcs_t. These functions and macros allow accessing version of the HarfBuzz library used at compile- as well as run-time, and to direct code conditionally based on those versions, again, at compile- or run-time. Converts @str representing a BCP 47 language tag to the corresponding #hb_language_t. The #hb_language_t corresponding to the BCP 47 language tag. a string representing a BCP 47 language tag length of the @str, or -1 if it is `NULL`-terminated. Fetch the default language from current locale. <note>Note that the first time this function is called, it calls "setlocale (LC_CTYPE, nullptr)" to fetch current locale. The underlying setlocale function is, in many implementations, NOT threadsafe. To avoid problems, call this function once before multiple threads can call it. This function is only used from hb_buffer_guess_segment_properties() by HarfBuzz itself.</note> The default language of the locale as an #hb_language_t Check whether a second language tag is the same or a more specific version of the provided language tag. For example, "fa_IR.utf8" is a more specific tag for "fa" or for "fa_IR". `true` if languages match, `false` otherwise. The #hb_language_t to work on Another #hb_language_t Data type for languages. Each #hb_language_t corresponds to a BCP 47 language tag. Converts an #hb_language_t to a string. A `NULL`-terminated string representing the @language. Must not be freed by the caller. The #hb_language_t to convert Converts an #hb_language_t to a string. A `NULL`-terminated string representing the @language. Must not be freed by the caller. The #hb_language_t to convert Tests whether memory allocation for a set was successful. `true` if allocation succeeded, `false` otherwise A map Clears out the contents of @map. A map Allocate a copy of @map. Newly-allocated map. A map Creates a new, initially empty map. The new #hb_map_t Removes @key and its stored value from @map. A map The key to delete Decreases the reference count on a map. When the reference count reaches zero, the map is destroyed, freeing all memory. A map Fetches the value stored for @key in @map. A map The key to query Fetches the singleton empty #hb_map_t. The empty #hb_map_t Returns the number of key-value pairs in the map. The population of @map A map Fetches the user data associated with the specified key, attached to the specified map. A pointer to the user data A map The user-data key to query Tests whether @key is an element of @map. `true` if @key is found in @map, `false` otherwise A map The key to query Creates a hash representing @map. A hash of @map. A map Tests whether @map is empty (contains no elements). `true` if @map is empty A map Tests whether @map and @other are equal (contain the same elements). `true` if the two maps are equal, `false` otherwise. A map Another map Increases the reference count on a map. The map A map Stores @key:@value in the map. A map The key to store in the map The value to store for @key Attaches a user-data key/data pair to the specified map. `true` if success, `false` otherwise A map The user-data key to set A pointer to the user data to set A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Data type for holding integer-to-integer hash maps. Data type holding the memory modes available to client programs. Regarding these various memory-modes: - In no case shall the HarfBuzz client modify memory that is passed to HarfBuzz in a blob. If there is any such possibility, @HB_MEMORY_MODE_DUPLICATE should be used such that HarfBuzz makes a copy immediately, - Use @HB_MEMORY_MODE_READONLY otherwise, unless you really really really know what you are doing, - @HB_MEMORY_MODE_WRITABLE is appropriate if you really made a copy of data solely for the purpose of passing to HarfBuzz and doing that just once (no reuse!), - If the font is mmap()ed, it's okay to use @HB_MEMORY_READONLY_MAY_MAKE_WRITABLE, however, using that mode correctly is very tricky. Use @HB_MEMORY_MODE_READONLY instead. HarfBuzz immediately makes a copy of the data. HarfBuzz client will never modify the data, and HarfBuzz will never modify the data. HarfBuzz client made a copy of the data solely for HarfBuzz, so HarfBuzz may modify the data. See above Fetches a list of all color layers for the specified glyph index in the specified face. The list returned will begin at the offset provided. Total number of layers available for the glyph index queried #hb_face_t to work upon The glyph index to query offset of the first layer to retrieve Input = the maximum number of layers to return; Output = the actual number of layers returned (may be zero) The array of layers found Fetches the PNG image for a glyph. This function takes a font object, not a face object, as input. To get an optimally sized PNG blob, the UPEM value must be set on the @font object. If UPEM is unset, the blob returned will be the largest PNG available. If the glyph has no PNG image, the singleton empty blob is returned. An #hb_blob_t containing the PNG image for the glyph, if available #hb_font_t to work upon a glyph index Fetches the SVG document for a glyph. The blob may be either plain text or gzip-encoded. If the glyph has no SVG document, the singleton empty blob is returned. An #hb_blob_t containing the SVG document of the glyph, if available #hb_face_t to work upon a svg glyph index Tests whether a face includes any `COLR` color layers. `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether a face includes a `CPAL` color-palette table. `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether a face has PNG glyph images (either in `CBDT` or `sbix` tables). `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether a face includes any `SVG` glyph images. `true` if data found, `false` otherwise. #hb_face_t to work upon. Pairs of glyph and color index. A color index of 0xFFFF does not refer to a palette color, but indicates that the foreground color should be used. the glyph ID of the layer the palette color index of the layer Fetches the `name` table Name ID that provides display names for the specified color in a face's `CPAL` color palette. Display names can be generic (e.g., "Background") or specific (e.g., "Eye color"). the Name ID found for the color. #hb_face_t to work upon The index of the color Flags that describe the properties of color palette. Default indicating that there is nothing special to note about a color palette. Flag indicating that the color palette is appropriate to use when displaying the font on a light background such as white. Flag indicating that the color palette is appropriate to use when displaying the font on a dark background such as black. Fetches a list of the colors in a color palette. After calling this function, @colors will be filled with the palette colors. If @colors is NULL, the function will just return the number of total colors without storing any actual colors; this can be used for allocating a buffer of suitable size before calling hb_ot_color_palette_get_colors() a second time. the total number of colors in the palette #hb_face_t to work upon the index of the color palette to query offset of the first color to retrieve Input = the maximum number of colors to return; Output = the actual number of colors returned (may be zero) The array of #hb_color_t records found Fetches the number of color palettes in a face. the number of palettes found #hb_face_t to work upon Fetches the flags defined for a color palette. the #hb_ot_color_palette_flags_t of the requested color palette #hb_face_t to work upon The index of the color palette Fetches the `name` table Name ID that provides display names for a `CPAL` color palette. Palette display names can be generic (e.g., "Default") or provide specific, themed names (e.g., "Spring", "Summer", "Fall", and "Winter"). the Named ID found for the palette. If the requested palette has no name the result is #HB_OT_NAME_ID_INVALID. #hb_face_t to work upon The index of the color palette Sets the font functions to use when working with @font. #hb_font_t to work upon Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry. The baseline used by alphabetic scripts such as Latin, Cyrillic and Greek. In vertical writing mode, the alphabetic baseline for characters rotated 90 degrees clockwise. (This would not apply to alphabetic characters that remain upright in vertical writing mode, since these characters are not rotated.) The hanging baseline. In horizontal direction, this is the horizontal line from which syllables seem, to hang in Tibetan and other similar scripts. In vertical writing mode, for Tibetan (or some other similar script) characters rotated 90 degrees clockwise. Ideographic character face bottom or left edge, if the direction is horizontal or vertical, respectively. Ideographic character face top or right edge, if the direction is horizontal or vertical, respectively. The center of the ideographic character face. Since: 4.0.0 Ideographic em-box bottom or left edge, if the direction is horizontal or vertical, respectively. Ideographic em-box top or right edge baseline, The center of the ideographic em-box. Since: 4.0.0 if the direction is horizontal or vertical, respectively. The baseline about which mathematical characters are centered. In vertical writing mode when mathematical characters rotated 90 degrees clockwise, are centered. Fetches a list of all feature indexes in the specified face's GSUB table or GPOS table, underneath the specified scripts, languages, and features. If no list of scripts is provided, all scripts will be queried. If no list of languages is provided, all languages will be queried. If no list of features is provided, all features will be queried. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The array of scripts to collect features for, terminated by %HB_TAG_NONE The array of languages to collect features for, terminated by %HB_TAG_NONE The array of features to collect, terminated by %HB_TAG_NONE The array of feature indexes found for the query Fetches a list of all feature-lookup indexes in the specified face's GSUB table or GPOS table, underneath the specified scripts, languages, and features. If no list of scripts is provided, all scripts will be queried. If no list of languages is provided, all languages will be queried. If no list of features is provided, all features will be queried. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The array of scripts to collect lookups for, terminated by %HB_TAG_NONE The array of languages to collect lookups for, terminated by %HB_TAG_NONE The array of features to collect lookups for, terminated by %HB_TAG_NONE The array of lookup indexes found for the query Fetches a list of the characters defined as having a variant under the specified "Character Variant" ("cvXX") feature tag. Number of total sample characters in the cvXX feature. #hb_face_t to work upon table tag to query, "GSUB" or "GPOS". index of feature to query. offset of the first character to retrieve Input = the maximum number of characters to return; Output = the actual number of characters returned (may be zero) A buffer pointer. The Unicode codepoints of the characters for which this feature provides glyph variants. Fetches a list of all lookups enumerated for the specified feature, in the specified face's GSUB table or GPOS table. The list returned will begin at the offset provided. Total number of lookups. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested feature offset of the first lookup to retrieve Input = the maximum number of lookups to return; Output = the actual number of lookups returned (may be zero) The array of lookup indexes found for the query Fetches name indices from feature parameters for "Stylistic Set" ('ssXX') or "Character Variant" ('cvXX') features. `true` if data found, `false` otherwise #hb_face_t to work upon table tag to query, "GSUB" or "GPOS". index of feature to query. The ‘name’ table name ID that specifies a string for a user-interface label for this feature. (May be NULL.) The ‘name’ table name ID that specifies a string that an application can use for tooltip text for this feature. (May be NULL.) The ‘name’ table name ID that specifies sample text that illustrates the effect of this feature. (May be NULL.) Number of named parameters. (May be zero.) The first ‘name’ table name ID used to specify strings for user-interface labels for the feature parameters. (Must be zero if numParameters is zero.) Fetches a list of all lookups enumerated for the specified feature, in the specified face's GSUB table or GPOS table, enabled at the specified variations index. The list returned will begin at the offset provided. Total number of lookups. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the feature to query The index of the feature variation to query offset of the first lookup to retrieve Input = the maximum number of lookups to return; Output = the actual number of lookups returned (may be zero) The array of lookups found for the query Fetches a list of all attachment points for the specified glyph in the GDEF table of the face. The list returned will begin at the offset provided. Useful if the client program wishes to cache the list. Total number of attachment points for @glyph. The #hb_face_t to work on The #hb_codepoint_t code point to query offset of the first attachment point to retrieve Input = the maximum number of attachment points to return; Output = the actual number of attachment points returned (may be zero) The array of attachment points found for the query Fetches a baseline value from the face. `true` if found baseline value in the font. a font a baseline tag text direction. script tag. language tag, currently unused. baseline value if found. Fetches a baseline value from the face, and synthesizes it if the font does not have it. a font a baseline tag text direction. script tag. language tag, currently unused. baseline value if found. Fetches the GDEF class of the requested glyph in the specified face. The #hb_ot_layout_glyph_class_t glyph class of the given code point in the GDEF table of the face. The #hb_face_t to work on The #hb_codepoint_t code point to query Retrieves the set of all glyphs from the face that belong to the requested glyph class in the face's GDEF table. The #hb_face_t to work on The #hb_ot_layout_glyph_class_t GDEF class to retrieve The #hb_set_t set of all glyphs belonging to the requested class. Fetches the dominant horizontal baseline tag used by @script. dominant baseline tag for the @script. a script tag. Fetches a list of the caret positions defined for a ligature glyph in the GDEF table of the font. The list returned will begin at the offset provided. Note that a ligature that is formed from n characters will have n-1 caret positions. The first character is not represented in the array, since its caret position is the glyph position. The positions returned by this function are 'unshaped', and will have to be fixed up for kerning that may be applied to the ligature glyph. Total number of ligature caret positions for @glyph. The #hb_font_t to work on The #hb_direction_t text direction to use The #hb_codepoint_t code point to query offset of the first caret position to retrieve Input = the maximum number of caret positions to return; Output = the actual number of caret positions returned (may be zero) The array of caret positions found for the query Fetches optical-size feature data (i.e., the `size` feature from GPOS). Note that the subfamily_id and the subfamily name string (accessible via the subfamily_name_id) as used here are defined as pertaining only to fonts within a font family that differ specifically in their respective size ranges; other ways to differentiate fonts within a subfamily are not covered by the `size` feature. For more information on this distinction, see the [`size` feature documentation]( https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-size). `true` if data found, `false` otherwise #hb_face_t to work upon The design size of the face The identifier of the face within the font subfamily The ‘name’ table name ID of the face within the font subfamily The minimum size of the recommended size range for the face The maximum size of the recommended size range for the face The GDEF classes defined for glyphs. Glyphs not matching the other classifications Spacing, single characters, capable of accepting marks Glyphs that represent ligation of multiple characters Non-spacing, combining glyphs that represent marks Spacing glyphs that represent part of a single character Tests whether a face has any glyph classes defined in its GDEF table. `true` if data found, `false` otherwise #hb_face_t to work upon Tests whether the specified face includes any GPOS positioning. `true` if the face has GPOS data, `false` otherwise #hb_face_t to work upon Tests whether the specified face includes any GSUB substitutions. `true` if data found, `false` otherwise #hb_face_t to work upon Fetches the index of a given feature tag in the specified face's GSUB table or GPOS table, underneath the specified script and language. `true` if the feature is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The index of the requested language tag #hb_tag_t of the feature tag requested The index of the requested feature Fetches a list of all features in the specified face's GSUB table or GPOS table, underneath the specified script and language. The list returned will begin at the offset provided. Total number of features. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The index of the requested language tag offset of the first feature tag to retrieve Input = the maximum number of feature tags to return; Output: the actual number of feature tags returned (may be zero) The array of feature indexes found for the query Fetches a list of all features in the specified face's GSUB table or GPOS table, underneath the specified script and language. The list returned will begin at the offset provided. Total number of feature tags. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The index of the requested language tag offset of the first feature tag to retrieve Input = the maximum number of feature tags to return; Output = the actual number of feature tags returned (may be zero) The array of #hb_tag_t feature tags found for the query Fetches the tag of a requested feature index in the given face's GSUB or GPOS table, underneath the specified script and language. `true` if the feature is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The index of the requested language tag The index of the requested feature The #hb_tag_t of the requested feature Fetches the index of a requested feature in the given face's GSUB or GPOS table, underneath the specified script and language. `true` if the feature is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The index of the requested language tag The index of the requested feature Fetches a list of all glyphs affected by the specified lookup in the specified face's GSUB table or GPOS table. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the feature lookup to query Array of glyphs preceding the substitution range Array of input glyphs that would be substituted by the lookup Array of glyphs following the substitution range Array of glyphs that would be the substituted output of the lookup Fetches alternates of a glyph from a given GSUB lookup index. Total number of alternates found in the specific lookup index for the given glyph id. a face. index of the feature lookup to query. a glyph id. starting offset. Input = the maximum number of alternate glyphs to return; Output = the actual number of alternate glyphs returned (may be zero). A glyphs buffer. Alternate glyphs associated with the glyph id. Compute the transitive closure of glyphs needed for a specified lookup. #hb_face_t to work upon index of the feature lookup to query Array of glyphs comprising the transitive closure of the lookup Tests whether a specified lookup in the specified face would trigger a substitution on the given glyph sequence. `true` if a substitution would be triggered, `false` otherwise #hb_face_t to work upon The index of the lookup to query The sequence of glyphs to query for substitution The length of the glyph sequence #hb_bool_t indicating whether pre-/post-context are disallowed in substitutions Compute the transitive closure of glyphs needed for all of the provided lookups. #hb_face_t to work upon The set of lookups to query Array of glyphs comprising the transitive closure of the lookups Fetches the index of a given language tag in the specified face's GSUB table or GPOS table, underneath the specified script tag. `true` if the language tag is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The #hb_tag_t of the requested language The index of the requested language Fetches a list of language tags in the given face's GSUB or GPOS table, underneath the specified script index. The list returned will begin at the offset provided. Total number of language tags. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag offset of the first language tag to retrieve Input = the maximum number of language tags to return; Output = the actual number of language tags returned (may be zero) Array of language tags found in the table Fetches the index of the first language tag fom @language_tags that is present in the specified face's GSUB or GPOS table, underneath the specified script index. If none of the given language tags is found, `false` is returned and @language_index is set to the default language index. `true` if one of the given language tags is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The index of the requested script tag The number of languages in the specified script The array of language tags The index of the requested language Deprecated since 2.0.0 #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS Array of #hb_tag_t script tags The index of the requested script tag #hb_tag_t of the script tag requested Fetches a list of feature variations in the specified face's GSUB table or GPOS table, at the specified variation coordinates. `true` if feature variations were found, `false` otherwise. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS The variation coordinates to query The number of variation coordinates The array of feature variations found for the query Fetches the index if a given script tag in the specified face's GSUB table or GPOS table. `true` if the script is found, `false` otherwise #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS #hb_tag_t of the script tag requested The index of the requested script tag Fetches a list of all feature tags in the given face's GSUB or GPOS table. Note that there might be duplicate feature tags, belonging to different script/language-system pairs of the table. Total number of feature tags. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS offset of the first feature tag to retrieve Input = the maximum number of feature tags to return; Output = the actual number of feature tags returned (may be zero) Array of feature tags found in the table Fetches the total number of lookups enumerated in the specified face's GSUB table or GPOS table. Total number of lookups. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS Fetches a list of all scripts enumerated in the specified face's GSUB table or GPOS table. The list returned will begin at the offset provided. Total number of script tags. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS offset of the first script tag to retrieve Input = the maximum number of script tags to return; Output = the actual number of script tags returned (may be zero) The array of #hb_tag_t script tags found for the query Selects an OpenType script for @table_tag from the @script_tags array. If the table does not have any of the requested scripts, then `DFLT`, `dflt`, and `latn` tags are tried in that order. If the table still does not have any of these scripts, @script_index and @chosen_script are set to #HB_OT_LAYOUT_NO_SCRIPT_INDEX. `true` if one of the requested scripts is selected, `false` if a fallback script is selected or if no scripts are selected. #hb_face_t to work upon #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS Number of script tags in the array Array of #hb_tag_t script tags The index of the requested script #hb_tag_t of the requested script The 'MATH' table constants, refer to [OpenType documentation](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table) For more explanations. scriptPercentScaleDown scriptScriptPercentScaleDown delimitedSubFormulaMinHeight displayOperatorMinHeight mathLeading axisHeight accentBaseHeight flattenedAccentBaseHeight subscriptShiftDown subscriptTopMax subscriptBaselineDropMin superscriptShiftUp superscriptShiftUpCramped superscriptBottomMin superscriptBaselineDropMax subSuperscriptGapMin superscriptBottomMaxWithSubscript spaceAfterScript upperLimitGapMin upperLimitBaselineRiseMin lowerLimitGapMin lowerLimitBaselineDropMin stackTopShiftUp stackTopDisplayStyleShiftUp stackBottomShiftDown stackBottomDisplayStyleShiftDown stackGapMin stackDisplayStyleGapMin stretchStackTopShiftUp stretchStackBottomShiftDown stretchStackGapAboveMin stretchStackGapBelowMin fractionNumeratorShiftUp fractionNumeratorDisplayStyleShiftUp fractionDenominatorShiftDown fractionDenominatorDisplayStyleShiftDown fractionNumeratorGapMin fractionNumDisplayStyleGapMin fractionRuleThickness fractionDenominatorGapMin fractionDenomDisplayStyleGapMin skewedFractionHorizontalGap skewedFractionVerticalGap overbarVerticalGap overbarRuleThickness overbarExtraAscender underbarVerticalGap underbarRuleThickness underbarExtraDescender radicalVerticalGap radicalDisplayStyleVerticalGap radicalRuleThickness radicalExtraAscender radicalKernBeforeDegree radicalKernAfterDegree radicalDegreeBottomRaisePercent Fetches the specified math constant. For most constants, the value returned is an #hb_position_t. However, if the requested constant is #HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN, #HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN or #HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN, then the return value is an integer between 0 and 100 representing that percentage. the requested constant or zero #hb_font_t to work upon #hb_ot_math_constant_t the constant to retrieve Fetches the GlyphAssembly for the specified font, glyph index, and direction. Returned are a list of #hb_ot_math_glyph_part_t glyph parts that can be used to draw the glyph and an italics-correction value (if one is defined in the font). <note>The @direction parameter is only used to select between horizontal or vertical directions for the construction. Even though all #hb_direction_t values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is considered.</note> the total number of parts in the glyph assembly #hb_font_t to work upon The index of the glyph to stretch direction of the stretching (horizontal or vertical) offset of the first glyph part to retrieve Input = maximum number of glyph parts to return; Output = actual number of parts returned the glyph parts returned italics correction of the glyph assembly Fetches an italics-correction value (if one exists) for the specified glyph index. the italics correction of the glyph or zero #hb_font_t to work upon The glyph index from which to retrieve the value Fetches the math kerning (cut-ins) value for the specified font, glyph index, and @kern. If the MathKern table is found, the function examines it to find a height value that is greater or equal to @correction_height. If such a height value is found, corresponding kerning value from the table is returned. If no such height value is found, the last kerning value is returned. requested kerning value or zero #hb_font_t to work upon The glyph index from which to retrieve the value The #hb_ot_math_kern_t from which to retrieve the value the correction height to use to determine the kerning. Fetches the raw MathKern (cut-in) data for the specified font, glyph index, and @kern. The corresponding list of kern values and correction heights is returned as a list of #hb_ot_math_kern_entry_t structs. See also #hb_ot_math_get_glyph_kerning, which handles selecting the appropriate kern value for a given correction height. <note>For a glyph with @n defined kern values (where @n > 0), there are only @n−1 defined correction heights, as each correction height defines a boundary past which the next kern value should be selected. Therefore, only the #hb_ot_math_kern_entry_t.kern_value of the uppermost #hb_ot_math_kern_entry_t actually comes from the font; its corresponding #hb_ot_math_kern_entry_t.max_correction_height is always set to <code>INT32_MAX</code>.</note> the total number of kern values available or zero #hb_font_t to work upon The glyph index from which to retrieve the kernings The #hb_ot_math_kern_t from which to retrieve the kernings offset of the first kern entry to retrieve Input = the maximum number of kern entries to return; Output = the actual number of kern entries returned array of kern entries returned Fetches a top-accent-attachment value (if one exists) for the specified glyph index. For any glyph that does not have a top-accent-attachment value - that is, a glyph not covered by the `MathTopAccentAttachment` table (or, when @font has no `MathTopAccentAttachment` table or no `MATH` table, any glyph) - the function synthesizes a value, returning the position at one-half the glyph's advance width. the top accent attachment of the glyph or 0.5 * the advance width of @glyph #hb_font_t to work upon The glyph index from which to retrieve the value Fetches the MathGlyphConstruction for the specified font, glyph index, and direction. The corresponding list of size variants is returned as a list of #hb_ot_math_glyph_variant_t structs. <note>The @direction parameter is only used to select between horizontal or vertical directions for the construction. Even though all #hb_direction_t values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is considered.</note> the total number of size variants available or zero #hb_font_t to work upon The index of the glyph to stretch The direction of the stretching (horizontal or vertical) offset of the first variant to retrieve Input = the maximum number of variants to return; Output = the actual number of variants returned array of variants returned Fetches the MathVariants table for the specified font and returns the minimum overlap of connecting glyphs that are required to draw a glyph assembly in the specified direction. <note>The @direction parameter is only used to select between horizontal or vertical directions for the construction. Even though all #hb_direction_t values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is considered.</note> requested minimum connector overlap or zero #hb_font_t to work upon direction of the stretching (horizontal or vertical) Flags for math glyph parts. This is an extender glyph part that can be repeated to reach the desired length. Data type to hold information for a "part" component of a math-variant glyph. Large variants for stretchable math glyphs (such as parentheses) can be constructed on the fly from parts. The glyph index of the variant part The length of the connector on the starting side of the variant part The length of the connector on the ending side of the variant part The total advance of the part #hb_ot_math_glyph_part_flags_t flags for the part Data type to hold math-variant information for a glyph. The glyph index of the variant The advance width of the variant Tests whether a face has a `MATH` table. `true` if the table is found, `false` otherwise #hb_face_t to test Tests whether the given glyph index is an extended shape in the face. `true` if the glyph is an extended shape, `false` otherwise #hb_face_t to work upon The glyph index to test Data type to hold math kerning (cut-in) information for a glyph. The maximum height at which this entry should be used The kern value of the entry The math kerning-table types defined for the four corners of a glyph. The top right corner of the glyph. The top left corner of the glyph. The bottom right corner of the glyph. The bottom left corner of the glyph. Fetches all available feature types. Number of all available feature types. a face object iteration's start offset buffer size as input, filled size as output entries tags buffer It fetches metadata entry of a given tag from a font. A blob containing the blob. a #hb_face_t object. tag of metadata you like to have. Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta Design languages. Text, using only Basic Latin (ASCII) characters. Indicates languages and/or scripts for the user audiences that the font was primarily designed for. Supported languages. Text, using only Basic Latin (ASCII) characters. Indicates languages and/or scripts that the font is declared to be capable of supporting. Fetches metrics value corresponding to @metrics_tag from @font. Whether found the requested metrics in the font. an #hb_font_t object. tag of metrics value you like to fetch. result of metrics value from the font. Fetches metrics value corresponding to @metrics_tag from @font, and synthesizes a value if it the value is missing in the font. an #hb_font_t object. tag of metrics value you like to fetch. result of metrics value from the font. Fetches metrics value corresponding to @metrics_tag from @font with the current font variation settings applied. The requested metric value. an #hb_font_t object. tag of metrics value you like to fetch. Fetches horizontal metrics value corresponding to @metrics_tag from @font with the current font variation settings applied. The requested metric value. an #hb_font_t object. tag of metrics value you like to fetch. Fetches vertical metrics value corresponding to @metrics_tag from @font with the current font variation settings applied. The requested metric value. an #hb_font_t object. tag of metrics value you like to fetch. Metric tags corresponding to [MVAR Value Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/mvar#value-tags) horizontal ascender. horizontal descender. horizontal line gap. horizontal clipping ascent. horizontal clipping descent. vertical ascender. vertical descender. vertical line gap. horizontal caret rise. horizontal caret run. horizontal caret offset. vertical caret rise. vertical caret run. vertical caret offset. x height. cap height. subscript em x size. subscript em y size. subscript em x offset. subscript em y offset. superscript em x size. superscript em y size. superscript em x offset. superscript em y offset. strikeout size. strikeout offset. underline size. underline offset. Structure representing a name ID in a particular language. name ID language Fetches a font name from the OpenType 'name' table. If @language is #HB_LANGUAGE_INVALID, English ("en") is assumed. Returns string in UTF-16 encoding. A NUL terminator is always written for convenience, and isn't included in the output @text_size. full length of the requested string, or 0 if not found. font face. OpenType name identifier to fetch. language to fetch the name for. input size of @text buffer, and output size of text written to buffer. buffer to write fetched name into. Fetches a font name from the OpenType 'name' table. If @language is #HB_LANGUAGE_INVALID, English ("en") is assumed. Returns string in UTF-32 encoding. A NUL terminator is always written for convenience, and isn't included in the output @text_size. full length of the requested string, or 0 if not found. font face. OpenType name identifier to fetch. language to fetch the name for. input size of @text buffer, and output size of text written to buffer. buffer to write fetched name into. Fetches a font name from the OpenType 'name' table. If @language is #HB_LANGUAGE_INVALID, English ("en") is assumed. Returns string in UTF-8 encoding. A NUL terminator is always written for convenience, and isn't included in the output @text_size. full length of the requested string, or 0 if not found. font face. OpenType name identifier to fetch. language to fetch the name for. input size of @text buffer, and output size of text written to buffer. buffer to write fetched name into. Enumerates all available name IDs and language combinations. Returned array is owned by the @face and should not be modified. It can be used as long as @face is alive. Array of available name entries. font face. number of returned entries. Computes the transitive closure of glyphs needed for a specified input buffer under the given font and feature list. The closure is computed as a set, not as a list. #hb_font_t to work upon The input buffer to compute from The features enabled on the buffer The number of features enabled on the buffer The #hb_set_t set of glyphs comprising the transitive closure of the query Computes the complete set of GSUB or GPOS lookups that are applicable under a given @shape_plan. #hb_shape_plan_t to query GSUB or GPOS The #hb_set_t set of lookups returned Converts a language tag to an #hb_language_t. The #hb_language_t corresponding to @tag. an language tag Converts a script tag to an #hb_script_t. The #hb_script_t corresponding to @tag. a script tag Converts an #hb_script_t and an #hb_language_t to script and language tags. an #hb_script_t to convert. an #hb_language_t to convert. maximum number of script tags to retrieve (IN) and actual number of script tags retrieved (OUT) array of size at least @script_count to store the script tag results maximum number of language tags to retrieve (IN) and actual number of language tags retrieved (OUT) array of size at least @language_count to store the language tag results Converts a script tag and a language tag to an #hb_script_t and an #hb_language_t. a script tag a language tag the #hb_script_t corresponding to @script_tag. the #hb_language_t corresponding to @script_tag and @language_tag. Flags for #hb_ot_var_axis_info_t. The axis should not be exposed directly in user interfaces. Data type for holding variation-axis values. The minimum, default, and maximum values are in un-normalized, user scales. <note>Note: at present, the only flag defined for @flags is #HB_OT_VAR_AXIS_FLAG_HIDDEN.</note> Index of the axis in the variation-axis array The #hb_tag_t tag identifying the design variation of the axis The `name` table Name ID that provides display names for the axis The #hb_ot_var_axis_flags_t flags for the axis The minimum value on the variation axis that the font covers The position on the variation axis corresponding to the font's defaults The maximum value on the variation axis that the font covers Use #hb_ot_var_axis_info_t instead. axis tag axis name identifier minimum value of the axis default value of the axis maximum value of the axis Fetches the variation-axis information corresponding to the specified axis tag in the specified face. - use hb_ot_var_find_axis_info() instead #hb_face_t to work upon The #hb_tag_t of the variation axis to query The index of the variation axis The #hb_ot_var_axis_info_t of the axis tag queried Fetches the variation-axis information corresponding to the specified axis tag in the specified face. `true` if data found, `false` otherwise #hb_face_t to work upon The #hb_tag_t of the variation axis to query The #hb_ot_var_axis_info_t of the axis tag queried Fetches a list of all variation axes in the specified face. The list returned will begin at the offset provided. use hb_ot_var_get_axis_infos() instead #hb_face_t to work upon offset of the first lookup to retrieve Input = the maximum number of variation axes to return; Output = the actual number of variation axes returned (may be zero) The array of variation axes found Fetches the number of OpenType variation axes included in the face. the number of variation axes defined The #hb_face_t to work on Fetches a list of all variation axes in the specified face. The list returned will begin at the offset provided. the number of variation axes in the face #hb_face_t to work upon offset of the first lookup to retrieve Input = the maximum number of variation axes to return; Output = the actual number of variation axes returned (may be zero) The array of variation axes found Fetches the number of named instances included in the face. the number of named instances defined The #hb_face_t to work on Tests whether a face includes any OpenType variation data in the `fvar` table. `true` if data found, `false` otherwise The #hb_face_t to work on Fetches the design-space coordinates corresponding to the given named instance in the face. the number of variation axes in the face The #hb_face_t to work on The index of the named instance to query Input = the maximum number of coordinates to return; Output = the actual number of coordinates returned (may be zero) The array of coordinates found for the query Fetches the `name` table Name ID that provides display names for the "PostScript name" defined for the given named instance in the face. the Name ID found for the PostScript name The #hb_face_t to work on The index of the named instance to query Fetches the `name` table Name ID that provides display names for the "Subfamily name" defined for the given named instance in the face. the Name ID found for the Subfamily name The #hb_face_t to work on The index of the named instance to query Normalizes the given design-space coordinates. The minimum and maximum values for the axis are mapped to the interval [-1,1], with the default axis value mapped to 0. The normalized values have 14 bits of fixed-point sub-integer precision as per OpenType specification. Any additional scaling defined in the face's `avar` table is also applied, as described at https://docs.microsoft.com/en-us/typography/opentype/spec/avar The #hb_face_t to work on The length of the coordinate array The design-space coordinates to normalize The normalized coordinates Normalizes all of the coordinates in the given list of variation axes. The #hb_face_t to work on The array of variations to normalize The number of variations to normalize The array of normalized coordinates The length of the coordinate array Callback function for hb_face_create_for_tables(). A pointer to the @tag table within @face an #hb_face_t to reference table for the tag of the table to reference User data pointer passed by the caller Converts an ISO 15924 script tag to a corresponding #hb_script_t. An #hb_script_t corresponding to the ISO 15924 tag. an #hb_tag_t representing an ISO 15924 tag. Converts a string @str representing an ISO 15924 script tag to a corresponding #hb_script_t. Shorthand for hb_tag_from_string() then hb_script_from_iso15924_tag(). An #hb_script_t corresponding to the ISO 15924 tag. a string representing an ISO 15924 tag. length of the @str, or -1 if it is `NULL`-terminated. Fetches the #hb_direction_t of a script when it is set horizontally. All right-to-left scripts will return #HB_DIRECTION_RTL. All left-to-right scripts will return #HB_DIRECTION_LTR. Scripts that can be written either horizontally or vertically will return #HB_DIRECTION_INVALID. Unknown scripts will return #HB_DIRECTION_LTR. The horizontal #hb_direction_t of @script The #hb_script_t to query Data type for scripts. Each #hb_script_t's value is an #hb_tag_t corresponding to the four-letter values defined by [ISO 15924](https://unicode.org/iso15924/). See also the Script (sc) property of the Unicode Character Database. `Zyyy` `Zinh` `Zzzz` `Arab` `Armn` `Beng` `Cyrl` `Deva` `Geor` `Grek` `Gujr` `Guru` `Hang` `Hani` `Hebr` `Hira` `Knda` `Kana` `Laoo` `Latn` `Mlym` `Orya` `Taml` `Telu` `Thai` `Tibt` `Bopo` `Brai` `Cans` `Cher` `Ethi` `Khmr` `Mong` `Mymr` `Ogam` `Runr` `Sinh` `Syrc` `Thaa` `Yiii` `Dsrt` `Goth` `Ital` `Buhd` `Hano` `Tglg` `Tagb` `Cprt` `Limb` `Linb` `Osma` `Shaw` `Tale` `Ugar` `Bugi` `Copt` `Glag` `Khar` `Talu` `Xpeo` `Sylo` `Tfng` `Bali` `Xsux` `Nkoo` `Phag` `Phnx` `Cari` `Cham` `Kali` `Lepc` `Lyci` `Lydi` `Olck` `Rjng` `Saur` `Sund` `Vaii` `Avst` `Bamu` `Egyp` `Armi` `Phli` `Prti` `Java` `Kthi` `Lisu` `Mtei` `Sarb` `Orkh` `Samr` `Lana` `Tavt` `Batk` `Brah` `Mand` `Cakm` `Merc` `Mero` `Plrd` `Shrd` `Sora` `Takr` `Bass`, Since: 0.9.30 `Aghb`, Since: 0.9.30 `Dupl`, Since: 0.9.30 `Elba`, Since: 0.9.30 `Gran`, Since: 0.9.30 `Khoj`, Since: 0.9.30 `Sind`, Since: 0.9.30 `Lina`, Since: 0.9.30 `Mahj`, Since: 0.9.30 `Mani`, Since: 0.9.30 `Mend`, Since: 0.9.30 `Modi`, Since: 0.9.30 `Mroo`, Since: 0.9.30 `Nbat`, Since: 0.9.30 `Narb`, Since: 0.9.30 `Perm`, Since: 0.9.30 `Hmng`, Since: 0.9.30 `Palm`, Since: 0.9.30 `Pauc`, Since: 0.9.30 `Phlp`, Since: 0.9.30 `Sidd`, Since: 0.9.30 `Tirh`, Since: 0.9.30 `Wara`, Since: 0.9.30 `Ahom`, Since: 0.9.30 `Hluw`, Since: 0.9.30 `Hatr`, Since: 0.9.30 `Mult`, Since: 0.9.30 `Hung`, Since: 0.9.30 `Sgnw`, Since: 0.9.30 `Adlm`, Since: 1.3.0 `Bhks`, Since: 1.3.0 `Marc`, Since: 1.3.0 `Osge`, Since: 1.3.0 `Tang`, Since: 1.3.0 `Newa`, Since: 1.3.0 `Gonm`, Since: 1.6.0 `Nshu`, Since: 1.6.0 `Soyo`, Since: 1.6.0 `Zanb`, Since: 1.6.0 `Dogr`, Since: 1.8.0 `Gong`, Since: 1.8.0 `Rohg`, Since: 1.8.0 `Maka`, Since: 1.8.0 `Medf`, Since: 1.8.0 `Sogo`, Since: 1.8.0 `Sogd`, Since: 1.8.0 `Elym`, Since: 2.4.0 `Nand`, Since: 2.4.0 `Hmnp`, Since: 2.4.0 `Wcho`, Since: 2.4.0 `Chrs`, Since: 2.6.7 `Diak`, Since: 2.6.7 `Kits`, Since: 2.6.7 `Yezi`, Since: 2.6.7 `Cpmn`, Since: 3.0.0 `Ougr`, Since: 3.0.0 `Tnsa`, Since: 3.0.0 `Toto`, Since: 3.0.0 `Vith`, Since: 3.0.0 `Zmth`, Since: 3.4.0 `Kawi`, Since: 5.2.0 `Nagm`, Since: 5.2.0 No script set Converts an #hb_script_t to a corresponding ISO 15924 script tag. An #hb_tag_t representing an ISO 15924 script tag. an #hb_script_t to convert. Checks the equality of two #hb_segment_properties_t's. `true` if all properties of @a equal those of @b, `false` otherwise. first #hb_segment_properties_t to compare. second #hb_segment_properties_t to compare. Creates a hash representing @p. A hash of @p. #hb_segment_properties_t to hash. Fills in missing fields of @p from @src in a considered manner. First, if @p does not have direction set, direction is copied from @src. Next, if @p and @src have the same direction (which can be unset), if @p does not have script set, script is copied from @src. Finally, if @p and @src have the same direction and script (which either can be unset), if @p does not have language set, language is copied from @src. #hb_segment_properties_t to fill in. #hb_segment_properties_t to fill in from. The structure that holds various text properties of an #hb_buffer_t. Can be set and retrieved using hb_buffer_set_segment_properties() and hb_buffer_get_segment_properties(), respectively. the #hb_direction_t of the buffer, see hb_buffer_set_direction(). the #hb_script_t of the buffer, see hb_buffer_set_script(). the #hb_language_t of the buffer, see hb_buffer_set_language(). Adds @codepoint to @set. A set The element to add to @set Adds all of the elements from @first to @last (inclusive) to @set. A set The first element to add to @set The final element to add to @set Adds @num_codepoints codepoints to a set at once. The codepoints array must be in increasing order, with size at least @num_codepoints. A set Array of codepoints to add Length of @sorted_codepoints Tests whether memory allocation for a set was successful. `true` if allocation succeeded, `false` otherwise A set Clears out the contents of a set. A set Allocate a copy of @set. Newly-allocated set. A set Creates a new, initially empty set. The new #hb_set_t Removes @codepoint from @set. A set Removes @codepoint from @set Removes all of the elements from @first to @last (inclusive) from @set. If @last is #HB_SET_VALUE_INVALID, then all values greater than or equal to @first are removed. A set The first element to remove from @set The final element to remove from @set Decreases the reference count on a set. When the reference count reaches zero, the set is destroyed, freeing all memory. A set Fetches the singleton empty #hb_set_t. The empty #hb_set_t Finds the largest element in the set. maximum of @set, or #HB_SET_VALUE_INVALID if @set is empty. A set Finds the smallest element in the set. minimum of @set, or #HB_SET_VALUE_INVALID if @set is empty. A set Returns the number of elements in the set. The population of @set A set Fetches the user data associated with the specified key, attached to the specified set. A pointer to the user data A set The user-data key to query Tests whether @codepoint belongs to @set. `true` if @codepoint is in @set, `false` otherwise A set The element to query Creates a hash representing @set. A hash of @set. A set Makes @set the intersection of @set and @other. A set Another set Inverts the contents of @set. A set Tests whether a set is empty (contains no elements). `true` if @set is empty a set. Tests whether @set and @other are equal (contain the same elements). `true` if the two sets are equal, `false` otherwise. A set Another set Tests whether @set is a subset of @larger_set. `true` if the @set is a subset of (or equal to) @larger_set, `false` otherwise. A set Another set Fetches the next element in @set that is greater than current value of @codepoint. Set @codepoint to #HB_SET_VALUE_INVALID to get started. `true` if there was a next value, `false` otherwise A set Input = Code point to query Output = Code point retrieved Finds the next element in @set that is greater than @codepoint. Writes out codepoints to @out, until either the set runs out of elements, or @size codepoints are written, whichever comes first. the number of values written. A set Outputting codepoints starting after this one. Use #HB_SET_VALUE_INVALID to get started. An array of codepoints to write to. The maximum number of codepoints to write out. Fetches the next consecutive range of elements in @set that are greater than current value of @last. Set @last to #HB_SET_VALUE_INVALID to get started. `true` if there was a next range, `false` otherwise A set The first code point in the range Input = The current last code point in the range Output = The last code point in the range Fetches the previous element in @set that is lower than current value of @codepoint. Set @codepoint to #HB_SET_VALUE_INVALID to get started. `true` if there was a previous value, `false` otherwise A set Input = Code point to query Output = Code point retrieved Fetches the previous consecutive range of elements in @set that are greater than current value of @last. Set @first to #HB_SET_VALUE_INVALID to get started. `true` if there was a previous range, `false` otherwise A set Input = The current first code point in the range Output = The first code point in the range The last code point in the range Increases the reference count on a set. The set A set Makes the contents of @set equal to the contents of @other. A set Another set Attaches a user-data key/data pair to the specified set. `true` if success, `false` otherwise A set The user-data key to set A pointer to the user data to set A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Subtracts the contents of @other from @set. A set Another set Makes @set the symmetric difference of @set and @other. A set Another set Data type for holding a set of integers. #hb_set_t's are used to gather and contain glyph IDs, Unicode code points, and various other collections of discrete values. Makes @set the union of @set and @other. A set Another set Shapes @buffer using @font turning its Unicode characters content to positioned glyphs. If @features is not `NULL`, it will be used to control the features applied during shaping. If two @features have the same tag but overlapping ranges the value of the feature with the higher index takes precedence. an #hb_font_t to use for shaping an #hb_buffer_t to shape an array of user specified #hb_feature_t or `NULL` the length of @features array See hb_shape() for details. If @shaper_list is not `NULL`, the specified shapers will be used in the given order, otherwise the default shapers list will be used. false if all shapers failed, true otherwise an #hb_font_t to use for shaping an #hb_buffer_t to shape an array of user specified #hb_feature_t or `NULL` the length of @features array a `NULL`-terminated array of shapers to use or `NULL` Retrieves the list of shapers supported by HarfBuzz. an array of constant strings Constructs a shaping plan for a combination of @face, @user_features, @props, and @shaper_list. The shaping plan #hb_face_t to use The #hb_segment_properties_t of the segment The list of user-selected features The number of user-selected features List of shapers to try The variable-font version of #hb_shape_plan_create. Constructs a shaping plan for a combination of @face, @user_features, @props, and @shaper_list, plus the variation-space coordinates @coords. The shaping plan #hb_face_t to use The #hb_segment_properties_t of the segment The list of user-selected features The number of user-selected features The list of variation-space coordinates The number of variation-space coordinates List of shapers to try Creates a cached shaping plan suitable for reuse, for a combination of @face, @user_features, @props, and @shaper_list. The shaping plan #hb_face_t to use The #hb_segment_properties_t of the segment The list of user-selected features The number of user-selected features List of shapers to try The variable-font version of #hb_shape_plan_create_cached. Creates a cached shaping plan suitable for reuse, for a combination of @face, @user_features, @props, and @shaper_list, plus the variation-space coordinates @coords. The shaping plan #hb_face_t to use The #hb_segment_properties_t of the segment The list of user-selected features The number of user-selected features The list of variation-space coordinates The number of variation-space coordinates List of shapers to try Decreases the reference count on the given shaping plan. When the reference count reaches zero, the shaping plan is destroyed, freeing all memory. A shaping plan Executes the given shaping plan on the specified buffer, using the given @font and @features. `true` if success, `false` otherwise. A shaping plan The #hb_font_t to use The #hb_buffer_t to work upon Features to enable The number of features to enable Fetches the singleton empty shaping plan. The empty shaping plan Fetches the shaper from a given shaping plan. The shaper A shaping plan Fetches the user data associated with the specified key, attached to the specified shaping plan. A pointer to the user data A shaping plan The user-data key to query Increases the reference count on the given shaping plan. @shape_plan A shaping plan Attaches a user-data key/data pair to the given shaping plan. `true` if success, `false` otherwise. A shaping plan The user-data key to set A pointer to the user data A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Data type for holding a shaping plan. Shape plans contain information about how HarfBuzz will shape a particular text segment, based on the segment's properties and the capabilities in the font face in use. Shape plans can be queried about how shaping will perform, given a set of specific input parameters (script, language, direction, features, etc.). Searches variation axes of a #hb_font_t object for a specific axis first, if not set, then tries to get default style values from different tables of the font. Corresponding axis or default value to a style tag. a #hb_font_t object. a style tag. Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg). Used to vary between non-italic and italic. A value of 0 can be interpreted as "Roman" (non-italic); a value of 1 can be interpreted as (fully) italic. Used to vary design to suit different text sizes. Non-zero. Values can be interpreted as text size, in points. Used to vary between upright and slanted text. Values must be greater than -90 and less than +90. Values can be interpreted as the angle, in counter-clockwise degrees, of oblique slant from whatever the designer considers to be upright for that font design. Typical right-leaning Italic fonts have a negative slant angle (typically around -12) same as @HB_STYLE_TAG_SLANT_ANGLE expression as ratio. Typical right-leaning Italic fonts have a positive slant ratio (typically around 0.2) Used to vary width of text from narrower to wider. Non-zero. Values can be interpreted as a percentage of whatever the font designer considers “normal width” for that font design. Used to vary stroke thicknesses or other design details to give variation from lighter to blacker. Values can be interpreted in direct comparison to values for usWeightClass in the OS/2 table, or the CSS font-weight property. Converts a string into an #hb_tag_t. Valid tags are four characters. Shorter input strings will be padded with spaces. Longer input strings will be truncated. The #hb_tag_t corresponding to @str String to convert Length of @str, or -1 if it is `NULL`-terminated Converts an #hb_tag_t to a string and returns it in @buf. Strings will be four characters long. #hb_tag_t to convert Converted string Retrieves the Canonical Combining Class (ccc) property of code point @unicode. The #hb_unicode_combining_class_t of @unicode The Unicode-functions structure The code point to query A virtual method for the #hb_unicode_funcs_t structure. This method should retrieve the Canonical Combining Class (ccc) property for a specified Unicode code point. The #hb_unicode_combining_class_t of @unicode A Unicode-functions structure The code point to query User data pointer passed by the caller Data type for the Canonical_Combining_Class (ccc) property from the Unicode Character Database. <note>Note: newer versions of Unicode may add new values. Client programs should be ready to handle any value in the 0..254 range being returned from hb_unicode_combining_class().</note> Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing Marks which overlay a base letter or symbol Diacritic nukta marks in Brahmi-derived scripts Hiragana/Katakana voicing marks Viramas [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Hebrew] [Arabic] [Arabic] [Arabic] [Arabic] [Arabic] [Arabic] [Arabic] [Arabic] [Arabic] [Syriac] [Telugu] [Telugu] [Thai] [Thai] [Lao] [Lao] [Tibetan] [Tibetan] [Tibetan] Marks attached at the bottom left Marks attached directly below Marks attached directly above Marks attached at the top right Distinct marks at the bottom left Distinct marks directly below Distinct marks at the bottom right Distinct marks to the left Distinct marks to the right Distinct marks at the top left Distinct marks directly above Distinct marks at the top right Distinct marks subtending two bases Distinct marks extending above two bases Greek iota subscript only Invalid combining class Fetches the composition of a sequence of two Unicode code points. Calls the composition function of the specified Unicode-functions structure @ufuncs. `true` if @a and @b composed, `false` otherwise The Unicode-functions structure The first Unicode code point to compose The second Unicode code point to compose The composition of @a, @b A virtual method for the #hb_unicode_funcs_t structure. This method should compose a sequence of two input Unicode code points by canonical equivalence, returning the composed code point in a #hb_codepoint_t output parameter (if successful). The method must return an #hb_bool_t indicating the success of the composition. `true` is @a,@b composed, `false` otherwise A Unicode-functions structure The first code point to compose The second code point to compose The composed code point user data pointer passed by the caller Fetches the decomposition of a Unicode code point. Calls the decomposition function of the specified Unicode-functions structure @ufuncs. `true` if @ab was decomposed, `false` otherwise The Unicode-functions structure Unicode code point to decompose The first code point of the decomposition of @ab The second code point of the decomposition of @ab Fetches the compatibility decomposition of a Unicode code point. Deprecated. length of @decomposed. The Unicode-functions structure Code point to decompose Compatibility decomposition of @u Fully decompose @u to its Unicode compatibility decomposition. The codepoints of the decomposition will be written to @decomposed. The complete length of the decomposition will be returned. If @u has no compatibility decomposition, zero should be returned. The Unicode standard guarantees that a buffer of length #HB_UNICODE_MAX_DECOMPOSITION_LEN codepoints will always be sufficient for any compatibility decomposition plus an terminating value of 0. Consequently, @decompose must be allocated by the caller to be at least this length. Implementations of this function type must ensure that they do not write past the provided array. number of codepoints in the full compatibility decomposition of @u, or 0 if no decomposition available. a Unicode function structure codepoint to decompose address of codepoint array (of length #HB_UNICODE_MAX_DECOMPOSITION_LEN) to write decomposition into user data pointer as passed to hb_unicode_funcs_set_decompose_compatibility_func() A virtual method for the #hb_unicode_funcs_t structure. This method should decompose an input Unicode code point, returning the two decomposed code points in #hb_codepoint_t output parameters (if successful). The method must return an #hb_bool_t indicating the success of the composition. `true` if @ab decomposed, `false` otherwise A Unicode-functions structure The code point to decompose The first decomposed code point The second decomposed code point user data pointer passed by the caller Don't use. Not used by HarfBuzz. a Unicode-function structure The code point to query A virtual method for the #hb_unicode_funcs_t structure. A Unicode-functions structure The code point to query User data pointer passed by the caller Creates a new #hb_unicode_funcs_t structure of Unicode functions. The Unicode-functions structure Parent Unicode-functions structure Decreases the reference count on a Unicode-functions structure. When the reference count reaches zero, the Unicode-functions structure is destroyed, freeing all memory. The Unicode-functions structure Fetches a pointer to the default Unicode-functions structure that is used when no functions are explicitly set on #hb_buffer_t. a pointer to the #hb_unicode_funcs_t Unicode-functions structure Fetches the singleton empty Unicode-functions structure. The empty Unicode-functions structure Fetches the parent of the Unicode-functions structure @ufuncs. The parent Unicode-functions structure The Unicode-functions structure Fetches the user-data associated with the specified key, attached to the specified Unicode-functions structure. A pointer to the user data The Unicode-functions structure The user-data key to query Tests whether the specified Unicode-functions structure is immutable. `true` if @ufuncs is immutable, `false` otherwise The Unicode-functions structure Makes the specified Unicode-functions structure immutable. The Unicode-functions structure Increases the reference count on a Unicode-functions structure. The Unicode-functions structure The Unicode-functions structure Sets the implementation function for #hb_unicode_combining_class_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_compose_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_decompose_compatibility_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_decompose_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_eastasian_width_func_t. a Unicode-function structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_general_category_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_mirroring_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Sets the implementation function for #hb_unicode_script_func_t. A Unicode-functions structure The callback function to assign Data to pass to @func The function to call when @user_data is not needed anymore Attaches a user-data key/data pair to the specified Unicode-functions structure. `true` if success, `false` otherwise The Unicode-functions structure The user-data key A pointer to the user data A callback to call when @data is not needed anymore Whether to replace an existing data with the same key Data type containing a set of virtual methods used for accessing various Unicode character properties. HarfBuzz provides a default function for each of the methods in #hb_unicode_funcs_t. Client programs can implement their own replacements for the individual Unicode functions, as needed, and replace the default by calling the setter for a method. Retrieves the General Category (gc) property of code point @unicode. The #hb_unicode_general_category_t of @unicode The Unicode-functions structure The code point to query A virtual method for the #hb_unicode_funcs_t structure. This method should retrieve the General Category property for a specified Unicode code point. The #hb_unicode_general_category_t of @unicode A Unicode-functions structure The code point to query User data pointer passed by the caller Data type for the "General_Category" (gc) property from the Unicode Character Database. [Cc] [Cf] [Cn] [Co] [Cs] [Ll] [Lm] [Lo] [Lt] [Lu] [Mc] [Me] [Mn] [Nd] [Nl] [No] [Pc] [Pd] [Pe] [Pf] [Pi] [Po] [Ps] [Sc] [Sk] [Sm] [So] [Zl] [Zp] [Zs] Retrieves the Bi-directional Mirroring Glyph code point defined for code point @unicode. The #hb_codepoint_t of the Mirroring Glyph for @unicode The Unicode-functions structure The code point to query A virtual method for the #hb_unicode_funcs_t structure. This method should retrieve the Bi-Directional Mirroring Glyph code point for a specified Unicode code point. <note>Note: If a code point does not have a specified Bi-Directional Mirroring Glyph defined, the method should return the original code point.</note> The #hb_codepoint_t of the Mirroring Glyph for @unicode A Unicode-functions structure The code point to query User data pointer passed by the caller Retrieves the #hb_script_t script to which code point @unicode belongs. The #hb_script_t of @unicode The Unicode-functions structure The code point to query A virtual method for the #hb_unicode_funcs_t structure. This method should retrieve the Script property for a specified Unicode code point. The #hb_script_t of @unicode A Unicode-functions structure The code point to query User data pointer passed by the caller Data structure for holding user-data keys. Parses a string into a #hb_variation_t. The format for specifying variation settings follows. All valid CSS font-variation-settings values other than 'normal' and 'inherited' are also accepted, though, not documented below. The format is a tag, optionally followed by an equals sign, followed by a number. For example `wght=500`, or `slnt=-7.5`. `true` if @str is successfully parsed, `false` otherwise a string to parse length of @str, or -1 if string is `NULL` terminated the #hb_variation_t to initialize with the parsed values Data type for holding variation data. Registered OpenType variation-axis tags are listed in [OpenType Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg). The #hb_tag_t tag of the variation-axis name The value of the variation axis Converts an #hb_variation_t into a `NULL`-terminated string in the format understood by hb_variation_from_string(). The client in responsible for allocating big enough size for @buf, 128 bytes is more than enough. an #hb_variation_t to convert output string the allocated size of @buf Converts an #hb_variation_t into a `NULL`-terminated string in the format understood by hb_variation_from_string(). The client in responsible for allocating big enough size for @buf, 128 bytes is more than enough. an #hb_variation_t to convert output string the allocated size of @buf