Gjsify LogoGjsify Logo

Index

Enumerations

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

Glyph: number
GlyphUnit: number
LayoutRun: GlyphItem

Variables

ANALYSIS_FLAG_CENTERED_BASELINE: number

Whether the segment should be shifted to center around the baseline.

This is mainly used in vertical writing directions.

ANALYSIS_FLAG_IS_ELLIPSIS: number

Whether this run holds ellipsized text.

ANALYSIS_FLAG_NEED_HYPHEN: number

Whether to add a hyphen at the end of the run during shaping.

ATTR_INDEX_FROM_TEXT_BEGINNING: number

Value for start_index in PangoAttribute that indicates the beginning of the text.

ATTR_INDEX_TO_TEXT_END: number

Value for end_index in PangoAttribute that indicates the end of the text.

GLYPH_EMPTY: Pango.Glyph

A PangoGlyph value that indicates a zero-width empty glpyh.

This is useful for example in shaper modules, to use as the glyph for various zero-width Unicode characters (those passing [funcis_zero_width]).

GLYPH_INVALID_INPUT: Pango.Glyph

A PangoGlyph value for invalid input.

PangoLayout produces one such glyph per invalid input UTF-8 byte and such a glyph is rendered as a crossed box.

Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG set.

GLYPH_UNKNOWN_FLAG: Pango.Glyph

Flag used in PangoGlyph to turn a gunichar value of a valid Unicode character into an unknown-character glyph for that gunichar.

Such unknown-character glyphs may be rendered as a 'hex box'.

SCALE: number

The scale between dimensions used for Pango distances and device units.

The definition of device units is dependent on the output device; it will typically be pixels for a screen, and points for a printer. %PANGO_SCALE is currently 1024, but this may be changed in the future.

When setting font sizes, device units are always considered to be points (as in "12 point font"), rather than pixels.

VERSION_MAJOR: number

The major component of the version of Pango available at compile-time.

VERSION_MICRO: number

The micro component of the version of Pango available at compile-time.

VERSION_MINOR: number

The minor component of the version of Pango available at compile-time.

VERSION_STRING: string

A string literal containing the version of Pango available at compile-time.

Functions

  • Create a new allow-breaks attribute.

    If breaks are disabled, the range will be kept in a single run, as far as possible.

    Parameters

    • allowBreaks: boolean

      %TRUE if we line breaks are allowed

    Returns Pango.Attribute

  • attrBackgroundNew(red: number, green: number, blue: number): Pango.Attribute
  • Create a new background color attribute.

    Parameters

    • red: number

      the red value (ranging from 0 to 65535)

    • green: number

      the green value

    • blue: number

      the blue value

    Returns Pango.Attribute

  • Create a new baseline displacement attribute.

    The effect of this attribute is to shift the baseline of a run, relative to the run of preceding run.

    Baseline Shift

    Parameters

    • shift: number

      either a PangoBaselineShift enumeration value or an absolute value (> 1024) in Pango units, relative to the baseline of the previous run. Positive values displace the text upwards.

    Returns Pango.Attribute

  • attrBreak(text: string, length: number, attrList: Pango.AttrList, offset: number, attrs: LogAttr[]): void
  • Apply customization from attributes to the breaks in attrs.

    The line breaks are assumed to have been produced by [funcPango.default_break] and [funcPango.tailor_break].

    Parameters

    • text: string

      text to break. Must be valid UTF-8

    • length: number

      length of text in bytes (may be -1 if text is nul-terminated)

    • attrList: Pango.AttrList

      PangoAttrList to apply

    • offset: number

      Byte offset of text from the beginning of the paragraph

    • attrs: LogAttr[]

      array with one PangoLogAttr per character in text, plus one extra, to be filled in

    Returns void

  • Create a new font fallback attribute.

    If fallback is disabled, characters will only be used from the closest matching font on the system. No fallback will be done to other fonts on the system that might contain the characters in the text.

    Parameters

    • enableFallback: boolean

      %TRUE if we should fall back on other fonts for characters the active font is missing

    Returns Pango.Attribute

  • Create a new font description attribute.

    This attribute allows setting family, style, weight, variant, stretch, and size simultaneously.

    Parameters

    Returns Pango.Attribute

  • Create a new font features tag attribute.

    You can use this attribute to select OpenType font features like small-caps, alternative glyphs, ligatures, etc. for fonts that support them.

    Parameters

    Returns Pango.Attribute

  • Create a new font scale attribute.

    The effect of this attribute is to change the font size of a run, relative to the size of preceding run.

    Parameters

    • scale: FontScale

      a PangoFontScale value, which indicates font size change relative to the size of the previous run.

    Returns Pango.Attribute

  • attrForegroundNew(red: number, green: number, blue: number): Pango.Attribute
  • Create a new foreground color attribute.

    Parameters

    • red: number

      the red value (ranging from 0 to 65535)

    • green: number

      the green value

    • blue: number

      the blue value

    Returns Pango.Attribute

  • Create a new insert-hyphens attribute.

    Pango will insert hyphens when breaking lines in the middle of a word. This attribute can be used to suppress the hyphen.

    Parameters

    • insertHyphens: boolean

      %TRUE if hyphens should be inserted

    Returns Pango.Attribute

  • Create a new letter-spacing attribute.

    Parameters

    • letterSpacing: number

      amount of extra space to add between graphemes of the text, in Pango units

    Returns Pango.Attribute

  • Modify the height of logical line extents by a factor.

    This affects the values returned by [methodPango.LayoutLine.get_extents], [methodPango.LayoutLine.get_pixel_extents] and [methodPango.LayoutIter.get_line_extents].

    Parameters

    • factor: number

      the scaling factor to apply to the logical height

    Returns Pango.Attribute

  • Override the height of logical line extents to be height.

    This affects the values returned by [methodPango.LayoutLine.get_extents], [methodPango.LayoutLine.get_pixel_extents] and [methodPango.LayoutIter.get_line_extents].

    Parameters

    • height: number

      the line height, in %PANGO_SCALE-ths of a point

    Returns Pango.Attribute

  • Deserializes a PangoAttrList from a string.

    This is the counterpart to [methodPango.AttrList.to_string]. See that functions for details about the format.

    Parameters

    • text: string

      a string

    Returns Pango.AttrList | null

  • attrOverlineColorNew(red: number, green: number, blue: number): Pango.Attribute
  • Create a new overline color attribute.

    This attribute modifies the color of overlines. If not set, overlines will use the foreground color.

    Parameters

    • red: number

      the red value (ranging from 0 to 65535)

    • green: number

      the green value

    • blue: number

      the blue value

    Returns Pango.Attribute

  • Create a new baseline displacement attribute.

    Parameters

    • rise: number

      the amount that the text should be displaced vertically, in Pango units. Positive values displace the text upwards.

    Returns Pango.Attribute

  • Create a new font size scale attribute.

    The base font for the affected text will have its size multiplied by scale_factor.

    Parameters

    • scaleFactor: number

      factor to scale the font

    Returns Pango.Attribute

  • Marks the range of the attribute as a single sentence.

    Note that this may require adjustments to word and sentence classification around the range.

    Returns Pango.Attribute

  • Create a new shape attribute.

    A shape is used to impose a particular ink and logical rectangle on the result of shaping a particular glyph. This might be used, for instance, for embedding a picture or a widget inside a PangoLayout.

    Parameters

    • inkRect: Pango.Rectangle

      ink rectangle to assign to each character

    • logicalRect: Pango.Rectangle

      logical rectangle to assign to each character

    Returns Pango.Attribute

  • Creates a new shape attribute.

    Like [funcPango.AttrShape.new], but a user data pointer is also provided; this pointer can be accessed when later rendering the glyph.

    Parameters

    • inkRect: Pango.Rectangle

      ink rectangle to assign to each character

    • logicalRect: Pango.Rectangle

      logical rectangle to assign to each character

    • data: object

      user data pointer

    • copyFunc: AttrDataCopyFunc

      function to copy data when the attribute is copied. If %NULL, data is simply copied as a pointer

    Returns Pango.Attribute

  • Create a new font-size attribute in fractional points.

    Parameters

    • size: number

      the font size, in %PANGO_SCALE-ths of a point

    Returns Pango.Attribute

  • Create a new font-size attribute in device units.

    Parameters

    • size: number

      the font size, in %PANGO_SCALE-ths of a device unit

    Returns Pango.Attribute

  • attrStrikethroughColorNew(red: number, green: number, blue: number): Pango.Attribute
  • Create a new strikethrough color attribute.

    This attribute modifies the color of strikethrough lines. If not set, strikethrough lines will use the foreground color.

    Parameters

    • red: number

      the red value (ranging from 0 to 65535)

    • green: number

      the green value

    • blue: number

      the blue value

    Returns Pango.Attribute

  • Create a new strike-through attribute.

    Parameters

    • strikethrough: boolean

      %TRUE if the text should be struck-through

    Returns Pango.Attribute

  • Fetches the attribute type name.

    The attribute type name is the string passed in when registering the type using [funcPango.AttrType.register].

    The returned value is an interned string (see g_intern_string() for what that means) that should not be modified or freed.

    Parameters

    Returns string | null

  • Allocate a new attribute type ID.

    The attribute type name can be accessed later by using [funcPango.AttrType.get_name].

    Parameters

    • name: string

      an identifier for the type

    Returns Pango.AttrType

  • attrUnderlineColorNew(red: number, green: number, blue: number): Pango.Attribute
  • Create a new underline color attribute.

    This attribute modifies the color of underlines. If not set, underlines will use the foreground color.

    Parameters

    • red: number

      the red value (ranging from 0 to 65535)

    • green: number

      the green value

    • blue: number

      the blue value

    Returns Pango.Attribute

  • Marks the range of the attribute as a single word.

    Note that this may require adjustments to word and sentence classification around the range.

    Returns Pango.Attribute

  • bidiTypeForUnichar(ch: string): BidiType
  • Determines the bidirectional type of a character.

    The bidirectional type is specified in the Unicode Character Database.

    A simplified version of this function is available as [funcunichar_direction].

    Parameters

    • ch: string

      a Unicode character

    Returns BidiType

  • break_TODO(text: string, length: number, analysis: Analysis, attrs: LogAttr[]): void
  • Determines possible line, word, and character breaks for a string of Unicode text with a single analysis.

    For most purposes you may want to use [funcPango.get_log_attrs].

    Parameters

    • text: string

      the text to process. Must be valid UTF-8

    • length: number

      length of text in bytes (may be -1 if text is nul-terminated)

    • analysis: Analysis

      PangoAnalysis structure for text

    • attrs: LogAttr[]

      an array to store character information in

    Returns void

  • defaultBreak(text: string, length: number, analysis: Analysis, attrs: LogAttr, attrsLen: number): void
  • This is the default break algorithm.

    It applies rules from the Unicode Line Breaking Algorithm without language-specific tailoring, therefore the analyis argument is unused and can be %NULL.

    See [funcPango.tailor_break] for language-specific breaks.

    See [funcPango.attr_break] for attribute-based customization.

    Parameters

    • text: string

      text to break. Must be valid UTF-8

    • length: number

      length of text in bytes (may be -1 if text is nul-terminated)

    • analysis: Analysis

      a PangoAnalysis structure for the text

    • attrs: LogAttr

      logical attributes to fill in

    • attrsLen: number

      size of the array passed as attrs

    Returns void

  • Converts extents from Pango units to device units.

    The conversion is done by dividing by the %PANGO_SCALE factor and performing rounding.

    The inclusive rectangle is converted by flooring the x/y coordinates and extending width/height, such that the final rectangle completely includes the original rectangle.

    The nearest rectangle is converted by rounding the coordinates of the rectangle to the nearest device unit (pixel).

    The rule to which argument to use is: if you want the resulting device-space rectangle to completely contain the original rectangle, pass it in as inclusive. If you want two touching-but-not-overlapping rectangles stay touching-but-not-overlapping after rounding to device units, pass them in as nearest.

    Parameters

    Returns void

  • Searches a string the first character that has a strong direction, according to the Unicode bidirectional algorithm.

    Parameters

    • text: string

      the text to process. Must be valid UTF-8

    • length: number

      length of text in bytes (may be -1 if text is nul-terminated)

    Returns Pango.Direction

  • findParagraphBoundary(text: string, length: number): [number, number]
  • Locates a paragraph boundary in text.

    A boundary is caused by delimiter characters, such as a newline, carriage return, carriage return-newline pair, or Unicode paragraph separator character.

    The index of the run of delimiters is returned in paragraph_delimiter_index. The index of the start of the next paragraph (index after all delimiters) is stored n next_paragraph_start.

    If no delimiters are found, both paragraph_delimiter_index and next_paragraph_start are filled with the length of text (an index one off the end).

    Parameters

    • text: string

      UTF-8 text

    • length: number

      length of text in bytes, or -1 if nul-terminated

    Returns [number, number]

  • Creates a new font description from a string representation.

    The string must have the form

    "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]",
    

    where FAMILY-LIST is a comma-separated list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace-separated list of words where each word describes one of style, variant, weight, stretch, or gravity, and SIZE is a decimal number (size in points) or optionally followed by the unit modifier "px" for absolute size. VARIATIONS is a comma-separated list of font variation specifications of the form "`axis=`value" (the = sign is optional).

    The following words are understood as styles: "Normal", "Roman", "Oblique", "Italic".

    The following words are understood as variants: "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps", "Unicase", "Title-Caps".

    The following words are understood as weights: "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light", "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold", "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black", "Extra-Black".

    The following words are understood as stretch values: "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed", "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".

    The following words are understood as gravity values: "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left", "East", "Rotated-Right", "West".

    Any one of the options may be absent. If FAMILY-LIST is absent, then the family_name field of the resulting font description will be initialized to %NULL. If STYLE-OPTIONS is missing, then all style options will be set to the default values. If SIZE is missing, the size in the resulting font description will be set to 0.

    A typical example:

    "Cantarell Italic Light 15 \`wght=`200"
    

    Parameters

    • str: string

      string representation of a font description.

    Returns FontDescription

  • getLogAttrs(text: string, length: number, level: number, language: Pango.Language, attrs: LogAttr[]): void
  • Computes a PangoLogAttr for each character in text.

    The attrs array must have one PangoLogAttr for each position in text; if text contains N characters, it has N+1 positions, including the last position at the end of the text. text should be an entire paragraph; logical attributes can't be computed without context (for example you need to see spaces on either side of a word to know the word is a word).

    Parameters

    • text: string

      text to process. Must be valid UTF-8

    • length: number

      length in bytes of text

    • level: number

      embedding level, or -1 if unknown

    • language: Pango.Language

      language tag

    • attrs: LogAttr[]

      array with one PangoLogAttr per character in text, plus one extra, to be filled in

    Returns void

  • getMirrorChar(ch: string, mirroredCh: string): boolean
  • Returns the mirrored character of a Unicode character.

    Mirror characters are determined by the Unicode mirrored property.

    Parameters

    • ch: string

      a Unicode character

    • mirroredCh: string

      location to store the mirrored character

    Returns boolean

  • Returns the gravity to use in laying out a PangoItem.

    The gravity is determined based on the script, base gravity, and hint.

    If base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of script. To get the preferred gravity of a script, pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in.

    Parameters

    Returns Pango.Gravity

  • Returns the gravity to use in laying out a single character or PangoItem.

    The gravity is determined based on the script, East Asian width, base gravity, and hint,

    This function is similar to [funcPango.Gravity.get_for_script] except that this function makes a distinction between narrow/half-width and wide/full-width characters also. Wide/full-width characters always stand upright, that is, they always take the base gravity, whereas narrow/full-width characters are always rotated in vertical context.

    If base_gravity is %PANGO_GRAVITY_AUTO, it is first replaced with the preferred gravity of script.

    Parameters

    • script: Pango.Script

      PangoScript to query

    • wide: boolean

      %TRUE for wide characters as returned by g_unichar_iswide()

    • baseGravity: Pango.Gravity

      base gravity of the paragraph

    • hint: GravityHint

      orientation hint

    Returns Pango.Gravity

  • Converts a PangoGravity value to its natural rotation in radians.

    Note that [methodPango.Matrix.rotate] takes angle in degrees, not radians. So, to call [methodPango.Matrix,rotate] with the output of this function you should multiply it by (180. / G_PI).

    Parameters

    • gravity: Pango.Gravity

      gravity to query, should not be %PANGO_GRAVITY_AUTO

    Returns number

  • isZeroWidth(ch: string): boolean
  • Checks if a character that should not be normally rendered.

    This includes all Unicode characters with "ZERO WIDTH" in their name, as well as bidi formatting characters, and a few other ones.

    This is totally different from [funcGLib.unichar_iszerowidth] and is at best misnamed.

    Parameters

    • ch: string

      a Unicode character

    Returns boolean

  • Breaks a piece of text into segments with consistent directional level and font.

    Each byte of text will be contained in exactly one of the items in the returned list; the generated list of items will be in logical order (the start offsets of the items are ascending).

    cached_iter should be an iterator over attrs currently positioned at a range before or containing start_index; cached_iter will be advanced to the range covering the position just after start_index + length. (i.e. if itemizing in a loop, just keep passing in the same cached_iter).

    Parameters

    • context: Pango.Context

      a structure holding information that affects the itemization process.

    • text: string

      the text to itemize. Must be valid UTF-8

    • startIndex: number

      first byte in text to process

    • length: number

      the number of bytes (not characters) to process after start_index. This must be >= 0.

    • attrs: Pango.AttrList

      the set of attributes that apply to text.

    • cachedIter: AttrIterator

      Cached attribute iterator

    Returns Pango.Item[]

  • Like pango_itemize(), but with an explicitly specified base direction.

    The base direction is used when computing bidirectional levels. [funcitemize] gets the base direction from the PangoContext (see [methodPango.Context.set_base_dir]).

    Parameters

    • context: Pango.Context

      a structure holding information that affects the itemization process.

    • baseDir: Pango.Direction

      base direction to use for bidirectional processing

    • text: string

      the text to itemize.

    • startIndex: number

      first byte in text to process

    • length: number

      the number of bytes (not characters) to process after start_index. This must be >= 0.

    • attrs: Pango.AttrList

      the set of attributes that apply to text.

    • cachedIter: AttrIterator

      Cached attribute iterator

    Returns Pango.Item[]

  • Convert a language tag to a PangoLanguage.

    The language tag must be in a RFC-3066 format. PangoLanguage pointers can be efficiently copied (copy the pointer) and compared with other language tags (compare the pointer.)

    This function first canonicalizes the string by converting it to lowercase, mapping '_' to '-', and stripping all characters other than letters and '-'.

    Use [funcPango.Language.get_default] if you want to get the PangoLanguage for the current locale of the process.

    Parameters

    • language: string

      a string representing a language tag

    Returns Pango.Language | null

  • Returns the PangoLanguage for the current locale of the process.

    On Unix systems, this is the return value is derived from setlocale (LC_CTYPE, NULL), and the user can affect this through the environment variables LC_ALL, LC_CTYPE or LANG (checked in that order). The locale string typically is in the form lang_COUNTRY, where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil.

    On Windows, the C library does not use any such environment variables, and setting them won't affect the behavior of functions like ctime(). The user sets the locale through the Regional Options in the Control Panel. The C library (in the setlocale() function) does not use country and language codes, but country and language names spelled out in English. However, this function does check the above environment variables, and does return a Unix-style locale string based on either said environment variables or the thread's current locale.

    Your application should call setlocale(LC_ALL, "") for the user settings to take effect. GTK does this in its initialization functions automatically (by calling gtk_set_locale()). See the setlocale() manpage for more details.

    Note that the default language can change over the life of an application.

    Also note that this function will not do the right thing if you use per-thread locales with uselocale(). In that case, you should just call pango_language_from_string() yourself.

    Returns Pango.Language

  • Returns the list of languages that the user prefers.

    The list is specified by the PANGO_LANGUAGE or LANGUAGE environment variables, in order of preference. Note that this list does not necessarily include the language returned by [funcPango.Language.get_default].

    When choosing language-specific resources, such as the sample text returned by [methodPango.Language.get_sample_string], you should first try the default language, followed by the languages returned by this function.

    Returns Pango.Language | null

  • layoutDeserializeErrorQuark(): Quark
  • log2visGetEmbeddingLevels(text: string, length: number, pbaseDir: Pango.Direction): number
  • Return the bidirectional embedding levels of the input paragraph.

    The bidirectional embedding levels are defined by the Unicode Bidirectional Algorithm.

    If the input base direction is a weak direction, the direction of the characters in the text will determine the final resolved direction.

    Parameters

    • text: string

      the text to itemize.

    • length: number

      the number of bytes (not characters) to process, or -1 if text is nul-terminated and the length should be calculated.

    • pbaseDir: Pango.Direction

      input base direction, and output resolved direction.

    Returns number

  • Finishes parsing markup.

    After feeding a Pango markup parser some data with [methodGLib.MarkupParseContext.parse], use this function to get the list of attributes and text out of the markup. This function will not free context, use [methodGLib.MarkupParseContext.free] to do so.

    Parameters

    • context: MarkupParseContext

      A valid parse context that was returned from [funcmarkup_parser_new]

    Returns [boolean, Pango.AttrList, string, string]

  • Incrementally parses marked-up text to create a plain-text string and an attribute list.

    See the Pango Markup docs for details about the supported markup.

    If accel_marker is nonzero, the given character will mark the character following it as an accelerator. For example, accel_marker might be an ampersand or underscore. All characters marked as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute, and the first character so marked will be returned in accel_char, when calling [funcmarkup_parser_finish]. Two accel_marker characters following each other produce a single literal accel_marker character.

    To feed markup to the parser, use [methodGLib.MarkupParseContext.parse] on the returned [structGLib.MarkupParseContext]. When done with feeding markup to the parser, use [funcmarkup_parser_finish] to get the data out of it, and then use [methodGLib.MarkupParseContext.free] to free it.

    This function is designed for applications that read Pango markup from streams. To simply parse a string containing Pango markup, the [funcPango.parse_markup] API is recommended instead.

    Parameters

    • accelMarker: string

      character that precedes an accelerator, or 0 for none

    Returns MarkupParseContext

  • parseEnum(type: GType<unknown>, str: string, warn: boolean): [boolean, number, string]
  • Parses an enum type and stores the result in value.

    If str does not match the nick name of any of the possible values for the enum and is not an integer, %FALSE is returned, a warning is issued if warn is %TRUE, and a string representing the list of possible values is stored in possible_values. The list is slash-separated, eg. "none/start/middle/end".

    If failed and possible_values is not %NULL, returned string should be freed using g_free().

    Parameters

    • type: GType<unknown>

      enum type to parse, eg. %PANGO_TYPE_ELLIPSIZE_MODE

    • str: string

      string to parse

    • warn: boolean

      if %TRUE, issue a g_warning() on bad input

    Returns [boolean, number, string]

  • parseMarkup(markupText: string, length: number, accelMarker: string): [boolean, Pango.AttrList, string, string]
  • Parses marked-up text to create a plain-text string and an attribute list.

    See the Pango Markup docs for details about the supported markup.

    If accel_marker is nonzero, the given character will mark the character following it as an accelerator. For example, accel_marker might be an ampersand or underscore. All characters marked as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute, and the first character so marked will be returned in accel_char. Two accel_marker characters following each other produce a single literal accel_marker character.

    To parse a stream of pango markup incrementally, use [funcmarkup_parser_new].

    If any error happens, none of the output arguments are touched except for error.

    Parameters

    • markupText: string

      markup to parse (see the Pango Markup docs)

    • length: number

      length of markup_text, or -1 if nul-terminated

    • accelMarker: string

      character that precedes an accelerator, or 0 for none

    Returns [boolean, Pango.AttrList, string, string]

  • parseStretch(str: string, warn: boolean): [boolean, Stretch]
  • Parses a font stretch.

    The allowed values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" and "ultra_expanded". Case variations are ignored and the '_' characters may be omitted.

    Parameters

    • str: string

      a string to parse.

    • warn: boolean

      if %TRUE, issue a g_warning() on bad input.

    Returns [boolean, Stretch]

  • parseStyle(str: string, warn: boolean): [boolean, Pango.Style]
  • Parses a font style.

    The allowed values are "normal", "italic" and "oblique", case variations being ignored.

    Parameters

    • str: string

      a string to parse.

    • warn: boolean

      if %TRUE, issue a g_warning() on bad input.

    Returns [boolean, Pango.Style]

  • parseVariant(str: string, warn: boolean): [boolean, Pango.Variant]
  • Parses a font variant.

    The allowed values are "normal", "small-caps", "all-small-caps", "petite-caps", "all-petite-caps", "unicase" and "title-caps", case variations being ignored.

    Parameters

    • str: string

      a string to parse.

    • warn: boolean

      if %TRUE, issue a g_warning() on bad input.

    Returns [boolean, Pango.Variant]

  • parseWeight(str: string, warn: boolean): [boolean, Weight]
  • Parses a font weight.

    The allowed values are "heavy", "ultrabold", "bold", "normal", "light", "ultraleight" and integers. Case variations are ignored.

    Parameters

    • str: string

      a string to parse.

    • warn: boolean

      if %TRUE, issue a g_warning() on bad input.

    Returns [boolean, Weight]

  • quantizeLineGeometry(thickness: number, position: number): [number, number]
  • Quantizes the thickness and position of a line to whole device pixels.

    This is typically used for underline or strikethrough. The purpose of this function is to avoid such lines looking blurry.

    Care is taken to make sure thickness is at least one pixel when this function returns, but returned position may become zero as a result of rounding.

    Parameters

    • thickness: number

      pointer to the thickness of a line, in Pango units

    • position: number

      corresponding position

    Returns [number, number]

  • readLine(stream: object, str: GLib.String): number
  • Reads an entire line from a file into a buffer.

    Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter is not written into the buffer. Text after a '#' character is treated as a comment and skipped. '' can be used to escape a # character. '' proceeding a line delimiter combines adjacent lines. A '' proceeding any other character is ignored and written into the output buffer unmodified.

    Parameters

    • stream: object

      a stdio stream

    • str: GLib.String

      GString buffer into which to write the result

    Returns number

  • Reorder items from logical order to visual order.

    The visual order is determined from the associated directional levels of the items. The original list is unmodified.

    (Please open a bug if you use this function. It is not a particularly convenient interface, and the code is duplicated elsewhere in Pango for that reason.)

    Parameters

    • items: Pango.Item[]

      a GList of PangoItem in logical order.

    Returns Pango.Item[]

  • scanInt(pos: string): [boolean, string, number]
  • Scans an integer.

    Leading white space is skipped.

    Parameters

    • pos: string

      in/out string position

    Returns [boolean, string, number]

  • scanString(pos: string, out: GLib.String): [boolean, string]
  • Scans a string into a GString buffer.

    The string may either be a sequence of non-white-space characters, or a quoted string with '"'. Instead a quoted string, '"' represents a literal quote. Leading white space outside of quotes is skipped.

    Parameters

    • pos: string

      in/out string position

    • out: GLib.String

      a GString into which to write the result

    Returns [boolean, string]

  • scanWord(pos: string, out: GLib.String): [boolean, string]
  • Scans a word into a GString buffer.

    A word consists of [A-Za-z_] followed by zero or more [A-Za-z_0-9]. Leading white space is skipped.

    Parameters

    • pos: string

      in/out string position

    • out: GLib.String

      a GString into which to write the result

    Returns [boolean, string]

  • Looks up the script for a particular character.

    The script of a character is defined by Unicode Standard Annex 24: Script names.

    No check is made for ch being a valid Unicode character; if you pass in invalid character, the result is undefined.

    Note that while the return type of this function is declared as PangoScript, as of Pango 1.18, this function simply returns the return value of [funcGLib.unichar_get_script]. Callers must be prepared to handle unknown values.

    Parameters

    • ch: string

      a Unicode character

    Returns Pango.Script

  • Finds a language tag that is reasonably representative of script.

    The language will usually be the most widely spoken or used language written in that script: for instance, the sample language for %PANGO_SCRIPT_CYRILLIC is ru (Russian), the sample language for %PANGO_SCRIPT_ARABIC is ar.

    For some scripts, no sample language will be returned because there is no language that is sufficiently representative. The best example of this is %PANGO_SCRIPT_HAN, where various different variants of written Chinese, Japanese, and Korean all use significantly different sets of Han characters and forms of shared characters. No sample language can be provided for many historical scripts as well.

    As of 1.18, this function checks the environment variables PANGO_LANGUAGE and LANGUAGE (checked in that order) first. If one of them is set, it is parsed as a list of language tags separated by colons or other separators. This function will return the first language in the parsed list that Pango believes may use script for writing. This last predicate is tested using [methodPango.Language.includes_script]. This can be used to control Pango's font selection for non-primary languages. For example, a PANGO_LANGUAGE enviroment variable set to "en:fa" makes Pango choose fonts suitable for Persian (fa) instead of Arabic (ar) when a segment of Arabic text is found in an otherwise non-Arabic text. The same trick can be used to choose a default language for %PANGO_SCRIPT_HAN when setting context language is not feasible.

    Parameters

    Returns Pango.Language | null

  • Convert the characters in text into glyphs.

    Given a segment of text and the corresponding PangoAnalysis structure returned from [funcPango.itemize], convert the characters into glyphs. You may also pass in only a substring of the item from [funcPango.itemize].

    It is recommended that you use [funcPango.shape_full] instead, since that API allows for shaping interaction happening across text item boundaries.

    Note that the extra attributes in the analyis that is returned from [funcPango.itemize] have indices that are relative to the entire paragraph, so you need to subtract the item offset from their indices before calling [funcPango.shape].

    Parameters

    • text: string

      the text to process

    • length: number

      the length (in bytes) of text

    • analysis: Analysis

      PangoAnalysis structure from [funcPango.itemize]

    • glyphs: GlyphString

      glyph string in which to store results

    Returns void

  • shapeFull(itemText: string, itemLength: number, paragraphText: string, paragraphLength: number, analysis: Analysis, glyphs: GlyphString): void
  • Convert the characters in text into glyphs.

    Given a segment of text and the corresponding PangoAnalysis structure returned from [funcPango.itemize], convert the characters into glyphs. You may also pass in only a substring of the item from [funcPango.itemize].

    This is similar to [funcPango.shape], except it also can optionally take the full paragraph text as input, which will then be used to perform certain cross-item shaping interactions. If you have access to the broader text of which item_text is part of, provide the broader text as paragraph_text. If paragraph_text is %NULL, item text is used instead.

    Note that the extra attributes in the analyis that is returned from [funcPango.itemize] have indices that are relative to the entire paragraph, so you do not pass the full paragraph text as paragraph_text, you need to subtract the item offset from their indices before calling [funcPango.shape_full].

    Parameters

    • itemText: string

      valid UTF-8 text to shape.

    • itemLength: number

      the length (in bytes) of item_text. -1 means nul-terminated text.

    • paragraphText: string

      text of the paragraph (see details).

    • paragraphLength: number

      the length (in bytes) of paragraph_text. -1 means nul-terminated text.

    • analysis: Analysis

      PangoAnalysis structure from [funcPango.itemize].

    • glyphs: GlyphString

      glyph string in which to store results.

    Returns void

  • Convert the characters in item into glyphs.

    This is similar to [funcPango.shape_with_flags], except it takes a PangoItem instead of separate item_text and analysis arguments. It also takes log_attrs, which may be used in implementing text transforms.

    Note that the extra attributes in the analyis that is returned from [funcPango.itemize] have indices that are relative to the entire paragraph, so you do not pass the full paragraph text as paragraph_text, you need to subtract the item offset from their indices before calling [funcPango.shape_with_flags].

    Parameters

    • item: Pango.Item

      PangoItem to shape

    • paragraphText: string

      text of the paragraph (see details).

    • paragraphLength: number

      the length (in bytes) of paragraph_text. -1 means nul-terminated text.

    • logAttrs: LogAttr

      array of PangoLogAttr for item

    • glyphs: GlyphString

      glyph string in which to store results

    • flags: ShapeFlags

      flags influencing the shaping process

    Returns void

  • shapeWithFlags(itemText: string, itemLength: number, paragraphText: string, paragraphLength: number, analysis: Analysis, glyphs: GlyphString, flags: ShapeFlags): void
  • Convert the characters in text into glyphs.

    Given a segment of text and the corresponding PangoAnalysis structure returned from [funcPango.itemize], convert the characters into glyphs. You may also pass in only a substring of the item from [funcPango.itemize].

    This is similar to [funcPango.shape_full], except it also takes flags that can influence the shaping process.

    Note that the extra attributes in the analyis that is returned from [funcPango.itemize] have indices that are relative to the entire paragraph, so you do not pass the full paragraph text as paragraph_text, you need to subtract the item offset from their indices before calling [funcPango.shape_with_flags].

    Parameters

    • itemText: string

      valid UTF-8 text to shape

    • itemLength: number

      the length (in bytes) of item_text. -1 means nul-terminated text.

    • paragraphText: string

      text of the paragraph (see details).

    • paragraphLength: number

      the length (in bytes) of paragraph_text. -1 means nul-terminated text.

    • analysis: Analysis

      PangoAnalysis structure from [funcPango.itemize]

    • glyphs: GlyphString

      glyph string in which to store results

    • flags: ShapeFlags

      flags influencing the shaping process

    Returns void

  • skipSpace(pos: string): [boolean, string]
  • Skips 0 or more characters of white space.

    Parameters

    • pos: string

      in/out string position

    Returns [boolean, string]

  • splitFileList(str: string): string[]
  • Splits a %G_SEARCHPATH_SEPARATOR-separated list of files, stripping white space and substituting ~/ with $HOME/.

    Parameters

    • str: string

      a %G_SEARCHPATH_SEPARATOR separated list of filenames

    Returns string[]

  • tabArrayFromString(text: string): TabArray | null
  • Deserializes a PangoTabArray from a string.

    This is the counterpart to [methodPango.TabArray.to_string]. See that functions for details about the format.

    Parameters

    • text: string

      a string

    Returns TabArray | null

  • tailorBreak(text: string, length: number, analysis: Analysis, offset: number, attrs: LogAttr[]): void
  • Apply language-specific tailoring to the breaks in attrs.

    The line breaks are assumed to have been produced by [funcPango.default_break].

    If offset is not -1, it is used to apply attributes from analysis that are relevant to line breaking.

    Note that it is better to pass -1 for offset and use [funcPango.attr_break] to apply attributes to the whole paragraph.

    Parameters

    • text: string

      text to process. Must be valid UTF-8

    • length: number

      length in bytes of text

    • analysis: Analysis

      PangoAnalysis for text

    • offset: number

      Byte offset of text from the beginning of the paragraph, or -1 to ignore attributes from analysis

    • attrs: LogAttr[]

      array with one PangoLogAttr per character in text, plus one extra, to be filled in

    Returns void

  • trimString(str: string): string
  • Trims leading and trailing whitespace from a string.

    Parameters

    • str: string

      a string

    Returns string

  • Determines the inherent direction of a character.

    The inherent direction is either PANGO_DIRECTION_LTR, PANGO_DIRECTION_RTL, or PANGO_DIRECTION_NEUTRAL.

    This function is useful to categorize characters into left-to-right letters, right-to-left letters, and everything else. If full Unicode bidirectional type of a character is needed, [funcPango.BidiType.for_unichar] can be used instead.

    Parameters

    • ch: string

      a Unicode character

    Returns Pango.Direction

  • unitsFromDouble(d: number): number
  • Converts a floating-point number to Pango units.

    The conversion is done by multiplying d by %PANGO_SCALE and rounding the result to nearest integer.

    Parameters

    • d: number

      double floating-point value

    Returns number

  • unitsToDouble(i: number): number
  • Converts a number in Pango units to floating-point.

    The conversion is done by dividing i by %PANGO_SCALE.

    Parameters

    • i: number

      value in Pango units

    Returns number

  • version(): number
  • Returns the encoded version of Pango available at run-time.

    This is similar to the macro %PANGO_VERSION except that the macro returns the encoded version available at compile-time. A version number can be encoded into an integer using PANGO_VERSION_ENCODE().

    Returns number

  • versionCheck(requiredMajor: number, requiredMinor: number, requiredMicro: number): string | null
  • Checks that the Pango library in use is compatible with the given version.

    Generally you would pass in the constants %PANGO_VERSION_MAJOR, %PANGO_VERSION_MINOR, %PANGO_VERSION_MICRO as the three arguments to this function; that produces a check that the library in use at run-time is compatible with the version of Pango the application or module was compiled against.

    Compatibility is defined by two things: first the version of the running library is newer than the version required_major.required_minor.required_micro. Second the running library must be binary compatible with the version required_major.required_minor.required_micro (same major version.)

    For compile-time version checking use PANGO_VERSION_CHECK().

    Parameters

    • requiredMajor: number

      the required major version

    • requiredMinor: number

      the required minor version

    • requiredMicro: number

      the required major version

    Returns string | null

  • versionString(): string
  • Returns the version of Pango available at run-time.

    This is similar to the macro %PANGO_VERSION_STRING except that the macro returns the version available at compile-time.

    Returns string

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Type alias with type parameter
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method