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