1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use glib::{translate::*, value::FromValue, value::ToValue, StaticType, Type};
use std::fmt;

/// The area of the panel.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "PanelArea")]
pub enum Area {
    /// the area of the panel that is at the horizontal
    ///  start. The side is defined by the direction of the user
    ///  language. In English, it is the left side.
    #[doc(alias = "PANEL_AREA_START")]
    Start,
    /// the area of the panel that is at the end.
    #[doc(alias = "PANEL_AREA_END")]
    End,
    /// the area at the top of the panel.
    #[doc(alias = "PANEL_AREA_TOP")]
    Top,
    /// the area at the bottom of the panel.
    #[doc(alias = "PANEL_AREA_BOTTOM")]
    Bottom,
    /// the area that would be considered as the main area, always
    ///  revealed.
    #[doc(alias = "PANEL_AREA_CENTER")]
    Center,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for Area {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Area::{}",
            match *self {
                Self::Start => "Start",
                Self::End => "End",
                Self::Top => "Top",
                Self::Bottom => "Bottom",
                Self::Center => "Center",
                _ => "Unknown",
            }
        )
    }
}

#[doc(hidden)]
impl IntoGlib for Area {
    type GlibType = ffi::PanelArea;

    #[inline]
    fn into_glib(self) -> ffi::PanelArea {
        match self {
            Self::Start => ffi::PANEL_AREA_START,
            Self::End => ffi::PANEL_AREA_END,
            Self::Top => ffi::PANEL_AREA_TOP,
            Self::Bottom => ffi::PANEL_AREA_BOTTOM,
            Self::Center => ffi::PANEL_AREA_CENTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::PanelArea> for Area {
    #[inline]
    unsafe fn from_glib(value: ffi::PanelArea) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::PANEL_AREA_START => Self::Start,
            ffi::PANEL_AREA_END => Self::End,
            ffi::PANEL_AREA_TOP => Self::Top,
            ffi::PANEL_AREA_BOTTOM => Self::Bottom,
            ffi::PANEL_AREA_CENTER => Self::Center,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Area {
    #[inline]
    fn static_type() -> Type {
        unsafe { from_glib(ffi::panel_area_get_type()) }
    }
}

impl glib::HasParamSpec for Area {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name, default_value| Self::ParamSpec::builder_with_default(name, default_value)
    }
}

impl glib::value::ValueType for Area {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for Area {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

impl ToValue for Area {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Area> for glib::Value {
    #[inline]
    fn from(v: Area) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}