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