1use crate::{ffi, Language, Matrix};
6use glib::{prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9#[non_exhaustive]
10#[doc(alias = "PangoAlignment")]
11pub enum Alignment {
12 #[doc(alias = "PANGO_ALIGN_LEFT")]
13 Left,
14 #[doc(alias = "PANGO_ALIGN_CENTER")]
15 Center,
16 #[doc(alias = "PANGO_ALIGN_RIGHT")]
17 Right,
18 #[doc(hidden)]
19 __Unknown(i32),
20}
21
22#[doc(hidden)]
23impl IntoGlib for Alignment {
24 type GlibType = ffi::PangoAlignment;
25
26 #[inline]
27 fn into_glib(self) -> ffi::PangoAlignment {
28 match self {
29 Self::Left => ffi::PANGO_ALIGN_LEFT,
30 Self::Center => ffi::PANGO_ALIGN_CENTER,
31 Self::Right => ffi::PANGO_ALIGN_RIGHT,
32 Self::__Unknown(value) => value,
33 }
34 }
35}
36
37#[doc(hidden)]
38impl FromGlib<ffi::PangoAlignment> for Alignment {
39 #[inline]
40 unsafe fn from_glib(value: ffi::PangoAlignment) -> Self {
41 match value {
42 ffi::PANGO_ALIGN_LEFT => Self::Left,
43 ffi::PANGO_ALIGN_CENTER => Self::Center,
44 ffi::PANGO_ALIGN_RIGHT => Self::Right,
45 value => Self::__Unknown(value),
46 }
47 }
48}
49
50impl StaticType for Alignment {
51 #[inline]
52 #[doc(alias = "pango_alignment_get_type")]
53 fn static_type() -> glib::Type {
54 unsafe { from_glib(ffi::pango_alignment_get_type()) }
55 }
56}
57
58impl glib::HasParamSpec for Alignment {
59 type ParamSpec = glib::ParamSpecEnum;
60 type SetValue = Self;
61 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
62
63 fn param_spec_builder() -> Self::BuilderFn {
64 Self::ParamSpec::builder_with_default
65 }
66}
67
68impl glib::value::ValueType for Alignment {
69 type Type = Self;
70}
71
72unsafe impl<'a> glib::value::FromValue<'a> for Alignment {
73 type Checker = glib::value::GenericValueTypeChecker<Self>;
74
75 #[inline]
76 unsafe fn from_value(value: &'a glib::Value) -> Self {
77 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
78 }
79}
80
81impl ToValue for Alignment {
82 #[inline]
83 fn to_value(&self) -> glib::Value {
84 let mut value = glib::Value::for_value_type::<Self>();
85 unsafe {
86 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
87 }
88 value
89 }
90
91 #[inline]
92 fn value_type(&self) -> glib::Type {
93 Self::static_type()
94 }
95}
96
97impl From<Alignment> for glib::Value {
98 #[inline]
99 fn from(v: Alignment) -> Self {
100 ToValue::to_value(&v)
101 }
102}
103
104#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
105#[non_exhaustive]
106#[doc(alias = "PangoAttrType")]
107pub enum AttrType {
108 #[doc(alias = "PANGO_ATTR_INVALID")]
109 Invalid,
110 #[doc(alias = "PANGO_ATTR_LANGUAGE")]
111 Language,
112 #[doc(alias = "PANGO_ATTR_FAMILY")]
113 Family,
114 #[doc(alias = "PANGO_ATTR_STYLE")]
115 Style,
116 #[doc(alias = "PANGO_ATTR_WEIGHT")]
117 Weight,
118 #[doc(alias = "PANGO_ATTR_VARIANT")]
119 Variant,
120 #[doc(alias = "PANGO_ATTR_STRETCH")]
121 Stretch,
122 #[doc(alias = "PANGO_ATTR_SIZE")]
123 Size,
124 #[doc(alias = "PANGO_ATTR_FONT_DESC")]
125 FontDesc,
126 #[doc(alias = "PANGO_ATTR_FOREGROUND")]
127 Foreground,
128 #[doc(alias = "PANGO_ATTR_BACKGROUND")]
129 Background,
130 #[doc(alias = "PANGO_ATTR_UNDERLINE")]
131 Underline,
132 #[doc(alias = "PANGO_ATTR_STRIKETHROUGH")]
133 Strikethrough,
134 #[doc(alias = "PANGO_ATTR_RISE")]
135 Rise,
136 #[doc(alias = "PANGO_ATTR_SHAPE")]
137 Shape,
138 #[doc(alias = "PANGO_ATTR_SCALE")]
139 Scale,
140 #[doc(alias = "PANGO_ATTR_FALLBACK")]
141 Fallback,
142 #[doc(alias = "PANGO_ATTR_LETTER_SPACING")]
143 LetterSpacing,
144 #[doc(alias = "PANGO_ATTR_UNDERLINE_COLOR")]
145 UnderlineColor,
146 #[doc(alias = "PANGO_ATTR_STRIKETHROUGH_COLOR")]
147 StrikethroughColor,
148 #[doc(alias = "PANGO_ATTR_ABSOLUTE_SIZE")]
149 AbsoluteSize,
150 #[doc(alias = "PANGO_ATTR_GRAVITY")]
151 Gravity,
152 #[doc(alias = "PANGO_ATTR_GRAVITY_HINT")]
153 GravityHint,
154 #[doc(alias = "PANGO_ATTR_FONT_FEATURES")]
155 FontFeatures,
156 #[doc(alias = "PANGO_ATTR_FOREGROUND_ALPHA")]
157 ForegroundAlpha,
158 #[doc(alias = "PANGO_ATTR_BACKGROUND_ALPHA")]
159 BackgroundAlpha,
160 #[doc(alias = "PANGO_ATTR_ALLOW_BREAKS")]
161 AllowBreaks,
162 #[doc(alias = "PANGO_ATTR_SHOW")]
163 Show,
164 #[doc(alias = "PANGO_ATTR_INSERT_HYPHENS")]
165 InsertHyphens,
166 #[doc(alias = "PANGO_ATTR_OVERLINE")]
167 Overline,
168 #[doc(alias = "PANGO_ATTR_OVERLINE_COLOR")]
169 OverlineColor,
170 #[cfg(feature = "v1_50")]
171 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
172 #[doc(alias = "PANGO_ATTR_LINE_HEIGHT")]
173 LineHeight,
174 #[cfg(feature = "v1_50")]
175 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
176 #[doc(alias = "PANGO_ATTR_ABSOLUTE_LINE_HEIGHT")]
177 AbsoluteLineHeight,
178 #[cfg(feature = "v1_50")]
179 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
180 #[doc(alias = "PANGO_ATTR_TEXT_TRANSFORM")]
181 TextTransform,
182 #[cfg(feature = "v1_50")]
183 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
184 #[doc(alias = "PANGO_ATTR_WORD")]
185 Word,
186 #[cfg(feature = "v1_50")]
187 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
188 #[doc(alias = "PANGO_ATTR_SENTENCE")]
189 Sentence,
190 #[cfg(feature = "v1_50")]
191 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
192 #[doc(alias = "PANGO_ATTR_BASELINE_SHIFT")]
193 BaselineShift,
194 #[cfg(feature = "v1_50")]
195 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
196 #[doc(alias = "PANGO_ATTR_FONT_SCALE")]
197 FontScale,
198 #[doc(hidden)]
199 __Unknown(i32),
200}
201
202impl AttrType {
203 #[doc(alias = "pango_attr_type_get_name")]
204 #[doc(alias = "get_name")]
205 pub fn name(self) -> Option<glib::GString> {
206 unsafe { from_glib_none(ffi::pango_attr_type_get_name(self.into_glib())) }
207 }
208}
209
210#[doc(hidden)]
211impl IntoGlib for AttrType {
212 type GlibType = ffi::PangoAttrType;
213
214 fn into_glib(self) -> ffi::PangoAttrType {
215 match self {
216 Self::Invalid => ffi::PANGO_ATTR_INVALID,
217 Self::Language => ffi::PANGO_ATTR_LANGUAGE,
218 Self::Family => ffi::PANGO_ATTR_FAMILY,
219 Self::Style => ffi::PANGO_ATTR_STYLE,
220 Self::Weight => ffi::PANGO_ATTR_WEIGHT,
221 Self::Variant => ffi::PANGO_ATTR_VARIANT,
222 Self::Stretch => ffi::PANGO_ATTR_STRETCH,
223 Self::Size => ffi::PANGO_ATTR_SIZE,
224 Self::FontDesc => ffi::PANGO_ATTR_FONT_DESC,
225 Self::Foreground => ffi::PANGO_ATTR_FOREGROUND,
226 Self::Background => ffi::PANGO_ATTR_BACKGROUND,
227 Self::Underline => ffi::PANGO_ATTR_UNDERLINE,
228 Self::Strikethrough => ffi::PANGO_ATTR_STRIKETHROUGH,
229 Self::Rise => ffi::PANGO_ATTR_RISE,
230 Self::Shape => ffi::PANGO_ATTR_SHAPE,
231 Self::Scale => ffi::PANGO_ATTR_SCALE,
232 Self::Fallback => ffi::PANGO_ATTR_FALLBACK,
233 Self::LetterSpacing => ffi::PANGO_ATTR_LETTER_SPACING,
234 Self::UnderlineColor => ffi::PANGO_ATTR_UNDERLINE_COLOR,
235 Self::StrikethroughColor => ffi::PANGO_ATTR_STRIKETHROUGH_COLOR,
236 Self::AbsoluteSize => ffi::PANGO_ATTR_ABSOLUTE_SIZE,
237 Self::Gravity => ffi::PANGO_ATTR_GRAVITY,
238 Self::GravityHint => ffi::PANGO_ATTR_GRAVITY_HINT,
239 Self::FontFeatures => ffi::PANGO_ATTR_FONT_FEATURES,
240 Self::ForegroundAlpha => ffi::PANGO_ATTR_FOREGROUND_ALPHA,
241 Self::BackgroundAlpha => ffi::PANGO_ATTR_BACKGROUND_ALPHA,
242 Self::AllowBreaks => ffi::PANGO_ATTR_ALLOW_BREAKS,
243 Self::Show => ffi::PANGO_ATTR_SHOW,
244 Self::InsertHyphens => ffi::PANGO_ATTR_INSERT_HYPHENS,
245 Self::Overline => ffi::PANGO_ATTR_OVERLINE,
246 Self::OverlineColor => ffi::PANGO_ATTR_OVERLINE_COLOR,
247 #[cfg(feature = "v1_50")]
248 Self::LineHeight => ffi::PANGO_ATTR_LINE_HEIGHT,
249 #[cfg(feature = "v1_50")]
250 Self::AbsoluteLineHeight => ffi::PANGO_ATTR_ABSOLUTE_LINE_HEIGHT,
251 #[cfg(feature = "v1_50")]
252 Self::TextTransform => ffi::PANGO_ATTR_TEXT_TRANSFORM,
253 #[cfg(feature = "v1_50")]
254 Self::Word => ffi::PANGO_ATTR_WORD,
255 #[cfg(feature = "v1_50")]
256 Self::Sentence => ffi::PANGO_ATTR_SENTENCE,
257 #[cfg(feature = "v1_50")]
258 Self::BaselineShift => ffi::PANGO_ATTR_BASELINE_SHIFT,
259 #[cfg(feature = "v1_50")]
260 Self::FontScale => ffi::PANGO_ATTR_FONT_SCALE,
261 Self::__Unknown(value) => value,
262 }
263 }
264}
265
266#[doc(hidden)]
267impl FromGlib<ffi::PangoAttrType> for AttrType {
268 unsafe fn from_glib(value: ffi::PangoAttrType) -> Self {
269 match value {
270 ffi::PANGO_ATTR_INVALID => Self::Invalid,
271 ffi::PANGO_ATTR_LANGUAGE => Self::Language,
272 ffi::PANGO_ATTR_FAMILY => Self::Family,
273 ffi::PANGO_ATTR_STYLE => Self::Style,
274 ffi::PANGO_ATTR_WEIGHT => Self::Weight,
275 ffi::PANGO_ATTR_VARIANT => Self::Variant,
276 ffi::PANGO_ATTR_STRETCH => Self::Stretch,
277 ffi::PANGO_ATTR_SIZE => Self::Size,
278 ffi::PANGO_ATTR_FONT_DESC => Self::FontDesc,
279 ffi::PANGO_ATTR_FOREGROUND => Self::Foreground,
280 ffi::PANGO_ATTR_BACKGROUND => Self::Background,
281 ffi::PANGO_ATTR_UNDERLINE => Self::Underline,
282 ffi::PANGO_ATTR_STRIKETHROUGH => Self::Strikethrough,
283 ffi::PANGO_ATTR_RISE => Self::Rise,
284 ffi::PANGO_ATTR_SHAPE => Self::Shape,
285 ffi::PANGO_ATTR_SCALE => Self::Scale,
286 ffi::PANGO_ATTR_FALLBACK => Self::Fallback,
287 ffi::PANGO_ATTR_LETTER_SPACING => Self::LetterSpacing,
288 ffi::PANGO_ATTR_UNDERLINE_COLOR => Self::UnderlineColor,
289 ffi::PANGO_ATTR_STRIKETHROUGH_COLOR => Self::StrikethroughColor,
290 ffi::PANGO_ATTR_ABSOLUTE_SIZE => Self::AbsoluteSize,
291 ffi::PANGO_ATTR_GRAVITY => Self::Gravity,
292 ffi::PANGO_ATTR_GRAVITY_HINT => Self::GravityHint,
293 ffi::PANGO_ATTR_FONT_FEATURES => Self::FontFeatures,
294 ffi::PANGO_ATTR_FOREGROUND_ALPHA => Self::ForegroundAlpha,
295 ffi::PANGO_ATTR_BACKGROUND_ALPHA => Self::BackgroundAlpha,
296 ffi::PANGO_ATTR_ALLOW_BREAKS => Self::AllowBreaks,
297 ffi::PANGO_ATTR_SHOW => Self::Show,
298 ffi::PANGO_ATTR_INSERT_HYPHENS => Self::InsertHyphens,
299 ffi::PANGO_ATTR_OVERLINE => Self::Overline,
300 ffi::PANGO_ATTR_OVERLINE_COLOR => Self::OverlineColor,
301 #[cfg(feature = "v1_50")]
302 ffi::PANGO_ATTR_LINE_HEIGHT => Self::LineHeight,
303 #[cfg(feature = "v1_50")]
304 ffi::PANGO_ATTR_ABSOLUTE_LINE_HEIGHT => Self::AbsoluteLineHeight,
305 #[cfg(feature = "v1_50")]
306 ffi::PANGO_ATTR_TEXT_TRANSFORM => Self::TextTransform,
307 #[cfg(feature = "v1_50")]
308 ffi::PANGO_ATTR_WORD => Self::Word,
309 #[cfg(feature = "v1_50")]
310 ffi::PANGO_ATTR_SENTENCE => Self::Sentence,
311 #[cfg(feature = "v1_50")]
312 ffi::PANGO_ATTR_BASELINE_SHIFT => Self::BaselineShift,
313 #[cfg(feature = "v1_50")]
314 ffi::PANGO_ATTR_FONT_SCALE => Self::FontScale,
315 value => Self::__Unknown(value),
316 }
317 }
318}
319
320impl StaticType for AttrType {
321 #[inline]
322 #[doc(alias = "pango_attr_type_get_type")]
323 fn static_type() -> glib::Type {
324 unsafe { from_glib(ffi::pango_attr_type_get_type()) }
325 }
326}
327
328impl glib::HasParamSpec for AttrType {
329 type ParamSpec = glib::ParamSpecEnum;
330 type SetValue = Self;
331 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
332
333 fn param_spec_builder() -> Self::BuilderFn {
334 Self::ParamSpec::builder_with_default
335 }
336}
337
338impl glib::value::ValueType for AttrType {
339 type Type = Self;
340}
341
342unsafe impl<'a> glib::value::FromValue<'a> for AttrType {
343 type Checker = glib::value::GenericValueTypeChecker<Self>;
344
345 #[inline]
346 unsafe fn from_value(value: &'a glib::Value) -> Self {
347 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
348 }
349}
350
351impl ToValue for AttrType {
352 #[inline]
353 fn to_value(&self) -> glib::Value {
354 let mut value = glib::Value::for_value_type::<Self>();
355 unsafe {
356 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
357 }
358 value
359 }
360
361 #[inline]
362 fn value_type(&self) -> glib::Type {
363 Self::static_type()
364 }
365}
366
367impl From<AttrType> for glib::Value {
368 #[inline]
369 fn from(v: AttrType) -> Self {
370 ToValue::to_value(&v)
371 }
372}
373
374#[cfg(feature = "v1_50")]
375#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
376#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
377#[non_exhaustive]
378#[doc(alias = "PangoBaselineShift")]
379pub enum BaselineShift {
380 #[doc(alias = "PANGO_BASELINE_SHIFT_NONE")]
381 None,
382 #[doc(alias = "PANGO_BASELINE_SHIFT_SUPERSCRIPT")]
383 Superscript,
384 #[doc(alias = "PANGO_BASELINE_SHIFT_SUBSCRIPT")]
385 Subscript,
386 #[doc(hidden)]
387 __Unknown(i32),
388}
389
390#[cfg(feature = "v1_50")]
391#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
392#[doc(hidden)]
393impl IntoGlib for BaselineShift {
394 type GlibType = ffi::PangoBaselineShift;
395
396 #[inline]
397 fn into_glib(self) -> ffi::PangoBaselineShift {
398 match self {
399 Self::None => ffi::PANGO_BASELINE_SHIFT_NONE,
400 Self::Superscript => ffi::PANGO_BASELINE_SHIFT_SUPERSCRIPT,
401 Self::Subscript => ffi::PANGO_BASELINE_SHIFT_SUBSCRIPT,
402 Self::__Unknown(value) => value,
403 }
404 }
405}
406
407#[cfg(feature = "v1_50")]
408#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
409#[doc(hidden)]
410impl FromGlib<ffi::PangoBaselineShift> for BaselineShift {
411 #[inline]
412 unsafe fn from_glib(value: ffi::PangoBaselineShift) -> Self {
413 match value {
414 ffi::PANGO_BASELINE_SHIFT_NONE => Self::None,
415 ffi::PANGO_BASELINE_SHIFT_SUPERSCRIPT => Self::Superscript,
416 ffi::PANGO_BASELINE_SHIFT_SUBSCRIPT => Self::Subscript,
417 value => Self::__Unknown(value),
418 }
419 }
420}
421
422#[cfg(feature = "v1_50")]
423#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
424impl StaticType for BaselineShift {
425 #[inline]
426 #[doc(alias = "pango_baseline_shift_get_type")]
427 fn static_type() -> glib::Type {
428 unsafe { from_glib(ffi::pango_baseline_shift_get_type()) }
429 }
430}
431
432#[cfg(feature = "v1_50")]
433#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
434impl glib::HasParamSpec for BaselineShift {
435 type ParamSpec = glib::ParamSpecEnum;
436 type SetValue = Self;
437 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
438
439 fn param_spec_builder() -> Self::BuilderFn {
440 Self::ParamSpec::builder_with_default
441 }
442}
443
444#[cfg(feature = "v1_50")]
445#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
446impl glib::value::ValueType for BaselineShift {
447 type Type = Self;
448}
449
450#[cfg(feature = "v1_50")]
451#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
452unsafe impl<'a> glib::value::FromValue<'a> for BaselineShift {
453 type Checker = glib::value::GenericValueTypeChecker<Self>;
454
455 #[inline]
456 unsafe fn from_value(value: &'a glib::Value) -> Self {
457 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
458 }
459}
460
461#[cfg(feature = "v1_50")]
462#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
463impl ToValue for BaselineShift {
464 #[inline]
465 fn to_value(&self) -> glib::Value {
466 let mut value = glib::Value::for_value_type::<Self>();
467 unsafe {
468 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
469 }
470 value
471 }
472
473 #[inline]
474 fn value_type(&self) -> glib::Type {
475 Self::static_type()
476 }
477}
478
479#[cfg(feature = "v1_50")]
480#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
481impl From<BaselineShift> for glib::Value {
482 #[inline]
483 fn from(v: BaselineShift) -> Self {
484 ToValue::to_value(&v)
485 }
486}
487
488#[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")]
489#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
490#[non_exhaustive]
491#[doc(alias = "PangoBidiType")]
492pub enum BidiType {
493 #[doc(alias = "PANGO_BIDI_TYPE_L")]
494 L,
495 #[doc(alias = "PANGO_BIDI_TYPE_LRE")]
496 Lre,
497 #[doc(alias = "PANGO_BIDI_TYPE_LRO")]
498 Lro,
499 #[doc(alias = "PANGO_BIDI_TYPE_R")]
500 R,
501 #[doc(alias = "PANGO_BIDI_TYPE_AL")]
502 Al,
503 #[doc(alias = "PANGO_BIDI_TYPE_RLE")]
504 Rle,
505 #[doc(alias = "PANGO_BIDI_TYPE_RLO")]
506 Rlo,
507 #[doc(alias = "PANGO_BIDI_TYPE_PDF")]
508 Pdf,
509 #[doc(alias = "PANGO_BIDI_TYPE_EN")]
510 En,
511 #[doc(alias = "PANGO_BIDI_TYPE_ES")]
512 Es,
513 #[doc(alias = "PANGO_BIDI_TYPE_ET")]
514 Et,
515 #[doc(alias = "PANGO_BIDI_TYPE_AN")]
516 An,
517 #[doc(alias = "PANGO_BIDI_TYPE_CS")]
518 Cs,
519 #[doc(alias = "PANGO_BIDI_TYPE_NSM")]
520 Nsm,
521 #[doc(alias = "PANGO_BIDI_TYPE_BN")]
522 Bn,
523 #[doc(alias = "PANGO_BIDI_TYPE_B")]
524 B,
525 #[doc(alias = "PANGO_BIDI_TYPE_S")]
526 S,
527 #[doc(alias = "PANGO_BIDI_TYPE_WS")]
528 Ws,
529 #[doc(alias = "PANGO_BIDI_TYPE_ON")]
530 On,
531 #[doc(alias = "PANGO_BIDI_TYPE_LRI")]
532 Lri,
533 #[doc(alias = "PANGO_BIDI_TYPE_RLI")]
534 Rli,
535 #[doc(alias = "PANGO_BIDI_TYPE_FSI")]
536 Fsi,
537 #[doc(alias = "PANGO_BIDI_TYPE_PDI")]
538 Pdi,
539 #[doc(hidden)]
540 __Unknown(i32),
541}
542
543#[allow(deprecated)]
544impl BidiType {
545 #[doc(alias = "pango_bidi_type_for_unichar")]
546 pub fn for_unichar(ch: char) -> BidiType {
547 unsafe { from_glib(ffi::pango_bidi_type_for_unichar(ch.into_glib())) }
548 }
549}
550
551#[allow(deprecated)]
552#[doc(hidden)]
553impl IntoGlib for BidiType {
554 type GlibType = ffi::PangoBidiType;
555
556 fn into_glib(self) -> ffi::PangoBidiType {
557 match self {
558 Self::L => ffi::PANGO_BIDI_TYPE_L,
559 Self::Lre => ffi::PANGO_BIDI_TYPE_LRE,
560 Self::Lro => ffi::PANGO_BIDI_TYPE_LRO,
561 Self::R => ffi::PANGO_BIDI_TYPE_R,
562 Self::Al => ffi::PANGO_BIDI_TYPE_AL,
563 Self::Rle => ffi::PANGO_BIDI_TYPE_RLE,
564 Self::Rlo => ffi::PANGO_BIDI_TYPE_RLO,
565 Self::Pdf => ffi::PANGO_BIDI_TYPE_PDF,
566 Self::En => ffi::PANGO_BIDI_TYPE_EN,
567 Self::Es => ffi::PANGO_BIDI_TYPE_ES,
568 Self::Et => ffi::PANGO_BIDI_TYPE_ET,
569 Self::An => ffi::PANGO_BIDI_TYPE_AN,
570 Self::Cs => ffi::PANGO_BIDI_TYPE_CS,
571 Self::Nsm => ffi::PANGO_BIDI_TYPE_NSM,
572 Self::Bn => ffi::PANGO_BIDI_TYPE_BN,
573 Self::B => ffi::PANGO_BIDI_TYPE_B,
574 Self::S => ffi::PANGO_BIDI_TYPE_S,
575 Self::Ws => ffi::PANGO_BIDI_TYPE_WS,
576 Self::On => ffi::PANGO_BIDI_TYPE_ON,
577 Self::Lri => ffi::PANGO_BIDI_TYPE_LRI,
578 Self::Rli => ffi::PANGO_BIDI_TYPE_RLI,
579 Self::Fsi => ffi::PANGO_BIDI_TYPE_FSI,
580 Self::Pdi => ffi::PANGO_BIDI_TYPE_PDI,
581 Self::__Unknown(value) => value,
582 }
583 }
584}
585
586#[allow(deprecated)]
587#[doc(hidden)]
588impl FromGlib<ffi::PangoBidiType> for BidiType {
589 unsafe fn from_glib(value: ffi::PangoBidiType) -> Self {
590 match value {
591 ffi::PANGO_BIDI_TYPE_L => Self::L,
592 ffi::PANGO_BIDI_TYPE_LRE => Self::Lre,
593 ffi::PANGO_BIDI_TYPE_LRO => Self::Lro,
594 ffi::PANGO_BIDI_TYPE_R => Self::R,
595 ffi::PANGO_BIDI_TYPE_AL => Self::Al,
596 ffi::PANGO_BIDI_TYPE_RLE => Self::Rle,
597 ffi::PANGO_BIDI_TYPE_RLO => Self::Rlo,
598 ffi::PANGO_BIDI_TYPE_PDF => Self::Pdf,
599 ffi::PANGO_BIDI_TYPE_EN => Self::En,
600 ffi::PANGO_BIDI_TYPE_ES => Self::Es,
601 ffi::PANGO_BIDI_TYPE_ET => Self::Et,
602 ffi::PANGO_BIDI_TYPE_AN => Self::An,
603 ffi::PANGO_BIDI_TYPE_CS => Self::Cs,
604 ffi::PANGO_BIDI_TYPE_NSM => Self::Nsm,
605 ffi::PANGO_BIDI_TYPE_BN => Self::Bn,
606 ffi::PANGO_BIDI_TYPE_B => Self::B,
607 ffi::PANGO_BIDI_TYPE_S => Self::S,
608 ffi::PANGO_BIDI_TYPE_WS => Self::Ws,
609 ffi::PANGO_BIDI_TYPE_ON => Self::On,
610 ffi::PANGO_BIDI_TYPE_LRI => Self::Lri,
611 ffi::PANGO_BIDI_TYPE_RLI => Self::Rli,
612 ffi::PANGO_BIDI_TYPE_FSI => Self::Fsi,
613 ffi::PANGO_BIDI_TYPE_PDI => Self::Pdi,
614 value => Self::__Unknown(value),
615 }
616 }
617}
618
619#[allow(deprecated)]
620impl StaticType for BidiType {
621 #[inline]
622 #[doc(alias = "pango_bidi_type_get_type")]
623 fn static_type() -> glib::Type {
624 unsafe { from_glib(ffi::pango_bidi_type_get_type()) }
625 }
626}
627
628#[allow(deprecated)]
629impl glib::HasParamSpec for BidiType {
630 type ParamSpec = glib::ParamSpecEnum;
631 type SetValue = Self;
632 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
633
634 fn param_spec_builder() -> Self::BuilderFn {
635 Self::ParamSpec::builder_with_default
636 }
637}
638
639#[allow(deprecated)]
640impl glib::value::ValueType for BidiType {
641 type Type = Self;
642}
643
644#[allow(deprecated)]
645unsafe impl<'a> glib::value::FromValue<'a> for BidiType {
646 type Checker = glib::value::GenericValueTypeChecker<Self>;
647
648 #[inline]
649 unsafe fn from_value(value: &'a glib::Value) -> Self {
650 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
651 }
652}
653
654#[allow(deprecated)]
655impl ToValue for BidiType {
656 #[inline]
657 fn to_value(&self) -> glib::Value {
658 let mut value = glib::Value::for_value_type::<Self>();
659 unsafe {
660 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
661 }
662 value
663 }
664
665 #[inline]
666 fn value_type(&self) -> glib::Type {
667 Self::static_type()
668 }
669}
670
671#[allow(deprecated)]
672impl From<BidiType> for glib::Value {
673 #[inline]
674 fn from(v: BidiType) -> Self {
675 ToValue::to_value(&v)
676 }
677}
678
679#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
680#[non_exhaustive]
681#[doc(alias = "PangoCoverageLevel")]
682pub enum CoverageLevel {
683 #[doc(alias = "PANGO_COVERAGE_NONE")]
684 None,
685 #[doc(alias = "PANGO_COVERAGE_FALLBACK")]
686 Fallback,
687 #[doc(alias = "PANGO_COVERAGE_APPROXIMATE")]
688 Approximate,
689 #[doc(alias = "PANGO_COVERAGE_EXACT")]
690 Exact,
691 #[doc(hidden)]
692 __Unknown(i32),
693}
694
695#[doc(hidden)]
696impl IntoGlib for CoverageLevel {
697 type GlibType = ffi::PangoCoverageLevel;
698
699 #[inline]
700 fn into_glib(self) -> ffi::PangoCoverageLevel {
701 match self {
702 Self::None => ffi::PANGO_COVERAGE_NONE,
703 Self::Fallback => ffi::PANGO_COVERAGE_FALLBACK,
704 Self::Approximate => ffi::PANGO_COVERAGE_APPROXIMATE,
705 Self::Exact => ffi::PANGO_COVERAGE_EXACT,
706 Self::__Unknown(value) => value,
707 }
708 }
709}
710
711#[doc(hidden)]
712impl FromGlib<ffi::PangoCoverageLevel> for CoverageLevel {
713 #[inline]
714 unsafe fn from_glib(value: ffi::PangoCoverageLevel) -> Self {
715 match value {
716 ffi::PANGO_COVERAGE_NONE => Self::None,
717 ffi::PANGO_COVERAGE_FALLBACK => Self::Fallback,
718 ffi::PANGO_COVERAGE_APPROXIMATE => Self::Approximate,
719 ffi::PANGO_COVERAGE_EXACT => Self::Exact,
720 value => Self::__Unknown(value),
721 }
722 }
723}
724
725impl StaticType for CoverageLevel {
726 #[inline]
727 #[doc(alias = "pango_coverage_level_get_type")]
728 fn static_type() -> glib::Type {
729 unsafe { from_glib(ffi::pango_coverage_level_get_type()) }
730 }
731}
732
733impl glib::HasParamSpec for CoverageLevel {
734 type ParamSpec = glib::ParamSpecEnum;
735 type SetValue = Self;
736 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
737
738 fn param_spec_builder() -> Self::BuilderFn {
739 Self::ParamSpec::builder_with_default
740 }
741}
742
743impl glib::value::ValueType for CoverageLevel {
744 type Type = Self;
745}
746
747unsafe impl<'a> glib::value::FromValue<'a> for CoverageLevel {
748 type Checker = glib::value::GenericValueTypeChecker<Self>;
749
750 #[inline]
751 unsafe fn from_value(value: &'a glib::Value) -> Self {
752 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
753 }
754}
755
756impl ToValue for CoverageLevel {
757 #[inline]
758 fn to_value(&self) -> glib::Value {
759 let mut value = glib::Value::for_value_type::<Self>();
760 unsafe {
761 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
762 }
763 value
764 }
765
766 #[inline]
767 fn value_type(&self) -> glib::Type {
768 Self::static_type()
769 }
770}
771
772impl From<CoverageLevel> for glib::Value {
773 #[inline]
774 fn from(v: CoverageLevel) -> Self {
775 ToValue::to_value(&v)
776 }
777}
778
779#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
780#[non_exhaustive]
781#[doc(alias = "PangoDirection")]
782pub enum Direction {
783 #[doc(alias = "PANGO_DIRECTION_LTR")]
784 Ltr,
785 #[doc(alias = "PANGO_DIRECTION_RTL")]
786 Rtl,
787 #[doc(alias = "PANGO_DIRECTION_TTB_LTR")]
788 TtbLtr,
789 #[doc(alias = "PANGO_DIRECTION_TTB_RTL")]
790 TtbRtl,
791 #[doc(alias = "PANGO_DIRECTION_WEAK_LTR")]
792 WeakLtr,
793 #[doc(alias = "PANGO_DIRECTION_WEAK_RTL")]
794 WeakRtl,
795 #[doc(alias = "PANGO_DIRECTION_NEUTRAL")]
796 Neutral,
797 #[doc(hidden)]
798 __Unknown(i32),
799}
800
801#[doc(hidden)]
802impl IntoGlib for Direction {
803 type GlibType = ffi::PangoDirection;
804
805 #[inline]
806 fn into_glib(self) -> ffi::PangoDirection {
807 match self {
808 Self::Ltr => ffi::PANGO_DIRECTION_LTR,
809 Self::Rtl => ffi::PANGO_DIRECTION_RTL,
810 Self::TtbLtr => ffi::PANGO_DIRECTION_TTB_LTR,
811 Self::TtbRtl => ffi::PANGO_DIRECTION_TTB_RTL,
812 Self::WeakLtr => ffi::PANGO_DIRECTION_WEAK_LTR,
813 Self::WeakRtl => ffi::PANGO_DIRECTION_WEAK_RTL,
814 Self::Neutral => ffi::PANGO_DIRECTION_NEUTRAL,
815 Self::__Unknown(value) => value,
816 }
817 }
818}
819
820#[doc(hidden)]
821impl FromGlib<ffi::PangoDirection> for Direction {
822 #[inline]
823 unsafe fn from_glib(value: ffi::PangoDirection) -> Self {
824 match value {
825 ffi::PANGO_DIRECTION_LTR => Self::Ltr,
826 ffi::PANGO_DIRECTION_RTL => Self::Rtl,
827 ffi::PANGO_DIRECTION_TTB_LTR => Self::TtbLtr,
828 ffi::PANGO_DIRECTION_TTB_RTL => Self::TtbRtl,
829 ffi::PANGO_DIRECTION_WEAK_LTR => Self::WeakLtr,
830 ffi::PANGO_DIRECTION_WEAK_RTL => Self::WeakRtl,
831 ffi::PANGO_DIRECTION_NEUTRAL => Self::Neutral,
832 value => Self::__Unknown(value),
833 }
834 }
835}
836
837impl StaticType for Direction {
838 #[inline]
839 #[doc(alias = "pango_direction_get_type")]
840 fn static_type() -> glib::Type {
841 unsafe { from_glib(ffi::pango_direction_get_type()) }
842 }
843}
844
845impl glib::HasParamSpec for Direction {
846 type ParamSpec = glib::ParamSpecEnum;
847 type SetValue = Self;
848 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
849
850 fn param_spec_builder() -> Self::BuilderFn {
851 Self::ParamSpec::builder_with_default
852 }
853}
854
855impl glib::value::ValueType for Direction {
856 type Type = Self;
857}
858
859unsafe impl<'a> glib::value::FromValue<'a> for Direction {
860 type Checker = glib::value::GenericValueTypeChecker<Self>;
861
862 #[inline]
863 unsafe fn from_value(value: &'a glib::Value) -> Self {
864 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
865 }
866}
867
868impl ToValue for Direction {
869 #[inline]
870 fn to_value(&self) -> glib::Value {
871 let mut value = glib::Value::for_value_type::<Self>();
872 unsafe {
873 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
874 }
875 value
876 }
877
878 #[inline]
879 fn value_type(&self) -> glib::Type {
880 Self::static_type()
881 }
882}
883
884impl From<Direction> for glib::Value {
885 #[inline]
886 fn from(v: Direction) -> Self {
887 ToValue::to_value(&v)
888 }
889}
890
891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
892#[non_exhaustive]
893#[doc(alias = "PangoEllipsizeMode")]
894pub enum EllipsizeMode {
895 #[doc(alias = "PANGO_ELLIPSIZE_NONE")]
896 None,
897 #[doc(alias = "PANGO_ELLIPSIZE_START")]
898 Start,
899 #[doc(alias = "PANGO_ELLIPSIZE_MIDDLE")]
900 Middle,
901 #[doc(alias = "PANGO_ELLIPSIZE_END")]
902 End,
903 #[doc(hidden)]
904 __Unknown(i32),
905}
906
907#[doc(hidden)]
908impl IntoGlib for EllipsizeMode {
909 type GlibType = ffi::PangoEllipsizeMode;
910
911 #[inline]
912 fn into_glib(self) -> ffi::PangoEllipsizeMode {
913 match self {
914 Self::None => ffi::PANGO_ELLIPSIZE_NONE,
915 Self::Start => ffi::PANGO_ELLIPSIZE_START,
916 Self::Middle => ffi::PANGO_ELLIPSIZE_MIDDLE,
917 Self::End => ffi::PANGO_ELLIPSIZE_END,
918 Self::__Unknown(value) => value,
919 }
920 }
921}
922
923#[doc(hidden)]
924impl FromGlib<ffi::PangoEllipsizeMode> for EllipsizeMode {
925 #[inline]
926 unsafe fn from_glib(value: ffi::PangoEllipsizeMode) -> Self {
927 match value {
928 ffi::PANGO_ELLIPSIZE_NONE => Self::None,
929 ffi::PANGO_ELLIPSIZE_START => Self::Start,
930 ffi::PANGO_ELLIPSIZE_MIDDLE => Self::Middle,
931 ffi::PANGO_ELLIPSIZE_END => Self::End,
932 value => Self::__Unknown(value),
933 }
934 }
935}
936
937impl StaticType for EllipsizeMode {
938 #[inline]
939 #[doc(alias = "pango_ellipsize_mode_get_type")]
940 fn static_type() -> glib::Type {
941 unsafe { from_glib(ffi::pango_ellipsize_mode_get_type()) }
942 }
943}
944
945impl glib::HasParamSpec for EllipsizeMode {
946 type ParamSpec = glib::ParamSpecEnum;
947 type SetValue = Self;
948 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
949
950 fn param_spec_builder() -> Self::BuilderFn {
951 Self::ParamSpec::builder_with_default
952 }
953}
954
955impl glib::value::ValueType for EllipsizeMode {
956 type Type = Self;
957}
958
959unsafe impl<'a> glib::value::FromValue<'a> for EllipsizeMode {
960 type Checker = glib::value::GenericValueTypeChecker<Self>;
961
962 #[inline]
963 unsafe fn from_value(value: &'a glib::Value) -> Self {
964 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
965 }
966}
967
968impl ToValue for EllipsizeMode {
969 #[inline]
970 fn to_value(&self) -> glib::Value {
971 let mut value = glib::Value::for_value_type::<Self>();
972 unsafe {
973 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
974 }
975 value
976 }
977
978 #[inline]
979 fn value_type(&self) -> glib::Type {
980 Self::static_type()
981 }
982}
983
984impl From<EllipsizeMode> for glib::Value {
985 #[inline]
986 fn from(v: EllipsizeMode) -> Self {
987 ToValue::to_value(&v)
988 }
989}
990
991#[cfg(feature = "v1_50")]
992#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
993#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
994#[non_exhaustive]
995#[doc(alias = "PangoFontScale")]
996pub enum FontScale {
997 #[doc(alias = "PANGO_FONT_SCALE_NONE")]
998 None,
999 #[doc(alias = "PANGO_FONT_SCALE_SUPERSCRIPT")]
1000 Superscript,
1001 #[doc(alias = "PANGO_FONT_SCALE_SUBSCRIPT")]
1002 Subscript,
1003 #[doc(alias = "PANGO_FONT_SCALE_SMALL_CAPS")]
1004 SmallCaps,
1005 #[doc(hidden)]
1006 __Unknown(i32),
1007}
1008
1009#[cfg(feature = "v1_50")]
1010#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1011#[doc(hidden)]
1012impl IntoGlib for FontScale {
1013 type GlibType = ffi::PangoFontScale;
1014
1015 #[inline]
1016 fn into_glib(self) -> ffi::PangoFontScale {
1017 match self {
1018 Self::None => ffi::PANGO_FONT_SCALE_NONE,
1019 Self::Superscript => ffi::PANGO_FONT_SCALE_SUPERSCRIPT,
1020 Self::Subscript => ffi::PANGO_FONT_SCALE_SUBSCRIPT,
1021 Self::SmallCaps => ffi::PANGO_FONT_SCALE_SMALL_CAPS,
1022 Self::__Unknown(value) => value,
1023 }
1024 }
1025}
1026
1027#[cfg(feature = "v1_50")]
1028#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1029#[doc(hidden)]
1030impl FromGlib<ffi::PangoFontScale> for FontScale {
1031 #[inline]
1032 unsafe fn from_glib(value: ffi::PangoFontScale) -> Self {
1033 match value {
1034 ffi::PANGO_FONT_SCALE_NONE => Self::None,
1035 ffi::PANGO_FONT_SCALE_SUPERSCRIPT => Self::Superscript,
1036 ffi::PANGO_FONT_SCALE_SUBSCRIPT => Self::Subscript,
1037 ffi::PANGO_FONT_SCALE_SMALL_CAPS => Self::SmallCaps,
1038 value => Self::__Unknown(value),
1039 }
1040 }
1041}
1042
1043#[cfg(feature = "v1_50")]
1044#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1045impl StaticType for FontScale {
1046 #[inline]
1047 #[doc(alias = "pango_font_scale_get_type")]
1048 fn static_type() -> glib::Type {
1049 unsafe { from_glib(ffi::pango_font_scale_get_type()) }
1050 }
1051}
1052
1053#[cfg(feature = "v1_50")]
1054#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1055impl glib::HasParamSpec for FontScale {
1056 type ParamSpec = glib::ParamSpecEnum;
1057 type SetValue = Self;
1058 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1059
1060 fn param_spec_builder() -> Self::BuilderFn {
1061 Self::ParamSpec::builder_with_default
1062 }
1063}
1064
1065#[cfg(feature = "v1_50")]
1066#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1067impl glib::value::ValueType for FontScale {
1068 type Type = Self;
1069}
1070
1071#[cfg(feature = "v1_50")]
1072#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1073unsafe impl<'a> glib::value::FromValue<'a> for FontScale {
1074 type Checker = glib::value::GenericValueTypeChecker<Self>;
1075
1076 #[inline]
1077 unsafe fn from_value(value: &'a glib::Value) -> Self {
1078 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1079 }
1080}
1081
1082#[cfg(feature = "v1_50")]
1083#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1084impl ToValue for FontScale {
1085 #[inline]
1086 fn to_value(&self) -> glib::Value {
1087 let mut value = glib::Value::for_value_type::<Self>();
1088 unsafe {
1089 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1090 }
1091 value
1092 }
1093
1094 #[inline]
1095 fn value_type(&self) -> glib::Type {
1096 Self::static_type()
1097 }
1098}
1099
1100#[cfg(feature = "v1_50")]
1101#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1102impl From<FontScale> for glib::Value {
1103 #[inline]
1104 fn from(v: FontScale) -> Self {
1105 ToValue::to_value(&v)
1106 }
1107}
1108
1109#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1110#[non_exhaustive]
1111#[doc(alias = "PangoGravity")]
1112pub enum Gravity {
1113 #[doc(alias = "PANGO_GRAVITY_SOUTH")]
1114 South,
1115 #[doc(alias = "PANGO_GRAVITY_EAST")]
1116 East,
1117 #[doc(alias = "PANGO_GRAVITY_NORTH")]
1118 North,
1119 #[doc(alias = "PANGO_GRAVITY_WEST")]
1120 West,
1121 #[doc(alias = "PANGO_GRAVITY_AUTO")]
1122 Auto,
1123 #[doc(hidden)]
1124 __Unknown(i32),
1125}
1126
1127impl Gravity {
1128 #[doc(alias = "pango_gravity_get_for_matrix")]
1129 #[doc(alias = "get_for_matrix")]
1130 pub fn for_matrix(matrix: Option<&Matrix>) -> Gravity {
1131 unsafe { from_glib(ffi::pango_gravity_get_for_matrix(matrix.to_glib_none().0)) }
1132 }
1133
1134 #[doc(alias = "pango_gravity_get_for_script")]
1135 #[doc(alias = "get_for_script")]
1136 pub fn for_script(script: Script, base_gravity: Gravity, hint: GravityHint) -> Gravity {
1137 unsafe {
1138 from_glib(ffi::pango_gravity_get_for_script(
1139 script.into_glib(),
1140 base_gravity.into_glib(),
1141 hint.into_glib(),
1142 ))
1143 }
1144 }
1145
1146 #[doc(alias = "pango_gravity_get_for_script_and_width")]
1147 #[doc(alias = "get_for_script_and_width")]
1148 pub fn for_script_and_width(
1149 script: Script,
1150 wide: bool,
1151 base_gravity: Gravity,
1152 hint: GravityHint,
1153 ) -> Gravity {
1154 unsafe {
1155 from_glib(ffi::pango_gravity_get_for_script_and_width(
1156 script.into_glib(),
1157 wide.into_glib(),
1158 base_gravity.into_glib(),
1159 hint.into_glib(),
1160 ))
1161 }
1162 }
1163
1164 #[doc(alias = "pango_gravity_to_rotation")]
1165 pub fn to_rotation(self) -> f64 {
1166 unsafe { ffi::pango_gravity_to_rotation(self.into_glib()) }
1167 }
1168}
1169
1170#[doc(hidden)]
1171impl IntoGlib for Gravity {
1172 type GlibType = ffi::PangoGravity;
1173
1174 #[inline]
1175 fn into_glib(self) -> ffi::PangoGravity {
1176 match self {
1177 Self::South => ffi::PANGO_GRAVITY_SOUTH,
1178 Self::East => ffi::PANGO_GRAVITY_EAST,
1179 Self::North => ffi::PANGO_GRAVITY_NORTH,
1180 Self::West => ffi::PANGO_GRAVITY_WEST,
1181 Self::Auto => ffi::PANGO_GRAVITY_AUTO,
1182 Self::__Unknown(value) => value,
1183 }
1184 }
1185}
1186
1187#[doc(hidden)]
1188impl FromGlib<ffi::PangoGravity> for Gravity {
1189 #[inline]
1190 unsafe fn from_glib(value: ffi::PangoGravity) -> Self {
1191 match value {
1192 ffi::PANGO_GRAVITY_SOUTH => Self::South,
1193 ffi::PANGO_GRAVITY_EAST => Self::East,
1194 ffi::PANGO_GRAVITY_NORTH => Self::North,
1195 ffi::PANGO_GRAVITY_WEST => Self::West,
1196 ffi::PANGO_GRAVITY_AUTO => Self::Auto,
1197 value => Self::__Unknown(value),
1198 }
1199 }
1200}
1201
1202impl StaticType for Gravity {
1203 #[inline]
1204 #[doc(alias = "pango_gravity_get_type")]
1205 fn static_type() -> glib::Type {
1206 unsafe { from_glib(ffi::pango_gravity_get_type()) }
1207 }
1208}
1209
1210impl glib::HasParamSpec for Gravity {
1211 type ParamSpec = glib::ParamSpecEnum;
1212 type SetValue = Self;
1213 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1214
1215 fn param_spec_builder() -> Self::BuilderFn {
1216 Self::ParamSpec::builder_with_default
1217 }
1218}
1219
1220impl glib::value::ValueType for Gravity {
1221 type Type = Self;
1222}
1223
1224unsafe impl<'a> glib::value::FromValue<'a> for Gravity {
1225 type Checker = glib::value::GenericValueTypeChecker<Self>;
1226
1227 #[inline]
1228 unsafe fn from_value(value: &'a glib::Value) -> Self {
1229 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1230 }
1231}
1232
1233impl ToValue for Gravity {
1234 #[inline]
1235 fn to_value(&self) -> glib::Value {
1236 let mut value = glib::Value::for_value_type::<Self>();
1237 unsafe {
1238 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1239 }
1240 value
1241 }
1242
1243 #[inline]
1244 fn value_type(&self) -> glib::Type {
1245 Self::static_type()
1246 }
1247}
1248
1249impl From<Gravity> for glib::Value {
1250 #[inline]
1251 fn from(v: Gravity) -> Self {
1252 ToValue::to_value(&v)
1253 }
1254}
1255
1256#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1257#[non_exhaustive]
1258#[doc(alias = "PangoGravityHint")]
1259pub enum GravityHint {
1260 #[doc(alias = "PANGO_GRAVITY_HINT_NATURAL")]
1261 Natural,
1262 #[doc(alias = "PANGO_GRAVITY_HINT_STRONG")]
1263 Strong,
1264 #[doc(alias = "PANGO_GRAVITY_HINT_LINE")]
1265 Line,
1266 #[doc(hidden)]
1267 __Unknown(i32),
1268}
1269
1270#[doc(hidden)]
1271impl IntoGlib for GravityHint {
1272 type GlibType = ffi::PangoGravityHint;
1273
1274 #[inline]
1275 fn into_glib(self) -> ffi::PangoGravityHint {
1276 match self {
1277 Self::Natural => ffi::PANGO_GRAVITY_HINT_NATURAL,
1278 Self::Strong => ffi::PANGO_GRAVITY_HINT_STRONG,
1279 Self::Line => ffi::PANGO_GRAVITY_HINT_LINE,
1280 Self::__Unknown(value) => value,
1281 }
1282 }
1283}
1284
1285#[doc(hidden)]
1286impl FromGlib<ffi::PangoGravityHint> for GravityHint {
1287 #[inline]
1288 unsafe fn from_glib(value: ffi::PangoGravityHint) -> Self {
1289 match value {
1290 ffi::PANGO_GRAVITY_HINT_NATURAL => Self::Natural,
1291 ffi::PANGO_GRAVITY_HINT_STRONG => Self::Strong,
1292 ffi::PANGO_GRAVITY_HINT_LINE => Self::Line,
1293 value => Self::__Unknown(value),
1294 }
1295 }
1296}
1297
1298impl StaticType for GravityHint {
1299 #[inline]
1300 #[doc(alias = "pango_gravity_hint_get_type")]
1301 fn static_type() -> glib::Type {
1302 unsafe { from_glib(ffi::pango_gravity_hint_get_type()) }
1303 }
1304}
1305
1306impl glib::HasParamSpec for GravityHint {
1307 type ParamSpec = glib::ParamSpecEnum;
1308 type SetValue = Self;
1309 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1310
1311 fn param_spec_builder() -> Self::BuilderFn {
1312 Self::ParamSpec::builder_with_default
1313 }
1314}
1315
1316impl glib::value::ValueType for GravityHint {
1317 type Type = Self;
1318}
1319
1320unsafe impl<'a> glib::value::FromValue<'a> for GravityHint {
1321 type Checker = glib::value::GenericValueTypeChecker<Self>;
1322
1323 #[inline]
1324 unsafe fn from_value(value: &'a glib::Value) -> Self {
1325 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1326 }
1327}
1328
1329impl ToValue for GravityHint {
1330 #[inline]
1331 fn to_value(&self) -> glib::Value {
1332 let mut value = glib::Value::for_value_type::<Self>();
1333 unsafe {
1334 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1335 }
1336 value
1337 }
1338
1339 #[inline]
1340 fn value_type(&self) -> glib::Type {
1341 Self::static_type()
1342 }
1343}
1344
1345impl From<GravityHint> for glib::Value {
1346 #[inline]
1347 fn from(v: GravityHint) -> Self {
1348 ToValue::to_value(&v)
1349 }
1350}
1351
1352#[cfg(feature = "v1_46")]
1353#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1354#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1355#[non_exhaustive]
1356#[doc(alias = "PangoOverline")]
1357pub enum Overline {
1358 #[doc(alias = "PANGO_OVERLINE_NONE")]
1359 None,
1360 #[doc(alias = "PANGO_OVERLINE_SINGLE")]
1361 Single,
1362 #[doc(hidden)]
1363 __Unknown(i32),
1364}
1365
1366#[cfg(feature = "v1_46")]
1367#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1368#[doc(hidden)]
1369impl IntoGlib for Overline {
1370 type GlibType = ffi::PangoOverline;
1371
1372 #[inline]
1373 fn into_glib(self) -> ffi::PangoOverline {
1374 match self {
1375 Self::None => ffi::PANGO_OVERLINE_NONE,
1376 Self::Single => ffi::PANGO_OVERLINE_SINGLE,
1377 Self::__Unknown(value) => value,
1378 }
1379 }
1380}
1381
1382#[cfg(feature = "v1_46")]
1383#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1384#[doc(hidden)]
1385impl FromGlib<ffi::PangoOverline> for Overline {
1386 #[inline]
1387 unsafe fn from_glib(value: ffi::PangoOverline) -> Self {
1388 match value {
1389 ffi::PANGO_OVERLINE_NONE => Self::None,
1390 ffi::PANGO_OVERLINE_SINGLE => Self::Single,
1391 value => Self::__Unknown(value),
1392 }
1393 }
1394}
1395
1396#[cfg(feature = "v1_46")]
1397#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1398impl StaticType for Overline {
1399 #[inline]
1400 #[doc(alias = "pango_overline_get_type")]
1401 fn static_type() -> glib::Type {
1402 unsafe { from_glib(ffi::pango_overline_get_type()) }
1403 }
1404}
1405
1406#[cfg(feature = "v1_46")]
1407#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1408impl glib::HasParamSpec for Overline {
1409 type ParamSpec = glib::ParamSpecEnum;
1410 type SetValue = Self;
1411 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1412
1413 fn param_spec_builder() -> Self::BuilderFn {
1414 Self::ParamSpec::builder_with_default
1415 }
1416}
1417
1418#[cfg(feature = "v1_46")]
1419#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1420impl glib::value::ValueType for Overline {
1421 type Type = Self;
1422}
1423
1424#[cfg(feature = "v1_46")]
1425#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1426unsafe impl<'a> glib::value::FromValue<'a> for Overline {
1427 type Checker = glib::value::GenericValueTypeChecker<Self>;
1428
1429 #[inline]
1430 unsafe fn from_value(value: &'a glib::Value) -> Self {
1431 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1432 }
1433}
1434
1435#[cfg(feature = "v1_46")]
1436#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1437impl ToValue for Overline {
1438 #[inline]
1439 fn to_value(&self) -> glib::Value {
1440 let mut value = glib::Value::for_value_type::<Self>();
1441 unsafe {
1442 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1443 }
1444 value
1445 }
1446
1447 #[inline]
1448 fn value_type(&self) -> glib::Type {
1449 Self::static_type()
1450 }
1451}
1452
1453#[cfg(feature = "v1_46")]
1454#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1455impl From<Overline> for glib::Value {
1456 #[inline]
1457 fn from(v: Overline) -> Self {
1458 ToValue::to_value(&v)
1459 }
1460}
1461
1462#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1463#[non_exhaustive]
1464#[doc(alias = "PangoRenderPart")]
1465pub enum RenderPart {
1466 #[doc(alias = "PANGO_RENDER_PART_FOREGROUND")]
1467 Foreground,
1468 #[doc(alias = "PANGO_RENDER_PART_BACKGROUND")]
1469 Background,
1470 #[doc(alias = "PANGO_RENDER_PART_UNDERLINE")]
1471 Underline,
1472 #[doc(alias = "PANGO_RENDER_PART_STRIKETHROUGH")]
1473 Strikethrough,
1474 #[doc(alias = "PANGO_RENDER_PART_OVERLINE")]
1475 Overline,
1476 #[doc(hidden)]
1477 __Unknown(i32),
1478}
1479
1480#[doc(hidden)]
1481impl IntoGlib for RenderPart {
1482 type GlibType = ffi::PangoRenderPart;
1483
1484 #[inline]
1485 fn into_glib(self) -> ffi::PangoRenderPart {
1486 match self {
1487 Self::Foreground => ffi::PANGO_RENDER_PART_FOREGROUND,
1488 Self::Background => ffi::PANGO_RENDER_PART_BACKGROUND,
1489 Self::Underline => ffi::PANGO_RENDER_PART_UNDERLINE,
1490 Self::Strikethrough => ffi::PANGO_RENDER_PART_STRIKETHROUGH,
1491 Self::Overline => ffi::PANGO_RENDER_PART_OVERLINE,
1492 Self::__Unknown(value) => value,
1493 }
1494 }
1495}
1496
1497#[doc(hidden)]
1498impl FromGlib<ffi::PangoRenderPart> for RenderPart {
1499 #[inline]
1500 unsafe fn from_glib(value: ffi::PangoRenderPart) -> Self {
1501 match value {
1502 ffi::PANGO_RENDER_PART_FOREGROUND => Self::Foreground,
1503 ffi::PANGO_RENDER_PART_BACKGROUND => Self::Background,
1504 ffi::PANGO_RENDER_PART_UNDERLINE => Self::Underline,
1505 ffi::PANGO_RENDER_PART_STRIKETHROUGH => Self::Strikethrough,
1506 ffi::PANGO_RENDER_PART_OVERLINE => Self::Overline,
1507 value => Self::__Unknown(value),
1508 }
1509 }
1510}
1511
1512impl StaticType for RenderPart {
1513 #[inline]
1514 #[doc(alias = "pango_render_part_get_type")]
1515 fn static_type() -> glib::Type {
1516 unsafe { from_glib(ffi::pango_render_part_get_type()) }
1517 }
1518}
1519
1520impl glib::HasParamSpec for RenderPart {
1521 type ParamSpec = glib::ParamSpecEnum;
1522 type SetValue = Self;
1523 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1524
1525 fn param_spec_builder() -> Self::BuilderFn {
1526 Self::ParamSpec::builder_with_default
1527 }
1528}
1529
1530impl glib::value::ValueType for RenderPart {
1531 type Type = Self;
1532}
1533
1534unsafe impl<'a> glib::value::FromValue<'a> for RenderPart {
1535 type Checker = glib::value::GenericValueTypeChecker<Self>;
1536
1537 #[inline]
1538 unsafe fn from_value(value: &'a glib::Value) -> Self {
1539 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1540 }
1541}
1542
1543impl ToValue for RenderPart {
1544 #[inline]
1545 fn to_value(&self) -> glib::Value {
1546 let mut value = glib::Value::for_value_type::<Self>();
1547 unsafe {
1548 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1549 }
1550 value
1551 }
1552
1553 #[inline]
1554 fn value_type(&self) -> glib::Type {
1555 Self::static_type()
1556 }
1557}
1558
1559impl From<RenderPart> for glib::Value {
1560 #[inline]
1561 fn from(v: RenderPart) -> Self {
1562 ToValue::to_value(&v)
1563 }
1564}
1565
1566#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1567#[non_exhaustive]
1568#[doc(alias = "PangoScript")]
1569pub enum Script {
1570 #[doc(alias = "PANGO_SCRIPT_INVALID_CODE")]
1571 InvalidCode,
1572 #[doc(alias = "PANGO_SCRIPT_COMMON")]
1573 Common,
1574 #[doc(alias = "PANGO_SCRIPT_INHERITED")]
1575 Inherited,
1576 #[doc(alias = "PANGO_SCRIPT_ARABIC")]
1577 Arabic,
1578 #[doc(alias = "PANGO_SCRIPT_ARMENIAN")]
1579 Armenian,
1580 #[doc(alias = "PANGO_SCRIPT_BENGALI")]
1581 Bengali,
1582 #[doc(alias = "PANGO_SCRIPT_BOPOMOFO")]
1583 Bopomofo,
1584 #[doc(alias = "PANGO_SCRIPT_CHEROKEE")]
1585 Cherokee,
1586 #[doc(alias = "PANGO_SCRIPT_COPTIC")]
1587 Coptic,
1588 #[doc(alias = "PANGO_SCRIPT_CYRILLIC")]
1589 Cyrillic,
1590 #[doc(alias = "PANGO_SCRIPT_DESERET")]
1591 Deseret,
1592 #[doc(alias = "PANGO_SCRIPT_DEVANAGARI")]
1593 Devanagari,
1594 #[doc(alias = "PANGO_SCRIPT_ETHIOPIC")]
1595 Ethiopic,
1596 #[doc(alias = "PANGO_SCRIPT_GEORGIAN")]
1597 Georgian,
1598 #[doc(alias = "PANGO_SCRIPT_GOTHIC")]
1599 Gothic,
1600 #[doc(alias = "PANGO_SCRIPT_GREEK")]
1601 Greek,
1602 #[doc(alias = "PANGO_SCRIPT_GUJARATI")]
1603 Gujarati,
1604 #[doc(alias = "PANGO_SCRIPT_GURMUKHI")]
1605 Gurmukhi,
1606 #[doc(alias = "PANGO_SCRIPT_HAN")]
1607 Han,
1608 #[doc(alias = "PANGO_SCRIPT_HANGUL")]
1609 Hangul,
1610 #[doc(alias = "PANGO_SCRIPT_HEBREW")]
1611 Hebrew,
1612 #[doc(alias = "PANGO_SCRIPT_HIRAGANA")]
1613 Hiragana,
1614 #[doc(alias = "PANGO_SCRIPT_KANNADA")]
1615 Kannada,
1616 #[doc(alias = "PANGO_SCRIPT_KATAKANA")]
1617 Katakana,
1618 #[doc(alias = "PANGO_SCRIPT_KHMER")]
1619 Khmer,
1620 #[doc(alias = "PANGO_SCRIPT_LAO")]
1621 Lao,
1622 #[doc(alias = "PANGO_SCRIPT_LATIN")]
1623 Latin,
1624 #[doc(alias = "PANGO_SCRIPT_MALAYALAM")]
1625 Malayalam,
1626 #[doc(alias = "PANGO_SCRIPT_MONGOLIAN")]
1627 Mongolian,
1628 #[doc(alias = "PANGO_SCRIPT_MYANMAR")]
1629 Myanmar,
1630 #[doc(alias = "PANGO_SCRIPT_OGHAM")]
1631 Ogham,
1632 #[doc(alias = "PANGO_SCRIPT_OLD_ITALIC")]
1633 OldItalic,
1634 #[doc(alias = "PANGO_SCRIPT_ORIYA")]
1635 Oriya,
1636 #[doc(alias = "PANGO_SCRIPT_RUNIC")]
1637 Runic,
1638 #[doc(alias = "PANGO_SCRIPT_SINHALA")]
1639 Sinhala,
1640 #[doc(alias = "PANGO_SCRIPT_SYRIAC")]
1641 Syriac,
1642 #[doc(alias = "PANGO_SCRIPT_TAMIL")]
1643 Tamil,
1644 #[doc(alias = "PANGO_SCRIPT_TELUGU")]
1645 Telugu,
1646 #[doc(alias = "PANGO_SCRIPT_THAANA")]
1647 Thaana,
1648 #[doc(alias = "PANGO_SCRIPT_THAI")]
1649 Thai,
1650 #[doc(alias = "PANGO_SCRIPT_TIBETAN")]
1651 Tibetan,
1652 #[doc(alias = "PANGO_SCRIPT_CANADIAN_ABORIGINAL")]
1653 CanadianAboriginal,
1654 #[doc(alias = "PANGO_SCRIPT_YI")]
1655 Yi,
1656 #[doc(alias = "PANGO_SCRIPT_TAGALOG")]
1657 Tagalog,
1658 #[doc(alias = "PANGO_SCRIPT_HANUNOO")]
1659 Hanunoo,
1660 #[doc(alias = "PANGO_SCRIPT_BUHID")]
1661 Buhid,
1662 #[doc(alias = "PANGO_SCRIPT_TAGBANWA")]
1663 Tagbanwa,
1664 #[doc(alias = "PANGO_SCRIPT_BRAILLE")]
1665 Braille,
1666 #[doc(alias = "PANGO_SCRIPT_CYPRIOT")]
1667 Cypriot,
1668 #[doc(alias = "PANGO_SCRIPT_LIMBU")]
1669 Limbu,
1670 #[doc(alias = "PANGO_SCRIPT_OSMANYA")]
1671 Osmanya,
1672 #[doc(alias = "PANGO_SCRIPT_SHAVIAN")]
1673 Shavian,
1674 #[doc(alias = "PANGO_SCRIPT_LINEAR_B")]
1675 LinearB,
1676 #[doc(alias = "PANGO_SCRIPT_TAI_LE")]
1677 TaiLe,
1678 #[doc(alias = "PANGO_SCRIPT_UGARITIC")]
1679 Ugaritic,
1680 #[doc(alias = "PANGO_SCRIPT_NEW_TAI_LUE")]
1681 NewTaiLue,
1682 #[doc(alias = "PANGO_SCRIPT_BUGINESE")]
1683 Buginese,
1684 #[doc(alias = "PANGO_SCRIPT_GLAGOLITIC")]
1685 Glagolitic,
1686 #[doc(alias = "PANGO_SCRIPT_TIFINAGH")]
1687 Tifinagh,
1688 #[doc(alias = "PANGO_SCRIPT_SYLOTI_NAGRI")]
1689 SylotiNagri,
1690 #[doc(alias = "PANGO_SCRIPT_OLD_PERSIAN")]
1691 OldPersian,
1692 #[doc(alias = "PANGO_SCRIPT_KHAROSHTHI")]
1693 Kharoshthi,
1694 #[doc(alias = "PANGO_SCRIPT_UNKNOWN")]
1695 Unknown,
1696 #[doc(alias = "PANGO_SCRIPT_BALINESE")]
1697 Balinese,
1698 #[doc(alias = "PANGO_SCRIPT_CUNEIFORM")]
1699 Cuneiform,
1700 #[doc(alias = "PANGO_SCRIPT_PHOENICIAN")]
1701 Phoenician,
1702 #[doc(alias = "PANGO_SCRIPT_PHAGS_PA")]
1703 PhagsPa,
1704 #[doc(alias = "PANGO_SCRIPT_NKO")]
1705 Nko,
1706 #[doc(alias = "PANGO_SCRIPT_KAYAH_LI")]
1707 KayahLi,
1708 #[doc(alias = "PANGO_SCRIPT_LEPCHA")]
1709 Lepcha,
1710 #[doc(alias = "PANGO_SCRIPT_REJANG")]
1711 Rejang,
1712 #[doc(alias = "PANGO_SCRIPT_SUNDANESE")]
1713 Sundanese,
1714 #[doc(alias = "PANGO_SCRIPT_SAURASHTRA")]
1715 Saurashtra,
1716 #[doc(alias = "PANGO_SCRIPT_CHAM")]
1717 Cham,
1718 #[doc(alias = "PANGO_SCRIPT_OL_CHIKI")]
1719 OlChiki,
1720 #[doc(alias = "PANGO_SCRIPT_VAI")]
1721 Vai,
1722 #[doc(alias = "PANGO_SCRIPT_CARIAN")]
1723 Carian,
1724 #[doc(alias = "PANGO_SCRIPT_LYCIAN")]
1725 Lycian,
1726 #[doc(alias = "PANGO_SCRIPT_LYDIAN")]
1727 Lydian,
1728 #[doc(alias = "PANGO_SCRIPT_BATAK")]
1729 Batak,
1730 #[doc(alias = "PANGO_SCRIPT_BRAHMI")]
1731 Brahmi,
1732 #[doc(alias = "PANGO_SCRIPT_MANDAIC")]
1733 Mandaic,
1734 #[doc(alias = "PANGO_SCRIPT_CHAKMA")]
1735 Chakma,
1736 #[doc(alias = "PANGO_SCRIPT_MEROITIC_CURSIVE")]
1737 MeroiticCursive,
1738 #[doc(alias = "PANGO_SCRIPT_MEROITIC_HIEROGLYPHS")]
1739 MeroiticHieroglyphs,
1740 #[doc(alias = "PANGO_SCRIPT_MIAO")]
1741 Miao,
1742 #[doc(alias = "PANGO_SCRIPT_SHARADA")]
1743 Sharada,
1744 #[doc(alias = "PANGO_SCRIPT_SORA_SOMPENG")]
1745 SoraSompeng,
1746 #[doc(alias = "PANGO_SCRIPT_TAKRI")]
1747 Takri,
1748 #[doc(alias = "PANGO_SCRIPT_BASSA_VAH")]
1749 BassaVah,
1750 #[doc(alias = "PANGO_SCRIPT_CAUCASIAN_ALBANIAN")]
1751 CaucasianAlbanian,
1752 #[doc(alias = "PANGO_SCRIPT_DUPLOYAN")]
1753 Duployan,
1754 #[doc(alias = "PANGO_SCRIPT_ELBASAN")]
1755 Elbasan,
1756 #[doc(alias = "PANGO_SCRIPT_GRANTHA")]
1757 Grantha,
1758 #[doc(alias = "PANGO_SCRIPT_KHOJKI")]
1759 Khojki,
1760 #[doc(alias = "PANGO_SCRIPT_KHUDAWADI")]
1761 Khudawadi,
1762 #[doc(alias = "PANGO_SCRIPT_LINEAR_A")]
1763 LinearA,
1764 #[doc(alias = "PANGO_SCRIPT_MAHAJANI")]
1765 Mahajani,
1766 #[doc(alias = "PANGO_SCRIPT_MANICHAEAN")]
1767 Manichaean,
1768 #[doc(alias = "PANGO_SCRIPT_MENDE_KIKAKUI")]
1769 MendeKikakui,
1770 #[doc(alias = "PANGO_SCRIPT_MODI")]
1771 Modi,
1772 #[doc(alias = "PANGO_SCRIPT_MRO")]
1773 Mro,
1774 #[doc(alias = "PANGO_SCRIPT_NABATAEAN")]
1775 Nabataean,
1776 #[doc(alias = "PANGO_SCRIPT_OLD_NORTH_ARABIAN")]
1777 OldNorthArabian,
1778 #[doc(alias = "PANGO_SCRIPT_OLD_PERMIC")]
1779 OldPermic,
1780 #[doc(alias = "PANGO_SCRIPT_PAHAWH_HMONG")]
1781 PahawhHmong,
1782 #[doc(alias = "PANGO_SCRIPT_PALMYRENE")]
1783 Palmyrene,
1784 #[doc(alias = "PANGO_SCRIPT_PAU_CIN_HAU")]
1785 PauCinHau,
1786 #[doc(alias = "PANGO_SCRIPT_PSALTER_PAHLAVI")]
1787 PsalterPahlavi,
1788 #[doc(alias = "PANGO_SCRIPT_SIDDHAM")]
1789 Siddham,
1790 #[doc(alias = "PANGO_SCRIPT_TIRHUTA")]
1791 Tirhuta,
1792 #[doc(alias = "PANGO_SCRIPT_WARANG_CITI")]
1793 WarangCiti,
1794 #[doc(alias = "PANGO_SCRIPT_AHOM")]
1795 Ahom,
1796 #[doc(alias = "PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS")]
1797 AnatolianHieroglyphs,
1798 #[doc(alias = "PANGO_SCRIPT_HATRAN")]
1799 Hatran,
1800 #[doc(alias = "PANGO_SCRIPT_MULTANI")]
1801 Multani,
1802 #[doc(alias = "PANGO_SCRIPT_OLD_HUNGARIAN")]
1803 OldHungarian,
1804 #[doc(alias = "PANGO_SCRIPT_SIGNWRITING")]
1805 Signwriting,
1806 #[doc(hidden)]
1807 __Unknown(i32),
1808}
1809
1810impl Script {
1811 #[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")]
1812 #[allow(deprecated)]
1813 #[doc(alias = "pango_script_for_unichar")]
1814 pub fn for_unichar(ch: char) -> Script {
1815 unsafe { from_glib(ffi::pango_script_for_unichar(ch.into_glib())) }
1816 }
1817
1818 #[doc(alias = "pango_script_get_sample_language")]
1819 #[doc(alias = "get_sample_language")]
1820 pub fn sample_language(self) -> Option<Language> {
1821 unsafe { from_glib_full(ffi::pango_script_get_sample_language(self.into_glib())) }
1822 }
1823}
1824
1825#[doc(hidden)]
1826impl IntoGlib for Script {
1827 type GlibType = ffi::PangoScript;
1828
1829 fn into_glib(self) -> ffi::PangoScript {
1830 match self {
1831 Self::InvalidCode => ffi::PANGO_SCRIPT_INVALID_CODE,
1832 Self::Common => ffi::PANGO_SCRIPT_COMMON,
1833 Self::Inherited => ffi::PANGO_SCRIPT_INHERITED,
1834 Self::Arabic => ffi::PANGO_SCRIPT_ARABIC,
1835 Self::Armenian => ffi::PANGO_SCRIPT_ARMENIAN,
1836 Self::Bengali => ffi::PANGO_SCRIPT_BENGALI,
1837 Self::Bopomofo => ffi::PANGO_SCRIPT_BOPOMOFO,
1838 Self::Cherokee => ffi::PANGO_SCRIPT_CHEROKEE,
1839 Self::Coptic => ffi::PANGO_SCRIPT_COPTIC,
1840 Self::Cyrillic => ffi::PANGO_SCRIPT_CYRILLIC,
1841 Self::Deseret => ffi::PANGO_SCRIPT_DESERET,
1842 Self::Devanagari => ffi::PANGO_SCRIPT_DEVANAGARI,
1843 Self::Ethiopic => ffi::PANGO_SCRIPT_ETHIOPIC,
1844 Self::Georgian => ffi::PANGO_SCRIPT_GEORGIAN,
1845 Self::Gothic => ffi::PANGO_SCRIPT_GOTHIC,
1846 Self::Greek => ffi::PANGO_SCRIPT_GREEK,
1847 Self::Gujarati => ffi::PANGO_SCRIPT_GUJARATI,
1848 Self::Gurmukhi => ffi::PANGO_SCRIPT_GURMUKHI,
1849 Self::Han => ffi::PANGO_SCRIPT_HAN,
1850 Self::Hangul => ffi::PANGO_SCRIPT_HANGUL,
1851 Self::Hebrew => ffi::PANGO_SCRIPT_HEBREW,
1852 Self::Hiragana => ffi::PANGO_SCRIPT_HIRAGANA,
1853 Self::Kannada => ffi::PANGO_SCRIPT_KANNADA,
1854 Self::Katakana => ffi::PANGO_SCRIPT_KATAKANA,
1855 Self::Khmer => ffi::PANGO_SCRIPT_KHMER,
1856 Self::Lao => ffi::PANGO_SCRIPT_LAO,
1857 Self::Latin => ffi::PANGO_SCRIPT_LATIN,
1858 Self::Malayalam => ffi::PANGO_SCRIPT_MALAYALAM,
1859 Self::Mongolian => ffi::PANGO_SCRIPT_MONGOLIAN,
1860 Self::Myanmar => ffi::PANGO_SCRIPT_MYANMAR,
1861 Self::Ogham => ffi::PANGO_SCRIPT_OGHAM,
1862 Self::OldItalic => ffi::PANGO_SCRIPT_OLD_ITALIC,
1863 Self::Oriya => ffi::PANGO_SCRIPT_ORIYA,
1864 Self::Runic => ffi::PANGO_SCRIPT_RUNIC,
1865 Self::Sinhala => ffi::PANGO_SCRIPT_SINHALA,
1866 Self::Syriac => ffi::PANGO_SCRIPT_SYRIAC,
1867 Self::Tamil => ffi::PANGO_SCRIPT_TAMIL,
1868 Self::Telugu => ffi::PANGO_SCRIPT_TELUGU,
1869 Self::Thaana => ffi::PANGO_SCRIPT_THAANA,
1870 Self::Thai => ffi::PANGO_SCRIPT_THAI,
1871 Self::Tibetan => ffi::PANGO_SCRIPT_TIBETAN,
1872 Self::CanadianAboriginal => ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL,
1873 Self::Yi => ffi::PANGO_SCRIPT_YI,
1874 Self::Tagalog => ffi::PANGO_SCRIPT_TAGALOG,
1875 Self::Hanunoo => ffi::PANGO_SCRIPT_HANUNOO,
1876 Self::Buhid => ffi::PANGO_SCRIPT_BUHID,
1877 Self::Tagbanwa => ffi::PANGO_SCRIPT_TAGBANWA,
1878 Self::Braille => ffi::PANGO_SCRIPT_BRAILLE,
1879 Self::Cypriot => ffi::PANGO_SCRIPT_CYPRIOT,
1880 Self::Limbu => ffi::PANGO_SCRIPT_LIMBU,
1881 Self::Osmanya => ffi::PANGO_SCRIPT_OSMANYA,
1882 Self::Shavian => ffi::PANGO_SCRIPT_SHAVIAN,
1883 Self::LinearB => ffi::PANGO_SCRIPT_LINEAR_B,
1884 Self::TaiLe => ffi::PANGO_SCRIPT_TAI_LE,
1885 Self::Ugaritic => ffi::PANGO_SCRIPT_UGARITIC,
1886 Self::NewTaiLue => ffi::PANGO_SCRIPT_NEW_TAI_LUE,
1887 Self::Buginese => ffi::PANGO_SCRIPT_BUGINESE,
1888 Self::Glagolitic => ffi::PANGO_SCRIPT_GLAGOLITIC,
1889 Self::Tifinagh => ffi::PANGO_SCRIPT_TIFINAGH,
1890 Self::SylotiNagri => ffi::PANGO_SCRIPT_SYLOTI_NAGRI,
1891 Self::OldPersian => ffi::PANGO_SCRIPT_OLD_PERSIAN,
1892 Self::Kharoshthi => ffi::PANGO_SCRIPT_KHAROSHTHI,
1893 Self::Unknown => ffi::PANGO_SCRIPT_UNKNOWN,
1894 Self::Balinese => ffi::PANGO_SCRIPT_BALINESE,
1895 Self::Cuneiform => ffi::PANGO_SCRIPT_CUNEIFORM,
1896 Self::Phoenician => ffi::PANGO_SCRIPT_PHOENICIAN,
1897 Self::PhagsPa => ffi::PANGO_SCRIPT_PHAGS_PA,
1898 Self::Nko => ffi::PANGO_SCRIPT_NKO,
1899 Self::KayahLi => ffi::PANGO_SCRIPT_KAYAH_LI,
1900 Self::Lepcha => ffi::PANGO_SCRIPT_LEPCHA,
1901 Self::Rejang => ffi::PANGO_SCRIPT_REJANG,
1902 Self::Sundanese => ffi::PANGO_SCRIPT_SUNDANESE,
1903 Self::Saurashtra => ffi::PANGO_SCRIPT_SAURASHTRA,
1904 Self::Cham => ffi::PANGO_SCRIPT_CHAM,
1905 Self::OlChiki => ffi::PANGO_SCRIPT_OL_CHIKI,
1906 Self::Vai => ffi::PANGO_SCRIPT_VAI,
1907 Self::Carian => ffi::PANGO_SCRIPT_CARIAN,
1908 Self::Lycian => ffi::PANGO_SCRIPT_LYCIAN,
1909 Self::Lydian => ffi::PANGO_SCRIPT_LYDIAN,
1910 Self::Batak => ffi::PANGO_SCRIPT_BATAK,
1911 Self::Brahmi => ffi::PANGO_SCRIPT_BRAHMI,
1912 Self::Mandaic => ffi::PANGO_SCRIPT_MANDAIC,
1913 Self::Chakma => ffi::PANGO_SCRIPT_CHAKMA,
1914 Self::MeroiticCursive => ffi::PANGO_SCRIPT_MEROITIC_CURSIVE,
1915 Self::MeroiticHieroglyphs => ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS,
1916 Self::Miao => ffi::PANGO_SCRIPT_MIAO,
1917 Self::Sharada => ffi::PANGO_SCRIPT_SHARADA,
1918 Self::SoraSompeng => ffi::PANGO_SCRIPT_SORA_SOMPENG,
1919 Self::Takri => ffi::PANGO_SCRIPT_TAKRI,
1920 Self::BassaVah => ffi::PANGO_SCRIPT_BASSA_VAH,
1921 Self::CaucasianAlbanian => ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN,
1922 Self::Duployan => ffi::PANGO_SCRIPT_DUPLOYAN,
1923 Self::Elbasan => ffi::PANGO_SCRIPT_ELBASAN,
1924 Self::Grantha => ffi::PANGO_SCRIPT_GRANTHA,
1925 Self::Khojki => ffi::PANGO_SCRIPT_KHOJKI,
1926 Self::Khudawadi => ffi::PANGO_SCRIPT_KHUDAWADI,
1927 Self::LinearA => ffi::PANGO_SCRIPT_LINEAR_A,
1928 Self::Mahajani => ffi::PANGO_SCRIPT_MAHAJANI,
1929 Self::Manichaean => ffi::PANGO_SCRIPT_MANICHAEAN,
1930 Self::MendeKikakui => ffi::PANGO_SCRIPT_MENDE_KIKAKUI,
1931 Self::Modi => ffi::PANGO_SCRIPT_MODI,
1932 Self::Mro => ffi::PANGO_SCRIPT_MRO,
1933 Self::Nabataean => ffi::PANGO_SCRIPT_NABATAEAN,
1934 Self::OldNorthArabian => ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN,
1935 Self::OldPermic => ffi::PANGO_SCRIPT_OLD_PERMIC,
1936 Self::PahawhHmong => ffi::PANGO_SCRIPT_PAHAWH_HMONG,
1937 Self::Palmyrene => ffi::PANGO_SCRIPT_PALMYRENE,
1938 Self::PauCinHau => ffi::PANGO_SCRIPT_PAU_CIN_HAU,
1939 Self::PsalterPahlavi => ffi::PANGO_SCRIPT_PSALTER_PAHLAVI,
1940 Self::Siddham => ffi::PANGO_SCRIPT_SIDDHAM,
1941 Self::Tirhuta => ffi::PANGO_SCRIPT_TIRHUTA,
1942 Self::WarangCiti => ffi::PANGO_SCRIPT_WARANG_CITI,
1943 Self::Ahom => ffi::PANGO_SCRIPT_AHOM,
1944 Self::AnatolianHieroglyphs => ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS,
1945 Self::Hatran => ffi::PANGO_SCRIPT_HATRAN,
1946 Self::Multani => ffi::PANGO_SCRIPT_MULTANI,
1947 Self::OldHungarian => ffi::PANGO_SCRIPT_OLD_HUNGARIAN,
1948 Self::Signwriting => ffi::PANGO_SCRIPT_SIGNWRITING,
1949 Self::__Unknown(value) => value,
1950 }
1951 }
1952}
1953
1954#[doc(hidden)]
1955impl FromGlib<ffi::PangoScript> for Script {
1956 unsafe fn from_glib(value: ffi::PangoScript) -> Self {
1957 match value {
1958 ffi::PANGO_SCRIPT_INVALID_CODE => Self::InvalidCode,
1959 ffi::PANGO_SCRIPT_COMMON => Self::Common,
1960 ffi::PANGO_SCRIPT_INHERITED => Self::Inherited,
1961 ffi::PANGO_SCRIPT_ARABIC => Self::Arabic,
1962 ffi::PANGO_SCRIPT_ARMENIAN => Self::Armenian,
1963 ffi::PANGO_SCRIPT_BENGALI => Self::Bengali,
1964 ffi::PANGO_SCRIPT_BOPOMOFO => Self::Bopomofo,
1965 ffi::PANGO_SCRIPT_CHEROKEE => Self::Cherokee,
1966 ffi::PANGO_SCRIPT_COPTIC => Self::Coptic,
1967 ffi::PANGO_SCRIPT_CYRILLIC => Self::Cyrillic,
1968 ffi::PANGO_SCRIPT_DESERET => Self::Deseret,
1969 ffi::PANGO_SCRIPT_DEVANAGARI => Self::Devanagari,
1970 ffi::PANGO_SCRIPT_ETHIOPIC => Self::Ethiopic,
1971 ffi::PANGO_SCRIPT_GEORGIAN => Self::Georgian,
1972 ffi::PANGO_SCRIPT_GOTHIC => Self::Gothic,
1973 ffi::PANGO_SCRIPT_GREEK => Self::Greek,
1974 ffi::PANGO_SCRIPT_GUJARATI => Self::Gujarati,
1975 ffi::PANGO_SCRIPT_GURMUKHI => Self::Gurmukhi,
1976 ffi::PANGO_SCRIPT_HAN => Self::Han,
1977 ffi::PANGO_SCRIPT_HANGUL => Self::Hangul,
1978 ffi::PANGO_SCRIPT_HEBREW => Self::Hebrew,
1979 ffi::PANGO_SCRIPT_HIRAGANA => Self::Hiragana,
1980 ffi::PANGO_SCRIPT_KANNADA => Self::Kannada,
1981 ffi::PANGO_SCRIPT_KATAKANA => Self::Katakana,
1982 ffi::PANGO_SCRIPT_KHMER => Self::Khmer,
1983 ffi::PANGO_SCRIPT_LAO => Self::Lao,
1984 ffi::PANGO_SCRIPT_LATIN => Self::Latin,
1985 ffi::PANGO_SCRIPT_MALAYALAM => Self::Malayalam,
1986 ffi::PANGO_SCRIPT_MONGOLIAN => Self::Mongolian,
1987 ffi::PANGO_SCRIPT_MYANMAR => Self::Myanmar,
1988 ffi::PANGO_SCRIPT_OGHAM => Self::Ogham,
1989 ffi::PANGO_SCRIPT_OLD_ITALIC => Self::OldItalic,
1990 ffi::PANGO_SCRIPT_ORIYA => Self::Oriya,
1991 ffi::PANGO_SCRIPT_RUNIC => Self::Runic,
1992 ffi::PANGO_SCRIPT_SINHALA => Self::Sinhala,
1993 ffi::PANGO_SCRIPT_SYRIAC => Self::Syriac,
1994 ffi::PANGO_SCRIPT_TAMIL => Self::Tamil,
1995 ffi::PANGO_SCRIPT_TELUGU => Self::Telugu,
1996 ffi::PANGO_SCRIPT_THAANA => Self::Thaana,
1997 ffi::PANGO_SCRIPT_THAI => Self::Thai,
1998 ffi::PANGO_SCRIPT_TIBETAN => Self::Tibetan,
1999 ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL => Self::CanadianAboriginal,
2000 ffi::PANGO_SCRIPT_YI => Self::Yi,
2001 ffi::PANGO_SCRIPT_TAGALOG => Self::Tagalog,
2002 ffi::PANGO_SCRIPT_HANUNOO => Self::Hanunoo,
2003 ffi::PANGO_SCRIPT_BUHID => Self::Buhid,
2004 ffi::PANGO_SCRIPT_TAGBANWA => Self::Tagbanwa,
2005 ffi::PANGO_SCRIPT_BRAILLE => Self::Braille,
2006 ffi::PANGO_SCRIPT_CYPRIOT => Self::Cypriot,
2007 ffi::PANGO_SCRIPT_LIMBU => Self::Limbu,
2008 ffi::PANGO_SCRIPT_OSMANYA => Self::Osmanya,
2009 ffi::PANGO_SCRIPT_SHAVIAN => Self::Shavian,
2010 ffi::PANGO_SCRIPT_LINEAR_B => Self::LinearB,
2011 ffi::PANGO_SCRIPT_TAI_LE => Self::TaiLe,
2012 ffi::PANGO_SCRIPT_UGARITIC => Self::Ugaritic,
2013 ffi::PANGO_SCRIPT_NEW_TAI_LUE => Self::NewTaiLue,
2014 ffi::PANGO_SCRIPT_BUGINESE => Self::Buginese,
2015 ffi::PANGO_SCRIPT_GLAGOLITIC => Self::Glagolitic,
2016 ffi::PANGO_SCRIPT_TIFINAGH => Self::Tifinagh,
2017 ffi::PANGO_SCRIPT_SYLOTI_NAGRI => Self::SylotiNagri,
2018 ffi::PANGO_SCRIPT_OLD_PERSIAN => Self::OldPersian,
2019 ffi::PANGO_SCRIPT_KHAROSHTHI => Self::Kharoshthi,
2020 ffi::PANGO_SCRIPT_UNKNOWN => Self::Unknown,
2021 ffi::PANGO_SCRIPT_BALINESE => Self::Balinese,
2022 ffi::PANGO_SCRIPT_CUNEIFORM => Self::Cuneiform,
2023 ffi::PANGO_SCRIPT_PHOENICIAN => Self::Phoenician,
2024 ffi::PANGO_SCRIPT_PHAGS_PA => Self::PhagsPa,
2025 ffi::PANGO_SCRIPT_NKO => Self::Nko,
2026 ffi::PANGO_SCRIPT_KAYAH_LI => Self::KayahLi,
2027 ffi::PANGO_SCRIPT_LEPCHA => Self::Lepcha,
2028 ffi::PANGO_SCRIPT_REJANG => Self::Rejang,
2029 ffi::PANGO_SCRIPT_SUNDANESE => Self::Sundanese,
2030 ffi::PANGO_SCRIPT_SAURASHTRA => Self::Saurashtra,
2031 ffi::PANGO_SCRIPT_CHAM => Self::Cham,
2032 ffi::PANGO_SCRIPT_OL_CHIKI => Self::OlChiki,
2033 ffi::PANGO_SCRIPT_VAI => Self::Vai,
2034 ffi::PANGO_SCRIPT_CARIAN => Self::Carian,
2035 ffi::PANGO_SCRIPT_LYCIAN => Self::Lycian,
2036 ffi::PANGO_SCRIPT_LYDIAN => Self::Lydian,
2037 ffi::PANGO_SCRIPT_BATAK => Self::Batak,
2038 ffi::PANGO_SCRIPT_BRAHMI => Self::Brahmi,
2039 ffi::PANGO_SCRIPT_MANDAIC => Self::Mandaic,
2040 ffi::PANGO_SCRIPT_CHAKMA => Self::Chakma,
2041 ffi::PANGO_SCRIPT_MEROITIC_CURSIVE => Self::MeroiticCursive,
2042 ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS => Self::MeroiticHieroglyphs,
2043 ffi::PANGO_SCRIPT_MIAO => Self::Miao,
2044 ffi::PANGO_SCRIPT_SHARADA => Self::Sharada,
2045 ffi::PANGO_SCRIPT_SORA_SOMPENG => Self::SoraSompeng,
2046 ffi::PANGO_SCRIPT_TAKRI => Self::Takri,
2047 ffi::PANGO_SCRIPT_BASSA_VAH => Self::BassaVah,
2048 ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN => Self::CaucasianAlbanian,
2049 ffi::PANGO_SCRIPT_DUPLOYAN => Self::Duployan,
2050 ffi::PANGO_SCRIPT_ELBASAN => Self::Elbasan,
2051 ffi::PANGO_SCRIPT_GRANTHA => Self::Grantha,
2052 ffi::PANGO_SCRIPT_KHOJKI => Self::Khojki,
2053 ffi::PANGO_SCRIPT_KHUDAWADI => Self::Khudawadi,
2054 ffi::PANGO_SCRIPT_LINEAR_A => Self::LinearA,
2055 ffi::PANGO_SCRIPT_MAHAJANI => Self::Mahajani,
2056 ffi::PANGO_SCRIPT_MANICHAEAN => Self::Manichaean,
2057 ffi::PANGO_SCRIPT_MENDE_KIKAKUI => Self::MendeKikakui,
2058 ffi::PANGO_SCRIPT_MODI => Self::Modi,
2059 ffi::PANGO_SCRIPT_MRO => Self::Mro,
2060 ffi::PANGO_SCRIPT_NABATAEAN => Self::Nabataean,
2061 ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN => Self::OldNorthArabian,
2062 ffi::PANGO_SCRIPT_OLD_PERMIC => Self::OldPermic,
2063 ffi::PANGO_SCRIPT_PAHAWH_HMONG => Self::PahawhHmong,
2064 ffi::PANGO_SCRIPT_PALMYRENE => Self::Palmyrene,
2065 ffi::PANGO_SCRIPT_PAU_CIN_HAU => Self::PauCinHau,
2066 ffi::PANGO_SCRIPT_PSALTER_PAHLAVI => Self::PsalterPahlavi,
2067 ffi::PANGO_SCRIPT_SIDDHAM => Self::Siddham,
2068 ffi::PANGO_SCRIPT_TIRHUTA => Self::Tirhuta,
2069 ffi::PANGO_SCRIPT_WARANG_CITI => Self::WarangCiti,
2070 ffi::PANGO_SCRIPT_AHOM => Self::Ahom,
2071 ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS => Self::AnatolianHieroglyphs,
2072 ffi::PANGO_SCRIPT_HATRAN => Self::Hatran,
2073 ffi::PANGO_SCRIPT_MULTANI => Self::Multani,
2074 ffi::PANGO_SCRIPT_OLD_HUNGARIAN => Self::OldHungarian,
2075 ffi::PANGO_SCRIPT_SIGNWRITING => Self::Signwriting,
2076 value => Self::__Unknown(value),
2077 }
2078 }
2079}
2080
2081impl StaticType for Script {
2082 #[inline]
2083 #[doc(alias = "pango_script_get_type")]
2084 fn static_type() -> glib::Type {
2085 unsafe { from_glib(ffi::pango_script_get_type()) }
2086 }
2087}
2088
2089impl glib::HasParamSpec for Script {
2090 type ParamSpec = glib::ParamSpecEnum;
2091 type SetValue = Self;
2092 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2093
2094 fn param_spec_builder() -> Self::BuilderFn {
2095 Self::ParamSpec::builder_with_default
2096 }
2097}
2098
2099impl glib::value::ValueType for Script {
2100 type Type = Self;
2101}
2102
2103unsafe impl<'a> glib::value::FromValue<'a> for Script {
2104 type Checker = glib::value::GenericValueTypeChecker<Self>;
2105
2106 #[inline]
2107 unsafe fn from_value(value: &'a glib::Value) -> Self {
2108 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2109 }
2110}
2111
2112impl ToValue for Script {
2113 #[inline]
2114 fn to_value(&self) -> glib::Value {
2115 let mut value = glib::Value::for_value_type::<Self>();
2116 unsafe {
2117 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2118 }
2119 value
2120 }
2121
2122 #[inline]
2123 fn value_type(&self) -> glib::Type {
2124 Self::static_type()
2125 }
2126}
2127
2128impl From<Script> for glib::Value {
2129 #[inline]
2130 fn from(v: Script) -> Self {
2131 ToValue::to_value(&v)
2132 }
2133}
2134
2135#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2136#[non_exhaustive]
2137#[doc(alias = "PangoStretch")]
2138pub enum Stretch {
2139 #[doc(alias = "PANGO_STRETCH_ULTRA_CONDENSED")]
2140 UltraCondensed,
2141 #[doc(alias = "PANGO_STRETCH_EXTRA_CONDENSED")]
2142 ExtraCondensed,
2143 #[doc(alias = "PANGO_STRETCH_CONDENSED")]
2144 Condensed,
2145 #[doc(alias = "PANGO_STRETCH_SEMI_CONDENSED")]
2146 SemiCondensed,
2147 #[doc(alias = "PANGO_STRETCH_NORMAL")]
2148 Normal,
2149 #[doc(alias = "PANGO_STRETCH_SEMI_EXPANDED")]
2150 SemiExpanded,
2151 #[doc(alias = "PANGO_STRETCH_EXPANDED")]
2152 Expanded,
2153 #[doc(alias = "PANGO_STRETCH_EXTRA_EXPANDED")]
2154 ExtraExpanded,
2155 #[doc(alias = "PANGO_STRETCH_ULTRA_EXPANDED")]
2156 UltraExpanded,
2157 #[doc(hidden)]
2158 __Unknown(i32),
2159}
2160
2161#[doc(hidden)]
2162impl IntoGlib for Stretch {
2163 type GlibType = ffi::PangoStretch;
2164
2165 #[inline]
2166 fn into_glib(self) -> ffi::PangoStretch {
2167 match self {
2168 Self::UltraCondensed => ffi::PANGO_STRETCH_ULTRA_CONDENSED,
2169 Self::ExtraCondensed => ffi::PANGO_STRETCH_EXTRA_CONDENSED,
2170 Self::Condensed => ffi::PANGO_STRETCH_CONDENSED,
2171 Self::SemiCondensed => ffi::PANGO_STRETCH_SEMI_CONDENSED,
2172 Self::Normal => ffi::PANGO_STRETCH_NORMAL,
2173 Self::SemiExpanded => ffi::PANGO_STRETCH_SEMI_EXPANDED,
2174 Self::Expanded => ffi::PANGO_STRETCH_EXPANDED,
2175 Self::ExtraExpanded => ffi::PANGO_STRETCH_EXTRA_EXPANDED,
2176 Self::UltraExpanded => ffi::PANGO_STRETCH_ULTRA_EXPANDED,
2177 Self::__Unknown(value) => value,
2178 }
2179 }
2180}
2181
2182#[doc(hidden)]
2183impl FromGlib<ffi::PangoStretch> for Stretch {
2184 #[inline]
2185 unsafe fn from_glib(value: ffi::PangoStretch) -> Self {
2186 match value {
2187 ffi::PANGO_STRETCH_ULTRA_CONDENSED => Self::UltraCondensed,
2188 ffi::PANGO_STRETCH_EXTRA_CONDENSED => Self::ExtraCondensed,
2189 ffi::PANGO_STRETCH_CONDENSED => Self::Condensed,
2190 ffi::PANGO_STRETCH_SEMI_CONDENSED => Self::SemiCondensed,
2191 ffi::PANGO_STRETCH_NORMAL => Self::Normal,
2192 ffi::PANGO_STRETCH_SEMI_EXPANDED => Self::SemiExpanded,
2193 ffi::PANGO_STRETCH_EXPANDED => Self::Expanded,
2194 ffi::PANGO_STRETCH_EXTRA_EXPANDED => Self::ExtraExpanded,
2195 ffi::PANGO_STRETCH_ULTRA_EXPANDED => Self::UltraExpanded,
2196 value => Self::__Unknown(value),
2197 }
2198 }
2199}
2200
2201impl StaticType for Stretch {
2202 #[inline]
2203 #[doc(alias = "pango_stretch_get_type")]
2204 fn static_type() -> glib::Type {
2205 unsafe { from_glib(ffi::pango_stretch_get_type()) }
2206 }
2207}
2208
2209impl glib::HasParamSpec for Stretch {
2210 type ParamSpec = glib::ParamSpecEnum;
2211 type SetValue = Self;
2212 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2213
2214 fn param_spec_builder() -> Self::BuilderFn {
2215 Self::ParamSpec::builder_with_default
2216 }
2217}
2218
2219impl glib::value::ValueType for Stretch {
2220 type Type = Self;
2221}
2222
2223unsafe impl<'a> glib::value::FromValue<'a> for Stretch {
2224 type Checker = glib::value::GenericValueTypeChecker<Self>;
2225
2226 #[inline]
2227 unsafe fn from_value(value: &'a glib::Value) -> Self {
2228 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2229 }
2230}
2231
2232impl ToValue for Stretch {
2233 #[inline]
2234 fn to_value(&self) -> glib::Value {
2235 let mut value = glib::Value::for_value_type::<Self>();
2236 unsafe {
2237 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2238 }
2239 value
2240 }
2241
2242 #[inline]
2243 fn value_type(&self) -> glib::Type {
2244 Self::static_type()
2245 }
2246}
2247
2248impl From<Stretch> for glib::Value {
2249 #[inline]
2250 fn from(v: Stretch) -> Self {
2251 ToValue::to_value(&v)
2252 }
2253}
2254
2255#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2256#[non_exhaustive]
2257#[doc(alias = "PangoStyle")]
2258pub enum Style {
2259 #[doc(alias = "PANGO_STYLE_NORMAL")]
2260 Normal,
2261 #[doc(alias = "PANGO_STYLE_OBLIQUE")]
2262 Oblique,
2263 #[doc(alias = "PANGO_STYLE_ITALIC")]
2264 Italic,
2265 #[doc(hidden)]
2266 __Unknown(i32),
2267}
2268
2269#[doc(hidden)]
2270impl IntoGlib for Style {
2271 type GlibType = ffi::PangoStyle;
2272
2273 #[inline]
2274 fn into_glib(self) -> ffi::PangoStyle {
2275 match self {
2276 Self::Normal => ffi::PANGO_STYLE_NORMAL,
2277 Self::Oblique => ffi::PANGO_STYLE_OBLIQUE,
2278 Self::Italic => ffi::PANGO_STYLE_ITALIC,
2279 Self::__Unknown(value) => value,
2280 }
2281 }
2282}
2283
2284#[doc(hidden)]
2285impl FromGlib<ffi::PangoStyle> for Style {
2286 #[inline]
2287 unsafe fn from_glib(value: ffi::PangoStyle) -> Self {
2288 match value {
2289 ffi::PANGO_STYLE_NORMAL => Self::Normal,
2290 ffi::PANGO_STYLE_OBLIQUE => Self::Oblique,
2291 ffi::PANGO_STYLE_ITALIC => Self::Italic,
2292 value => Self::__Unknown(value),
2293 }
2294 }
2295}
2296
2297impl StaticType for Style {
2298 #[inline]
2299 #[doc(alias = "pango_style_get_type")]
2300 fn static_type() -> glib::Type {
2301 unsafe { from_glib(ffi::pango_style_get_type()) }
2302 }
2303}
2304
2305impl glib::HasParamSpec for Style {
2306 type ParamSpec = glib::ParamSpecEnum;
2307 type SetValue = Self;
2308 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2309
2310 fn param_spec_builder() -> Self::BuilderFn {
2311 Self::ParamSpec::builder_with_default
2312 }
2313}
2314
2315impl glib::value::ValueType for Style {
2316 type Type = Self;
2317}
2318
2319unsafe impl<'a> glib::value::FromValue<'a> for Style {
2320 type Checker = glib::value::GenericValueTypeChecker<Self>;
2321
2322 #[inline]
2323 unsafe fn from_value(value: &'a glib::Value) -> Self {
2324 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2325 }
2326}
2327
2328impl ToValue for Style {
2329 #[inline]
2330 fn to_value(&self) -> glib::Value {
2331 let mut value = glib::Value::for_value_type::<Self>();
2332 unsafe {
2333 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2334 }
2335 value
2336 }
2337
2338 #[inline]
2339 fn value_type(&self) -> glib::Type {
2340 Self::static_type()
2341 }
2342}
2343
2344impl From<Style> for glib::Value {
2345 #[inline]
2346 fn from(v: Style) -> Self {
2347 ToValue::to_value(&v)
2348 }
2349}
2350
2351#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2352#[non_exhaustive]
2353#[doc(alias = "PangoTabAlign")]
2354pub enum TabAlign {
2355 #[doc(alias = "PANGO_TAB_LEFT")]
2356 Left,
2357 #[cfg(feature = "v1_50")]
2358 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2359 #[doc(alias = "PANGO_TAB_RIGHT")]
2360 Right,
2361 #[cfg(feature = "v1_50")]
2362 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2363 #[doc(alias = "PANGO_TAB_CENTER")]
2364 Center,
2365 #[cfg(feature = "v1_50")]
2366 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2367 #[doc(alias = "PANGO_TAB_DECIMAL")]
2368 Decimal,
2369 #[doc(hidden)]
2370 __Unknown(i32),
2371}
2372
2373#[doc(hidden)]
2374impl IntoGlib for TabAlign {
2375 type GlibType = ffi::PangoTabAlign;
2376
2377 #[inline]
2378 fn into_glib(self) -> ffi::PangoTabAlign {
2379 match self {
2380 Self::Left => ffi::PANGO_TAB_LEFT,
2381 #[cfg(feature = "v1_50")]
2382 Self::Right => ffi::PANGO_TAB_RIGHT,
2383 #[cfg(feature = "v1_50")]
2384 Self::Center => ffi::PANGO_TAB_CENTER,
2385 #[cfg(feature = "v1_50")]
2386 Self::Decimal => ffi::PANGO_TAB_DECIMAL,
2387 Self::__Unknown(value) => value,
2388 }
2389 }
2390}
2391
2392#[doc(hidden)]
2393impl FromGlib<ffi::PangoTabAlign> for TabAlign {
2394 #[inline]
2395 unsafe fn from_glib(value: ffi::PangoTabAlign) -> Self {
2396 match value {
2397 ffi::PANGO_TAB_LEFT => Self::Left,
2398 #[cfg(feature = "v1_50")]
2399 ffi::PANGO_TAB_RIGHT => Self::Right,
2400 #[cfg(feature = "v1_50")]
2401 ffi::PANGO_TAB_CENTER => Self::Center,
2402 #[cfg(feature = "v1_50")]
2403 ffi::PANGO_TAB_DECIMAL => Self::Decimal,
2404 value => Self::__Unknown(value),
2405 }
2406 }
2407}
2408
2409impl StaticType for TabAlign {
2410 #[inline]
2411 #[doc(alias = "pango_tab_align_get_type")]
2412 fn static_type() -> glib::Type {
2413 unsafe { from_glib(ffi::pango_tab_align_get_type()) }
2414 }
2415}
2416
2417impl glib::HasParamSpec for TabAlign {
2418 type ParamSpec = glib::ParamSpecEnum;
2419 type SetValue = Self;
2420 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2421
2422 fn param_spec_builder() -> Self::BuilderFn {
2423 Self::ParamSpec::builder_with_default
2424 }
2425}
2426
2427impl glib::value::ValueType for TabAlign {
2428 type Type = Self;
2429}
2430
2431unsafe impl<'a> glib::value::FromValue<'a> for TabAlign {
2432 type Checker = glib::value::GenericValueTypeChecker<Self>;
2433
2434 #[inline]
2435 unsafe fn from_value(value: &'a glib::Value) -> Self {
2436 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2437 }
2438}
2439
2440impl ToValue for TabAlign {
2441 #[inline]
2442 fn to_value(&self) -> glib::Value {
2443 let mut value = glib::Value::for_value_type::<Self>();
2444 unsafe {
2445 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2446 }
2447 value
2448 }
2449
2450 #[inline]
2451 fn value_type(&self) -> glib::Type {
2452 Self::static_type()
2453 }
2454}
2455
2456impl From<TabAlign> for glib::Value {
2457 #[inline]
2458 fn from(v: TabAlign) -> Self {
2459 ToValue::to_value(&v)
2460 }
2461}
2462
2463#[cfg(feature = "v1_50")]
2464#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2465#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2466#[non_exhaustive]
2467#[doc(alias = "PangoTextTransform")]
2468pub enum TextTransform {
2469 #[doc(alias = "PANGO_TEXT_TRANSFORM_NONE")]
2470 None,
2471 #[doc(alias = "PANGO_TEXT_TRANSFORM_LOWERCASE")]
2472 Lowercase,
2473 #[doc(alias = "PANGO_TEXT_TRANSFORM_UPPERCASE")]
2474 Uppercase,
2475 #[doc(alias = "PANGO_TEXT_TRANSFORM_CAPITALIZE")]
2476 Capitalize,
2477 #[doc(hidden)]
2478 __Unknown(i32),
2479}
2480
2481#[cfg(feature = "v1_50")]
2482#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2483#[doc(hidden)]
2484impl IntoGlib for TextTransform {
2485 type GlibType = ffi::PangoTextTransform;
2486
2487 #[inline]
2488 fn into_glib(self) -> ffi::PangoTextTransform {
2489 match self {
2490 Self::None => ffi::PANGO_TEXT_TRANSFORM_NONE,
2491 Self::Lowercase => ffi::PANGO_TEXT_TRANSFORM_LOWERCASE,
2492 Self::Uppercase => ffi::PANGO_TEXT_TRANSFORM_UPPERCASE,
2493 Self::Capitalize => ffi::PANGO_TEXT_TRANSFORM_CAPITALIZE,
2494 Self::__Unknown(value) => value,
2495 }
2496 }
2497}
2498
2499#[cfg(feature = "v1_50")]
2500#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2501#[doc(hidden)]
2502impl FromGlib<ffi::PangoTextTransform> for TextTransform {
2503 #[inline]
2504 unsafe fn from_glib(value: ffi::PangoTextTransform) -> Self {
2505 match value {
2506 ffi::PANGO_TEXT_TRANSFORM_NONE => Self::None,
2507 ffi::PANGO_TEXT_TRANSFORM_LOWERCASE => Self::Lowercase,
2508 ffi::PANGO_TEXT_TRANSFORM_UPPERCASE => Self::Uppercase,
2509 ffi::PANGO_TEXT_TRANSFORM_CAPITALIZE => Self::Capitalize,
2510 value => Self::__Unknown(value),
2511 }
2512 }
2513}
2514
2515#[cfg(feature = "v1_50")]
2516#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2517impl StaticType for TextTransform {
2518 #[inline]
2519 #[doc(alias = "pango_text_transform_get_type")]
2520 fn static_type() -> glib::Type {
2521 unsafe { from_glib(ffi::pango_text_transform_get_type()) }
2522 }
2523}
2524
2525#[cfg(feature = "v1_50")]
2526#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2527impl glib::HasParamSpec for TextTransform {
2528 type ParamSpec = glib::ParamSpecEnum;
2529 type SetValue = Self;
2530 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2531
2532 fn param_spec_builder() -> Self::BuilderFn {
2533 Self::ParamSpec::builder_with_default
2534 }
2535}
2536
2537#[cfg(feature = "v1_50")]
2538#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2539impl glib::value::ValueType for TextTransform {
2540 type Type = Self;
2541}
2542
2543#[cfg(feature = "v1_50")]
2544#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2545unsafe impl<'a> glib::value::FromValue<'a> for TextTransform {
2546 type Checker = glib::value::GenericValueTypeChecker<Self>;
2547
2548 #[inline]
2549 unsafe fn from_value(value: &'a glib::Value) -> Self {
2550 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2551 }
2552}
2553
2554#[cfg(feature = "v1_50")]
2555#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2556impl ToValue for TextTransform {
2557 #[inline]
2558 fn to_value(&self) -> glib::Value {
2559 let mut value = glib::Value::for_value_type::<Self>();
2560 unsafe {
2561 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2562 }
2563 value
2564 }
2565
2566 #[inline]
2567 fn value_type(&self) -> glib::Type {
2568 Self::static_type()
2569 }
2570}
2571
2572#[cfg(feature = "v1_50")]
2573#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2574impl From<TextTransform> for glib::Value {
2575 #[inline]
2576 fn from(v: TextTransform) -> Self {
2577 ToValue::to_value(&v)
2578 }
2579}
2580
2581#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2582#[non_exhaustive]
2583#[doc(alias = "PangoUnderline")]
2584pub enum Underline {
2585 #[doc(alias = "PANGO_UNDERLINE_NONE")]
2586 None,
2587 #[doc(alias = "PANGO_UNDERLINE_SINGLE")]
2588 Single,
2589 #[doc(alias = "PANGO_UNDERLINE_DOUBLE")]
2590 Double,
2591 #[doc(alias = "PANGO_UNDERLINE_LOW")]
2592 Low,
2593 #[doc(alias = "PANGO_UNDERLINE_ERROR")]
2594 Error,
2595 #[doc(alias = "PANGO_UNDERLINE_SINGLE_LINE")]
2596 SingleLine,
2597 #[doc(alias = "PANGO_UNDERLINE_DOUBLE_LINE")]
2598 DoubleLine,
2599 #[doc(alias = "PANGO_UNDERLINE_ERROR_LINE")]
2600 ErrorLine,
2601 #[doc(hidden)]
2602 __Unknown(i32),
2603}
2604
2605#[doc(hidden)]
2606impl IntoGlib for Underline {
2607 type GlibType = ffi::PangoUnderline;
2608
2609 #[inline]
2610 fn into_glib(self) -> ffi::PangoUnderline {
2611 match self {
2612 Self::None => ffi::PANGO_UNDERLINE_NONE,
2613 Self::Single => ffi::PANGO_UNDERLINE_SINGLE,
2614 Self::Double => ffi::PANGO_UNDERLINE_DOUBLE,
2615 Self::Low => ffi::PANGO_UNDERLINE_LOW,
2616 Self::Error => ffi::PANGO_UNDERLINE_ERROR,
2617 Self::SingleLine => ffi::PANGO_UNDERLINE_SINGLE_LINE,
2618 Self::DoubleLine => ffi::PANGO_UNDERLINE_DOUBLE_LINE,
2619 Self::ErrorLine => ffi::PANGO_UNDERLINE_ERROR_LINE,
2620 Self::__Unknown(value) => value,
2621 }
2622 }
2623}
2624
2625#[doc(hidden)]
2626impl FromGlib<ffi::PangoUnderline> for Underline {
2627 #[inline]
2628 unsafe fn from_glib(value: ffi::PangoUnderline) -> Self {
2629 match value {
2630 ffi::PANGO_UNDERLINE_NONE => Self::None,
2631 ffi::PANGO_UNDERLINE_SINGLE => Self::Single,
2632 ffi::PANGO_UNDERLINE_DOUBLE => Self::Double,
2633 ffi::PANGO_UNDERLINE_LOW => Self::Low,
2634 ffi::PANGO_UNDERLINE_ERROR => Self::Error,
2635 ffi::PANGO_UNDERLINE_SINGLE_LINE => Self::SingleLine,
2636 ffi::PANGO_UNDERLINE_DOUBLE_LINE => Self::DoubleLine,
2637 ffi::PANGO_UNDERLINE_ERROR_LINE => Self::ErrorLine,
2638 value => Self::__Unknown(value),
2639 }
2640 }
2641}
2642
2643impl StaticType for Underline {
2644 #[inline]
2645 #[doc(alias = "pango_underline_get_type")]
2646 fn static_type() -> glib::Type {
2647 unsafe { from_glib(ffi::pango_underline_get_type()) }
2648 }
2649}
2650
2651impl glib::HasParamSpec for Underline {
2652 type ParamSpec = glib::ParamSpecEnum;
2653 type SetValue = Self;
2654 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2655
2656 fn param_spec_builder() -> Self::BuilderFn {
2657 Self::ParamSpec::builder_with_default
2658 }
2659}
2660
2661impl glib::value::ValueType for Underline {
2662 type Type = Self;
2663}
2664
2665unsafe impl<'a> glib::value::FromValue<'a> for Underline {
2666 type Checker = glib::value::GenericValueTypeChecker<Self>;
2667
2668 #[inline]
2669 unsafe fn from_value(value: &'a glib::Value) -> Self {
2670 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2671 }
2672}
2673
2674impl ToValue for Underline {
2675 #[inline]
2676 fn to_value(&self) -> glib::Value {
2677 let mut value = glib::Value::for_value_type::<Self>();
2678 unsafe {
2679 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2680 }
2681 value
2682 }
2683
2684 #[inline]
2685 fn value_type(&self) -> glib::Type {
2686 Self::static_type()
2687 }
2688}
2689
2690impl From<Underline> for glib::Value {
2691 #[inline]
2692 fn from(v: Underline) -> Self {
2693 ToValue::to_value(&v)
2694 }
2695}
2696
2697#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2698#[non_exhaustive]
2699#[doc(alias = "PangoVariant")]
2700pub enum Variant {
2701 #[doc(alias = "PANGO_VARIANT_NORMAL")]
2702 Normal,
2703 #[doc(alias = "PANGO_VARIANT_SMALL_CAPS")]
2704 SmallCaps,
2705 #[cfg(feature = "v1_50")]
2706 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2707 #[doc(alias = "PANGO_VARIANT_ALL_SMALL_CAPS")]
2708 AllSmallCaps,
2709 #[cfg(feature = "v1_50")]
2710 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2711 #[doc(alias = "PANGO_VARIANT_PETITE_CAPS")]
2712 PetiteCaps,
2713 #[cfg(feature = "v1_50")]
2714 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2715 #[doc(alias = "PANGO_VARIANT_ALL_PETITE_CAPS")]
2716 AllPetiteCaps,
2717 #[cfg(feature = "v1_50")]
2718 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2719 #[doc(alias = "PANGO_VARIANT_UNICASE")]
2720 Unicase,
2721 #[cfg(feature = "v1_50")]
2722 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2723 #[doc(alias = "PANGO_VARIANT_TITLE_CAPS")]
2724 TitleCaps,
2725 #[doc(hidden)]
2726 __Unknown(i32),
2727}
2728
2729#[doc(hidden)]
2730impl IntoGlib for Variant {
2731 type GlibType = ffi::PangoVariant;
2732
2733 #[inline]
2734 fn into_glib(self) -> ffi::PangoVariant {
2735 match self {
2736 Self::Normal => ffi::PANGO_VARIANT_NORMAL,
2737 Self::SmallCaps => ffi::PANGO_VARIANT_SMALL_CAPS,
2738 #[cfg(feature = "v1_50")]
2739 Self::AllSmallCaps => ffi::PANGO_VARIANT_ALL_SMALL_CAPS,
2740 #[cfg(feature = "v1_50")]
2741 Self::PetiteCaps => ffi::PANGO_VARIANT_PETITE_CAPS,
2742 #[cfg(feature = "v1_50")]
2743 Self::AllPetiteCaps => ffi::PANGO_VARIANT_ALL_PETITE_CAPS,
2744 #[cfg(feature = "v1_50")]
2745 Self::Unicase => ffi::PANGO_VARIANT_UNICASE,
2746 #[cfg(feature = "v1_50")]
2747 Self::TitleCaps => ffi::PANGO_VARIANT_TITLE_CAPS,
2748 Self::__Unknown(value) => value,
2749 }
2750 }
2751}
2752
2753#[doc(hidden)]
2754impl FromGlib<ffi::PangoVariant> for Variant {
2755 #[inline]
2756 unsafe fn from_glib(value: ffi::PangoVariant) -> Self {
2757 match value {
2758 ffi::PANGO_VARIANT_NORMAL => Self::Normal,
2759 ffi::PANGO_VARIANT_SMALL_CAPS => Self::SmallCaps,
2760 #[cfg(feature = "v1_50")]
2761 ffi::PANGO_VARIANT_ALL_SMALL_CAPS => Self::AllSmallCaps,
2762 #[cfg(feature = "v1_50")]
2763 ffi::PANGO_VARIANT_PETITE_CAPS => Self::PetiteCaps,
2764 #[cfg(feature = "v1_50")]
2765 ffi::PANGO_VARIANT_ALL_PETITE_CAPS => Self::AllPetiteCaps,
2766 #[cfg(feature = "v1_50")]
2767 ffi::PANGO_VARIANT_UNICASE => Self::Unicase,
2768 #[cfg(feature = "v1_50")]
2769 ffi::PANGO_VARIANT_TITLE_CAPS => Self::TitleCaps,
2770 value => Self::__Unknown(value),
2771 }
2772 }
2773}
2774
2775impl StaticType for Variant {
2776 #[inline]
2777 #[doc(alias = "pango_variant_get_type")]
2778 fn static_type() -> glib::Type {
2779 unsafe { from_glib(ffi::pango_variant_get_type()) }
2780 }
2781}
2782
2783impl glib::HasParamSpec for Variant {
2784 type ParamSpec = glib::ParamSpecEnum;
2785 type SetValue = Self;
2786 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2787
2788 fn param_spec_builder() -> Self::BuilderFn {
2789 Self::ParamSpec::builder_with_default
2790 }
2791}
2792
2793impl glib::value::ValueType for Variant {
2794 type Type = Self;
2795}
2796
2797unsafe impl<'a> glib::value::FromValue<'a> for Variant {
2798 type Checker = glib::value::GenericValueTypeChecker<Self>;
2799
2800 #[inline]
2801 unsafe fn from_value(value: &'a glib::Value) -> Self {
2802 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2803 }
2804}
2805
2806impl ToValue for Variant {
2807 #[inline]
2808 fn to_value(&self) -> glib::Value {
2809 let mut value = glib::Value::for_value_type::<Self>();
2810 unsafe {
2811 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2812 }
2813 value
2814 }
2815
2816 #[inline]
2817 fn value_type(&self) -> glib::Type {
2818 Self::static_type()
2819 }
2820}
2821
2822impl From<Variant> for glib::Value {
2823 #[inline]
2824 fn from(v: Variant) -> Self {
2825 ToValue::to_value(&v)
2826 }
2827}
2828
2829#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2830#[non_exhaustive]
2831#[doc(alias = "PangoWeight")]
2832pub enum Weight {
2833 #[doc(alias = "PANGO_WEIGHT_THIN")]
2834 Thin,
2835 #[doc(alias = "PANGO_WEIGHT_ULTRALIGHT")]
2836 Ultralight,
2837 #[doc(alias = "PANGO_WEIGHT_LIGHT")]
2838 Light,
2839 #[doc(alias = "PANGO_WEIGHT_SEMILIGHT")]
2840 Semilight,
2841 #[doc(alias = "PANGO_WEIGHT_BOOK")]
2842 Book,
2843 #[doc(alias = "PANGO_WEIGHT_NORMAL")]
2844 Normal,
2845 #[doc(alias = "PANGO_WEIGHT_MEDIUM")]
2846 Medium,
2847 #[doc(alias = "PANGO_WEIGHT_SEMIBOLD")]
2848 Semibold,
2849 #[doc(alias = "PANGO_WEIGHT_BOLD")]
2850 Bold,
2851 #[doc(alias = "PANGO_WEIGHT_ULTRABOLD")]
2852 Ultrabold,
2853 #[doc(alias = "PANGO_WEIGHT_HEAVY")]
2854 Heavy,
2855 #[doc(alias = "PANGO_WEIGHT_ULTRAHEAVY")]
2856 Ultraheavy,
2857 #[doc(hidden)]
2858 __Unknown(i32),
2859}
2860
2861#[doc(hidden)]
2862impl IntoGlib for Weight {
2863 type GlibType = ffi::PangoWeight;
2864
2865 #[inline]
2866 fn into_glib(self) -> ffi::PangoWeight {
2867 match self {
2868 Self::Thin => ffi::PANGO_WEIGHT_THIN,
2869 Self::Ultralight => ffi::PANGO_WEIGHT_ULTRALIGHT,
2870 Self::Light => ffi::PANGO_WEIGHT_LIGHT,
2871 Self::Semilight => ffi::PANGO_WEIGHT_SEMILIGHT,
2872 Self::Book => ffi::PANGO_WEIGHT_BOOK,
2873 Self::Normal => ffi::PANGO_WEIGHT_NORMAL,
2874 Self::Medium => ffi::PANGO_WEIGHT_MEDIUM,
2875 Self::Semibold => ffi::PANGO_WEIGHT_SEMIBOLD,
2876 Self::Bold => ffi::PANGO_WEIGHT_BOLD,
2877 Self::Ultrabold => ffi::PANGO_WEIGHT_ULTRABOLD,
2878 Self::Heavy => ffi::PANGO_WEIGHT_HEAVY,
2879 Self::Ultraheavy => ffi::PANGO_WEIGHT_ULTRAHEAVY,
2880 Self::__Unknown(value) => value,
2881 }
2882 }
2883}
2884
2885#[doc(hidden)]
2886impl FromGlib<ffi::PangoWeight> for Weight {
2887 #[inline]
2888 unsafe fn from_glib(value: ffi::PangoWeight) -> Self {
2889 match value {
2890 ffi::PANGO_WEIGHT_THIN => Self::Thin,
2891 ffi::PANGO_WEIGHT_ULTRALIGHT => Self::Ultralight,
2892 ffi::PANGO_WEIGHT_LIGHT => Self::Light,
2893 ffi::PANGO_WEIGHT_SEMILIGHT => Self::Semilight,
2894 ffi::PANGO_WEIGHT_BOOK => Self::Book,
2895 ffi::PANGO_WEIGHT_NORMAL => Self::Normal,
2896 ffi::PANGO_WEIGHT_MEDIUM => Self::Medium,
2897 ffi::PANGO_WEIGHT_SEMIBOLD => Self::Semibold,
2898 ffi::PANGO_WEIGHT_BOLD => Self::Bold,
2899 ffi::PANGO_WEIGHT_ULTRABOLD => Self::Ultrabold,
2900 ffi::PANGO_WEIGHT_HEAVY => Self::Heavy,
2901 ffi::PANGO_WEIGHT_ULTRAHEAVY => Self::Ultraheavy,
2902 value => Self::__Unknown(value),
2903 }
2904 }
2905}
2906
2907impl StaticType for Weight {
2908 #[inline]
2909 #[doc(alias = "pango_weight_get_type")]
2910 fn static_type() -> glib::Type {
2911 unsafe { from_glib(ffi::pango_weight_get_type()) }
2912 }
2913}
2914
2915impl glib::HasParamSpec for Weight {
2916 type ParamSpec = glib::ParamSpecEnum;
2917 type SetValue = Self;
2918 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2919
2920 fn param_spec_builder() -> Self::BuilderFn {
2921 Self::ParamSpec::builder_with_default
2922 }
2923}
2924
2925impl glib::value::ValueType for Weight {
2926 type Type = Self;
2927}
2928
2929unsafe impl<'a> glib::value::FromValue<'a> for Weight {
2930 type Checker = glib::value::GenericValueTypeChecker<Self>;
2931
2932 #[inline]
2933 unsafe fn from_value(value: &'a glib::Value) -> Self {
2934 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2935 }
2936}
2937
2938impl ToValue for Weight {
2939 #[inline]
2940 fn to_value(&self) -> glib::Value {
2941 let mut value = glib::Value::for_value_type::<Self>();
2942 unsafe {
2943 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2944 }
2945 value
2946 }
2947
2948 #[inline]
2949 fn value_type(&self) -> glib::Type {
2950 Self::static_type()
2951 }
2952}
2953
2954impl From<Weight> for glib::Value {
2955 #[inline]
2956 fn from(v: Weight) -> Self {
2957 ToValue::to_value(&v)
2958 }
2959}
2960
2961#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2962#[non_exhaustive]
2963#[doc(alias = "PangoWrapMode")]
2964pub enum WrapMode {
2965 #[doc(alias = "PANGO_WRAP_WORD")]
2966 Word,
2967 #[doc(alias = "PANGO_WRAP_CHAR")]
2968 Char,
2969 #[doc(alias = "PANGO_WRAP_WORD_CHAR")]
2970 WordChar,
2971 #[cfg(feature = "v1_56")]
2972 #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
2973 #[doc(alias = "PANGO_WRAP_NONE")]
2974 None,
2975 #[doc(hidden)]
2976 __Unknown(i32),
2977}
2978
2979#[doc(hidden)]
2980impl IntoGlib for WrapMode {
2981 type GlibType = ffi::PangoWrapMode;
2982
2983 #[inline]
2984 fn into_glib(self) -> ffi::PangoWrapMode {
2985 match self {
2986 Self::Word => ffi::PANGO_WRAP_WORD,
2987 Self::Char => ffi::PANGO_WRAP_CHAR,
2988 Self::WordChar => ffi::PANGO_WRAP_WORD_CHAR,
2989 #[cfg(feature = "v1_56")]
2990 Self::None => ffi::PANGO_WRAP_NONE,
2991 Self::__Unknown(value) => value,
2992 }
2993 }
2994}
2995
2996#[doc(hidden)]
2997impl FromGlib<ffi::PangoWrapMode> for WrapMode {
2998 #[inline]
2999 unsafe fn from_glib(value: ffi::PangoWrapMode) -> Self {
3000 match value {
3001 ffi::PANGO_WRAP_WORD => Self::Word,
3002 ffi::PANGO_WRAP_CHAR => Self::Char,
3003 ffi::PANGO_WRAP_WORD_CHAR => Self::WordChar,
3004 #[cfg(feature = "v1_56")]
3005 ffi::PANGO_WRAP_NONE => Self::None,
3006 value => Self::__Unknown(value),
3007 }
3008 }
3009}
3010
3011impl StaticType for WrapMode {
3012 #[inline]
3013 #[doc(alias = "pango_wrap_mode_get_type")]
3014 fn static_type() -> glib::Type {
3015 unsafe { from_glib(ffi::pango_wrap_mode_get_type()) }
3016 }
3017}
3018
3019impl glib::HasParamSpec for WrapMode {
3020 type ParamSpec = glib::ParamSpecEnum;
3021 type SetValue = Self;
3022 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3023
3024 fn param_spec_builder() -> Self::BuilderFn {
3025 Self::ParamSpec::builder_with_default
3026 }
3027}
3028
3029impl glib::value::ValueType for WrapMode {
3030 type Type = Self;
3031}
3032
3033unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
3034 type Checker = glib::value::GenericValueTypeChecker<Self>;
3035
3036 #[inline]
3037 unsafe fn from_value(value: &'a glib::Value) -> Self {
3038 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3039 }
3040}
3041
3042impl ToValue for WrapMode {
3043 #[inline]
3044 fn to_value(&self) -> glib::Value {
3045 let mut value = glib::Value::for_value_type::<Self>();
3046 unsafe {
3047 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3048 }
3049 value
3050 }
3051
3052 #[inline]
3053 fn value_type(&self) -> glib::Type {
3054 Self::static_type()
3055 }
3056}
3057
3058impl From<WrapMode> for glib::Value {
3059 #[inline]
3060 fn from(v: WrapMode) -> Self {
3061 ToValue::to_value(&v)
3062 }
3063}