1#![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
25pub type PangoGlyph = u32;
27pub type PangoGlyphUnit = i32;
28pub type PangoLayoutRun = PangoGlyphItem;
29
30pub 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
293pub 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
311pub 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
322pub 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#[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 }
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 }
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#[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 pub fn pango_alignment_get_type() -> GType;
1433
1434 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 pub fn pango_bidi_type_get_type() -> GType;
1445 pub fn pango_bidi_type_for_unichar(ch: u32) -> PangoBidiType;
1446
1447 pub fn pango_coverage_level_get_type() -> GType;
1451
1452 pub fn pango_direction_get_type() -> GType;
1456
1457 pub fn pango_ellipsize_mode_get_type() -> GType;
1461
1462 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 pub fn pango_gravity_hint_get_type() -> GType;
1484
1485 pub fn pango_render_part_get_type() -> GType;
1489
1490 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 pub fn pango_stretch_get_type() -> GType;
1501
1502 pub fn pango_style_get_type() -> GType;
1506
1507 pub fn pango_tab_align_get_type() -> GType;
1511
1512 pub fn pango_underline_get_type() -> GType;
1516
1517 pub fn pango_variant_get_type() -> GType;
1521
1522 pub fn pango_weight_get_type() -> GType;
1526
1527 pub fn pango_wrap_mode_get_type() -> GType;
1531
1532 pub fn pango_font_mask_get_type() -> GType;
1536
1537 pub fn pango_attr_font_desc_new(desc: *const PangoFontDescription) -> *mut PangoAttribute;
1541
1542 #[cfg(any(feature = "v1_38", feature = "dox"))]
1546 pub fn pango_attr_font_features_new(features: *const c_char) -> *mut PangoAttribute;
1547
1548 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 pub fn pango_attr_language_new(language: *mut PangoLanguage) -> *mut PangoAttribute;
1575
1576 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 pub fn pango_engine_get_type() -> GType;
2132
2133 pub fn pango_engine_lang_get_type() -> GType;
2137
2138 pub fn pango_engine_shape_get_type() -> GType;
2142
2143 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 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 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 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 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 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 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 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 #[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}