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