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_57")]
992#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
993#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
994#[non_exhaustive]
995#[doc(alias = "PangoFontColor")]
996pub enum FontColor {
997 #[doc(alias = "PANGO_FONT_COLOR_FORBIDDEN")]
998 Forbidden,
999 #[doc(alias = "PANGO_FONT_COLOR_REQUIRED")]
1000 Required,
1001 #[doc(alias = "PANGO_FONT_COLOR_DONT_CARE")]
1002 DontCare,
1003 #[doc(hidden)]
1004 __Unknown(i32),
1005}
1006
1007#[cfg(feature = "v1_57")]
1008#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1009#[doc(hidden)]
1010impl IntoGlib for FontColor {
1011 type GlibType = ffi::PangoFontColor;
1012
1013 #[inline]
1014 fn into_glib(self) -> ffi::PangoFontColor {
1015 match self {
1016 Self::Forbidden => ffi::PANGO_FONT_COLOR_FORBIDDEN,
1017 Self::Required => ffi::PANGO_FONT_COLOR_REQUIRED,
1018 Self::DontCare => ffi::PANGO_FONT_COLOR_DONT_CARE,
1019 Self::__Unknown(value) => value,
1020 }
1021 }
1022}
1023
1024#[cfg(feature = "v1_57")]
1025#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1026#[doc(hidden)]
1027impl FromGlib<ffi::PangoFontColor> for FontColor {
1028 #[inline]
1029 unsafe fn from_glib(value: ffi::PangoFontColor) -> Self {
1030 match value {
1031 ffi::PANGO_FONT_COLOR_FORBIDDEN => Self::Forbidden,
1032 ffi::PANGO_FONT_COLOR_REQUIRED => Self::Required,
1033 ffi::PANGO_FONT_COLOR_DONT_CARE => Self::DontCare,
1034 value => Self::__Unknown(value),
1035 }
1036 }
1037}
1038
1039#[cfg(feature = "v1_57")]
1040#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1041impl StaticType for FontColor {
1042 #[inline]
1043 #[doc(alias = "pango_font_color_get_type")]
1044 fn static_type() -> glib::Type {
1045 unsafe { from_glib(ffi::pango_font_color_get_type()) }
1046 }
1047}
1048
1049#[cfg(feature = "v1_57")]
1050#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1051impl glib::HasParamSpec for FontColor {
1052 type ParamSpec = glib::ParamSpecEnum;
1053 type SetValue = Self;
1054 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1055
1056 fn param_spec_builder() -> Self::BuilderFn {
1057 Self::ParamSpec::builder_with_default
1058 }
1059}
1060
1061#[cfg(feature = "v1_57")]
1062#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1063impl glib::value::ValueType for FontColor {
1064 type Type = Self;
1065}
1066
1067#[cfg(feature = "v1_57")]
1068#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1069unsafe impl<'a> glib::value::FromValue<'a> for FontColor {
1070 type Checker = glib::value::GenericValueTypeChecker<Self>;
1071
1072 #[inline]
1073 unsafe fn from_value(value: &'a glib::Value) -> Self {
1074 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1075 }
1076}
1077
1078#[cfg(feature = "v1_57")]
1079#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1080impl ToValue for FontColor {
1081 #[inline]
1082 fn to_value(&self) -> glib::Value {
1083 let mut value = glib::Value::for_value_type::<Self>();
1084 unsafe {
1085 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1086 }
1087 value
1088 }
1089
1090 #[inline]
1091 fn value_type(&self) -> glib::Type {
1092 Self::static_type()
1093 }
1094}
1095
1096#[cfg(feature = "v1_57")]
1097#[cfg_attr(docsrs, doc(cfg(feature = "v1_57")))]
1098impl From<FontColor> for glib::Value {
1099 #[inline]
1100 fn from(v: FontColor) -> Self {
1101 ToValue::to_value(&v)
1102 }
1103}
1104
1105#[cfg(feature = "v1_50")]
1106#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1107#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1108#[non_exhaustive]
1109#[doc(alias = "PangoFontScale")]
1110pub enum FontScale {
1111 #[doc(alias = "PANGO_FONT_SCALE_NONE")]
1112 None,
1113 #[doc(alias = "PANGO_FONT_SCALE_SUPERSCRIPT")]
1114 Superscript,
1115 #[doc(alias = "PANGO_FONT_SCALE_SUBSCRIPT")]
1116 Subscript,
1117 #[doc(alias = "PANGO_FONT_SCALE_SMALL_CAPS")]
1118 SmallCaps,
1119 #[doc(hidden)]
1120 __Unknown(i32),
1121}
1122
1123#[cfg(feature = "v1_50")]
1124#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1125#[doc(hidden)]
1126impl IntoGlib for FontScale {
1127 type GlibType = ffi::PangoFontScale;
1128
1129 #[inline]
1130 fn into_glib(self) -> ffi::PangoFontScale {
1131 match self {
1132 Self::None => ffi::PANGO_FONT_SCALE_NONE,
1133 Self::Superscript => ffi::PANGO_FONT_SCALE_SUPERSCRIPT,
1134 Self::Subscript => ffi::PANGO_FONT_SCALE_SUBSCRIPT,
1135 Self::SmallCaps => ffi::PANGO_FONT_SCALE_SMALL_CAPS,
1136 Self::__Unknown(value) => value,
1137 }
1138 }
1139}
1140
1141#[cfg(feature = "v1_50")]
1142#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1143#[doc(hidden)]
1144impl FromGlib<ffi::PangoFontScale> for FontScale {
1145 #[inline]
1146 unsafe fn from_glib(value: ffi::PangoFontScale) -> Self {
1147 match value {
1148 ffi::PANGO_FONT_SCALE_NONE => Self::None,
1149 ffi::PANGO_FONT_SCALE_SUPERSCRIPT => Self::Superscript,
1150 ffi::PANGO_FONT_SCALE_SUBSCRIPT => Self::Subscript,
1151 ffi::PANGO_FONT_SCALE_SMALL_CAPS => Self::SmallCaps,
1152 value => Self::__Unknown(value),
1153 }
1154 }
1155}
1156
1157#[cfg(feature = "v1_50")]
1158#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1159impl StaticType for FontScale {
1160 #[inline]
1161 #[doc(alias = "pango_font_scale_get_type")]
1162 fn static_type() -> glib::Type {
1163 unsafe { from_glib(ffi::pango_font_scale_get_type()) }
1164 }
1165}
1166
1167#[cfg(feature = "v1_50")]
1168#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1169impl glib::HasParamSpec for FontScale {
1170 type ParamSpec = glib::ParamSpecEnum;
1171 type SetValue = Self;
1172 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1173
1174 fn param_spec_builder() -> Self::BuilderFn {
1175 Self::ParamSpec::builder_with_default
1176 }
1177}
1178
1179#[cfg(feature = "v1_50")]
1180#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1181impl glib::value::ValueType for FontScale {
1182 type Type = Self;
1183}
1184
1185#[cfg(feature = "v1_50")]
1186#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1187unsafe impl<'a> glib::value::FromValue<'a> for FontScale {
1188 type Checker = glib::value::GenericValueTypeChecker<Self>;
1189
1190 #[inline]
1191 unsafe fn from_value(value: &'a glib::Value) -> Self {
1192 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1193 }
1194}
1195
1196#[cfg(feature = "v1_50")]
1197#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1198impl ToValue for FontScale {
1199 #[inline]
1200 fn to_value(&self) -> glib::Value {
1201 let mut value = glib::Value::for_value_type::<Self>();
1202 unsafe {
1203 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1204 }
1205 value
1206 }
1207
1208 #[inline]
1209 fn value_type(&self) -> glib::Type {
1210 Self::static_type()
1211 }
1212}
1213
1214#[cfg(feature = "v1_50")]
1215#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
1216impl From<FontScale> for glib::Value {
1217 #[inline]
1218 fn from(v: FontScale) -> Self {
1219 ToValue::to_value(&v)
1220 }
1221}
1222
1223#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1224#[non_exhaustive]
1225#[doc(alias = "PangoGravity")]
1226pub enum Gravity {
1227 #[doc(alias = "PANGO_GRAVITY_SOUTH")]
1228 South,
1229 #[doc(alias = "PANGO_GRAVITY_EAST")]
1230 East,
1231 #[doc(alias = "PANGO_GRAVITY_NORTH")]
1232 North,
1233 #[doc(alias = "PANGO_GRAVITY_WEST")]
1234 West,
1235 #[doc(alias = "PANGO_GRAVITY_AUTO")]
1236 Auto,
1237 #[doc(hidden)]
1238 __Unknown(i32),
1239}
1240
1241impl Gravity {
1242 #[doc(alias = "pango_gravity_get_for_matrix")]
1243 #[doc(alias = "get_for_matrix")]
1244 pub fn for_matrix(matrix: Option<&Matrix>) -> Gravity {
1245 unsafe { from_glib(ffi::pango_gravity_get_for_matrix(matrix.to_glib_none().0)) }
1246 }
1247
1248 #[doc(alias = "pango_gravity_get_for_script")]
1249 #[doc(alias = "get_for_script")]
1250 pub fn for_script(script: Script, base_gravity: Gravity, hint: GravityHint) -> Gravity {
1251 unsafe {
1252 from_glib(ffi::pango_gravity_get_for_script(
1253 script.into_glib(),
1254 base_gravity.into_glib(),
1255 hint.into_glib(),
1256 ))
1257 }
1258 }
1259
1260 #[doc(alias = "pango_gravity_get_for_script_and_width")]
1261 #[doc(alias = "get_for_script_and_width")]
1262 pub fn for_script_and_width(
1263 script: Script,
1264 wide: bool,
1265 base_gravity: Gravity,
1266 hint: GravityHint,
1267 ) -> Gravity {
1268 unsafe {
1269 from_glib(ffi::pango_gravity_get_for_script_and_width(
1270 script.into_glib(),
1271 wide.into_glib(),
1272 base_gravity.into_glib(),
1273 hint.into_glib(),
1274 ))
1275 }
1276 }
1277
1278 #[doc(alias = "pango_gravity_to_rotation")]
1279 pub fn to_rotation(self) -> f64 {
1280 unsafe { ffi::pango_gravity_to_rotation(self.into_glib()) }
1281 }
1282}
1283
1284#[doc(hidden)]
1285impl IntoGlib for Gravity {
1286 type GlibType = ffi::PangoGravity;
1287
1288 #[inline]
1289 fn into_glib(self) -> ffi::PangoGravity {
1290 match self {
1291 Self::South => ffi::PANGO_GRAVITY_SOUTH,
1292 Self::East => ffi::PANGO_GRAVITY_EAST,
1293 Self::North => ffi::PANGO_GRAVITY_NORTH,
1294 Self::West => ffi::PANGO_GRAVITY_WEST,
1295 Self::Auto => ffi::PANGO_GRAVITY_AUTO,
1296 Self::__Unknown(value) => value,
1297 }
1298 }
1299}
1300
1301#[doc(hidden)]
1302impl FromGlib<ffi::PangoGravity> for Gravity {
1303 #[inline]
1304 unsafe fn from_glib(value: ffi::PangoGravity) -> Self {
1305 match value {
1306 ffi::PANGO_GRAVITY_SOUTH => Self::South,
1307 ffi::PANGO_GRAVITY_EAST => Self::East,
1308 ffi::PANGO_GRAVITY_NORTH => Self::North,
1309 ffi::PANGO_GRAVITY_WEST => Self::West,
1310 ffi::PANGO_GRAVITY_AUTO => Self::Auto,
1311 value => Self::__Unknown(value),
1312 }
1313 }
1314}
1315
1316impl StaticType for Gravity {
1317 #[inline]
1318 #[doc(alias = "pango_gravity_get_type")]
1319 fn static_type() -> glib::Type {
1320 unsafe { from_glib(ffi::pango_gravity_get_type()) }
1321 }
1322}
1323
1324impl glib::HasParamSpec for Gravity {
1325 type ParamSpec = glib::ParamSpecEnum;
1326 type SetValue = Self;
1327 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1328
1329 fn param_spec_builder() -> Self::BuilderFn {
1330 Self::ParamSpec::builder_with_default
1331 }
1332}
1333
1334impl glib::value::ValueType for Gravity {
1335 type Type = Self;
1336}
1337
1338unsafe impl<'a> glib::value::FromValue<'a> for Gravity {
1339 type Checker = glib::value::GenericValueTypeChecker<Self>;
1340
1341 #[inline]
1342 unsafe fn from_value(value: &'a glib::Value) -> Self {
1343 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1344 }
1345}
1346
1347impl ToValue for Gravity {
1348 #[inline]
1349 fn to_value(&self) -> glib::Value {
1350 let mut value = glib::Value::for_value_type::<Self>();
1351 unsafe {
1352 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1353 }
1354 value
1355 }
1356
1357 #[inline]
1358 fn value_type(&self) -> glib::Type {
1359 Self::static_type()
1360 }
1361}
1362
1363impl From<Gravity> for glib::Value {
1364 #[inline]
1365 fn from(v: Gravity) -> Self {
1366 ToValue::to_value(&v)
1367 }
1368}
1369
1370#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1371#[non_exhaustive]
1372#[doc(alias = "PangoGravityHint")]
1373pub enum GravityHint {
1374 #[doc(alias = "PANGO_GRAVITY_HINT_NATURAL")]
1375 Natural,
1376 #[doc(alias = "PANGO_GRAVITY_HINT_STRONG")]
1377 Strong,
1378 #[doc(alias = "PANGO_GRAVITY_HINT_LINE")]
1379 Line,
1380 #[doc(hidden)]
1381 __Unknown(i32),
1382}
1383
1384#[doc(hidden)]
1385impl IntoGlib for GravityHint {
1386 type GlibType = ffi::PangoGravityHint;
1387
1388 #[inline]
1389 fn into_glib(self) -> ffi::PangoGravityHint {
1390 match self {
1391 Self::Natural => ffi::PANGO_GRAVITY_HINT_NATURAL,
1392 Self::Strong => ffi::PANGO_GRAVITY_HINT_STRONG,
1393 Self::Line => ffi::PANGO_GRAVITY_HINT_LINE,
1394 Self::__Unknown(value) => value,
1395 }
1396 }
1397}
1398
1399#[doc(hidden)]
1400impl FromGlib<ffi::PangoGravityHint> for GravityHint {
1401 #[inline]
1402 unsafe fn from_glib(value: ffi::PangoGravityHint) -> Self {
1403 match value {
1404 ffi::PANGO_GRAVITY_HINT_NATURAL => Self::Natural,
1405 ffi::PANGO_GRAVITY_HINT_STRONG => Self::Strong,
1406 ffi::PANGO_GRAVITY_HINT_LINE => Self::Line,
1407 value => Self::__Unknown(value),
1408 }
1409 }
1410}
1411
1412impl StaticType for GravityHint {
1413 #[inline]
1414 #[doc(alias = "pango_gravity_hint_get_type")]
1415 fn static_type() -> glib::Type {
1416 unsafe { from_glib(ffi::pango_gravity_hint_get_type()) }
1417 }
1418}
1419
1420impl glib::HasParamSpec for GravityHint {
1421 type ParamSpec = glib::ParamSpecEnum;
1422 type SetValue = Self;
1423 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1424
1425 fn param_spec_builder() -> Self::BuilderFn {
1426 Self::ParamSpec::builder_with_default
1427 }
1428}
1429
1430impl glib::value::ValueType for GravityHint {
1431 type Type = Self;
1432}
1433
1434unsafe impl<'a> glib::value::FromValue<'a> for GravityHint {
1435 type Checker = glib::value::GenericValueTypeChecker<Self>;
1436
1437 #[inline]
1438 unsafe fn from_value(value: &'a glib::Value) -> Self {
1439 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1440 }
1441}
1442
1443impl ToValue for GravityHint {
1444 #[inline]
1445 fn to_value(&self) -> glib::Value {
1446 let mut value = glib::Value::for_value_type::<Self>();
1447 unsafe {
1448 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1449 }
1450 value
1451 }
1452
1453 #[inline]
1454 fn value_type(&self) -> glib::Type {
1455 Self::static_type()
1456 }
1457}
1458
1459impl From<GravityHint> for glib::Value {
1460 #[inline]
1461 fn from(v: GravityHint) -> Self {
1462 ToValue::to_value(&v)
1463 }
1464}
1465
1466#[cfg(feature = "v1_46")]
1467#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1468#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1469#[non_exhaustive]
1470#[doc(alias = "PangoOverline")]
1471pub enum Overline {
1472 #[doc(alias = "PANGO_OVERLINE_NONE")]
1473 None,
1474 #[doc(alias = "PANGO_OVERLINE_SINGLE")]
1475 Single,
1476 #[doc(hidden)]
1477 __Unknown(i32),
1478}
1479
1480#[cfg(feature = "v1_46")]
1481#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1482#[doc(hidden)]
1483impl IntoGlib for Overline {
1484 type GlibType = ffi::PangoOverline;
1485
1486 #[inline]
1487 fn into_glib(self) -> ffi::PangoOverline {
1488 match self {
1489 Self::None => ffi::PANGO_OVERLINE_NONE,
1490 Self::Single => ffi::PANGO_OVERLINE_SINGLE,
1491 Self::__Unknown(value) => value,
1492 }
1493 }
1494}
1495
1496#[cfg(feature = "v1_46")]
1497#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1498#[doc(hidden)]
1499impl FromGlib<ffi::PangoOverline> for Overline {
1500 #[inline]
1501 unsafe fn from_glib(value: ffi::PangoOverline) -> Self {
1502 match value {
1503 ffi::PANGO_OVERLINE_NONE => Self::None,
1504 ffi::PANGO_OVERLINE_SINGLE => Self::Single,
1505 value => Self::__Unknown(value),
1506 }
1507 }
1508}
1509
1510#[cfg(feature = "v1_46")]
1511#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1512impl StaticType for Overline {
1513 #[inline]
1514 #[doc(alias = "pango_overline_get_type")]
1515 fn static_type() -> glib::Type {
1516 unsafe { from_glib(ffi::pango_overline_get_type()) }
1517 }
1518}
1519
1520#[cfg(feature = "v1_46")]
1521#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1522impl glib::HasParamSpec for Overline {
1523 type ParamSpec = glib::ParamSpecEnum;
1524 type SetValue = Self;
1525 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1526
1527 fn param_spec_builder() -> Self::BuilderFn {
1528 Self::ParamSpec::builder_with_default
1529 }
1530}
1531
1532#[cfg(feature = "v1_46")]
1533#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1534impl glib::value::ValueType for Overline {
1535 type Type = Self;
1536}
1537
1538#[cfg(feature = "v1_46")]
1539#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1540unsafe impl<'a> glib::value::FromValue<'a> for Overline {
1541 type Checker = glib::value::GenericValueTypeChecker<Self>;
1542
1543 #[inline]
1544 unsafe fn from_value(value: &'a glib::Value) -> Self {
1545 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1546 }
1547}
1548
1549#[cfg(feature = "v1_46")]
1550#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1551impl ToValue for Overline {
1552 #[inline]
1553 fn to_value(&self) -> glib::Value {
1554 let mut value = glib::Value::for_value_type::<Self>();
1555 unsafe {
1556 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1557 }
1558 value
1559 }
1560
1561 #[inline]
1562 fn value_type(&self) -> glib::Type {
1563 Self::static_type()
1564 }
1565}
1566
1567#[cfg(feature = "v1_46")]
1568#[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))]
1569impl From<Overline> for glib::Value {
1570 #[inline]
1571 fn from(v: Overline) -> Self {
1572 ToValue::to_value(&v)
1573 }
1574}
1575
1576#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1577#[non_exhaustive]
1578#[doc(alias = "PangoRenderPart")]
1579pub enum RenderPart {
1580 #[doc(alias = "PANGO_RENDER_PART_FOREGROUND")]
1581 Foreground,
1582 #[doc(alias = "PANGO_RENDER_PART_BACKGROUND")]
1583 Background,
1584 #[doc(alias = "PANGO_RENDER_PART_UNDERLINE")]
1585 Underline,
1586 #[doc(alias = "PANGO_RENDER_PART_STRIKETHROUGH")]
1587 Strikethrough,
1588 #[doc(alias = "PANGO_RENDER_PART_OVERLINE")]
1589 Overline,
1590 #[doc(hidden)]
1591 __Unknown(i32),
1592}
1593
1594#[doc(hidden)]
1595impl IntoGlib for RenderPart {
1596 type GlibType = ffi::PangoRenderPart;
1597
1598 #[inline]
1599 fn into_glib(self) -> ffi::PangoRenderPart {
1600 match self {
1601 Self::Foreground => ffi::PANGO_RENDER_PART_FOREGROUND,
1602 Self::Background => ffi::PANGO_RENDER_PART_BACKGROUND,
1603 Self::Underline => ffi::PANGO_RENDER_PART_UNDERLINE,
1604 Self::Strikethrough => ffi::PANGO_RENDER_PART_STRIKETHROUGH,
1605 Self::Overline => ffi::PANGO_RENDER_PART_OVERLINE,
1606 Self::__Unknown(value) => value,
1607 }
1608 }
1609}
1610
1611#[doc(hidden)]
1612impl FromGlib<ffi::PangoRenderPart> for RenderPart {
1613 #[inline]
1614 unsafe fn from_glib(value: ffi::PangoRenderPart) -> Self {
1615 match value {
1616 ffi::PANGO_RENDER_PART_FOREGROUND => Self::Foreground,
1617 ffi::PANGO_RENDER_PART_BACKGROUND => Self::Background,
1618 ffi::PANGO_RENDER_PART_UNDERLINE => Self::Underline,
1619 ffi::PANGO_RENDER_PART_STRIKETHROUGH => Self::Strikethrough,
1620 ffi::PANGO_RENDER_PART_OVERLINE => Self::Overline,
1621 value => Self::__Unknown(value),
1622 }
1623 }
1624}
1625
1626impl StaticType for RenderPart {
1627 #[inline]
1628 #[doc(alias = "pango_render_part_get_type")]
1629 fn static_type() -> glib::Type {
1630 unsafe { from_glib(ffi::pango_render_part_get_type()) }
1631 }
1632}
1633
1634impl glib::HasParamSpec for RenderPart {
1635 type ParamSpec = glib::ParamSpecEnum;
1636 type SetValue = Self;
1637 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1638
1639 fn param_spec_builder() -> Self::BuilderFn {
1640 Self::ParamSpec::builder_with_default
1641 }
1642}
1643
1644impl glib::value::ValueType for RenderPart {
1645 type Type = Self;
1646}
1647
1648unsafe impl<'a> glib::value::FromValue<'a> for RenderPart {
1649 type Checker = glib::value::GenericValueTypeChecker<Self>;
1650
1651 #[inline]
1652 unsafe fn from_value(value: &'a glib::Value) -> Self {
1653 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1654 }
1655}
1656
1657impl ToValue for RenderPart {
1658 #[inline]
1659 fn to_value(&self) -> glib::Value {
1660 let mut value = glib::Value::for_value_type::<Self>();
1661 unsafe {
1662 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1663 }
1664 value
1665 }
1666
1667 #[inline]
1668 fn value_type(&self) -> glib::Type {
1669 Self::static_type()
1670 }
1671}
1672
1673impl From<RenderPart> for glib::Value {
1674 #[inline]
1675 fn from(v: RenderPart) -> Self {
1676 ToValue::to_value(&v)
1677 }
1678}
1679
1680#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1681#[non_exhaustive]
1682#[doc(alias = "PangoScript")]
1683pub enum Script {
1684 #[doc(alias = "PANGO_SCRIPT_INVALID_CODE")]
1685 InvalidCode,
1686 #[doc(alias = "PANGO_SCRIPT_COMMON")]
1687 Common,
1688 #[doc(alias = "PANGO_SCRIPT_INHERITED")]
1689 Inherited,
1690 #[doc(alias = "PANGO_SCRIPT_ARABIC")]
1691 Arabic,
1692 #[doc(alias = "PANGO_SCRIPT_ARMENIAN")]
1693 Armenian,
1694 #[doc(alias = "PANGO_SCRIPT_BENGALI")]
1695 Bengali,
1696 #[doc(alias = "PANGO_SCRIPT_BOPOMOFO")]
1697 Bopomofo,
1698 #[doc(alias = "PANGO_SCRIPT_CHEROKEE")]
1699 Cherokee,
1700 #[doc(alias = "PANGO_SCRIPT_COPTIC")]
1701 Coptic,
1702 #[doc(alias = "PANGO_SCRIPT_CYRILLIC")]
1703 Cyrillic,
1704 #[doc(alias = "PANGO_SCRIPT_DESERET")]
1705 Deseret,
1706 #[doc(alias = "PANGO_SCRIPT_DEVANAGARI")]
1707 Devanagari,
1708 #[doc(alias = "PANGO_SCRIPT_ETHIOPIC")]
1709 Ethiopic,
1710 #[doc(alias = "PANGO_SCRIPT_GEORGIAN")]
1711 Georgian,
1712 #[doc(alias = "PANGO_SCRIPT_GOTHIC")]
1713 Gothic,
1714 #[doc(alias = "PANGO_SCRIPT_GREEK")]
1715 Greek,
1716 #[doc(alias = "PANGO_SCRIPT_GUJARATI")]
1717 Gujarati,
1718 #[doc(alias = "PANGO_SCRIPT_GURMUKHI")]
1719 Gurmukhi,
1720 #[doc(alias = "PANGO_SCRIPT_HAN")]
1721 Han,
1722 #[doc(alias = "PANGO_SCRIPT_HANGUL")]
1723 Hangul,
1724 #[doc(alias = "PANGO_SCRIPT_HEBREW")]
1725 Hebrew,
1726 #[doc(alias = "PANGO_SCRIPT_HIRAGANA")]
1727 Hiragana,
1728 #[doc(alias = "PANGO_SCRIPT_KANNADA")]
1729 Kannada,
1730 #[doc(alias = "PANGO_SCRIPT_KATAKANA")]
1731 Katakana,
1732 #[doc(alias = "PANGO_SCRIPT_KHMER")]
1733 Khmer,
1734 #[doc(alias = "PANGO_SCRIPT_LAO")]
1735 Lao,
1736 #[doc(alias = "PANGO_SCRIPT_LATIN")]
1737 Latin,
1738 #[doc(alias = "PANGO_SCRIPT_MALAYALAM")]
1739 Malayalam,
1740 #[doc(alias = "PANGO_SCRIPT_MONGOLIAN")]
1741 Mongolian,
1742 #[doc(alias = "PANGO_SCRIPT_MYANMAR")]
1743 Myanmar,
1744 #[doc(alias = "PANGO_SCRIPT_OGHAM")]
1745 Ogham,
1746 #[doc(alias = "PANGO_SCRIPT_OLD_ITALIC")]
1747 OldItalic,
1748 #[doc(alias = "PANGO_SCRIPT_ORIYA")]
1749 Oriya,
1750 #[doc(alias = "PANGO_SCRIPT_RUNIC")]
1751 Runic,
1752 #[doc(alias = "PANGO_SCRIPT_SINHALA")]
1753 Sinhala,
1754 #[doc(alias = "PANGO_SCRIPT_SYRIAC")]
1755 Syriac,
1756 #[doc(alias = "PANGO_SCRIPT_TAMIL")]
1757 Tamil,
1758 #[doc(alias = "PANGO_SCRIPT_TELUGU")]
1759 Telugu,
1760 #[doc(alias = "PANGO_SCRIPT_THAANA")]
1761 Thaana,
1762 #[doc(alias = "PANGO_SCRIPT_THAI")]
1763 Thai,
1764 #[doc(alias = "PANGO_SCRIPT_TIBETAN")]
1765 Tibetan,
1766 #[doc(alias = "PANGO_SCRIPT_CANADIAN_ABORIGINAL")]
1767 CanadianAboriginal,
1768 #[doc(alias = "PANGO_SCRIPT_YI")]
1769 Yi,
1770 #[doc(alias = "PANGO_SCRIPT_TAGALOG")]
1771 Tagalog,
1772 #[doc(alias = "PANGO_SCRIPT_HANUNOO")]
1773 Hanunoo,
1774 #[doc(alias = "PANGO_SCRIPT_BUHID")]
1775 Buhid,
1776 #[doc(alias = "PANGO_SCRIPT_TAGBANWA")]
1777 Tagbanwa,
1778 #[doc(alias = "PANGO_SCRIPT_BRAILLE")]
1779 Braille,
1780 #[doc(alias = "PANGO_SCRIPT_CYPRIOT")]
1781 Cypriot,
1782 #[doc(alias = "PANGO_SCRIPT_LIMBU")]
1783 Limbu,
1784 #[doc(alias = "PANGO_SCRIPT_OSMANYA")]
1785 Osmanya,
1786 #[doc(alias = "PANGO_SCRIPT_SHAVIAN")]
1787 Shavian,
1788 #[doc(alias = "PANGO_SCRIPT_LINEAR_B")]
1789 LinearB,
1790 #[doc(alias = "PANGO_SCRIPT_TAI_LE")]
1791 TaiLe,
1792 #[doc(alias = "PANGO_SCRIPT_UGARITIC")]
1793 Ugaritic,
1794 #[doc(alias = "PANGO_SCRIPT_NEW_TAI_LUE")]
1795 NewTaiLue,
1796 #[doc(alias = "PANGO_SCRIPT_BUGINESE")]
1797 Buginese,
1798 #[doc(alias = "PANGO_SCRIPT_GLAGOLITIC")]
1799 Glagolitic,
1800 #[doc(alias = "PANGO_SCRIPT_TIFINAGH")]
1801 Tifinagh,
1802 #[doc(alias = "PANGO_SCRIPT_SYLOTI_NAGRI")]
1803 SylotiNagri,
1804 #[doc(alias = "PANGO_SCRIPT_OLD_PERSIAN")]
1805 OldPersian,
1806 #[doc(alias = "PANGO_SCRIPT_KHAROSHTHI")]
1807 Kharoshthi,
1808 #[doc(alias = "PANGO_SCRIPT_UNKNOWN")]
1809 Unknown,
1810 #[doc(alias = "PANGO_SCRIPT_BALINESE")]
1811 Balinese,
1812 #[doc(alias = "PANGO_SCRIPT_CUNEIFORM")]
1813 Cuneiform,
1814 #[doc(alias = "PANGO_SCRIPT_PHOENICIAN")]
1815 Phoenician,
1816 #[doc(alias = "PANGO_SCRIPT_PHAGS_PA")]
1817 PhagsPa,
1818 #[doc(alias = "PANGO_SCRIPT_NKO")]
1819 Nko,
1820 #[doc(alias = "PANGO_SCRIPT_KAYAH_LI")]
1821 KayahLi,
1822 #[doc(alias = "PANGO_SCRIPT_LEPCHA")]
1823 Lepcha,
1824 #[doc(alias = "PANGO_SCRIPT_REJANG")]
1825 Rejang,
1826 #[doc(alias = "PANGO_SCRIPT_SUNDANESE")]
1827 Sundanese,
1828 #[doc(alias = "PANGO_SCRIPT_SAURASHTRA")]
1829 Saurashtra,
1830 #[doc(alias = "PANGO_SCRIPT_CHAM")]
1831 Cham,
1832 #[doc(alias = "PANGO_SCRIPT_OL_CHIKI")]
1833 OlChiki,
1834 #[doc(alias = "PANGO_SCRIPT_VAI")]
1835 Vai,
1836 #[doc(alias = "PANGO_SCRIPT_CARIAN")]
1837 Carian,
1838 #[doc(alias = "PANGO_SCRIPT_LYCIAN")]
1839 Lycian,
1840 #[doc(alias = "PANGO_SCRIPT_LYDIAN")]
1841 Lydian,
1842 #[doc(alias = "PANGO_SCRIPT_BATAK")]
1843 Batak,
1844 #[doc(alias = "PANGO_SCRIPT_BRAHMI")]
1845 Brahmi,
1846 #[doc(alias = "PANGO_SCRIPT_MANDAIC")]
1847 Mandaic,
1848 #[doc(alias = "PANGO_SCRIPT_CHAKMA")]
1849 Chakma,
1850 #[doc(alias = "PANGO_SCRIPT_MEROITIC_CURSIVE")]
1851 MeroiticCursive,
1852 #[doc(alias = "PANGO_SCRIPT_MEROITIC_HIEROGLYPHS")]
1853 MeroiticHieroglyphs,
1854 #[doc(alias = "PANGO_SCRIPT_MIAO")]
1855 Miao,
1856 #[doc(alias = "PANGO_SCRIPT_SHARADA")]
1857 Sharada,
1858 #[doc(alias = "PANGO_SCRIPT_SORA_SOMPENG")]
1859 SoraSompeng,
1860 #[doc(alias = "PANGO_SCRIPT_TAKRI")]
1861 Takri,
1862 #[doc(alias = "PANGO_SCRIPT_BASSA_VAH")]
1863 BassaVah,
1864 #[doc(alias = "PANGO_SCRIPT_CAUCASIAN_ALBANIAN")]
1865 CaucasianAlbanian,
1866 #[doc(alias = "PANGO_SCRIPT_DUPLOYAN")]
1867 Duployan,
1868 #[doc(alias = "PANGO_SCRIPT_ELBASAN")]
1869 Elbasan,
1870 #[doc(alias = "PANGO_SCRIPT_GRANTHA")]
1871 Grantha,
1872 #[doc(alias = "PANGO_SCRIPT_KHOJKI")]
1873 Khojki,
1874 #[doc(alias = "PANGO_SCRIPT_KHUDAWADI")]
1875 Khudawadi,
1876 #[doc(alias = "PANGO_SCRIPT_LINEAR_A")]
1877 LinearA,
1878 #[doc(alias = "PANGO_SCRIPT_MAHAJANI")]
1879 Mahajani,
1880 #[doc(alias = "PANGO_SCRIPT_MANICHAEAN")]
1881 Manichaean,
1882 #[doc(alias = "PANGO_SCRIPT_MENDE_KIKAKUI")]
1883 MendeKikakui,
1884 #[doc(alias = "PANGO_SCRIPT_MODI")]
1885 Modi,
1886 #[doc(alias = "PANGO_SCRIPT_MRO")]
1887 Mro,
1888 #[doc(alias = "PANGO_SCRIPT_NABATAEAN")]
1889 Nabataean,
1890 #[doc(alias = "PANGO_SCRIPT_OLD_NORTH_ARABIAN")]
1891 OldNorthArabian,
1892 #[doc(alias = "PANGO_SCRIPT_OLD_PERMIC")]
1893 OldPermic,
1894 #[doc(alias = "PANGO_SCRIPT_PAHAWH_HMONG")]
1895 PahawhHmong,
1896 #[doc(alias = "PANGO_SCRIPT_PALMYRENE")]
1897 Palmyrene,
1898 #[doc(alias = "PANGO_SCRIPT_PAU_CIN_HAU")]
1899 PauCinHau,
1900 #[doc(alias = "PANGO_SCRIPT_PSALTER_PAHLAVI")]
1901 PsalterPahlavi,
1902 #[doc(alias = "PANGO_SCRIPT_SIDDHAM")]
1903 Siddham,
1904 #[doc(alias = "PANGO_SCRIPT_TIRHUTA")]
1905 Tirhuta,
1906 #[doc(alias = "PANGO_SCRIPT_WARANG_CITI")]
1907 WarangCiti,
1908 #[doc(alias = "PANGO_SCRIPT_AHOM")]
1909 Ahom,
1910 #[doc(alias = "PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS")]
1911 AnatolianHieroglyphs,
1912 #[doc(alias = "PANGO_SCRIPT_HATRAN")]
1913 Hatran,
1914 #[doc(alias = "PANGO_SCRIPT_MULTANI")]
1915 Multani,
1916 #[doc(alias = "PANGO_SCRIPT_OLD_HUNGARIAN")]
1917 OldHungarian,
1918 #[doc(alias = "PANGO_SCRIPT_SIGNWRITING")]
1919 Signwriting,
1920 #[doc(hidden)]
1921 __Unknown(i32),
1922}
1923
1924impl Script {
1925 #[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")]
1926 #[allow(deprecated)]
1927 #[doc(alias = "pango_script_for_unichar")]
1928 pub fn for_unichar(ch: char) -> Script {
1929 unsafe { from_glib(ffi::pango_script_for_unichar(ch.into_glib())) }
1930 }
1931
1932 #[doc(alias = "pango_script_get_sample_language")]
1933 #[doc(alias = "get_sample_language")]
1934 pub fn sample_language(self) -> Option<Language> {
1935 unsafe { from_glib_full(ffi::pango_script_get_sample_language(self.into_glib())) }
1936 }
1937}
1938
1939#[doc(hidden)]
1940impl IntoGlib for Script {
1941 type GlibType = ffi::PangoScript;
1942
1943 fn into_glib(self) -> ffi::PangoScript {
1944 match self {
1945 Self::InvalidCode => ffi::PANGO_SCRIPT_INVALID_CODE,
1946 Self::Common => ffi::PANGO_SCRIPT_COMMON,
1947 Self::Inherited => ffi::PANGO_SCRIPT_INHERITED,
1948 Self::Arabic => ffi::PANGO_SCRIPT_ARABIC,
1949 Self::Armenian => ffi::PANGO_SCRIPT_ARMENIAN,
1950 Self::Bengali => ffi::PANGO_SCRIPT_BENGALI,
1951 Self::Bopomofo => ffi::PANGO_SCRIPT_BOPOMOFO,
1952 Self::Cherokee => ffi::PANGO_SCRIPT_CHEROKEE,
1953 Self::Coptic => ffi::PANGO_SCRIPT_COPTIC,
1954 Self::Cyrillic => ffi::PANGO_SCRIPT_CYRILLIC,
1955 Self::Deseret => ffi::PANGO_SCRIPT_DESERET,
1956 Self::Devanagari => ffi::PANGO_SCRIPT_DEVANAGARI,
1957 Self::Ethiopic => ffi::PANGO_SCRIPT_ETHIOPIC,
1958 Self::Georgian => ffi::PANGO_SCRIPT_GEORGIAN,
1959 Self::Gothic => ffi::PANGO_SCRIPT_GOTHIC,
1960 Self::Greek => ffi::PANGO_SCRIPT_GREEK,
1961 Self::Gujarati => ffi::PANGO_SCRIPT_GUJARATI,
1962 Self::Gurmukhi => ffi::PANGO_SCRIPT_GURMUKHI,
1963 Self::Han => ffi::PANGO_SCRIPT_HAN,
1964 Self::Hangul => ffi::PANGO_SCRIPT_HANGUL,
1965 Self::Hebrew => ffi::PANGO_SCRIPT_HEBREW,
1966 Self::Hiragana => ffi::PANGO_SCRIPT_HIRAGANA,
1967 Self::Kannada => ffi::PANGO_SCRIPT_KANNADA,
1968 Self::Katakana => ffi::PANGO_SCRIPT_KATAKANA,
1969 Self::Khmer => ffi::PANGO_SCRIPT_KHMER,
1970 Self::Lao => ffi::PANGO_SCRIPT_LAO,
1971 Self::Latin => ffi::PANGO_SCRIPT_LATIN,
1972 Self::Malayalam => ffi::PANGO_SCRIPT_MALAYALAM,
1973 Self::Mongolian => ffi::PANGO_SCRIPT_MONGOLIAN,
1974 Self::Myanmar => ffi::PANGO_SCRIPT_MYANMAR,
1975 Self::Ogham => ffi::PANGO_SCRIPT_OGHAM,
1976 Self::OldItalic => ffi::PANGO_SCRIPT_OLD_ITALIC,
1977 Self::Oriya => ffi::PANGO_SCRIPT_ORIYA,
1978 Self::Runic => ffi::PANGO_SCRIPT_RUNIC,
1979 Self::Sinhala => ffi::PANGO_SCRIPT_SINHALA,
1980 Self::Syriac => ffi::PANGO_SCRIPT_SYRIAC,
1981 Self::Tamil => ffi::PANGO_SCRIPT_TAMIL,
1982 Self::Telugu => ffi::PANGO_SCRIPT_TELUGU,
1983 Self::Thaana => ffi::PANGO_SCRIPT_THAANA,
1984 Self::Thai => ffi::PANGO_SCRIPT_THAI,
1985 Self::Tibetan => ffi::PANGO_SCRIPT_TIBETAN,
1986 Self::CanadianAboriginal => ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL,
1987 Self::Yi => ffi::PANGO_SCRIPT_YI,
1988 Self::Tagalog => ffi::PANGO_SCRIPT_TAGALOG,
1989 Self::Hanunoo => ffi::PANGO_SCRIPT_HANUNOO,
1990 Self::Buhid => ffi::PANGO_SCRIPT_BUHID,
1991 Self::Tagbanwa => ffi::PANGO_SCRIPT_TAGBANWA,
1992 Self::Braille => ffi::PANGO_SCRIPT_BRAILLE,
1993 Self::Cypriot => ffi::PANGO_SCRIPT_CYPRIOT,
1994 Self::Limbu => ffi::PANGO_SCRIPT_LIMBU,
1995 Self::Osmanya => ffi::PANGO_SCRIPT_OSMANYA,
1996 Self::Shavian => ffi::PANGO_SCRIPT_SHAVIAN,
1997 Self::LinearB => ffi::PANGO_SCRIPT_LINEAR_B,
1998 Self::TaiLe => ffi::PANGO_SCRIPT_TAI_LE,
1999 Self::Ugaritic => ffi::PANGO_SCRIPT_UGARITIC,
2000 Self::NewTaiLue => ffi::PANGO_SCRIPT_NEW_TAI_LUE,
2001 Self::Buginese => ffi::PANGO_SCRIPT_BUGINESE,
2002 Self::Glagolitic => ffi::PANGO_SCRIPT_GLAGOLITIC,
2003 Self::Tifinagh => ffi::PANGO_SCRIPT_TIFINAGH,
2004 Self::SylotiNagri => ffi::PANGO_SCRIPT_SYLOTI_NAGRI,
2005 Self::OldPersian => ffi::PANGO_SCRIPT_OLD_PERSIAN,
2006 Self::Kharoshthi => ffi::PANGO_SCRIPT_KHAROSHTHI,
2007 Self::Unknown => ffi::PANGO_SCRIPT_UNKNOWN,
2008 Self::Balinese => ffi::PANGO_SCRIPT_BALINESE,
2009 Self::Cuneiform => ffi::PANGO_SCRIPT_CUNEIFORM,
2010 Self::Phoenician => ffi::PANGO_SCRIPT_PHOENICIAN,
2011 Self::PhagsPa => ffi::PANGO_SCRIPT_PHAGS_PA,
2012 Self::Nko => ffi::PANGO_SCRIPT_NKO,
2013 Self::KayahLi => ffi::PANGO_SCRIPT_KAYAH_LI,
2014 Self::Lepcha => ffi::PANGO_SCRIPT_LEPCHA,
2015 Self::Rejang => ffi::PANGO_SCRIPT_REJANG,
2016 Self::Sundanese => ffi::PANGO_SCRIPT_SUNDANESE,
2017 Self::Saurashtra => ffi::PANGO_SCRIPT_SAURASHTRA,
2018 Self::Cham => ffi::PANGO_SCRIPT_CHAM,
2019 Self::OlChiki => ffi::PANGO_SCRIPT_OL_CHIKI,
2020 Self::Vai => ffi::PANGO_SCRIPT_VAI,
2021 Self::Carian => ffi::PANGO_SCRIPT_CARIAN,
2022 Self::Lycian => ffi::PANGO_SCRIPT_LYCIAN,
2023 Self::Lydian => ffi::PANGO_SCRIPT_LYDIAN,
2024 Self::Batak => ffi::PANGO_SCRIPT_BATAK,
2025 Self::Brahmi => ffi::PANGO_SCRIPT_BRAHMI,
2026 Self::Mandaic => ffi::PANGO_SCRIPT_MANDAIC,
2027 Self::Chakma => ffi::PANGO_SCRIPT_CHAKMA,
2028 Self::MeroiticCursive => ffi::PANGO_SCRIPT_MEROITIC_CURSIVE,
2029 Self::MeroiticHieroglyphs => ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS,
2030 Self::Miao => ffi::PANGO_SCRIPT_MIAO,
2031 Self::Sharada => ffi::PANGO_SCRIPT_SHARADA,
2032 Self::SoraSompeng => ffi::PANGO_SCRIPT_SORA_SOMPENG,
2033 Self::Takri => ffi::PANGO_SCRIPT_TAKRI,
2034 Self::BassaVah => ffi::PANGO_SCRIPT_BASSA_VAH,
2035 Self::CaucasianAlbanian => ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN,
2036 Self::Duployan => ffi::PANGO_SCRIPT_DUPLOYAN,
2037 Self::Elbasan => ffi::PANGO_SCRIPT_ELBASAN,
2038 Self::Grantha => ffi::PANGO_SCRIPT_GRANTHA,
2039 Self::Khojki => ffi::PANGO_SCRIPT_KHOJKI,
2040 Self::Khudawadi => ffi::PANGO_SCRIPT_KHUDAWADI,
2041 Self::LinearA => ffi::PANGO_SCRIPT_LINEAR_A,
2042 Self::Mahajani => ffi::PANGO_SCRIPT_MAHAJANI,
2043 Self::Manichaean => ffi::PANGO_SCRIPT_MANICHAEAN,
2044 Self::MendeKikakui => ffi::PANGO_SCRIPT_MENDE_KIKAKUI,
2045 Self::Modi => ffi::PANGO_SCRIPT_MODI,
2046 Self::Mro => ffi::PANGO_SCRIPT_MRO,
2047 Self::Nabataean => ffi::PANGO_SCRIPT_NABATAEAN,
2048 Self::OldNorthArabian => ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN,
2049 Self::OldPermic => ffi::PANGO_SCRIPT_OLD_PERMIC,
2050 Self::PahawhHmong => ffi::PANGO_SCRIPT_PAHAWH_HMONG,
2051 Self::Palmyrene => ffi::PANGO_SCRIPT_PALMYRENE,
2052 Self::PauCinHau => ffi::PANGO_SCRIPT_PAU_CIN_HAU,
2053 Self::PsalterPahlavi => ffi::PANGO_SCRIPT_PSALTER_PAHLAVI,
2054 Self::Siddham => ffi::PANGO_SCRIPT_SIDDHAM,
2055 Self::Tirhuta => ffi::PANGO_SCRIPT_TIRHUTA,
2056 Self::WarangCiti => ffi::PANGO_SCRIPT_WARANG_CITI,
2057 Self::Ahom => ffi::PANGO_SCRIPT_AHOM,
2058 Self::AnatolianHieroglyphs => ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS,
2059 Self::Hatran => ffi::PANGO_SCRIPT_HATRAN,
2060 Self::Multani => ffi::PANGO_SCRIPT_MULTANI,
2061 Self::OldHungarian => ffi::PANGO_SCRIPT_OLD_HUNGARIAN,
2062 Self::Signwriting => ffi::PANGO_SCRIPT_SIGNWRITING,
2063 Self::__Unknown(value) => value,
2064 }
2065 }
2066}
2067
2068#[doc(hidden)]
2069impl FromGlib<ffi::PangoScript> for Script {
2070 unsafe fn from_glib(value: ffi::PangoScript) -> Self {
2071 match value {
2072 ffi::PANGO_SCRIPT_INVALID_CODE => Self::InvalidCode,
2073 ffi::PANGO_SCRIPT_COMMON => Self::Common,
2074 ffi::PANGO_SCRIPT_INHERITED => Self::Inherited,
2075 ffi::PANGO_SCRIPT_ARABIC => Self::Arabic,
2076 ffi::PANGO_SCRIPT_ARMENIAN => Self::Armenian,
2077 ffi::PANGO_SCRIPT_BENGALI => Self::Bengali,
2078 ffi::PANGO_SCRIPT_BOPOMOFO => Self::Bopomofo,
2079 ffi::PANGO_SCRIPT_CHEROKEE => Self::Cherokee,
2080 ffi::PANGO_SCRIPT_COPTIC => Self::Coptic,
2081 ffi::PANGO_SCRIPT_CYRILLIC => Self::Cyrillic,
2082 ffi::PANGO_SCRIPT_DESERET => Self::Deseret,
2083 ffi::PANGO_SCRIPT_DEVANAGARI => Self::Devanagari,
2084 ffi::PANGO_SCRIPT_ETHIOPIC => Self::Ethiopic,
2085 ffi::PANGO_SCRIPT_GEORGIAN => Self::Georgian,
2086 ffi::PANGO_SCRIPT_GOTHIC => Self::Gothic,
2087 ffi::PANGO_SCRIPT_GREEK => Self::Greek,
2088 ffi::PANGO_SCRIPT_GUJARATI => Self::Gujarati,
2089 ffi::PANGO_SCRIPT_GURMUKHI => Self::Gurmukhi,
2090 ffi::PANGO_SCRIPT_HAN => Self::Han,
2091 ffi::PANGO_SCRIPT_HANGUL => Self::Hangul,
2092 ffi::PANGO_SCRIPT_HEBREW => Self::Hebrew,
2093 ffi::PANGO_SCRIPT_HIRAGANA => Self::Hiragana,
2094 ffi::PANGO_SCRIPT_KANNADA => Self::Kannada,
2095 ffi::PANGO_SCRIPT_KATAKANA => Self::Katakana,
2096 ffi::PANGO_SCRIPT_KHMER => Self::Khmer,
2097 ffi::PANGO_SCRIPT_LAO => Self::Lao,
2098 ffi::PANGO_SCRIPT_LATIN => Self::Latin,
2099 ffi::PANGO_SCRIPT_MALAYALAM => Self::Malayalam,
2100 ffi::PANGO_SCRIPT_MONGOLIAN => Self::Mongolian,
2101 ffi::PANGO_SCRIPT_MYANMAR => Self::Myanmar,
2102 ffi::PANGO_SCRIPT_OGHAM => Self::Ogham,
2103 ffi::PANGO_SCRIPT_OLD_ITALIC => Self::OldItalic,
2104 ffi::PANGO_SCRIPT_ORIYA => Self::Oriya,
2105 ffi::PANGO_SCRIPT_RUNIC => Self::Runic,
2106 ffi::PANGO_SCRIPT_SINHALA => Self::Sinhala,
2107 ffi::PANGO_SCRIPT_SYRIAC => Self::Syriac,
2108 ffi::PANGO_SCRIPT_TAMIL => Self::Tamil,
2109 ffi::PANGO_SCRIPT_TELUGU => Self::Telugu,
2110 ffi::PANGO_SCRIPT_THAANA => Self::Thaana,
2111 ffi::PANGO_SCRIPT_THAI => Self::Thai,
2112 ffi::PANGO_SCRIPT_TIBETAN => Self::Tibetan,
2113 ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL => Self::CanadianAboriginal,
2114 ffi::PANGO_SCRIPT_YI => Self::Yi,
2115 ffi::PANGO_SCRIPT_TAGALOG => Self::Tagalog,
2116 ffi::PANGO_SCRIPT_HANUNOO => Self::Hanunoo,
2117 ffi::PANGO_SCRIPT_BUHID => Self::Buhid,
2118 ffi::PANGO_SCRIPT_TAGBANWA => Self::Tagbanwa,
2119 ffi::PANGO_SCRIPT_BRAILLE => Self::Braille,
2120 ffi::PANGO_SCRIPT_CYPRIOT => Self::Cypriot,
2121 ffi::PANGO_SCRIPT_LIMBU => Self::Limbu,
2122 ffi::PANGO_SCRIPT_OSMANYA => Self::Osmanya,
2123 ffi::PANGO_SCRIPT_SHAVIAN => Self::Shavian,
2124 ffi::PANGO_SCRIPT_LINEAR_B => Self::LinearB,
2125 ffi::PANGO_SCRIPT_TAI_LE => Self::TaiLe,
2126 ffi::PANGO_SCRIPT_UGARITIC => Self::Ugaritic,
2127 ffi::PANGO_SCRIPT_NEW_TAI_LUE => Self::NewTaiLue,
2128 ffi::PANGO_SCRIPT_BUGINESE => Self::Buginese,
2129 ffi::PANGO_SCRIPT_GLAGOLITIC => Self::Glagolitic,
2130 ffi::PANGO_SCRIPT_TIFINAGH => Self::Tifinagh,
2131 ffi::PANGO_SCRIPT_SYLOTI_NAGRI => Self::SylotiNagri,
2132 ffi::PANGO_SCRIPT_OLD_PERSIAN => Self::OldPersian,
2133 ffi::PANGO_SCRIPT_KHAROSHTHI => Self::Kharoshthi,
2134 ffi::PANGO_SCRIPT_UNKNOWN => Self::Unknown,
2135 ffi::PANGO_SCRIPT_BALINESE => Self::Balinese,
2136 ffi::PANGO_SCRIPT_CUNEIFORM => Self::Cuneiform,
2137 ffi::PANGO_SCRIPT_PHOENICIAN => Self::Phoenician,
2138 ffi::PANGO_SCRIPT_PHAGS_PA => Self::PhagsPa,
2139 ffi::PANGO_SCRIPT_NKO => Self::Nko,
2140 ffi::PANGO_SCRIPT_KAYAH_LI => Self::KayahLi,
2141 ffi::PANGO_SCRIPT_LEPCHA => Self::Lepcha,
2142 ffi::PANGO_SCRIPT_REJANG => Self::Rejang,
2143 ffi::PANGO_SCRIPT_SUNDANESE => Self::Sundanese,
2144 ffi::PANGO_SCRIPT_SAURASHTRA => Self::Saurashtra,
2145 ffi::PANGO_SCRIPT_CHAM => Self::Cham,
2146 ffi::PANGO_SCRIPT_OL_CHIKI => Self::OlChiki,
2147 ffi::PANGO_SCRIPT_VAI => Self::Vai,
2148 ffi::PANGO_SCRIPT_CARIAN => Self::Carian,
2149 ffi::PANGO_SCRIPT_LYCIAN => Self::Lycian,
2150 ffi::PANGO_SCRIPT_LYDIAN => Self::Lydian,
2151 ffi::PANGO_SCRIPT_BATAK => Self::Batak,
2152 ffi::PANGO_SCRIPT_BRAHMI => Self::Brahmi,
2153 ffi::PANGO_SCRIPT_MANDAIC => Self::Mandaic,
2154 ffi::PANGO_SCRIPT_CHAKMA => Self::Chakma,
2155 ffi::PANGO_SCRIPT_MEROITIC_CURSIVE => Self::MeroiticCursive,
2156 ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS => Self::MeroiticHieroglyphs,
2157 ffi::PANGO_SCRIPT_MIAO => Self::Miao,
2158 ffi::PANGO_SCRIPT_SHARADA => Self::Sharada,
2159 ffi::PANGO_SCRIPT_SORA_SOMPENG => Self::SoraSompeng,
2160 ffi::PANGO_SCRIPT_TAKRI => Self::Takri,
2161 ffi::PANGO_SCRIPT_BASSA_VAH => Self::BassaVah,
2162 ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN => Self::CaucasianAlbanian,
2163 ffi::PANGO_SCRIPT_DUPLOYAN => Self::Duployan,
2164 ffi::PANGO_SCRIPT_ELBASAN => Self::Elbasan,
2165 ffi::PANGO_SCRIPT_GRANTHA => Self::Grantha,
2166 ffi::PANGO_SCRIPT_KHOJKI => Self::Khojki,
2167 ffi::PANGO_SCRIPT_KHUDAWADI => Self::Khudawadi,
2168 ffi::PANGO_SCRIPT_LINEAR_A => Self::LinearA,
2169 ffi::PANGO_SCRIPT_MAHAJANI => Self::Mahajani,
2170 ffi::PANGO_SCRIPT_MANICHAEAN => Self::Manichaean,
2171 ffi::PANGO_SCRIPT_MENDE_KIKAKUI => Self::MendeKikakui,
2172 ffi::PANGO_SCRIPT_MODI => Self::Modi,
2173 ffi::PANGO_SCRIPT_MRO => Self::Mro,
2174 ffi::PANGO_SCRIPT_NABATAEAN => Self::Nabataean,
2175 ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN => Self::OldNorthArabian,
2176 ffi::PANGO_SCRIPT_OLD_PERMIC => Self::OldPermic,
2177 ffi::PANGO_SCRIPT_PAHAWH_HMONG => Self::PahawhHmong,
2178 ffi::PANGO_SCRIPT_PALMYRENE => Self::Palmyrene,
2179 ffi::PANGO_SCRIPT_PAU_CIN_HAU => Self::PauCinHau,
2180 ffi::PANGO_SCRIPT_PSALTER_PAHLAVI => Self::PsalterPahlavi,
2181 ffi::PANGO_SCRIPT_SIDDHAM => Self::Siddham,
2182 ffi::PANGO_SCRIPT_TIRHUTA => Self::Tirhuta,
2183 ffi::PANGO_SCRIPT_WARANG_CITI => Self::WarangCiti,
2184 ffi::PANGO_SCRIPT_AHOM => Self::Ahom,
2185 ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS => Self::AnatolianHieroglyphs,
2186 ffi::PANGO_SCRIPT_HATRAN => Self::Hatran,
2187 ffi::PANGO_SCRIPT_MULTANI => Self::Multani,
2188 ffi::PANGO_SCRIPT_OLD_HUNGARIAN => Self::OldHungarian,
2189 ffi::PANGO_SCRIPT_SIGNWRITING => Self::Signwriting,
2190 value => Self::__Unknown(value),
2191 }
2192 }
2193}
2194
2195impl StaticType for Script {
2196 #[inline]
2197 #[doc(alias = "pango_script_get_type")]
2198 fn static_type() -> glib::Type {
2199 unsafe { from_glib(ffi::pango_script_get_type()) }
2200 }
2201}
2202
2203impl glib::HasParamSpec for Script {
2204 type ParamSpec = glib::ParamSpecEnum;
2205 type SetValue = Self;
2206 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2207
2208 fn param_spec_builder() -> Self::BuilderFn {
2209 Self::ParamSpec::builder_with_default
2210 }
2211}
2212
2213impl glib::value::ValueType for Script {
2214 type Type = Self;
2215}
2216
2217unsafe impl<'a> glib::value::FromValue<'a> for Script {
2218 type Checker = glib::value::GenericValueTypeChecker<Self>;
2219
2220 #[inline]
2221 unsafe fn from_value(value: &'a glib::Value) -> Self {
2222 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2223 }
2224}
2225
2226impl ToValue for Script {
2227 #[inline]
2228 fn to_value(&self) -> glib::Value {
2229 let mut value = glib::Value::for_value_type::<Self>();
2230 unsafe {
2231 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2232 }
2233 value
2234 }
2235
2236 #[inline]
2237 fn value_type(&self) -> glib::Type {
2238 Self::static_type()
2239 }
2240}
2241
2242impl From<Script> for glib::Value {
2243 #[inline]
2244 fn from(v: Script) -> Self {
2245 ToValue::to_value(&v)
2246 }
2247}
2248
2249#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2250#[non_exhaustive]
2251#[doc(alias = "PangoStretch")]
2252pub enum Stretch {
2253 #[doc(alias = "PANGO_STRETCH_ULTRA_CONDENSED")]
2254 UltraCondensed,
2255 #[doc(alias = "PANGO_STRETCH_EXTRA_CONDENSED")]
2256 ExtraCondensed,
2257 #[doc(alias = "PANGO_STRETCH_CONDENSED")]
2258 Condensed,
2259 #[doc(alias = "PANGO_STRETCH_SEMI_CONDENSED")]
2260 SemiCondensed,
2261 #[doc(alias = "PANGO_STRETCH_NORMAL")]
2262 Normal,
2263 #[doc(alias = "PANGO_STRETCH_SEMI_EXPANDED")]
2264 SemiExpanded,
2265 #[doc(alias = "PANGO_STRETCH_EXPANDED")]
2266 Expanded,
2267 #[doc(alias = "PANGO_STRETCH_EXTRA_EXPANDED")]
2268 ExtraExpanded,
2269 #[doc(alias = "PANGO_STRETCH_ULTRA_EXPANDED")]
2270 UltraExpanded,
2271 #[doc(hidden)]
2272 __Unknown(i32),
2273}
2274
2275#[doc(hidden)]
2276impl IntoGlib for Stretch {
2277 type GlibType = ffi::PangoStretch;
2278
2279 #[inline]
2280 fn into_glib(self) -> ffi::PangoStretch {
2281 match self {
2282 Self::UltraCondensed => ffi::PANGO_STRETCH_ULTRA_CONDENSED,
2283 Self::ExtraCondensed => ffi::PANGO_STRETCH_EXTRA_CONDENSED,
2284 Self::Condensed => ffi::PANGO_STRETCH_CONDENSED,
2285 Self::SemiCondensed => ffi::PANGO_STRETCH_SEMI_CONDENSED,
2286 Self::Normal => ffi::PANGO_STRETCH_NORMAL,
2287 Self::SemiExpanded => ffi::PANGO_STRETCH_SEMI_EXPANDED,
2288 Self::Expanded => ffi::PANGO_STRETCH_EXPANDED,
2289 Self::ExtraExpanded => ffi::PANGO_STRETCH_EXTRA_EXPANDED,
2290 Self::UltraExpanded => ffi::PANGO_STRETCH_ULTRA_EXPANDED,
2291 Self::__Unknown(value) => value,
2292 }
2293 }
2294}
2295
2296#[doc(hidden)]
2297impl FromGlib<ffi::PangoStretch> for Stretch {
2298 #[inline]
2299 unsafe fn from_glib(value: ffi::PangoStretch) -> Self {
2300 match value {
2301 ffi::PANGO_STRETCH_ULTRA_CONDENSED => Self::UltraCondensed,
2302 ffi::PANGO_STRETCH_EXTRA_CONDENSED => Self::ExtraCondensed,
2303 ffi::PANGO_STRETCH_CONDENSED => Self::Condensed,
2304 ffi::PANGO_STRETCH_SEMI_CONDENSED => Self::SemiCondensed,
2305 ffi::PANGO_STRETCH_NORMAL => Self::Normal,
2306 ffi::PANGO_STRETCH_SEMI_EXPANDED => Self::SemiExpanded,
2307 ffi::PANGO_STRETCH_EXPANDED => Self::Expanded,
2308 ffi::PANGO_STRETCH_EXTRA_EXPANDED => Self::ExtraExpanded,
2309 ffi::PANGO_STRETCH_ULTRA_EXPANDED => Self::UltraExpanded,
2310 value => Self::__Unknown(value),
2311 }
2312 }
2313}
2314
2315impl StaticType for Stretch {
2316 #[inline]
2317 #[doc(alias = "pango_stretch_get_type")]
2318 fn static_type() -> glib::Type {
2319 unsafe { from_glib(ffi::pango_stretch_get_type()) }
2320 }
2321}
2322
2323impl glib::HasParamSpec for Stretch {
2324 type ParamSpec = glib::ParamSpecEnum;
2325 type SetValue = Self;
2326 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2327
2328 fn param_spec_builder() -> Self::BuilderFn {
2329 Self::ParamSpec::builder_with_default
2330 }
2331}
2332
2333impl glib::value::ValueType for Stretch {
2334 type Type = Self;
2335}
2336
2337unsafe impl<'a> glib::value::FromValue<'a> for Stretch {
2338 type Checker = glib::value::GenericValueTypeChecker<Self>;
2339
2340 #[inline]
2341 unsafe fn from_value(value: &'a glib::Value) -> Self {
2342 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2343 }
2344}
2345
2346impl ToValue for Stretch {
2347 #[inline]
2348 fn to_value(&self) -> glib::Value {
2349 let mut value = glib::Value::for_value_type::<Self>();
2350 unsafe {
2351 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2352 }
2353 value
2354 }
2355
2356 #[inline]
2357 fn value_type(&self) -> glib::Type {
2358 Self::static_type()
2359 }
2360}
2361
2362impl From<Stretch> for glib::Value {
2363 #[inline]
2364 fn from(v: Stretch) -> Self {
2365 ToValue::to_value(&v)
2366 }
2367}
2368
2369#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2370#[non_exhaustive]
2371#[doc(alias = "PangoStyle")]
2372pub enum Style {
2373 #[doc(alias = "PANGO_STYLE_NORMAL")]
2374 Normal,
2375 #[doc(alias = "PANGO_STYLE_OBLIQUE")]
2376 Oblique,
2377 #[doc(alias = "PANGO_STYLE_ITALIC")]
2378 Italic,
2379 #[doc(hidden)]
2380 __Unknown(i32),
2381}
2382
2383#[doc(hidden)]
2384impl IntoGlib for Style {
2385 type GlibType = ffi::PangoStyle;
2386
2387 #[inline]
2388 fn into_glib(self) -> ffi::PangoStyle {
2389 match self {
2390 Self::Normal => ffi::PANGO_STYLE_NORMAL,
2391 Self::Oblique => ffi::PANGO_STYLE_OBLIQUE,
2392 Self::Italic => ffi::PANGO_STYLE_ITALIC,
2393 Self::__Unknown(value) => value,
2394 }
2395 }
2396}
2397
2398#[doc(hidden)]
2399impl FromGlib<ffi::PangoStyle> for Style {
2400 #[inline]
2401 unsafe fn from_glib(value: ffi::PangoStyle) -> Self {
2402 match value {
2403 ffi::PANGO_STYLE_NORMAL => Self::Normal,
2404 ffi::PANGO_STYLE_OBLIQUE => Self::Oblique,
2405 ffi::PANGO_STYLE_ITALIC => Self::Italic,
2406 value => Self::__Unknown(value),
2407 }
2408 }
2409}
2410
2411impl StaticType for Style {
2412 #[inline]
2413 #[doc(alias = "pango_style_get_type")]
2414 fn static_type() -> glib::Type {
2415 unsafe { from_glib(ffi::pango_style_get_type()) }
2416 }
2417}
2418
2419impl glib::HasParamSpec for Style {
2420 type ParamSpec = glib::ParamSpecEnum;
2421 type SetValue = Self;
2422 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2423
2424 fn param_spec_builder() -> Self::BuilderFn {
2425 Self::ParamSpec::builder_with_default
2426 }
2427}
2428
2429impl glib::value::ValueType for Style {
2430 type Type = Self;
2431}
2432
2433unsafe impl<'a> glib::value::FromValue<'a> for Style {
2434 type Checker = glib::value::GenericValueTypeChecker<Self>;
2435
2436 #[inline]
2437 unsafe fn from_value(value: &'a glib::Value) -> Self {
2438 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2439 }
2440}
2441
2442impl ToValue for Style {
2443 #[inline]
2444 fn to_value(&self) -> glib::Value {
2445 let mut value = glib::Value::for_value_type::<Self>();
2446 unsafe {
2447 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2448 }
2449 value
2450 }
2451
2452 #[inline]
2453 fn value_type(&self) -> glib::Type {
2454 Self::static_type()
2455 }
2456}
2457
2458impl From<Style> for glib::Value {
2459 #[inline]
2460 fn from(v: Style) -> Self {
2461 ToValue::to_value(&v)
2462 }
2463}
2464
2465#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2466#[non_exhaustive]
2467#[doc(alias = "PangoTabAlign")]
2468pub enum TabAlign {
2469 #[doc(alias = "PANGO_TAB_LEFT")]
2470 Left,
2471 #[cfg(feature = "v1_50")]
2472 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2473 #[doc(alias = "PANGO_TAB_RIGHT")]
2474 Right,
2475 #[cfg(feature = "v1_50")]
2476 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2477 #[doc(alias = "PANGO_TAB_CENTER")]
2478 Center,
2479 #[cfg(feature = "v1_50")]
2480 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2481 #[doc(alias = "PANGO_TAB_DECIMAL")]
2482 Decimal,
2483 #[doc(hidden)]
2484 __Unknown(i32),
2485}
2486
2487#[doc(hidden)]
2488impl IntoGlib for TabAlign {
2489 type GlibType = ffi::PangoTabAlign;
2490
2491 #[inline]
2492 fn into_glib(self) -> ffi::PangoTabAlign {
2493 match self {
2494 Self::Left => ffi::PANGO_TAB_LEFT,
2495 #[cfg(feature = "v1_50")]
2496 Self::Right => ffi::PANGO_TAB_RIGHT,
2497 #[cfg(feature = "v1_50")]
2498 Self::Center => ffi::PANGO_TAB_CENTER,
2499 #[cfg(feature = "v1_50")]
2500 Self::Decimal => ffi::PANGO_TAB_DECIMAL,
2501 Self::__Unknown(value) => value,
2502 }
2503 }
2504}
2505
2506#[doc(hidden)]
2507impl FromGlib<ffi::PangoTabAlign> for TabAlign {
2508 #[inline]
2509 unsafe fn from_glib(value: ffi::PangoTabAlign) -> Self {
2510 match value {
2511 ffi::PANGO_TAB_LEFT => Self::Left,
2512 #[cfg(feature = "v1_50")]
2513 ffi::PANGO_TAB_RIGHT => Self::Right,
2514 #[cfg(feature = "v1_50")]
2515 ffi::PANGO_TAB_CENTER => Self::Center,
2516 #[cfg(feature = "v1_50")]
2517 ffi::PANGO_TAB_DECIMAL => Self::Decimal,
2518 value => Self::__Unknown(value),
2519 }
2520 }
2521}
2522
2523impl StaticType for TabAlign {
2524 #[inline]
2525 #[doc(alias = "pango_tab_align_get_type")]
2526 fn static_type() -> glib::Type {
2527 unsafe { from_glib(ffi::pango_tab_align_get_type()) }
2528 }
2529}
2530
2531impl glib::HasParamSpec for TabAlign {
2532 type ParamSpec = glib::ParamSpecEnum;
2533 type SetValue = Self;
2534 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2535
2536 fn param_spec_builder() -> Self::BuilderFn {
2537 Self::ParamSpec::builder_with_default
2538 }
2539}
2540
2541impl glib::value::ValueType for TabAlign {
2542 type Type = Self;
2543}
2544
2545unsafe impl<'a> glib::value::FromValue<'a> for TabAlign {
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
2554impl ToValue for TabAlign {
2555 #[inline]
2556 fn to_value(&self) -> glib::Value {
2557 let mut value = glib::Value::for_value_type::<Self>();
2558 unsafe {
2559 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2560 }
2561 value
2562 }
2563
2564 #[inline]
2565 fn value_type(&self) -> glib::Type {
2566 Self::static_type()
2567 }
2568}
2569
2570impl From<TabAlign> for glib::Value {
2571 #[inline]
2572 fn from(v: TabAlign) -> Self {
2573 ToValue::to_value(&v)
2574 }
2575}
2576
2577#[cfg(feature = "v1_50")]
2578#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2579#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2580#[non_exhaustive]
2581#[doc(alias = "PangoTextTransform")]
2582pub enum TextTransform {
2583 #[doc(alias = "PANGO_TEXT_TRANSFORM_NONE")]
2584 None,
2585 #[doc(alias = "PANGO_TEXT_TRANSFORM_LOWERCASE")]
2586 Lowercase,
2587 #[doc(alias = "PANGO_TEXT_TRANSFORM_UPPERCASE")]
2588 Uppercase,
2589 #[doc(alias = "PANGO_TEXT_TRANSFORM_CAPITALIZE")]
2590 Capitalize,
2591 #[doc(hidden)]
2592 __Unknown(i32),
2593}
2594
2595#[cfg(feature = "v1_50")]
2596#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2597#[doc(hidden)]
2598impl IntoGlib for TextTransform {
2599 type GlibType = ffi::PangoTextTransform;
2600
2601 #[inline]
2602 fn into_glib(self) -> ffi::PangoTextTransform {
2603 match self {
2604 Self::None => ffi::PANGO_TEXT_TRANSFORM_NONE,
2605 Self::Lowercase => ffi::PANGO_TEXT_TRANSFORM_LOWERCASE,
2606 Self::Uppercase => ffi::PANGO_TEXT_TRANSFORM_UPPERCASE,
2607 Self::Capitalize => ffi::PANGO_TEXT_TRANSFORM_CAPITALIZE,
2608 Self::__Unknown(value) => value,
2609 }
2610 }
2611}
2612
2613#[cfg(feature = "v1_50")]
2614#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2615#[doc(hidden)]
2616impl FromGlib<ffi::PangoTextTransform> for TextTransform {
2617 #[inline]
2618 unsafe fn from_glib(value: ffi::PangoTextTransform) -> Self {
2619 match value {
2620 ffi::PANGO_TEXT_TRANSFORM_NONE => Self::None,
2621 ffi::PANGO_TEXT_TRANSFORM_LOWERCASE => Self::Lowercase,
2622 ffi::PANGO_TEXT_TRANSFORM_UPPERCASE => Self::Uppercase,
2623 ffi::PANGO_TEXT_TRANSFORM_CAPITALIZE => Self::Capitalize,
2624 value => Self::__Unknown(value),
2625 }
2626 }
2627}
2628
2629#[cfg(feature = "v1_50")]
2630#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2631impl StaticType for TextTransform {
2632 #[inline]
2633 #[doc(alias = "pango_text_transform_get_type")]
2634 fn static_type() -> glib::Type {
2635 unsafe { from_glib(ffi::pango_text_transform_get_type()) }
2636 }
2637}
2638
2639#[cfg(feature = "v1_50")]
2640#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2641impl glib::HasParamSpec for TextTransform {
2642 type ParamSpec = glib::ParamSpecEnum;
2643 type SetValue = Self;
2644 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2645
2646 fn param_spec_builder() -> Self::BuilderFn {
2647 Self::ParamSpec::builder_with_default
2648 }
2649}
2650
2651#[cfg(feature = "v1_50")]
2652#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2653impl glib::value::ValueType for TextTransform {
2654 type Type = Self;
2655}
2656
2657#[cfg(feature = "v1_50")]
2658#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2659unsafe impl<'a> glib::value::FromValue<'a> for TextTransform {
2660 type Checker = glib::value::GenericValueTypeChecker<Self>;
2661
2662 #[inline]
2663 unsafe fn from_value(value: &'a glib::Value) -> Self {
2664 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2665 }
2666}
2667
2668#[cfg(feature = "v1_50")]
2669#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2670impl ToValue for TextTransform {
2671 #[inline]
2672 fn to_value(&self) -> glib::Value {
2673 let mut value = glib::Value::for_value_type::<Self>();
2674 unsafe {
2675 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2676 }
2677 value
2678 }
2679
2680 #[inline]
2681 fn value_type(&self) -> glib::Type {
2682 Self::static_type()
2683 }
2684}
2685
2686#[cfg(feature = "v1_50")]
2687#[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2688impl From<TextTransform> for glib::Value {
2689 #[inline]
2690 fn from(v: TextTransform) -> Self {
2691 ToValue::to_value(&v)
2692 }
2693}
2694
2695#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2696#[non_exhaustive]
2697#[doc(alias = "PangoUnderline")]
2698pub enum Underline {
2699 #[doc(alias = "PANGO_UNDERLINE_NONE")]
2700 None,
2701 #[doc(alias = "PANGO_UNDERLINE_SINGLE")]
2702 Single,
2703 #[doc(alias = "PANGO_UNDERLINE_DOUBLE")]
2704 Double,
2705 #[doc(alias = "PANGO_UNDERLINE_LOW")]
2706 Low,
2707 #[doc(alias = "PANGO_UNDERLINE_ERROR")]
2708 Error,
2709 #[doc(alias = "PANGO_UNDERLINE_SINGLE_LINE")]
2710 SingleLine,
2711 #[doc(alias = "PANGO_UNDERLINE_DOUBLE_LINE")]
2712 DoubleLine,
2713 #[doc(alias = "PANGO_UNDERLINE_ERROR_LINE")]
2714 ErrorLine,
2715 #[doc(hidden)]
2716 __Unknown(i32),
2717}
2718
2719#[doc(hidden)]
2720impl IntoGlib for Underline {
2721 type GlibType = ffi::PangoUnderline;
2722
2723 #[inline]
2724 fn into_glib(self) -> ffi::PangoUnderline {
2725 match self {
2726 Self::None => ffi::PANGO_UNDERLINE_NONE,
2727 Self::Single => ffi::PANGO_UNDERLINE_SINGLE,
2728 Self::Double => ffi::PANGO_UNDERLINE_DOUBLE,
2729 Self::Low => ffi::PANGO_UNDERLINE_LOW,
2730 Self::Error => ffi::PANGO_UNDERLINE_ERROR,
2731 Self::SingleLine => ffi::PANGO_UNDERLINE_SINGLE_LINE,
2732 Self::DoubleLine => ffi::PANGO_UNDERLINE_DOUBLE_LINE,
2733 Self::ErrorLine => ffi::PANGO_UNDERLINE_ERROR_LINE,
2734 Self::__Unknown(value) => value,
2735 }
2736 }
2737}
2738
2739#[doc(hidden)]
2740impl FromGlib<ffi::PangoUnderline> for Underline {
2741 #[inline]
2742 unsafe fn from_glib(value: ffi::PangoUnderline) -> Self {
2743 match value {
2744 ffi::PANGO_UNDERLINE_NONE => Self::None,
2745 ffi::PANGO_UNDERLINE_SINGLE => Self::Single,
2746 ffi::PANGO_UNDERLINE_DOUBLE => Self::Double,
2747 ffi::PANGO_UNDERLINE_LOW => Self::Low,
2748 ffi::PANGO_UNDERLINE_ERROR => Self::Error,
2749 ffi::PANGO_UNDERLINE_SINGLE_LINE => Self::SingleLine,
2750 ffi::PANGO_UNDERLINE_DOUBLE_LINE => Self::DoubleLine,
2751 ffi::PANGO_UNDERLINE_ERROR_LINE => Self::ErrorLine,
2752 value => Self::__Unknown(value),
2753 }
2754 }
2755}
2756
2757impl StaticType for Underline {
2758 #[inline]
2759 #[doc(alias = "pango_underline_get_type")]
2760 fn static_type() -> glib::Type {
2761 unsafe { from_glib(ffi::pango_underline_get_type()) }
2762 }
2763}
2764
2765impl glib::HasParamSpec for Underline {
2766 type ParamSpec = glib::ParamSpecEnum;
2767 type SetValue = Self;
2768 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2769
2770 fn param_spec_builder() -> Self::BuilderFn {
2771 Self::ParamSpec::builder_with_default
2772 }
2773}
2774
2775impl glib::value::ValueType for Underline {
2776 type Type = Self;
2777}
2778
2779unsafe impl<'a> glib::value::FromValue<'a> for Underline {
2780 type Checker = glib::value::GenericValueTypeChecker<Self>;
2781
2782 #[inline]
2783 unsafe fn from_value(value: &'a glib::Value) -> Self {
2784 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2785 }
2786}
2787
2788impl ToValue for Underline {
2789 #[inline]
2790 fn to_value(&self) -> glib::Value {
2791 let mut value = glib::Value::for_value_type::<Self>();
2792 unsafe {
2793 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2794 }
2795 value
2796 }
2797
2798 #[inline]
2799 fn value_type(&self) -> glib::Type {
2800 Self::static_type()
2801 }
2802}
2803
2804impl From<Underline> for glib::Value {
2805 #[inline]
2806 fn from(v: Underline) -> Self {
2807 ToValue::to_value(&v)
2808 }
2809}
2810
2811#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2812#[non_exhaustive]
2813#[doc(alias = "PangoVariant")]
2814pub enum Variant {
2815 #[doc(alias = "PANGO_VARIANT_NORMAL")]
2816 Normal,
2817 #[doc(alias = "PANGO_VARIANT_SMALL_CAPS")]
2818 SmallCaps,
2819 #[cfg(feature = "v1_50")]
2820 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2821 #[doc(alias = "PANGO_VARIANT_ALL_SMALL_CAPS")]
2822 AllSmallCaps,
2823 #[cfg(feature = "v1_50")]
2824 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2825 #[doc(alias = "PANGO_VARIANT_PETITE_CAPS")]
2826 PetiteCaps,
2827 #[cfg(feature = "v1_50")]
2828 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2829 #[doc(alias = "PANGO_VARIANT_ALL_PETITE_CAPS")]
2830 AllPetiteCaps,
2831 #[cfg(feature = "v1_50")]
2832 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2833 #[doc(alias = "PANGO_VARIANT_UNICASE")]
2834 Unicase,
2835 #[cfg(feature = "v1_50")]
2836 #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
2837 #[doc(alias = "PANGO_VARIANT_TITLE_CAPS")]
2838 TitleCaps,
2839 #[doc(hidden)]
2840 __Unknown(i32),
2841}
2842
2843#[doc(hidden)]
2844impl IntoGlib for Variant {
2845 type GlibType = ffi::PangoVariant;
2846
2847 #[inline]
2848 fn into_glib(self) -> ffi::PangoVariant {
2849 match self {
2850 Self::Normal => ffi::PANGO_VARIANT_NORMAL,
2851 Self::SmallCaps => ffi::PANGO_VARIANT_SMALL_CAPS,
2852 #[cfg(feature = "v1_50")]
2853 Self::AllSmallCaps => ffi::PANGO_VARIANT_ALL_SMALL_CAPS,
2854 #[cfg(feature = "v1_50")]
2855 Self::PetiteCaps => ffi::PANGO_VARIANT_PETITE_CAPS,
2856 #[cfg(feature = "v1_50")]
2857 Self::AllPetiteCaps => ffi::PANGO_VARIANT_ALL_PETITE_CAPS,
2858 #[cfg(feature = "v1_50")]
2859 Self::Unicase => ffi::PANGO_VARIANT_UNICASE,
2860 #[cfg(feature = "v1_50")]
2861 Self::TitleCaps => ffi::PANGO_VARIANT_TITLE_CAPS,
2862 Self::__Unknown(value) => value,
2863 }
2864 }
2865}
2866
2867#[doc(hidden)]
2868impl FromGlib<ffi::PangoVariant> for Variant {
2869 #[inline]
2870 unsafe fn from_glib(value: ffi::PangoVariant) -> Self {
2871 match value {
2872 ffi::PANGO_VARIANT_NORMAL => Self::Normal,
2873 ffi::PANGO_VARIANT_SMALL_CAPS => Self::SmallCaps,
2874 #[cfg(feature = "v1_50")]
2875 ffi::PANGO_VARIANT_ALL_SMALL_CAPS => Self::AllSmallCaps,
2876 #[cfg(feature = "v1_50")]
2877 ffi::PANGO_VARIANT_PETITE_CAPS => Self::PetiteCaps,
2878 #[cfg(feature = "v1_50")]
2879 ffi::PANGO_VARIANT_ALL_PETITE_CAPS => Self::AllPetiteCaps,
2880 #[cfg(feature = "v1_50")]
2881 ffi::PANGO_VARIANT_UNICASE => Self::Unicase,
2882 #[cfg(feature = "v1_50")]
2883 ffi::PANGO_VARIANT_TITLE_CAPS => Self::TitleCaps,
2884 value => Self::__Unknown(value),
2885 }
2886 }
2887}
2888
2889impl StaticType for Variant {
2890 #[inline]
2891 #[doc(alias = "pango_variant_get_type")]
2892 fn static_type() -> glib::Type {
2893 unsafe { from_glib(ffi::pango_variant_get_type()) }
2894 }
2895}
2896
2897impl glib::HasParamSpec for Variant {
2898 type ParamSpec = glib::ParamSpecEnum;
2899 type SetValue = Self;
2900 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2901
2902 fn param_spec_builder() -> Self::BuilderFn {
2903 Self::ParamSpec::builder_with_default
2904 }
2905}
2906
2907impl glib::value::ValueType for Variant {
2908 type Type = Self;
2909}
2910
2911unsafe impl<'a> glib::value::FromValue<'a> for Variant {
2912 type Checker = glib::value::GenericValueTypeChecker<Self>;
2913
2914 #[inline]
2915 unsafe fn from_value(value: &'a glib::Value) -> Self {
2916 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2917 }
2918}
2919
2920impl ToValue for Variant {
2921 #[inline]
2922 fn to_value(&self) -> glib::Value {
2923 let mut value = glib::Value::for_value_type::<Self>();
2924 unsafe {
2925 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2926 }
2927 value
2928 }
2929
2930 #[inline]
2931 fn value_type(&self) -> glib::Type {
2932 Self::static_type()
2933 }
2934}
2935
2936impl From<Variant> for glib::Value {
2937 #[inline]
2938 fn from(v: Variant) -> Self {
2939 ToValue::to_value(&v)
2940 }
2941}
2942
2943#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2944#[non_exhaustive]
2945#[doc(alias = "PangoWeight")]
2946pub enum Weight {
2947 #[doc(alias = "PANGO_WEIGHT_THIN")]
2948 Thin,
2949 #[doc(alias = "PANGO_WEIGHT_ULTRALIGHT")]
2950 Ultralight,
2951 #[doc(alias = "PANGO_WEIGHT_LIGHT")]
2952 Light,
2953 #[doc(alias = "PANGO_WEIGHT_SEMILIGHT")]
2954 Semilight,
2955 #[doc(alias = "PANGO_WEIGHT_BOOK")]
2956 Book,
2957 #[doc(alias = "PANGO_WEIGHT_NORMAL")]
2958 Normal,
2959 #[doc(alias = "PANGO_WEIGHT_MEDIUM")]
2960 Medium,
2961 #[doc(alias = "PANGO_WEIGHT_SEMIBOLD")]
2962 Semibold,
2963 #[doc(alias = "PANGO_WEIGHT_BOLD")]
2964 Bold,
2965 #[doc(alias = "PANGO_WEIGHT_ULTRABOLD")]
2966 Ultrabold,
2967 #[doc(alias = "PANGO_WEIGHT_HEAVY")]
2968 Heavy,
2969 #[doc(alias = "PANGO_WEIGHT_ULTRAHEAVY")]
2970 Ultraheavy,
2971 #[doc(hidden)]
2972 __Unknown(i32),
2973}
2974
2975#[doc(hidden)]
2976impl IntoGlib for Weight {
2977 type GlibType = ffi::PangoWeight;
2978
2979 #[inline]
2980 fn into_glib(self) -> ffi::PangoWeight {
2981 match self {
2982 Self::Thin => ffi::PANGO_WEIGHT_THIN,
2983 Self::Ultralight => ffi::PANGO_WEIGHT_ULTRALIGHT,
2984 Self::Light => ffi::PANGO_WEIGHT_LIGHT,
2985 Self::Semilight => ffi::PANGO_WEIGHT_SEMILIGHT,
2986 Self::Book => ffi::PANGO_WEIGHT_BOOK,
2987 Self::Normal => ffi::PANGO_WEIGHT_NORMAL,
2988 Self::Medium => ffi::PANGO_WEIGHT_MEDIUM,
2989 Self::Semibold => ffi::PANGO_WEIGHT_SEMIBOLD,
2990 Self::Bold => ffi::PANGO_WEIGHT_BOLD,
2991 Self::Ultrabold => ffi::PANGO_WEIGHT_ULTRABOLD,
2992 Self::Heavy => ffi::PANGO_WEIGHT_HEAVY,
2993 Self::Ultraheavy => ffi::PANGO_WEIGHT_ULTRAHEAVY,
2994 Self::__Unknown(value) => value,
2995 }
2996 }
2997}
2998
2999#[doc(hidden)]
3000impl FromGlib<ffi::PangoWeight> for Weight {
3001 #[inline]
3002 unsafe fn from_glib(value: ffi::PangoWeight) -> Self {
3003 match value {
3004 ffi::PANGO_WEIGHT_THIN => Self::Thin,
3005 ffi::PANGO_WEIGHT_ULTRALIGHT => Self::Ultralight,
3006 ffi::PANGO_WEIGHT_LIGHT => Self::Light,
3007 ffi::PANGO_WEIGHT_SEMILIGHT => Self::Semilight,
3008 ffi::PANGO_WEIGHT_BOOK => Self::Book,
3009 ffi::PANGO_WEIGHT_NORMAL => Self::Normal,
3010 ffi::PANGO_WEIGHT_MEDIUM => Self::Medium,
3011 ffi::PANGO_WEIGHT_SEMIBOLD => Self::Semibold,
3012 ffi::PANGO_WEIGHT_BOLD => Self::Bold,
3013 ffi::PANGO_WEIGHT_ULTRABOLD => Self::Ultrabold,
3014 ffi::PANGO_WEIGHT_HEAVY => Self::Heavy,
3015 ffi::PANGO_WEIGHT_ULTRAHEAVY => Self::Ultraheavy,
3016 value => Self::__Unknown(value),
3017 }
3018 }
3019}
3020
3021impl StaticType for Weight {
3022 #[inline]
3023 #[doc(alias = "pango_weight_get_type")]
3024 fn static_type() -> glib::Type {
3025 unsafe { from_glib(ffi::pango_weight_get_type()) }
3026 }
3027}
3028
3029impl glib::HasParamSpec for Weight {
3030 type ParamSpec = glib::ParamSpecEnum;
3031 type SetValue = Self;
3032 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3033
3034 fn param_spec_builder() -> Self::BuilderFn {
3035 Self::ParamSpec::builder_with_default
3036 }
3037}
3038
3039impl glib::value::ValueType for Weight {
3040 type Type = Self;
3041}
3042
3043unsafe impl<'a> glib::value::FromValue<'a> for Weight {
3044 type Checker = glib::value::GenericValueTypeChecker<Self>;
3045
3046 #[inline]
3047 unsafe fn from_value(value: &'a glib::Value) -> Self {
3048 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3049 }
3050}
3051
3052impl ToValue for Weight {
3053 #[inline]
3054 fn to_value(&self) -> glib::Value {
3055 let mut value = glib::Value::for_value_type::<Self>();
3056 unsafe {
3057 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3058 }
3059 value
3060 }
3061
3062 #[inline]
3063 fn value_type(&self) -> glib::Type {
3064 Self::static_type()
3065 }
3066}
3067
3068impl From<Weight> for glib::Value {
3069 #[inline]
3070 fn from(v: Weight) -> Self {
3071 ToValue::to_value(&v)
3072 }
3073}
3074
3075#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3076#[non_exhaustive]
3077#[doc(alias = "PangoWrapMode")]
3078pub enum WrapMode {
3079 #[doc(alias = "PANGO_WRAP_WORD")]
3080 Word,
3081 #[doc(alias = "PANGO_WRAP_CHAR")]
3082 Char,
3083 #[doc(alias = "PANGO_WRAP_WORD_CHAR")]
3084 WordChar,
3085 #[cfg(feature = "v1_56")]
3086 #[cfg_attr(docsrs, doc(cfg(feature = "v1_56")))]
3087 #[doc(alias = "PANGO_WRAP_NONE")]
3088 None,
3089 #[doc(hidden)]
3090 __Unknown(i32),
3091}
3092
3093#[doc(hidden)]
3094impl IntoGlib for WrapMode {
3095 type GlibType = ffi::PangoWrapMode;
3096
3097 #[inline]
3098 fn into_glib(self) -> ffi::PangoWrapMode {
3099 match self {
3100 Self::Word => ffi::PANGO_WRAP_WORD,
3101 Self::Char => ffi::PANGO_WRAP_CHAR,
3102 Self::WordChar => ffi::PANGO_WRAP_WORD_CHAR,
3103 #[cfg(feature = "v1_56")]
3104 Self::None => ffi::PANGO_WRAP_NONE,
3105 Self::__Unknown(value) => value,
3106 }
3107 }
3108}
3109
3110#[doc(hidden)]
3111impl FromGlib<ffi::PangoWrapMode> for WrapMode {
3112 #[inline]
3113 unsafe fn from_glib(value: ffi::PangoWrapMode) -> Self {
3114 match value {
3115 ffi::PANGO_WRAP_WORD => Self::Word,
3116 ffi::PANGO_WRAP_CHAR => Self::Char,
3117 ffi::PANGO_WRAP_WORD_CHAR => Self::WordChar,
3118 #[cfg(feature = "v1_56")]
3119 ffi::PANGO_WRAP_NONE => Self::None,
3120 value => Self::__Unknown(value),
3121 }
3122 }
3123}
3124
3125impl StaticType for WrapMode {
3126 #[inline]
3127 #[doc(alias = "pango_wrap_mode_get_type")]
3128 fn static_type() -> glib::Type {
3129 unsafe { from_glib(ffi::pango_wrap_mode_get_type()) }
3130 }
3131}
3132
3133impl glib::HasParamSpec for WrapMode {
3134 type ParamSpec = glib::ParamSpecEnum;
3135 type SetValue = Self;
3136 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3137
3138 fn param_spec_builder() -> Self::BuilderFn {
3139 Self::ParamSpec::builder_with_default
3140 }
3141}
3142
3143impl glib::value::ValueType for WrapMode {
3144 type Type = Self;
3145}
3146
3147unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
3148 type Checker = glib::value::GenericValueTypeChecker<Self>;
3149
3150 #[inline]
3151 unsafe fn from_value(value: &'a glib::Value) -> Self {
3152 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3153 }
3154}
3155
3156impl ToValue for WrapMode {
3157 #[inline]
3158 fn to_value(&self) -> glib::Value {
3159 let mut value = glib::Value::for_value_type::<Self>();
3160 unsafe {
3161 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3162 }
3163 value
3164 }
3165
3166 #[inline]
3167 fn value_type(&self) -> glib::Type {
3168 Self::static_type()
3169 }
3170}
3171
3172impl From<WrapMode> for glib::Value {
3173 #[inline]
3174 fn from(v: WrapMode) -> Self {
3175 ToValue::to_value(&v)
3176 }
3177}