pango_sys/
lib.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7    clippy::approx_constant,
8    clippy::type_complexity,
9    clippy::unreadable_literal,
10    clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14use glib_sys as glib;
15use gobject_sys as gobject;
16
17#[cfg(unix)]
18#[allow(unused_imports)]
19use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
20#[allow(unused_imports)]
21use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
22#[allow(unused_imports)]
23use std::ffi::{
24    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
25};
26
27#[allow(unused_imports)]
28use glib::{gboolean, gconstpointer, gpointer, GType};
29
30// Aliases
31pub type PangoGlyph = u32;
32pub type PangoGlyphUnit = i32;
33pub type PangoLayoutRun = PangoGlyphItem;
34
35// Enums
36pub type PangoAlignment = c_int;
37pub const PANGO_ALIGN_LEFT: PangoAlignment = 0;
38pub const PANGO_ALIGN_CENTER: PangoAlignment = 1;
39pub const PANGO_ALIGN_RIGHT: PangoAlignment = 2;
40
41pub type PangoAttrType = c_int;
42pub const PANGO_ATTR_INVALID: PangoAttrType = 0;
43pub const PANGO_ATTR_LANGUAGE: PangoAttrType = 1;
44pub const PANGO_ATTR_FAMILY: PangoAttrType = 2;
45pub const PANGO_ATTR_STYLE: PangoAttrType = 3;
46pub const PANGO_ATTR_WEIGHT: PangoAttrType = 4;
47pub const PANGO_ATTR_VARIANT: PangoAttrType = 5;
48pub const PANGO_ATTR_STRETCH: PangoAttrType = 6;
49pub const PANGO_ATTR_SIZE: PangoAttrType = 7;
50pub const PANGO_ATTR_FONT_DESC: PangoAttrType = 8;
51pub const PANGO_ATTR_FOREGROUND: PangoAttrType = 9;
52pub const PANGO_ATTR_BACKGROUND: PangoAttrType = 10;
53pub const PANGO_ATTR_UNDERLINE: PangoAttrType = 11;
54pub const PANGO_ATTR_STRIKETHROUGH: PangoAttrType = 12;
55pub const PANGO_ATTR_RISE: PangoAttrType = 13;
56pub const PANGO_ATTR_SHAPE: PangoAttrType = 14;
57pub const PANGO_ATTR_SCALE: PangoAttrType = 15;
58pub const PANGO_ATTR_FALLBACK: PangoAttrType = 16;
59pub const PANGO_ATTR_LETTER_SPACING: PangoAttrType = 17;
60pub const PANGO_ATTR_UNDERLINE_COLOR: PangoAttrType = 18;
61pub const PANGO_ATTR_STRIKETHROUGH_COLOR: PangoAttrType = 19;
62pub const PANGO_ATTR_ABSOLUTE_SIZE: PangoAttrType = 20;
63pub const PANGO_ATTR_GRAVITY: PangoAttrType = 21;
64pub const PANGO_ATTR_GRAVITY_HINT: PangoAttrType = 22;
65pub const PANGO_ATTR_FONT_FEATURES: PangoAttrType = 23;
66pub const PANGO_ATTR_FOREGROUND_ALPHA: PangoAttrType = 24;
67pub const PANGO_ATTR_BACKGROUND_ALPHA: PangoAttrType = 25;
68pub const PANGO_ATTR_ALLOW_BREAKS: PangoAttrType = 26;
69pub const PANGO_ATTR_SHOW: PangoAttrType = 27;
70pub const PANGO_ATTR_INSERT_HYPHENS: PangoAttrType = 28;
71pub const PANGO_ATTR_OVERLINE: PangoAttrType = 29;
72pub const PANGO_ATTR_OVERLINE_COLOR: PangoAttrType = 30;
73pub const PANGO_ATTR_LINE_HEIGHT: PangoAttrType = 31;
74pub const PANGO_ATTR_ABSOLUTE_LINE_HEIGHT: PangoAttrType = 32;
75pub const PANGO_ATTR_TEXT_TRANSFORM: PangoAttrType = 33;
76pub const PANGO_ATTR_WORD: PangoAttrType = 34;
77pub const PANGO_ATTR_SENTENCE: PangoAttrType = 35;
78pub const PANGO_ATTR_BASELINE_SHIFT: PangoAttrType = 36;
79pub const PANGO_ATTR_FONT_SCALE: PangoAttrType = 37;
80
81pub type PangoBaselineShift = c_int;
82pub const PANGO_BASELINE_SHIFT_NONE: PangoBaselineShift = 0;
83pub const PANGO_BASELINE_SHIFT_SUPERSCRIPT: PangoBaselineShift = 1;
84pub const PANGO_BASELINE_SHIFT_SUBSCRIPT: PangoBaselineShift = 2;
85
86pub type PangoBidiType = c_int;
87pub const PANGO_BIDI_TYPE_L: PangoBidiType = 0;
88pub const PANGO_BIDI_TYPE_LRE: PangoBidiType = 1;
89pub const PANGO_BIDI_TYPE_LRO: PangoBidiType = 2;
90pub const PANGO_BIDI_TYPE_R: PangoBidiType = 3;
91pub const PANGO_BIDI_TYPE_AL: PangoBidiType = 4;
92pub const PANGO_BIDI_TYPE_RLE: PangoBidiType = 5;
93pub const PANGO_BIDI_TYPE_RLO: PangoBidiType = 6;
94pub const PANGO_BIDI_TYPE_PDF: PangoBidiType = 7;
95pub const PANGO_BIDI_TYPE_EN: PangoBidiType = 8;
96pub const PANGO_BIDI_TYPE_ES: PangoBidiType = 9;
97pub const PANGO_BIDI_TYPE_ET: PangoBidiType = 10;
98pub const PANGO_BIDI_TYPE_AN: PangoBidiType = 11;
99pub const PANGO_BIDI_TYPE_CS: PangoBidiType = 12;
100pub const PANGO_BIDI_TYPE_NSM: PangoBidiType = 13;
101pub const PANGO_BIDI_TYPE_BN: PangoBidiType = 14;
102pub const PANGO_BIDI_TYPE_B: PangoBidiType = 15;
103pub const PANGO_BIDI_TYPE_S: PangoBidiType = 16;
104pub const PANGO_BIDI_TYPE_WS: PangoBidiType = 17;
105pub const PANGO_BIDI_TYPE_ON: PangoBidiType = 18;
106pub const PANGO_BIDI_TYPE_LRI: PangoBidiType = 19;
107pub const PANGO_BIDI_TYPE_RLI: PangoBidiType = 20;
108pub const PANGO_BIDI_TYPE_FSI: PangoBidiType = 21;
109pub const PANGO_BIDI_TYPE_PDI: PangoBidiType = 22;
110
111pub type PangoCoverageLevel = c_int;
112pub const PANGO_COVERAGE_NONE: PangoCoverageLevel = 0;
113pub const PANGO_COVERAGE_FALLBACK: PangoCoverageLevel = 1;
114pub const PANGO_COVERAGE_APPROXIMATE: PangoCoverageLevel = 2;
115pub const PANGO_COVERAGE_EXACT: PangoCoverageLevel = 3;
116
117pub type PangoDirection = c_int;
118pub const PANGO_DIRECTION_LTR: PangoDirection = 0;
119pub const PANGO_DIRECTION_RTL: PangoDirection = 1;
120pub const PANGO_DIRECTION_TTB_LTR: PangoDirection = 2;
121pub const PANGO_DIRECTION_TTB_RTL: PangoDirection = 3;
122pub const PANGO_DIRECTION_WEAK_LTR: PangoDirection = 4;
123pub const PANGO_DIRECTION_WEAK_RTL: PangoDirection = 5;
124pub const PANGO_DIRECTION_NEUTRAL: PangoDirection = 6;
125
126pub type PangoEllipsizeMode = c_int;
127pub const PANGO_ELLIPSIZE_NONE: PangoEllipsizeMode = 0;
128pub const PANGO_ELLIPSIZE_START: PangoEllipsizeMode = 1;
129pub const PANGO_ELLIPSIZE_MIDDLE: PangoEllipsizeMode = 2;
130pub const PANGO_ELLIPSIZE_END: PangoEllipsizeMode = 3;
131
132pub type PangoFontColor = c_int;
133pub const PANGO_FONT_COLOR_FORBIDDEN: PangoFontColor = 0;
134pub const PANGO_FONT_COLOR_REQUIRED: PangoFontColor = 1;
135pub const PANGO_FONT_COLOR_DONT_CARE: PangoFontColor = 2;
136
137pub type PangoFontScale = c_int;
138pub const PANGO_FONT_SCALE_NONE: PangoFontScale = 0;
139pub const PANGO_FONT_SCALE_SUPERSCRIPT: PangoFontScale = 1;
140pub const PANGO_FONT_SCALE_SUBSCRIPT: PangoFontScale = 2;
141pub const PANGO_FONT_SCALE_SMALL_CAPS: PangoFontScale = 3;
142
143pub type PangoGravity = c_int;
144pub const PANGO_GRAVITY_SOUTH: PangoGravity = 0;
145pub const PANGO_GRAVITY_EAST: PangoGravity = 1;
146pub const PANGO_GRAVITY_NORTH: PangoGravity = 2;
147pub const PANGO_GRAVITY_WEST: PangoGravity = 3;
148pub const PANGO_GRAVITY_AUTO: PangoGravity = 4;
149
150pub type PangoGravityHint = c_int;
151pub const PANGO_GRAVITY_HINT_NATURAL: PangoGravityHint = 0;
152pub const PANGO_GRAVITY_HINT_STRONG: PangoGravityHint = 1;
153pub const PANGO_GRAVITY_HINT_LINE: PangoGravityHint = 2;
154
155pub type PangoLayoutDeserializeError = c_int;
156pub const PANGO_LAYOUT_DESERIALIZE_INVALID: PangoLayoutDeserializeError = 0;
157pub const PANGO_LAYOUT_DESERIALIZE_INVALID_VALUE: PangoLayoutDeserializeError = 1;
158pub const PANGO_LAYOUT_DESERIALIZE_MISSING_VALUE: PangoLayoutDeserializeError = 2;
159
160pub type PangoOverline = c_int;
161pub const PANGO_OVERLINE_NONE: PangoOverline = 0;
162pub const PANGO_OVERLINE_SINGLE: PangoOverline = 1;
163
164pub type PangoRenderPart = c_int;
165pub const PANGO_RENDER_PART_FOREGROUND: PangoRenderPart = 0;
166pub const PANGO_RENDER_PART_BACKGROUND: PangoRenderPart = 1;
167pub const PANGO_RENDER_PART_UNDERLINE: PangoRenderPart = 2;
168pub const PANGO_RENDER_PART_STRIKETHROUGH: PangoRenderPart = 3;
169pub const PANGO_RENDER_PART_OVERLINE: PangoRenderPart = 4;
170
171pub type PangoScript = c_int;
172pub const PANGO_SCRIPT_INVALID_CODE: PangoScript = -1;
173pub const PANGO_SCRIPT_COMMON: PangoScript = 0;
174pub const PANGO_SCRIPT_INHERITED: PangoScript = 1;
175pub const PANGO_SCRIPT_ARABIC: PangoScript = 2;
176pub const PANGO_SCRIPT_ARMENIAN: PangoScript = 3;
177pub const PANGO_SCRIPT_BENGALI: PangoScript = 4;
178pub const PANGO_SCRIPT_BOPOMOFO: PangoScript = 5;
179pub const PANGO_SCRIPT_CHEROKEE: PangoScript = 6;
180pub const PANGO_SCRIPT_COPTIC: PangoScript = 7;
181pub const PANGO_SCRIPT_CYRILLIC: PangoScript = 8;
182pub const PANGO_SCRIPT_DESERET: PangoScript = 9;
183pub const PANGO_SCRIPT_DEVANAGARI: PangoScript = 10;
184pub const PANGO_SCRIPT_ETHIOPIC: PangoScript = 11;
185pub const PANGO_SCRIPT_GEORGIAN: PangoScript = 12;
186pub const PANGO_SCRIPT_GOTHIC: PangoScript = 13;
187pub const PANGO_SCRIPT_GREEK: PangoScript = 14;
188pub const PANGO_SCRIPT_GUJARATI: PangoScript = 15;
189pub const PANGO_SCRIPT_GURMUKHI: PangoScript = 16;
190pub const PANGO_SCRIPT_HAN: PangoScript = 17;
191pub const PANGO_SCRIPT_HANGUL: PangoScript = 18;
192pub const PANGO_SCRIPT_HEBREW: PangoScript = 19;
193pub const PANGO_SCRIPT_HIRAGANA: PangoScript = 20;
194pub const PANGO_SCRIPT_KANNADA: PangoScript = 21;
195pub const PANGO_SCRIPT_KATAKANA: PangoScript = 22;
196pub const PANGO_SCRIPT_KHMER: PangoScript = 23;
197pub const PANGO_SCRIPT_LAO: PangoScript = 24;
198pub const PANGO_SCRIPT_LATIN: PangoScript = 25;
199pub const PANGO_SCRIPT_MALAYALAM: PangoScript = 26;
200pub const PANGO_SCRIPT_MONGOLIAN: PangoScript = 27;
201pub const PANGO_SCRIPT_MYANMAR: PangoScript = 28;
202pub const PANGO_SCRIPT_OGHAM: PangoScript = 29;
203pub const PANGO_SCRIPT_OLD_ITALIC: PangoScript = 30;
204pub const PANGO_SCRIPT_ORIYA: PangoScript = 31;
205pub const PANGO_SCRIPT_RUNIC: PangoScript = 32;
206pub const PANGO_SCRIPT_SINHALA: PangoScript = 33;
207pub const PANGO_SCRIPT_SYRIAC: PangoScript = 34;
208pub const PANGO_SCRIPT_TAMIL: PangoScript = 35;
209pub const PANGO_SCRIPT_TELUGU: PangoScript = 36;
210pub const PANGO_SCRIPT_THAANA: PangoScript = 37;
211pub const PANGO_SCRIPT_THAI: PangoScript = 38;
212pub const PANGO_SCRIPT_TIBETAN: PangoScript = 39;
213pub const PANGO_SCRIPT_CANADIAN_ABORIGINAL: PangoScript = 40;
214pub const PANGO_SCRIPT_YI: PangoScript = 41;
215pub const PANGO_SCRIPT_TAGALOG: PangoScript = 42;
216pub const PANGO_SCRIPT_HANUNOO: PangoScript = 43;
217pub const PANGO_SCRIPT_BUHID: PangoScript = 44;
218pub const PANGO_SCRIPT_TAGBANWA: PangoScript = 45;
219pub const PANGO_SCRIPT_BRAILLE: PangoScript = 46;
220pub const PANGO_SCRIPT_CYPRIOT: PangoScript = 47;
221pub const PANGO_SCRIPT_LIMBU: PangoScript = 48;
222pub const PANGO_SCRIPT_OSMANYA: PangoScript = 49;
223pub const PANGO_SCRIPT_SHAVIAN: PangoScript = 50;
224pub const PANGO_SCRIPT_LINEAR_B: PangoScript = 51;
225pub const PANGO_SCRIPT_TAI_LE: PangoScript = 52;
226pub const PANGO_SCRIPT_UGARITIC: PangoScript = 53;
227pub const PANGO_SCRIPT_NEW_TAI_LUE: PangoScript = 54;
228pub const PANGO_SCRIPT_BUGINESE: PangoScript = 55;
229pub const PANGO_SCRIPT_GLAGOLITIC: PangoScript = 56;
230pub const PANGO_SCRIPT_TIFINAGH: PangoScript = 57;
231pub const PANGO_SCRIPT_SYLOTI_NAGRI: PangoScript = 58;
232pub const PANGO_SCRIPT_OLD_PERSIAN: PangoScript = 59;
233pub const PANGO_SCRIPT_KHAROSHTHI: PangoScript = 60;
234pub const PANGO_SCRIPT_UNKNOWN: PangoScript = 61;
235pub const PANGO_SCRIPT_BALINESE: PangoScript = 62;
236pub const PANGO_SCRIPT_CUNEIFORM: PangoScript = 63;
237pub const PANGO_SCRIPT_PHOENICIAN: PangoScript = 64;
238pub const PANGO_SCRIPT_PHAGS_PA: PangoScript = 65;
239pub const PANGO_SCRIPT_NKO: PangoScript = 66;
240pub const PANGO_SCRIPT_KAYAH_LI: PangoScript = 67;
241pub const PANGO_SCRIPT_LEPCHA: PangoScript = 68;
242pub const PANGO_SCRIPT_REJANG: PangoScript = 69;
243pub const PANGO_SCRIPT_SUNDANESE: PangoScript = 70;
244pub const PANGO_SCRIPT_SAURASHTRA: PangoScript = 71;
245pub const PANGO_SCRIPT_CHAM: PangoScript = 72;
246pub const PANGO_SCRIPT_OL_CHIKI: PangoScript = 73;
247pub const PANGO_SCRIPT_VAI: PangoScript = 74;
248pub const PANGO_SCRIPT_CARIAN: PangoScript = 75;
249pub const PANGO_SCRIPT_LYCIAN: PangoScript = 76;
250pub const PANGO_SCRIPT_LYDIAN: PangoScript = 77;
251pub const PANGO_SCRIPT_BATAK: PangoScript = 78;
252pub const PANGO_SCRIPT_BRAHMI: PangoScript = 79;
253pub const PANGO_SCRIPT_MANDAIC: PangoScript = 80;
254pub const PANGO_SCRIPT_CHAKMA: PangoScript = 81;
255pub const PANGO_SCRIPT_MEROITIC_CURSIVE: PangoScript = 82;
256pub const PANGO_SCRIPT_MEROITIC_HIEROGLYPHS: PangoScript = 83;
257pub const PANGO_SCRIPT_MIAO: PangoScript = 84;
258pub const PANGO_SCRIPT_SHARADA: PangoScript = 85;
259pub const PANGO_SCRIPT_SORA_SOMPENG: PangoScript = 86;
260pub const PANGO_SCRIPT_TAKRI: PangoScript = 87;
261pub const PANGO_SCRIPT_BASSA_VAH: PangoScript = 88;
262pub const PANGO_SCRIPT_CAUCASIAN_ALBANIAN: PangoScript = 89;
263pub const PANGO_SCRIPT_DUPLOYAN: PangoScript = 90;
264pub const PANGO_SCRIPT_ELBASAN: PangoScript = 91;
265pub const PANGO_SCRIPT_GRANTHA: PangoScript = 92;
266pub const PANGO_SCRIPT_KHOJKI: PangoScript = 93;
267pub const PANGO_SCRIPT_KHUDAWADI: PangoScript = 94;
268pub const PANGO_SCRIPT_LINEAR_A: PangoScript = 95;
269pub const PANGO_SCRIPT_MAHAJANI: PangoScript = 96;
270pub const PANGO_SCRIPT_MANICHAEAN: PangoScript = 97;
271pub const PANGO_SCRIPT_MENDE_KIKAKUI: PangoScript = 98;
272pub const PANGO_SCRIPT_MODI: PangoScript = 99;
273pub const PANGO_SCRIPT_MRO: PangoScript = 100;
274pub const PANGO_SCRIPT_NABATAEAN: PangoScript = 101;
275pub const PANGO_SCRIPT_OLD_NORTH_ARABIAN: PangoScript = 102;
276pub const PANGO_SCRIPT_OLD_PERMIC: PangoScript = 103;
277pub const PANGO_SCRIPT_PAHAWH_HMONG: PangoScript = 104;
278pub const PANGO_SCRIPT_PALMYRENE: PangoScript = 105;
279pub const PANGO_SCRIPT_PAU_CIN_HAU: PangoScript = 106;
280pub const PANGO_SCRIPT_PSALTER_PAHLAVI: PangoScript = 107;
281pub const PANGO_SCRIPT_SIDDHAM: PangoScript = 108;
282pub const PANGO_SCRIPT_TIRHUTA: PangoScript = 109;
283pub const PANGO_SCRIPT_WARANG_CITI: PangoScript = 110;
284pub const PANGO_SCRIPT_AHOM: PangoScript = 111;
285pub const PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS: PangoScript = 112;
286pub const PANGO_SCRIPT_HATRAN: PangoScript = 113;
287pub const PANGO_SCRIPT_MULTANI: PangoScript = 114;
288pub const PANGO_SCRIPT_OLD_HUNGARIAN: PangoScript = 115;
289pub const PANGO_SCRIPT_SIGNWRITING: PangoScript = 116;
290
291pub type PangoStretch = c_int;
292pub const PANGO_STRETCH_ULTRA_CONDENSED: PangoStretch = 0;
293pub const PANGO_STRETCH_EXTRA_CONDENSED: PangoStretch = 1;
294pub const PANGO_STRETCH_CONDENSED: PangoStretch = 2;
295pub const PANGO_STRETCH_SEMI_CONDENSED: PangoStretch = 3;
296pub const PANGO_STRETCH_NORMAL: PangoStretch = 4;
297pub const PANGO_STRETCH_SEMI_EXPANDED: PangoStretch = 5;
298pub const PANGO_STRETCH_EXPANDED: PangoStretch = 6;
299pub const PANGO_STRETCH_EXTRA_EXPANDED: PangoStretch = 7;
300pub const PANGO_STRETCH_ULTRA_EXPANDED: PangoStretch = 8;
301
302pub type PangoStyle = c_int;
303pub const PANGO_STYLE_NORMAL: PangoStyle = 0;
304pub const PANGO_STYLE_OBLIQUE: PangoStyle = 1;
305pub const PANGO_STYLE_ITALIC: PangoStyle = 2;
306
307pub type PangoTabAlign = c_int;
308pub const PANGO_TAB_LEFT: PangoTabAlign = 0;
309pub const PANGO_TAB_RIGHT: PangoTabAlign = 1;
310pub const PANGO_TAB_CENTER: PangoTabAlign = 2;
311pub const PANGO_TAB_DECIMAL: PangoTabAlign = 3;
312
313pub type PangoTextTransform = c_int;
314pub const PANGO_TEXT_TRANSFORM_NONE: PangoTextTransform = 0;
315pub const PANGO_TEXT_TRANSFORM_LOWERCASE: PangoTextTransform = 1;
316pub const PANGO_TEXT_TRANSFORM_UPPERCASE: PangoTextTransform = 2;
317pub const PANGO_TEXT_TRANSFORM_CAPITALIZE: PangoTextTransform = 3;
318
319pub type PangoUnderline = c_int;
320pub const PANGO_UNDERLINE_NONE: PangoUnderline = 0;
321pub const PANGO_UNDERLINE_SINGLE: PangoUnderline = 1;
322pub const PANGO_UNDERLINE_DOUBLE: PangoUnderline = 2;
323pub const PANGO_UNDERLINE_LOW: PangoUnderline = 3;
324pub const PANGO_UNDERLINE_ERROR: PangoUnderline = 4;
325pub const PANGO_UNDERLINE_SINGLE_LINE: PangoUnderline = 5;
326pub const PANGO_UNDERLINE_DOUBLE_LINE: PangoUnderline = 6;
327pub const PANGO_UNDERLINE_ERROR_LINE: PangoUnderline = 7;
328
329pub type PangoVariant = c_int;
330pub const PANGO_VARIANT_NORMAL: PangoVariant = 0;
331pub const PANGO_VARIANT_SMALL_CAPS: PangoVariant = 1;
332pub const PANGO_VARIANT_ALL_SMALL_CAPS: PangoVariant = 2;
333pub const PANGO_VARIANT_PETITE_CAPS: PangoVariant = 3;
334pub const PANGO_VARIANT_ALL_PETITE_CAPS: PangoVariant = 4;
335pub const PANGO_VARIANT_UNICASE: PangoVariant = 5;
336pub const PANGO_VARIANT_TITLE_CAPS: PangoVariant = 6;
337
338pub type PangoWeight = c_int;
339pub const PANGO_WEIGHT_THIN: PangoWeight = 100;
340pub const PANGO_WEIGHT_ULTRALIGHT: PangoWeight = 200;
341pub const PANGO_WEIGHT_LIGHT: PangoWeight = 300;
342pub const PANGO_WEIGHT_SEMILIGHT: PangoWeight = 350;
343pub const PANGO_WEIGHT_BOOK: PangoWeight = 380;
344pub const PANGO_WEIGHT_NORMAL: PangoWeight = 400;
345pub const PANGO_WEIGHT_MEDIUM: PangoWeight = 500;
346pub const PANGO_WEIGHT_SEMIBOLD: PangoWeight = 600;
347pub const PANGO_WEIGHT_BOLD: PangoWeight = 700;
348pub const PANGO_WEIGHT_ULTRABOLD: PangoWeight = 800;
349pub const PANGO_WEIGHT_HEAVY: PangoWeight = 900;
350pub const PANGO_WEIGHT_ULTRAHEAVY: PangoWeight = 1000;
351
352pub type PangoWrapMode = c_int;
353pub const PANGO_WRAP_WORD: PangoWrapMode = 0;
354pub const PANGO_WRAP_CHAR: PangoWrapMode = 1;
355pub const PANGO_WRAP_WORD_CHAR: PangoWrapMode = 2;
356#[cfg(feature = "v1_56")]
357#[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
358pub const PANGO_WRAP_NONE: PangoWrapMode = 3;
359
360// Constants
361pub const PANGO_ANALYSIS_FLAG_CENTERED_BASELINE: c_int = 1;
362pub const PANGO_ANALYSIS_FLAG_IS_ELLIPSIS: c_int = 2;
363pub const PANGO_ANALYSIS_FLAG_NEED_HYPHEN: c_int = 4;
364pub const PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING: c_uint = 0;
365pub const PANGO_ATTR_INDEX_TO_TEXT_END: c_uint = 4294967295;
366pub const PANGO_GLYPH_EMPTY: PangoGlyph = 268435455;
367pub const PANGO_GLYPH_INVALID_INPUT: PangoGlyph = 4294967295;
368pub const PANGO_GLYPH_UNKNOWN_FLAG: PangoGlyph = 268435456;
369pub const PANGO_SCALE: c_int = 1024;
370
371// Flags
372pub type PangoFontMask = c_uint;
373pub const PANGO_FONT_MASK_FAMILY: PangoFontMask = 1;
374pub const PANGO_FONT_MASK_STYLE: PangoFontMask = 2;
375pub const PANGO_FONT_MASK_VARIANT: PangoFontMask = 4;
376pub const PANGO_FONT_MASK_WEIGHT: PangoFontMask = 8;
377pub const PANGO_FONT_MASK_STRETCH: PangoFontMask = 16;
378pub const PANGO_FONT_MASK_SIZE: PangoFontMask = 32;
379pub const PANGO_FONT_MASK_GRAVITY: PangoFontMask = 64;
380#[cfg(feature = "v1_42")]
381#[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
382pub const PANGO_FONT_MASK_VARIATIONS: PangoFontMask = 128;
383#[cfg(feature = "v1_56")]
384#[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
385pub const PANGO_FONT_MASK_FEATURES: PangoFontMask = 256;
386#[cfg(feature = "v1_57")]
387#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
388pub const PANGO_FONT_MASK_COLOR: PangoFontMask = 512;
389
390pub type PangoLayoutDeserializeFlags = c_uint;
391pub const PANGO_LAYOUT_DESERIALIZE_DEFAULT: PangoLayoutDeserializeFlags = 0;
392pub const PANGO_LAYOUT_DESERIALIZE_CONTEXT: PangoLayoutDeserializeFlags = 1;
393
394pub type PangoLayoutSerializeFlags = c_uint;
395pub const PANGO_LAYOUT_SERIALIZE_DEFAULT: PangoLayoutSerializeFlags = 0;
396pub const PANGO_LAYOUT_SERIALIZE_CONTEXT: PangoLayoutSerializeFlags = 1;
397pub const PANGO_LAYOUT_SERIALIZE_OUTPUT: PangoLayoutSerializeFlags = 2;
398
399pub type PangoShapeFlags = c_uint;
400pub const PANGO_SHAPE_NONE: PangoShapeFlags = 0;
401pub const PANGO_SHAPE_ROUND_POSITIONS: PangoShapeFlags = 1;
402
403pub type PangoShowFlags = c_uint;
404pub const PANGO_SHOW_NONE: PangoShowFlags = 0;
405pub const PANGO_SHOW_SPACES: PangoShowFlags = 1;
406pub const PANGO_SHOW_LINE_BREAKS: PangoShowFlags = 2;
407pub const PANGO_SHOW_IGNORABLES: PangoShowFlags = 4;
408
409// Callbacks
410pub type PangoAttrDataCopyFunc = Option<unsafe extern "C" fn(gconstpointer) -> gpointer>;
411pub type PangoAttrFilterFunc =
412    Option<unsafe extern "C" fn(*mut PangoAttribute, gpointer) -> gboolean>;
413pub type PangoFontsetForeachFunc =
414    Option<unsafe extern "C" fn(*mut PangoFontset, *mut PangoFont, gpointer) -> gboolean>;
415
416// Records
417#[derive(Copy, Clone)]
418#[repr(C)]
419pub struct PangoAnalysis {
420    pub shape_engine: gpointer,
421    pub lang_engine: gpointer,
422    pub font: *mut PangoFont,
423    pub level: u8,
424    pub gravity: u8,
425    pub flags: u8,
426    pub script: u8,
427    pub language: *mut PangoLanguage,
428    pub extra_attrs: *mut glib::GSList,
429}
430
431impl ::std::fmt::Debug for PangoAnalysis {
432    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
433        f.debug_struct(&format!("PangoAnalysis @ {self:p}"))
434            .field("shape_engine", &self.shape_engine)
435            .field("lang_engine", &self.lang_engine)
436            .field("font", &self.font)
437            .field("level", &self.level)
438            .field("gravity", &self.gravity)
439            .field("flags", &self.flags)
440            .field("script", &self.script)
441            .field("language", &self.language)
442            .field("extra_attrs", &self.extra_attrs)
443            .finish()
444    }
445}
446
447#[derive(Copy, Clone)]
448#[repr(C)]
449pub struct PangoAttrClass {
450    pub type_: PangoAttrType,
451    pub copy: Option<unsafe extern "C" fn(*const PangoAttribute) -> *mut PangoAttribute>,
452    pub destroy: Option<unsafe extern "C" fn(*mut PangoAttribute)>,
453    pub equal:
454        Option<unsafe extern "C" fn(*const PangoAttribute, *const PangoAttribute) -> gboolean>,
455}
456
457impl ::std::fmt::Debug for PangoAttrClass {
458    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
459        f.debug_struct(&format!("PangoAttrClass @ {self:p}"))
460            .field("type_", &self.type_)
461            .field("copy", &self.copy)
462            .field("destroy", &self.destroy)
463            .field("equal", &self.equal)
464            .finish()
465    }
466}
467
468#[derive(Copy, Clone)]
469#[repr(C)]
470pub struct PangoAttrColor {
471    pub attr: PangoAttribute,
472    pub color: PangoColor,
473}
474
475impl ::std::fmt::Debug for PangoAttrColor {
476    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
477        f.debug_struct(&format!("PangoAttrColor @ {self:p}"))
478            .field("attr", &self.attr)
479            .field("color", &self.color)
480            .finish()
481    }
482}
483
484#[derive(Copy, Clone)]
485#[repr(C)]
486pub struct PangoAttrFloat {
487    pub attr: PangoAttribute,
488    pub value: c_double,
489}
490
491impl ::std::fmt::Debug for PangoAttrFloat {
492    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
493        f.debug_struct(&format!("PangoAttrFloat @ {self:p}"))
494            .field("attr", &self.attr)
495            .field("value", &self.value)
496            .finish()
497    }
498}
499
500#[derive(Copy, Clone)]
501#[repr(C)]
502pub struct PangoAttrFontDesc {
503    pub attr: PangoAttribute,
504    pub desc: *mut PangoFontDescription,
505}
506
507impl ::std::fmt::Debug for PangoAttrFontDesc {
508    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
509        f.debug_struct(&format!("PangoAttrFontDesc @ {self:p}"))
510            .field("attr", &self.attr)
511            .field("desc", &self.desc)
512            .finish()
513    }
514}
515
516#[derive(Copy, Clone)]
517#[repr(C)]
518pub struct PangoAttrFontFeatures {
519    pub attr: PangoAttribute,
520    pub features: *mut c_char,
521}
522
523impl ::std::fmt::Debug for PangoAttrFontFeatures {
524    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
525        f.debug_struct(&format!("PangoAttrFontFeatures @ {self:p}"))
526            .field("attr", &self.attr)
527            .field("features", &self.features)
528            .finish()
529    }
530}
531
532#[derive(Copy, Clone)]
533#[repr(C)]
534pub struct PangoAttrInt {
535    pub attr: PangoAttribute,
536    pub value: c_int,
537}
538
539impl ::std::fmt::Debug for PangoAttrInt {
540    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
541        f.debug_struct(&format!("PangoAttrInt @ {self:p}"))
542            .field("attr", &self.attr)
543            .field("value", &self.value)
544            .finish()
545    }
546}
547
548#[repr(C)]
549#[allow(dead_code)]
550pub struct PangoAttrIterator {
551    _data: [u8; 0],
552    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
553}
554
555impl ::std::fmt::Debug for PangoAttrIterator {
556    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
557        f.debug_struct(&format!("PangoAttrIterator @ {self:p}"))
558            .finish()
559    }
560}
561
562#[derive(Copy, Clone)]
563#[repr(C)]
564pub struct PangoAttrLanguage {
565    pub attr: PangoAttribute,
566    pub value: *mut PangoLanguage,
567}
568
569impl ::std::fmt::Debug for PangoAttrLanguage {
570    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
571        f.debug_struct(&format!("PangoAttrLanguage @ {self:p}"))
572            .field("attr", &self.attr)
573            .field("value", &self.value)
574            .finish()
575    }
576}
577
578#[repr(C)]
579#[allow(dead_code)]
580pub struct PangoAttrList {
581    _data: [u8; 0],
582    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
583}
584
585impl ::std::fmt::Debug for PangoAttrList {
586    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
587        f.debug_struct(&format!("PangoAttrList @ {self:p}"))
588            .finish()
589    }
590}
591
592#[derive(Copy, Clone)]
593#[repr(C)]
594pub struct PangoAttrShape {
595    pub attr: PangoAttribute,
596    pub ink_rect: PangoRectangle,
597    pub logical_rect: PangoRectangle,
598    pub data: gpointer,
599    pub copy_func: PangoAttrDataCopyFunc,
600    pub destroy_func: glib::GDestroyNotify,
601}
602
603impl ::std::fmt::Debug for PangoAttrShape {
604    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
605        f.debug_struct(&format!("PangoAttrShape @ {self:p}"))
606            .field("attr", &self.attr)
607            .field("ink_rect", &self.ink_rect)
608            .field("logical_rect", &self.logical_rect)
609            .field("data", &self.data)
610            .field("copy_func", &self.copy_func)
611            .field("destroy_func", &self.destroy_func)
612            .finish()
613    }
614}
615
616#[derive(Copy, Clone)]
617#[repr(C)]
618pub struct PangoAttrSize {
619    pub attr: PangoAttribute,
620    pub size: c_int,
621    pub absolute: c_uint,
622}
623
624impl ::std::fmt::Debug for PangoAttrSize {
625    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
626        f.debug_struct(&format!("PangoAttrSize @ {self:p}"))
627            .field("attr", &self.attr)
628            .field("size", &self.size)
629            .field("absolute", &self.absolute)
630            .finish()
631    }
632}
633
634#[derive(Copy, Clone)]
635#[repr(C)]
636pub struct PangoAttrString {
637    pub attr: PangoAttribute,
638    pub value: *mut c_char,
639}
640
641impl ::std::fmt::Debug for PangoAttrString {
642    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
643        f.debug_struct(&format!("PangoAttrString @ {self:p}"))
644            .field("attr", &self.attr)
645            .field("value", &self.value)
646            .finish()
647    }
648}
649
650#[derive(Copy, Clone)]
651#[repr(C)]
652pub struct PangoAttribute {
653    pub klass: *const PangoAttrClass,
654    pub start_index: c_uint,
655    pub end_index: c_uint,
656}
657
658impl ::std::fmt::Debug for PangoAttribute {
659    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
660        f.debug_struct(&format!("PangoAttribute @ {self:p}"))
661            .field("klass", &self.klass)
662            .field("start_index", &self.start_index)
663            .field("end_index", &self.end_index)
664            .finish()
665    }
666}
667
668#[derive(Copy, Clone)]
669#[repr(C)]
670pub struct PangoColor {
671    pub red: u16,
672    pub green: u16,
673    pub blue: u16,
674}
675
676impl ::std::fmt::Debug for PangoColor {
677    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
678        f.debug_struct(&format!("PangoColor @ {self:p}"))
679            .field("red", &self.red)
680            .field("green", &self.green)
681            .field("blue", &self.blue)
682            .finish()
683    }
684}
685
686#[repr(C)]
687#[allow(dead_code)]
688pub struct _PangoContextClass {
689    _data: [u8; 0],
690    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
691}
692
693pub type PangoContextClass = _PangoContextClass;
694
695#[derive(Copy, Clone)]
696#[repr(C)]
697pub struct PangoFontClass {
698    pub parent_class: gobject::GObjectClass,
699    pub describe: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
700    pub get_coverage:
701        Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoCoverage>,
702    pub get_glyph_extents: Option<
703        unsafe extern "C" fn(*mut PangoFont, PangoGlyph, *mut PangoRectangle, *mut PangoRectangle),
704    >,
705    pub get_metrics:
706        Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoFontMetrics>,
707    pub get_font_map: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontMap>,
708    pub describe_absolute:
709        Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
710    pub get_features:
711        Option<unsafe extern "C" fn(*mut PangoFont, gconstpointer, c_uint, *mut c_uint)>,
712    pub create_hb_font: Option<unsafe extern "C" fn(*mut PangoFont) -> gconstpointer>,
713}
714
715impl ::std::fmt::Debug for PangoFontClass {
716    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
717        f.debug_struct(&format!("PangoFontClass @ {self:p}"))
718            .field("parent_class", &self.parent_class)
719            .field("describe", &self.describe)
720            .field("get_coverage", &self.get_coverage)
721            .field("get_glyph_extents", &self.get_glyph_extents)
722            .field("get_metrics", &self.get_metrics)
723            .field("get_font_map", &self.get_font_map)
724            .field("describe_absolute", &self.describe_absolute)
725            .field("get_features", &self.get_features)
726            .field("create_hb_font", &self.create_hb_font)
727            .finish()
728    }
729}
730
731#[repr(C)]
732#[allow(dead_code)]
733pub struct PangoFontDescription {
734    _data: [u8; 0],
735    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
736}
737
738impl ::std::fmt::Debug for PangoFontDescription {
739    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
740        f.debug_struct(&format!("PangoFontDescription @ {self:p}"))
741            .finish()
742    }
743}
744
745#[derive(Copy, Clone)]
746#[repr(C)]
747pub struct PangoFontFaceClass {
748    pub parent_class: gobject::GObjectClass,
749    pub get_face_name: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *const c_char>,
750    pub describe: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *mut PangoFontDescription>,
751    pub list_sizes: Option<unsafe extern "C" fn(*mut PangoFontFace, *mut *mut c_int, *mut c_int)>,
752    pub is_synthesized: Option<unsafe extern "C" fn(*mut PangoFontFace) -> gboolean>,
753    pub get_family: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *mut PangoFontFamily>,
754    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
755    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
756}
757
758impl ::std::fmt::Debug for PangoFontFaceClass {
759    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
760        f.debug_struct(&format!("PangoFontFaceClass @ {self:p}"))
761            .field("parent_class", &self.parent_class)
762            .field("get_face_name", &self.get_face_name)
763            .field("describe", &self.describe)
764            .field("list_sizes", &self.list_sizes)
765            .field("is_synthesized", &self.is_synthesized)
766            .field("get_family", &self.get_family)
767            .field("_pango_reserved3", &self._pango_reserved3)
768            .field("_pango_reserved4", &self._pango_reserved4)
769            .finish()
770    }
771}
772
773#[derive(Copy, Clone)]
774#[repr(C)]
775pub struct PangoFontFamilyClass {
776    pub parent_class: gobject::GObjectClass,
777    pub list_faces: Option<
778        unsafe extern "C" fn(*mut PangoFontFamily, *mut *mut *mut PangoFontFace, *mut c_int),
779    >,
780    pub get_name: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> *const c_char>,
781    pub is_monospace: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> gboolean>,
782    pub is_variable: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> gboolean>,
783    pub get_face:
784        Option<unsafe extern "C" fn(*mut PangoFontFamily, *const c_char) -> *mut PangoFontFace>,
785    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
786}
787
788impl ::std::fmt::Debug for PangoFontFamilyClass {
789    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
790        f.debug_struct(&format!("PangoFontFamilyClass @ {self:p}"))
791            .field("parent_class", &self.parent_class)
792            .field("list_faces", &self.list_faces)
793            .field("get_name", &self.get_name)
794            .field("is_monospace", &self.is_monospace)
795            .field("is_variable", &self.is_variable)
796            .field("get_face", &self.get_face)
797            .field("_pango_reserved2", &self._pango_reserved2)
798            .finish()
799    }
800}
801
802#[derive(Copy, Clone)]
803#[repr(C)]
804pub struct PangoFontMapClass {
805    pub parent_class: gobject::GObjectClass,
806    pub load_font: Option<
807        unsafe extern "C" fn(
808            *mut PangoFontMap,
809            *mut PangoContext,
810            *const PangoFontDescription,
811        ) -> *mut PangoFont,
812    >,
813    pub list_families:
814        Option<unsafe extern "C" fn(*mut PangoFontMap, *mut *mut *mut PangoFontFamily, *mut c_int)>,
815    pub load_fontset: Option<
816        unsafe extern "C" fn(
817            *mut PangoFontMap,
818            *mut PangoContext,
819            *const PangoFontDescription,
820            *mut PangoLanguage,
821        ) -> *mut PangoFontset,
822    >,
823    pub shape_engine_type: *const c_char,
824    pub get_serial: Option<unsafe extern "C" fn(*mut PangoFontMap) -> c_uint>,
825    pub changed: Option<unsafe extern "C" fn(*mut PangoFontMap)>,
826    pub get_family:
827        Option<unsafe extern "C" fn(*mut PangoFontMap, *const c_char) -> *mut PangoFontFamily>,
828    pub get_face:
829        Option<unsafe extern "C" fn(*mut PangoFontMap, *mut PangoFont) -> *mut PangoFontFace>,
830}
831
832impl ::std::fmt::Debug for PangoFontMapClass {
833    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
834        f.debug_struct(&format!("PangoFontMapClass @ {self:p}"))
835            .field("parent_class", &self.parent_class)
836            .field("load_font", &self.load_font)
837            .field("list_families", &self.list_families)
838            .field("load_fontset", &self.load_fontset)
839            .field("shape_engine_type", &self.shape_engine_type)
840            .field("get_serial", &self.get_serial)
841            .field("changed", &self.changed)
842            .field("get_family", &self.get_family)
843            .field("get_face", &self.get_face)
844            .finish()
845    }
846}
847
848#[derive(Copy, Clone)]
849#[repr(C)]
850pub struct PangoFontMetrics {
851    pub ref_count: c_uint,
852    pub ascent: c_int,
853    pub descent: c_int,
854    pub height: c_int,
855    pub approximate_char_width: c_int,
856    pub approximate_digit_width: c_int,
857    pub underline_position: c_int,
858    pub underline_thickness: c_int,
859    pub strikethrough_position: c_int,
860    pub strikethrough_thickness: c_int,
861}
862
863impl ::std::fmt::Debug for PangoFontMetrics {
864    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
865        f.debug_struct(&format!("PangoFontMetrics @ {self:p}"))
866            .finish()
867    }
868}
869
870#[derive(Copy, Clone)]
871#[repr(C)]
872pub struct PangoFontsetClass {
873    pub parent_class: gobject::GObjectClass,
874    pub get_font: Option<unsafe extern "C" fn(*mut PangoFontset, c_uint) -> *mut PangoFont>,
875    pub get_metrics: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoFontMetrics>,
876    pub get_language: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoLanguage>,
877    pub foreach: Option<unsafe extern "C" fn(*mut PangoFontset, PangoFontsetForeachFunc, gpointer)>,
878    pub _pango_reserved1: Option<unsafe extern "C" fn()>,
879    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
880    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
881    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
882}
883
884impl ::std::fmt::Debug for PangoFontsetClass {
885    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
886        f.debug_struct(&format!("PangoFontsetClass @ {self:p}"))
887            .field("parent_class", &self.parent_class)
888            .field("get_font", &self.get_font)
889            .field("get_metrics", &self.get_metrics)
890            .field("get_language", &self.get_language)
891            .field("foreach", &self.foreach)
892            .field("_pango_reserved1", &self._pango_reserved1)
893            .field("_pango_reserved2", &self._pango_reserved2)
894            .field("_pango_reserved3", &self._pango_reserved3)
895            .field("_pango_reserved4", &self._pango_reserved4)
896            .finish()
897    }
898}
899
900#[repr(C)]
901#[allow(dead_code)]
902pub struct _PangoFontsetSimpleClass {
903    _data: [u8; 0],
904    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
905}
906
907pub type PangoFontsetSimpleClass = _PangoFontsetSimpleClass;
908
909#[derive(Copy, Clone)]
910#[repr(C)]
911pub struct PangoGlyphGeometry {
912    pub width: PangoGlyphUnit,
913    pub x_offset: PangoGlyphUnit,
914    pub y_offset: PangoGlyphUnit,
915}
916
917impl ::std::fmt::Debug for PangoGlyphGeometry {
918    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
919        f.debug_struct(&format!("PangoGlyphGeometry @ {self:p}"))
920            .field("width", &self.width)
921            .field("x_offset", &self.x_offset)
922            .field("y_offset", &self.y_offset)
923            .finish()
924    }
925}
926
927#[derive(Copy, Clone)]
928#[repr(C)]
929pub struct PangoGlyphInfo {
930    pub glyph: PangoGlyph,
931    pub geometry: PangoGlyphGeometry,
932    pub attr: PangoGlyphVisAttr,
933}
934
935impl ::std::fmt::Debug for PangoGlyphInfo {
936    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
937        f.debug_struct(&format!("PangoGlyphInfo @ {self:p}"))
938            .field("glyph", &self.glyph)
939            .field("geometry", &self.geometry)
940            .field("attr", &self.attr)
941            .finish()
942    }
943}
944
945#[derive(Copy, Clone)]
946#[repr(C)]
947pub struct PangoGlyphItem {
948    pub item: *mut PangoItem,
949    pub glyphs: *mut PangoGlyphString,
950    pub y_offset: c_int,
951    pub start_x_offset: c_int,
952    pub end_x_offset: c_int,
953}
954
955impl ::std::fmt::Debug for PangoGlyphItem {
956    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
957        f.debug_struct(&format!("PangoGlyphItem @ {self:p}"))
958            .field("item", &self.item)
959            .field("glyphs", &self.glyphs)
960            .field("y_offset", &self.y_offset)
961            .field("start_x_offset", &self.start_x_offset)
962            .field("end_x_offset", &self.end_x_offset)
963            .finish()
964    }
965}
966
967#[derive(Copy, Clone)]
968#[repr(C)]
969pub struct PangoGlyphItemIter {
970    pub glyph_item: *mut PangoGlyphItem,
971    pub text: *const c_char,
972    pub start_glyph: c_int,
973    pub start_index: c_int,
974    pub start_char: c_int,
975    pub end_glyph: c_int,
976    pub end_index: c_int,
977    pub end_char: c_int,
978}
979
980impl ::std::fmt::Debug for PangoGlyphItemIter {
981    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
982        f.debug_struct(&format!("PangoGlyphItemIter @ {self:p}"))
983            .field("glyph_item", &self.glyph_item)
984            .field("text", &self.text)
985            .field("start_glyph", &self.start_glyph)
986            .field("start_index", &self.start_index)
987            .field("start_char", &self.start_char)
988            .field("end_glyph", &self.end_glyph)
989            .field("end_index", &self.end_index)
990            .field("end_char", &self.end_char)
991            .finish()
992    }
993}
994
995#[derive(Copy, Clone)]
996#[repr(C)]
997pub struct PangoGlyphString {
998    pub num_glyphs: c_int,
999    pub glyphs: *mut PangoGlyphInfo,
1000    pub log_clusters: *mut c_int,
1001    pub space: c_int,
1002}
1003
1004impl ::std::fmt::Debug for PangoGlyphString {
1005    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1006        f.debug_struct(&format!("PangoGlyphString @ {self:p}"))
1007            .field("num_glyphs", &self.num_glyphs)
1008            .field("glyphs", &self.glyphs)
1009            .field("log_clusters", &self.log_clusters)
1010            .finish()
1011    }
1012}
1013
1014#[derive(Copy, Clone)]
1015#[repr(C)]
1016pub struct PangoGlyphVisAttr {
1017    pub is_cluster_start: c_uint,
1018}
1019
1020impl ::std::fmt::Debug for PangoGlyphVisAttr {
1021    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1022        f.debug_struct(&format!("PangoGlyphVisAttr @ {self:p}"))
1023            .field("is_cluster_start", &self.is_cluster_start)
1024            .finish()
1025    }
1026}
1027
1028#[derive(Copy, Clone)]
1029#[repr(C)]
1030pub struct PangoItem {
1031    pub offset: c_int,
1032    pub length: c_int,
1033    pub num_chars: c_int,
1034    pub analysis: PangoAnalysis,
1035}
1036
1037impl ::std::fmt::Debug for PangoItem {
1038    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1039        f.debug_struct(&format!("PangoItem @ {self:p}"))
1040            .field("offset", &self.offset)
1041            .field("length", &self.length)
1042            .field("num_chars", &self.num_chars)
1043            .field("analysis", &self.analysis)
1044            .finish()
1045    }
1046}
1047
1048#[repr(C)]
1049#[allow(dead_code)]
1050pub struct PangoLanguage {
1051    _data: [u8; 0],
1052    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1053}
1054
1055impl ::std::fmt::Debug for PangoLanguage {
1056    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1057        f.debug_struct(&format!("PangoLanguage @ {self:p}"))
1058            .finish()
1059    }
1060}
1061
1062#[repr(C)]
1063#[allow(dead_code)]
1064pub struct _PangoLayoutClass {
1065    _data: [u8; 0],
1066    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1067}
1068
1069pub type PangoLayoutClass = _PangoLayoutClass;
1070
1071#[repr(C)]
1072#[allow(dead_code)]
1073pub struct PangoLayoutIter {
1074    _data: [u8; 0],
1075    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1076}
1077
1078impl ::std::fmt::Debug for PangoLayoutIter {
1079    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1080        f.debug_struct(&format!("PangoLayoutIter @ {self:p}"))
1081            .finish()
1082    }
1083}
1084
1085#[repr(C)]
1086#[allow(dead_code)]
1087pub struct PangoLayoutLine {
1088    pub layout: *mut PangoLayout,
1089    pub start_index: c_int,
1090    pub length: c_int,
1091    pub runs: *mut glib::GSList,
1092    pub is_paragraph_start: c_uint,
1093    _truncated_record_marker: c_void,
1094    // field resolved_dir has incomplete type
1095}
1096
1097impl ::std::fmt::Debug for PangoLayoutLine {
1098    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1099        f.debug_struct(&format!("PangoLayoutLine @ {self:p}"))
1100            .field("layout", &self.layout)
1101            .field("start_index", &self.start_index)
1102            .field("length", &self.length)
1103            .field("runs", &self.runs)
1104            .field("is_paragraph_start", &self.is_paragraph_start)
1105            .finish()
1106    }
1107}
1108
1109#[repr(C)]
1110#[allow(dead_code)]
1111pub struct PangoLogAttr {
1112    pub is_line_break: c_uint,
1113    _truncated_record_marker: c_void,
1114    // field is_mandatory_break has incomplete type
1115}
1116
1117impl ::std::fmt::Debug for PangoLogAttr {
1118    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1119        f.debug_struct(&format!("PangoLogAttr @ {self:p}"))
1120            .field("is_line_break", &self.is_line_break)
1121            .finish()
1122    }
1123}
1124
1125#[derive(Copy, Clone)]
1126#[repr(C)]
1127pub struct PangoMatrix {
1128    pub xx: c_double,
1129    pub xy: c_double,
1130    pub yx: c_double,
1131    pub yy: c_double,
1132    pub x0: c_double,
1133    pub y0: c_double,
1134}
1135
1136impl ::std::fmt::Debug for PangoMatrix {
1137    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1138        f.debug_struct(&format!("PangoMatrix @ {self:p}"))
1139            .field("xx", &self.xx)
1140            .field("xy", &self.xy)
1141            .field("yx", &self.yx)
1142            .field("yy", &self.yy)
1143            .field("x0", &self.x0)
1144            .field("y0", &self.y0)
1145            .finish()
1146    }
1147}
1148
1149#[derive(Copy, Clone)]
1150#[repr(C)]
1151pub struct PangoRectangle {
1152    pub x: c_int,
1153    pub y: c_int,
1154    pub width: c_int,
1155    pub height: c_int,
1156}
1157
1158impl ::std::fmt::Debug for PangoRectangle {
1159    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1160        f.debug_struct(&format!("PangoRectangle @ {self:p}"))
1161            .field("x", &self.x)
1162            .field("y", &self.y)
1163            .field("width", &self.width)
1164            .field("height", &self.height)
1165            .finish()
1166    }
1167}
1168
1169#[derive(Copy, Clone)]
1170#[repr(C)]
1171pub struct PangoRendererClass {
1172    pub parent_class: gobject::GObjectClass,
1173    pub draw_glyphs: Option<
1174        unsafe extern "C" fn(
1175            *mut PangoRenderer,
1176            *mut PangoFont,
1177            *mut PangoGlyphString,
1178            c_int,
1179            c_int,
1180        ),
1181    >,
1182    pub draw_rectangle: Option<
1183        unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart, c_int, c_int, c_int, c_int),
1184    >,
1185    pub draw_error_underline:
1186        Option<unsafe extern "C" fn(*mut PangoRenderer, c_int, c_int, c_int, c_int)>,
1187    pub draw_shape:
1188        Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoAttrShape, c_int, c_int)>,
1189    pub draw_trapezoid: Option<
1190        unsafe extern "C" fn(
1191            *mut PangoRenderer,
1192            PangoRenderPart,
1193            c_double,
1194            c_double,
1195            c_double,
1196            c_double,
1197            c_double,
1198            c_double,
1199        ),
1200    >,
1201    pub draw_glyph: Option<
1202        unsafe extern "C" fn(*mut PangoRenderer, *mut PangoFont, PangoGlyph, c_double, c_double),
1203    >,
1204    pub part_changed: Option<unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart)>,
1205    pub begin: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
1206    pub end: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
1207    pub prepare_run: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoLayoutRun)>,
1208    pub draw_glyph_item: Option<
1209        unsafe extern "C" fn(*mut PangoRenderer, *const c_char, *mut PangoGlyphItem, c_int, c_int),
1210    >,
1211    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
1212    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
1213    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
1214}
1215
1216impl ::std::fmt::Debug for PangoRendererClass {
1217    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1218        f.debug_struct(&format!("PangoRendererClass @ {self:p}"))
1219            .field("draw_glyphs", &self.draw_glyphs)
1220            .field("draw_rectangle", &self.draw_rectangle)
1221            .field("draw_error_underline", &self.draw_error_underline)
1222            .field("draw_shape", &self.draw_shape)
1223            .field("draw_trapezoid", &self.draw_trapezoid)
1224            .field("draw_glyph", &self.draw_glyph)
1225            .field("part_changed", &self.part_changed)
1226            .field("begin", &self.begin)
1227            .field("end", &self.end)
1228            .field("prepare_run", &self.prepare_run)
1229            .field("draw_glyph_item", &self.draw_glyph_item)
1230            .field("_pango_reserved2", &self._pango_reserved2)
1231            .field("_pango_reserved3", &self._pango_reserved3)
1232            .field("_pango_reserved4", &self._pango_reserved4)
1233            .finish()
1234    }
1235}
1236
1237#[repr(C)]
1238#[allow(dead_code)]
1239pub struct _PangoRendererPrivate {
1240    _data: [u8; 0],
1241    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1242}
1243
1244pub type PangoRendererPrivate = _PangoRendererPrivate;
1245
1246#[repr(C)]
1247#[allow(dead_code)]
1248pub struct PangoScriptIter {
1249    _data: [u8; 0],
1250    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1251}
1252
1253impl ::std::fmt::Debug for PangoScriptIter {
1254    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1255        f.debug_struct(&format!("PangoScriptIter @ {self:p}"))
1256            .finish()
1257    }
1258}
1259
1260#[repr(C)]
1261#[allow(dead_code)]
1262pub struct PangoTabArray {
1263    _data: [u8; 0],
1264    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1265}
1266
1267impl ::std::fmt::Debug for PangoTabArray {
1268    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1269        f.debug_struct(&format!("PangoTabArray @ {self:p}"))
1270            .finish()
1271    }
1272}
1273
1274// Classes
1275#[repr(C)]
1276#[allow(dead_code)]
1277pub struct PangoContext {
1278    _data: [u8; 0],
1279    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1280}
1281
1282impl ::std::fmt::Debug for PangoContext {
1283    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1284        f.debug_struct(&format!("PangoContext @ {self:p}")).finish()
1285    }
1286}
1287
1288#[repr(C)]
1289#[allow(dead_code)]
1290pub struct PangoCoverage {
1291    _data: [u8; 0],
1292    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1293}
1294
1295impl ::std::fmt::Debug for PangoCoverage {
1296    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1297        f.debug_struct(&format!("PangoCoverage @ {self:p}"))
1298            .finish()
1299    }
1300}
1301
1302#[derive(Copy, Clone)]
1303#[repr(C)]
1304pub struct PangoFont {
1305    pub parent_instance: gobject::GObject,
1306}
1307
1308impl ::std::fmt::Debug for PangoFont {
1309    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1310        f.debug_struct(&format!("PangoFont @ {self:p}"))
1311            .field("parent_instance", &self.parent_instance)
1312            .finish()
1313    }
1314}
1315
1316#[derive(Copy, Clone)]
1317#[repr(C)]
1318pub struct PangoFontFace {
1319    pub parent_instance: gobject::GObject,
1320}
1321
1322impl ::std::fmt::Debug for PangoFontFace {
1323    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1324        f.debug_struct(&format!("PangoFontFace @ {self:p}"))
1325            .field("parent_instance", &self.parent_instance)
1326            .finish()
1327    }
1328}
1329
1330#[derive(Copy, Clone)]
1331#[repr(C)]
1332pub struct PangoFontFamily {
1333    pub parent_instance: gobject::GObject,
1334}
1335
1336impl ::std::fmt::Debug for PangoFontFamily {
1337    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1338        f.debug_struct(&format!("PangoFontFamily @ {self:p}"))
1339            .field("parent_instance", &self.parent_instance)
1340            .finish()
1341    }
1342}
1343
1344#[derive(Copy, Clone)]
1345#[repr(C)]
1346pub struct PangoFontMap {
1347    pub parent_instance: gobject::GObject,
1348}
1349
1350impl ::std::fmt::Debug for PangoFontMap {
1351    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1352        f.debug_struct(&format!("PangoFontMap @ {self:p}"))
1353            .field("parent_instance", &self.parent_instance)
1354            .finish()
1355    }
1356}
1357
1358#[derive(Copy, Clone)]
1359#[repr(C)]
1360pub struct PangoFontset {
1361    pub parent_instance: gobject::GObject,
1362}
1363
1364impl ::std::fmt::Debug for PangoFontset {
1365    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1366        f.debug_struct(&format!("PangoFontset @ {self:p}"))
1367            .field("parent_instance", &self.parent_instance)
1368            .finish()
1369    }
1370}
1371
1372#[repr(C)]
1373#[allow(dead_code)]
1374pub struct PangoFontsetSimple {
1375    _data: [u8; 0],
1376    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1377}
1378
1379impl ::std::fmt::Debug for PangoFontsetSimple {
1380    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1381        f.debug_struct(&format!("PangoFontsetSimple @ {self:p}"))
1382            .finish()
1383    }
1384}
1385
1386#[repr(C)]
1387#[allow(dead_code)]
1388pub struct PangoLayout {
1389    _data: [u8; 0],
1390    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1391}
1392
1393impl ::std::fmt::Debug for PangoLayout {
1394    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1395        f.debug_struct(&format!("PangoLayout @ {self:p}")).finish()
1396    }
1397}
1398
1399#[derive(Copy, Clone)]
1400#[repr(C)]
1401pub struct PangoRenderer {
1402    pub parent_instance: gobject::GObject,
1403    pub underline: PangoUnderline,
1404    pub strikethrough: gboolean,
1405    pub active_count: c_int,
1406    pub matrix: *mut PangoMatrix,
1407    pub priv_: *mut PangoRendererPrivate,
1408}
1409
1410impl ::std::fmt::Debug for PangoRenderer {
1411    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1412        f.debug_struct(&format!("PangoRenderer @ {self:p}"))
1413            .field("matrix", &self.matrix)
1414            .finish()
1415    }
1416}
1417
1418extern "C" {
1419
1420    //=========================================================================
1421    // PangoAlignment
1422    //=========================================================================
1423    pub fn pango_alignment_get_type() -> GType;
1424
1425    //=========================================================================
1426    // PangoAttrType
1427    //=========================================================================
1428    pub fn pango_attr_type_get_type() -> GType;
1429    pub fn pango_attr_type_get_name(type_: PangoAttrType) -> *const c_char;
1430    pub fn pango_attr_type_register(name: *const c_char) -> PangoAttrType;
1431
1432    //=========================================================================
1433    // PangoBaselineShift
1434    //=========================================================================
1435    #[cfg(feature = "v1_50")]
1436    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1437    pub fn pango_baseline_shift_get_type() -> GType;
1438
1439    //=========================================================================
1440    // PangoBidiType
1441    //=========================================================================
1442    pub fn pango_bidi_type_get_type() -> GType;
1443    pub fn pango_bidi_type_for_unichar(ch: u32) -> PangoBidiType;
1444
1445    //=========================================================================
1446    // PangoCoverageLevel
1447    //=========================================================================
1448    pub fn pango_coverage_level_get_type() -> GType;
1449
1450    //=========================================================================
1451    // PangoDirection
1452    //=========================================================================
1453    pub fn pango_direction_get_type() -> GType;
1454
1455    //=========================================================================
1456    // PangoEllipsizeMode
1457    //=========================================================================
1458    pub fn pango_ellipsize_mode_get_type() -> GType;
1459
1460    //=========================================================================
1461    // PangoFontColor
1462    //=========================================================================
1463    #[cfg(feature = "v1_57")]
1464    #[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1465    pub fn pango_font_color_get_type() -> GType;
1466
1467    //=========================================================================
1468    // PangoFontScale
1469    //=========================================================================
1470    #[cfg(feature = "v1_50")]
1471    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1472    pub fn pango_font_scale_get_type() -> GType;
1473
1474    //=========================================================================
1475    // PangoGravity
1476    //=========================================================================
1477    pub fn pango_gravity_get_type() -> GType;
1478    pub fn pango_gravity_get_for_matrix(matrix: *const PangoMatrix) -> PangoGravity;
1479    pub fn pango_gravity_get_for_script(
1480        script: PangoScript,
1481        base_gravity: PangoGravity,
1482        hint: PangoGravityHint,
1483    ) -> PangoGravity;
1484    pub fn pango_gravity_get_for_script_and_width(
1485        script: PangoScript,
1486        wide: gboolean,
1487        base_gravity: PangoGravity,
1488        hint: PangoGravityHint,
1489    ) -> PangoGravity;
1490    pub fn pango_gravity_to_rotation(gravity: PangoGravity) -> c_double;
1491
1492    //=========================================================================
1493    // PangoGravityHint
1494    //=========================================================================
1495    pub fn pango_gravity_hint_get_type() -> GType;
1496
1497    //=========================================================================
1498    // PangoLayoutDeserializeError
1499    //=========================================================================
1500    #[cfg(feature = "v1_50")]
1501    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1502    pub fn pango_layout_deserialize_error_get_type() -> GType;
1503    #[cfg(feature = "v1_50")]
1504    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1505    pub fn pango_layout_deserialize_error_quark() -> glib::GQuark;
1506
1507    //=========================================================================
1508    // PangoOverline
1509    //=========================================================================
1510    #[cfg(feature = "v1_46")]
1511    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1512    pub fn pango_overline_get_type() -> GType;
1513
1514    //=========================================================================
1515    // PangoRenderPart
1516    //=========================================================================
1517    pub fn pango_render_part_get_type() -> GType;
1518
1519    //=========================================================================
1520    // PangoScript
1521    //=========================================================================
1522    pub fn pango_script_get_type() -> GType;
1523    pub fn pango_script_for_unichar(ch: u32) -> PangoScript;
1524    pub fn pango_script_get_sample_language(script: PangoScript) -> *mut PangoLanguage;
1525
1526    //=========================================================================
1527    // PangoStretch
1528    //=========================================================================
1529    pub fn pango_stretch_get_type() -> GType;
1530
1531    //=========================================================================
1532    // PangoStyle
1533    //=========================================================================
1534    pub fn pango_style_get_type() -> GType;
1535
1536    //=========================================================================
1537    // PangoTabAlign
1538    //=========================================================================
1539    pub fn pango_tab_align_get_type() -> GType;
1540
1541    //=========================================================================
1542    // PangoTextTransform
1543    //=========================================================================
1544    #[cfg(feature = "v1_50")]
1545    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1546    pub fn pango_text_transform_get_type() -> GType;
1547
1548    //=========================================================================
1549    // PangoUnderline
1550    //=========================================================================
1551    pub fn pango_underline_get_type() -> GType;
1552
1553    //=========================================================================
1554    // PangoVariant
1555    //=========================================================================
1556    pub fn pango_variant_get_type() -> GType;
1557
1558    //=========================================================================
1559    // PangoWeight
1560    //=========================================================================
1561    pub fn pango_weight_get_type() -> GType;
1562
1563    //=========================================================================
1564    // PangoWrapMode
1565    //=========================================================================
1566    pub fn pango_wrap_mode_get_type() -> GType;
1567
1568    //=========================================================================
1569    // PangoFontMask
1570    //=========================================================================
1571    pub fn pango_font_mask_get_type() -> GType;
1572
1573    //=========================================================================
1574    // PangoLayoutDeserializeFlags
1575    //=========================================================================
1576    #[cfg(feature = "v1_50")]
1577    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1578    pub fn pango_layout_deserialize_flags_get_type() -> GType;
1579
1580    //=========================================================================
1581    // PangoLayoutSerializeFlags
1582    //=========================================================================
1583    #[cfg(feature = "v1_50")]
1584    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1585    pub fn pango_layout_serialize_flags_get_type() -> GType;
1586
1587    //=========================================================================
1588    // PangoShapeFlags
1589    //=========================================================================
1590    #[cfg(feature = "v1_44")]
1591    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1592    pub fn pango_shape_flags_get_type() -> GType;
1593
1594    //=========================================================================
1595    // PangoShowFlags
1596    //=========================================================================
1597    #[cfg(feature = "v1_44")]
1598    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1599    pub fn pango_show_flags_get_type() -> GType;
1600
1601    //=========================================================================
1602    // PangoAttrFontDesc
1603    //=========================================================================
1604    pub fn pango_attr_font_desc_new(desc: *const PangoFontDescription) -> *mut PangoAttribute;
1605
1606    //=========================================================================
1607    // PangoAttrFontFeatures
1608    //=========================================================================
1609    pub fn pango_attr_font_features_new(features: *const c_char) -> *mut PangoAttribute;
1610
1611    //=========================================================================
1612    // PangoAttrIterator
1613    //=========================================================================
1614    #[cfg(feature = "v1_44")]
1615    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1616    pub fn pango_attr_iterator_get_type() -> GType;
1617    pub fn pango_attr_iterator_copy(iterator: *mut PangoAttrIterator) -> *mut PangoAttrIterator;
1618    pub fn pango_attr_iterator_destroy(iterator: *mut PangoAttrIterator);
1619    pub fn pango_attr_iterator_get(
1620        iterator: *mut PangoAttrIterator,
1621        type_: PangoAttrType,
1622    ) -> *mut PangoAttribute;
1623    pub fn pango_attr_iterator_get_attrs(iterator: *mut PangoAttrIterator) -> *mut glib::GSList;
1624    pub fn pango_attr_iterator_get_font(
1625        iterator: *mut PangoAttrIterator,
1626        desc: *mut PangoFontDescription,
1627        language: *mut *mut PangoLanguage,
1628        extra_attrs: *mut *mut glib::GSList,
1629    );
1630    pub fn pango_attr_iterator_next(iterator: *mut PangoAttrIterator) -> gboolean;
1631    pub fn pango_attr_iterator_range(
1632        iterator: *mut PangoAttrIterator,
1633        start: *mut c_int,
1634        end: *mut c_int,
1635    );
1636
1637    //=========================================================================
1638    // PangoAttrLanguage
1639    //=========================================================================
1640    pub fn pango_attr_language_new(language: *mut PangoLanguage) -> *mut PangoAttribute;
1641
1642    //=========================================================================
1643    // PangoAttrList
1644    //=========================================================================
1645    pub fn pango_attr_list_get_type() -> GType;
1646    pub fn pango_attr_list_new() -> *mut PangoAttrList;
1647    pub fn pango_attr_list_change(list: *mut PangoAttrList, attr: *mut PangoAttribute);
1648    pub fn pango_attr_list_copy(list: *mut PangoAttrList) -> *mut PangoAttrList;
1649    #[cfg(feature = "v1_46")]
1650    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1651    pub fn pango_attr_list_equal(
1652        list: *mut PangoAttrList,
1653        other_list: *mut PangoAttrList,
1654    ) -> gboolean;
1655    pub fn pango_attr_list_filter(
1656        list: *mut PangoAttrList,
1657        func: PangoAttrFilterFunc,
1658        data: gpointer,
1659    ) -> *mut PangoAttrList;
1660    #[cfg(feature = "v1_44")]
1661    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1662    pub fn pango_attr_list_get_attributes(list: *mut PangoAttrList) -> *mut glib::GSList;
1663    pub fn pango_attr_list_get_iterator(list: *mut PangoAttrList) -> *mut PangoAttrIterator;
1664    pub fn pango_attr_list_insert(list: *mut PangoAttrList, attr: *mut PangoAttribute);
1665    pub fn pango_attr_list_insert_before(list: *mut PangoAttrList, attr: *mut PangoAttribute);
1666    pub fn pango_attr_list_ref(list: *mut PangoAttrList) -> *mut PangoAttrList;
1667    pub fn pango_attr_list_splice(
1668        list: *mut PangoAttrList,
1669        other: *mut PangoAttrList,
1670        pos: c_int,
1671        len: c_int,
1672    );
1673    #[cfg(feature = "v1_50")]
1674    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1675    pub fn pango_attr_list_to_string(list: *mut PangoAttrList) -> *mut c_char;
1676    pub fn pango_attr_list_unref(list: *mut PangoAttrList);
1677    #[cfg(feature = "v1_44")]
1678    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1679    pub fn pango_attr_list_update(list: *mut PangoAttrList, pos: c_int, remove: c_int, add: c_int);
1680    #[cfg(feature = "v1_50")]
1681    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1682    pub fn pango_attr_list_from_string(text: *const c_char) -> *mut PangoAttrList;
1683
1684    //=========================================================================
1685    // PangoAttrShape
1686    //=========================================================================
1687    pub fn pango_attr_shape_new(
1688        ink_rect: *const PangoRectangle,
1689        logical_rect: *const PangoRectangle,
1690    ) -> *mut PangoAttribute;
1691    pub fn pango_attr_shape_new_with_data(
1692        ink_rect: *const PangoRectangle,
1693        logical_rect: *const PangoRectangle,
1694        data: gpointer,
1695        copy_func: PangoAttrDataCopyFunc,
1696        destroy_func: glib::GDestroyNotify,
1697    ) -> *mut PangoAttribute;
1698
1699    //=========================================================================
1700    // PangoAttrSize
1701    //=========================================================================
1702    pub fn pango_attr_size_new(size: c_int) -> *mut PangoAttribute;
1703    pub fn pango_attr_size_new_absolute(size: c_int) -> *mut PangoAttribute;
1704
1705    //=========================================================================
1706    // PangoAttribute
1707    //=========================================================================
1708    #[cfg(feature = "v1_44")]
1709    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1710    pub fn pango_attribute_get_type() -> GType;
1711    #[cfg(feature = "v1_50")]
1712    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1713    pub fn pango_attribute_as_color(attr: *mut PangoAttribute) -> *mut PangoAttrColor;
1714    #[cfg(feature = "v1_50")]
1715    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1716    pub fn pango_attribute_as_float(attr: *mut PangoAttribute) -> *mut PangoAttrFloat;
1717    #[cfg(feature = "v1_50")]
1718    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1719    pub fn pango_attribute_as_font_desc(attr: *mut PangoAttribute) -> *mut PangoAttrFontDesc;
1720    #[cfg(feature = "v1_50")]
1721    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1722    pub fn pango_attribute_as_font_features(
1723        attr: *mut PangoAttribute,
1724    ) -> *mut PangoAttrFontFeatures;
1725    #[cfg(feature = "v1_50")]
1726    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1727    pub fn pango_attribute_as_int(attr: *mut PangoAttribute) -> *mut PangoAttrInt;
1728    #[cfg(feature = "v1_50")]
1729    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1730    pub fn pango_attribute_as_language(attr: *mut PangoAttribute) -> *mut PangoAttrLanguage;
1731    #[cfg(feature = "v1_50")]
1732    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1733    pub fn pango_attribute_as_shape(attr: *mut PangoAttribute) -> *mut PangoAttrShape;
1734    #[cfg(feature = "v1_50")]
1735    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1736    pub fn pango_attribute_as_size(attr: *mut PangoAttribute) -> *mut PangoAttrSize;
1737    #[cfg(feature = "v1_50")]
1738    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1739    pub fn pango_attribute_as_string(attr: *mut PangoAttribute) -> *mut PangoAttrString;
1740    pub fn pango_attribute_copy(attr: *const PangoAttribute) -> *mut PangoAttribute;
1741    pub fn pango_attribute_destroy(attr: *mut PangoAttribute);
1742    pub fn pango_attribute_equal(
1743        attr1: *const PangoAttribute,
1744        attr2: *const PangoAttribute,
1745    ) -> gboolean;
1746    pub fn pango_attribute_init(attr: *mut PangoAttribute, klass: *const PangoAttrClass);
1747
1748    //=========================================================================
1749    // PangoColor
1750    //=========================================================================
1751    pub fn pango_color_get_type() -> GType;
1752    pub fn pango_color_copy(src: *const PangoColor) -> *mut PangoColor;
1753    pub fn pango_color_free(color: *mut PangoColor);
1754    pub fn pango_color_parse(color: *mut PangoColor, spec: *const c_char) -> gboolean;
1755    #[cfg(feature = "v1_46")]
1756    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1757    pub fn pango_color_parse_with_alpha(
1758        color: *mut PangoColor,
1759        alpha: *mut u16,
1760        spec: *const c_char,
1761    ) -> gboolean;
1762    pub fn pango_color_to_string(color: *const PangoColor) -> *mut c_char;
1763
1764    //=========================================================================
1765    // PangoFontDescription
1766    //=========================================================================
1767    pub fn pango_font_description_get_type() -> GType;
1768    pub fn pango_font_description_new() -> *mut PangoFontDescription;
1769    pub fn pango_font_description_better_match(
1770        desc: *const PangoFontDescription,
1771        old_match: *const PangoFontDescription,
1772        new_match: *const PangoFontDescription,
1773    ) -> gboolean;
1774    pub fn pango_font_description_copy(
1775        desc: *const PangoFontDescription,
1776    ) -> *mut PangoFontDescription;
1777    pub fn pango_font_description_copy_static(
1778        desc: *const PangoFontDescription,
1779    ) -> *mut PangoFontDescription;
1780    pub fn pango_font_description_equal(
1781        desc1: *const PangoFontDescription,
1782        desc2: *const PangoFontDescription,
1783    ) -> gboolean;
1784    pub fn pango_font_description_free(desc: *mut PangoFontDescription);
1785    #[cfg(feature = "v1_57")]
1786    #[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1787    pub fn pango_font_description_get_color(desc: *const PangoFontDescription) -> PangoFontColor;
1788    pub fn pango_font_description_get_family(desc: *const PangoFontDescription) -> *const c_char;
1789    #[cfg(feature = "v1_56")]
1790    #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
1791    pub fn pango_font_description_get_features(desc: *const PangoFontDescription) -> *const c_char;
1792    pub fn pango_font_description_get_gravity(desc: *const PangoFontDescription) -> PangoGravity;
1793    pub fn pango_font_description_get_set_fields(
1794        desc: *const PangoFontDescription,
1795    ) -> PangoFontMask;
1796    pub fn pango_font_description_get_size(desc: *const PangoFontDescription) -> c_int;
1797    pub fn pango_font_description_get_size_is_absolute(
1798        desc: *const PangoFontDescription,
1799    ) -> gboolean;
1800    pub fn pango_font_description_get_stretch(desc: *const PangoFontDescription) -> PangoStretch;
1801    pub fn pango_font_description_get_style(desc: *const PangoFontDescription) -> PangoStyle;
1802    pub fn pango_font_description_get_variant(desc: *const PangoFontDescription) -> PangoVariant;
1803    #[cfg(feature = "v1_42")]
1804    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
1805    pub fn pango_font_description_get_variations(
1806        desc: *const PangoFontDescription,
1807    ) -> *const c_char;
1808    pub fn pango_font_description_get_weight(desc: *const PangoFontDescription) -> PangoWeight;
1809    pub fn pango_font_description_hash(desc: *const PangoFontDescription) -> c_uint;
1810    pub fn pango_font_description_merge(
1811        desc: *mut PangoFontDescription,
1812        desc_to_merge: *const PangoFontDescription,
1813        replace_existing: gboolean,
1814    );
1815    pub fn pango_font_description_merge_static(
1816        desc: *mut PangoFontDescription,
1817        desc_to_merge: *const PangoFontDescription,
1818        replace_existing: gboolean,
1819    );
1820    pub fn pango_font_description_set_absolute_size(
1821        desc: *mut PangoFontDescription,
1822        size: c_double,
1823    );
1824    #[cfg(feature = "v1_57")]
1825    #[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1826    pub fn pango_font_description_set_color(desc: *mut PangoFontDescription, color: PangoFontColor);
1827    pub fn pango_font_description_set_family(
1828        desc: *mut PangoFontDescription,
1829        family: *const c_char,
1830    );
1831    pub fn pango_font_description_set_family_static(
1832        desc: *mut PangoFontDescription,
1833        family: *const c_char,
1834    );
1835    #[cfg(feature = "v1_56")]
1836    #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
1837    pub fn pango_font_description_set_features(
1838        desc: *mut PangoFontDescription,
1839        features: *const c_char,
1840    );
1841    #[cfg(feature = "v1_56")]
1842    #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
1843    pub fn pango_font_description_set_features_static(
1844        desc: *mut PangoFontDescription,
1845        features: *const c_char,
1846    );
1847    pub fn pango_font_description_set_gravity(
1848        desc: *mut PangoFontDescription,
1849        gravity: PangoGravity,
1850    );
1851    pub fn pango_font_description_set_size(desc: *mut PangoFontDescription, size: c_int);
1852    pub fn pango_font_description_set_stretch(
1853        desc: *mut PangoFontDescription,
1854        stretch: PangoStretch,
1855    );
1856    pub fn pango_font_description_set_style(desc: *mut PangoFontDescription, style: PangoStyle);
1857    pub fn pango_font_description_set_variant(
1858        desc: *mut PangoFontDescription,
1859        variant: PangoVariant,
1860    );
1861    #[cfg(feature = "v1_42")]
1862    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
1863    pub fn pango_font_description_set_variations(
1864        desc: *mut PangoFontDescription,
1865        variations: *const c_char,
1866    );
1867    #[cfg(feature = "v1_42")]
1868    #[cfg_attr(docsrs, doc(cfg(feature = "v1_42")))]
1869    pub fn pango_font_description_set_variations_static(
1870        desc: *mut PangoFontDescription,
1871        variations: *const c_char,
1872    );
1873    pub fn pango_font_description_set_weight(desc: *mut PangoFontDescription, weight: PangoWeight);
1874    pub fn pango_font_description_to_filename(desc: *const PangoFontDescription) -> *mut c_char;
1875    pub fn pango_font_description_to_string(desc: *const PangoFontDescription) -> *mut c_char;
1876    pub fn pango_font_description_unset_fields(
1877        desc: *mut PangoFontDescription,
1878        to_unset: PangoFontMask,
1879    );
1880    pub fn pango_font_description_from_string(str: *const c_char) -> *mut PangoFontDescription;
1881
1882    //=========================================================================
1883    // PangoFontMetrics
1884    //=========================================================================
1885    pub fn pango_font_metrics_get_type() -> GType;
1886    pub fn pango_font_metrics_get_approximate_char_width(metrics: *mut PangoFontMetrics) -> c_int;
1887    pub fn pango_font_metrics_get_approximate_digit_width(metrics: *mut PangoFontMetrics) -> c_int;
1888    pub fn pango_font_metrics_get_ascent(metrics: *mut PangoFontMetrics) -> c_int;
1889    pub fn pango_font_metrics_get_descent(metrics: *mut PangoFontMetrics) -> c_int;
1890    #[cfg(feature = "v1_44")]
1891    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
1892    pub fn pango_font_metrics_get_height(metrics: *mut PangoFontMetrics) -> c_int;
1893    pub fn pango_font_metrics_get_strikethrough_position(metrics: *mut PangoFontMetrics) -> c_int;
1894    pub fn pango_font_metrics_get_strikethrough_thickness(metrics: *mut PangoFontMetrics) -> c_int;
1895    pub fn pango_font_metrics_get_underline_position(metrics: *mut PangoFontMetrics) -> c_int;
1896    pub fn pango_font_metrics_get_underline_thickness(metrics: *mut PangoFontMetrics) -> c_int;
1897    pub fn pango_font_metrics_ref(metrics: *mut PangoFontMetrics) -> *mut PangoFontMetrics;
1898    pub fn pango_font_metrics_unref(metrics: *mut PangoFontMetrics);
1899
1900    //=========================================================================
1901    // PangoGlyphItem
1902    //=========================================================================
1903    pub fn pango_glyph_item_get_type() -> GType;
1904    pub fn pango_glyph_item_apply_attrs(
1905        glyph_item: *mut PangoGlyphItem,
1906        text: *const c_char,
1907        list: *mut PangoAttrList,
1908    ) -> *mut glib::GSList;
1909    pub fn pango_glyph_item_copy(orig: *mut PangoGlyphItem) -> *mut PangoGlyphItem;
1910    pub fn pango_glyph_item_free(glyph_item: *mut PangoGlyphItem);
1911    pub fn pango_glyph_item_get_logical_widths(
1912        glyph_item: *mut PangoGlyphItem,
1913        text: *const c_char,
1914        logical_widths: *mut c_int,
1915    );
1916    pub fn pango_glyph_item_letter_space(
1917        glyph_item: *mut PangoGlyphItem,
1918        text: *const c_char,
1919        log_attrs: *mut PangoLogAttr,
1920        letter_spacing: c_int,
1921    );
1922    pub fn pango_glyph_item_split(
1923        orig: *mut PangoGlyphItem,
1924        text: *const c_char,
1925        split_index: c_int,
1926    ) -> *mut PangoGlyphItem;
1927
1928    //=========================================================================
1929    // PangoGlyphItemIter
1930    //=========================================================================
1931    pub fn pango_glyph_item_iter_get_type() -> GType;
1932    pub fn pango_glyph_item_iter_copy(orig: *mut PangoGlyphItemIter) -> *mut PangoGlyphItemIter;
1933    pub fn pango_glyph_item_iter_free(iter: *mut PangoGlyphItemIter);
1934    pub fn pango_glyph_item_iter_init_end(
1935        iter: *mut PangoGlyphItemIter,
1936        glyph_item: *mut PangoGlyphItem,
1937        text: *const c_char,
1938    ) -> gboolean;
1939    pub fn pango_glyph_item_iter_init_start(
1940        iter: *mut PangoGlyphItemIter,
1941        glyph_item: *mut PangoGlyphItem,
1942        text: *const c_char,
1943    ) -> gboolean;
1944    pub fn pango_glyph_item_iter_next_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;
1945    pub fn pango_glyph_item_iter_prev_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;
1946
1947    //=========================================================================
1948    // PangoGlyphString
1949    //=========================================================================
1950    pub fn pango_glyph_string_get_type() -> GType;
1951    pub fn pango_glyph_string_new() -> *mut PangoGlyphString;
1952    pub fn pango_glyph_string_copy(string: *mut PangoGlyphString) -> *mut PangoGlyphString;
1953    pub fn pango_glyph_string_extents(
1954        glyphs: *mut PangoGlyphString,
1955        font: *mut PangoFont,
1956        ink_rect: *mut PangoRectangle,
1957        logical_rect: *mut PangoRectangle,
1958    );
1959    pub fn pango_glyph_string_extents_range(
1960        glyphs: *mut PangoGlyphString,
1961        start: c_int,
1962        end: c_int,
1963        font: *mut PangoFont,
1964        ink_rect: *mut PangoRectangle,
1965        logical_rect: *mut PangoRectangle,
1966    );
1967    pub fn pango_glyph_string_free(string: *mut PangoGlyphString);
1968    pub fn pango_glyph_string_get_logical_widths(
1969        glyphs: *mut PangoGlyphString,
1970        text: *const c_char,
1971        length: c_int,
1972        embedding_level: c_int,
1973        logical_widths: *mut c_int,
1974    );
1975    pub fn pango_glyph_string_get_width(glyphs: *mut PangoGlyphString) -> c_int;
1976    pub fn pango_glyph_string_index_to_x(
1977        glyphs: *mut PangoGlyphString,
1978        text: *const c_char,
1979        length: c_int,
1980        analysis: *mut PangoAnalysis,
1981        index_: c_int,
1982        trailing: gboolean,
1983        x_pos: *mut c_int,
1984    );
1985    #[cfg(feature = "v1_50")]
1986    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1987    pub fn pango_glyph_string_index_to_x_full(
1988        glyphs: *mut PangoGlyphString,
1989        text: *const c_char,
1990        length: c_int,
1991        analysis: *mut PangoAnalysis,
1992        attrs: *mut PangoLogAttr,
1993        index_: c_int,
1994        trailing: gboolean,
1995        x_pos: *mut c_int,
1996    );
1997    pub fn pango_glyph_string_set_size(string: *mut PangoGlyphString, new_len: c_int);
1998    pub fn pango_glyph_string_x_to_index(
1999        glyphs: *mut PangoGlyphString,
2000        text: *const c_char,
2001        length: c_int,
2002        analysis: *mut PangoAnalysis,
2003        x_pos: c_int,
2004        index_: *mut c_int,
2005        trailing: *mut c_int,
2006    );
2007
2008    //=========================================================================
2009    // PangoItem
2010    //=========================================================================
2011    pub fn pango_item_get_type() -> GType;
2012    pub fn pango_item_new() -> *mut PangoItem;
2013    #[cfg(feature = "v1_44")]
2014    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2015    pub fn pango_item_apply_attrs(item: *mut PangoItem, iter: *mut PangoAttrIterator);
2016    pub fn pango_item_copy(item: *mut PangoItem) -> *mut PangoItem;
2017    pub fn pango_item_free(item: *mut PangoItem);
2018    #[cfg(feature = "v1_54")]
2019    #[cfg_attr(docsrs, doc(cfg(feature = "v1_54")))]
2020    pub fn pango_item_get_char_offset(item: *mut PangoItem) -> c_int;
2021    pub fn pango_item_split(
2022        orig: *mut PangoItem,
2023        split_index: c_int,
2024        split_offset: c_int,
2025    ) -> *mut PangoItem;
2026
2027    //=========================================================================
2028    // PangoLanguage
2029    //=========================================================================
2030    pub fn pango_language_get_type() -> GType;
2031    pub fn pango_language_get_sample_string(language: *mut PangoLanguage) -> *const c_char;
2032    pub fn pango_language_get_scripts(
2033        language: *mut PangoLanguage,
2034        num_scripts: *mut c_int,
2035    ) -> *const PangoScript;
2036    pub fn pango_language_includes_script(
2037        language: *mut PangoLanguage,
2038        script: PangoScript,
2039    ) -> gboolean;
2040    pub fn pango_language_matches(
2041        language: *mut PangoLanguage,
2042        range_list: *const c_char,
2043    ) -> gboolean;
2044    pub fn pango_language_to_string(language: *mut PangoLanguage) -> *const c_char;
2045    pub fn pango_language_from_string(language: *const c_char) -> *mut PangoLanguage;
2046    pub fn pango_language_get_default() -> *mut PangoLanguage;
2047    #[cfg(feature = "v1_48")]
2048    #[cfg_attr(docsrs, doc(cfg(feature = "v1_48")))]
2049    pub fn pango_language_get_preferred() -> *mut *mut PangoLanguage;
2050
2051    //=========================================================================
2052    // PangoLayoutIter
2053    //=========================================================================
2054    pub fn pango_layout_iter_get_type() -> GType;
2055    pub fn pango_layout_iter_at_last_line(iter: *mut PangoLayoutIter) -> gboolean;
2056    pub fn pango_layout_iter_copy(iter: *mut PangoLayoutIter) -> *mut PangoLayoutIter;
2057    pub fn pango_layout_iter_free(iter: *mut PangoLayoutIter);
2058    pub fn pango_layout_iter_get_baseline(iter: *mut PangoLayoutIter) -> c_int;
2059    pub fn pango_layout_iter_get_char_extents(
2060        iter: *mut PangoLayoutIter,
2061        logical_rect: *mut PangoRectangle,
2062    );
2063    pub fn pango_layout_iter_get_cluster_extents(
2064        iter: *mut PangoLayoutIter,
2065        ink_rect: *mut PangoRectangle,
2066        logical_rect: *mut PangoRectangle,
2067    );
2068    pub fn pango_layout_iter_get_index(iter: *mut PangoLayoutIter) -> c_int;
2069    pub fn pango_layout_iter_get_layout(iter: *mut PangoLayoutIter) -> *mut PangoLayout;
2070    pub fn pango_layout_iter_get_layout_extents(
2071        iter: *mut PangoLayoutIter,
2072        ink_rect: *mut PangoRectangle,
2073        logical_rect: *mut PangoRectangle,
2074    );
2075    pub fn pango_layout_iter_get_line(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
2076    pub fn pango_layout_iter_get_line_extents(
2077        iter: *mut PangoLayoutIter,
2078        ink_rect: *mut PangoRectangle,
2079        logical_rect: *mut PangoRectangle,
2080    );
2081    pub fn pango_layout_iter_get_line_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
2082    pub fn pango_layout_iter_get_line_yrange(
2083        iter: *mut PangoLayoutIter,
2084        y0_: *mut c_int,
2085        y1_: *mut c_int,
2086    );
2087    pub fn pango_layout_iter_get_run(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
2088    #[cfg(feature = "v1_50")]
2089    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2090    pub fn pango_layout_iter_get_run_baseline(iter: *mut PangoLayoutIter) -> c_int;
2091    pub fn pango_layout_iter_get_run_extents(
2092        iter: *mut PangoLayoutIter,
2093        ink_rect: *mut PangoRectangle,
2094        logical_rect: *mut PangoRectangle,
2095    );
2096    pub fn pango_layout_iter_get_run_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
2097    pub fn pango_layout_iter_next_char(iter: *mut PangoLayoutIter) -> gboolean;
2098    pub fn pango_layout_iter_next_cluster(iter: *mut PangoLayoutIter) -> gboolean;
2099    pub fn pango_layout_iter_next_line(iter: *mut PangoLayoutIter) -> gboolean;
2100    pub fn pango_layout_iter_next_run(iter: *mut PangoLayoutIter) -> gboolean;
2101
2102    //=========================================================================
2103    // PangoLayoutLine
2104    //=========================================================================
2105    pub fn pango_layout_line_get_type() -> GType;
2106    pub fn pango_layout_line_get_extents(
2107        line: *mut PangoLayoutLine,
2108        ink_rect: *mut PangoRectangle,
2109        logical_rect: *mut PangoRectangle,
2110    );
2111    #[cfg(feature = "v1_44")]
2112    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2113    pub fn pango_layout_line_get_height(line: *mut PangoLayoutLine, height: *mut c_int);
2114    #[cfg(feature = "v1_50")]
2115    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2116    pub fn pango_layout_line_get_length(line: *mut PangoLayoutLine) -> c_int;
2117    pub fn pango_layout_line_get_pixel_extents(
2118        layout_line: *mut PangoLayoutLine,
2119        ink_rect: *mut PangoRectangle,
2120        logical_rect: *mut PangoRectangle,
2121    );
2122    #[cfg(feature = "v1_50")]
2123    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2124    pub fn pango_layout_line_get_resolved_direction(line: *mut PangoLayoutLine) -> PangoDirection;
2125    #[cfg(feature = "v1_50")]
2126    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2127    pub fn pango_layout_line_get_start_index(line: *mut PangoLayoutLine) -> c_int;
2128    pub fn pango_layout_line_get_x_ranges(
2129        line: *mut PangoLayoutLine,
2130        start_index: c_int,
2131        end_index: c_int,
2132        ranges: *mut *mut c_int,
2133        n_ranges: *mut c_int,
2134    );
2135    pub fn pango_layout_line_index_to_x(
2136        line: *mut PangoLayoutLine,
2137        index_: c_int,
2138        trailing: gboolean,
2139        x_pos: *mut c_int,
2140    );
2141    #[cfg(feature = "v1_50")]
2142    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2143    pub fn pango_layout_line_is_paragraph_start(line: *mut PangoLayoutLine) -> gboolean;
2144    pub fn pango_layout_line_ref(line: *mut PangoLayoutLine) -> *mut PangoLayoutLine;
2145    pub fn pango_layout_line_unref(line: *mut PangoLayoutLine);
2146    pub fn pango_layout_line_x_to_index(
2147        line: *mut PangoLayoutLine,
2148        x_pos: c_int,
2149        index_: *mut c_int,
2150        trailing: *mut c_int,
2151    ) -> gboolean;
2152
2153    //=========================================================================
2154    // PangoMatrix
2155    //=========================================================================
2156    pub fn pango_matrix_get_type() -> GType;
2157    pub fn pango_matrix_concat(matrix: *mut PangoMatrix, new_matrix: *const PangoMatrix);
2158    pub fn pango_matrix_copy(matrix: *const PangoMatrix) -> *mut PangoMatrix;
2159    pub fn pango_matrix_free(matrix: *mut PangoMatrix);
2160    pub fn pango_matrix_get_font_scale_factor(matrix: *const PangoMatrix) -> c_double;
2161    pub fn pango_matrix_get_font_scale_factors(
2162        matrix: *const PangoMatrix,
2163        xscale: *mut c_double,
2164        yscale: *mut c_double,
2165    );
2166    #[cfg(feature = "v1_50")]
2167    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2168    pub fn pango_matrix_get_slant_ratio(matrix: *const PangoMatrix) -> c_double;
2169    pub fn pango_matrix_rotate(matrix: *mut PangoMatrix, degrees: c_double);
2170    pub fn pango_matrix_scale(matrix: *mut PangoMatrix, scale_x: c_double, scale_y: c_double);
2171    pub fn pango_matrix_transform_distance(
2172        matrix: *const PangoMatrix,
2173        dx: *mut c_double,
2174        dy: *mut c_double,
2175    );
2176    pub fn pango_matrix_transform_pixel_rectangle(
2177        matrix: *const PangoMatrix,
2178        rect: *mut PangoRectangle,
2179    );
2180    pub fn pango_matrix_transform_point(
2181        matrix: *const PangoMatrix,
2182        x: *mut c_double,
2183        y: *mut c_double,
2184    );
2185    pub fn pango_matrix_transform_rectangle(matrix: *const PangoMatrix, rect: *mut PangoRectangle);
2186    pub fn pango_matrix_translate(matrix: *mut PangoMatrix, tx: c_double, ty: c_double);
2187
2188    //=========================================================================
2189    // PangoScriptIter
2190    //=========================================================================
2191    #[cfg(feature = "v1_44")]
2192    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2193    pub fn pango_script_iter_get_type() -> GType;
2194    pub fn pango_script_iter_new(text: *const c_char, length: c_int) -> *mut PangoScriptIter;
2195    pub fn pango_script_iter_free(iter: *mut PangoScriptIter);
2196    pub fn pango_script_iter_get_range(
2197        iter: *mut PangoScriptIter,
2198        start: *mut *const c_char,
2199        end: *mut *const c_char,
2200        script: *mut PangoScript,
2201    );
2202    pub fn pango_script_iter_next(iter: *mut PangoScriptIter) -> gboolean;
2203
2204    //=========================================================================
2205    // PangoTabArray
2206    //=========================================================================
2207    pub fn pango_tab_array_get_type() -> GType;
2208    pub fn pango_tab_array_new(
2209        initial_size: c_int,
2210        positions_in_pixels: gboolean,
2211    ) -> *mut PangoTabArray;
2212    pub fn pango_tab_array_new_with_positions(
2213        size: c_int,
2214        positions_in_pixels: gboolean,
2215        first_alignment: PangoTabAlign,
2216        first_position: c_int,
2217        ...
2218    ) -> *mut PangoTabArray;
2219    pub fn pango_tab_array_copy(src: *mut PangoTabArray) -> *mut PangoTabArray;
2220    pub fn pango_tab_array_free(tab_array: *mut PangoTabArray);
2221    #[cfg(feature = "v1_50")]
2222    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2223    pub fn pango_tab_array_get_decimal_point(
2224        tab_array: *mut PangoTabArray,
2225        tab_index: c_int,
2226    ) -> u32;
2227    pub fn pango_tab_array_get_positions_in_pixels(tab_array: *mut PangoTabArray) -> gboolean;
2228    pub fn pango_tab_array_get_size(tab_array: *mut PangoTabArray) -> c_int;
2229    pub fn pango_tab_array_get_tab(
2230        tab_array: *mut PangoTabArray,
2231        tab_index: c_int,
2232        alignment: *mut PangoTabAlign,
2233        location: *mut c_int,
2234    );
2235    pub fn pango_tab_array_get_tabs(
2236        tab_array: *mut PangoTabArray,
2237        alignments: *mut *mut PangoTabAlign,
2238        locations: *mut *mut c_int,
2239    );
2240    pub fn pango_tab_array_resize(tab_array: *mut PangoTabArray, new_size: c_int);
2241    #[cfg(feature = "v1_50")]
2242    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2243    pub fn pango_tab_array_set_decimal_point(
2244        tab_array: *mut PangoTabArray,
2245        tab_index: c_int,
2246        decimal_point: u32,
2247    );
2248    #[cfg(feature = "v1_50")]
2249    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2250    pub fn pango_tab_array_set_positions_in_pixels(
2251        tab_array: *mut PangoTabArray,
2252        positions_in_pixels: gboolean,
2253    );
2254    pub fn pango_tab_array_set_tab(
2255        tab_array: *mut PangoTabArray,
2256        tab_index: c_int,
2257        alignment: PangoTabAlign,
2258        location: c_int,
2259    );
2260    #[cfg(feature = "v1_50")]
2261    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2262    pub fn pango_tab_array_sort(tab_array: *mut PangoTabArray);
2263    #[cfg(feature = "v1_50")]
2264    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2265    pub fn pango_tab_array_to_string(tab_array: *mut PangoTabArray) -> *mut c_char;
2266    #[cfg(feature = "v1_50")]
2267    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2268    pub fn pango_tab_array_from_string(text: *const c_char) -> *mut PangoTabArray;
2269
2270    //=========================================================================
2271    // PangoContext
2272    //=========================================================================
2273    pub fn pango_context_get_type() -> GType;
2274    pub fn pango_context_new() -> *mut PangoContext;
2275    pub fn pango_context_changed(context: *mut PangoContext);
2276    pub fn pango_context_get_base_dir(context: *mut PangoContext) -> PangoDirection;
2277    pub fn pango_context_get_base_gravity(context: *mut PangoContext) -> PangoGravity;
2278    pub fn pango_context_get_font_description(
2279        context: *mut PangoContext,
2280    ) -> *mut PangoFontDescription;
2281    pub fn pango_context_get_font_map(context: *mut PangoContext) -> *mut PangoFontMap;
2282    pub fn pango_context_get_gravity(context: *mut PangoContext) -> PangoGravity;
2283    pub fn pango_context_get_gravity_hint(context: *mut PangoContext) -> PangoGravityHint;
2284    pub fn pango_context_get_language(context: *mut PangoContext) -> *mut PangoLanguage;
2285    pub fn pango_context_get_matrix(context: *mut PangoContext) -> *const PangoMatrix;
2286    pub fn pango_context_get_metrics(
2287        context: *mut PangoContext,
2288        desc: *const PangoFontDescription,
2289        language: *mut PangoLanguage,
2290    ) -> *mut PangoFontMetrics;
2291    #[cfg(feature = "v1_44")]
2292    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2293    pub fn pango_context_get_round_glyph_positions(context: *mut PangoContext) -> gboolean;
2294    pub fn pango_context_get_serial(context: *mut PangoContext) -> c_uint;
2295    pub fn pango_context_list_families(
2296        context: *mut PangoContext,
2297        families: *mut *mut *mut PangoFontFamily,
2298        n_families: *mut c_int,
2299    );
2300    pub fn pango_context_load_font(
2301        context: *mut PangoContext,
2302        desc: *const PangoFontDescription,
2303    ) -> *mut PangoFont;
2304    pub fn pango_context_load_fontset(
2305        context: *mut PangoContext,
2306        desc: *const PangoFontDescription,
2307        language: *mut PangoLanguage,
2308    ) -> *mut PangoFontset;
2309    pub fn pango_context_set_base_dir(context: *mut PangoContext, direction: PangoDirection);
2310    pub fn pango_context_set_base_gravity(context: *mut PangoContext, gravity: PangoGravity);
2311    pub fn pango_context_set_font_description(
2312        context: *mut PangoContext,
2313        desc: *const PangoFontDescription,
2314    );
2315    pub fn pango_context_set_font_map(context: *mut PangoContext, font_map: *mut PangoFontMap);
2316    pub fn pango_context_set_gravity_hint(context: *mut PangoContext, hint: PangoGravityHint);
2317    pub fn pango_context_set_language(context: *mut PangoContext, language: *mut PangoLanguage);
2318    pub fn pango_context_set_matrix(context: *mut PangoContext, matrix: *const PangoMatrix);
2319    #[cfg(feature = "v1_44")]
2320    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2321    pub fn pango_context_set_round_glyph_positions(
2322        context: *mut PangoContext,
2323        round_positions: gboolean,
2324    );
2325
2326    //=========================================================================
2327    // PangoCoverage
2328    //=========================================================================
2329    #[cfg(feature = "v1_44")]
2330    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2331    pub fn pango_coverage_get_type() -> GType;
2332    pub fn pango_coverage_new() -> *mut PangoCoverage;
2333    pub fn pango_coverage_from_bytes(bytes: *mut u8, n_bytes: c_int) -> *mut PangoCoverage;
2334    pub fn pango_coverage_copy(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
2335    pub fn pango_coverage_get(coverage: *mut PangoCoverage, index_: c_int) -> PangoCoverageLevel;
2336    pub fn pango_coverage_max(coverage: *mut PangoCoverage, other: *mut PangoCoverage);
2337    pub fn pango_coverage_ref(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
2338    pub fn pango_coverage_set(
2339        coverage: *mut PangoCoverage,
2340        index_: c_int,
2341        level: PangoCoverageLevel,
2342    );
2343    pub fn pango_coverage_to_bytes(
2344        coverage: *mut PangoCoverage,
2345        bytes: *mut *mut u8,
2346        n_bytes: *mut c_int,
2347    );
2348    pub fn pango_coverage_unref(coverage: *mut PangoCoverage);
2349
2350    //=========================================================================
2351    // PangoFont
2352    //=========================================================================
2353    pub fn pango_font_get_type() -> GType;
2354    pub fn pango_font_descriptions_free(descs: *mut *mut PangoFontDescription, n_descs: c_int);
2355    #[cfg(feature = "v1_50")]
2356    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2357    pub fn pango_font_deserialize(
2358        context: *mut PangoContext,
2359        bytes: *mut glib::GBytes,
2360        error: *mut *mut glib::GError,
2361    ) -> *mut PangoFont;
2362    pub fn pango_font_describe(font: *mut PangoFont) -> *mut PangoFontDescription;
2363    pub fn pango_font_describe_with_absolute_size(
2364        font: *mut PangoFont,
2365    ) -> *mut PangoFontDescription;
2366    pub fn pango_font_get_coverage(
2367        font: *mut PangoFont,
2368        language: *mut PangoLanguage,
2369    ) -> *mut PangoCoverage;
2370    #[cfg(feature = "v1_46")]
2371    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2372    pub fn pango_font_get_face(font: *mut PangoFont) -> *mut PangoFontFace;
2373    #[cfg(feature = "v1_44")]
2374    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2375    pub fn pango_font_get_features(
2376        font: *mut PangoFont,
2377        features: gconstpointer,
2378        len: c_uint,
2379        num_features: *mut c_uint,
2380    );
2381    pub fn pango_font_get_font_map(font: *mut PangoFont) -> *mut PangoFontMap;
2382    pub fn pango_font_get_glyph_extents(
2383        font: *mut PangoFont,
2384        glyph: PangoGlyph,
2385        ink_rect: *mut PangoRectangle,
2386        logical_rect: *mut PangoRectangle,
2387    );
2388    #[cfg(feature = "v1_44")]
2389    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2390    pub fn pango_font_get_hb_font(font: *mut PangoFont) -> gconstpointer;
2391    #[cfg(feature = "v1_50")]
2392    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2393    pub fn pango_font_get_languages(font: *mut PangoFont) -> *mut *mut PangoLanguage;
2394    pub fn pango_font_get_metrics(
2395        font: *mut PangoFont,
2396        language: *mut PangoLanguage,
2397    ) -> *mut PangoFontMetrics;
2398    #[cfg(feature = "v1_44")]
2399    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2400    pub fn pango_font_has_char(font: *mut PangoFont, wc: u32) -> gboolean;
2401    #[cfg(feature = "v1_50")]
2402    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2403    pub fn pango_font_serialize(font: *mut PangoFont) -> *mut glib::GBytes;
2404
2405    //=========================================================================
2406    // PangoFontFace
2407    //=========================================================================
2408    pub fn pango_font_face_get_type() -> GType;
2409    pub fn pango_font_face_describe(face: *mut PangoFontFace) -> *mut PangoFontDescription;
2410    pub fn pango_font_face_get_face_name(face: *mut PangoFontFace) -> *const c_char;
2411    #[cfg(feature = "v1_46")]
2412    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2413    pub fn pango_font_face_get_family(face: *mut PangoFontFace) -> *mut PangoFontFamily;
2414    pub fn pango_font_face_is_synthesized(face: *mut PangoFontFace) -> gboolean;
2415    pub fn pango_font_face_list_sizes(
2416        face: *mut PangoFontFace,
2417        sizes: *mut *mut c_int,
2418        n_sizes: *mut c_int,
2419    );
2420
2421    //=========================================================================
2422    // PangoFontFamily
2423    //=========================================================================
2424    pub fn pango_font_family_get_type() -> GType;
2425    #[cfg(feature = "v1_46")]
2426    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2427    pub fn pango_font_family_get_face(
2428        family: *mut PangoFontFamily,
2429        name: *const c_char,
2430    ) -> *mut PangoFontFace;
2431    pub fn pango_font_family_get_name(family: *mut PangoFontFamily) -> *const c_char;
2432    pub fn pango_font_family_is_monospace(family: *mut PangoFontFamily) -> gboolean;
2433    #[cfg(feature = "v1_44")]
2434    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2435    pub fn pango_font_family_is_variable(family: *mut PangoFontFamily) -> gboolean;
2436    pub fn pango_font_family_list_faces(
2437        family: *mut PangoFontFamily,
2438        faces: *mut *mut *mut PangoFontFace,
2439        n_faces: *mut c_int,
2440    );
2441
2442    //=========================================================================
2443    // PangoFontMap
2444    //=========================================================================
2445    pub fn pango_font_map_get_type() -> GType;
2446    #[cfg(feature = "v1_56")]
2447    #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
2448    pub fn pango_font_map_add_font_file(
2449        fontmap: *mut PangoFontMap,
2450        filename: *const c_char,
2451        error: *mut *mut glib::GError,
2452    ) -> gboolean;
2453    pub fn pango_font_map_changed(fontmap: *mut PangoFontMap);
2454    pub fn pango_font_map_create_context(fontmap: *mut PangoFontMap) -> *mut PangoContext;
2455    #[cfg(feature = "v1_46")]
2456    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2457    pub fn pango_font_map_get_family(
2458        fontmap: *mut PangoFontMap,
2459        name: *const c_char,
2460    ) -> *mut PangoFontFamily;
2461    pub fn pango_font_map_get_serial(fontmap: *mut PangoFontMap) -> c_uint;
2462    pub fn pango_font_map_list_families(
2463        fontmap: *mut PangoFontMap,
2464        families: *mut *mut *mut PangoFontFamily,
2465        n_families: *mut c_int,
2466    );
2467    pub fn pango_font_map_load_font(
2468        fontmap: *mut PangoFontMap,
2469        context: *mut PangoContext,
2470        desc: *const PangoFontDescription,
2471    ) -> *mut PangoFont;
2472    pub fn pango_font_map_load_fontset(
2473        fontmap: *mut PangoFontMap,
2474        context: *mut PangoContext,
2475        desc: *const PangoFontDescription,
2476        language: *mut PangoLanguage,
2477    ) -> *mut PangoFontset;
2478    #[cfg(feature = "v1_52")]
2479    #[cfg_attr(docsrs, doc(cfg(feature = "v1_52")))]
2480    pub fn pango_font_map_reload_font(
2481        fontmap: *mut PangoFontMap,
2482        font: *mut PangoFont,
2483        scale: c_double,
2484        context: *mut PangoContext,
2485        variations: *const c_char,
2486    ) -> *mut PangoFont;
2487
2488    //=========================================================================
2489    // PangoFontset
2490    //=========================================================================
2491    pub fn pango_fontset_get_type() -> GType;
2492    pub fn pango_fontset_foreach(
2493        fontset: *mut PangoFontset,
2494        func: PangoFontsetForeachFunc,
2495        data: gpointer,
2496    );
2497    pub fn pango_fontset_get_font(fontset: *mut PangoFontset, wc: c_uint) -> *mut PangoFont;
2498    pub fn pango_fontset_get_metrics(fontset: *mut PangoFontset) -> *mut PangoFontMetrics;
2499
2500    //=========================================================================
2501    // PangoFontsetSimple
2502    //=========================================================================
2503    pub fn pango_fontset_simple_get_type() -> GType;
2504    pub fn pango_fontset_simple_new(language: *mut PangoLanguage) -> *mut PangoFontsetSimple;
2505    pub fn pango_fontset_simple_append(fontset: *mut PangoFontsetSimple, font: *mut PangoFont);
2506    pub fn pango_fontset_simple_size(fontset: *mut PangoFontsetSimple) -> c_int;
2507
2508    //=========================================================================
2509    // PangoLayout
2510    //=========================================================================
2511    pub fn pango_layout_get_type() -> GType;
2512    pub fn pango_layout_new(context: *mut PangoContext) -> *mut PangoLayout;
2513    #[cfg(feature = "v1_50")]
2514    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2515    pub fn pango_layout_deserialize(
2516        context: *mut PangoContext,
2517        bytes: *mut glib::GBytes,
2518        flags: PangoLayoutDeserializeFlags,
2519        error: *mut *mut glib::GError,
2520    ) -> *mut PangoLayout;
2521    pub fn pango_layout_context_changed(layout: *mut PangoLayout);
2522    pub fn pango_layout_copy(src: *mut PangoLayout) -> *mut PangoLayout;
2523    pub fn pango_layout_get_alignment(layout: *mut PangoLayout) -> PangoAlignment;
2524    pub fn pango_layout_get_attributes(layout: *mut PangoLayout) -> *mut PangoAttrList;
2525    pub fn pango_layout_get_auto_dir(layout: *mut PangoLayout) -> gboolean;
2526    pub fn pango_layout_get_baseline(layout: *mut PangoLayout) -> c_int;
2527    #[cfg(feature = "v1_50")]
2528    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2529    pub fn pango_layout_get_caret_pos(
2530        layout: *mut PangoLayout,
2531        index_: c_int,
2532        strong_pos: *mut PangoRectangle,
2533        weak_pos: *mut PangoRectangle,
2534    );
2535    pub fn pango_layout_get_character_count(layout: *mut PangoLayout) -> c_int;
2536    pub fn pango_layout_get_context(layout: *mut PangoLayout) -> *mut PangoContext;
2537    pub fn pango_layout_get_cursor_pos(
2538        layout: *mut PangoLayout,
2539        index_: c_int,
2540        strong_pos: *mut PangoRectangle,
2541        weak_pos: *mut PangoRectangle,
2542    );
2543    #[cfg(feature = "v1_46")]
2544    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2545    pub fn pango_layout_get_direction(layout: *mut PangoLayout, index: c_int) -> PangoDirection;
2546    pub fn pango_layout_get_ellipsize(layout: *mut PangoLayout) -> PangoEllipsizeMode;
2547    pub fn pango_layout_get_extents(
2548        layout: *mut PangoLayout,
2549        ink_rect: *mut PangoRectangle,
2550        logical_rect: *mut PangoRectangle,
2551    );
2552    pub fn pango_layout_get_font_description(
2553        layout: *mut PangoLayout,
2554    ) -> *const PangoFontDescription;
2555    pub fn pango_layout_get_height(layout: *mut PangoLayout) -> c_int;
2556    pub fn pango_layout_get_indent(layout: *mut PangoLayout) -> c_int;
2557    pub fn pango_layout_get_iter(layout: *mut PangoLayout) -> *mut PangoLayoutIter;
2558    pub fn pango_layout_get_justify(layout: *mut PangoLayout) -> gboolean;
2559    #[cfg(feature = "v1_50")]
2560    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2561    pub fn pango_layout_get_justify_last_line(layout: *mut PangoLayout) -> gboolean;
2562    pub fn pango_layout_get_line(layout: *mut PangoLayout, line: c_int) -> *mut PangoLayoutLine;
2563    pub fn pango_layout_get_line_count(layout: *mut PangoLayout) -> c_int;
2564    pub fn pango_layout_get_line_readonly(
2565        layout: *mut PangoLayout,
2566        line: c_int,
2567    ) -> *mut PangoLayoutLine;
2568    #[cfg(feature = "v1_44")]
2569    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2570    pub fn pango_layout_get_line_spacing(layout: *mut PangoLayout) -> c_float;
2571    pub fn pango_layout_get_lines(layout: *mut PangoLayout) -> *mut glib::GSList;
2572    pub fn pango_layout_get_lines_readonly(layout: *mut PangoLayout) -> *mut glib::GSList;
2573    pub fn pango_layout_get_log_attrs(
2574        layout: *mut PangoLayout,
2575        attrs: *mut *mut PangoLogAttr,
2576        n_attrs: *mut c_int,
2577    );
2578    pub fn pango_layout_get_log_attrs_readonly(
2579        layout: *mut PangoLayout,
2580        n_attrs: *mut c_int,
2581    ) -> *const PangoLogAttr;
2582    pub fn pango_layout_get_pixel_extents(
2583        layout: *mut PangoLayout,
2584        ink_rect: *mut PangoRectangle,
2585        logical_rect: *mut PangoRectangle,
2586    );
2587    pub fn pango_layout_get_pixel_size(
2588        layout: *mut PangoLayout,
2589        width: *mut c_int,
2590        height: *mut c_int,
2591    );
2592    pub fn pango_layout_get_serial(layout: *mut PangoLayout) -> c_uint;
2593    pub fn pango_layout_get_single_paragraph_mode(layout: *mut PangoLayout) -> gboolean;
2594    pub fn pango_layout_get_size(layout: *mut PangoLayout, width: *mut c_int, height: *mut c_int);
2595    pub fn pango_layout_get_spacing(layout: *mut PangoLayout) -> c_int;
2596    pub fn pango_layout_get_tabs(layout: *mut PangoLayout) -> *mut PangoTabArray;
2597    pub fn pango_layout_get_text(layout: *mut PangoLayout) -> *const c_char;
2598    pub fn pango_layout_get_unknown_glyphs_count(layout: *mut PangoLayout) -> c_int;
2599    pub fn pango_layout_get_width(layout: *mut PangoLayout) -> c_int;
2600    pub fn pango_layout_get_wrap(layout: *mut PangoLayout) -> PangoWrapMode;
2601    pub fn pango_layout_index_to_line_x(
2602        layout: *mut PangoLayout,
2603        index_: c_int,
2604        trailing: gboolean,
2605        line: *mut c_int,
2606        x_pos: *mut c_int,
2607    );
2608    pub fn pango_layout_index_to_pos(
2609        layout: *mut PangoLayout,
2610        index_: c_int,
2611        pos: *mut PangoRectangle,
2612    );
2613    pub fn pango_layout_is_ellipsized(layout: *mut PangoLayout) -> gboolean;
2614    pub fn pango_layout_is_wrapped(layout: *mut PangoLayout) -> gboolean;
2615    pub fn pango_layout_move_cursor_visually(
2616        layout: *mut PangoLayout,
2617        strong: gboolean,
2618        old_index: c_int,
2619        old_trailing: c_int,
2620        direction: c_int,
2621        new_index: *mut c_int,
2622        new_trailing: *mut c_int,
2623    );
2624    #[cfg(feature = "v1_50")]
2625    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2626    pub fn pango_layout_serialize(
2627        layout: *mut PangoLayout,
2628        flags: PangoLayoutSerializeFlags,
2629    ) -> *mut glib::GBytes;
2630    pub fn pango_layout_set_alignment(layout: *mut PangoLayout, alignment: PangoAlignment);
2631    pub fn pango_layout_set_attributes(layout: *mut PangoLayout, attrs: *mut PangoAttrList);
2632    pub fn pango_layout_set_auto_dir(layout: *mut PangoLayout, auto_dir: gboolean);
2633    pub fn pango_layout_set_ellipsize(layout: *mut PangoLayout, ellipsize: PangoEllipsizeMode);
2634    pub fn pango_layout_set_font_description(
2635        layout: *mut PangoLayout,
2636        desc: *const PangoFontDescription,
2637    );
2638    pub fn pango_layout_set_height(layout: *mut PangoLayout, height: c_int);
2639    pub fn pango_layout_set_indent(layout: *mut PangoLayout, indent: c_int);
2640    pub fn pango_layout_set_justify(layout: *mut PangoLayout, justify: gboolean);
2641    #[cfg(feature = "v1_50")]
2642    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2643    pub fn pango_layout_set_justify_last_line(layout: *mut PangoLayout, justify: gboolean);
2644    #[cfg(feature = "v1_44")]
2645    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2646    pub fn pango_layout_set_line_spacing(layout: *mut PangoLayout, factor: c_float);
2647    pub fn pango_layout_set_markup(layout: *mut PangoLayout, markup: *const c_char, length: c_int);
2648    pub fn pango_layout_set_markup_with_accel(
2649        layout: *mut PangoLayout,
2650        markup: *const c_char,
2651        length: c_int,
2652        accel_marker: u32,
2653        accel_char: *mut u32,
2654    );
2655    pub fn pango_layout_set_single_paragraph_mode(layout: *mut PangoLayout, setting: gboolean);
2656    pub fn pango_layout_set_spacing(layout: *mut PangoLayout, spacing: c_int);
2657    pub fn pango_layout_set_tabs(layout: *mut PangoLayout, tabs: *mut PangoTabArray);
2658    pub fn pango_layout_set_text(layout: *mut PangoLayout, text: *const c_char, length: c_int);
2659    pub fn pango_layout_set_width(layout: *mut PangoLayout, width: c_int);
2660    pub fn pango_layout_set_wrap(layout: *mut PangoLayout, wrap: PangoWrapMode);
2661    #[cfg(feature = "v1_50")]
2662    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2663    pub fn pango_layout_write_to_file(
2664        layout: *mut PangoLayout,
2665        flags: PangoLayoutSerializeFlags,
2666        filename: *const c_char,
2667        error: *mut *mut glib::GError,
2668    ) -> gboolean;
2669    pub fn pango_layout_xy_to_index(
2670        layout: *mut PangoLayout,
2671        x: c_int,
2672        y: c_int,
2673        index_: *mut c_int,
2674        trailing: *mut c_int,
2675    ) -> gboolean;
2676
2677    //=========================================================================
2678    // PangoRenderer
2679    //=========================================================================
2680    pub fn pango_renderer_get_type() -> GType;
2681    pub fn pango_renderer_activate(renderer: *mut PangoRenderer);
2682    pub fn pango_renderer_deactivate(renderer: *mut PangoRenderer);
2683    pub fn pango_renderer_draw_error_underline(
2684        renderer: *mut PangoRenderer,
2685        x: c_int,
2686        y: c_int,
2687        width: c_int,
2688        height: c_int,
2689    );
2690    pub fn pango_renderer_draw_glyph(
2691        renderer: *mut PangoRenderer,
2692        font: *mut PangoFont,
2693        glyph: PangoGlyph,
2694        x: c_double,
2695        y: c_double,
2696    );
2697    pub fn pango_renderer_draw_glyph_item(
2698        renderer: *mut PangoRenderer,
2699        text: *const c_char,
2700        glyph_item: *mut PangoGlyphItem,
2701        x: c_int,
2702        y: c_int,
2703    );
2704    pub fn pango_renderer_draw_glyphs(
2705        renderer: *mut PangoRenderer,
2706        font: *mut PangoFont,
2707        glyphs: *mut PangoGlyphString,
2708        x: c_int,
2709        y: c_int,
2710    );
2711    pub fn pango_renderer_draw_layout(
2712        renderer: *mut PangoRenderer,
2713        layout: *mut PangoLayout,
2714        x: c_int,
2715        y: c_int,
2716    );
2717    pub fn pango_renderer_draw_layout_line(
2718        renderer: *mut PangoRenderer,
2719        line: *mut PangoLayoutLine,
2720        x: c_int,
2721        y: c_int,
2722    );
2723    pub fn pango_renderer_draw_rectangle(
2724        renderer: *mut PangoRenderer,
2725        part: PangoRenderPart,
2726        x: c_int,
2727        y: c_int,
2728        width: c_int,
2729        height: c_int,
2730    );
2731    pub fn pango_renderer_draw_trapezoid(
2732        renderer: *mut PangoRenderer,
2733        part: PangoRenderPart,
2734        y1_: c_double,
2735        x11: c_double,
2736        x21: c_double,
2737        y2: c_double,
2738        x12: c_double,
2739        x22: c_double,
2740    );
2741    pub fn pango_renderer_get_alpha(renderer: *mut PangoRenderer, part: PangoRenderPart) -> u16;
2742    pub fn pango_renderer_get_color(
2743        renderer: *mut PangoRenderer,
2744        part: PangoRenderPart,
2745    ) -> *mut PangoColor;
2746    pub fn pango_renderer_get_layout(renderer: *mut PangoRenderer) -> *mut PangoLayout;
2747    pub fn pango_renderer_get_layout_line(renderer: *mut PangoRenderer) -> *mut PangoLayoutLine;
2748    pub fn pango_renderer_get_matrix(renderer: *mut PangoRenderer) -> *const PangoMatrix;
2749    pub fn pango_renderer_part_changed(renderer: *mut PangoRenderer, part: PangoRenderPart);
2750    pub fn pango_renderer_set_alpha(
2751        renderer: *mut PangoRenderer,
2752        part: PangoRenderPart,
2753        alpha: u16,
2754    );
2755    pub fn pango_renderer_set_color(
2756        renderer: *mut PangoRenderer,
2757        part: PangoRenderPart,
2758        color: *const PangoColor,
2759    );
2760    pub fn pango_renderer_set_matrix(renderer: *mut PangoRenderer, matrix: *const PangoMatrix);
2761
2762    //=========================================================================
2763    // Other functions
2764    //=========================================================================
2765    #[cfg(feature = "v1_44")]
2766    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2767    pub fn pango_attr_allow_breaks_new(allow_breaks: gboolean) -> *mut PangoAttribute;
2768    pub fn pango_attr_background_alpha_new(alpha: u16) -> *mut PangoAttribute;
2769    pub fn pango_attr_background_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
2770    #[cfg(feature = "v1_50")]
2771    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2772    pub fn pango_attr_baseline_shift_new(shift: c_int) -> *mut PangoAttribute;
2773    #[cfg(feature = "v1_50")]
2774    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2775    pub fn pango_attr_break(
2776        text: *const c_char,
2777        length: c_int,
2778        attr_list: *mut PangoAttrList,
2779        offset: c_int,
2780        attrs: *mut PangoLogAttr,
2781        attrs_len: c_int,
2782    );
2783    pub fn pango_attr_fallback_new(enable_fallback: gboolean) -> *mut PangoAttribute;
2784    pub fn pango_attr_family_new(family: *const c_char) -> *mut PangoAttribute;
2785    #[cfg(feature = "v1_50")]
2786    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2787    pub fn pango_attr_font_scale_new(scale: PangoFontScale) -> *mut PangoAttribute;
2788    pub fn pango_attr_foreground_alpha_new(alpha: u16) -> *mut PangoAttribute;
2789    pub fn pango_attr_foreground_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
2790    pub fn pango_attr_gravity_hint_new(hint: PangoGravityHint) -> *mut PangoAttribute;
2791    pub fn pango_attr_gravity_new(gravity: PangoGravity) -> *mut PangoAttribute;
2792    #[cfg(feature = "v1_44")]
2793    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2794    pub fn pango_attr_insert_hyphens_new(insert_hyphens: gboolean) -> *mut PangoAttribute;
2795    pub fn pango_attr_letter_spacing_new(letter_spacing: c_int) -> *mut PangoAttribute;
2796    #[cfg(feature = "v1_50")]
2797    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2798    pub fn pango_attr_line_height_new(factor: c_double) -> *mut PangoAttribute;
2799    #[cfg(feature = "v1_50")]
2800    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2801    pub fn pango_attr_line_height_new_absolute(height: c_int) -> *mut PangoAttribute;
2802    #[cfg(feature = "v1_46")]
2803    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2804    pub fn pango_attr_overline_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
2805    #[cfg(feature = "v1_46")]
2806    #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
2807    pub fn pango_attr_overline_new(overline: PangoOverline) -> *mut PangoAttribute;
2808    pub fn pango_attr_rise_new(rise: c_int) -> *mut PangoAttribute;
2809    pub fn pango_attr_scale_new(scale_factor: c_double) -> *mut PangoAttribute;
2810    #[cfg(feature = "v1_50")]
2811    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2812    pub fn pango_attr_sentence_new() -> *mut PangoAttribute;
2813    #[cfg(feature = "v1_44")]
2814    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2815    pub fn pango_attr_show_new(flags: PangoShowFlags) -> *mut PangoAttribute;
2816    pub fn pango_attr_stretch_new(stretch: PangoStretch) -> *mut PangoAttribute;
2817    pub fn pango_attr_strikethrough_color_new(
2818        red: u16,
2819        green: u16,
2820        blue: u16,
2821    ) -> *mut PangoAttribute;
2822    pub fn pango_attr_strikethrough_new(strikethrough: gboolean) -> *mut PangoAttribute;
2823    pub fn pango_attr_style_new(style: PangoStyle) -> *mut PangoAttribute;
2824    #[cfg(feature = "v1_50")]
2825    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2826    pub fn pango_attr_text_transform_new(transform: PangoTextTransform) -> *mut PangoAttribute;
2827    pub fn pango_attr_underline_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
2828    pub fn pango_attr_underline_new(underline: PangoUnderline) -> *mut PangoAttribute;
2829    pub fn pango_attr_variant_new(variant: PangoVariant) -> *mut PangoAttribute;
2830    pub fn pango_attr_weight_new(weight: PangoWeight) -> *mut PangoAttribute;
2831    #[cfg(feature = "v1_50")]
2832    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2833    pub fn pango_attr_word_new() -> *mut PangoAttribute;
2834    pub fn pango_break(
2835        text: *const c_char,
2836        length: c_int,
2837        analysis: *mut PangoAnalysis,
2838        attrs: *mut PangoLogAttr,
2839        attrs_len: c_int,
2840    );
2841    pub fn pango_default_break(
2842        text: *const c_char,
2843        length: c_int,
2844        analysis: *mut PangoAnalysis,
2845        attrs: *mut PangoLogAttr,
2846        attrs_len: c_int,
2847    );
2848    pub fn pango_extents_to_pixels(inclusive: *mut PangoRectangle, nearest: *mut PangoRectangle);
2849    pub fn pango_find_base_dir(text: *const c_char, length: c_int) -> PangoDirection;
2850    pub fn pango_find_paragraph_boundary(
2851        text: *const c_char,
2852        length: c_int,
2853        paragraph_delimiter_index: *mut c_int,
2854        next_paragraph_start: *mut c_int,
2855    );
2856    pub fn pango_get_log_attrs(
2857        text: *const c_char,
2858        length: c_int,
2859        level: c_int,
2860        language: *mut PangoLanguage,
2861        attrs: *mut PangoLogAttr,
2862        attrs_len: c_int,
2863    );
2864    pub fn pango_get_mirror_char(ch: u32, mirrored_ch: *mut u32) -> gboolean;
2865    pub fn pango_is_zero_width(ch: u32) -> gboolean;
2866    pub fn pango_itemize(
2867        context: *mut PangoContext,
2868        text: *const c_char,
2869        start_index: c_int,
2870        length: c_int,
2871        attrs: *mut PangoAttrList,
2872        cached_iter: *mut PangoAttrIterator,
2873    ) -> *mut glib::GList;
2874    pub fn pango_itemize_with_base_dir(
2875        context: *mut PangoContext,
2876        base_dir: PangoDirection,
2877        text: *const c_char,
2878        start_index: c_int,
2879        length: c_int,
2880        attrs: *mut PangoAttrList,
2881        cached_iter: *mut PangoAttrIterator,
2882    ) -> *mut glib::GList;
2883    pub fn pango_log2vis_get_embedding_levels(
2884        text: *const c_char,
2885        length: c_int,
2886        pbase_dir: *mut PangoDirection,
2887    ) -> *mut u8;
2888    pub fn pango_markup_parser_finish(
2889        context: *mut glib::GMarkupParseContext,
2890        attr_list: *mut *mut PangoAttrList,
2891        text: *mut *mut c_char,
2892        accel_char: *mut u32,
2893        error: *mut *mut glib::GError,
2894    ) -> gboolean;
2895    pub fn pango_markup_parser_new(accel_marker: u32) -> *mut glib::GMarkupParseContext;
2896    pub fn pango_parse_enum(
2897        type_: GType,
2898        str: *const c_char,
2899        value: *mut c_int,
2900        warn: gboolean,
2901        possible_values: *mut *mut c_char,
2902    ) -> gboolean;
2903    pub fn pango_parse_markup(
2904        markup_text: *const c_char,
2905        length: c_int,
2906        accel_marker: u32,
2907        attr_list: *mut *mut PangoAttrList,
2908        text: *mut *mut c_char,
2909        accel_char: *mut u32,
2910        error: *mut *mut glib::GError,
2911    ) -> gboolean;
2912    pub fn pango_parse_stretch(
2913        str: *const c_char,
2914        stretch: *mut PangoStretch,
2915        warn: gboolean,
2916    ) -> gboolean;
2917    pub fn pango_parse_style(
2918        str: *const c_char,
2919        style: *mut PangoStyle,
2920        warn: gboolean,
2921    ) -> gboolean;
2922    pub fn pango_parse_variant(
2923        str: *const c_char,
2924        variant: *mut PangoVariant,
2925        warn: gboolean,
2926    ) -> gboolean;
2927    pub fn pango_parse_weight(
2928        str: *const c_char,
2929        weight: *mut PangoWeight,
2930        warn: gboolean,
2931    ) -> gboolean;
2932    pub fn pango_quantize_line_geometry(thickness: *mut c_int, position: *mut c_int);
2933    pub fn pango_read_line(stream: *mut FILE, str: *mut glib::GString) -> c_int;
2934    pub fn pango_reorder_items(items: *mut glib::GList) -> *mut glib::GList;
2935    pub fn pango_scan_int(pos: *mut *const c_char, out: *mut c_int) -> gboolean;
2936    pub fn pango_scan_string(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
2937    pub fn pango_scan_word(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
2938    pub fn pango_shape(
2939        text: *const c_char,
2940        length: c_int,
2941        analysis: *const PangoAnalysis,
2942        glyphs: *mut PangoGlyphString,
2943    );
2944    pub fn pango_shape_full(
2945        item_text: *const c_char,
2946        item_length: c_int,
2947        paragraph_text: *const c_char,
2948        paragraph_length: c_int,
2949        analysis: *const PangoAnalysis,
2950        glyphs: *mut PangoGlyphString,
2951    );
2952    #[cfg(feature = "v1_50")]
2953    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2954    pub fn pango_shape_item(
2955        item: *mut PangoItem,
2956        paragraph_text: *const c_char,
2957        paragraph_length: c_int,
2958        log_attrs: *mut PangoLogAttr,
2959        glyphs: *mut PangoGlyphString,
2960        flags: PangoShapeFlags,
2961    );
2962    #[cfg(feature = "v1_44")]
2963    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2964    pub fn pango_shape_with_flags(
2965        item_text: *const c_char,
2966        item_length: c_int,
2967        paragraph_text: *const c_char,
2968        paragraph_length: c_int,
2969        analysis: *const PangoAnalysis,
2970        glyphs: *mut PangoGlyphString,
2971        flags: PangoShapeFlags,
2972    );
2973    pub fn pango_skip_space(pos: *mut *const c_char) -> gboolean;
2974    pub fn pango_split_file_list(str: *const c_char) -> *mut *mut c_char;
2975    #[cfg(feature = "v1_44")]
2976    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
2977    pub fn pango_tailor_break(
2978        text: *const c_char,
2979        length: c_int,
2980        analysis: *mut PangoAnalysis,
2981        offset: c_int,
2982        attrs: *mut PangoLogAttr,
2983        attrs_len: c_int,
2984    );
2985    pub fn pango_trim_string(str: *const c_char) -> *mut c_char;
2986    pub fn pango_unichar_direction(ch: u32) -> PangoDirection;
2987    pub fn pango_units_from_double(d: c_double) -> c_int;
2988    pub fn pango_units_to_double(i: c_int) -> c_double;
2989    pub fn pango_version() -> c_int;
2990    pub fn pango_version_check(
2991        required_major: c_int,
2992        required_minor: c_int,
2993        required_micro: c_int,
2994    ) -> *const c_char;
2995    pub fn pango_version_string() -> *const c_char;
2996
2997}