pango_sys/

lib.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use glib_sys as glib;
use gobject_sys as gobject;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Aliases
pub type PangoGlyph = u32;
pub type PangoGlyphUnit = i32;
pub type PangoLayoutRun = PangoGlyphItem;

// Enums
pub type PangoAlignment = c_int;
pub const PANGO_ALIGN_LEFT: PangoAlignment = 0;
pub const PANGO_ALIGN_CENTER: PangoAlignment = 1;
pub const PANGO_ALIGN_RIGHT: PangoAlignment = 2;

pub type PangoAttrType = c_int;
pub const PANGO_ATTR_INVALID: PangoAttrType = 0;
pub const PANGO_ATTR_LANGUAGE: PangoAttrType = 1;
pub const PANGO_ATTR_FAMILY: PangoAttrType = 2;
pub const PANGO_ATTR_STYLE: PangoAttrType = 3;
pub const PANGO_ATTR_WEIGHT: PangoAttrType = 4;
pub const PANGO_ATTR_VARIANT: PangoAttrType = 5;
pub const PANGO_ATTR_STRETCH: PangoAttrType = 6;
pub const PANGO_ATTR_SIZE: PangoAttrType = 7;
pub const PANGO_ATTR_FONT_DESC: PangoAttrType = 8;
pub const PANGO_ATTR_FOREGROUND: PangoAttrType = 9;
pub const PANGO_ATTR_BACKGROUND: PangoAttrType = 10;
pub const PANGO_ATTR_UNDERLINE: PangoAttrType = 11;
pub const PANGO_ATTR_STRIKETHROUGH: PangoAttrType = 12;
pub const PANGO_ATTR_RISE: PangoAttrType = 13;
pub const PANGO_ATTR_SHAPE: PangoAttrType = 14;
pub const PANGO_ATTR_SCALE: PangoAttrType = 15;
pub const PANGO_ATTR_FALLBACK: PangoAttrType = 16;
pub const PANGO_ATTR_LETTER_SPACING: PangoAttrType = 17;
pub const PANGO_ATTR_UNDERLINE_COLOR: PangoAttrType = 18;
pub const PANGO_ATTR_STRIKETHROUGH_COLOR: PangoAttrType = 19;
pub const PANGO_ATTR_ABSOLUTE_SIZE: PangoAttrType = 20;
pub const PANGO_ATTR_GRAVITY: PangoAttrType = 21;
pub const PANGO_ATTR_GRAVITY_HINT: PangoAttrType = 22;
pub const PANGO_ATTR_FONT_FEATURES: PangoAttrType = 23;
pub const PANGO_ATTR_FOREGROUND_ALPHA: PangoAttrType = 24;
pub const PANGO_ATTR_BACKGROUND_ALPHA: PangoAttrType = 25;
pub const PANGO_ATTR_ALLOW_BREAKS: PangoAttrType = 26;
pub const PANGO_ATTR_SHOW: PangoAttrType = 27;
pub const PANGO_ATTR_INSERT_HYPHENS: PangoAttrType = 28;
pub const PANGO_ATTR_OVERLINE: PangoAttrType = 29;
pub const PANGO_ATTR_OVERLINE_COLOR: PangoAttrType = 30;
pub const PANGO_ATTR_LINE_HEIGHT: PangoAttrType = 31;
pub const PANGO_ATTR_ABSOLUTE_LINE_HEIGHT: PangoAttrType = 32;
pub const PANGO_ATTR_TEXT_TRANSFORM: PangoAttrType = 33;
pub const PANGO_ATTR_WORD: PangoAttrType = 34;
pub const PANGO_ATTR_SENTENCE: PangoAttrType = 35;
pub const PANGO_ATTR_BASELINE_SHIFT: PangoAttrType = 36;
pub const PANGO_ATTR_FONT_SCALE: PangoAttrType = 37;

pub type PangoBaselineShift = c_int;
pub const PANGO_BASELINE_SHIFT_NONE: PangoBaselineShift = 0;
pub const PANGO_BASELINE_SHIFT_SUPERSCRIPT: PangoBaselineShift = 1;
pub const PANGO_BASELINE_SHIFT_SUBSCRIPT: PangoBaselineShift = 2;

pub type PangoBidiType = c_int;
pub const PANGO_BIDI_TYPE_L: PangoBidiType = 0;
pub const PANGO_BIDI_TYPE_LRE: PangoBidiType = 1;
pub const PANGO_BIDI_TYPE_LRO: PangoBidiType = 2;
pub const PANGO_BIDI_TYPE_R: PangoBidiType = 3;
pub const PANGO_BIDI_TYPE_AL: PangoBidiType = 4;
pub const PANGO_BIDI_TYPE_RLE: PangoBidiType = 5;
pub const PANGO_BIDI_TYPE_RLO: PangoBidiType = 6;
pub const PANGO_BIDI_TYPE_PDF: PangoBidiType = 7;
pub const PANGO_BIDI_TYPE_EN: PangoBidiType = 8;
pub const PANGO_BIDI_TYPE_ES: PangoBidiType = 9;
pub const PANGO_BIDI_TYPE_ET: PangoBidiType = 10;
pub const PANGO_BIDI_TYPE_AN: PangoBidiType = 11;
pub const PANGO_BIDI_TYPE_CS: PangoBidiType = 12;
pub const PANGO_BIDI_TYPE_NSM: PangoBidiType = 13;
pub const PANGO_BIDI_TYPE_BN: PangoBidiType = 14;
pub const PANGO_BIDI_TYPE_B: PangoBidiType = 15;
pub const PANGO_BIDI_TYPE_S: PangoBidiType = 16;
pub const PANGO_BIDI_TYPE_WS: PangoBidiType = 17;
pub const PANGO_BIDI_TYPE_ON: PangoBidiType = 18;
pub const PANGO_BIDI_TYPE_LRI: PangoBidiType = 19;
pub const PANGO_BIDI_TYPE_RLI: PangoBidiType = 20;
pub const PANGO_BIDI_TYPE_FSI: PangoBidiType = 21;
pub const PANGO_BIDI_TYPE_PDI: PangoBidiType = 22;

pub type PangoCoverageLevel = c_int;
pub const PANGO_COVERAGE_NONE: PangoCoverageLevel = 0;
pub const PANGO_COVERAGE_FALLBACK: PangoCoverageLevel = 1;
pub const PANGO_COVERAGE_APPROXIMATE: PangoCoverageLevel = 2;
pub const PANGO_COVERAGE_EXACT: PangoCoverageLevel = 3;

pub type PangoDirection = c_int;
pub const PANGO_DIRECTION_LTR: PangoDirection = 0;
pub const PANGO_DIRECTION_RTL: PangoDirection = 1;
pub const PANGO_DIRECTION_TTB_LTR: PangoDirection = 2;
pub const PANGO_DIRECTION_TTB_RTL: PangoDirection = 3;
pub const PANGO_DIRECTION_WEAK_LTR: PangoDirection = 4;
pub const PANGO_DIRECTION_WEAK_RTL: PangoDirection = 5;
pub const PANGO_DIRECTION_NEUTRAL: PangoDirection = 6;

pub type PangoEllipsizeMode = c_int;
pub const PANGO_ELLIPSIZE_NONE: PangoEllipsizeMode = 0;
pub const PANGO_ELLIPSIZE_START: PangoEllipsizeMode = 1;
pub const PANGO_ELLIPSIZE_MIDDLE: PangoEllipsizeMode = 2;
pub const PANGO_ELLIPSIZE_END: PangoEllipsizeMode = 3;

pub type PangoFontScale = c_int;
pub const PANGO_FONT_SCALE_NONE: PangoFontScale = 0;
pub const PANGO_FONT_SCALE_SUPERSCRIPT: PangoFontScale = 1;
pub const PANGO_FONT_SCALE_SUBSCRIPT: PangoFontScale = 2;
pub const PANGO_FONT_SCALE_SMALL_CAPS: PangoFontScale = 3;

pub type PangoGravity = c_int;
pub const PANGO_GRAVITY_SOUTH: PangoGravity = 0;
pub const PANGO_GRAVITY_EAST: PangoGravity = 1;
pub const PANGO_GRAVITY_NORTH: PangoGravity = 2;
pub const PANGO_GRAVITY_WEST: PangoGravity = 3;
pub const PANGO_GRAVITY_AUTO: PangoGravity = 4;

pub type PangoGravityHint = c_int;
pub const PANGO_GRAVITY_HINT_NATURAL: PangoGravityHint = 0;
pub const PANGO_GRAVITY_HINT_STRONG: PangoGravityHint = 1;
pub const PANGO_GRAVITY_HINT_LINE: PangoGravityHint = 2;

pub type PangoLayoutDeserializeError = c_int;
pub const PANGO_LAYOUT_DESERIALIZE_INVALID: PangoLayoutDeserializeError = 0;
pub const PANGO_LAYOUT_DESERIALIZE_INVALID_VALUE: PangoLayoutDeserializeError = 1;
pub const PANGO_LAYOUT_DESERIALIZE_MISSING_VALUE: PangoLayoutDeserializeError = 2;

pub type PangoOverline = c_int;
pub const PANGO_OVERLINE_NONE: PangoOverline = 0;
pub const PANGO_OVERLINE_SINGLE: PangoOverline = 1;

pub type PangoRenderPart = c_int;
pub const PANGO_RENDER_PART_FOREGROUND: PangoRenderPart = 0;
pub const PANGO_RENDER_PART_BACKGROUND: PangoRenderPart = 1;
pub const PANGO_RENDER_PART_UNDERLINE: PangoRenderPart = 2;
pub const PANGO_RENDER_PART_STRIKETHROUGH: PangoRenderPart = 3;
pub const PANGO_RENDER_PART_OVERLINE: PangoRenderPart = 4;

pub type PangoScript = c_int;
pub const PANGO_SCRIPT_INVALID_CODE: PangoScript = -1;
pub const PANGO_SCRIPT_COMMON: PangoScript = 0;
pub const PANGO_SCRIPT_INHERITED: PangoScript = 1;
pub const PANGO_SCRIPT_ARABIC: PangoScript = 2;
pub const PANGO_SCRIPT_ARMENIAN: PangoScript = 3;
pub const PANGO_SCRIPT_BENGALI: PangoScript = 4;
pub const PANGO_SCRIPT_BOPOMOFO: PangoScript = 5;
pub const PANGO_SCRIPT_CHEROKEE: PangoScript = 6;
pub const PANGO_SCRIPT_COPTIC: PangoScript = 7;
pub const PANGO_SCRIPT_CYRILLIC: PangoScript = 8;
pub const PANGO_SCRIPT_DESERET: PangoScript = 9;
pub const PANGO_SCRIPT_DEVANAGARI: PangoScript = 10;
pub const PANGO_SCRIPT_ETHIOPIC: PangoScript = 11;
pub const PANGO_SCRIPT_GEORGIAN: PangoScript = 12;
pub const PANGO_SCRIPT_GOTHIC: PangoScript = 13;
pub const PANGO_SCRIPT_GREEK: PangoScript = 14;
pub const PANGO_SCRIPT_GUJARATI: PangoScript = 15;
pub const PANGO_SCRIPT_GURMUKHI: PangoScript = 16;
pub const PANGO_SCRIPT_HAN: PangoScript = 17;
pub const PANGO_SCRIPT_HANGUL: PangoScript = 18;
pub const PANGO_SCRIPT_HEBREW: PangoScript = 19;
pub const PANGO_SCRIPT_HIRAGANA: PangoScript = 20;
pub const PANGO_SCRIPT_KANNADA: PangoScript = 21;
pub const PANGO_SCRIPT_KATAKANA: PangoScript = 22;
pub const PANGO_SCRIPT_KHMER: PangoScript = 23;
pub const PANGO_SCRIPT_LAO: PangoScript = 24;
pub const PANGO_SCRIPT_LATIN: PangoScript = 25;
pub const PANGO_SCRIPT_MALAYALAM: PangoScript = 26;
pub const PANGO_SCRIPT_MONGOLIAN: PangoScript = 27;
pub const PANGO_SCRIPT_MYANMAR: PangoScript = 28;
pub const PANGO_SCRIPT_OGHAM: PangoScript = 29;
pub const PANGO_SCRIPT_OLD_ITALIC: PangoScript = 30;
pub const PANGO_SCRIPT_ORIYA: PangoScript = 31;
pub const PANGO_SCRIPT_RUNIC: PangoScript = 32;
pub const PANGO_SCRIPT_SINHALA: PangoScript = 33;
pub const PANGO_SCRIPT_SYRIAC: PangoScript = 34;
pub const PANGO_SCRIPT_TAMIL: PangoScript = 35;
pub const PANGO_SCRIPT_TELUGU: PangoScript = 36;
pub const PANGO_SCRIPT_THAANA: PangoScript = 37;
pub const PANGO_SCRIPT_THAI: PangoScript = 38;
pub const PANGO_SCRIPT_TIBETAN: PangoScript = 39;
pub const PANGO_SCRIPT_CANADIAN_ABORIGINAL: PangoScript = 40;
pub const PANGO_SCRIPT_YI: PangoScript = 41;
pub const PANGO_SCRIPT_TAGALOG: PangoScript = 42;
pub const PANGO_SCRIPT_HANUNOO: PangoScript = 43;
pub const PANGO_SCRIPT_BUHID: PangoScript = 44;
pub const PANGO_SCRIPT_TAGBANWA: PangoScript = 45;
pub const PANGO_SCRIPT_BRAILLE: PangoScript = 46;
pub const PANGO_SCRIPT_CYPRIOT: PangoScript = 47;
pub const PANGO_SCRIPT_LIMBU: PangoScript = 48;
pub const PANGO_SCRIPT_OSMANYA: PangoScript = 49;
pub const PANGO_SCRIPT_SHAVIAN: PangoScript = 50;
pub const PANGO_SCRIPT_LINEAR_B: PangoScript = 51;
pub const PANGO_SCRIPT_TAI_LE: PangoScript = 52;
pub const PANGO_SCRIPT_UGARITIC: PangoScript = 53;
pub const PANGO_SCRIPT_NEW_TAI_LUE: PangoScript = 54;
pub const PANGO_SCRIPT_BUGINESE: PangoScript = 55;
pub const PANGO_SCRIPT_GLAGOLITIC: PangoScript = 56;
pub const PANGO_SCRIPT_TIFINAGH: PangoScript = 57;
pub const PANGO_SCRIPT_SYLOTI_NAGRI: PangoScript = 58;
pub const PANGO_SCRIPT_OLD_PERSIAN: PangoScript = 59;
pub const PANGO_SCRIPT_KHAROSHTHI: PangoScript = 60;
pub const PANGO_SCRIPT_UNKNOWN: PangoScript = 61;
pub const PANGO_SCRIPT_BALINESE: PangoScript = 62;
pub const PANGO_SCRIPT_CUNEIFORM: PangoScript = 63;
pub const PANGO_SCRIPT_PHOENICIAN: PangoScript = 64;
pub const PANGO_SCRIPT_PHAGS_PA: PangoScript = 65;
pub const PANGO_SCRIPT_NKO: PangoScript = 66;
pub const PANGO_SCRIPT_KAYAH_LI: PangoScript = 67;
pub const PANGO_SCRIPT_LEPCHA: PangoScript = 68;
pub const PANGO_SCRIPT_REJANG: PangoScript = 69;
pub const PANGO_SCRIPT_SUNDANESE: PangoScript = 70;
pub const PANGO_SCRIPT_SAURASHTRA: PangoScript = 71;
pub const PANGO_SCRIPT_CHAM: PangoScript = 72;
pub const PANGO_SCRIPT_OL_CHIKI: PangoScript = 73;
pub const PANGO_SCRIPT_VAI: PangoScript = 74;
pub const PANGO_SCRIPT_CARIAN: PangoScript = 75;
pub const PANGO_SCRIPT_LYCIAN: PangoScript = 76;
pub const PANGO_SCRIPT_LYDIAN: PangoScript = 77;
pub const PANGO_SCRIPT_BATAK: PangoScript = 78;
pub const PANGO_SCRIPT_BRAHMI: PangoScript = 79;
pub const PANGO_SCRIPT_MANDAIC: PangoScript = 80;
pub const PANGO_SCRIPT_CHAKMA: PangoScript = 81;
pub const PANGO_SCRIPT_MEROITIC_CURSIVE: PangoScript = 82;
pub const PANGO_SCRIPT_MEROITIC_HIEROGLYPHS: PangoScript = 83;
pub const PANGO_SCRIPT_MIAO: PangoScript = 84;
pub const PANGO_SCRIPT_SHARADA: PangoScript = 85;
pub const PANGO_SCRIPT_SORA_SOMPENG: PangoScript = 86;
pub const PANGO_SCRIPT_TAKRI: PangoScript = 87;
pub const PANGO_SCRIPT_BASSA_VAH: PangoScript = 88;
pub const PANGO_SCRIPT_CAUCASIAN_ALBANIAN: PangoScript = 89;
pub const PANGO_SCRIPT_DUPLOYAN: PangoScript = 90;
pub const PANGO_SCRIPT_ELBASAN: PangoScript = 91;
pub const PANGO_SCRIPT_GRANTHA: PangoScript = 92;
pub const PANGO_SCRIPT_KHOJKI: PangoScript = 93;
pub const PANGO_SCRIPT_KHUDAWADI: PangoScript = 94;
pub const PANGO_SCRIPT_LINEAR_A: PangoScript = 95;
pub const PANGO_SCRIPT_MAHAJANI: PangoScript = 96;
pub const PANGO_SCRIPT_MANICHAEAN: PangoScript = 97;
pub const PANGO_SCRIPT_MENDE_KIKAKUI: PangoScript = 98;
pub const PANGO_SCRIPT_MODI: PangoScript = 99;
pub const PANGO_SCRIPT_MRO: PangoScript = 100;
pub const PANGO_SCRIPT_NABATAEAN: PangoScript = 101;
pub const PANGO_SCRIPT_OLD_NORTH_ARABIAN: PangoScript = 102;
pub const PANGO_SCRIPT_OLD_PERMIC: PangoScript = 103;
pub const PANGO_SCRIPT_PAHAWH_HMONG: PangoScript = 104;
pub const PANGO_SCRIPT_PALMYRENE: PangoScript = 105;
pub const PANGO_SCRIPT_PAU_CIN_HAU: PangoScript = 106;
pub const PANGO_SCRIPT_PSALTER_PAHLAVI: PangoScript = 107;
pub const PANGO_SCRIPT_SIDDHAM: PangoScript = 108;
pub const PANGO_SCRIPT_TIRHUTA: PangoScript = 109;
pub const PANGO_SCRIPT_WARANG_CITI: PangoScript = 110;
pub const PANGO_SCRIPT_AHOM: PangoScript = 111;
pub const PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS: PangoScript = 112;
pub const PANGO_SCRIPT_HATRAN: PangoScript = 113;
pub const PANGO_SCRIPT_MULTANI: PangoScript = 114;
pub const PANGO_SCRIPT_OLD_HUNGARIAN: PangoScript = 115;
pub const PANGO_SCRIPT_SIGNWRITING: PangoScript = 116;

pub type PangoStretch = c_int;
pub const PANGO_STRETCH_ULTRA_CONDENSED: PangoStretch = 0;
pub const PANGO_STRETCH_EXTRA_CONDENSED: PangoStretch = 1;
pub const PANGO_STRETCH_CONDENSED: PangoStretch = 2;
pub const PANGO_STRETCH_SEMI_CONDENSED: PangoStretch = 3;
pub const PANGO_STRETCH_NORMAL: PangoStretch = 4;
pub const PANGO_STRETCH_SEMI_EXPANDED: PangoStretch = 5;
pub const PANGO_STRETCH_EXPANDED: PangoStretch = 6;
pub const PANGO_STRETCH_EXTRA_EXPANDED: PangoStretch = 7;
pub const PANGO_STRETCH_ULTRA_EXPANDED: PangoStretch = 8;

pub type PangoStyle = c_int;
pub const PANGO_STYLE_NORMAL: PangoStyle = 0;
pub const PANGO_STYLE_OBLIQUE: PangoStyle = 1;
pub const PANGO_STYLE_ITALIC: PangoStyle = 2;

pub type PangoTabAlign = c_int;
pub const PANGO_TAB_LEFT: PangoTabAlign = 0;
pub const PANGO_TAB_RIGHT: PangoTabAlign = 1;
pub const PANGO_TAB_CENTER: PangoTabAlign = 2;
pub const PANGO_TAB_DECIMAL: PangoTabAlign = 3;

pub type PangoTextTransform = c_int;
pub const PANGO_TEXT_TRANSFORM_NONE: PangoTextTransform = 0;
pub const PANGO_TEXT_TRANSFORM_LOWERCASE: PangoTextTransform = 1;
pub const PANGO_TEXT_TRANSFORM_UPPERCASE: PangoTextTransform = 2;
pub const PANGO_TEXT_TRANSFORM_CAPITALIZE: PangoTextTransform = 3;

pub type PangoUnderline = c_int;
pub const PANGO_UNDERLINE_NONE: PangoUnderline = 0;
pub const PANGO_UNDERLINE_SINGLE: PangoUnderline = 1;
pub const PANGO_UNDERLINE_DOUBLE: PangoUnderline = 2;
pub const PANGO_UNDERLINE_LOW: PangoUnderline = 3;
pub const PANGO_UNDERLINE_ERROR: PangoUnderline = 4;
pub const PANGO_UNDERLINE_SINGLE_LINE: PangoUnderline = 5;
pub const PANGO_UNDERLINE_DOUBLE_LINE: PangoUnderline = 6;
pub const PANGO_UNDERLINE_ERROR_LINE: PangoUnderline = 7;

pub type PangoVariant = c_int;
pub const PANGO_VARIANT_NORMAL: PangoVariant = 0;
pub const PANGO_VARIANT_SMALL_CAPS: PangoVariant = 1;
pub const PANGO_VARIANT_ALL_SMALL_CAPS: PangoVariant = 2;
pub const PANGO_VARIANT_PETITE_CAPS: PangoVariant = 3;
pub const PANGO_VARIANT_ALL_PETITE_CAPS: PangoVariant = 4;
pub const PANGO_VARIANT_UNICASE: PangoVariant = 5;
pub const PANGO_VARIANT_TITLE_CAPS: PangoVariant = 6;

pub type PangoWeight = c_int;
pub const PANGO_WEIGHT_THIN: PangoWeight = 100;
pub const PANGO_WEIGHT_ULTRALIGHT: PangoWeight = 200;
pub const PANGO_WEIGHT_LIGHT: PangoWeight = 300;
pub const PANGO_WEIGHT_SEMILIGHT: PangoWeight = 350;
pub const PANGO_WEIGHT_BOOK: PangoWeight = 380;
pub const PANGO_WEIGHT_NORMAL: PangoWeight = 400;
pub const PANGO_WEIGHT_MEDIUM: PangoWeight = 500;
pub const PANGO_WEIGHT_SEMIBOLD: PangoWeight = 600;
pub const PANGO_WEIGHT_BOLD: PangoWeight = 700;
pub const PANGO_WEIGHT_ULTRABOLD: PangoWeight = 800;
pub const PANGO_WEIGHT_HEAVY: PangoWeight = 900;
pub const PANGO_WEIGHT_ULTRAHEAVY: PangoWeight = 1000;

pub type PangoWrapMode = c_int;
pub const PANGO_WRAP_WORD: PangoWrapMode = 0;
pub const PANGO_WRAP_CHAR: PangoWrapMode = 1;
pub const PANGO_WRAP_WORD_CHAR: PangoWrapMode = 2;

// Constants
pub const PANGO_ANALYSIS_FLAG_CENTERED_BASELINE: c_int = 1;
pub const PANGO_ANALYSIS_FLAG_IS_ELLIPSIS: c_int = 2;
pub const PANGO_ANALYSIS_FLAG_NEED_HYPHEN: c_int = 4;
pub const PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING: c_uint = 0;
pub const PANGO_ATTR_INDEX_TO_TEXT_END: c_uint = 4294967295;
pub const PANGO_GLYPH_EMPTY: PangoGlyph = 268435455;
pub const PANGO_GLYPH_INVALID_INPUT: PangoGlyph = 4294967295;
pub const PANGO_GLYPH_UNKNOWN_FLAG: PangoGlyph = 268435456;
pub const PANGO_SCALE: c_int = 1024;

// Flags
pub type PangoFontMask = c_uint;
pub const PANGO_FONT_MASK_FAMILY: PangoFontMask = 1;
pub const PANGO_FONT_MASK_STYLE: PangoFontMask = 2;
pub const PANGO_FONT_MASK_VARIANT: PangoFontMask = 4;
pub const PANGO_FONT_MASK_WEIGHT: PangoFontMask = 8;
pub const PANGO_FONT_MASK_STRETCH: PangoFontMask = 16;
pub const PANGO_FONT_MASK_SIZE: PangoFontMask = 32;
pub const PANGO_FONT_MASK_GRAVITY: PangoFontMask = 64;
pub const PANGO_FONT_MASK_VARIATIONS: PangoFontMask = 128;

pub type PangoLayoutDeserializeFlags = c_uint;
pub const PANGO_LAYOUT_DESERIALIZE_DEFAULT: PangoLayoutDeserializeFlags = 0;
pub const PANGO_LAYOUT_DESERIALIZE_CONTEXT: PangoLayoutDeserializeFlags = 1;

pub type PangoLayoutSerializeFlags = c_uint;
pub const PANGO_LAYOUT_SERIALIZE_DEFAULT: PangoLayoutSerializeFlags = 0;
pub const PANGO_LAYOUT_SERIALIZE_CONTEXT: PangoLayoutSerializeFlags = 1;
pub const PANGO_LAYOUT_SERIALIZE_OUTPUT: PangoLayoutSerializeFlags = 2;

pub type PangoShapeFlags = c_uint;
pub const PANGO_SHAPE_NONE: PangoShapeFlags = 0;
pub const PANGO_SHAPE_ROUND_POSITIONS: PangoShapeFlags = 1;

pub type PangoShowFlags = c_uint;
pub const PANGO_SHOW_NONE: PangoShowFlags = 0;
pub const PANGO_SHOW_SPACES: PangoShowFlags = 1;
pub const PANGO_SHOW_LINE_BREAKS: PangoShowFlags = 2;
pub const PANGO_SHOW_IGNORABLES: PangoShowFlags = 4;

// Callbacks
pub type PangoAttrDataCopyFunc = Option<unsafe extern "C" fn(gconstpointer) -> gpointer>;
pub type PangoAttrFilterFunc =
    Option<unsafe extern "C" fn(*mut PangoAttribute, gpointer) -> gboolean>;
pub type PangoFontsetForeachFunc =
    Option<unsafe extern "C" fn(*mut PangoFontset, *mut PangoFont, gpointer) -> gboolean>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAnalysis {
    pub shape_engine: gpointer,
    pub lang_engine: gpointer,
    pub font: *mut PangoFont,
    pub level: u8,
    pub gravity: u8,
    pub flags: u8,
    pub script: u8,
    pub language: *mut PangoLanguage,
    pub extra_attrs: *mut glib::GSList,
}

impl ::std::fmt::Debug for PangoAnalysis {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAnalysis @ {self:p}"))
            .field("shape_engine", &self.shape_engine)
            .field("lang_engine", &self.lang_engine)
            .field("font", &self.font)
            .field("level", &self.level)
            .field("gravity", &self.gravity)
            .field("flags", &self.flags)
            .field("script", &self.script)
            .field("language", &self.language)
            .field("extra_attrs", &self.extra_attrs)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrClass {
    pub type_: PangoAttrType,
    pub copy: Option<unsafe extern "C" fn(*const PangoAttribute) -> *mut PangoAttribute>,
    pub destroy: Option<unsafe extern "C" fn(*mut PangoAttribute)>,
    pub equal:
        Option<unsafe extern "C" fn(*const PangoAttribute, *const PangoAttribute) -> gboolean>,
}

impl ::std::fmt::Debug for PangoAttrClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrClass @ {self:p}"))
            .field("type_", &self.type_)
            .field("copy", &self.copy)
            .field("destroy", &self.destroy)
            .field("equal", &self.equal)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrColor {
    pub attr: PangoAttribute,
    pub color: PangoColor,
}

impl ::std::fmt::Debug for PangoAttrColor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrColor @ {self:p}"))
            .field("attr", &self.attr)
            .field("color", &self.color)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrFloat {
    pub attr: PangoAttribute,
    pub value: c_double,
}

impl ::std::fmt::Debug for PangoAttrFloat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrFloat @ {self:p}"))
            .field("attr", &self.attr)
            .field("value", &self.value)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrFontDesc {
    pub attr: PangoAttribute,
    pub desc: *mut PangoFontDescription,
}

impl ::std::fmt::Debug for PangoAttrFontDesc {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrFontDesc @ {self:p}"))
            .field("attr", &self.attr)
            .field("desc", &self.desc)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrFontFeatures {
    pub attr: PangoAttribute,
    pub features: *mut c_char,
}

impl ::std::fmt::Debug for PangoAttrFontFeatures {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrFontFeatures @ {self:p}"))
            .field("attr", &self.attr)
            .field("features", &self.features)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrInt {
    pub attr: PangoAttribute,
    pub value: c_int,
}

impl ::std::fmt::Debug for PangoAttrInt {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrInt @ {self:p}"))
            .field("attr", &self.attr)
            .field("value", &self.value)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoAttrIterator {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoAttrIterator {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrIterator @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrLanguage {
    pub attr: PangoAttribute,
    pub value: *mut PangoLanguage,
}

impl ::std::fmt::Debug for PangoAttrLanguage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrLanguage @ {self:p}"))
            .field("attr", &self.attr)
            .field("value", &self.value)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoAttrList {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoAttrList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrList @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrShape {
    pub attr: PangoAttribute,
    pub ink_rect: PangoRectangle,
    pub logical_rect: PangoRectangle,
    pub data: gpointer,
    pub copy_func: PangoAttrDataCopyFunc,
    pub destroy_func: glib::GDestroyNotify,
}

impl ::std::fmt::Debug for PangoAttrShape {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrShape @ {self:p}"))
            .field("attr", &self.attr)
            .field("ink_rect", &self.ink_rect)
            .field("logical_rect", &self.logical_rect)
            .field("data", &self.data)
            .field("copy_func", &self.copy_func)
            .field("destroy_func", &self.destroy_func)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrSize {
    pub attr: PangoAttribute,
    pub size: c_int,
    pub absolute: c_uint,
}

impl ::std::fmt::Debug for PangoAttrSize {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrSize @ {self:p}"))
            .field("attr", &self.attr)
            .field("size", &self.size)
            .field("absolute", &self.absolute)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttrString {
    pub attr: PangoAttribute,
    pub value: *mut c_char,
}

impl ::std::fmt::Debug for PangoAttrString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttrString @ {self:p}"))
            .field("attr", &self.attr)
            .field("value", &self.value)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoAttribute {
    pub klass: *const PangoAttrClass,
    pub start_index: c_uint,
    pub end_index: c_uint,
}

impl ::std::fmt::Debug for PangoAttribute {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoAttribute @ {self:p}"))
            .field("klass", &self.klass)
            .field("start_index", &self.start_index)
            .field("end_index", &self.end_index)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoColor {
    pub red: u16,
    pub green: u16,
    pub blue: u16,
}

impl ::std::fmt::Debug for PangoColor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoColor @ {self:p}"))
            .field("red", &self.red)
            .field("green", &self.green)
            .field("blue", &self.blue)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _PangoContextClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PangoContextClass = _PangoContextClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontClass {
    pub parent_class: gobject::GObjectClass,
    pub describe: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
    pub get_coverage:
        Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoCoverage>,
    pub get_glyph_extents: Option<
        unsafe extern "C" fn(*mut PangoFont, PangoGlyph, *mut PangoRectangle, *mut PangoRectangle),
    >,
    pub get_metrics:
        Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoFontMetrics>,
    pub get_font_map: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontMap>,
    pub describe_absolute:
        Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
    pub get_features:
        Option<unsafe extern "C" fn(*mut PangoFont, gconstpointer, c_uint, *mut c_uint)>,
    pub create_hb_font: Option<unsafe extern "C" fn(*mut PangoFont) -> gconstpointer>,
}

impl ::std::fmt::Debug for PangoFontClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("describe", &self.describe)
            .field("get_coverage", &self.get_coverage)
            .field("get_glyph_extents", &self.get_glyph_extents)
            .field("get_metrics", &self.get_metrics)
            .field("get_font_map", &self.get_font_map)
            .field("describe_absolute", &self.describe_absolute)
            .field("get_features", &self.get_features)
            .field("create_hb_font", &self.create_hb_font)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoFontDescription {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoFontDescription {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontDescription @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontFaceClass {
    pub parent_class: gobject::GObjectClass,
    pub get_face_name: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *const c_char>,
    pub describe: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *mut PangoFontDescription>,
    pub list_sizes: Option<unsafe extern "C" fn(*mut PangoFontFace, *mut *mut c_int, *mut c_int)>,
    pub is_synthesized: Option<unsafe extern "C" fn(*mut PangoFontFace) -> gboolean>,
    pub get_family: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *mut PangoFontFamily>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PangoFontFaceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontFaceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("get_face_name", &self.get_face_name)
            .field("describe", &self.describe)
            .field("list_sizes", &self.list_sizes)
            .field("is_synthesized", &self.is_synthesized)
            .field("get_family", &self.get_family)
            .field("_pango_reserved3", &self._pango_reserved3)
            .field("_pango_reserved4", &self._pango_reserved4)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontFamilyClass {
    pub parent_class: gobject::GObjectClass,
    pub list_faces: Option<
        unsafe extern "C" fn(*mut PangoFontFamily, *mut *mut *mut PangoFontFace, *mut c_int),
    >,
    pub get_name: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> *const c_char>,
    pub is_monospace: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> gboolean>,
    pub is_variable: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> gboolean>,
    pub get_face:
        Option<unsafe extern "C" fn(*mut PangoFontFamily, *const c_char) -> *mut PangoFontFace>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PangoFontFamilyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontFamilyClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("list_faces", &self.list_faces)
            .field("get_name", &self.get_name)
            .field("is_monospace", &self.is_monospace)
            .field("is_variable", &self.is_variable)
            .field("get_face", &self.get_face)
            .field("_pango_reserved2", &self._pango_reserved2)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontMapClass {
    pub parent_class: gobject::GObjectClass,
    pub load_font: Option<
        unsafe extern "C" fn(
            *mut PangoFontMap,
            *mut PangoContext,
            *const PangoFontDescription,
        ) -> *mut PangoFont,
    >,
    pub list_families:
        Option<unsafe extern "C" fn(*mut PangoFontMap, *mut *mut *mut PangoFontFamily, *mut c_int)>,
    pub load_fontset: Option<
        unsafe extern "C" fn(
            *mut PangoFontMap,
            *mut PangoContext,
            *const PangoFontDescription,
            *mut PangoLanguage,
        ) -> *mut PangoFontset,
    >,
    pub shape_engine_type: *const c_char,
    pub get_serial: Option<unsafe extern "C" fn(*mut PangoFontMap) -> c_uint>,
    pub changed: Option<unsafe extern "C" fn(*mut PangoFontMap)>,
    pub get_family:
        Option<unsafe extern "C" fn(*mut PangoFontMap, *const c_char) -> *mut PangoFontFamily>,
    pub get_face:
        Option<unsafe extern "C" fn(*mut PangoFontMap, *mut PangoFont) -> *mut PangoFontFace>,
}

impl ::std::fmt::Debug for PangoFontMapClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontMapClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("load_font", &self.load_font)
            .field("list_families", &self.list_families)
            .field("load_fontset", &self.load_fontset)
            .field("shape_engine_type", &self.shape_engine_type)
            .field("get_serial", &self.get_serial)
            .field("changed", &self.changed)
            .field("get_family", &self.get_family)
            .field("get_face", &self.get_face)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontMetrics {
    pub ref_count: c_uint,
    pub ascent: c_int,
    pub descent: c_int,
    pub height: c_int,
    pub approximate_char_width: c_int,
    pub approximate_digit_width: c_int,
    pub underline_position: c_int,
    pub underline_thickness: c_int,
    pub strikethrough_position: c_int,
    pub strikethrough_thickness: c_int,
}

impl ::std::fmt::Debug for PangoFontMetrics {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontMetrics @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontsetClass {
    pub parent_class: gobject::GObjectClass,
    pub get_font: Option<unsafe extern "C" fn(*mut PangoFontset, c_uint) -> *mut PangoFont>,
    pub get_metrics: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoFontMetrics>,
    pub get_language: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoLanguage>,
    pub foreach: Option<unsafe extern "C" fn(*mut PangoFontset, PangoFontsetForeachFunc, gpointer)>,
    pub _pango_reserved1: Option<unsafe extern "C" fn()>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PangoFontsetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontsetClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("get_font", &self.get_font)
            .field("get_metrics", &self.get_metrics)
            .field("get_language", &self.get_language)
            .field("foreach", &self.foreach)
            .field("_pango_reserved1", &self._pango_reserved1)
            .field("_pango_reserved2", &self._pango_reserved2)
            .field("_pango_reserved3", &self._pango_reserved3)
            .field("_pango_reserved4", &self._pango_reserved4)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _PangoFontsetSimpleClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PangoFontsetSimpleClass = _PangoFontsetSimpleClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphGeometry {
    pub width: PangoGlyphUnit,
    pub x_offset: PangoGlyphUnit,
    pub y_offset: PangoGlyphUnit,
}

impl ::std::fmt::Debug for PangoGlyphGeometry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphGeometry @ {self:p}"))
            .field("width", &self.width)
            .field("x_offset", &self.x_offset)
            .field("y_offset", &self.y_offset)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphInfo {
    pub glyph: PangoGlyph,
    pub geometry: PangoGlyphGeometry,
    pub attr: PangoGlyphVisAttr,
}

impl ::std::fmt::Debug for PangoGlyphInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphInfo @ {self:p}"))
            .field("glyph", &self.glyph)
            .field("geometry", &self.geometry)
            .field("attr", &self.attr)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphItem {
    pub item: *mut PangoItem,
    pub glyphs: *mut PangoGlyphString,
    pub y_offset: c_int,
    pub start_x_offset: c_int,
    pub end_x_offset: c_int,
}

impl ::std::fmt::Debug for PangoGlyphItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphItem @ {self:p}"))
            .field("item", &self.item)
            .field("glyphs", &self.glyphs)
            .field("y_offset", &self.y_offset)
            .field("start_x_offset", &self.start_x_offset)
            .field("end_x_offset", &self.end_x_offset)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphItemIter {
    pub glyph_item: *mut PangoGlyphItem,
    pub text: *const c_char,
    pub start_glyph: c_int,
    pub start_index: c_int,
    pub start_char: c_int,
    pub end_glyph: c_int,
    pub end_index: c_int,
    pub end_char: c_int,
}

impl ::std::fmt::Debug for PangoGlyphItemIter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphItemIter @ {self:p}"))
            .field("glyph_item", &self.glyph_item)
            .field("text", &self.text)
            .field("start_glyph", &self.start_glyph)
            .field("start_index", &self.start_index)
            .field("start_char", &self.start_char)
            .field("end_glyph", &self.end_glyph)
            .field("end_index", &self.end_index)
            .field("end_char", &self.end_char)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphString {
    pub num_glyphs: c_int,
    pub glyphs: *mut PangoGlyphInfo,
    pub log_clusters: *mut c_int,
    pub space: c_int,
}

impl ::std::fmt::Debug for PangoGlyphString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphString @ {self:p}"))
            .field("num_glyphs", &self.num_glyphs)
            .field("glyphs", &self.glyphs)
            .field("log_clusters", &self.log_clusters)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoGlyphVisAttr {
    pub is_cluster_start: c_uint,
}

impl ::std::fmt::Debug for PangoGlyphVisAttr {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoGlyphVisAttr @ {self:p}"))
            .field("is_cluster_start", &self.is_cluster_start)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoItem {
    pub offset: c_int,
    pub length: c_int,
    pub num_chars: c_int,
    pub analysis: PangoAnalysis,
}

impl ::std::fmt::Debug for PangoItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoItem @ {self:p}"))
            .field("offset", &self.offset)
            .field("length", &self.length)
            .field("num_chars", &self.num_chars)
            .field("analysis", &self.analysis)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoLanguage {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoLanguage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoLanguage @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _PangoLayoutClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PangoLayoutClass = _PangoLayoutClass;

#[repr(C)]
#[allow(dead_code)]
pub struct PangoLayoutIter {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoLayoutIter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoLayoutIter @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoLayoutLine {
    pub layout: *mut PangoLayout,
    pub start_index: c_int,
    pub length: c_int,
    pub runs: *mut glib::GSList,
    pub is_paragraph_start: c_uint,
    _truncated_record_marker: c_void,
    // field resolved_dir has incomplete type
}

impl ::std::fmt::Debug for PangoLayoutLine {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoLayoutLine @ {self:p}"))
            .field("layout", &self.layout)
            .field("start_index", &self.start_index)
            .field("length", &self.length)
            .field("runs", &self.runs)
            .field("is_paragraph_start", &self.is_paragraph_start)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoLogAttr {
    pub is_line_break: c_uint,
    _truncated_record_marker: c_void,
    // field is_mandatory_break has incomplete type
}

impl ::std::fmt::Debug for PangoLogAttr {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoLogAttr @ {self:p}"))
            .field("is_line_break", &self.is_line_break)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoMatrix {
    pub xx: c_double,
    pub xy: c_double,
    pub yx: c_double,
    pub yy: c_double,
    pub x0: c_double,
    pub y0: c_double,
}

impl ::std::fmt::Debug for PangoMatrix {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoMatrix @ {self:p}"))
            .field("xx", &self.xx)
            .field("xy", &self.xy)
            .field("yx", &self.yx)
            .field("yy", &self.yy)
            .field("x0", &self.x0)
            .field("y0", &self.y0)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoRectangle {
    pub x: c_int,
    pub y: c_int,
    pub width: c_int,
    pub height: c_int,
}

impl ::std::fmt::Debug for PangoRectangle {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoRectangle @ {self:p}"))
            .field("x", &self.x)
            .field("y", &self.y)
            .field("width", &self.width)
            .field("height", &self.height)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoRendererClass {
    pub parent_class: gobject::GObjectClass,
    pub draw_glyphs: Option<
        unsafe extern "C" fn(
            *mut PangoRenderer,
            *mut PangoFont,
            *mut PangoGlyphString,
            c_int,
            c_int,
        ),
    >,
    pub draw_rectangle: Option<
        unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart, c_int, c_int, c_int, c_int),
    >,
    pub draw_error_underline:
        Option<unsafe extern "C" fn(*mut PangoRenderer, c_int, c_int, c_int, c_int)>,
    pub draw_shape:
        Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoAttrShape, c_int, c_int)>,
    pub draw_trapezoid: Option<
        unsafe extern "C" fn(
            *mut PangoRenderer,
            PangoRenderPart,
            c_double,
            c_double,
            c_double,
            c_double,
            c_double,
            c_double,
        ),
    >,
    pub draw_glyph: Option<
        unsafe extern "C" fn(*mut PangoRenderer, *mut PangoFont, PangoGlyph, c_double, c_double),
    >,
    pub part_changed: Option<unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart)>,
    pub begin: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
    pub end: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
    pub prepare_run: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoLayoutRun)>,
    pub draw_glyph_item: Option<
        unsafe extern "C" fn(*mut PangoRenderer, *const c_char, *mut PangoGlyphItem, c_int, c_int),
    >,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for PangoRendererClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoRendererClass @ {self:p}"))
            .field("draw_glyphs", &self.draw_glyphs)
            .field("draw_rectangle", &self.draw_rectangle)
            .field("draw_error_underline", &self.draw_error_underline)
            .field("draw_shape", &self.draw_shape)
            .field("draw_trapezoid", &self.draw_trapezoid)
            .field("draw_glyph", &self.draw_glyph)
            .field("part_changed", &self.part_changed)
            .field("begin", &self.begin)
            .field("end", &self.end)
            .field("prepare_run", &self.prepare_run)
            .field("draw_glyph_item", &self.draw_glyph_item)
            .field("_pango_reserved2", &self._pango_reserved2)
            .field("_pango_reserved3", &self._pango_reserved3)
            .field("_pango_reserved4", &self._pango_reserved4)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _PangoRendererPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PangoRendererPrivate = _PangoRendererPrivate;

#[repr(C)]
#[allow(dead_code)]
pub struct PangoScriptIter {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoScriptIter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoScriptIter @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoTabArray {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoTabArray {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoTabArray @ {self:p}"))
            .finish()
    }
}

// Classes
#[repr(C)]
#[allow(dead_code)]
pub struct PangoContext {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoContext {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoContext @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoCoverage {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoCoverage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoCoverage @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFont {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PangoFont {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFont @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontFace {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PangoFontFace {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontFace @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontFamily {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PangoFontFamily {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontFamily @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontMap {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PangoFontMap {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontMap @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoFontset {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PangoFontset {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontset @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoFontsetSimple {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoFontsetSimple {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoFontsetSimple @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PangoLayout {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PangoLayout {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoLayout @ {self:p}")).finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PangoRenderer {
    pub parent_instance: gobject::GObject,
    pub underline: PangoUnderline,
    pub strikethrough: gboolean,
    pub active_count: c_int,
    pub matrix: *mut PangoMatrix,
    pub priv_: *mut PangoRendererPrivate,
}

impl ::std::fmt::Debug for PangoRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PangoRenderer @ {self:p}"))
            .field("matrix", &self.matrix)
            .finish()
    }
}

extern "C" {

    //=========================================================================
    // PangoAlignment
    //=========================================================================
    pub fn pango_alignment_get_type() -> GType;

    //=========================================================================
    // PangoAttrType
    //=========================================================================
    pub fn pango_attr_type_get_type() -> GType;
    pub fn pango_attr_type_get_name(type_: PangoAttrType) -> *const c_char;
    pub fn pango_attr_type_register(name: *const c_char) -> PangoAttrType;

    //=========================================================================
    // PangoBaselineShift
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_baseline_shift_get_type() -> GType;

    //=========================================================================
    // PangoBidiType
    //=========================================================================
    pub fn pango_bidi_type_get_type() -> GType;
    pub fn pango_bidi_type_for_unichar(ch: u32) -> PangoBidiType;

    //=========================================================================
    // PangoCoverageLevel
    //=========================================================================
    pub fn pango_coverage_level_get_type() -> GType;

    //=========================================================================
    // PangoDirection
    //=========================================================================
    pub fn pango_direction_get_type() -> GType;

    //=========================================================================
    // PangoEllipsizeMode
    //=========================================================================
    pub fn pango_ellipsize_mode_get_type() -> GType;

    //=========================================================================
    // PangoFontScale
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_font_scale_get_type() -> GType;

    //=========================================================================
    // PangoGravity
    //=========================================================================
    pub fn pango_gravity_get_type() -> GType;
    pub fn pango_gravity_get_for_matrix(matrix: *const PangoMatrix) -> PangoGravity;
    pub fn pango_gravity_get_for_script(
        script: PangoScript,
        base_gravity: PangoGravity,
        hint: PangoGravityHint,
    ) -> PangoGravity;
    pub fn pango_gravity_get_for_script_and_width(
        script: PangoScript,
        wide: gboolean,
        base_gravity: PangoGravity,
        hint: PangoGravityHint,
    ) -> PangoGravity;
    pub fn pango_gravity_to_rotation(gravity: PangoGravity) -> c_double;

    //=========================================================================
    // PangoGravityHint
    //=========================================================================
    pub fn pango_gravity_hint_get_type() -> GType;

    //=========================================================================
    // PangoLayoutDeserializeError
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_deserialize_error_get_type() -> GType;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_deserialize_error_quark() -> glib::GQuark;

    //=========================================================================
    // PangoOverline
    //=========================================================================
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_overline_get_type() -> GType;

    //=========================================================================
    // PangoRenderPart
    //=========================================================================
    pub fn pango_render_part_get_type() -> GType;

    //=========================================================================
    // PangoScript
    //=========================================================================
    pub fn pango_script_get_type() -> GType;
    pub fn pango_script_for_unichar(ch: u32) -> PangoScript;
    pub fn pango_script_get_sample_language(script: PangoScript) -> *mut PangoLanguage;

    //=========================================================================
    // PangoStretch
    //=========================================================================
    pub fn pango_stretch_get_type() -> GType;

    //=========================================================================
    // PangoStyle
    //=========================================================================
    pub fn pango_style_get_type() -> GType;

    //=========================================================================
    // PangoTabAlign
    //=========================================================================
    pub fn pango_tab_align_get_type() -> GType;

    //=========================================================================
    // PangoTextTransform
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_text_transform_get_type() -> GType;

    //=========================================================================
    // PangoUnderline
    //=========================================================================
    pub fn pango_underline_get_type() -> GType;

    //=========================================================================
    // PangoVariant
    //=========================================================================
    pub fn pango_variant_get_type() -> GType;

    //=========================================================================
    // PangoWeight
    //=========================================================================
    pub fn pango_weight_get_type() -> GType;

    //=========================================================================
    // PangoWrapMode
    //=========================================================================
    pub fn pango_wrap_mode_get_type() -> GType;

    //=========================================================================
    // PangoFontMask
    //=========================================================================
    pub fn pango_font_mask_get_type() -> GType;

    //=========================================================================
    // PangoLayoutDeserializeFlags
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_deserialize_flags_get_type() -> GType;

    //=========================================================================
    // PangoLayoutSerializeFlags
    //=========================================================================
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_serialize_flags_get_type() -> GType;

    //=========================================================================
    // PangoShapeFlags
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_shape_flags_get_type() -> GType;

    //=========================================================================
    // PangoShowFlags
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_show_flags_get_type() -> GType;

    //=========================================================================
    // PangoAttrFontDesc
    //=========================================================================
    pub fn pango_attr_font_desc_new(desc: *const PangoFontDescription) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrFontFeatures
    //=========================================================================
    pub fn pango_attr_font_features_new(features: *const c_char) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrIterator
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_iterator_get_type() -> GType;
    pub fn pango_attr_iterator_copy(iterator: *mut PangoAttrIterator) -> *mut PangoAttrIterator;
    pub fn pango_attr_iterator_destroy(iterator: *mut PangoAttrIterator);
    pub fn pango_attr_iterator_get(
        iterator: *mut PangoAttrIterator,
        type_: PangoAttrType,
    ) -> *mut PangoAttribute;
    pub fn pango_attr_iterator_get_attrs(iterator: *mut PangoAttrIterator) -> *mut glib::GSList;
    pub fn pango_attr_iterator_get_font(
        iterator: *mut PangoAttrIterator,
        desc: *mut PangoFontDescription,
        language: *mut *mut PangoLanguage,
        extra_attrs: *mut *mut glib::GSList,
    );
    pub fn pango_attr_iterator_next(iterator: *mut PangoAttrIterator) -> gboolean;
    pub fn pango_attr_iterator_range(
        iterator: *mut PangoAttrIterator,
        start: *mut c_int,
        end: *mut c_int,
    );

    //=========================================================================
    // PangoAttrLanguage
    //=========================================================================
    pub fn pango_attr_language_new(language: *mut PangoLanguage) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrList
    //=========================================================================
    pub fn pango_attr_list_get_type() -> GType;
    pub fn pango_attr_list_new() -> *mut PangoAttrList;
    pub fn pango_attr_list_change(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_copy(list: *mut PangoAttrList) -> *mut PangoAttrList;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_attr_list_equal(
        list: *mut PangoAttrList,
        other_list: *mut PangoAttrList,
    ) -> gboolean;
    pub fn pango_attr_list_filter(
        list: *mut PangoAttrList,
        func: PangoAttrFilterFunc,
        data: gpointer,
    ) -> *mut PangoAttrList;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_list_get_attributes(list: *mut PangoAttrList) -> *mut glib::GSList;
    pub fn pango_attr_list_get_iterator(list: *mut PangoAttrList) -> *mut PangoAttrIterator;
    pub fn pango_attr_list_insert(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_insert_before(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_ref(list: *mut PangoAttrList) -> *mut PangoAttrList;
    pub fn pango_attr_list_splice(
        list: *mut PangoAttrList,
        other: *mut PangoAttrList,
        pos: c_int,
        len: c_int,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_list_to_string(list: *mut PangoAttrList) -> *mut c_char;
    pub fn pango_attr_list_unref(list: *mut PangoAttrList);
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_list_update(list: *mut PangoAttrList, pos: c_int, remove: c_int, add: c_int);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_list_from_string(text: *const c_char) -> *mut PangoAttrList;

    //=========================================================================
    // PangoAttrShape
    //=========================================================================
    pub fn pango_attr_shape_new(
        ink_rect: *const PangoRectangle,
        logical_rect: *const PangoRectangle,
    ) -> *mut PangoAttribute;
    pub fn pango_attr_shape_new_with_data(
        ink_rect: *const PangoRectangle,
        logical_rect: *const PangoRectangle,
        data: gpointer,
        copy_func: PangoAttrDataCopyFunc,
        destroy_func: glib::GDestroyNotify,
    ) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrSize
    //=========================================================================
    pub fn pango_attr_size_new(size: c_int) -> *mut PangoAttribute;
    pub fn pango_attr_size_new_absolute(size: c_int) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttribute
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attribute_get_type() -> GType;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_color(attr: *mut PangoAttribute) -> *mut PangoAttrColor;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_float(attr: *mut PangoAttribute) -> *mut PangoAttrFloat;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_font_desc(attr: *mut PangoAttribute) -> *mut PangoAttrFontDesc;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_font_features(
        attr: *mut PangoAttribute,
    ) -> *mut PangoAttrFontFeatures;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_int(attr: *mut PangoAttribute) -> *mut PangoAttrInt;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_language(attr: *mut PangoAttribute) -> *mut PangoAttrLanguage;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_shape(attr: *mut PangoAttribute) -> *mut PangoAttrShape;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_size(attr: *mut PangoAttribute) -> *mut PangoAttrSize;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attribute_as_string(attr: *mut PangoAttribute) -> *mut PangoAttrString;
    pub fn pango_attribute_copy(attr: *const PangoAttribute) -> *mut PangoAttribute;
    pub fn pango_attribute_destroy(attr: *mut PangoAttribute);
    pub fn pango_attribute_equal(
        attr1: *const PangoAttribute,
        attr2: *const PangoAttribute,
    ) -> gboolean;
    pub fn pango_attribute_init(attr: *mut PangoAttribute, klass: *const PangoAttrClass);

    //=========================================================================
    // PangoColor
    //=========================================================================
    pub fn pango_color_get_type() -> GType;
    pub fn pango_color_copy(src: *const PangoColor) -> *mut PangoColor;
    pub fn pango_color_free(color: *mut PangoColor);
    pub fn pango_color_parse(color: *mut PangoColor, spec: *const c_char) -> gboolean;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_color_parse_with_alpha(
        color: *mut PangoColor,
        alpha: *mut u16,
        spec: *const c_char,
    ) -> gboolean;
    pub fn pango_color_to_string(color: *const PangoColor) -> *mut c_char;

    //=========================================================================
    // PangoFontDescription
    //=========================================================================
    pub fn pango_font_description_get_type() -> GType;
    pub fn pango_font_description_new() -> *mut PangoFontDescription;
    pub fn pango_font_description_better_match(
        desc: *const PangoFontDescription,
        old_match: *const PangoFontDescription,
        new_match: *const PangoFontDescription,
    ) -> gboolean;
    pub fn pango_font_description_copy(
        desc: *const PangoFontDescription,
    ) -> *mut PangoFontDescription;
    pub fn pango_font_description_copy_static(
        desc: *const PangoFontDescription,
    ) -> *mut PangoFontDescription;
    pub fn pango_font_description_equal(
        desc1: *const PangoFontDescription,
        desc2: *const PangoFontDescription,
    ) -> gboolean;
    pub fn pango_font_description_free(desc: *mut PangoFontDescription);
    pub fn pango_font_description_get_family(desc: *const PangoFontDescription) -> *const c_char;
    pub fn pango_font_description_get_gravity(desc: *const PangoFontDescription) -> PangoGravity;
    pub fn pango_font_description_get_set_fields(
        desc: *const PangoFontDescription,
    ) -> PangoFontMask;
    pub fn pango_font_description_get_size(desc: *const PangoFontDescription) -> c_int;
    pub fn pango_font_description_get_size_is_absolute(
        desc: *const PangoFontDescription,
    ) -> gboolean;
    pub fn pango_font_description_get_stretch(desc: *const PangoFontDescription) -> PangoStretch;
    pub fn pango_font_description_get_style(desc: *const PangoFontDescription) -> PangoStyle;
    pub fn pango_font_description_get_variant(desc: *const PangoFontDescription) -> PangoVariant;
    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    pub fn pango_font_description_get_variations(
        desc: *const PangoFontDescription,
    ) -> *const c_char;
    pub fn pango_font_description_get_weight(desc: *const PangoFontDescription) -> PangoWeight;
    pub fn pango_font_description_hash(desc: *const PangoFontDescription) -> c_uint;
    pub fn pango_font_description_merge(
        desc: *mut PangoFontDescription,
        desc_to_merge: *const PangoFontDescription,
        replace_existing: gboolean,
    );
    pub fn pango_font_description_merge_static(
        desc: *mut PangoFontDescription,
        desc_to_merge: *const PangoFontDescription,
        replace_existing: gboolean,
    );
    pub fn pango_font_description_set_absolute_size(
        desc: *mut PangoFontDescription,
        size: c_double,
    );
    pub fn pango_font_description_set_family(
        desc: *mut PangoFontDescription,
        family: *const c_char,
    );
    pub fn pango_font_description_set_family_static(
        desc: *mut PangoFontDescription,
        family: *const c_char,
    );
    pub fn pango_font_description_set_gravity(
        desc: *mut PangoFontDescription,
        gravity: PangoGravity,
    );
    pub fn pango_font_description_set_size(desc: *mut PangoFontDescription, size: c_int);
    pub fn pango_font_description_set_stretch(
        desc: *mut PangoFontDescription,
        stretch: PangoStretch,
    );
    pub fn pango_font_description_set_style(desc: *mut PangoFontDescription, style: PangoStyle);
    pub fn pango_font_description_set_variant(
        desc: *mut PangoFontDescription,
        variant: PangoVariant,
    );
    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    pub fn pango_font_description_set_variations(
        desc: *mut PangoFontDescription,
        variations: *const c_char,
    );
    #[cfg(feature = "v1_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
    pub fn pango_font_description_set_variations_static(
        desc: *mut PangoFontDescription,
        variations: *const c_char,
    );
    pub fn pango_font_description_set_weight(desc: *mut PangoFontDescription, weight: PangoWeight);
    pub fn pango_font_description_to_filename(desc: *const PangoFontDescription) -> *mut c_char;
    pub fn pango_font_description_to_string(desc: *const PangoFontDescription) -> *mut c_char;
    pub fn pango_font_description_unset_fields(
        desc: *mut PangoFontDescription,
        to_unset: PangoFontMask,
    );
    pub fn pango_font_description_from_string(str: *const c_char) -> *mut PangoFontDescription;

    //=========================================================================
    // PangoFontMetrics
    //=========================================================================
    pub fn pango_font_metrics_get_type() -> GType;
    pub fn pango_font_metrics_get_approximate_char_width(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_approximate_digit_width(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_ascent(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_descent(metrics: *mut PangoFontMetrics) -> c_int;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_font_metrics_get_height(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_strikethrough_position(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_strikethrough_thickness(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_underline_position(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_underline_thickness(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_ref(metrics: *mut PangoFontMetrics) -> *mut PangoFontMetrics;
    pub fn pango_font_metrics_unref(metrics: *mut PangoFontMetrics);

    //=========================================================================
    // PangoGlyphItem
    //=========================================================================
    pub fn pango_glyph_item_get_type() -> GType;
    pub fn pango_glyph_item_apply_attrs(
        glyph_item: *mut PangoGlyphItem,
        text: *const c_char,
        list: *mut PangoAttrList,
    ) -> *mut glib::GSList;
    pub fn pango_glyph_item_copy(orig: *mut PangoGlyphItem) -> *mut PangoGlyphItem;
    pub fn pango_glyph_item_free(glyph_item: *mut PangoGlyphItem);
    pub fn pango_glyph_item_get_logical_widths(
        glyph_item: *mut PangoGlyphItem,
        text: *const c_char,
        logical_widths: *mut c_int,
    );
    pub fn pango_glyph_item_letter_space(
        glyph_item: *mut PangoGlyphItem,
        text: *const c_char,
        log_attrs: *mut PangoLogAttr,
        letter_spacing: c_int,
    );
    pub fn pango_glyph_item_split(
        orig: *mut PangoGlyphItem,
        text: *const c_char,
        split_index: c_int,
    ) -> *mut PangoGlyphItem;

    //=========================================================================
    // PangoGlyphItemIter
    //=========================================================================
    pub fn pango_glyph_item_iter_get_type() -> GType;
    pub fn pango_glyph_item_iter_copy(orig: *mut PangoGlyphItemIter) -> *mut PangoGlyphItemIter;
    pub fn pango_glyph_item_iter_free(iter: *mut PangoGlyphItemIter);
    pub fn pango_glyph_item_iter_init_end(
        iter: *mut PangoGlyphItemIter,
        glyph_item: *mut PangoGlyphItem,
        text: *const c_char,
    ) -> gboolean;
    pub fn pango_glyph_item_iter_init_start(
        iter: *mut PangoGlyphItemIter,
        glyph_item: *mut PangoGlyphItem,
        text: *const c_char,
    ) -> gboolean;
    pub fn pango_glyph_item_iter_next_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;
    pub fn pango_glyph_item_iter_prev_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;

    //=========================================================================
    // PangoGlyphString
    //=========================================================================
    pub fn pango_glyph_string_get_type() -> GType;
    pub fn pango_glyph_string_new() -> *mut PangoGlyphString;
    pub fn pango_glyph_string_copy(string: *mut PangoGlyphString) -> *mut PangoGlyphString;
    pub fn pango_glyph_string_extents(
        glyphs: *mut PangoGlyphString,
        font: *mut PangoFont,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_glyph_string_extents_range(
        glyphs: *mut PangoGlyphString,
        start: c_int,
        end: c_int,
        font: *mut PangoFont,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_glyph_string_free(string: *mut PangoGlyphString);
    pub fn pango_glyph_string_get_logical_widths(
        glyphs: *mut PangoGlyphString,
        text: *const c_char,
        length: c_int,
        embedding_level: c_int,
        logical_widths: *mut c_int,
    );
    pub fn pango_glyph_string_get_width(glyphs: *mut PangoGlyphString) -> c_int;
    pub fn pango_glyph_string_index_to_x(
        glyphs: *mut PangoGlyphString,
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        index_: c_int,
        trailing: gboolean,
        x_pos: *mut c_int,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_glyph_string_index_to_x_full(
        glyphs: *mut PangoGlyphString,
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        attrs: *mut PangoLogAttr,
        index_: c_int,
        trailing: gboolean,
        x_pos: *mut c_int,
    );
    pub fn pango_glyph_string_set_size(string: *mut PangoGlyphString, new_len: c_int);
    pub fn pango_glyph_string_x_to_index(
        glyphs: *mut PangoGlyphString,
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        x_pos: c_int,
        index_: *mut c_int,
        trailing: *mut c_int,
    );

    //=========================================================================
    // PangoItem
    //=========================================================================
    pub fn pango_item_get_type() -> GType;
    pub fn pango_item_new() -> *mut PangoItem;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_item_apply_attrs(item: *mut PangoItem, iter: *mut PangoAttrIterator);
    pub fn pango_item_copy(item: *mut PangoItem) -> *mut PangoItem;
    pub fn pango_item_free(item: *mut PangoItem);
    #[cfg(feature = "v1_54")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_54")))]
    pub fn pango_item_get_char_offset(item: *mut PangoItem) -> c_int;
    pub fn pango_item_split(
        orig: *mut PangoItem,
        split_index: c_int,
        split_offset: c_int,
    ) -> *mut PangoItem;

    //=========================================================================
    // PangoLanguage
    //=========================================================================
    pub fn pango_language_get_type() -> GType;
    pub fn pango_language_get_sample_string(language: *mut PangoLanguage) -> *const c_char;
    pub fn pango_language_get_scripts(
        language: *mut PangoLanguage,
        num_scripts: *mut c_int,
    ) -> *const PangoScript;
    pub fn pango_language_includes_script(
        language: *mut PangoLanguage,
        script: PangoScript,
    ) -> gboolean;
    pub fn pango_language_matches(
        language: *mut PangoLanguage,
        range_list: *const c_char,
    ) -> gboolean;
    pub fn pango_language_to_string(language: *mut PangoLanguage) -> *const c_char;
    pub fn pango_language_from_string(language: *const c_char) -> *mut PangoLanguage;
    pub fn pango_language_get_default() -> *mut PangoLanguage;
    #[cfg(feature = "v1_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_48")))]
    pub fn pango_language_get_preferred() -> *mut *mut PangoLanguage;

    //=========================================================================
    // PangoLayoutIter
    //=========================================================================
    pub fn pango_layout_iter_get_type() -> GType;
    pub fn pango_layout_iter_at_last_line(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_copy(iter: *mut PangoLayoutIter) -> *mut PangoLayoutIter;
    pub fn pango_layout_iter_free(iter: *mut PangoLayoutIter);
    pub fn pango_layout_iter_get_baseline(iter: *mut PangoLayoutIter) -> c_int;
    pub fn pango_layout_iter_get_char_extents(
        iter: *mut PangoLayoutIter,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_iter_get_cluster_extents(
        iter: *mut PangoLayoutIter,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_iter_get_index(iter: *mut PangoLayoutIter) -> c_int;
    pub fn pango_layout_iter_get_layout(iter: *mut PangoLayoutIter) -> *mut PangoLayout;
    pub fn pango_layout_iter_get_layout_extents(
        iter: *mut PangoLayoutIter,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_iter_get_line(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
    pub fn pango_layout_iter_get_line_extents(
        iter: *mut PangoLayoutIter,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_iter_get_line_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
    pub fn pango_layout_iter_get_line_yrange(
        iter: *mut PangoLayoutIter,
        y0_: *mut c_int,
        y1_: *mut c_int,
    );
    pub fn pango_layout_iter_get_run(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_iter_get_run_baseline(iter: *mut PangoLayoutIter) -> c_int;
    pub fn pango_layout_iter_get_run_extents(
        iter: *mut PangoLayoutIter,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_iter_get_run_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
    pub fn pango_layout_iter_next_char(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_cluster(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_line(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_run(iter: *mut PangoLayoutIter) -> gboolean;

    //=========================================================================
    // PangoLayoutLine
    //=========================================================================
    pub fn pango_layout_line_get_type() -> GType;
    pub fn pango_layout_line_get_extents(
        line: *mut PangoLayoutLine,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_layout_line_get_height(line: *mut PangoLayoutLine, height: *mut c_int);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_line_get_length(line: *mut PangoLayoutLine) -> c_int;
    pub fn pango_layout_line_get_pixel_extents(
        layout_line: *mut PangoLayoutLine,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_line_get_resolved_direction(line: *mut PangoLayoutLine) -> PangoDirection;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_line_get_start_index(line: *mut PangoLayoutLine) -> c_int;
    pub fn pango_layout_line_get_x_ranges(
        line: *mut PangoLayoutLine,
        start_index: c_int,
        end_index: c_int,
        ranges: *mut *mut c_int,
        n_ranges: *mut c_int,
    );
    pub fn pango_layout_line_index_to_x(
        line: *mut PangoLayoutLine,
        index_: c_int,
        trailing: gboolean,
        x_pos: *mut c_int,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_line_is_paragraph_start(line: *mut PangoLayoutLine) -> gboolean;
    pub fn pango_layout_line_ref(line: *mut PangoLayoutLine) -> *mut PangoLayoutLine;
    pub fn pango_layout_line_unref(line: *mut PangoLayoutLine);
    pub fn pango_layout_line_x_to_index(
        line: *mut PangoLayoutLine,
        x_pos: c_int,
        index_: *mut c_int,
        trailing: *mut c_int,
    ) -> gboolean;

    //=========================================================================
    // PangoMatrix
    //=========================================================================
    pub fn pango_matrix_get_type() -> GType;
    pub fn pango_matrix_concat(matrix: *mut PangoMatrix, new_matrix: *const PangoMatrix);
    pub fn pango_matrix_copy(matrix: *const PangoMatrix) -> *mut PangoMatrix;
    pub fn pango_matrix_free(matrix: *mut PangoMatrix);
    pub fn pango_matrix_get_font_scale_factor(matrix: *const PangoMatrix) -> c_double;
    pub fn pango_matrix_get_font_scale_factors(
        matrix: *const PangoMatrix,
        xscale: *mut c_double,
        yscale: *mut c_double,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_matrix_get_slant_ratio(matrix: *const PangoMatrix) -> c_double;
    pub fn pango_matrix_rotate(matrix: *mut PangoMatrix, degrees: c_double);
    pub fn pango_matrix_scale(matrix: *mut PangoMatrix, scale_x: c_double, scale_y: c_double);
    pub fn pango_matrix_transform_distance(
        matrix: *const PangoMatrix,
        dx: *mut c_double,
        dy: *mut c_double,
    );
    pub fn pango_matrix_transform_pixel_rectangle(
        matrix: *const PangoMatrix,
        rect: *mut PangoRectangle,
    );
    pub fn pango_matrix_transform_point(
        matrix: *const PangoMatrix,
        x: *mut c_double,
        y: *mut c_double,
    );
    pub fn pango_matrix_transform_rectangle(matrix: *const PangoMatrix, rect: *mut PangoRectangle);
    pub fn pango_matrix_translate(matrix: *mut PangoMatrix, tx: c_double, ty: c_double);

    //=========================================================================
    // PangoScriptIter
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_script_iter_get_type() -> GType;
    pub fn pango_script_iter_new(text: *const c_char, length: c_int) -> *mut PangoScriptIter;
    pub fn pango_script_iter_free(iter: *mut PangoScriptIter);
    pub fn pango_script_iter_get_range(
        iter: *mut PangoScriptIter,
        start: *mut *const c_char,
        end: *mut *const c_char,
        script: *mut PangoScript,
    );
    pub fn pango_script_iter_next(iter: *mut PangoScriptIter) -> gboolean;

    //=========================================================================
    // PangoTabArray
    //=========================================================================
    pub fn pango_tab_array_get_type() -> GType;
    pub fn pango_tab_array_new(
        initial_size: c_int,
        positions_in_pixels: gboolean,
    ) -> *mut PangoTabArray;
    pub fn pango_tab_array_new_with_positions(
        size: c_int,
        positions_in_pixels: gboolean,
        first_alignment: PangoTabAlign,
        first_position: c_int,
        ...
    ) -> *mut PangoTabArray;
    pub fn pango_tab_array_copy(src: *mut PangoTabArray) -> *mut PangoTabArray;
    pub fn pango_tab_array_free(tab_array: *mut PangoTabArray);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_get_decimal_point(
        tab_array: *mut PangoTabArray,
        tab_index: c_int,
    ) -> u32;
    pub fn pango_tab_array_get_positions_in_pixels(tab_array: *mut PangoTabArray) -> gboolean;
    pub fn pango_tab_array_get_size(tab_array: *mut PangoTabArray) -> c_int;
    pub fn pango_tab_array_get_tab(
        tab_array: *mut PangoTabArray,
        tab_index: c_int,
        alignment: *mut PangoTabAlign,
        location: *mut c_int,
    );
    pub fn pango_tab_array_get_tabs(
        tab_array: *mut PangoTabArray,
        alignments: *mut *mut PangoTabAlign,
        locations: *mut *mut c_int,
    );
    pub fn pango_tab_array_resize(tab_array: *mut PangoTabArray, new_size: c_int);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_set_decimal_point(
        tab_array: *mut PangoTabArray,
        tab_index: c_int,
        decimal_point: u32,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_set_positions_in_pixels(
        tab_array: *mut PangoTabArray,
        positions_in_pixels: gboolean,
    );
    pub fn pango_tab_array_set_tab(
        tab_array: *mut PangoTabArray,
        tab_index: c_int,
        alignment: PangoTabAlign,
        location: c_int,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_sort(tab_array: *mut PangoTabArray);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_to_string(tab_array: *mut PangoTabArray) -> *mut c_char;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_tab_array_from_string(text: *const c_char) -> *mut PangoTabArray;

    //=========================================================================
    // PangoContext
    //=========================================================================
    pub fn pango_context_get_type() -> GType;
    pub fn pango_context_new() -> *mut PangoContext;
    pub fn pango_context_changed(context: *mut PangoContext);
    pub fn pango_context_get_base_dir(context: *mut PangoContext) -> PangoDirection;
    pub fn pango_context_get_base_gravity(context: *mut PangoContext) -> PangoGravity;
    pub fn pango_context_get_font_description(
        context: *mut PangoContext,
    ) -> *mut PangoFontDescription;
    pub fn pango_context_get_font_map(context: *mut PangoContext) -> *mut PangoFontMap;
    pub fn pango_context_get_gravity(context: *mut PangoContext) -> PangoGravity;
    pub fn pango_context_get_gravity_hint(context: *mut PangoContext) -> PangoGravityHint;
    pub fn pango_context_get_language(context: *mut PangoContext) -> *mut PangoLanguage;
    pub fn pango_context_get_matrix(context: *mut PangoContext) -> *const PangoMatrix;
    pub fn pango_context_get_metrics(
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
        language: *mut PangoLanguage,
    ) -> *mut PangoFontMetrics;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_context_get_round_glyph_positions(context: *mut PangoContext) -> gboolean;
    pub fn pango_context_get_serial(context: *mut PangoContext) -> c_uint;
    pub fn pango_context_list_families(
        context: *mut PangoContext,
        families: *mut *mut *mut PangoFontFamily,
        n_families: *mut c_int,
    );
    pub fn pango_context_load_font(
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
    ) -> *mut PangoFont;
    pub fn pango_context_load_fontset(
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
        language: *mut PangoLanguage,
    ) -> *mut PangoFontset;
    pub fn pango_context_set_base_dir(context: *mut PangoContext, direction: PangoDirection);
    pub fn pango_context_set_base_gravity(context: *mut PangoContext, gravity: PangoGravity);
    pub fn pango_context_set_font_description(
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
    );
    pub fn pango_context_set_font_map(context: *mut PangoContext, font_map: *mut PangoFontMap);
    pub fn pango_context_set_gravity_hint(context: *mut PangoContext, hint: PangoGravityHint);
    pub fn pango_context_set_language(context: *mut PangoContext, language: *mut PangoLanguage);
    pub fn pango_context_set_matrix(context: *mut PangoContext, matrix: *const PangoMatrix);
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_context_set_round_glyph_positions(
        context: *mut PangoContext,
        round_positions: gboolean,
    );

    //=========================================================================
    // PangoCoverage
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_coverage_get_type() -> GType;
    pub fn pango_coverage_new() -> *mut PangoCoverage;
    pub fn pango_coverage_from_bytes(bytes: *mut u8, n_bytes: c_int) -> *mut PangoCoverage;
    pub fn pango_coverage_copy(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
    pub fn pango_coverage_get(coverage: *mut PangoCoverage, index_: c_int) -> PangoCoverageLevel;
    pub fn pango_coverage_max(coverage: *mut PangoCoverage, other: *mut PangoCoverage);
    pub fn pango_coverage_ref(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
    pub fn pango_coverage_set(
        coverage: *mut PangoCoverage,
        index_: c_int,
        level: PangoCoverageLevel,
    );
    pub fn pango_coverage_to_bytes(
        coverage: *mut PangoCoverage,
        bytes: *mut *mut u8,
        n_bytes: *mut c_int,
    );
    pub fn pango_coverage_unref(coverage: *mut PangoCoverage);

    //=========================================================================
    // PangoFont
    //=========================================================================
    pub fn pango_font_get_type() -> GType;
    pub fn pango_font_descriptions_free(descs: *mut *mut PangoFontDescription, n_descs: c_int);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_font_deserialize(
        context: *mut PangoContext,
        bytes: *mut glib::GBytes,
        error: *mut *mut glib::GError,
    ) -> *mut PangoFont;
    pub fn pango_font_describe(font: *mut PangoFont) -> *mut PangoFontDescription;
    pub fn pango_font_describe_with_absolute_size(
        font: *mut PangoFont,
    ) -> *mut PangoFontDescription;
    pub fn pango_font_get_coverage(
        font: *mut PangoFont,
        language: *mut PangoLanguage,
    ) -> *mut PangoCoverage;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_font_get_face(font: *mut PangoFont) -> *mut PangoFontFace;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_font_get_features(
        font: *mut PangoFont,
        features: gconstpointer,
        len: c_uint,
        num_features: *mut c_uint,
    );
    pub fn pango_font_get_font_map(font: *mut PangoFont) -> *mut PangoFontMap;
    pub fn pango_font_get_glyph_extents(
        font: *mut PangoFont,
        glyph: PangoGlyph,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_font_get_hb_font(font: *mut PangoFont) -> gconstpointer;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_font_get_languages(font: *mut PangoFont) -> *mut *mut PangoLanguage;
    pub fn pango_font_get_metrics(
        font: *mut PangoFont,
        language: *mut PangoLanguage,
    ) -> *mut PangoFontMetrics;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_font_has_char(font: *mut PangoFont, wc: u32) -> gboolean;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_font_serialize(font: *mut PangoFont) -> *mut glib::GBytes;

    //=========================================================================
    // PangoFontFace
    //=========================================================================
    pub fn pango_font_face_get_type() -> GType;
    pub fn pango_font_face_describe(face: *mut PangoFontFace) -> *mut PangoFontDescription;
    pub fn pango_font_face_get_face_name(face: *mut PangoFontFace) -> *const c_char;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_font_face_get_family(face: *mut PangoFontFace) -> *mut PangoFontFamily;
    pub fn pango_font_face_is_synthesized(face: *mut PangoFontFace) -> gboolean;
    pub fn pango_font_face_list_sizes(
        face: *mut PangoFontFace,
        sizes: *mut *mut c_int,
        n_sizes: *mut c_int,
    );

    //=========================================================================
    // PangoFontFamily
    //=========================================================================
    pub fn pango_font_family_get_type() -> GType;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_font_family_get_face(
        family: *mut PangoFontFamily,
        name: *const c_char,
    ) -> *mut PangoFontFace;
    pub fn pango_font_family_get_name(family: *mut PangoFontFamily) -> *const c_char;
    pub fn pango_font_family_is_monospace(family: *mut PangoFontFamily) -> gboolean;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_font_family_is_variable(family: *mut PangoFontFamily) -> gboolean;
    pub fn pango_font_family_list_faces(
        family: *mut PangoFontFamily,
        faces: *mut *mut *mut PangoFontFace,
        n_faces: *mut c_int,
    );

    //=========================================================================
    // PangoFontMap
    //=========================================================================
    pub fn pango_font_map_get_type() -> GType;
    #[cfg(feature = "v1_56")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
    pub fn pango_font_map_add_font_file(
        fontmap: *mut PangoFontMap,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pango_font_map_changed(fontmap: *mut PangoFontMap);
    pub fn pango_font_map_create_context(fontmap: *mut PangoFontMap) -> *mut PangoContext;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_font_map_get_family(
        fontmap: *mut PangoFontMap,
        name: *const c_char,
    ) -> *mut PangoFontFamily;
    pub fn pango_font_map_get_serial(fontmap: *mut PangoFontMap) -> c_uint;
    pub fn pango_font_map_list_families(
        fontmap: *mut PangoFontMap,
        families: *mut *mut *mut PangoFontFamily,
        n_families: *mut c_int,
    );
    pub fn pango_font_map_load_font(
        fontmap: *mut PangoFontMap,
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
    ) -> *mut PangoFont;
    pub fn pango_font_map_load_fontset(
        fontmap: *mut PangoFontMap,
        context: *mut PangoContext,
        desc: *const PangoFontDescription,
        language: *mut PangoLanguage,
    ) -> *mut PangoFontset;
    #[cfg(feature = "v1_52")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_52")))]
    pub fn pango_font_map_reload_font(
        fontmap: *mut PangoFontMap,
        font: *mut PangoFont,
        scale: c_double,
        context: *mut PangoContext,
        variations: *const c_char,
    ) -> *mut PangoFont;

    //=========================================================================
    // PangoFontset
    //=========================================================================
    pub fn pango_fontset_get_type() -> GType;
    pub fn pango_fontset_foreach(
        fontset: *mut PangoFontset,
        func: PangoFontsetForeachFunc,
        data: gpointer,
    );
    pub fn pango_fontset_get_font(fontset: *mut PangoFontset, wc: c_uint) -> *mut PangoFont;
    pub fn pango_fontset_get_metrics(fontset: *mut PangoFontset) -> *mut PangoFontMetrics;

    //=========================================================================
    // PangoFontsetSimple
    //=========================================================================
    pub fn pango_fontset_simple_get_type() -> GType;
    pub fn pango_fontset_simple_new(language: *mut PangoLanguage) -> *mut PangoFontsetSimple;
    pub fn pango_fontset_simple_append(fontset: *mut PangoFontsetSimple, font: *mut PangoFont);
    pub fn pango_fontset_simple_size(fontset: *mut PangoFontsetSimple) -> c_int;

    //=========================================================================
    // PangoLayout
    //=========================================================================
    pub fn pango_layout_get_type() -> GType;
    pub fn pango_layout_new(context: *mut PangoContext) -> *mut PangoLayout;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_deserialize(
        context: *mut PangoContext,
        bytes: *mut glib::GBytes,
        flags: PangoLayoutDeserializeFlags,
        error: *mut *mut glib::GError,
    ) -> *mut PangoLayout;
    pub fn pango_layout_context_changed(layout: *mut PangoLayout);
    pub fn pango_layout_copy(src: *mut PangoLayout) -> *mut PangoLayout;
    pub fn pango_layout_get_alignment(layout: *mut PangoLayout) -> PangoAlignment;
    pub fn pango_layout_get_attributes(layout: *mut PangoLayout) -> *mut PangoAttrList;
    pub fn pango_layout_get_auto_dir(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_baseline(layout: *mut PangoLayout) -> c_int;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_get_caret_pos(
        layout: *mut PangoLayout,
        index_: c_int,
        strong_pos: *mut PangoRectangle,
        weak_pos: *mut PangoRectangle,
    );
    pub fn pango_layout_get_character_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_context(layout: *mut PangoLayout) -> *mut PangoContext;
    pub fn pango_layout_get_cursor_pos(
        layout: *mut PangoLayout,
        index_: c_int,
        strong_pos: *mut PangoRectangle,
        weak_pos: *mut PangoRectangle,
    );
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_layout_get_direction(layout: *mut PangoLayout, index: c_int) -> PangoDirection;
    pub fn pango_layout_get_ellipsize(layout: *mut PangoLayout) -> PangoEllipsizeMode;
    pub fn pango_layout_get_extents(
        layout: *mut PangoLayout,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_get_font_description(
        layout: *mut PangoLayout,
    ) -> *const PangoFontDescription;
    pub fn pango_layout_get_height(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_indent(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_iter(layout: *mut PangoLayout) -> *mut PangoLayoutIter;
    pub fn pango_layout_get_justify(layout: *mut PangoLayout) -> gboolean;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_get_justify_last_line(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_line(layout: *mut PangoLayout, line: c_int) -> *mut PangoLayoutLine;
    pub fn pango_layout_get_line_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_line_readonly(
        layout: *mut PangoLayout,
        line: c_int,
    ) -> *mut PangoLayoutLine;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_layout_get_line_spacing(layout: *mut PangoLayout) -> c_float;
    pub fn pango_layout_get_lines(layout: *mut PangoLayout) -> *mut glib::GSList;
    pub fn pango_layout_get_lines_readonly(layout: *mut PangoLayout) -> *mut glib::GSList;
    pub fn pango_layout_get_log_attrs(
        layout: *mut PangoLayout,
        attrs: *mut *mut PangoLogAttr,
        n_attrs: *mut c_int,
    );
    pub fn pango_layout_get_log_attrs_readonly(
        layout: *mut PangoLayout,
        n_attrs: *mut c_int,
    ) -> *const PangoLogAttr;
    pub fn pango_layout_get_pixel_extents(
        layout: *mut PangoLayout,
        ink_rect: *mut PangoRectangle,
        logical_rect: *mut PangoRectangle,
    );
    pub fn pango_layout_get_pixel_size(
        layout: *mut PangoLayout,
        width: *mut c_int,
        height: *mut c_int,
    );
    pub fn pango_layout_get_serial(layout: *mut PangoLayout) -> c_uint;
    pub fn pango_layout_get_single_paragraph_mode(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_size(layout: *mut PangoLayout, width: *mut c_int, height: *mut c_int);
    pub fn pango_layout_get_spacing(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_tabs(layout: *mut PangoLayout) -> *mut PangoTabArray;
    pub fn pango_layout_get_text(layout: *mut PangoLayout) -> *const c_char;
    pub fn pango_layout_get_unknown_glyphs_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_width(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_wrap(layout: *mut PangoLayout) -> PangoWrapMode;
    pub fn pango_layout_index_to_line_x(
        layout: *mut PangoLayout,
        index_: c_int,
        trailing: gboolean,
        line: *mut c_int,
        x_pos: *mut c_int,
    );
    pub fn pango_layout_index_to_pos(
        layout: *mut PangoLayout,
        index_: c_int,
        pos: *mut PangoRectangle,
    );
    pub fn pango_layout_is_ellipsized(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_is_wrapped(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_move_cursor_visually(
        layout: *mut PangoLayout,
        strong: gboolean,
        old_index: c_int,
        old_trailing: c_int,
        direction: c_int,
        new_index: *mut c_int,
        new_trailing: *mut c_int,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_serialize(
        layout: *mut PangoLayout,
        flags: PangoLayoutSerializeFlags,
    ) -> *mut glib::GBytes;
    pub fn pango_layout_set_alignment(layout: *mut PangoLayout, alignment: PangoAlignment);
    pub fn pango_layout_set_attributes(layout: *mut PangoLayout, attrs: *mut PangoAttrList);
    pub fn pango_layout_set_auto_dir(layout: *mut PangoLayout, auto_dir: gboolean);
    pub fn pango_layout_set_ellipsize(layout: *mut PangoLayout, ellipsize: PangoEllipsizeMode);
    pub fn pango_layout_set_font_description(
        layout: *mut PangoLayout,
        desc: *const PangoFontDescription,
    );
    pub fn pango_layout_set_height(layout: *mut PangoLayout, height: c_int);
    pub fn pango_layout_set_indent(layout: *mut PangoLayout, indent: c_int);
    pub fn pango_layout_set_justify(layout: *mut PangoLayout, justify: gboolean);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_set_justify_last_line(layout: *mut PangoLayout, justify: gboolean);
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_layout_set_line_spacing(layout: *mut PangoLayout, factor: c_float);
    pub fn pango_layout_set_markup(layout: *mut PangoLayout, markup: *const c_char, length: c_int);
    pub fn pango_layout_set_markup_with_accel(
        layout: *mut PangoLayout,
        markup: *const c_char,
        length: c_int,
        accel_marker: u32,
        accel_char: *mut u32,
    );
    pub fn pango_layout_set_single_paragraph_mode(layout: *mut PangoLayout, setting: gboolean);
    pub fn pango_layout_set_spacing(layout: *mut PangoLayout, spacing: c_int);
    pub fn pango_layout_set_tabs(layout: *mut PangoLayout, tabs: *mut PangoTabArray);
    pub fn pango_layout_set_text(layout: *mut PangoLayout, text: *const c_char, length: c_int);
    pub fn pango_layout_set_width(layout: *mut PangoLayout, width: c_int);
    pub fn pango_layout_set_wrap(layout: *mut PangoLayout, wrap: PangoWrapMode);
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_layout_write_to_file(
        layout: *mut PangoLayout,
        flags: PangoLayoutSerializeFlags,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pango_layout_xy_to_index(
        layout: *mut PangoLayout,
        x: c_int,
        y: c_int,
        index_: *mut c_int,
        trailing: *mut c_int,
    ) -> gboolean;

    //=========================================================================
    // PangoRenderer
    //=========================================================================
    pub fn pango_renderer_get_type() -> GType;
    pub fn pango_renderer_activate(renderer: *mut PangoRenderer);
    pub fn pango_renderer_deactivate(renderer: *mut PangoRenderer);
    pub fn pango_renderer_draw_error_underline(
        renderer: *mut PangoRenderer,
        x: c_int,
        y: c_int,
        width: c_int,
        height: c_int,
    );
    pub fn pango_renderer_draw_glyph(
        renderer: *mut PangoRenderer,
        font: *mut PangoFont,
        glyph: PangoGlyph,
        x: c_double,
        y: c_double,
    );
    pub fn pango_renderer_draw_glyph_item(
        renderer: *mut PangoRenderer,
        text: *const c_char,
        glyph_item: *mut PangoGlyphItem,
        x: c_int,
        y: c_int,
    );
    pub fn pango_renderer_draw_glyphs(
        renderer: *mut PangoRenderer,
        font: *mut PangoFont,
        glyphs: *mut PangoGlyphString,
        x: c_int,
        y: c_int,
    );
    pub fn pango_renderer_draw_layout(
        renderer: *mut PangoRenderer,
        layout: *mut PangoLayout,
        x: c_int,
        y: c_int,
    );
    pub fn pango_renderer_draw_layout_line(
        renderer: *mut PangoRenderer,
        line: *mut PangoLayoutLine,
        x: c_int,
        y: c_int,
    );
    pub fn pango_renderer_draw_rectangle(
        renderer: *mut PangoRenderer,
        part: PangoRenderPart,
        x: c_int,
        y: c_int,
        width: c_int,
        height: c_int,
    );
    pub fn pango_renderer_draw_trapezoid(
        renderer: *mut PangoRenderer,
        part: PangoRenderPart,
        y1_: c_double,
        x11: c_double,
        x21: c_double,
        y2: c_double,
        x12: c_double,
        x22: c_double,
    );
    pub fn pango_renderer_get_alpha(renderer: *mut PangoRenderer, part: PangoRenderPart) -> u16;
    pub fn pango_renderer_get_color(
        renderer: *mut PangoRenderer,
        part: PangoRenderPart,
    ) -> *mut PangoColor;
    pub fn pango_renderer_get_layout(renderer: *mut PangoRenderer) -> *mut PangoLayout;
    pub fn pango_renderer_get_layout_line(renderer: *mut PangoRenderer) -> *mut PangoLayoutLine;
    pub fn pango_renderer_get_matrix(renderer: *mut PangoRenderer) -> *const PangoMatrix;
    pub fn pango_renderer_part_changed(renderer: *mut PangoRenderer, part: PangoRenderPart);
    pub fn pango_renderer_set_alpha(
        renderer: *mut PangoRenderer,
        part: PangoRenderPart,
        alpha: u16,
    );
    pub fn pango_renderer_set_color(
        renderer: *mut PangoRenderer,
        part: PangoRenderPart,
        color: *const PangoColor,
    );
    pub fn pango_renderer_set_matrix(renderer: *mut PangoRenderer, matrix: *const PangoMatrix);

    //=========================================================================
    // Other functions
    //=========================================================================
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_allow_breaks_new(allow_breaks: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_background_alpha_new(alpha: u16) -> *mut PangoAttribute;
    pub fn pango_attr_background_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_baseline_shift_new(shift: c_int) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_break(
        text: *const c_char,
        length: c_int,
        attr_list: *mut PangoAttrList,
        offset: c_int,
        attrs: *mut PangoLogAttr,
        attrs_len: c_int,
    );
    pub fn pango_attr_fallback_new(enable_fallback: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_family_new(family: *const c_char) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_font_scale_new(scale: PangoFontScale) -> *mut PangoAttribute;
    pub fn pango_attr_foreground_alpha_new(alpha: u16) -> *mut PangoAttribute;
    pub fn pango_attr_foreground_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_gravity_hint_new(hint: PangoGravityHint) -> *mut PangoAttribute;
    pub fn pango_attr_gravity_new(gravity: PangoGravity) -> *mut PangoAttribute;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_insert_hyphens_new(insert_hyphens: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_letter_spacing_new(letter_spacing: c_int) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_line_height_new(factor: c_double) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_line_height_new_absolute(height: c_int) -> *mut PangoAttribute;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_attr_overline_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    #[cfg(feature = "v1_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
    pub fn pango_attr_overline_new(overline: PangoOverline) -> *mut PangoAttribute;
    pub fn pango_attr_rise_new(rise: c_int) -> *mut PangoAttribute;
    pub fn pango_attr_scale_new(scale_factor: c_double) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_sentence_new() -> *mut PangoAttribute;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_attr_show_new(flags: PangoShowFlags) -> *mut PangoAttribute;
    pub fn pango_attr_stretch_new(stretch: PangoStretch) -> *mut PangoAttribute;
    pub fn pango_attr_strikethrough_color_new(
        red: u16,
        green: u16,
        blue: u16,
    ) -> *mut PangoAttribute;
    pub fn pango_attr_strikethrough_new(strikethrough: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_style_new(style: PangoStyle) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_text_transform_new(transform: PangoTextTransform) -> *mut PangoAttribute;
    pub fn pango_attr_underline_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_underline_new(underline: PangoUnderline) -> *mut PangoAttribute;
    pub fn pango_attr_variant_new(variant: PangoVariant) -> *mut PangoAttribute;
    pub fn pango_attr_weight_new(weight: PangoWeight) -> *mut PangoAttribute;
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_attr_word_new() -> *mut PangoAttribute;
    pub fn pango_break(
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        attrs: *mut PangoLogAttr,
        attrs_len: c_int,
    );
    pub fn pango_default_break(
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        attrs: *mut PangoLogAttr,
        attrs_len: c_int,
    );
    pub fn pango_extents_to_pixels(inclusive: *mut PangoRectangle, nearest: *mut PangoRectangle);
    pub fn pango_find_base_dir(text: *const c_char, length: c_int) -> PangoDirection;
    pub fn pango_find_paragraph_boundary(
        text: *const c_char,
        length: c_int,
        paragraph_delimiter_index: *mut c_int,
        next_paragraph_start: *mut c_int,
    );
    pub fn pango_get_log_attrs(
        text: *const c_char,
        length: c_int,
        level: c_int,
        language: *mut PangoLanguage,
        attrs: *mut PangoLogAttr,
        attrs_len: c_int,
    );
    pub fn pango_get_mirror_char(ch: u32, mirrored_ch: *mut u32) -> gboolean;
    pub fn pango_is_zero_width(ch: u32) -> gboolean;
    pub fn pango_itemize(
        context: *mut PangoContext,
        text: *const c_char,
        start_index: c_int,
        length: c_int,
        attrs: *mut PangoAttrList,
        cached_iter: *mut PangoAttrIterator,
    ) -> *mut glib::GList;
    pub fn pango_itemize_with_base_dir(
        context: *mut PangoContext,
        base_dir: PangoDirection,
        text: *const c_char,
        start_index: c_int,
        length: c_int,
        attrs: *mut PangoAttrList,
        cached_iter: *mut PangoAttrIterator,
    ) -> *mut glib::GList;
    pub fn pango_log2vis_get_embedding_levels(
        text: *const c_char,
        length: c_int,
        pbase_dir: *mut PangoDirection,
    ) -> *mut u8;
    pub fn pango_markup_parser_finish(
        context: *mut glib::GMarkupParseContext,
        attr_list: *mut *mut PangoAttrList,
        text: *mut *mut c_char,
        accel_char: *mut u32,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pango_markup_parser_new(accel_marker: u32) -> *mut glib::GMarkupParseContext;
    pub fn pango_parse_enum(
        type_: GType,
        str: *const c_char,
        value: *mut c_int,
        warn: gboolean,
        possible_values: *mut *mut c_char,
    ) -> gboolean;
    pub fn pango_parse_markup(
        markup_text: *const c_char,
        length: c_int,
        accel_marker: u32,
        attr_list: *mut *mut PangoAttrList,
        text: *mut *mut c_char,
        accel_char: *mut u32,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn pango_parse_stretch(
        str: *const c_char,
        stretch: *mut PangoStretch,
        warn: gboolean,
    ) -> gboolean;
    pub fn pango_parse_style(
        str: *const c_char,
        style: *mut PangoStyle,
        warn: gboolean,
    ) -> gboolean;
    pub fn pango_parse_variant(
        str: *const c_char,
        variant: *mut PangoVariant,
        warn: gboolean,
    ) -> gboolean;
    pub fn pango_parse_weight(
        str: *const c_char,
        weight: *mut PangoWeight,
        warn: gboolean,
    ) -> gboolean;
    pub fn pango_quantize_line_geometry(thickness: *mut c_int, position: *mut c_int);
    pub fn pango_read_line(stream: *mut FILE, str: *mut glib::GString) -> c_int;
    pub fn pango_reorder_items(items: *mut glib::GList) -> *mut glib::GList;
    pub fn pango_scan_int(pos: *mut *const c_char, out: *mut c_int) -> gboolean;
    pub fn pango_scan_string(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
    pub fn pango_scan_word(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
    pub fn pango_shape(
        text: *const c_char,
        length: c_int,
        analysis: *const PangoAnalysis,
        glyphs: *mut PangoGlyphString,
    );
    pub fn pango_shape_full(
        item_text: *const c_char,
        item_length: c_int,
        paragraph_text: *const c_char,
        paragraph_length: c_int,
        analysis: *const PangoAnalysis,
        glyphs: *mut PangoGlyphString,
    );
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    pub fn pango_shape_item(
        item: *mut PangoItem,
        paragraph_text: *const c_char,
        paragraph_length: c_int,
        log_attrs: *mut PangoLogAttr,
        glyphs: *mut PangoGlyphString,
        flags: PangoShapeFlags,
    );
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_shape_with_flags(
        item_text: *const c_char,
        item_length: c_int,
        paragraph_text: *const c_char,
        paragraph_length: c_int,
        analysis: *const PangoAnalysis,
        glyphs: *mut PangoGlyphString,
        flags: PangoShapeFlags,
    );
    pub fn pango_skip_space(pos: *mut *const c_char) -> gboolean;
    pub fn pango_split_file_list(str: *const c_char) -> *mut *mut c_char;
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    pub fn pango_tailor_break(
        text: *const c_char,
        length: c_int,
        analysis: *mut PangoAnalysis,
        offset: c_int,
        attrs: *mut PangoLogAttr,
        attrs_len: c_int,
    );
    pub fn pango_trim_string(str: *const c_char) -> *mut c_char;
    pub fn pango_unichar_direction(ch: u32) -> PangoDirection;
    pub fn pango_units_from_double(d: c_double) -> c_int;
    pub fn pango_units_to_double(i: c_int) -> c_double;
    pub fn pango_version() -> c_int;
    pub fn pango_version_check(
        required_major: c_int,
        required_minor: c_int,
        required_micro: c_int,
    ) -> *const c_char;
    pub fn pango_version_string() -> *const c_char;

}