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