1use glib::{prelude::*, translate::*};
7use std::fmt;
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "HdyCenteringPolicy")]
12pub enum CenteringPolicy {
13 #[doc(alias = "HDY_CENTERING_POLICY_LOOSE")]
14 Loose,
15 #[doc(alias = "HDY_CENTERING_POLICY_STRICT")]
16 Strict,
17 #[doc(hidden)]
18 __Unknown(i32),
19}
20
21impl fmt::Display for CenteringPolicy {
22 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
23 write!(
24 f,
25 "CenteringPolicy::{}",
26 match *self {
27 Self::Loose => "Loose",
28 Self::Strict => "Strict",
29 _ => "Unknown",
30 }
31 )
32 }
33}
34
35#[doc(hidden)]
36impl IntoGlib for CenteringPolicy {
37 type GlibType = ffi::HdyCenteringPolicy;
38
39 #[inline]
40 fn into_glib(self) -> ffi::HdyCenteringPolicy {
41 match self {
42 Self::Loose => ffi::HDY_CENTERING_POLICY_LOOSE,
43 Self::Strict => ffi::HDY_CENTERING_POLICY_STRICT,
44 Self::__Unknown(value) => value,
45 }
46 }
47}
48
49#[doc(hidden)]
50impl FromGlib<ffi::HdyCenteringPolicy> for CenteringPolicy {
51 #[inline]
52 unsafe fn from_glib(value: ffi::HdyCenteringPolicy) -> Self {
53 skip_assert_initialized!();
54
55 match value {
56 ffi::HDY_CENTERING_POLICY_LOOSE => Self::Loose,
57 ffi::HDY_CENTERING_POLICY_STRICT => Self::Strict,
58 value => Self::__Unknown(value),
59 }
60 }
61}
62
63impl StaticType for CenteringPolicy {
64 #[inline]
65 #[doc(alias = "hdy_centering_policy_get_type")]
66 fn static_type() -> glib::Type {
67 unsafe { from_glib(ffi::hdy_centering_policy_get_type()) }
68 }
69}
70
71impl glib::HasParamSpec for CenteringPolicy {
72 type ParamSpec = glib::ParamSpecEnum;
73 type SetValue = Self;
74 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
75
76 fn param_spec_builder() -> Self::BuilderFn {
77 Self::ParamSpec::builder_with_default
78 }
79}
80
81impl glib::value::ValueType for CenteringPolicy {
82 type Type = Self;
83}
84
85unsafe impl<'a> glib::value::FromValue<'a> for CenteringPolicy {
86 type Checker = glib::value::GenericValueTypeChecker<Self>;
87
88 #[inline]
89 unsafe fn from_value(value: &'a glib::Value) -> Self {
90 skip_assert_initialized!();
91 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
92 }
93}
94
95impl ToValue for CenteringPolicy {
96 #[inline]
97 fn to_value(&self) -> glib::Value {
98 let mut value = glib::Value::for_value_type::<Self>();
99 unsafe {
100 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
101 }
102 value
103 }
104
105 #[inline]
106 fn value_type(&self) -> glib::Type {
107 Self::static_type()
108 }
109}
110
111impl From<CenteringPolicy> for glib::Value {
112 #[inline]
113 fn from(v: CenteringPolicy) -> Self {
114 skip_assert_initialized!();
115 ToValue::to_value(&v)
116 }
117}
118
119#[cfg(feature = "v1_6")]
120#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
121#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
122#[non_exhaustive]
123#[doc(alias = "HdyColorScheme")]
124pub enum ColorScheme {
125 #[doc(alias = "HDY_COLOR_SCHEME_DEFAULT")]
126 Default,
127 #[doc(alias = "HDY_COLOR_SCHEME_FORCE_LIGHT")]
128 ForceLight,
129 #[doc(alias = "HDY_COLOR_SCHEME_PREFER_LIGHT")]
130 PreferLight,
131 #[doc(alias = "HDY_COLOR_SCHEME_PREFER_DARK")]
132 PreferDark,
133 #[doc(alias = "HDY_COLOR_SCHEME_FORCE_DARK")]
134 ForceDark,
135 #[doc(hidden)]
136 __Unknown(i32),
137}
138
139#[cfg(feature = "v1_6")]
140#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
141impl fmt::Display for ColorScheme {
142 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
143 write!(
144 f,
145 "ColorScheme::{}",
146 match *self {
147 Self::Default => "Default",
148 Self::ForceLight => "ForceLight",
149 Self::PreferLight => "PreferLight",
150 Self::PreferDark => "PreferDark",
151 Self::ForceDark => "ForceDark",
152 _ => "Unknown",
153 }
154 )
155 }
156}
157
158#[cfg(feature = "v1_6")]
159#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
160#[doc(hidden)]
161impl IntoGlib for ColorScheme {
162 type GlibType = ffi::HdyColorScheme;
163
164 #[inline]
165 fn into_glib(self) -> ffi::HdyColorScheme {
166 match self {
167 Self::Default => ffi::HDY_COLOR_SCHEME_DEFAULT,
168 Self::ForceLight => ffi::HDY_COLOR_SCHEME_FORCE_LIGHT,
169 Self::PreferLight => ffi::HDY_COLOR_SCHEME_PREFER_LIGHT,
170 Self::PreferDark => ffi::HDY_COLOR_SCHEME_PREFER_DARK,
171 Self::ForceDark => ffi::HDY_COLOR_SCHEME_FORCE_DARK,
172 Self::__Unknown(value) => value,
173 }
174 }
175}
176
177#[cfg(feature = "v1_6")]
178#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
179#[doc(hidden)]
180impl FromGlib<ffi::HdyColorScheme> for ColorScheme {
181 #[inline]
182 unsafe fn from_glib(value: ffi::HdyColorScheme) -> Self {
183 skip_assert_initialized!();
184
185 match value {
186 ffi::HDY_COLOR_SCHEME_DEFAULT => Self::Default,
187 ffi::HDY_COLOR_SCHEME_FORCE_LIGHT => Self::ForceLight,
188 ffi::HDY_COLOR_SCHEME_PREFER_LIGHT => Self::PreferLight,
189 ffi::HDY_COLOR_SCHEME_PREFER_DARK => Self::PreferDark,
190 ffi::HDY_COLOR_SCHEME_FORCE_DARK => Self::ForceDark,
191 value => Self::__Unknown(value),
192 }
193 }
194}
195
196#[cfg(feature = "v1_6")]
197#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
198impl StaticType for ColorScheme {
199 #[inline]
200 #[doc(alias = "hdy_color_scheme_get_type")]
201 fn static_type() -> glib::Type {
202 unsafe { from_glib(ffi::hdy_color_scheme_get_type()) }
203 }
204}
205
206#[cfg(feature = "v1_6")]
207#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
208impl glib::HasParamSpec for ColorScheme {
209 type ParamSpec = glib::ParamSpecEnum;
210 type SetValue = Self;
211 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
212
213 fn param_spec_builder() -> Self::BuilderFn {
214 Self::ParamSpec::builder_with_default
215 }
216}
217
218#[cfg(feature = "v1_6")]
219#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
220impl glib::value::ValueType for ColorScheme {
221 type Type = Self;
222}
223
224#[cfg(feature = "v1_6")]
225#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
226unsafe impl<'a> glib::value::FromValue<'a> for ColorScheme {
227 type Checker = glib::value::GenericValueTypeChecker<Self>;
228
229 #[inline]
230 unsafe fn from_value(value: &'a glib::Value) -> Self {
231 skip_assert_initialized!();
232 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
233 }
234}
235
236#[cfg(feature = "v1_6")]
237#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
238impl ToValue for ColorScheme {
239 #[inline]
240 fn to_value(&self) -> glib::Value {
241 let mut value = glib::Value::for_value_type::<Self>();
242 unsafe {
243 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
244 }
245 value
246 }
247
248 #[inline]
249 fn value_type(&self) -> glib::Type {
250 Self::static_type()
251 }
252}
253
254#[cfg(feature = "v1_6")]
255#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
256impl From<ColorScheme> for glib::Value {
257 #[inline]
258 fn from(v: ColorScheme) -> Self {
259 skip_assert_initialized!();
260 ToValue::to_value(&v)
261 }
262}
263
264#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
265#[non_exhaustive]
266#[doc(alias = "HdyDeckTransitionType")]
267pub enum DeckTransitionType {
268 #[doc(alias = "HDY_DECK_TRANSITION_TYPE_OVER")]
269 Over,
270 #[doc(alias = "HDY_DECK_TRANSITION_TYPE_UNDER")]
271 Under,
272 #[doc(alias = "HDY_DECK_TRANSITION_TYPE_SLIDE")]
273 Slide,
274 #[doc(hidden)]
275 __Unknown(i32),
276}
277
278impl fmt::Display for DeckTransitionType {
279 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
280 write!(
281 f,
282 "DeckTransitionType::{}",
283 match *self {
284 Self::Over => "Over",
285 Self::Under => "Under",
286 Self::Slide => "Slide",
287 _ => "Unknown",
288 }
289 )
290 }
291}
292
293#[doc(hidden)]
294impl IntoGlib for DeckTransitionType {
295 type GlibType = ffi::HdyDeckTransitionType;
296
297 #[inline]
298 fn into_glib(self) -> ffi::HdyDeckTransitionType {
299 match self {
300 Self::Over => ffi::HDY_DECK_TRANSITION_TYPE_OVER,
301 Self::Under => ffi::HDY_DECK_TRANSITION_TYPE_UNDER,
302 Self::Slide => ffi::HDY_DECK_TRANSITION_TYPE_SLIDE,
303 Self::__Unknown(value) => value,
304 }
305 }
306}
307
308#[doc(hidden)]
309impl FromGlib<ffi::HdyDeckTransitionType> for DeckTransitionType {
310 #[inline]
311 unsafe fn from_glib(value: ffi::HdyDeckTransitionType) -> Self {
312 skip_assert_initialized!();
313
314 match value {
315 ffi::HDY_DECK_TRANSITION_TYPE_OVER => Self::Over,
316 ffi::HDY_DECK_TRANSITION_TYPE_UNDER => Self::Under,
317 ffi::HDY_DECK_TRANSITION_TYPE_SLIDE => Self::Slide,
318 value => Self::__Unknown(value),
319 }
320 }
321}
322
323impl StaticType for DeckTransitionType {
324 #[inline]
325 #[doc(alias = "hdy_deck_transition_type_get_type")]
326 fn static_type() -> glib::Type {
327 unsafe { from_glib(ffi::hdy_deck_transition_type_get_type()) }
328 }
329}
330
331impl glib::HasParamSpec for DeckTransitionType {
332 type ParamSpec = glib::ParamSpecEnum;
333 type SetValue = Self;
334 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
335
336 fn param_spec_builder() -> Self::BuilderFn {
337 Self::ParamSpec::builder_with_default
338 }
339}
340
341impl glib::value::ValueType for DeckTransitionType {
342 type Type = Self;
343}
344
345unsafe impl<'a> glib::value::FromValue<'a> for DeckTransitionType {
346 type Checker = glib::value::GenericValueTypeChecker<Self>;
347
348 #[inline]
349 unsafe fn from_value(value: &'a glib::Value) -> Self {
350 skip_assert_initialized!();
351 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
352 }
353}
354
355impl ToValue for DeckTransitionType {
356 #[inline]
357 fn to_value(&self) -> glib::Value {
358 let mut value = glib::Value::for_value_type::<Self>();
359 unsafe {
360 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
361 }
362 value
363 }
364
365 #[inline]
366 fn value_type(&self) -> glib::Type {
367 Self::static_type()
368 }
369}
370
371impl From<DeckTransitionType> for glib::Value {
372 #[inline]
373 fn from(v: DeckTransitionType) -> Self {
374 skip_assert_initialized!();
375 ToValue::to_value(&v)
376 }
377}
378
379#[cfg(feature = "v1_2")]
380#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
381#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
382#[non_exhaustive]
383#[doc(alias = "HdyFlapFoldPolicy")]
384pub enum FlapFoldPolicy {
385 #[doc(alias = "HDY_FLAP_FOLD_POLICY_NEVER")]
386 Never,
387 #[doc(alias = "HDY_FLAP_FOLD_POLICY_ALWAYS")]
388 Always,
389 #[doc(alias = "HDY_FLAP_FOLD_POLICY_AUTO")]
390 Auto,
391 #[doc(hidden)]
392 __Unknown(i32),
393}
394
395#[cfg(feature = "v1_2")]
396#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
397impl fmt::Display for FlapFoldPolicy {
398 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
399 write!(
400 f,
401 "FlapFoldPolicy::{}",
402 match *self {
403 Self::Never => "Never",
404 Self::Always => "Always",
405 Self::Auto => "Auto",
406 _ => "Unknown",
407 }
408 )
409 }
410}
411
412#[cfg(feature = "v1_2")]
413#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
414#[doc(hidden)]
415impl IntoGlib for FlapFoldPolicy {
416 type GlibType = ffi::HdyFlapFoldPolicy;
417
418 #[inline]
419 fn into_glib(self) -> ffi::HdyFlapFoldPolicy {
420 match self {
421 Self::Never => ffi::HDY_FLAP_FOLD_POLICY_NEVER,
422 Self::Always => ffi::HDY_FLAP_FOLD_POLICY_ALWAYS,
423 Self::Auto => ffi::HDY_FLAP_FOLD_POLICY_AUTO,
424 Self::__Unknown(value) => value,
425 }
426 }
427}
428
429#[cfg(feature = "v1_2")]
430#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
431#[doc(hidden)]
432impl FromGlib<ffi::HdyFlapFoldPolicy> for FlapFoldPolicy {
433 #[inline]
434 unsafe fn from_glib(value: ffi::HdyFlapFoldPolicy) -> Self {
435 skip_assert_initialized!();
436
437 match value {
438 ffi::HDY_FLAP_FOLD_POLICY_NEVER => Self::Never,
439 ffi::HDY_FLAP_FOLD_POLICY_ALWAYS => Self::Always,
440 ffi::HDY_FLAP_FOLD_POLICY_AUTO => Self::Auto,
441 value => Self::__Unknown(value),
442 }
443 }
444}
445
446#[cfg(feature = "v1_2")]
447#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
448impl StaticType for FlapFoldPolicy {
449 #[inline]
450 #[doc(alias = "hdy_flap_fold_policy_get_type")]
451 fn static_type() -> glib::Type {
452 unsafe { from_glib(ffi::hdy_flap_fold_policy_get_type()) }
453 }
454}
455
456#[cfg(feature = "v1_2")]
457#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
458impl glib::HasParamSpec for FlapFoldPolicy {
459 type ParamSpec = glib::ParamSpecEnum;
460 type SetValue = Self;
461 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
462
463 fn param_spec_builder() -> Self::BuilderFn {
464 Self::ParamSpec::builder_with_default
465 }
466}
467
468#[cfg(feature = "v1_2")]
469#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
470impl glib::value::ValueType for FlapFoldPolicy {
471 type Type = Self;
472}
473
474#[cfg(feature = "v1_2")]
475#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
476unsafe impl<'a> glib::value::FromValue<'a> for FlapFoldPolicy {
477 type Checker = glib::value::GenericValueTypeChecker<Self>;
478
479 #[inline]
480 unsafe fn from_value(value: &'a glib::Value) -> Self {
481 skip_assert_initialized!();
482 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
483 }
484}
485
486#[cfg(feature = "v1_2")]
487#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
488impl ToValue for FlapFoldPolicy {
489 #[inline]
490 fn to_value(&self) -> glib::Value {
491 let mut value = glib::Value::for_value_type::<Self>();
492 unsafe {
493 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
494 }
495 value
496 }
497
498 #[inline]
499 fn value_type(&self) -> glib::Type {
500 Self::static_type()
501 }
502}
503
504#[cfg(feature = "v1_2")]
505#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
506impl From<FlapFoldPolicy> for glib::Value {
507 #[inline]
508 fn from(v: FlapFoldPolicy) -> Self {
509 skip_assert_initialized!();
510 ToValue::to_value(&v)
511 }
512}
513
514#[cfg(feature = "v1_2")]
515#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
516#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
517#[non_exhaustive]
518#[doc(alias = "HdyFlapTransitionType")]
519pub enum FlapTransitionType {
520 #[doc(alias = "HDY_FLAP_TRANSITION_TYPE_OVER")]
521 Over,
522 #[doc(alias = "HDY_FLAP_TRANSITION_TYPE_UNDER")]
523 Under,
524 #[doc(alias = "HDY_FLAP_TRANSITION_TYPE_SLIDE")]
525 Slide,
526 #[doc(hidden)]
527 __Unknown(i32),
528}
529
530#[cfg(feature = "v1_2")]
531#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
532impl fmt::Display for FlapTransitionType {
533 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
534 write!(
535 f,
536 "FlapTransitionType::{}",
537 match *self {
538 Self::Over => "Over",
539 Self::Under => "Under",
540 Self::Slide => "Slide",
541 _ => "Unknown",
542 }
543 )
544 }
545}
546
547#[cfg(feature = "v1_2")]
548#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
549#[doc(hidden)]
550impl IntoGlib for FlapTransitionType {
551 type GlibType = ffi::HdyFlapTransitionType;
552
553 #[inline]
554 fn into_glib(self) -> ffi::HdyFlapTransitionType {
555 match self {
556 Self::Over => ffi::HDY_FLAP_TRANSITION_TYPE_OVER,
557 Self::Under => ffi::HDY_FLAP_TRANSITION_TYPE_UNDER,
558 Self::Slide => ffi::HDY_FLAP_TRANSITION_TYPE_SLIDE,
559 Self::__Unknown(value) => value,
560 }
561 }
562}
563
564#[cfg(feature = "v1_2")]
565#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
566#[doc(hidden)]
567impl FromGlib<ffi::HdyFlapTransitionType> for FlapTransitionType {
568 #[inline]
569 unsafe fn from_glib(value: ffi::HdyFlapTransitionType) -> Self {
570 skip_assert_initialized!();
571
572 match value {
573 ffi::HDY_FLAP_TRANSITION_TYPE_OVER => Self::Over,
574 ffi::HDY_FLAP_TRANSITION_TYPE_UNDER => Self::Under,
575 ffi::HDY_FLAP_TRANSITION_TYPE_SLIDE => Self::Slide,
576 value => Self::__Unknown(value),
577 }
578 }
579}
580
581#[cfg(feature = "v1_2")]
582#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
583impl StaticType for FlapTransitionType {
584 #[inline]
585 #[doc(alias = "hdy_flap_transition_type_get_type")]
586 fn static_type() -> glib::Type {
587 unsafe { from_glib(ffi::hdy_flap_transition_type_get_type()) }
588 }
589}
590
591#[cfg(feature = "v1_2")]
592#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
593impl glib::HasParamSpec for FlapTransitionType {
594 type ParamSpec = glib::ParamSpecEnum;
595 type SetValue = Self;
596 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
597
598 fn param_spec_builder() -> Self::BuilderFn {
599 Self::ParamSpec::builder_with_default
600 }
601}
602
603#[cfg(feature = "v1_2")]
604#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
605impl glib::value::ValueType for FlapTransitionType {
606 type Type = Self;
607}
608
609#[cfg(feature = "v1_2")]
610#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
611unsafe impl<'a> glib::value::FromValue<'a> for FlapTransitionType {
612 type Checker = glib::value::GenericValueTypeChecker<Self>;
613
614 #[inline]
615 unsafe fn from_value(value: &'a glib::Value) -> Self {
616 skip_assert_initialized!();
617 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
618 }
619}
620
621#[cfg(feature = "v1_2")]
622#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
623impl ToValue for FlapTransitionType {
624 #[inline]
625 fn to_value(&self) -> glib::Value {
626 let mut value = glib::Value::for_value_type::<Self>();
627 unsafe {
628 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
629 }
630 value
631 }
632
633 #[inline]
634 fn value_type(&self) -> glib::Type {
635 Self::static_type()
636 }
637}
638
639#[cfg(feature = "v1_2")]
640#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
641impl From<FlapTransitionType> for glib::Value {
642 #[inline]
643 fn from(v: FlapTransitionType) -> Self {
644 skip_assert_initialized!();
645 ToValue::to_value(&v)
646 }
647}
648
649#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
650#[non_exhaustive]
651#[doc(alias = "HdyHeaderGroupChildType")]
652pub enum HeaderGroupChildType {
653 #[doc(alias = "HDY_HEADER_GROUP_CHILD_TYPE_HEADER_BAR")]
654 HeaderBar,
655 #[doc(alias = "HDY_HEADER_GROUP_CHILD_TYPE_GTK_HEADER_BAR")]
656 GtkHeaderBar,
657 #[doc(alias = "HDY_HEADER_GROUP_CHILD_TYPE_HEADER_GROUP")]
658 HeaderGroup,
659 #[doc(hidden)]
660 __Unknown(i32),
661}
662
663impl fmt::Display for HeaderGroupChildType {
664 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
665 write!(
666 f,
667 "HeaderGroupChildType::{}",
668 match *self {
669 Self::HeaderBar => "HeaderBar",
670 Self::GtkHeaderBar => "GtkHeaderBar",
671 Self::HeaderGroup => "HeaderGroup",
672 _ => "Unknown",
673 }
674 )
675 }
676}
677
678#[doc(hidden)]
679impl IntoGlib for HeaderGroupChildType {
680 type GlibType = ffi::HdyHeaderGroupChildType;
681
682 #[inline]
683 fn into_glib(self) -> ffi::HdyHeaderGroupChildType {
684 match self {
685 Self::HeaderBar => ffi::HDY_HEADER_GROUP_CHILD_TYPE_HEADER_BAR,
686 Self::GtkHeaderBar => ffi::HDY_HEADER_GROUP_CHILD_TYPE_GTK_HEADER_BAR,
687 Self::HeaderGroup => ffi::HDY_HEADER_GROUP_CHILD_TYPE_HEADER_GROUP,
688 Self::__Unknown(value) => value,
689 }
690 }
691}
692
693#[doc(hidden)]
694impl FromGlib<ffi::HdyHeaderGroupChildType> for HeaderGroupChildType {
695 #[inline]
696 unsafe fn from_glib(value: ffi::HdyHeaderGroupChildType) -> Self {
697 skip_assert_initialized!();
698
699 match value {
700 ffi::HDY_HEADER_GROUP_CHILD_TYPE_HEADER_BAR => Self::HeaderBar,
701 ffi::HDY_HEADER_GROUP_CHILD_TYPE_GTK_HEADER_BAR => Self::GtkHeaderBar,
702 ffi::HDY_HEADER_GROUP_CHILD_TYPE_HEADER_GROUP => Self::HeaderGroup,
703 value => Self::__Unknown(value),
704 }
705 }
706}
707
708impl StaticType for HeaderGroupChildType {
709 #[inline]
710 #[doc(alias = "hdy_header_group_child_type_get_type")]
711 fn static_type() -> glib::Type {
712 unsafe { from_glib(ffi::hdy_header_group_child_type_get_type()) }
713 }
714}
715
716impl glib::HasParamSpec for HeaderGroupChildType {
717 type ParamSpec = glib::ParamSpecEnum;
718 type SetValue = Self;
719 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
720
721 fn param_spec_builder() -> Self::BuilderFn {
722 Self::ParamSpec::builder_with_default
723 }
724}
725
726impl glib::value::ValueType for HeaderGroupChildType {
727 type Type = Self;
728}
729
730unsafe impl<'a> glib::value::FromValue<'a> for HeaderGroupChildType {
731 type Checker = glib::value::GenericValueTypeChecker<Self>;
732
733 #[inline]
734 unsafe fn from_value(value: &'a glib::Value) -> Self {
735 skip_assert_initialized!();
736 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
737 }
738}
739
740impl ToValue for HeaderGroupChildType {
741 #[inline]
742 fn to_value(&self) -> glib::Value {
743 let mut value = glib::Value::for_value_type::<Self>();
744 unsafe {
745 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
746 }
747 value
748 }
749
750 #[inline]
751 fn value_type(&self) -> glib::Type {
752 Self::static_type()
753 }
754}
755
756impl From<HeaderGroupChildType> for glib::Value {
757 #[inline]
758 fn from(v: HeaderGroupChildType) -> Self {
759 skip_assert_initialized!();
760 ToValue::to_value(&v)
761 }
762}
763
764#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
765#[non_exhaustive]
766#[doc(alias = "HdyLeafletTransitionType")]
767pub enum LeafletTransitionType {
768 #[doc(alias = "HDY_LEAFLET_TRANSITION_TYPE_OVER")]
769 Over,
770 #[doc(alias = "HDY_LEAFLET_TRANSITION_TYPE_UNDER")]
771 Under,
772 #[doc(alias = "HDY_LEAFLET_TRANSITION_TYPE_SLIDE")]
773 Slide,
774 #[doc(hidden)]
775 __Unknown(i32),
776}
777
778impl fmt::Display for LeafletTransitionType {
779 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
780 write!(
781 f,
782 "LeafletTransitionType::{}",
783 match *self {
784 Self::Over => "Over",
785 Self::Under => "Under",
786 Self::Slide => "Slide",
787 _ => "Unknown",
788 }
789 )
790 }
791}
792
793#[doc(hidden)]
794impl IntoGlib for LeafletTransitionType {
795 type GlibType = ffi::HdyLeafletTransitionType;
796
797 #[inline]
798 fn into_glib(self) -> ffi::HdyLeafletTransitionType {
799 match self {
800 Self::Over => ffi::HDY_LEAFLET_TRANSITION_TYPE_OVER,
801 Self::Under => ffi::HDY_LEAFLET_TRANSITION_TYPE_UNDER,
802 Self::Slide => ffi::HDY_LEAFLET_TRANSITION_TYPE_SLIDE,
803 Self::__Unknown(value) => value,
804 }
805 }
806}
807
808#[doc(hidden)]
809impl FromGlib<ffi::HdyLeafletTransitionType> for LeafletTransitionType {
810 #[inline]
811 unsafe fn from_glib(value: ffi::HdyLeafletTransitionType) -> Self {
812 skip_assert_initialized!();
813
814 match value {
815 ffi::HDY_LEAFLET_TRANSITION_TYPE_OVER => Self::Over,
816 ffi::HDY_LEAFLET_TRANSITION_TYPE_UNDER => Self::Under,
817 ffi::HDY_LEAFLET_TRANSITION_TYPE_SLIDE => Self::Slide,
818 value => Self::__Unknown(value),
819 }
820 }
821}
822
823impl StaticType for LeafletTransitionType {
824 #[inline]
825 #[doc(alias = "hdy_leaflet_transition_type_get_type")]
826 fn static_type() -> glib::Type {
827 unsafe { from_glib(ffi::hdy_leaflet_transition_type_get_type()) }
828 }
829}
830
831impl glib::HasParamSpec for LeafletTransitionType {
832 type ParamSpec = glib::ParamSpecEnum;
833 type SetValue = Self;
834 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
835
836 fn param_spec_builder() -> Self::BuilderFn {
837 Self::ParamSpec::builder_with_default
838 }
839}
840
841impl glib::value::ValueType for LeafletTransitionType {
842 type Type = Self;
843}
844
845unsafe impl<'a> glib::value::FromValue<'a> for LeafletTransitionType {
846 type Checker = glib::value::GenericValueTypeChecker<Self>;
847
848 #[inline]
849 unsafe fn from_value(value: &'a glib::Value) -> Self {
850 skip_assert_initialized!();
851 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
852 }
853}
854
855impl ToValue for LeafletTransitionType {
856 #[inline]
857 fn to_value(&self) -> glib::Value {
858 let mut value = glib::Value::for_value_type::<Self>();
859 unsafe {
860 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
861 }
862 value
863 }
864
865 #[inline]
866 fn value_type(&self) -> glib::Type {
867 Self::static_type()
868 }
869}
870
871impl From<LeafletTransitionType> for glib::Value {
872 #[inline]
873 fn from(v: LeafletTransitionType) -> Self {
874 skip_assert_initialized!();
875 ToValue::to_value(&v)
876 }
877}
878
879#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
880#[non_exhaustive]
881#[doc(alias = "HdyNavigationDirection")]
882pub enum NavigationDirection {
883 #[doc(alias = "HDY_NAVIGATION_DIRECTION_BACK")]
884 Back,
885 #[doc(alias = "HDY_NAVIGATION_DIRECTION_FORWARD")]
886 Forward,
887 #[doc(hidden)]
888 __Unknown(i32),
889}
890
891impl fmt::Display for NavigationDirection {
892 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
893 write!(
894 f,
895 "NavigationDirection::{}",
896 match *self {
897 Self::Back => "Back",
898 Self::Forward => "Forward",
899 _ => "Unknown",
900 }
901 )
902 }
903}
904
905#[doc(hidden)]
906impl IntoGlib for NavigationDirection {
907 type GlibType = ffi::HdyNavigationDirection;
908
909 #[inline]
910 fn into_glib(self) -> ffi::HdyNavigationDirection {
911 match self {
912 Self::Back => ffi::HDY_NAVIGATION_DIRECTION_BACK,
913 Self::Forward => ffi::HDY_NAVIGATION_DIRECTION_FORWARD,
914 Self::__Unknown(value) => value,
915 }
916 }
917}
918
919#[doc(hidden)]
920impl FromGlib<ffi::HdyNavigationDirection> for NavigationDirection {
921 #[inline]
922 unsafe fn from_glib(value: ffi::HdyNavigationDirection) -> Self {
923 skip_assert_initialized!();
924
925 match value {
926 ffi::HDY_NAVIGATION_DIRECTION_BACK => Self::Back,
927 ffi::HDY_NAVIGATION_DIRECTION_FORWARD => Self::Forward,
928 value => Self::__Unknown(value),
929 }
930 }
931}
932
933impl StaticType for NavigationDirection {
934 #[inline]
935 #[doc(alias = "hdy_navigation_direction_get_type")]
936 fn static_type() -> glib::Type {
937 unsafe { from_glib(ffi::hdy_navigation_direction_get_type()) }
938 }
939}
940
941impl glib::HasParamSpec for NavigationDirection {
942 type ParamSpec = glib::ParamSpecEnum;
943 type SetValue = Self;
944 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
945
946 fn param_spec_builder() -> Self::BuilderFn {
947 Self::ParamSpec::builder_with_default
948 }
949}
950
951impl glib::value::ValueType for NavigationDirection {
952 type Type = Self;
953}
954
955unsafe impl<'a> glib::value::FromValue<'a> for NavigationDirection {
956 type Checker = glib::value::GenericValueTypeChecker<Self>;
957
958 #[inline]
959 unsafe fn from_value(value: &'a glib::Value) -> Self {
960 skip_assert_initialized!();
961 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
962 }
963}
964
965impl ToValue for NavigationDirection {
966 #[inline]
967 fn to_value(&self) -> glib::Value {
968 let mut value = glib::Value::for_value_type::<Self>();
969 unsafe {
970 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
971 }
972 value
973 }
974
975 #[inline]
976 fn value_type(&self) -> glib::Type {
977 Self::static_type()
978 }
979}
980
981impl From<NavigationDirection> for glib::Value {
982 #[inline]
983 fn from(v: NavigationDirection) -> Self {
984 skip_assert_initialized!();
985 ToValue::to_value(&v)
986 }
987}
988
989#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
990#[non_exhaustive]
991#[doc(alias = "HdySqueezerTransitionType")]
992pub enum SqueezerTransitionType {
993 #[doc(alias = "HDY_SQUEEZER_TRANSITION_TYPE_NONE")]
994 None,
995 #[doc(alias = "HDY_SQUEEZER_TRANSITION_TYPE_CROSSFADE")]
996 Crossfade,
997 #[doc(hidden)]
998 __Unknown(i32),
999}
1000
1001impl fmt::Display for SqueezerTransitionType {
1002 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1003 write!(
1004 f,
1005 "SqueezerTransitionType::{}",
1006 match *self {
1007 Self::None => "None",
1008 Self::Crossfade => "Crossfade",
1009 _ => "Unknown",
1010 }
1011 )
1012 }
1013}
1014
1015#[doc(hidden)]
1016impl IntoGlib for SqueezerTransitionType {
1017 type GlibType = ffi::HdySqueezerTransitionType;
1018
1019 #[inline]
1020 fn into_glib(self) -> ffi::HdySqueezerTransitionType {
1021 match self {
1022 Self::None => ffi::HDY_SQUEEZER_TRANSITION_TYPE_NONE,
1023 Self::Crossfade => ffi::HDY_SQUEEZER_TRANSITION_TYPE_CROSSFADE,
1024 Self::__Unknown(value) => value,
1025 }
1026 }
1027}
1028
1029#[doc(hidden)]
1030impl FromGlib<ffi::HdySqueezerTransitionType> for SqueezerTransitionType {
1031 #[inline]
1032 unsafe fn from_glib(value: ffi::HdySqueezerTransitionType) -> Self {
1033 skip_assert_initialized!();
1034
1035 match value {
1036 ffi::HDY_SQUEEZER_TRANSITION_TYPE_NONE => Self::None,
1037 ffi::HDY_SQUEEZER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
1038 value => Self::__Unknown(value),
1039 }
1040 }
1041}
1042
1043impl StaticType for SqueezerTransitionType {
1044 #[inline]
1045 #[doc(alias = "hdy_squeezer_transition_type_get_type")]
1046 fn static_type() -> glib::Type {
1047 unsafe { from_glib(ffi::hdy_squeezer_transition_type_get_type()) }
1048 }
1049}
1050
1051impl glib::HasParamSpec for SqueezerTransitionType {
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
1061impl glib::value::ValueType for SqueezerTransitionType {
1062 type Type = Self;
1063}
1064
1065unsafe impl<'a> glib::value::FromValue<'a> for SqueezerTransitionType {
1066 type Checker = glib::value::GenericValueTypeChecker<Self>;
1067
1068 #[inline]
1069 unsafe fn from_value(value: &'a glib::Value) -> Self {
1070 skip_assert_initialized!();
1071 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1072 }
1073}
1074
1075impl ToValue for SqueezerTransitionType {
1076 #[inline]
1077 fn to_value(&self) -> glib::Value {
1078 let mut value = glib::Value::for_value_type::<Self>();
1079 unsafe {
1080 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1081 }
1082 value
1083 }
1084
1085 #[inline]
1086 fn value_type(&self) -> glib::Type {
1087 Self::static_type()
1088 }
1089}
1090
1091impl From<SqueezerTransitionType> for glib::Value {
1092 #[inline]
1093 fn from(v: SqueezerTransitionType) -> Self {
1094 skip_assert_initialized!();
1095 ToValue::to_value(&v)
1096 }
1097}
1098
1099#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1100#[non_exhaustive]
1101#[doc(alias = "HdyViewSwitcherPolicy")]
1102pub enum ViewSwitcherPolicy {
1103 #[doc(alias = "HDY_VIEW_SWITCHER_POLICY_AUTO")]
1104 Auto,
1105 #[doc(alias = "HDY_VIEW_SWITCHER_POLICY_NARROW")]
1106 Narrow,
1107 #[doc(alias = "HDY_VIEW_SWITCHER_POLICY_WIDE")]
1108 Wide,
1109 #[doc(hidden)]
1110 __Unknown(i32),
1111}
1112
1113impl fmt::Display for ViewSwitcherPolicy {
1114 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1115 write!(
1116 f,
1117 "ViewSwitcherPolicy::{}",
1118 match *self {
1119 Self::Auto => "Auto",
1120 Self::Narrow => "Narrow",
1121 Self::Wide => "Wide",
1122 _ => "Unknown",
1123 }
1124 )
1125 }
1126}
1127
1128#[doc(hidden)]
1129impl IntoGlib for ViewSwitcherPolicy {
1130 type GlibType = ffi::HdyViewSwitcherPolicy;
1131
1132 #[inline]
1133 fn into_glib(self) -> ffi::HdyViewSwitcherPolicy {
1134 match self {
1135 Self::Auto => ffi::HDY_VIEW_SWITCHER_POLICY_AUTO,
1136 Self::Narrow => ffi::HDY_VIEW_SWITCHER_POLICY_NARROW,
1137 Self::Wide => ffi::HDY_VIEW_SWITCHER_POLICY_WIDE,
1138 Self::__Unknown(value) => value,
1139 }
1140 }
1141}
1142
1143#[doc(hidden)]
1144impl FromGlib<ffi::HdyViewSwitcherPolicy> for ViewSwitcherPolicy {
1145 #[inline]
1146 unsafe fn from_glib(value: ffi::HdyViewSwitcherPolicy) -> Self {
1147 skip_assert_initialized!();
1148
1149 match value {
1150 ffi::HDY_VIEW_SWITCHER_POLICY_AUTO => Self::Auto,
1151 ffi::HDY_VIEW_SWITCHER_POLICY_NARROW => Self::Narrow,
1152 ffi::HDY_VIEW_SWITCHER_POLICY_WIDE => Self::Wide,
1153 value => Self::__Unknown(value),
1154 }
1155 }
1156}
1157
1158impl StaticType for ViewSwitcherPolicy {
1159 #[inline]
1160 #[doc(alias = "hdy_view_switcher_policy_get_type")]
1161 fn static_type() -> glib::Type {
1162 unsafe { from_glib(ffi::hdy_view_switcher_policy_get_type()) }
1163 }
1164}
1165
1166impl glib::HasParamSpec for ViewSwitcherPolicy {
1167 type ParamSpec = glib::ParamSpecEnum;
1168 type SetValue = Self;
1169 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1170
1171 fn param_spec_builder() -> Self::BuilderFn {
1172 Self::ParamSpec::builder_with_default
1173 }
1174}
1175
1176impl glib::value::ValueType for ViewSwitcherPolicy {
1177 type Type = Self;
1178}
1179
1180unsafe impl<'a> glib::value::FromValue<'a> for ViewSwitcherPolicy {
1181 type Checker = glib::value::GenericValueTypeChecker<Self>;
1182
1183 #[inline]
1184 unsafe fn from_value(value: &'a glib::Value) -> Self {
1185 skip_assert_initialized!();
1186 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1187 }
1188}
1189
1190impl ToValue for ViewSwitcherPolicy {
1191 #[inline]
1192 fn to_value(&self) -> glib::Value {
1193 let mut value = glib::Value::for_value_type::<Self>();
1194 unsafe {
1195 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1196 }
1197 value
1198 }
1199
1200 #[inline]
1201 fn value_type(&self) -> glib::Type {
1202 Self::static_type()
1203 }
1204}
1205
1206impl From<ViewSwitcherPolicy> for glib::Value {
1207 #[inline]
1208 fn from(v: ViewSwitcherPolicy) -> Self {
1209 skip_assert_initialized!();
1210 ToValue::to_value(&v)
1211 }
1212}