1use crate::ffi;
7use glib::{prelude::*, translate::*};
8
9#[cfg(feature = "v1_6")]
10#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
11#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12#[non_exhaustive]
13#[doc(alias = "AdwAccentColor")]
14pub enum AccentColor {
15 #[doc(alias = "ADW_ACCENT_COLOR_BLUE")]
16 Blue,
17 #[doc(alias = "ADW_ACCENT_COLOR_TEAL")]
18 Teal,
19 #[doc(alias = "ADW_ACCENT_COLOR_GREEN")]
20 Green,
21 #[doc(alias = "ADW_ACCENT_COLOR_YELLOW")]
22 Yellow,
23 #[doc(alias = "ADW_ACCENT_COLOR_ORANGE")]
24 Orange,
25 #[doc(alias = "ADW_ACCENT_COLOR_RED")]
26 Red,
27 #[doc(alias = "ADW_ACCENT_COLOR_PINK")]
28 Pink,
29 #[doc(alias = "ADW_ACCENT_COLOR_PURPLE")]
30 Purple,
31 #[doc(alias = "ADW_ACCENT_COLOR_SLATE")]
32 Slate,
33 #[doc(hidden)]
34 __Unknown(i32),
35}
36
37#[cfg(feature = "v1_6")]
38#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
39impl AccentColor {
40 #[doc(alias = "adw_accent_color_to_rgba")]
41 pub fn to_rgba(self) -> gdk::RGBA {
42 assert_initialized_main_thread!();
43 unsafe {
44 let mut rgba = gdk::RGBA::uninitialized();
45 ffi::adw_accent_color_to_rgba(self.into_glib(), rgba.to_glib_none_mut().0);
46 rgba
47 }
48 }
49
50 #[doc(alias = "adw_accent_color_to_standalone_rgba")]
51 pub fn to_standalone_rgba(self, dark: bool) -> gdk::RGBA {
52 assert_initialized_main_thread!();
53 unsafe {
54 let mut rgba = gdk::RGBA::uninitialized();
55 ffi::adw_accent_color_to_standalone_rgba(
56 self.into_glib(),
57 dark.into_glib(),
58 rgba.to_glib_none_mut().0,
59 );
60 rgba
61 }
62 }
63}
64
65#[cfg(feature = "v1_6")]
66#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
67#[doc(hidden)]
68impl IntoGlib for AccentColor {
69 type GlibType = ffi::AdwAccentColor;
70
71 #[inline]
72 fn into_glib(self) -> ffi::AdwAccentColor {
73 match self {
74 Self::Blue => ffi::ADW_ACCENT_COLOR_BLUE,
75 Self::Teal => ffi::ADW_ACCENT_COLOR_TEAL,
76 Self::Green => ffi::ADW_ACCENT_COLOR_GREEN,
77 Self::Yellow => ffi::ADW_ACCENT_COLOR_YELLOW,
78 Self::Orange => ffi::ADW_ACCENT_COLOR_ORANGE,
79 Self::Red => ffi::ADW_ACCENT_COLOR_RED,
80 Self::Pink => ffi::ADW_ACCENT_COLOR_PINK,
81 Self::Purple => ffi::ADW_ACCENT_COLOR_PURPLE,
82 Self::Slate => ffi::ADW_ACCENT_COLOR_SLATE,
83 Self::__Unknown(value) => value,
84 }
85 }
86}
87
88#[cfg(feature = "v1_6")]
89#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
90#[doc(hidden)]
91impl FromGlib<ffi::AdwAccentColor> for AccentColor {
92 #[inline]
93 unsafe fn from_glib(value: ffi::AdwAccentColor) -> Self {
94 skip_assert_initialized!();
95
96 match value {
97 ffi::ADW_ACCENT_COLOR_BLUE => Self::Blue,
98 ffi::ADW_ACCENT_COLOR_TEAL => Self::Teal,
99 ffi::ADW_ACCENT_COLOR_GREEN => Self::Green,
100 ffi::ADW_ACCENT_COLOR_YELLOW => Self::Yellow,
101 ffi::ADW_ACCENT_COLOR_ORANGE => Self::Orange,
102 ffi::ADW_ACCENT_COLOR_RED => Self::Red,
103 ffi::ADW_ACCENT_COLOR_PINK => Self::Pink,
104 ffi::ADW_ACCENT_COLOR_PURPLE => Self::Purple,
105 ffi::ADW_ACCENT_COLOR_SLATE => Self::Slate,
106 value => Self::__Unknown(value),
107 }
108 }
109}
110
111#[cfg(feature = "v1_6")]
112#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
113impl StaticType for AccentColor {
114 #[inline]
115 #[doc(alias = "adw_accent_color_get_type")]
116 fn static_type() -> glib::Type {
117 unsafe { from_glib(ffi::adw_accent_color_get_type()) }
118 }
119}
120
121#[cfg(feature = "v1_6")]
122#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
123impl glib::HasParamSpec for AccentColor {
124 type ParamSpec = glib::ParamSpecEnum;
125 type SetValue = Self;
126 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
127
128 fn param_spec_builder() -> Self::BuilderFn {
129 Self::ParamSpec::builder_with_default
130 }
131}
132
133#[cfg(feature = "v1_6")]
134#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
135impl glib::value::ValueType for AccentColor {
136 type Type = Self;
137}
138
139#[cfg(feature = "v1_6")]
140#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
141unsafe impl<'a> glib::value::FromValue<'a> for AccentColor {
142 type Checker = glib::value::GenericValueTypeChecker<Self>;
143
144 #[inline]
145 unsafe fn from_value(value: &'a glib::Value) -> Self {
146 skip_assert_initialized!();
147 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
148 }
149}
150
151#[cfg(feature = "v1_6")]
152#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
153impl ToValue for AccentColor {
154 #[inline]
155 fn to_value(&self) -> glib::Value {
156 let mut value = glib::Value::for_value_type::<Self>();
157 unsafe {
158 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
159 }
160 value
161 }
162
163 #[inline]
164 fn value_type(&self) -> glib::Type {
165 Self::static_type()
166 }
167}
168
169#[cfg(feature = "v1_6")]
170#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
171impl From<AccentColor> for glib::Value {
172 #[inline]
173 fn from(v: AccentColor) -> Self {
174 skip_assert_initialized!();
175 ToValue::to_value(&v)
176 }
177}
178
179#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
180#[non_exhaustive]
181#[doc(alias = "AdwAnimationState")]
182pub enum AnimationState {
183 #[doc(alias = "ADW_ANIMATION_IDLE")]
184 Idle,
185 #[doc(alias = "ADW_ANIMATION_PAUSED")]
186 Paused,
187 #[doc(alias = "ADW_ANIMATION_PLAYING")]
188 Playing,
189 #[doc(alias = "ADW_ANIMATION_FINISHED")]
190 Finished,
191 #[doc(hidden)]
192 __Unknown(i32),
193}
194
195#[doc(hidden)]
196impl IntoGlib for AnimationState {
197 type GlibType = ffi::AdwAnimationState;
198
199 #[inline]
200 fn into_glib(self) -> ffi::AdwAnimationState {
201 match self {
202 Self::Idle => ffi::ADW_ANIMATION_IDLE,
203 Self::Paused => ffi::ADW_ANIMATION_PAUSED,
204 Self::Playing => ffi::ADW_ANIMATION_PLAYING,
205 Self::Finished => ffi::ADW_ANIMATION_FINISHED,
206 Self::__Unknown(value) => value,
207 }
208 }
209}
210
211#[doc(hidden)]
212impl FromGlib<ffi::AdwAnimationState> for AnimationState {
213 #[inline]
214 unsafe fn from_glib(value: ffi::AdwAnimationState) -> Self {
215 skip_assert_initialized!();
216
217 match value {
218 ffi::ADW_ANIMATION_IDLE => Self::Idle,
219 ffi::ADW_ANIMATION_PAUSED => Self::Paused,
220 ffi::ADW_ANIMATION_PLAYING => Self::Playing,
221 ffi::ADW_ANIMATION_FINISHED => Self::Finished,
222 value => Self::__Unknown(value),
223 }
224 }
225}
226
227impl StaticType for AnimationState {
228 #[inline]
229 #[doc(alias = "adw_animation_state_get_type")]
230 fn static_type() -> glib::Type {
231 unsafe { from_glib(ffi::adw_animation_state_get_type()) }
232 }
233}
234
235impl glib::HasParamSpec for AnimationState {
236 type ParamSpec = glib::ParamSpecEnum;
237 type SetValue = Self;
238 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
239
240 fn param_spec_builder() -> Self::BuilderFn {
241 Self::ParamSpec::builder_with_default
242 }
243}
244
245impl glib::value::ValueType for AnimationState {
246 type Type = Self;
247}
248
249unsafe impl<'a> glib::value::FromValue<'a> for AnimationState {
250 type Checker = glib::value::GenericValueTypeChecker<Self>;
251
252 #[inline]
253 unsafe fn from_value(value: &'a glib::Value) -> Self {
254 skip_assert_initialized!();
255 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
256 }
257}
258
259impl ToValue for AnimationState {
260 #[inline]
261 fn to_value(&self) -> glib::Value {
262 let mut value = glib::Value::for_value_type::<Self>();
263 unsafe {
264 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
265 }
266 value
267 }
268
269 #[inline]
270 fn value_type(&self) -> glib::Type {
271 Self::static_type()
272 }
273}
274
275impl From<AnimationState> for glib::Value {
276 #[inline]
277 fn from(v: AnimationState) -> Self {
278 skip_assert_initialized!();
279 ToValue::to_value(&v)
280 }
281}
282
283#[cfg(feature = "v1_7")]
284#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
285#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
286#[non_exhaustive]
287#[doc(alias = "AdwBannerButtonStyle")]
288pub enum BannerButtonStyle {
289 #[doc(alias = "ADW_BANNER_BUTTON_DEFAULT")]
290 Default,
291 #[doc(alias = "ADW_BANNER_BUTTON_SUGGESTED")]
292 Suggested,
293 #[doc(hidden)]
294 __Unknown(i32),
295}
296
297#[cfg(feature = "v1_7")]
298#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
299#[doc(hidden)]
300impl IntoGlib for BannerButtonStyle {
301 type GlibType = ffi::AdwBannerButtonStyle;
302
303 #[inline]
304 fn into_glib(self) -> ffi::AdwBannerButtonStyle {
305 match self {
306 Self::Default => ffi::ADW_BANNER_BUTTON_DEFAULT,
307 Self::Suggested => ffi::ADW_BANNER_BUTTON_SUGGESTED,
308 Self::__Unknown(value) => value,
309 }
310 }
311}
312
313#[cfg(feature = "v1_7")]
314#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
315#[doc(hidden)]
316impl FromGlib<ffi::AdwBannerButtonStyle> for BannerButtonStyle {
317 #[inline]
318 unsafe fn from_glib(value: ffi::AdwBannerButtonStyle) -> Self {
319 skip_assert_initialized!();
320
321 match value {
322 ffi::ADW_BANNER_BUTTON_DEFAULT => Self::Default,
323 ffi::ADW_BANNER_BUTTON_SUGGESTED => Self::Suggested,
324 value => Self::__Unknown(value),
325 }
326 }
327}
328
329#[cfg(feature = "v1_7")]
330#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
331impl StaticType for BannerButtonStyle {
332 #[inline]
333 #[doc(alias = "adw_banner_button_style_get_type")]
334 fn static_type() -> glib::Type {
335 unsafe { from_glib(ffi::adw_banner_button_style_get_type()) }
336 }
337}
338
339#[cfg(feature = "v1_7")]
340#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
341impl glib::HasParamSpec for BannerButtonStyle {
342 type ParamSpec = glib::ParamSpecEnum;
343 type SetValue = Self;
344 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
345
346 fn param_spec_builder() -> Self::BuilderFn {
347 Self::ParamSpec::builder_with_default
348 }
349}
350
351#[cfg(feature = "v1_7")]
352#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
353impl glib::value::ValueType for BannerButtonStyle {
354 type Type = Self;
355}
356
357#[cfg(feature = "v1_7")]
358#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
359unsafe impl<'a> glib::value::FromValue<'a> for BannerButtonStyle {
360 type Checker = glib::value::GenericValueTypeChecker<Self>;
361
362 #[inline]
363 unsafe fn from_value(value: &'a glib::Value) -> Self {
364 skip_assert_initialized!();
365 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
366 }
367}
368
369#[cfg(feature = "v1_7")]
370#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
371impl ToValue for BannerButtonStyle {
372 #[inline]
373 fn to_value(&self) -> glib::Value {
374 let mut value = glib::Value::for_value_type::<Self>();
375 unsafe {
376 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
377 }
378 value
379 }
380
381 #[inline]
382 fn value_type(&self) -> glib::Type {
383 Self::static_type()
384 }
385}
386
387#[cfg(feature = "v1_7")]
388#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
389impl From<BannerButtonStyle> for glib::Value {
390 #[inline]
391 fn from(v: BannerButtonStyle) -> Self {
392 skip_assert_initialized!();
393 ToValue::to_value(&v)
394 }
395}
396
397#[cfg(feature = "v1_4")]
398#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
399#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
400#[non_exhaustive]
401#[doc(alias = "AdwBreakpointConditionLengthType")]
402pub enum BreakpointConditionLengthType {
403 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_WIDTH")]
404 MinWidth,
405 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_WIDTH")]
406 MaxWidth,
407 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_HEIGHT")]
408 MinHeight,
409 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_HEIGHT")]
410 MaxHeight,
411 #[doc(hidden)]
412 __Unknown(i32),
413}
414
415#[cfg(feature = "v1_4")]
416#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
417#[doc(hidden)]
418impl IntoGlib for BreakpointConditionLengthType {
419 type GlibType = ffi::AdwBreakpointConditionLengthType;
420
421 #[inline]
422 fn into_glib(self) -> ffi::AdwBreakpointConditionLengthType {
423 match self {
424 Self::MinWidth => ffi::ADW_BREAKPOINT_CONDITION_MIN_WIDTH,
425 Self::MaxWidth => ffi::ADW_BREAKPOINT_CONDITION_MAX_WIDTH,
426 Self::MinHeight => ffi::ADW_BREAKPOINT_CONDITION_MIN_HEIGHT,
427 Self::MaxHeight => ffi::ADW_BREAKPOINT_CONDITION_MAX_HEIGHT,
428 Self::__Unknown(value) => value,
429 }
430 }
431}
432
433#[cfg(feature = "v1_4")]
434#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
435#[doc(hidden)]
436impl FromGlib<ffi::AdwBreakpointConditionLengthType> for BreakpointConditionLengthType {
437 #[inline]
438 unsafe fn from_glib(value: ffi::AdwBreakpointConditionLengthType) -> Self {
439 skip_assert_initialized!();
440
441 match value {
442 ffi::ADW_BREAKPOINT_CONDITION_MIN_WIDTH => Self::MinWidth,
443 ffi::ADW_BREAKPOINT_CONDITION_MAX_WIDTH => Self::MaxWidth,
444 ffi::ADW_BREAKPOINT_CONDITION_MIN_HEIGHT => Self::MinHeight,
445 ffi::ADW_BREAKPOINT_CONDITION_MAX_HEIGHT => Self::MaxHeight,
446 value => Self::__Unknown(value),
447 }
448 }
449}
450
451#[cfg(feature = "v1_4")]
452#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
453impl StaticType for BreakpointConditionLengthType {
454 #[inline]
455 #[doc(alias = "adw_breakpoint_condition_length_type_get_type")]
456 fn static_type() -> glib::Type {
457 unsafe { from_glib(ffi::adw_breakpoint_condition_length_type_get_type()) }
458 }
459}
460
461#[cfg(feature = "v1_4")]
462#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
463impl glib::HasParamSpec for BreakpointConditionLengthType {
464 type ParamSpec = glib::ParamSpecEnum;
465 type SetValue = Self;
466 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
467
468 fn param_spec_builder() -> Self::BuilderFn {
469 Self::ParamSpec::builder_with_default
470 }
471}
472
473#[cfg(feature = "v1_4")]
474#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
475impl glib::value::ValueType for BreakpointConditionLengthType {
476 type Type = Self;
477}
478
479#[cfg(feature = "v1_4")]
480#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
481unsafe impl<'a> glib::value::FromValue<'a> for BreakpointConditionLengthType {
482 type Checker = glib::value::GenericValueTypeChecker<Self>;
483
484 #[inline]
485 unsafe fn from_value(value: &'a glib::Value) -> Self {
486 skip_assert_initialized!();
487 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
488 }
489}
490
491#[cfg(feature = "v1_4")]
492#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
493impl ToValue for BreakpointConditionLengthType {
494 #[inline]
495 fn to_value(&self) -> glib::Value {
496 let mut value = glib::Value::for_value_type::<Self>();
497 unsafe {
498 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
499 }
500 value
501 }
502
503 #[inline]
504 fn value_type(&self) -> glib::Type {
505 Self::static_type()
506 }
507}
508
509#[cfg(feature = "v1_4")]
510#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
511impl From<BreakpointConditionLengthType> for glib::Value {
512 #[inline]
513 fn from(v: BreakpointConditionLengthType) -> Self {
514 skip_assert_initialized!();
515 ToValue::to_value(&v)
516 }
517}
518
519#[cfg(feature = "v1_4")]
520#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
521#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
522#[non_exhaustive]
523#[doc(alias = "AdwBreakpointConditionRatioType")]
524pub enum BreakpointConditionRatioType {
525 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO")]
526 MinAspectRatio,
527 #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO")]
528 MaxAspectRatio,
529 #[doc(hidden)]
530 __Unknown(i32),
531}
532
533#[cfg(feature = "v1_4")]
534#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
535#[doc(hidden)]
536impl IntoGlib for BreakpointConditionRatioType {
537 type GlibType = ffi::AdwBreakpointConditionRatioType;
538
539 #[inline]
540 fn into_glib(self) -> ffi::AdwBreakpointConditionRatioType {
541 match self {
542 Self::MinAspectRatio => ffi::ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO,
543 Self::MaxAspectRatio => ffi::ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO,
544 Self::__Unknown(value) => value,
545 }
546 }
547}
548
549#[cfg(feature = "v1_4")]
550#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
551#[doc(hidden)]
552impl FromGlib<ffi::AdwBreakpointConditionRatioType> for BreakpointConditionRatioType {
553 #[inline]
554 unsafe fn from_glib(value: ffi::AdwBreakpointConditionRatioType) -> Self {
555 skip_assert_initialized!();
556
557 match value {
558 ffi::ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO => Self::MinAspectRatio,
559 ffi::ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO => Self::MaxAspectRatio,
560 value => Self::__Unknown(value),
561 }
562 }
563}
564
565#[cfg(feature = "v1_4")]
566#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
567impl StaticType for BreakpointConditionRatioType {
568 #[inline]
569 #[doc(alias = "adw_breakpoint_condition_ratio_type_get_type")]
570 fn static_type() -> glib::Type {
571 unsafe { from_glib(ffi::adw_breakpoint_condition_ratio_type_get_type()) }
572 }
573}
574
575#[cfg(feature = "v1_4")]
576#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
577impl glib::HasParamSpec for BreakpointConditionRatioType {
578 type ParamSpec = glib::ParamSpecEnum;
579 type SetValue = Self;
580 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
581
582 fn param_spec_builder() -> Self::BuilderFn {
583 Self::ParamSpec::builder_with_default
584 }
585}
586
587#[cfg(feature = "v1_4")]
588#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
589impl glib::value::ValueType for BreakpointConditionRatioType {
590 type Type = Self;
591}
592
593#[cfg(feature = "v1_4")]
594#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
595unsafe impl<'a> glib::value::FromValue<'a> for BreakpointConditionRatioType {
596 type Checker = glib::value::GenericValueTypeChecker<Self>;
597
598 #[inline]
599 unsafe fn from_value(value: &'a glib::Value) -> Self {
600 skip_assert_initialized!();
601 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
602 }
603}
604
605#[cfg(feature = "v1_4")]
606#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
607impl ToValue for BreakpointConditionRatioType {
608 #[inline]
609 fn to_value(&self) -> glib::Value {
610 let mut value = glib::Value::for_value_type::<Self>();
611 unsafe {
612 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
613 }
614 value
615 }
616
617 #[inline]
618 fn value_type(&self) -> glib::Type {
619 Self::static_type()
620 }
621}
622
623#[cfg(feature = "v1_4")]
624#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
625impl From<BreakpointConditionRatioType> for glib::Value {
626 #[inline]
627 fn from(v: BreakpointConditionRatioType) -> Self {
628 skip_assert_initialized!();
629 ToValue::to_value(&v)
630 }
631}
632
633#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
634#[non_exhaustive]
635#[doc(alias = "AdwCenteringPolicy")]
636pub enum CenteringPolicy {
637 #[doc(alias = "ADW_CENTERING_POLICY_LOOSE")]
638 Loose,
639 #[doc(alias = "ADW_CENTERING_POLICY_STRICT")]
640 Strict,
641 #[doc(hidden)]
642 __Unknown(i32),
643}
644
645#[doc(hidden)]
646impl IntoGlib for CenteringPolicy {
647 type GlibType = ffi::AdwCenteringPolicy;
648
649 #[inline]
650 fn into_glib(self) -> ffi::AdwCenteringPolicy {
651 match self {
652 Self::Loose => ffi::ADW_CENTERING_POLICY_LOOSE,
653 Self::Strict => ffi::ADW_CENTERING_POLICY_STRICT,
654 Self::__Unknown(value) => value,
655 }
656 }
657}
658
659#[doc(hidden)]
660impl FromGlib<ffi::AdwCenteringPolicy> for CenteringPolicy {
661 #[inline]
662 unsafe fn from_glib(value: ffi::AdwCenteringPolicy) -> Self {
663 skip_assert_initialized!();
664
665 match value {
666 ffi::ADW_CENTERING_POLICY_LOOSE => Self::Loose,
667 ffi::ADW_CENTERING_POLICY_STRICT => Self::Strict,
668 value => Self::__Unknown(value),
669 }
670 }
671}
672
673impl StaticType for CenteringPolicy {
674 #[inline]
675 #[doc(alias = "adw_centering_policy_get_type")]
676 fn static_type() -> glib::Type {
677 unsafe { from_glib(ffi::adw_centering_policy_get_type()) }
678 }
679}
680
681impl glib::HasParamSpec for CenteringPolicy {
682 type ParamSpec = glib::ParamSpecEnum;
683 type SetValue = Self;
684 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
685
686 fn param_spec_builder() -> Self::BuilderFn {
687 Self::ParamSpec::builder_with_default
688 }
689}
690
691impl glib::value::ValueType for CenteringPolicy {
692 type Type = Self;
693}
694
695unsafe impl<'a> glib::value::FromValue<'a> for CenteringPolicy {
696 type Checker = glib::value::GenericValueTypeChecker<Self>;
697
698 #[inline]
699 unsafe fn from_value(value: &'a glib::Value) -> Self {
700 skip_assert_initialized!();
701 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
702 }
703}
704
705impl ToValue for CenteringPolicy {
706 #[inline]
707 fn to_value(&self) -> glib::Value {
708 let mut value = glib::Value::for_value_type::<Self>();
709 unsafe {
710 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
711 }
712 value
713 }
714
715 #[inline]
716 fn value_type(&self) -> glib::Type {
717 Self::static_type()
718 }
719}
720
721impl From<CenteringPolicy> for glib::Value {
722 #[inline]
723 fn from(v: CenteringPolicy) -> Self {
724 skip_assert_initialized!();
725 ToValue::to_value(&v)
726 }
727}
728
729#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
730#[non_exhaustive]
731#[doc(alias = "AdwColorScheme")]
732pub enum ColorScheme {
733 #[doc(alias = "ADW_COLOR_SCHEME_DEFAULT")]
734 Default,
735 #[doc(alias = "ADW_COLOR_SCHEME_FORCE_LIGHT")]
736 ForceLight,
737 #[doc(alias = "ADW_COLOR_SCHEME_PREFER_LIGHT")]
738 PreferLight,
739 #[doc(alias = "ADW_COLOR_SCHEME_PREFER_DARK")]
740 PreferDark,
741 #[doc(alias = "ADW_COLOR_SCHEME_FORCE_DARK")]
742 ForceDark,
743 #[doc(hidden)]
744 __Unknown(i32),
745}
746
747#[doc(hidden)]
748impl IntoGlib for ColorScheme {
749 type GlibType = ffi::AdwColorScheme;
750
751 #[inline]
752 fn into_glib(self) -> ffi::AdwColorScheme {
753 match self {
754 Self::Default => ffi::ADW_COLOR_SCHEME_DEFAULT,
755 Self::ForceLight => ffi::ADW_COLOR_SCHEME_FORCE_LIGHT,
756 Self::PreferLight => ffi::ADW_COLOR_SCHEME_PREFER_LIGHT,
757 Self::PreferDark => ffi::ADW_COLOR_SCHEME_PREFER_DARK,
758 Self::ForceDark => ffi::ADW_COLOR_SCHEME_FORCE_DARK,
759 Self::__Unknown(value) => value,
760 }
761 }
762}
763
764#[doc(hidden)]
765impl FromGlib<ffi::AdwColorScheme> for ColorScheme {
766 #[inline]
767 unsafe fn from_glib(value: ffi::AdwColorScheme) -> Self {
768 skip_assert_initialized!();
769
770 match value {
771 ffi::ADW_COLOR_SCHEME_DEFAULT => Self::Default,
772 ffi::ADW_COLOR_SCHEME_FORCE_LIGHT => Self::ForceLight,
773 ffi::ADW_COLOR_SCHEME_PREFER_LIGHT => Self::PreferLight,
774 ffi::ADW_COLOR_SCHEME_PREFER_DARK => Self::PreferDark,
775 ffi::ADW_COLOR_SCHEME_FORCE_DARK => Self::ForceDark,
776 value => Self::__Unknown(value),
777 }
778 }
779}
780
781impl StaticType for ColorScheme {
782 #[inline]
783 #[doc(alias = "adw_color_scheme_get_type")]
784 fn static_type() -> glib::Type {
785 unsafe { from_glib(ffi::adw_color_scheme_get_type()) }
786 }
787}
788
789impl glib::HasParamSpec for ColorScheme {
790 type ParamSpec = glib::ParamSpecEnum;
791 type SetValue = Self;
792 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
793
794 fn param_spec_builder() -> Self::BuilderFn {
795 Self::ParamSpec::builder_with_default
796 }
797}
798
799impl glib::value::ValueType for ColorScheme {
800 type Type = Self;
801}
802
803unsafe impl<'a> glib::value::FromValue<'a> for ColorScheme {
804 type Checker = glib::value::GenericValueTypeChecker<Self>;
805
806 #[inline]
807 unsafe fn from_value(value: &'a glib::Value) -> Self {
808 skip_assert_initialized!();
809 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
810 }
811}
812
813impl ToValue for ColorScheme {
814 #[inline]
815 fn to_value(&self) -> glib::Value {
816 let mut value = glib::Value::for_value_type::<Self>();
817 unsafe {
818 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
819 }
820 value
821 }
822
823 #[inline]
824 fn value_type(&self) -> glib::Type {
825 Self::static_type()
826 }
827}
828
829impl From<ColorScheme> for glib::Value {
830 #[inline]
831 fn from(v: ColorScheme) -> Self {
832 skip_assert_initialized!();
833 ToValue::to_value(&v)
834 }
835}
836
837#[cfg(feature = "v1_5")]
838#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
839#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
840#[non_exhaustive]
841#[doc(alias = "AdwDialogPresentationMode")]
842pub enum DialogPresentationMode {
843 #[doc(alias = "ADW_DIALOG_AUTO")]
844 Auto,
845 #[doc(alias = "ADW_DIALOG_FLOATING")]
846 Floating,
847 #[doc(alias = "ADW_DIALOG_BOTTOM_SHEET")]
848 BottomSheet,
849 #[doc(hidden)]
850 __Unknown(i32),
851}
852
853#[cfg(feature = "v1_5")]
854#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
855#[doc(hidden)]
856impl IntoGlib for DialogPresentationMode {
857 type GlibType = ffi::AdwDialogPresentationMode;
858
859 #[inline]
860 fn into_glib(self) -> ffi::AdwDialogPresentationMode {
861 match self {
862 Self::Auto => ffi::ADW_DIALOG_AUTO,
863 Self::Floating => ffi::ADW_DIALOG_FLOATING,
864 Self::BottomSheet => ffi::ADW_DIALOG_BOTTOM_SHEET,
865 Self::__Unknown(value) => value,
866 }
867 }
868}
869
870#[cfg(feature = "v1_5")]
871#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
872#[doc(hidden)]
873impl FromGlib<ffi::AdwDialogPresentationMode> for DialogPresentationMode {
874 #[inline]
875 unsafe fn from_glib(value: ffi::AdwDialogPresentationMode) -> Self {
876 skip_assert_initialized!();
877
878 match value {
879 ffi::ADW_DIALOG_AUTO => Self::Auto,
880 ffi::ADW_DIALOG_FLOATING => Self::Floating,
881 ffi::ADW_DIALOG_BOTTOM_SHEET => Self::BottomSheet,
882 value => Self::__Unknown(value),
883 }
884 }
885}
886
887#[cfg(feature = "v1_5")]
888#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
889impl StaticType for DialogPresentationMode {
890 #[inline]
891 #[doc(alias = "adw_dialog_presentation_mode_get_type")]
892 fn static_type() -> glib::Type {
893 unsafe { from_glib(ffi::adw_dialog_presentation_mode_get_type()) }
894 }
895}
896
897#[cfg(feature = "v1_5")]
898#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
899impl glib::HasParamSpec for DialogPresentationMode {
900 type ParamSpec = glib::ParamSpecEnum;
901 type SetValue = Self;
902 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
903
904 fn param_spec_builder() -> Self::BuilderFn {
905 Self::ParamSpec::builder_with_default
906 }
907}
908
909#[cfg(feature = "v1_5")]
910#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
911impl glib::value::ValueType for DialogPresentationMode {
912 type Type = Self;
913}
914
915#[cfg(feature = "v1_5")]
916#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
917unsafe impl<'a> glib::value::FromValue<'a> for DialogPresentationMode {
918 type Checker = glib::value::GenericValueTypeChecker<Self>;
919
920 #[inline]
921 unsafe fn from_value(value: &'a glib::Value) -> Self {
922 skip_assert_initialized!();
923 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
924 }
925}
926
927#[cfg(feature = "v1_5")]
928#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
929impl ToValue for DialogPresentationMode {
930 #[inline]
931 fn to_value(&self) -> glib::Value {
932 let mut value = glib::Value::for_value_type::<Self>();
933 unsafe {
934 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
935 }
936 value
937 }
938
939 #[inline]
940 fn value_type(&self) -> glib::Type {
941 Self::static_type()
942 }
943}
944
945#[cfg(feature = "v1_5")]
946#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
947impl From<DialogPresentationMode> for glib::Value {
948 #[inline]
949 fn from(v: DialogPresentationMode) -> Self {
950 skip_assert_initialized!();
951 ToValue::to_value(&v)
952 }
953}
954
955#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
956#[non_exhaustive]
957#[doc(alias = "AdwEasing")]
958pub enum Easing {
959 #[doc(alias = "ADW_LINEAR")]
960 Linear,
961 #[doc(alias = "ADW_EASE_IN_QUAD")]
962 EaseInQuad,
963 #[doc(alias = "ADW_EASE_OUT_QUAD")]
964 EaseOutQuad,
965 #[doc(alias = "ADW_EASE_IN_OUT_QUAD")]
966 EaseInOutQuad,
967 #[doc(alias = "ADW_EASE_IN_CUBIC")]
968 EaseInCubic,
969 #[doc(alias = "ADW_EASE_OUT_CUBIC")]
970 EaseOutCubic,
971 #[doc(alias = "ADW_EASE_IN_OUT_CUBIC")]
972 EaseInOutCubic,
973 #[doc(alias = "ADW_EASE_IN_QUART")]
974 EaseInQuart,
975 #[doc(alias = "ADW_EASE_OUT_QUART")]
976 EaseOutQuart,
977 #[doc(alias = "ADW_EASE_IN_OUT_QUART")]
978 EaseInOutQuart,
979 #[doc(alias = "ADW_EASE_IN_QUINT")]
980 EaseInQuint,
981 #[doc(alias = "ADW_EASE_OUT_QUINT")]
982 EaseOutQuint,
983 #[doc(alias = "ADW_EASE_IN_OUT_QUINT")]
984 EaseInOutQuint,
985 #[doc(alias = "ADW_EASE_IN_SINE")]
986 EaseInSine,
987 #[doc(alias = "ADW_EASE_OUT_SINE")]
988 EaseOutSine,
989 #[doc(alias = "ADW_EASE_IN_OUT_SINE")]
990 EaseInOutSine,
991 #[doc(alias = "ADW_EASE_IN_EXPO")]
992 EaseInExpo,
993 #[doc(alias = "ADW_EASE_OUT_EXPO")]
994 EaseOutExpo,
995 #[doc(alias = "ADW_EASE_IN_OUT_EXPO")]
996 EaseInOutExpo,
997 #[doc(alias = "ADW_EASE_IN_CIRC")]
998 EaseInCirc,
999 #[doc(alias = "ADW_EASE_OUT_CIRC")]
1000 EaseOutCirc,
1001 #[doc(alias = "ADW_EASE_IN_OUT_CIRC")]
1002 EaseInOutCirc,
1003 #[doc(alias = "ADW_EASE_IN_ELASTIC")]
1004 EaseInElastic,
1005 #[doc(alias = "ADW_EASE_OUT_ELASTIC")]
1006 EaseOutElastic,
1007 #[doc(alias = "ADW_EASE_IN_OUT_ELASTIC")]
1008 EaseInOutElastic,
1009 #[doc(alias = "ADW_EASE_IN_BACK")]
1010 EaseInBack,
1011 #[doc(alias = "ADW_EASE_OUT_BACK")]
1012 EaseOutBack,
1013 #[doc(alias = "ADW_EASE_IN_OUT_BACK")]
1014 EaseInOutBack,
1015 #[doc(alias = "ADW_EASE_IN_BOUNCE")]
1016 EaseInBounce,
1017 #[doc(alias = "ADW_EASE_OUT_BOUNCE")]
1018 EaseOutBounce,
1019 #[doc(alias = "ADW_EASE_IN_OUT_BOUNCE")]
1020 EaseInOutBounce,
1021 #[cfg(feature = "v1_7")]
1022 #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1023 #[doc(alias = "ADW_EASE")]
1024 Ease,
1025 #[cfg(feature = "v1_7")]
1026 #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1027 #[doc(alias = "ADW_EASE_IN")]
1028 EaseIn,
1029 #[cfg(feature = "v1_7")]
1030 #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1031 #[doc(alias = "ADW_EASE_OUT")]
1032 EaseOut,
1033 #[cfg(feature = "v1_7")]
1034 #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1035 #[doc(alias = "ADW_EASE_IN_OUT")]
1036 EaseInOut,
1037 #[doc(hidden)]
1038 __Unknown(i32),
1039}
1040
1041impl Easing {
1042 #[doc(alias = "adw_easing_ease")]
1043 pub fn ease(self, value: f64) -> f64 {
1044 assert_initialized_main_thread!();
1045 unsafe { ffi::adw_easing_ease(self.into_glib(), value) }
1046 }
1047}
1048
1049#[doc(hidden)]
1050impl IntoGlib for Easing {
1051 type GlibType = ffi::AdwEasing;
1052
1053 fn into_glib(self) -> ffi::AdwEasing {
1054 match self {
1055 Self::Linear => ffi::ADW_LINEAR,
1056 Self::EaseInQuad => ffi::ADW_EASE_IN_QUAD,
1057 Self::EaseOutQuad => ffi::ADW_EASE_OUT_QUAD,
1058 Self::EaseInOutQuad => ffi::ADW_EASE_IN_OUT_QUAD,
1059 Self::EaseInCubic => ffi::ADW_EASE_IN_CUBIC,
1060 Self::EaseOutCubic => ffi::ADW_EASE_OUT_CUBIC,
1061 Self::EaseInOutCubic => ffi::ADW_EASE_IN_OUT_CUBIC,
1062 Self::EaseInQuart => ffi::ADW_EASE_IN_QUART,
1063 Self::EaseOutQuart => ffi::ADW_EASE_OUT_QUART,
1064 Self::EaseInOutQuart => ffi::ADW_EASE_IN_OUT_QUART,
1065 Self::EaseInQuint => ffi::ADW_EASE_IN_QUINT,
1066 Self::EaseOutQuint => ffi::ADW_EASE_OUT_QUINT,
1067 Self::EaseInOutQuint => ffi::ADW_EASE_IN_OUT_QUINT,
1068 Self::EaseInSine => ffi::ADW_EASE_IN_SINE,
1069 Self::EaseOutSine => ffi::ADW_EASE_OUT_SINE,
1070 Self::EaseInOutSine => ffi::ADW_EASE_IN_OUT_SINE,
1071 Self::EaseInExpo => ffi::ADW_EASE_IN_EXPO,
1072 Self::EaseOutExpo => ffi::ADW_EASE_OUT_EXPO,
1073 Self::EaseInOutExpo => ffi::ADW_EASE_IN_OUT_EXPO,
1074 Self::EaseInCirc => ffi::ADW_EASE_IN_CIRC,
1075 Self::EaseOutCirc => ffi::ADW_EASE_OUT_CIRC,
1076 Self::EaseInOutCirc => ffi::ADW_EASE_IN_OUT_CIRC,
1077 Self::EaseInElastic => ffi::ADW_EASE_IN_ELASTIC,
1078 Self::EaseOutElastic => ffi::ADW_EASE_OUT_ELASTIC,
1079 Self::EaseInOutElastic => ffi::ADW_EASE_IN_OUT_ELASTIC,
1080 Self::EaseInBack => ffi::ADW_EASE_IN_BACK,
1081 Self::EaseOutBack => ffi::ADW_EASE_OUT_BACK,
1082 Self::EaseInOutBack => ffi::ADW_EASE_IN_OUT_BACK,
1083 Self::EaseInBounce => ffi::ADW_EASE_IN_BOUNCE,
1084 Self::EaseOutBounce => ffi::ADW_EASE_OUT_BOUNCE,
1085 Self::EaseInOutBounce => ffi::ADW_EASE_IN_OUT_BOUNCE,
1086 #[cfg(feature = "v1_7")]
1087 Self::Ease => ffi::ADW_EASE,
1088 #[cfg(feature = "v1_7")]
1089 Self::EaseIn => ffi::ADW_EASE_IN,
1090 #[cfg(feature = "v1_7")]
1091 Self::EaseOut => ffi::ADW_EASE_OUT,
1092 #[cfg(feature = "v1_7")]
1093 Self::EaseInOut => ffi::ADW_EASE_IN_OUT,
1094 Self::__Unknown(value) => value,
1095 }
1096 }
1097}
1098
1099#[doc(hidden)]
1100impl FromGlib<ffi::AdwEasing> for Easing {
1101 unsafe fn from_glib(value: ffi::AdwEasing) -> Self {
1102 skip_assert_initialized!();
1103
1104 match value {
1105 ffi::ADW_LINEAR => Self::Linear,
1106 ffi::ADW_EASE_IN_QUAD => Self::EaseInQuad,
1107 ffi::ADW_EASE_OUT_QUAD => Self::EaseOutQuad,
1108 ffi::ADW_EASE_IN_OUT_QUAD => Self::EaseInOutQuad,
1109 ffi::ADW_EASE_IN_CUBIC => Self::EaseInCubic,
1110 ffi::ADW_EASE_OUT_CUBIC => Self::EaseOutCubic,
1111 ffi::ADW_EASE_IN_OUT_CUBIC => Self::EaseInOutCubic,
1112 ffi::ADW_EASE_IN_QUART => Self::EaseInQuart,
1113 ffi::ADW_EASE_OUT_QUART => Self::EaseOutQuart,
1114 ffi::ADW_EASE_IN_OUT_QUART => Self::EaseInOutQuart,
1115 ffi::ADW_EASE_IN_QUINT => Self::EaseInQuint,
1116 ffi::ADW_EASE_OUT_QUINT => Self::EaseOutQuint,
1117 ffi::ADW_EASE_IN_OUT_QUINT => Self::EaseInOutQuint,
1118 ffi::ADW_EASE_IN_SINE => Self::EaseInSine,
1119 ffi::ADW_EASE_OUT_SINE => Self::EaseOutSine,
1120 ffi::ADW_EASE_IN_OUT_SINE => Self::EaseInOutSine,
1121 ffi::ADW_EASE_IN_EXPO => Self::EaseInExpo,
1122 ffi::ADW_EASE_OUT_EXPO => Self::EaseOutExpo,
1123 ffi::ADW_EASE_IN_OUT_EXPO => Self::EaseInOutExpo,
1124 ffi::ADW_EASE_IN_CIRC => Self::EaseInCirc,
1125 ffi::ADW_EASE_OUT_CIRC => Self::EaseOutCirc,
1126 ffi::ADW_EASE_IN_OUT_CIRC => Self::EaseInOutCirc,
1127 ffi::ADW_EASE_IN_ELASTIC => Self::EaseInElastic,
1128 ffi::ADW_EASE_OUT_ELASTIC => Self::EaseOutElastic,
1129 ffi::ADW_EASE_IN_OUT_ELASTIC => Self::EaseInOutElastic,
1130 ffi::ADW_EASE_IN_BACK => Self::EaseInBack,
1131 ffi::ADW_EASE_OUT_BACK => Self::EaseOutBack,
1132 ffi::ADW_EASE_IN_OUT_BACK => Self::EaseInOutBack,
1133 ffi::ADW_EASE_IN_BOUNCE => Self::EaseInBounce,
1134 ffi::ADW_EASE_OUT_BOUNCE => Self::EaseOutBounce,
1135 ffi::ADW_EASE_IN_OUT_BOUNCE => Self::EaseInOutBounce,
1136 #[cfg(feature = "v1_7")]
1137 ffi::ADW_EASE => Self::Ease,
1138 #[cfg(feature = "v1_7")]
1139 ffi::ADW_EASE_IN => Self::EaseIn,
1140 #[cfg(feature = "v1_7")]
1141 ffi::ADW_EASE_OUT => Self::EaseOut,
1142 #[cfg(feature = "v1_7")]
1143 ffi::ADW_EASE_IN_OUT => Self::EaseInOut,
1144 value => Self::__Unknown(value),
1145 }
1146 }
1147}
1148
1149impl StaticType for Easing {
1150 #[inline]
1151 #[doc(alias = "adw_easing_get_type")]
1152 fn static_type() -> glib::Type {
1153 unsafe { from_glib(ffi::adw_easing_get_type()) }
1154 }
1155}
1156
1157impl glib::HasParamSpec for Easing {
1158 type ParamSpec = glib::ParamSpecEnum;
1159 type SetValue = Self;
1160 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1161
1162 fn param_spec_builder() -> Self::BuilderFn {
1163 Self::ParamSpec::builder_with_default
1164 }
1165}
1166
1167impl glib::value::ValueType for Easing {
1168 type Type = Self;
1169}
1170
1171unsafe impl<'a> glib::value::FromValue<'a> for Easing {
1172 type Checker = glib::value::GenericValueTypeChecker<Self>;
1173
1174 #[inline]
1175 unsafe fn from_value(value: &'a glib::Value) -> Self {
1176 skip_assert_initialized!();
1177 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1178 }
1179}
1180
1181impl ToValue for Easing {
1182 #[inline]
1183 fn to_value(&self) -> glib::Value {
1184 let mut value = glib::Value::for_value_type::<Self>();
1185 unsafe {
1186 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1187 }
1188 value
1189 }
1190
1191 #[inline]
1192 fn value_type(&self) -> glib::Type {
1193 Self::static_type()
1194 }
1195}
1196
1197impl From<Easing> for glib::Value {
1198 #[inline]
1199 fn from(v: Easing) -> Self {
1200 skip_assert_initialized!();
1201 ToValue::to_value(&v)
1202 }
1203}
1204
1205#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
1206#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1207#[non_exhaustive]
1208#[doc(alias = "AdwFlapFoldPolicy")]
1209pub enum FlapFoldPolicy {
1210 #[doc(alias = "ADW_FLAP_FOLD_POLICY_NEVER")]
1211 Never,
1212 #[doc(alias = "ADW_FLAP_FOLD_POLICY_ALWAYS")]
1213 Always,
1214 #[doc(alias = "ADW_FLAP_FOLD_POLICY_AUTO")]
1215 Auto,
1216 #[doc(hidden)]
1217 __Unknown(i32),
1218}
1219
1220#[allow(deprecated)]
1221#[doc(hidden)]
1222impl IntoGlib for FlapFoldPolicy {
1223 type GlibType = ffi::AdwFlapFoldPolicy;
1224
1225 #[inline]
1226 fn into_glib(self) -> ffi::AdwFlapFoldPolicy {
1227 match self {
1228 Self::Never => ffi::ADW_FLAP_FOLD_POLICY_NEVER,
1229 Self::Always => ffi::ADW_FLAP_FOLD_POLICY_ALWAYS,
1230 Self::Auto => ffi::ADW_FLAP_FOLD_POLICY_AUTO,
1231 Self::__Unknown(value) => value,
1232 }
1233 }
1234}
1235
1236#[allow(deprecated)]
1237#[doc(hidden)]
1238impl FromGlib<ffi::AdwFlapFoldPolicy> for FlapFoldPolicy {
1239 #[inline]
1240 unsafe fn from_glib(value: ffi::AdwFlapFoldPolicy) -> Self {
1241 skip_assert_initialized!();
1242
1243 match value {
1244 ffi::ADW_FLAP_FOLD_POLICY_NEVER => Self::Never,
1245 ffi::ADW_FLAP_FOLD_POLICY_ALWAYS => Self::Always,
1246 ffi::ADW_FLAP_FOLD_POLICY_AUTO => Self::Auto,
1247 value => Self::__Unknown(value),
1248 }
1249 }
1250}
1251
1252#[allow(deprecated)]
1253impl StaticType for FlapFoldPolicy {
1254 #[inline]
1255 #[doc(alias = "adw_flap_fold_policy_get_type")]
1256 fn static_type() -> glib::Type {
1257 unsafe { from_glib(ffi::adw_flap_fold_policy_get_type()) }
1258 }
1259}
1260
1261#[allow(deprecated)]
1262impl glib::HasParamSpec for FlapFoldPolicy {
1263 type ParamSpec = glib::ParamSpecEnum;
1264 type SetValue = Self;
1265 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1266
1267 fn param_spec_builder() -> Self::BuilderFn {
1268 Self::ParamSpec::builder_with_default
1269 }
1270}
1271
1272#[allow(deprecated)]
1273impl glib::value::ValueType for FlapFoldPolicy {
1274 type Type = Self;
1275}
1276
1277#[allow(deprecated)]
1278unsafe impl<'a> glib::value::FromValue<'a> for FlapFoldPolicy {
1279 type Checker = glib::value::GenericValueTypeChecker<Self>;
1280
1281 #[inline]
1282 unsafe fn from_value(value: &'a glib::Value) -> Self {
1283 skip_assert_initialized!();
1284 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1285 }
1286}
1287
1288#[allow(deprecated)]
1289impl ToValue for FlapFoldPolicy {
1290 #[inline]
1291 fn to_value(&self) -> glib::Value {
1292 let mut value = glib::Value::for_value_type::<Self>();
1293 unsafe {
1294 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1295 }
1296 value
1297 }
1298
1299 #[inline]
1300 fn value_type(&self) -> glib::Type {
1301 Self::static_type()
1302 }
1303}
1304
1305#[allow(deprecated)]
1306impl From<FlapFoldPolicy> for glib::Value {
1307 #[inline]
1308 fn from(v: FlapFoldPolicy) -> Self {
1309 skip_assert_initialized!();
1310 ToValue::to_value(&v)
1311 }
1312}
1313
1314#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
1315#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1316#[non_exhaustive]
1317#[doc(alias = "AdwFlapTransitionType")]
1318pub enum FlapTransitionType {
1319 #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_OVER")]
1320 Over,
1321 #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_UNDER")]
1322 Under,
1323 #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_SLIDE")]
1324 Slide,
1325 #[doc(hidden)]
1326 __Unknown(i32),
1327}
1328
1329#[allow(deprecated)]
1330#[doc(hidden)]
1331impl IntoGlib for FlapTransitionType {
1332 type GlibType = ffi::AdwFlapTransitionType;
1333
1334 #[inline]
1335 fn into_glib(self) -> ffi::AdwFlapTransitionType {
1336 match self {
1337 Self::Over => ffi::ADW_FLAP_TRANSITION_TYPE_OVER,
1338 Self::Under => ffi::ADW_FLAP_TRANSITION_TYPE_UNDER,
1339 Self::Slide => ffi::ADW_FLAP_TRANSITION_TYPE_SLIDE,
1340 Self::__Unknown(value) => value,
1341 }
1342 }
1343}
1344
1345#[allow(deprecated)]
1346#[doc(hidden)]
1347impl FromGlib<ffi::AdwFlapTransitionType> for FlapTransitionType {
1348 #[inline]
1349 unsafe fn from_glib(value: ffi::AdwFlapTransitionType) -> Self {
1350 skip_assert_initialized!();
1351
1352 match value {
1353 ffi::ADW_FLAP_TRANSITION_TYPE_OVER => Self::Over,
1354 ffi::ADW_FLAP_TRANSITION_TYPE_UNDER => Self::Under,
1355 ffi::ADW_FLAP_TRANSITION_TYPE_SLIDE => Self::Slide,
1356 value => Self::__Unknown(value),
1357 }
1358 }
1359}
1360
1361#[allow(deprecated)]
1362impl StaticType for FlapTransitionType {
1363 #[inline]
1364 #[doc(alias = "adw_flap_transition_type_get_type")]
1365 fn static_type() -> glib::Type {
1366 unsafe { from_glib(ffi::adw_flap_transition_type_get_type()) }
1367 }
1368}
1369
1370#[allow(deprecated)]
1371impl glib::HasParamSpec for FlapTransitionType {
1372 type ParamSpec = glib::ParamSpecEnum;
1373 type SetValue = Self;
1374 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1375
1376 fn param_spec_builder() -> Self::BuilderFn {
1377 Self::ParamSpec::builder_with_default
1378 }
1379}
1380
1381#[allow(deprecated)]
1382impl glib::value::ValueType for FlapTransitionType {
1383 type Type = Self;
1384}
1385
1386#[allow(deprecated)]
1387unsafe impl<'a> glib::value::FromValue<'a> for FlapTransitionType {
1388 type Checker = glib::value::GenericValueTypeChecker<Self>;
1389
1390 #[inline]
1391 unsafe fn from_value(value: &'a glib::Value) -> Self {
1392 skip_assert_initialized!();
1393 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1394 }
1395}
1396
1397#[allow(deprecated)]
1398impl ToValue for FlapTransitionType {
1399 #[inline]
1400 fn to_value(&self) -> glib::Value {
1401 let mut value = glib::Value::for_value_type::<Self>();
1402 unsafe {
1403 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1404 }
1405 value
1406 }
1407
1408 #[inline]
1409 fn value_type(&self) -> glib::Type {
1410 Self::static_type()
1411 }
1412}
1413
1414#[allow(deprecated)]
1415impl From<FlapTransitionType> for glib::Value {
1416 #[inline]
1417 fn from(v: FlapTransitionType) -> Self {
1418 skip_assert_initialized!();
1419 ToValue::to_value(&v)
1420 }
1421}
1422
1423#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
1424#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1425#[non_exhaustive]
1426#[doc(alias = "AdwFoldThresholdPolicy")]
1427pub enum FoldThresholdPolicy {
1428 #[doc(alias = "ADW_FOLD_THRESHOLD_POLICY_MINIMUM")]
1429 Minimum,
1430 #[doc(alias = "ADW_FOLD_THRESHOLD_POLICY_NATURAL")]
1431 Natural,
1432 #[doc(hidden)]
1433 __Unknown(i32),
1434}
1435
1436#[allow(deprecated)]
1437#[doc(hidden)]
1438impl IntoGlib for FoldThresholdPolicy {
1439 type GlibType = ffi::AdwFoldThresholdPolicy;
1440
1441 #[inline]
1442 fn into_glib(self) -> ffi::AdwFoldThresholdPolicy {
1443 match self {
1444 Self::Minimum => ffi::ADW_FOLD_THRESHOLD_POLICY_MINIMUM,
1445 Self::Natural => ffi::ADW_FOLD_THRESHOLD_POLICY_NATURAL,
1446 Self::__Unknown(value) => value,
1447 }
1448 }
1449}
1450
1451#[allow(deprecated)]
1452#[doc(hidden)]
1453impl FromGlib<ffi::AdwFoldThresholdPolicy> for FoldThresholdPolicy {
1454 #[inline]
1455 unsafe fn from_glib(value: ffi::AdwFoldThresholdPolicy) -> Self {
1456 skip_assert_initialized!();
1457
1458 match value {
1459 ffi::ADW_FOLD_THRESHOLD_POLICY_MINIMUM => Self::Minimum,
1460 ffi::ADW_FOLD_THRESHOLD_POLICY_NATURAL => Self::Natural,
1461 value => Self::__Unknown(value),
1462 }
1463 }
1464}
1465
1466#[allow(deprecated)]
1467impl StaticType for FoldThresholdPolicy {
1468 #[inline]
1469 #[doc(alias = "adw_fold_threshold_policy_get_type")]
1470 fn static_type() -> glib::Type {
1471 unsafe { from_glib(ffi::adw_fold_threshold_policy_get_type()) }
1472 }
1473}
1474
1475#[allow(deprecated)]
1476impl glib::HasParamSpec for FoldThresholdPolicy {
1477 type ParamSpec = glib::ParamSpecEnum;
1478 type SetValue = Self;
1479 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1480
1481 fn param_spec_builder() -> Self::BuilderFn {
1482 Self::ParamSpec::builder_with_default
1483 }
1484}
1485
1486#[allow(deprecated)]
1487impl glib::value::ValueType for FoldThresholdPolicy {
1488 type Type = Self;
1489}
1490
1491#[allow(deprecated)]
1492unsafe impl<'a> glib::value::FromValue<'a> for FoldThresholdPolicy {
1493 type Checker = glib::value::GenericValueTypeChecker<Self>;
1494
1495 #[inline]
1496 unsafe fn from_value(value: &'a glib::Value) -> Self {
1497 skip_assert_initialized!();
1498 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1499 }
1500}
1501
1502#[allow(deprecated)]
1503impl ToValue for FoldThresholdPolicy {
1504 #[inline]
1505 fn to_value(&self) -> glib::Value {
1506 let mut value = glib::Value::for_value_type::<Self>();
1507 unsafe {
1508 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1509 }
1510 value
1511 }
1512
1513 #[inline]
1514 fn value_type(&self) -> glib::Type {
1515 Self::static_type()
1516 }
1517}
1518
1519#[allow(deprecated)]
1520impl From<FoldThresholdPolicy> for glib::Value {
1521 #[inline]
1522 fn from(v: FoldThresholdPolicy) -> Self {
1523 skip_assert_initialized!();
1524 ToValue::to_value(&v)
1525 }
1526}
1527
1528#[cfg(feature = "v1_7")]
1529#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1530#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1531#[non_exhaustive]
1532#[doc(alias = "AdwInlineViewSwitcherDisplayMode")]
1533pub enum InlineViewSwitcherDisplayMode {
1534 #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_LABELS")]
1535 Labels,
1536 #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_ICONS")]
1537 Icons,
1538 #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_BOTH")]
1539 Both,
1540 #[doc(hidden)]
1541 __Unknown(i32),
1542}
1543
1544#[cfg(feature = "v1_7")]
1545#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1546#[doc(hidden)]
1547impl IntoGlib for InlineViewSwitcherDisplayMode {
1548 type GlibType = ffi::AdwInlineViewSwitcherDisplayMode;
1549
1550 #[inline]
1551 fn into_glib(self) -> ffi::AdwInlineViewSwitcherDisplayMode {
1552 match self {
1553 Self::Labels => ffi::ADW_INLINE_VIEW_SWITCHER_LABELS,
1554 Self::Icons => ffi::ADW_INLINE_VIEW_SWITCHER_ICONS,
1555 Self::Both => ffi::ADW_INLINE_VIEW_SWITCHER_BOTH,
1556 Self::__Unknown(value) => value,
1557 }
1558 }
1559}
1560
1561#[cfg(feature = "v1_7")]
1562#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1563#[doc(hidden)]
1564impl FromGlib<ffi::AdwInlineViewSwitcherDisplayMode> for InlineViewSwitcherDisplayMode {
1565 #[inline]
1566 unsafe fn from_glib(value: ffi::AdwInlineViewSwitcherDisplayMode) -> Self {
1567 skip_assert_initialized!();
1568
1569 match value {
1570 ffi::ADW_INLINE_VIEW_SWITCHER_LABELS => Self::Labels,
1571 ffi::ADW_INLINE_VIEW_SWITCHER_ICONS => Self::Icons,
1572 ffi::ADW_INLINE_VIEW_SWITCHER_BOTH => Self::Both,
1573 value => Self::__Unknown(value),
1574 }
1575 }
1576}
1577
1578#[cfg(feature = "v1_7")]
1579#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1580impl StaticType for InlineViewSwitcherDisplayMode {
1581 #[inline]
1582 #[doc(alias = "adw_inline_view_switcher_display_mode_get_type")]
1583 fn static_type() -> glib::Type {
1584 unsafe { from_glib(ffi::adw_inline_view_switcher_display_mode_get_type()) }
1585 }
1586}
1587
1588#[cfg(feature = "v1_7")]
1589#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1590impl glib::HasParamSpec for InlineViewSwitcherDisplayMode {
1591 type ParamSpec = glib::ParamSpecEnum;
1592 type SetValue = Self;
1593 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1594
1595 fn param_spec_builder() -> Self::BuilderFn {
1596 Self::ParamSpec::builder_with_default
1597 }
1598}
1599
1600#[cfg(feature = "v1_7")]
1601#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1602impl glib::value::ValueType for InlineViewSwitcherDisplayMode {
1603 type Type = Self;
1604}
1605
1606#[cfg(feature = "v1_7")]
1607#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1608unsafe impl<'a> glib::value::FromValue<'a> for InlineViewSwitcherDisplayMode {
1609 type Checker = glib::value::GenericValueTypeChecker<Self>;
1610
1611 #[inline]
1612 unsafe fn from_value(value: &'a glib::Value) -> Self {
1613 skip_assert_initialized!();
1614 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1615 }
1616}
1617
1618#[cfg(feature = "v1_7")]
1619#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1620impl ToValue for InlineViewSwitcherDisplayMode {
1621 #[inline]
1622 fn to_value(&self) -> glib::Value {
1623 let mut value = glib::Value::for_value_type::<Self>();
1624 unsafe {
1625 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1626 }
1627 value
1628 }
1629
1630 #[inline]
1631 fn value_type(&self) -> glib::Type {
1632 Self::static_type()
1633 }
1634}
1635
1636#[cfg(feature = "v1_7")]
1637#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1638impl From<InlineViewSwitcherDisplayMode> for glib::Value {
1639 #[inline]
1640 fn from(v: InlineViewSwitcherDisplayMode) -> Self {
1641 skip_assert_initialized!();
1642 ToValue::to_value(&v)
1643 }
1644}
1645
1646#[cfg(feature = "v1_7")]
1647#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1648#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1649#[non_exhaustive]
1650#[doc(alias = "AdwJustifyMode")]
1651pub enum JustifyMode {
1652 #[doc(alias = "ADW_JUSTIFY_NONE")]
1653 None,
1654 #[doc(alias = "ADW_JUSTIFY_FILL")]
1655 Fill,
1656 #[doc(alias = "ADW_JUSTIFY_SPREAD")]
1657 Spread,
1658 #[doc(hidden)]
1659 __Unknown(i32),
1660}
1661
1662#[cfg(feature = "v1_7")]
1663#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1664#[doc(hidden)]
1665impl IntoGlib for JustifyMode {
1666 type GlibType = ffi::AdwJustifyMode;
1667
1668 #[inline]
1669 fn into_glib(self) -> ffi::AdwJustifyMode {
1670 match self {
1671 Self::None => ffi::ADW_JUSTIFY_NONE,
1672 Self::Fill => ffi::ADW_JUSTIFY_FILL,
1673 Self::Spread => ffi::ADW_JUSTIFY_SPREAD,
1674 Self::__Unknown(value) => value,
1675 }
1676 }
1677}
1678
1679#[cfg(feature = "v1_7")]
1680#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1681#[doc(hidden)]
1682impl FromGlib<ffi::AdwJustifyMode> for JustifyMode {
1683 #[inline]
1684 unsafe fn from_glib(value: ffi::AdwJustifyMode) -> Self {
1685 skip_assert_initialized!();
1686
1687 match value {
1688 ffi::ADW_JUSTIFY_NONE => Self::None,
1689 ffi::ADW_JUSTIFY_FILL => Self::Fill,
1690 ffi::ADW_JUSTIFY_SPREAD => Self::Spread,
1691 value => Self::__Unknown(value),
1692 }
1693 }
1694}
1695
1696#[cfg(feature = "v1_7")]
1697#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1698impl StaticType for JustifyMode {
1699 #[inline]
1700 #[doc(alias = "adw_justify_mode_get_type")]
1701 fn static_type() -> glib::Type {
1702 unsafe { from_glib(ffi::adw_justify_mode_get_type()) }
1703 }
1704}
1705
1706#[cfg(feature = "v1_7")]
1707#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1708impl glib::HasParamSpec for JustifyMode {
1709 type ParamSpec = glib::ParamSpecEnum;
1710 type SetValue = Self;
1711 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1712
1713 fn param_spec_builder() -> Self::BuilderFn {
1714 Self::ParamSpec::builder_with_default
1715 }
1716}
1717
1718#[cfg(feature = "v1_7")]
1719#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1720impl glib::value::ValueType for JustifyMode {
1721 type Type = Self;
1722}
1723
1724#[cfg(feature = "v1_7")]
1725#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1726unsafe impl<'a> glib::value::FromValue<'a> for JustifyMode {
1727 type Checker = glib::value::GenericValueTypeChecker<Self>;
1728
1729 #[inline]
1730 unsafe fn from_value(value: &'a glib::Value) -> Self {
1731 skip_assert_initialized!();
1732 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1733 }
1734}
1735
1736#[cfg(feature = "v1_7")]
1737#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1738impl ToValue for JustifyMode {
1739 #[inline]
1740 fn to_value(&self) -> glib::Value {
1741 let mut value = glib::Value::for_value_type::<Self>();
1742 unsafe {
1743 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1744 }
1745 value
1746 }
1747
1748 #[inline]
1749 fn value_type(&self) -> glib::Type {
1750 Self::static_type()
1751 }
1752}
1753
1754#[cfg(feature = "v1_7")]
1755#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
1756impl From<JustifyMode> for glib::Value {
1757 #[inline]
1758 fn from(v: JustifyMode) -> Self {
1759 skip_assert_initialized!();
1760 ToValue::to_value(&v)
1761 }
1762}
1763
1764#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
1765#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1766#[non_exhaustive]
1767#[doc(alias = "AdwLeafletTransitionType")]
1768pub enum LeafletTransitionType {
1769 #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_OVER")]
1770 Over,
1771 #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_UNDER")]
1772 Under,
1773 #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_SLIDE")]
1774 Slide,
1775 #[doc(hidden)]
1776 __Unknown(i32),
1777}
1778
1779#[allow(deprecated)]
1780#[doc(hidden)]
1781impl IntoGlib for LeafletTransitionType {
1782 type GlibType = ffi::AdwLeafletTransitionType;
1783
1784 #[inline]
1785 fn into_glib(self) -> ffi::AdwLeafletTransitionType {
1786 match self {
1787 Self::Over => ffi::ADW_LEAFLET_TRANSITION_TYPE_OVER,
1788 Self::Under => ffi::ADW_LEAFLET_TRANSITION_TYPE_UNDER,
1789 Self::Slide => ffi::ADW_LEAFLET_TRANSITION_TYPE_SLIDE,
1790 Self::__Unknown(value) => value,
1791 }
1792 }
1793}
1794
1795#[allow(deprecated)]
1796#[doc(hidden)]
1797impl FromGlib<ffi::AdwLeafletTransitionType> for LeafletTransitionType {
1798 #[inline]
1799 unsafe fn from_glib(value: ffi::AdwLeafletTransitionType) -> Self {
1800 skip_assert_initialized!();
1801
1802 match value {
1803 ffi::ADW_LEAFLET_TRANSITION_TYPE_OVER => Self::Over,
1804 ffi::ADW_LEAFLET_TRANSITION_TYPE_UNDER => Self::Under,
1805 ffi::ADW_LEAFLET_TRANSITION_TYPE_SLIDE => Self::Slide,
1806 value => Self::__Unknown(value),
1807 }
1808 }
1809}
1810
1811#[allow(deprecated)]
1812impl StaticType for LeafletTransitionType {
1813 #[inline]
1814 #[doc(alias = "adw_leaflet_transition_type_get_type")]
1815 fn static_type() -> glib::Type {
1816 unsafe { from_glib(ffi::adw_leaflet_transition_type_get_type()) }
1817 }
1818}
1819
1820#[allow(deprecated)]
1821impl glib::HasParamSpec for LeafletTransitionType {
1822 type ParamSpec = glib::ParamSpecEnum;
1823 type SetValue = Self;
1824 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1825
1826 fn param_spec_builder() -> Self::BuilderFn {
1827 Self::ParamSpec::builder_with_default
1828 }
1829}
1830
1831#[allow(deprecated)]
1832impl glib::value::ValueType for LeafletTransitionType {
1833 type Type = Self;
1834}
1835
1836#[allow(deprecated)]
1837unsafe impl<'a> glib::value::FromValue<'a> for LeafletTransitionType {
1838 type Checker = glib::value::GenericValueTypeChecker<Self>;
1839
1840 #[inline]
1841 unsafe fn from_value(value: &'a glib::Value) -> Self {
1842 skip_assert_initialized!();
1843 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1844 }
1845}
1846
1847#[allow(deprecated)]
1848impl ToValue for LeafletTransitionType {
1849 #[inline]
1850 fn to_value(&self) -> glib::Value {
1851 let mut value = glib::Value::for_value_type::<Self>();
1852 unsafe {
1853 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1854 }
1855 value
1856 }
1857
1858 #[inline]
1859 fn value_type(&self) -> glib::Type {
1860 Self::static_type()
1861 }
1862}
1863
1864#[allow(deprecated)]
1865impl From<LeafletTransitionType> for glib::Value {
1866 #[inline]
1867 fn from(v: LeafletTransitionType) -> Self {
1868 skip_assert_initialized!();
1869 ToValue::to_value(&v)
1870 }
1871}
1872
1873#[cfg(feature = "v1_4")]
1874#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1875#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1876#[non_exhaustive]
1877#[doc(alias = "AdwLengthUnit")]
1878pub enum LengthUnit {
1879 #[doc(alias = "ADW_LENGTH_UNIT_PX")]
1880 Px,
1881 #[doc(alias = "ADW_LENGTH_UNIT_PT")]
1882 Pt,
1883 #[doc(alias = "ADW_LENGTH_UNIT_SP")]
1884 Sp,
1885 #[doc(hidden)]
1886 __Unknown(i32),
1887}
1888
1889#[cfg(feature = "v1_4")]
1890#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1891impl LengthUnit {
1892 #[doc(alias = "adw_length_unit_from_px")]
1893 pub fn from_px(self, value: f64, settings: Option<>k::Settings>) -> f64 {
1894 assert_initialized_main_thread!();
1895 unsafe { ffi::adw_length_unit_from_px(self.into_glib(), value, settings.to_glib_none().0) }
1896 }
1897
1898 #[doc(alias = "adw_length_unit_to_px")]
1899 pub fn to_px(self, value: f64, settings: Option<>k::Settings>) -> f64 {
1900 assert_initialized_main_thread!();
1901 unsafe { ffi::adw_length_unit_to_px(self.into_glib(), value, settings.to_glib_none().0) }
1902 }
1903}
1904
1905#[cfg(feature = "v1_4")]
1906#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1907#[doc(hidden)]
1908impl IntoGlib for LengthUnit {
1909 type GlibType = ffi::AdwLengthUnit;
1910
1911 #[inline]
1912 fn into_glib(self) -> ffi::AdwLengthUnit {
1913 match self {
1914 Self::Px => ffi::ADW_LENGTH_UNIT_PX,
1915 Self::Pt => ffi::ADW_LENGTH_UNIT_PT,
1916 Self::Sp => ffi::ADW_LENGTH_UNIT_SP,
1917 Self::__Unknown(value) => value,
1918 }
1919 }
1920}
1921
1922#[cfg(feature = "v1_4")]
1923#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1924#[doc(hidden)]
1925impl FromGlib<ffi::AdwLengthUnit> for LengthUnit {
1926 #[inline]
1927 unsafe fn from_glib(value: ffi::AdwLengthUnit) -> Self {
1928 skip_assert_initialized!();
1929
1930 match value {
1931 ffi::ADW_LENGTH_UNIT_PX => Self::Px,
1932 ffi::ADW_LENGTH_UNIT_PT => Self::Pt,
1933 ffi::ADW_LENGTH_UNIT_SP => Self::Sp,
1934 value => Self::__Unknown(value),
1935 }
1936 }
1937}
1938
1939#[cfg(feature = "v1_4")]
1940#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1941impl StaticType for LengthUnit {
1942 #[inline]
1943 #[doc(alias = "adw_length_unit_get_type")]
1944 fn static_type() -> glib::Type {
1945 unsafe { from_glib(ffi::adw_length_unit_get_type()) }
1946 }
1947}
1948
1949#[cfg(feature = "v1_4")]
1950#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1951impl glib::HasParamSpec for LengthUnit {
1952 type ParamSpec = glib::ParamSpecEnum;
1953 type SetValue = Self;
1954 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1955
1956 fn param_spec_builder() -> Self::BuilderFn {
1957 Self::ParamSpec::builder_with_default
1958 }
1959}
1960
1961#[cfg(feature = "v1_4")]
1962#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1963impl glib::value::ValueType for LengthUnit {
1964 type Type = Self;
1965}
1966
1967#[cfg(feature = "v1_4")]
1968#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1969unsafe impl<'a> glib::value::FromValue<'a> for LengthUnit {
1970 type Checker = glib::value::GenericValueTypeChecker<Self>;
1971
1972 #[inline]
1973 unsafe fn from_value(value: &'a glib::Value) -> Self {
1974 skip_assert_initialized!();
1975 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1976 }
1977}
1978
1979#[cfg(feature = "v1_4")]
1980#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1981impl ToValue for LengthUnit {
1982 #[inline]
1983 fn to_value(&self) -> glib::Value {
1984 let mut value = glib::Value::for_value_type::<Self>();
1985 unsafe {
1986 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1987 }
1988 value
1989 }
1990
1991 #[inline]
1992 fn value_type(&self) -> glib::Type {
1993 Self::static_type()
1994 }
1995}
1996
1997#[cfg(feature = "v1_4")]
1998#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
1999impl From<LengthUnit> for glib::Value {
2000 #[inline]
2001 fn from(v: LengthUnit) -> Self {
2002 skip_assert_initialized!();
2003 ToValue::to_value(&v)
2004 }
2005}
2006
2007#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2008#[non_exhaustive]
2009#[doc(alias = "AdwNavigationDirection")]
2010pub enum NavigationDirection {
2011 #[doc(alias = "ADW_NAVIGATION_DIRECTION_BACK")]
2012 Back,
2013 #[doc(alias = "ADW_NAVIGATION_DIRECTION_FORWARD")]
2014 Forward,
2015 #[doc(hidden)]
2016 __Unknown(i32),
2017}
2018
2019#[doc(hidden)]
2020impl IntoGlib for NavigationDirection {
2021 type GlibType = ffi::AdwNavigationDirection;
2022
2023 #[inline]
2024 fn into_glib(self) -> ffi::AdwNavigationDirection {
2025 match self {
2026 Self::Back => ffi::ADW_NAVIGATION_DIRECTION_BACK,
2027 Self::Forward => ffi::ADW_NAVIGATION_DIRECTION_FORWARD,
2028 Self::__Unknown(value) => value,
2029 }
2030 }
2031}
2032
2033#[doc(hidden)]
2034impl FromGlib<ffi::AdwNavigationDirection> for NavigationDirection {
2035 #[inline]
2036 unsafe fn from_glib(value: ffi::AdwNavigationDirection) -> Self {
2037 skip_assert_initialized!();
2038
2039 match value {
2040 ffi::ADW_NAVIGATION_DIRECTION_BACK => Self::Back,
2041 ffi::ADW_NAVIGATION_DIRECTION_FORWARD => Self::Forward,
2042 value => Self::__Unknown(value),
2043 }
2044 }
2045}
2046
2047impl StaticType for NavigationDirection {
2048 #[inline]
2049 #[doc(alias = "adw_navigation_direction_get_type")]
2050 fn static_type() -> glib::Type {
2051 unsafe { from_glib(ffi::adw_navigation_direction_get_type()) }
2052 }
2053}
2054
2055impl glib::HasParamSpec for NavigationDirection {
2056 type ParamSpec = glib::ParamSpecEnum;
2057 type SetValue = Self;
2058 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2059
2060 fn param_spec_builder() -> Self::BuilderFn {
2061 Self::ParamSpec::builder_with_default
2062 }
2063}
2064
2065impl glib::value::ValueType for NavigationDirection {
2066 type Type = Self;
2067}
2068
2069unsafe impl<'a> glib::value::FromValue<'a> for NavigationDirection {
2070 type Checker = glib::value::GenericValueTypeChecker<Self>;
2071
2072 #[inline]
2073 unsafe fn from_value(value: &'a glib::Value) -> Self {
2074 skip_assert_initialized!();
2075 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2076 }
2077}
2078
2079impl ToValue for NavigationDirection {
2080 #[inline]
2081 fn to_value(&self) -> glib::Value {
2082 let mut value = glib::Value::for_value_type::<Self>();
2083 unsafe {
2084 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2085 }
2086 value
2087 }
2088
2089 #[inline]
2090 fn value_type(&self) -> glib::Type {
2091 Self::static_type()
2092 }
2093}
2094
2095impl From<NavigationDirection> for glib::Value {
2096 #[inline]
2097 fn from(v: NavigationDirection) -> Self {
2098 skip_assert_initialized!();
2099 ToValue::to_value(&v)
2100 }
2101}
2102
2103#[cfg(feature = "v1_7")]
2104#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2105#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2106#[non_exhaustive]
2107#[doc(alias = "AdwPackDirection")]
2108pub enum PackDirection {
2109 #[doc(alias = "ADW_PACK_START_TO_END")]
2110 StartToEnd,
2111 #[doc(alias = "ADW_PACK_END_TO_START")]
2112 EndToStart,
2113 #[doc(hidden)]
2114 __Unknown(i32),
2115}
2116
2117#[cfg(feature = "v1_7")]
2118#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2119#[doc(hidden)]
2120impl IntoGlib for PackDirection {
2121 type GlibType = ffi::AdwPackDirection;
2122
2123 #[inline]
2124 fn into_glib(self) -> ffi::AdwPackDirection {
2125 match self {
2126 Self::StartToEnd => ffi::ADW_PACK_START_TO_END,
2127 Self::EndToStart => ffi::ADW_PACK_END_TO_START,
2128 Self::__Unknown(value) => value,
2129 }
2130 }
2131}
2132
2133#[cfg(feature = "v1_7")]
2134#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2135#[doc(hidden)]
2136impl FromGlib<ffi::AdwPackDirection> for PackDirection {
2137 #[inline]
2138 unsafe fn from_glib(value: ffi::AdwPackDirection) -> Self {
2139 skip_assert_initialized!();
2140
2141 match value {
2142 ffi::ADW_PACK_START_TO_END => Self::StartToEnd,
2143 ffi::ADW_PACK_END_TO_START => Self::EndToStart,
2144 value => Self::__Unknown(value),
2145 }
2146 }
2147}
2148
2149#[cfg(feature = "v1_7")]
2150#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2151impl StaticType for PackDirection {
2152 #[inline]
2153 #[doc(alias = "adw_pack_direction_get_type")]
2154 fn static_type() -> glib::Type {
2155 unsafe { from_glib(ffi::adw_pack_direction_get_type()) }
2156 }
2157}
2158
2159#[cfg(feature = "v1_7")]
2160#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2161impl glib::HasParamSpec for PackDirection {
2162 type ParamSpec = glib::ParamSpecEnum;
2163 type SetValue = Self;
2164 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2165
2166 fn param_spec_builder() -> Self::BuilderFn {
2167 Self::ParamSpec::builder_with_default
2168 }
2169}
2170
2171#[cfg(feature = "v1_7")]
2172#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2173impl glib::value::ValueType for PackDirection {
2174 type Type = Self;
2175}
2176
2177#[cfg(feature = "v1_7")]
2178#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2179unsafe impl<'a> glib::value::FromValue<'a> for PackDirection {
2180 type Checker = glib::value::GenericValueTypeChecker<Self>;
2181
2182 #[inline]
2183 unsafe fn from_value(value: &'a glib::Value) -> Self {
2184 skip_assert_initialized!();
2185 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2186 }
2187}
2188
2189#[cfg(feature = "v1_7")]
2190#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2191impl ToValue for PackDirection {
2192 #[inline]
2193 fn to_value(&self) -> glib::Value {
2194 let mut value = glib::Value::for_value_type::<Self>();
2195 unsafe {
2196 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2197 }
2198 value
2199 }
2200
2201 #[inline]
2202 fn value_type(&self) -> glib::Type {
2203 Self::static_type()
2204 }
2205}
2206
2207#[cfg(feature = "v1_7")]
2208#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2209impl From<PackDirection> for glib::Value {
2210 #[inline]
2211 fn from(v: PackDirection) -> Self {
2212 skip_assert_initialized!();
2213 ToValue::to_value(&v)
2214 }
2215}
2216
2217#[cfg(feature = "v1_2")]
2218#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2219#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2220#[non_exhaustive]
2221#[doc(alias = "AdwResponseAppearance")]
2222pub enum ResponseAppearance {
2223 #[doc(alias = "ADW_RESPONSE_DEFAULT")]
2224 Default,
2225 #[doc(alias = "ADW_RESPONSE_SUGGESTED")]
2226 Suggested,
2227 #[doc(alias = "ADW_RESPONSE_DESTRUCTIVE")]
2228 Destructive,
2229 #[doc(hidden)]
2230 __Unknown(i32),
2231}
2232
2233#[cfg(feature = "v1_2")]
2234#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2235#[doc(hidden)]
2236impl IntoGlib for ResponseAppearance {
2237 type GlibType = ffi::AdwResponseAppearance;
2238
2239 #[inline]
2240 fn into_glib(self) -> ffi::AdwResponseAppearance {
2241 match self {
2242 Self::Default => ffi::ADW_RESPONSE_DEFAULT,
2243 Self::Suggested => ffi::ADW_RESPONSE_SUGGESTED,
2244 Self::Destructive => ffi::ADW_RESPONSE_DESTRUCTIVE,
2245 Self::__Unknown(value) => value,
2246 }
2247 }
2248}
2249
2250#[cfg(feature = "v1_2")]
2251#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2252#[doc(hidden)]
2253impl FromGlib<ffi::AdwResponseAppearance> for ResponseAppearance {
2254 #[inline]
2255 unsafe fn from_glib(value: ffi::AdwResponseAppearance) -> Self {
2256 skip_assert_initialized!();
2257
2258 match value {
2259 ffi::ADW_RESPONSE_DEFAULT => Self::Default,
2260 ffi::ADW_RESPONSE_SUGGESTED => Self::Suggested,
2261 ffi::ADW_RESPONSE_DESTRUCTIVE => Self::Destructive,
2262 value => Self::__Unknown(value),
2263 }
2264 }
2265}
2266
2267#[cfg(feature = "v1_2")]
2268#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2269impl StaticType for ResponseAppearance {
2270 #[inline]
2271 #[doc(alias = "adw_response_appearance_get_type")]
2272 fn static_type() -> glib::Type {
2273 unsafe { from_glib(ffi::adw_response_appearance_get_type()) }
2274 }
2275}
2276
2277#[cfg(feature = "v1_2")]
2278#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2279impl glib::HasParamSpec for ResponseAppearance {
2280 type ParamSpec = glib::ParamSpecEnum;
2281 type SetValue = Self;
2282 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2283
2284 fn param_spec_builder() -> Self::BuilderFn {
2285 Self::ParamSpec::builder_with_default
2286 }
2287}
2288
2289#[cfg(feature = "v1_2")]
2290#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2291impl glib::value::ValueType for ResponseAppearance {
2292 type Type = Self;
2293}
2294
2295#[cfg(feature = "v1_2")]
2296#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2297unsafe impl<'a> glib::value::FromValue<'a> for ResponseAppearance {
2298 type Checker = glib::value::GenericValueTypeChecker<Self>;
2299
2300 #[inline]
2301 unsafe fn from_value(value: &'a glib::Value) -> Self {
2302 skip_assert_initialized!();
2303 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2304 }
2305}
2306
2307#[cfg(feature = "v1_2")]
2308#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2309impl ToValue for ResponseAppearance {
2310 #[inline]
2311 fn to_value(&self) -> glib::Value {
2312 let mut value = glib::Value::for_value_type::<Self>();
2313 unsafe {
2314 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2315 }
2316 value
2317 }
2318
2319 #[inline]
2320 fn value_type(&self) -> glib::Type {
2321 Self::static_type()
2322 }
2323}
2324
2325#[cfg(feature = "v1_2")]
2326#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2327impl From<ResponseAppearance> for glib::Value {
2328 #[inline]
2329 fn from(v: ResponseAppearance) -> Self {
2330 skip_assert_initialized!();
2331 ToValue::to_value(&v)
2332 }
2333}
2334
2335#[cfg(feature = "v1_9")]
2336#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2337#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2338#[non_exhaustive]
2339#[doc(alias = "AdwSidebarMode")]
2340pub enum SidebarMode {
2341 #[doc(alias = "ADW_SIDEBAR_MODE_SIDEBAR")]
2342 Sidebar,
2343 #[doc(alias = "ADW_SIDEBAR_MODE_PAGE")]
2344 Page,
2345 #[doc(hidden)]
2346 __Unknown(i32),
2347}
2348
2349#[cfg(feature = "v1_9")]
2350#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2351#[doc(hidden)]
2352impl IntoGlib for SidebarMode {
2353 type GlibType = ffi::AdwSidebarMode;
2354
2355 #[inline]
2356 fn into_glib(self) -> ffi::AdwSidebarMode {
2357 match self {
2358 Self::Sidebar => ffi::ADW_SIDEBAR_MODE_SIDEBAR,
2359 Self::Page => ffi::ADW_SIDEBAR_MODE_PAGE,
2360 Self::__Unknown(value) => value,
2361 }
2362 }
2363}
2364
2365#[cfg(feature = "v1_9")]
2366#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2367#[doc(hidden)]
2368impl FromGlib<ffi::AdwSidebarMode> for SidebarMode {
2369 #[inline]
2370 unsafe fn from_glib(value: ffi::AdwSidebarMode) -> Self {
2371 skip_assert_initialized!();
2372
2373 match value {
2374 ffi::ADW_SIDEBAR_MODE_SIDEBAR => Self::Sidebar,
2375 ffi::ADW_SIDEBAR_MODE_PAGE => Self::Page,
2376 value => Self::__Unknown(value),
2377 }
2378 }
2379}
2380
2381#[cfg(feature = "v1_9")]
2382#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2383impl StaticType for SidebarMode {
2384 #[inline]
2385 #[doc(alias = "adw_sidebar_mode_get_type")]
2386 fn static_type() -> glib::Type {
2387 unsafe { from_glib(ffi::adw_sidebar_mode_get_type()) }
2388 }
2389}
2390
2391#[cfg(feature = "v1_9")]
2392#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2393impl glib::HasParamSpec for SidebarMode {
2394 type ParamSpec = glib::ParamSpecEnum;
2395 type SetValue = Self;
2396 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2397
2398 fn param_spec_builder() -> Self::BuilderFn {
2399 Self::ParamSpec::builder_with_default
2400 }
2401}
2402
2403#[cfg(feature = "v1_9")]
2404#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2405impl glib::value::ValueType for SidebarMode {
2406 type Type = Self;
2407}
2408
2409#[cfg(feature = "v1_9")]
2410#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2411unsafe impl<'a> glib::value::FromValue<'a> for SidebarMode {
2412 type Checker = glib::value::GenericValueTypeChecker<Self>;
2413
2414 #[inline]
2415 unsafe fn from_value(value: &'a glib::Value) -> Self {
2416 skip_assert_initialized!();
2417 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2418 }
2419}
2420
2421#[cfg(feature = "v1_9")]
2422#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2423impl ToValue for SidebarMode {
2424 #[inline]
2425 fn to_value(&self) -> glib::Value {
2426 let mut value = glib::Value::for_value_type::<Self>();
2427 unsafe {
2428 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2429 }
2430 value
2431 }
2432
2433 #[inline]
2434 fn value_type(&self) -> glib::Type {
2435 Self::static_type()
2436 }
2437}
2438
2439#[cfg(feature = "v1_9")]
2440#[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2441impl From<SidebarMode> for glib::Value {
2442 #[inline]
2443 fn from(v: SidebarMode) -> Self {
2444 skip_assert_initialized!();
2445 ToValue::to_value(&v)
2446 }
2447}
2448
2449#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
2450#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2451#[non_exhaustive]
2452#[doc(alias = "AdwSqueezerTransitionType")]
2453pub enum SqueezerTransitionType {
2454 #[doc(alias = "ADW_SQUEEZER_TRANSITION_TYPE_NONE")]
2455 None,
2456 #[doc(alias = "ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE")]
2457 Crossfade,
2458 #[doc(hidden)]
2459 __Unknown(i32),
2460}
2461
2462#[allow(deprecated)]
2463#[doc(hidden)]
2464impl IntoGlib for SqueezerTransitionType {
2465 type GlibType = ffi::AdwSqueezerTransitionType;
2466
2467 #[inline]
2468 fn into_glib(self) -> ffi::AdwSqueezerTransitionType {
2469 match self {
2470 Self::None => ffi::ADW_SQUEEZER_TRANSITION_TYPE_NONE,
2471 Self::Crossfade => ffi::ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE,
2472 Self::__Unknown(value) => value,
2473 }
2474 }
2475}
2476
2477#[allow(deprecated)]
2478#[doc(hidden)]
2479impl FromGlib<ffi::AdwSqueezerTransitionType> for SqueezerTransitionType {
2480 #[inline]
2481 unsafe fn from_glib(value: ffi::AdwSqueezerTransitionType) -> Self {
2482 skip_assert_initialized!();
2483
2484 match value {
2485 ffi::ADW_SQUEEZER_TRANSITION_TYPE_NONE => Self::None,
2486 ffi::ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
2487 value => Self::__Unknown(value),
2488 }
2489 }
2490}
2491
2492#[allow(deprecated)]
2493impl StaticType for SqueezerTransitionType {
2494 #[inline]
2495 #[doc(alias = "adw_squeezer_transition_type_get_type")]
2496 fn static_type() -> glib::Type {
2497 unsafe { from_glib(ffi::adw_squeezer_transition_type_get_type()) }
2498 }
2499}
2500
2501#[allow(deprecated)]
2502impl glib::HasParamSpec for SqueezerTransitionType {
2503 type ParamSpec = glib::ParamSpecEnum;
2504 type SetValue = Self;
2505 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2506
2507 fn param_spec_builder() -> Self::BuilderFn {
2508 Self::ParamSpec::builder_with_default
2509 }
2510}
2511
2512#[allow(deprecated)]
2513impl glib::value::ValueType for SqueezerTransitionType {
2514 type Type = Self;
2515}
2516
2517#[allow(deprecated)]
2518unsafe impl<'a> glib::value::FromValue<'a> for SqueezerTransitionType {
2519 type Checker = glib::value::GenericValueTypeChecker<Self>;
2520
2521 #[inline]
2522 unsafe fn from_value(value: &'a glib::Value) -> Self {
2523 skip_assert_initialized!();
2524 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2525 }
2526}
2527
2528#[allow(deprecated)]
2529impl ToValue for SqueezerTransitionType {
2530 #[inline]
2531 fn to_value(&self) -> glib::Value {
2532 let mut value = glib::Value::for_value_type::<Self>();
2533 unsafe {
2534 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2535 }
2536 value
2537 }
2538
2539 #[inline]
2540 fn value_type(&self) -> glib::Type {
2541 Self::static_type()
2542 }
2543}
2544
2545#[allow(deprecated)]
2546impl From<SqueezerTransitionType> for glib::Value {
2547 #[inline]
2548 fn from(v: SqueezerTransitionType) -> Self {
2549 skip_assert_initialized!();
2550 ToValue::to_value(&v)
2551 }
2552}
2553
2554#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2555#[non_exhaustive]
2556#[doc(alias = "AdwToastPriority")]
2557pub enum ToastPriority {
2558 #[doc(alias = "ADW_TOAST_PRIORITY_NORMAL")]
2559 Normal,
2560 #[doc(alias = "ADW_TOAST_PRIORITY_HIGH")]
2561 High,
2562 #[doc(hidden)]
2563 __Unknown(i32),
2564}
2565
2566#[doc(hidden)]
2567impl IntoGlib for ToastPriority {
2568 type GlibType = ffi::AdwToastPriority;
2569
2570 #[inline]
2571 fn into_glib(self) -> ffi::AdwToastPriority {
2572 match self {
2573 Self::Normal => ffi::ADW_TOAST_PRIORITY_NORMAL,
2574 Self::High => ffi::ADW_TOAST_PRIORITY_HIGH,
2575 Self::__Unknown(value) => value,
2576 }
2577 }
2578}
2579
2580#[doc(hidden)]
2581impl FromGlib<ffi::AdwToastPriority> for ToastPriority {
2582 #[inline]
2583 unsafe fn from_glib(value: ffi::AdwToastPriority) -> Self {
2584 skip_assert_initialized!();
2585
2586 match value {
2587 ffi::ADW_TOAST_PRIORITY_NORMAL => Self::Normal,
2588 ffi::ADW_TOAST_PRIORITY_HIGH => Self::High,
2589 value => Self::__Unknown(value),
2590 }
2591 }
2592}
2593
2594impl StaticType for ToastPriority {
2595 #[inline]
2596 #[doc(alias = "adw_toast_priority_get_type")]
2597 fn static_type() -> glib::Type {
2598 unsafe { from_glib(ffi::adw_toast_priority_get_type()) }
2599 }
2600}
2601
2602impl glib::HasParamSpec for ToastPriority {
2603 type ParamSpec = glib::ParamSpecEnum;
2604 type SetValue = Self;
2605 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2606
2607 fn param_spec_builder() -> Self::BuilderFn {
2608 Self::ParamSpec::builder_with_default
2609 }
2610}
2611
2612impl glib::value::ValueType for ToastPriority {
2613 type Type = Self;
2614}
2615
2616unsafe impl<'a> glib::value::FromValue<'a> for ToastPriority {
2617 type Checker = glib::value::GenericValueTypeChecker<Self>;
2618
2619 #[inline]
2620 unsafe fn from_value(value: &'a glib::Value) -> Self {
2621 skip_assert_initialized!();
2622 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2623 }
2624}
2625
2626impl ToValue for ToastPriority {
2627 #[inline]
2628 fn to_value(&self) -> glib::Value {
2629 let mut value = glib::Value::for_value_type::<Self>();
2630 unsafe {
2631 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2632 }
2633 value
2634 }
2635
2636 #[inline]
2637 fn value_type(&self) -> glib::Type {
2638 Self::static_type()
2639 }
2640}
2641
2642impl From<ToastPriority> for glib::Value {
2643 #[inline]
2644 fn from(v: ToastPriority) -> Self {
2645 skip_assert_initialized!();
2646 ToValue::to_value(&v)
2647 }
2648}
2649
2650#[cfg(feature = "v1_4")]
2651#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2652#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2653#[non_exhaustive]
2654#[doc(alias = "AdwToolbarStyle")]
2655pub enum ToolbarStyle {
2656 #[doc(alias = "ADW_TOOLBAR_FLAT")]
2657 Flat,
2658 #[doc(alias = "ADW_TOOLBAR_RAISED")]
2659 Raised,
2660 #[doc(alias = "ADW_TOOLBAR_RAISED_BORDER")]
2661 RaisedBorder,
2662 #[doc(hidden)]
2663 __Unknown(i32),
2664}
2665
2666#[cfg(feature = "v1_4")]
2667#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2668#[doc(hidden)]
2669impl IntoGlib for ToolbarStyle {
2670 type GlibType = ffi::AdwToolbarStyle;
2671
2672 #[inline]
2673 fn into_glib(self) -> ffi::AdwToolbarStyle {
2674 match self {
2675 Self::Flat => ffi::ADW_TOOLBAR_FLAT,
2676 Self::Raised => ffi::ADW_TOOLBAR_RAISED,
2677 Self::RaisedBorder => ffi::ADW_TOOLBAR_RAISED_BORDER,
2678 Self::__Unknown(value) => value,
2679 }
2680 }
2681}
2682
2683#[cfg(feature = "v1_4")]
2684#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2685#[doc(hidden)]
2686impl FromGlib<ffi::AdwToolbarStyle> for ToolbarStyle {
2687 #[inline]
2688 unsafe fn from_glib(value: ffi::AdwToolbarStyle) -> Self {
2689 skip_assert_initialized!();
2690
2691 match value {
2692 ffi::ADW_TOOLBAR_FLAT => Self::Flat,
2693 ffi::ADW_TOOLBAR_RAISED => Self::Raised,
2694 ffi::ADW_TOOLBAR_RAISED_BORDER => Self::RaisedBorder,
2695 value => Self::__Unknown(value),
2696 }
2697 }
2698}
2699
2700#[cfg(feature = "v1_4")]
2701#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2702impl StaticType for ToolbarStyle {
2703 #[inline]
2704 #[doc(alias = "adw_toolbar_style_get_type")]
2705 fn static_type() -> glib::Type {
2706 unsafe { from_glib(ffi::adw_toolbar_style_get_type()) }
2707 }
2708}
2709
2710#[cfg(feature = "v1_4")]
2711#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2712impl glib::HasParamSpec for ToolbarStyle {
2713 type ParamSpec = glib::ParamSpecEnum;
2714 type SetValue = Self;
2715 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2716
2717 fn param_spec_builder() -> Self::BuilderFn {
2718 Self::ParamSpec::builder_with_default
2719 }
2720}
2721
2722#[cfg(feature = "v1_4")]
2723#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2724impl glib::value::ValueType for ToolbarStyle {
2725 type Type = Self;
2726}
2727
2728#[cfg(feature = "v1_4")]
2729#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2730unsafe impl<'a> glib::value::FromValue<'a> for ToolbarStyle {
2731 type Checker = glib::value::GenericValueTypeChecker<Self>;
2732
2733 #[inline]
2734 unsafe fn from_value(value: &'a glib::Value) -> Self {
2735 skip_assert_initialized!();
2736 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2737 }
2738}
2739
2740#[cfg(feature = "v1_4")]
2741#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2742impl ToValue for ToolbarStyle {
2743 #[inline]
2744 fn to_value(&self) -> glib::Value {
2745 let mut value = glib::Value::for_value_type::<Self>();
2746 unsafe {
2747 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2748 }
2749 value
2750 }
2751
2752 #[inline]
2753 fn value_type(&self) -> glib::Type {
2754 Self::static_type()
2755 }
2756}
2757
2758#[cfg(feature = "v1_4")]
2759#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2760impl From<ToolbarStyle> for glib::Value {
2761 #[inline]
2762 fn from(v: ToolbarStyle) -> Self {
2763 skip_assert_initialized!();
2764 ToValue::to_value(&v)
2765 }
2766}
2767
2768#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2769#[non_exhaustive]
2770#[doc(alias = "AdwViewSwitcherPolicy")]
2771pub enum ViewSwitcherPolicy {
2772 #[doc(alias = "ADW_VIEW_SWITCHER_POLICY_NARROW")]
2773 Narrow,
2774 #[doc(alias = "ADW_VIEW_SWITCHER_POLICY_WIDE")]
2775 Wide,
2776 #[doc(hidden)]
2777 __Unknown(i32),
2778}
2779
2780#[doc(hidden)]
2781impl IntoGlib for ViewSwitcherPolicy {
2782 type GlibType = ffi::AdwViewSwitcherPolicy;
2783
2784 #[inline]
2785 fn into_glib(self) -> ffi::AdwViewSwitcherPolicy {
2786 match self {
2787 Self::Narrow => ffi::ADW_VIEW_SWITCHER_POLICY_NARROW,
2788 Self::Wide => ffi::ADW_VIEW_SWITCHER_POLICY_WIDE,
2789 Self::__Unknown(value) => value,
2790 }
2791 }
2792}
2793
2794#[doc(hidden)]
2795impl FromGlib<ffi::AdwViewSwitcherPolicy> for ViewSwitcherPolicy {
2796 #[inline]
2797 unsafe fn from_glib(value: ffi::AdwViewSwitcherPolicy) -> Self {
2798 skip_assert_initialized!();
2799
2800 match value {
2801 ffi::ADW_VIEW_SWITCHER_POLICY_NARROW => Self::Narrow,
2802 ffi::ADW_VIEW_SWITCHER_POLICY_WIDE => Self::Wide,
2803 value => Self::__Unknown(value),
2804 }
2805 }
2806}
2807
2808impl StaticType for ViewSwitcherPolicy {
2809 #[inline]
2810 #[doc(alias = "adw_view_switcher_policy_get_type")]
2811 fn static_type() -> glib::Type {
2812 unsafe { from_glib(ffi::adw_view_switcher_policy_get_type()) }
2813 }
2814}
2815
2816impl glib::HasParamSpec for ViewSwitcherPolicy {
2817 type ParamSpec = glib::ParamSpecEnum;
2818 type SetValue = Self;
2819 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2820
2821 fn param_spec_builder() -> Self::BuilderFn {
2822 Self::ParamSpec::builder_with_default
2823 }
2824}
2825
2826impl glib::value::ValueType for ViewSwitcherPolicy {
2827 type Type = Self;
2828}
2829
2830unsafe impl<'a> glib::value::FromValue<'a> for ViewSwitcherPolicy {
2831 type Checker = glib::value::GenericValueTypeChecker<Self>;
2832
2833 #[inline]
2834 unsafe fn from_value(value: &'a glib::Value) -> Self {
2835 skip_assert_initialized!();
2836 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2837 }
2838}
2839
2840impl ToValue for ViewSwitcherPolicy {
2841 #[inline]
2842 fn to_value(&self) -> glib::Value {
2843 let mut value = glib::Value::for_value_type::<Self>();
2844 unsafe {
2845 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2846 }
2847 value
2848 }
2849
2850 #[inline]
2851 fn value_type(&self) -> glib::Type {
2852 Self::static_type()
2853 }
2854}
2855
2856impl From<ViewSwitcherPolicy> for glib::Value {
2857 #[inline]
2858 fn from(v: ViewSwitcherPolicy) -> Self {
2859 skip_assert_initialized!();
2860 ToValue::to_value(&v)
2861 }
2862}
2863
2864#[cfg(feature = "v1_7")]
2865#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2866#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2867#[non_exhaustive]
2868#[doc(alias = "AdwWrapPolicy")]
2869pub enum WrapPolicy {
2870 #[doc(alias = "ADW_WRAP_MINIMUM")]
2871 Minimum,
2872 #[doc(alias = "ADW_WRAP_NATURAL")]
2873 Natural,
2874 #[doc(hidden)]
2875 __Unknown(i32),
2876}
2877
2878#[cfg(feature = "v1_7")]
2879#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2880#[doc(hidden)]
2881impl IntoGlib for WrapPolicy {
2882 type GlibType = ffi::AdwWrapPolicy;
2883
2884 #[inline]
2885 fn into_glib(self) -> ffi::AdwWrapPolicy {
2886 match self {
2887 Self::Minimum => ffi::ADW_WRAP_MINIMUM,
2888 Self::Natural => ffi::ADW_WRAP_NATURAL,
2889 Self::__Unknown(value) => value,
2890 }
2891 }
2892}
2893
2894#[cfg(feature = "v1_7")]
2895#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2896#[doc(hidden)]
2897impl FromGlib<ffi::AdwWrapPolicy> for WrapPolicy {
2898 #[inline]
2899 unsafe fn from_glib(value: ffi::AdwWrapPolicy) -> Self {
2900 skip_assert_initialized!();
2901
2902 match value {
2903 ffi::ADW_WRAP_MINIMUM => Self::Minimum,
2904 ffi::ADW_WRAP_NATURAL => Self::Natural,
2905 value => Self::__Unknown(value),
2906 }
2907 }
2908}
2909
2910#[cfg(feature = "v1_7")]
2911#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2912impl StaticType for WrapPolicy {
2913 #[inline]
2914 #[doc(alias = "adw_wrap_policy_get_type")]
2915 fn static_type() -> glib::Type {
2916 unsafe { from_glib(ffi::adw_wrap_policy_get_type()) }
2917 }
2918}
2919
2920#[cfg(feature = "v1_7")]
2921#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2922impl glib::HasParamSpec for WrapPolicy {
2923 type ParamSpec = glib::ParamSpecEnum;
2924 type SetValue = Self;
2925 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2926
2927 fn param_spec_builder() -> Self::BuilderFn {
2928 Self::ParamSpec::builder_with_default
2929 }
2930}
2931
2932#[cfg(feature = "v1_7")]
2933#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2934impl glib::value::ValueType for WrapPolicy {
2935 type Type = Self;
2936}
2937
2938#[cfg(feature = "v1_7")]
2939#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2940unsafe impl<'a> glib::value::FromValue<'a> for WrapPolicy {
2941 type Checker = glib::value::GenericValueTypeChecker<Self>;
2942
2943 #[inline]
2944 unsafe fn from_value(value: &'a glib::Value) -> Self {
2945 skip_assert_initialized!();
2946 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2947 }
2948}
2949
2950#[cfg(feature = "v1_7")]
2951#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2952impl ToValue for WrapPolicy {
2953 #[inline]
2954 fn to_value(&self) -> glib::Value {
2955 let mut value = glib::Value::for_value_type::<Self>();
2956 unsafe {
2957 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2958 }
2959 value
2960 }
2961
2962 #[inline]
2963 fn value_type(&self) -> glib::Type {
2964 Self::static_type()
2965 }
2966}
2967
2968#[cfg(feature = "v1_7")]
2969#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2970impl From<WrapPolicy> for glib::Value {
2971 #[inline]
2972 fn from(v: WrapPolicy) -> Self {
2973 skip_assert_initialized!();
2974 ToValue::to_value(&v)
2975 }
2976}