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

use glib::error::ErrorDomain;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::Quark;
use glib::StaticType;
use glib::Type;
use std::fmt;

/// An enumeration describing the way in which a device
/// axis (valuator) maps onto the predefined valuator
/// types that GTK+ understands.
///
/// Note that the X and Y axes are not really needed; pointer devices
/// report their location via the x/y members of events regardless. Whether
/// X and Y are present as axes depends on the GDK backend.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkAxisUse")]
pub enum AxisUse {
    /// the axis is ignored.
    #[doc(alias = "GDK_AXIS_IGNORE")]
    Ignore,
    /// the axis is used as the x axis.
    #[doc(alias = "GDK_AXIS_X")]
    X,
    /// the axis is used as the y axis.
    #[doc(alias = "GDK_AXIS_Y")]
    Y,
    /// the axis is used for pressure information.
    #[doc(alias = "GDK_AXIS_PRESSURE")]
    Pressure,
    /// the axis is used for x tilt information.
    #[doc(alias = "GDK_AXIS_XTILT")]
    Xtilt,
    /// the axis is used for y tilt information.
    #[doc(alias = "GDK_AXIS_YTILT")]
    Ytilt,
    /// the axis is used for wheel information.
    #[doc(alias = "GDK_AXIS_WHEEL")]
    Wheel,
    /// the axis is used for pen/tablet distance information. (Since: 3.22)
    #[doc(alias = "GDK_AXIS_DISTANCE")]
    Distance,
    /// the axis is used for pen rotation information. (Since: 3.22)
    #[doc(alias = "GDK_AXIS_ROTATION")]
    Rotation,
    /// the axis is used for pen slider information. (Since: 3.22)
    #[doc(alias = "GDK_AXIS_SLIDER")]
    Slider,
    /// a constant equal to the numerically highest axis value.
    #[doc(alias = "GDK_AXIS_LAST")]
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for AxisUse {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "AxisUse::{}",
            match *self {
                Self::Ignore => "Ignore",
                Self::X => "X",
                Self::Y => "Y",
                Self::Pressure => "Pressure",
                Self::Xtilt => "Xtilt",
                Self::Ytilt => "Ytilt",
                Self::Wheel => "Wheel",
                Self::Distance => "Distance",
                Self::Rotation => "Rotation",
                Self::Slider => "Slider",
                Self::Last => "Last",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkAxisUse {
        match self {
            Self::Ignore => ffi::GDK_AXIS_IGNORE,
            Self::X => ffi::GDK_AXIS_X,
            Self::Y => ffi::GDK_AXIS_Y,
            Self::Pressure => ffi::GDK_AXIS_PRESSURE,
            Self::Xtilt => ffi::GDK_AXIS_XTILT,
            Self::Ytilt => ffi::GDK_AXIS_YTILT,
            Self::Wheel => ffi::GDK_AXIS_WHEEL,
            Self::Distance => ffi::GDK_AXIS_DISTANCE,
            Self::Rotation => ffi::GDK_AXIS_ROTATION,
            Self::Slider => ffi::GDK_AXIS_SLIDER,
            Self::Last => ffi::GDK_AXIS_LAST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkAxisUse> for AxisUse {
    unsafe fn from_glib(value: ffi::GdkAxisUse) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_AXIS_IGNORE => Self::Ignore,
            ffi::GDK_AXIS_X => Self::X,
            ffi::GDK_AXIS_Y => Self::Y,
            ffi::GDK_AXIS_PRESSURE => Self::Pressure,
            ffi::GDK_AXIS_XTILT => Self::Xtilt,
            ffi::GDK_AXIS_YTILT => Self::Ytilt,
            ffi::GDK_AXIS_WHEEL => Self::Wheel,
            ffi::GDK_AXIS_DISTANCE => Self::Distance,
            ffi::GDK_AXIS_ROTATION => Self::Rotation,
            ffi::GDK_AXIS_SLIDER => Self::Slider,
            ffi::GDK_AXIS_LAST => Self::Last,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AxisUse {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_axis_use_get_type()) }
    }
}

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

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

    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 AxisUse {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// A set of values describing the possible byte-orders
/// for storing pixel values in memory.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkByteOrder")]
pub enum ByteOrder {
    /// The values are stored with the least-significant byte
    ///  first. For instance, the 32-bit value 0xffeecc would be stored
    ///  in memory as 0xcc, 0xee, 0xff, 0x00.
    #[doc(alias = "GDK_LSB_FIRST")]
    LsbFirst,
    /// The values are stored with the most-significant byte
    ///  first. For instance, the 32-bit value 0xffeecc would be stored
    ///  in memory as 0x00, 0xff, 0xee, 0xcc.
    #[doc(alias = "GDK_MSB_FIRST")]
    MsbFirst,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for ByteOrder {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "ByteOrder::{}",
            match *self {
                Self::LsbFirst => "LsbFirst",
                Self::MsbFirst => "MsbFirst",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkByteOrder {
        match self {
            Self::LsbFirst => ffi::GDK_LSB_FIRST,
            Self::MsbFirst => ffi::GDK_MSB_FIRST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkByteOrder> for ByteOrder {
    unsafe fn from_glib(value: ffi::GdkByteOrder) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_LSB_FIRST => Self::LsbFirst,
            ffi::GDK_MSB_FIRST => Self::MsbFirst,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ByteOrder {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_byte_order_get_type()) }
    }
}

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

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

    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 ByteOrder {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the crossing mode for [`EventCrossing`][crate::EventCrossing].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkCrossingMode")]
pub enum CrossingMode {
    /// crossing because of pointer motion.
    #[doc(alias = "GDK_CROSSING_NORMAL")]
    Normal,
    /// crossing because a grab is activated.
    #[doc(alias = "GDK_CROSSING_GRAB")]
    Grab,
    /// crossing because a grab is deactivated.
    #[doc(alias = "GDK_CROSSING_UNGRAB")]
    Ungrab,
    /// crossing because a GTK+ grab is activated.
    #[doc(alias = "GDK_CROSSING_GTK_GRAB")]
    GtkGrab,
    /// crossing because a GTK+ grab is deactivated.
    #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")]
    GtkUngrab,
    /// crossing because a GTK+ widget changed
    ///  state (e.g. sensitivity).
    #[doc(alias = "GDK_CROSSING_STATE_CHANGED")]
    StateChanged,
    /// crossing because a touch sequence has begun,
    ///  this event is synthetic as the pointer might have not left the window.
    #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")]
    TouchBegin,
    /// crossing because a touch sequence has ended,
    ///  this event is synthetic as the pointer might have not left the window.
    #[doc(alias = "GDK_CROSSING_TOUCH_END")]
    TouchEnd,
    /// crossing because of a device switch (i.e.
    ///  a mouse taking control of the pointer after a touch device), this event
    ///  is synthetic as the pointer didn’t leave the window.
    #[doc(alias = "GDK_CROSSING_DEVICE_SWITCH")]
    DeviceSwitch,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for CrossingMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "CrossingMode::{}",
            match *self {
                Self::Normal => "Normal",
                Self::Grab => "Grab",
                Self::Ungrab => "Ungrab",
                Self::GtkGrab => "GtkGrab",
                Self::GtkUngrab => "GtkUngrab",
                Self::StateChanged => "StateChanged",
                Self::TouchBegin => "TouchBegin",
                Self::TouchEnd => "TouchEnd",
                Self::DeviceSwitch => "DeviceSwitch",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkCrossingMode {
        match self {
            Self::Normal => ffi::GDK_CROSSING_NORMAL,
            Self::Grab => ffi::GDK_CROSSING_GRAB,
            Self::Ungrab => ffi::GDK_CROSSING_UNGRAB,
            Self::GtkGrab => ffi::GDK_CROSSING_GTK_GRAB,
            Self::GtkUngrab => ffi::GDK_CROSSING_GTK_UNGRAB,
            Self::StateChanged => ffi::GDK_CROSSING_STATE_CHANGED,
            Self::TouchBegin => ffi::GDK_CROSSING_TOUCH_BEGIN,
            Self::TouchEnd => ffi::GDK_CROSSING_TOUCH_END,
            Self::DeviceSwitch => ffi::GDK_CROSSING_DEVICE_SWITCH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkCrossingMode> for CrossingMode {
    unsafe fn from_glib(value: ffi::GdkCrossingMode) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_CROSSING_NORMAL => Self::Normal,
            ffi::GDK_CROSSING_GRAB => Self::Grab,
            ffi::GDK_CROSSING_UNGRAB => Self::Ungrab,
            ffi::GDK_CROSSING_GTK_GRAB => Self::GtkGrab,
            ffi::GDK_CROSSING_GTK_UNGRAB => Self::GtkUngrab,
            ffi::GDK_CROSSING_STATE_CHANGED => Self::StateChanged,
            ffi::GDK_CROSSING_TOUCH_BEGIN => Self::TouchBegin,
            ffi::GDK_CROSSING_TOUCH_END => Self::TouchEnd,
            ffi::GDK_CROSSING_DEVICE_SWITCH => Self::DeviceSwitch,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for CrossingMode {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) }
    }
}

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

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

    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 CrossingMode {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Predefined cursors.
///
/// Note that these IDs are directly taken from the X cursor font, and many
/// of these cursors are either not useful, or are not available on other platforms.
///
/// The recommended way to create cursors is to use [`Cursor::from_name()`][crate::Cursor::from_name()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkCursorType")]
pub enum CursorType {
    /// ![](X_cursor.png)
    #[doc(alias = "GDK_X_CURSOR")]
    XCursor,
    /// ![](arrow.png)
    #[doc(alias = "GDK_ARROW")]
    Arrow,
    /// ![](based_arrow_down.png)
    #[doc(alias = "GDK_BASED_ARROW_DOWN")]
    BasedArrowDown,
    /// ![](based_arrow_up.png)
    #[doc(alias = "GDK_BASED_ARROW_UP")]
    BasedArrowUp,
    /// ![](boat.png)
    #[doc(alias = "GDK_BOAT")]
    Boat,
    /// ![](bogosity.png)
    #[doc(alias = "GDK_BOGOSITY")]
    Bogosity,
    /// ![](bottom_left_corner.png)
    #[doc(alias = "GDK_BOTTOM_LEFT_CORNER")]
    BottomLeftCorner,
    /// ![](bottom_right_corner.png)
    #[doc(alias = "GDK_BOTTOM_RIGHT_CORNER")]
    BottomRightCorner,
    /// ![](bottom_side.png)
    #[doc(alias = "GDK_BOTTOM_SIDE")]
    BottomSide,
    /// ![](bottom_tee.png)
    #[doc(alias = "GDK_BOTTOM_TEE")]
    BottomTee,
    /// ![](box_spiral.png)
    #[doc(alias = "GDK_BOX_SPIRAL")]
    BoxSpiral,
    /// ![](center_ptr.png)
    #[doc(alias = "GDK_CENTER_PTR")]
    CenterPtr,
    /// ![](circle.png)
    #[doc(alias = "GDK_CIRCLE")]
    Circle,
    /// ![](clock.png)
    #[doc(alias = "GDK_CLOCK")]
    Clock,
    /// ![](coffee_mug.png)
    #[doc(alias = "GDK_COFFEE_MUG")]
    CoffeeMug,
    /// ![](cross.png)
    #[doc(alias = "GDK_CROSS")]
    Cross,
    /// ![](cross_reverse.png)
    #[doc(alias = "GDK_CROSS_REVERSE")]
    CrossReverse,
    /// ![](crosshair.png)
    #[doc(alias = "GDK_CROSSHAIR")]
    Crosshair,
    /// ![](diamond_cross.png)
    #[doc(alias = "GDK_DIAMOND_CROSS")]
    DiamondCross,
    /// ![](dot.png)
    #[doc(alias = "GDK_DOT")]
    Dot,
    /// ![](dotbox.png)
    #[doc(alias = "GDK_DOTBOX")]
    Dotbox,
    /// ![](double_arrow.png)
    #[doc(alias = "GDK_DOUBLE_ARROW")]
    DoubleArrow,
    /// ![](draft_large.png)
    #[doc(alias = "GDK_DRAFT_LARGE")]
    DraftLarge,
    /// ![](draft_small.png)
    #[doc(alias = "GDK_DRAFT_SMALL")]
    DraftSmall,
    /// ![](draped_box.png)
    #[doc(alias = "GDK_DRAPED_BOX")]
    DrapedBox,
    /// ![](exchange.png)
    #[doc(alias = "GDK_EXCHANGE")]
    Exchange,
    /// ![](fleur.png)
    #[doc(alias = "GDK_FLEUR")]
    Fleur,
    /// ![](gobbler.png)
    #[doc(alias = "GDK_GOBBLER")]
    Gobbler,
    /// ![](gumby.png)
    #[doc(alias = "GDK_GUMBY")]
    Gumby,
    /// ![](hand1.png)
    #[doc(alias = "GDK_HAND1")]
    Hand1,
    /// ![](hand2.png)
    #[doc(alias = "GDK_HAND2")]
    Hand2,
    /// ![](heart.png)
    #[doc(alias = "GDK_HEART")]
    Heart,
    /// ![](icon.png)
    #[doc(alias = "GDK_ICON")]
    Icon,
    /// ![](iron_cross.png)
    #[doc(alias = "GDK_IRON_CROSS")]
    IronCross,
    /// ![](left_ptr.png)
    #[doc(alias = "GDK_LEFT_PTR")]
    LeftPtr,
    /// ![](left_side.png)
    #[doc(alias = "GDK_LEFT_SIDE")]
    LeftSide,
    /// ![](left_tee.png)
    #[doc(alias = "GDK_LEFT_TEE")]
    LeftTee,
    /// ![](leftbutton.png)
    #[doc(alias = "GDK_LEFTBUTTON")]
    Leftbutton,
    /// ![](ll_angle.png)
    #[doc(alias = "GDK_LL_ANGLE")]
    LlAngle,
    /// ![](lr_angle.png)
    #[doc(alias = "GDK_LR_ANGLE")]
    LrAngle,
    /// ![](man.png)
    #[doc(alias = "GDK_MAN")]
    Man,
    /// ![](middlebutton.png)
    #[doc(alias = "GDK_MIDDLEBUTTON")]
    Middlebutton,
    /// ![](mouse.png)
    #[doc(alias = "GDK_MOUSE")]
    Mouse,
    /// ![](pencil.png)
    #[doc(alias = "GDK_PENCIL")]
    Pencil,
    /// ![](pirate.png)
    #[doc(alias = "GDK_PIRATE")]
    Pirate,
    /// ![](plus.png)
    #[doc(alias = "GDK_PLUS")]
    Plus,
    /// ![](question_arrow.png)
    #[doc(alias = "GDK_QUESTION_ARROW")]
    QuestionArrow,
    /// ![](right_ptr.png)
    #[doc(alias = "GDK_RIGHT_PTR")]
    RightPtr,
    /// ![](right_side.png)
    #[doc(alias = "GDK_RIGHT_SIDE")]
    RightSide,
    /// ![](right_tee.png)
    #[doc(alias = "GDK_RIGHT_TEE")]
    RightTee,
    /// ![](rightbutton.png)
    #[doc(alias = "GDK_RIGHTBUTTON")]
    Rightbutton,
    /// ![](rtl_logo.png)
    #[doc(alias = "GDK_RTL_LOGO")]
    RtlLogo,
    /// ![](sailboat.png)
    #[doc(alias = "GDK_SAILBOAT")]
    Sailboat,
    /// ![](sb_down_arrow.png)
    #[doc(alias = "GDK_SB_DOWN_ARROW")]
    SbDownArrow,
    /// ![](sb_h_double_arrow.png)
    #[doc(alias = "GDK_SB_H_DOUBLE_ARROW")]
    SbHDoubleArrow,
    /// ![](sb_left_arrow.png)
    #[doc(alias = "GDK_SB_LEFT_ARROW")]
    SbLeftArrow,
    /// ![](sb_right_arrow.png)
    #[doc(alias = "GDK_SB_RIGHT_ARROW")]
    SbRightArrow,
    /// ![](sb_up_arrow.png)
    #[doc(alias = "GDK_SB_UP_ARROW")]
    SbUpArrow,
    /// ![](sb_v_double_arrow.png)
    #[doc(alias = "GDK_SB_V_DOUBLE_ARROW")]
    SbVDoubleArrow,
    /// ![](shuttle.png)
    #[doc(alias = "GDK_SHUTTLE")]
    Shuttle,
    /// ![](sizing.png)
    #[doc(alias = "GDK_SIZING")]
    Sizing,
    /// ![](spider.png)
    #[doc(alias = "GDK_SPIDER")]
    Spider,
    /// ![](spraycan.png)
    #[doc(alias = "GDK_SPRAYCAN")]
    Spraycan,
    /// ![](star.png)
    #[doc(alias = "GDK_STAR")]
    Star,
    /// ![](target.png)
    #[doc(alias = "GDK_TARGET")]
    Target,
    /// ![](tcross.png)
    #[doc(alias = "GDK_TCROSS")]
    Tcross,
    /// ![](top_left_arrow.png)
    #[doc(alias = "GDK_TOP_LEFT_ARROW")]
    TopLeftArrow,
    /// ![](top_left_corner.png)
    #[doc(alias = "GDK_TOP_LEFT_CORNER")]
    TopLeftCorner,
    /// ![](top_right_corner.png)
    #[doc(alias = "GDK_TOP_RIGHT_CORNER")]
    TopRightCorner,
    /// ![](top_side.png)
    #[doc(alias = "GDK_TOP_SIDE")]
    TopSide,
    /// ![](top_tee.png)
    #[doc(alias = "GDK_TOP_TEE")]
    TopTee,
    /// ![](trek.png)
    #[doc(alias = "GDK_TREK")]
    Trek,
    /// ![](ul_angle.png)
    #[doc(alias = "GDK_UL_ANGLE")]
    UlAngle,
    /// ![](umbrella.png)
    #[doc(alias = "GDK_UMBRELLA")]
    Umbrella,
    /// ![](ur_angle.png)
    #[doc(alias = "GDK_UR_ANGLE")]
    UrAngle,
    /// ![](watch.png)
    #[doc(alias = "GDK_WATCH")]
    Watch,
    /// ![](xterm.png)
    #[doc(alias = "GDK_XTERM")]
    Xterm,
    /// last cursor type
    #[doc(alias = "GDK_LAST_CURSOR")]
    LastCursor,
    /// Blank cursor. Since 2.16
    #[doc(alias = "GDK_BLANK_CURSOR")]
    BlankCursor,
    /// type of cursors constructed with
    ///  [`Cursor::from_pixbuf()`][crate::Cursor::from_pixbuf()]
    #[doc(alias = "GDK_CURSOR_IS_PIXMAP")]
    CursorIsPixmap,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for CursorType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "CursorType::{}",
            match *self {
                Self::XCursor => "XCursor",
                Self::Arrow => "Arrow",
                Self::BasedArrowDown => "BasedArrowDown",
                Self::BasedArrowUp => "BasedArrowUp",
                Self::Boat => "Boat",
                Self::Bogosity => "Bogosity",
                Self::BottomLeftCorner => "BottomLeftCorner",
                Self::BottomRightCorner => "BottomRightCorner",
                Self::BottomSide => "BottomSide",
                Self::BottomTee => "BottomTee",
                Self::BoxSpiral => "BoxSpiral",
                Self::CenterPtr => "CenterPtr",
                Self::Circle => "Circle",
                Self::Clock => "Clock",
                Self::CoffeeMug => "CoffeeMug",
                Self::Cross => "Cross",
                Self::CrossReverse => "CrossReverse",
                Self::Crosshair => "Crosshair",
                Self::DiamondCross => "DiamondCross",
                Self::Dot => "Dot",
                Self::Dotbox => "Dotbox",
                Self::DoubleArrow => "DoubleArrow",
                Self::DraftLarge => "DraftLarge",
                Self::DraftSmall => "DraftSmall",
                Self::DrapedBox => "DrapedBox",
                Self::Exchange => "Exchange",
                Self::Fleur => "Fleur",
                Self::Gobbler => "Gobbler",
                Self::Gumby => "Gumby",
                Self::Hand1 => "Hand1",
                Self::Hand2 => "Hand2",
                Self::Heart => "Heart",
                Self::Icon => "Icon",
                Self::IronCross => "IronCross",
                Self::LeftPtr => "LeftPtr",
                Self::LeftSide => "LeftSide",
                Self::LeftTee => "LeftTee",
                Self::Leftbutton => "Leftbutton",
                Self::LlAngle => "LlAngle",
                Self::LrAngle => "LrAngle",
                Self::Man => "Man",
                Self::Middlebutton => "Middlebutton",
                Self::Mouse => "Mouse",
                Self::Pencil => "Pencil",
                Self::Pirate => "Pirate",
                Self::Plus => "Plus",
                Self::QuestionArrow => "QuestionArrow",
                Self::RightPtr => "RightPtr",
                Self::RightSide => "RightSide",
                Self::RightTee => "RightTee",
                Self::Rightbutton => "Rightbutton",
                Self::RtlLogo => "RtlLogo",
                Self::Sailboat => "Sailboat",
                Self::SbDownArrow => "SbDownArrow",
                Self::SbHDoubleArrow => "SbHDoubleArrow",
                Self::SbLeftArrow => "SbLeftArrow",
                Self::SbRightArrow => "SbRightArrow",
                Self::SbUpArrow => "SbUpArrow",
                Self::SbVDoubleArrow => "SbVDoubleArrow",
                Self::Shuttle => "Shuttle",
                Self::Sizing => "Sizing",
                Self::Spider => "Spider",
                Self::Spraycan => "Spraycan",
                Self::Star => "Star",
                Self::Target => "Target",
                Self::Tcross => "Tcross",
                Self::TopLeftArrow => "TopLeftArrow",
                Self::TopLeftCorner => "TopLeftCorner",
                Self::TopRightCorner => "TopRightCorner",
                Self::TopSide => "TopSide",
                Self::TopTee => "TopTee",
                Self::Trek => "Trek",
                Self::UlAngle => "UlAngle",
                Self::Umbrella => "Umbrella",
                Self::UrAngle => "UrAngle",
                Self::Watch => "Watch",
                Self::Xterm => "Xterm",
                Self::LastCursor => "LastCursor",
                Self::BlankCursor => "BlankCursor",
                Self::CursorIsPixmap => "CursorIsPixmap",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkCursorType {
        match self {
            Self::XCursor => ffi::GDK_X_CURSOR,
            Self::Arrow => ffi::GDK_ARROW,
            Self::BasedArrowDown => ffi::GDK_BASED_ARROW_DOWN,
            Self::BasedArrowUp => ffi::GDK_BASED_ARROW_UP,
            Self::Boat => ffi::GDK_BOAT,
            Self::Bogosity => ffi::GDK_BOGOSITY,
            Self::BottomLeftCorner => ffi::GDK_BOTTOM_LEFT_CORNER,
            Self::BottomRightCorner => ffi::GDK_BOTTOM_RIGHT_CORNER,
            Self::BottomSide => ffi::GDK_BOTTOM_SIDE,
            Self::BottomTee => ffi::GDK_BOTTOM_TEE,
            Self::BoxSpiral => ffi::GDK_BOX_SPIRAL,
            Self::CenterPtr => ffi::GDK_CENTER_PTR,
            Self::Circle => ffi::GDK_CIRCLE,
            Self::Clock => ffi::GDK_CLOCK,
            Self::CoffeeMug => ffi::GDK_COFFEE_MUG,
            Self::Cross => ffi::GDK_CROSS,
            Self::CrossReverse => ffi::GDK_CROSS_REVERSE,
            Self::Crosshair => ffi::GDK_CROSSHAIR,
            Self::DiamondCross => ffi::GDK_DIAMOND_CROSS,
            Self::Dot => ffi::GDK_DOT,
            Self::Dotbox => ffi::GDK_DOTBOX,
            Self::DoubleArrow => ffi::GDK_DOUBLE_ARROW,
            Self::DraftLarge => ffi::GDK_DRAFT_LARGE,
            Self::DraftSmall => ffi::GDK_DRAFT_SMALL,
            Self::DrapedBox => ffi::GDK_DRAPED_BOX,
            Self::Exchange => ffi::GDK_EXCHANGE,
            Self::Fleur => ffi::GDK_FLEUR,
            Self::Gobbler => ffi::GDK_GOBBLER,
            Self::Gumby => ffi::GDK_GUMBY,
            Self::Hand1 => ffi::GDK_HAND1,
            Self::Hand2 => ffi::GDK_HAND2,
            Self::Heart => ffi::GDK_HEART,
            Self::Icon => ffi::GDK_ICON,
            Self::IronCross => ffi::GDK_IRON_CROSS,
            Self::LeftPtr => ffi::GDK_LEFT_PTR,
            Self::LeftSide => ffi::GDK_LEFT_SIDE,
            Self::LeftTee => ffi::GDK_LEFT_TEE,
            Self::Leftbutton => ffi::GDK_LEFTBUTTON,
            Self::LlAngle => ffi::GDK_LL_ANGLE,
            Self::LrAngle => ffi::GDK_LR_ANGLE,
            Self::Man => ffi::GDK_MAN,
            Self::Middlebutton => ffi::GDK_MIDDLEBUTTON,
            Self::Mouse => ffi::GDK_MOUSE,
            Self::Pencil => ffi::GDK_PENCIL,
            Self::Pirate => ffi::GDK_PIRATE,
            Self::Plus => ffi::GDK_PLUS,
            Self::QuestionArrow => ffi::GDK_QUESTION_ARROW,
            Self::RightPtr => ffi::GDK_RIGHT_PTR,
            Self::RightSide => ffi::GDK_RIGHT_SIDE,
            Self::RightTee => ffi::GDK_RIGHT_TEE,
            Self::Rightbutton => ffi::GDK_RIGHTBUTTON,
            Self::RtlLogo => ffi::GDK_RTL_LOGO,
            Self::Sailboat => ffi::GDK_SAILBOAT,
            Self::SbDownArrow => ffi::GDK_SB_DOWN_ARROW,
            Self::SbHDoubleArrow => ffi::GDK_SB_H_DOUBLE_ARROW,
            Self::SbLeftArrow => ffi::GDK_SB_LEFT_ARROW,
            Self::SbRightArrow => ffi::GDK_SB_RIGHT_ARROW,
            Self::SbUpArrow => ffi::GDK_SB_UP_ARROW,
            Self::SbVDoubleArrow => ffi::GDK_SB_V_DOUBLE_ARROW,
            Self::Shuttle => ffi::GDK_SHUTTLE,
            Self::Sizing => ffi::GDK_SIZING,
            Self::Spider => ffi::GDK_SPIDER,
            Self::Spraycan => ffi::GDK_SPRAYCAN,
            Self::Star => ffi::GDK_STAR,
            Self::Target => ffi::GDK_TARGET,
            Self::Tcross => ffi::GDK_TCROSS,
            Self::TopLeftArrow => ffi::GDK_TOP_LEFT_ARROW,
            Self::TopLeftCorner => ffi::GDK_TOP_LEFT_CORNER,
            Self::TopRightCorner => ffi::GDK_TOP_RIGHT_CORNER,
            Self::TopSide => ffi::GDK_TOP_SIDE,
            Self::TopTee => ffi::GDK_TOP_TEE,
            Self::Trek => ffi::GDK_TREK,
            Self::UlAngle => ffi::GDK_UL_ANGLE,
            Self::Umbrella => ffi::GDK_UMBRELLA,
            Self::UrAngle => ffi::GDK_UR_ANGLE,
            Self::Watch => ffi::GDK_WATCH,
            Self::Xterm => ffi::GDK_XTERM,
            Self::LastCursor => ffi::GDK_LAST_CURSOR,
            Self::BlankCursor => ffi::GDK_BLANK_CURSOR,
            Self::CursorIsPixmap => ffi::GDK_CURSOR_IS_PIXMAP,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkCursorType> for CursorType {
    unsafe fn from_glib(value: ffi::GdkCursorType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_X_CURSOR => Self::XCursor,
            ffi::GDK_ARROW => Self::Arrow,
            ffi::GDK_BASED_ARROW_DOWN => Self::BasedArrowDown,
            ffi::GDK_BASED_ARROW_UP => Self::BasedArrowUp,
            ffi::GDK_BOAT => Self::Boat,
            ffi::GDK_BOGOSITY => Self::Bogosity,
            ffi::GDK_BOTTOM_LEFT_CORNER => Self::BottomLeftCorner,
            ffi::GDK_BOTTOM_RIGHT_CORNER => Self::BottomRightCorner,
            ffi::GDK_BOTTOM_SIDE => Self::BottomSide,
            ffi::GDK_BOTTOM_TEE => Self::BottomTee,
            ffi::GDK_BOX_SPIRAL => Self::BoxSpiral,
            ffi::GDK_CENTER_PTR => Self::CenterPtr,
            ffi::GDK_CIRCLE => Self::Circle,
            ffi::GDK_CLOCK => Self::Clock,
            ffi::GDK_COFFEE_MUG => Self::CoffeeMug,
            ffi::GDK_CROSS => Self::Cross,
            ffi::GDK_CROSS_REVERSE => Self::CrossReverse,
            ffi::GDK_CROSSHAIR => Self::Crosshair,
            ffi::GDK_DIAMOND_CROSS => Self::DiamondCross,
            ffi::GDK_DOT => Self::Dot,
            ffi::GDK_DOTBOX => Self::Dotbox,
            ffi::GDK_DOUBLE_ARROW => Self::DoubleArrow,
            ffi::GDK_DRAFT_LARGE => Self::DraftLarge,
            ffi::GDK_DRAFT_SMALL => Self::DraftSmall,
            ffi::GDK_DRAPED_BOX => Self::DrapedBox,
            ffi::GDK_EXCHANGE => Self::Exchange,
            ffi::GDK_FLEUR => Self::Fleur,
            ffi::GDK_GOBBLER => Self::Gobbler,
            ffi::GDK_GUMBY => Self::Gumby,
            ffi::GDK_HAND1 => Self::Hand1,
            ffi::GDK_HAND2 => Self::Hand2,
            ffi::GDK_HEART => Self::Heart,
            ffi::GDK_ICON => Self::Icon,
            ffi::GDK_IRON_CROSS => Self::IronCross,
            ffi::GDK_LEFT_PTR => Self::LeftPtr,
            ffi::GDK_LEFT_SIDE => Self::LeftSide,
            ffi::GDK_LEFT_TEE => Self::LeftTee,
            ffi::GDK_LEFTBUTTON => Self::Leftbutton,
            ffi::GDK_LL_ANGLE => Self::LlAngle,
            ffi::GDK_LR_ANGLE => Self::LrAngle,
            ffi::GDK_MAN => Self::Man,
            ffi::GDK_MIDDLEBUTTON => Self::Middlebutton,
            ffi::GDK_MOUSE => Self::Mouse,
            ffi::GDK_PENCIL => Self::Pencil,
            ffi::GDK_PIRATE => Self::Pirate,
            ffi::GDK_PLUS => Self::Plus,
            ffi::GDK_QUESTION_ARROW => Self::QuestionArrow,
            ffi::GDK_RIGHT_PTR => Self::RightPtr,
            ffi::GDK_RIGHT_SIDE => Self::RightSide,
            ffi::GDK_RIGHT_TEE => Self::RightTee,
            ffi::GDK_RIGHTBUTTON => Self::Rightbutton,
            ffi::GDK_RTL_LOGO => Self::RtlLogo,
            ffi::GDK_SAILBOAT => Self::Sailboat,
            ffi::GDK_SB_DOWN_ARROW => Self::SbDownArrow,
            ffi::GDK_SB_H_DOUBLE_ARROW => Self::SbHDoubleArrow,
            ffi::GDK_SB_LEFT_ARROW => Self::SbLeftArrow,
            ffi::GDK_SB_RIGHT_ARROW => Self::SbRightArrow,
            ffi::GDK_SB_UP_ARROW => Self::SbUpArrow,
            ffi::GDK_SB_V_DOUBLE_ARROW => Self::SbVDoubleArrow,
            ffi::GDK_SHUTTLE => Self::Shuttle,
            ffi::GDK_SIZING => Self::Sizing,
            ffi::GDK_SPIDER => Self::Spider,
            ffi::GDK_SPRAYCAN => Self::Spraycan,
            ffi::GDK_STAR => Self::Star,
            ffi::GDK_TARGET => Self::Target,
            ffi::GDK_TCROSS => Self::Tcross,
            ffi::GDK_TOP_LEFT_ARROW => Self::TopLeftArrow,
            ffi::GDK_TOP_LEFT_CORNER => Self::TopLeftCorner,
            ffi::GDK_TOP_RIGHT_CORNER => Self::TopRightCorner,
            ffi::GDK_TOP_SIDE => Self::TopSide,
            ffi::GDK_TOP_TEE => Self::TopTee,
            ffi::GDK_TREK => Self::Trek,
            ffi::GDK_UL_ANGLE => Self::UlAngle,
            ffi::GDK_UMBRELLA => Self::Umbrella,
            ffi::GDK_UR_ANGLE => Self::UrAngle,
            ffi::GDK_WATCH => Self::Watch,
            ffi::GDK_XTERM => Self::Xterm,
            ffi::GDK_LAST_CURSOR => Self::LastCursor,
            ffi::GDK_BLANK_CURSOR => Self::BlankCursor,
            ffi::GDK_CURSOR_IS_PIXMAP => Self::CursorIsPixmap,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for CursorType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_cursor_type_get_type()) }
    }
}

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

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

    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 CursorType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// A pad feature.
#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkDevicePadFeature")]
pub enum DevicePadFeature {
    /// a button
    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")]
    Button,
    /// a ring-shaped interactive area
    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")]
    Ring,
    /// a straight interactive area
    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_STRIP")]
    Strip,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl fmt::Display for DevicePadFeature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "DevicePadFeature::{}",
            match *self {
                Self::Button => "Button",
                Self::Ring => "Ring",
                Self::Strip => "Strip",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl IntoGlib for DevicePadFeature {
    type GlibType = ffi::GdkDevicePadFeature;

    fn into_glib(self) -> ffi::GdkDevicePadFeature {
        match self {
            Self::Button => ffi::GDK_DEVICE_PAD_FEATURE_BUTTON,
            Self::Ring => ffi::GDK_DEVICE_PAD_FEATURE_RING,
            Self::Strip => ffi::GDK_DEVICE_PAD_FEATURE_STRIP,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature {
    unsafe fn from_glib(value: ffi::GdkDevicePadFeature) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_DEVICE_PAD_FEATURE_BUTTON => Self::Button,
            ffi::GDK_DEVICE_PAD_FEATURE_RING => Self::Ring,
            ffi::GDK_DEVICE_PAD_FEATURE_STRIP => Self::Strip,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl StaticType for DevicePadFeature {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_device_pad_feature_get_type()) }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl glib::value::ValueType for DevicePadFeature {
    type Type = Self;
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
unsafe impl<'a> FromValue<'a> for DevicePadFeature {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    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))
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl ToValue for DevicePadFeature {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Indicates the specific type of tool being used being a tablet. Such as an
/// airbrush, pencil, etc.
#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkDeviceToolType")]
pub enum DeviceToolType {
    /// Tool is of an unknown type.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")]
    Unknown,
    /// Tool is a standard tablet stylus.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")]
    Pen,
    /// Tool is standard tablet eraser.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")]
    Eraser,
    /// Tool is a brush stylus.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")]
    Brush,
    /// Tool is a pencil stylus.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")]
    Pencil,
    /// Tool is an airbrush stylus.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")]
    Airbrush,
    /// Tool is a mouse.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")]
    Mouse,
    /// Tool is a lens cursor.
    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_LENS")]
    Lens,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl fmt::Display for DeviceToolType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "DeviceToolType::{}",
            match *self {
                Self::Unknown => "Unknown",
                Self::Pen => "Pen",
                Self::Eraser => "Eraser",
                Self::Brush => "Brush",
                Self::Pencil => "Pencil",
                Self::Airbrush => "Airbrush",
                Self::Mouse => "Mouse",
                Self::Lens => "Lens",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl IntoGlib for DeviceToolType {
    type GlibType = ffi::GdkDeviceToolType;

    fn into_glib(self) -> ffi::GdkDeviceToolType {
        match self {
            Self::Unknown => ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN,
            Self::Pen => ffi::GDK_DEVICE_TOOL_TYPE_PEN,
            Self::Eraser => ffi::GDK_DEVICE_TOOL_TYPE_ERASER,
            Self::Brush => ffi::GDK_DEVICE_TOOL_TYPE_BRUSH,
            Self::Pencil => ffi::GDK_DEVICE_TOOL_TYPE_PENCIL,
            Self::Airbrush => ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
            Self::Mouse => ffi::GDK_DEVICE_TOOL_TYPE_MOUSE,
            Self::Lens => ffi::GDK_DEVICE_TOOL_TYPE_LENS,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType {
    unsafe fn from_glib(value: ffi::GdkDeviceToolType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN => Self::Unknown,
            ffi::GDK_DEVICE_TOOL_TYPE_PEN => Self::Pen,
            ffi::GDK_DEVICE_TOOL_TYPE_ERASER => Self::Eraser,
            ffi::GDK_DEVICE_TOOL_TYPE_BRUSH => Self::Brush,
            ffi::GDK_DEVICE_TOOL_TYPE_PENCIL => Self::Pencil,
            ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH => Self::Airbrush,
            ffi::GDK_DEVICE_TOOL_TYPE_MOUSE => Self::Mouse,
            ffi::GDK_DEVICE_TOOL_TYPE_LENS => Self::Lens,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl StaticType for DeviceToolType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_device_tool_type_get_type()) }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl glib::value::ValueType for DeviceToolType {
    type Type = Self;
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
unsafe impl<'a> FromValue<'a> for DeviceToolType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    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))
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl ToValue for DeviceToolType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Indicates the device type. See [above][GdkDeviceManager.description]
/// for more information about the meaning of these device types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkDeviceType")]
pub enum DeviceType {
    /// Device is a master (or virtual) device. There will
    ///  be an associated focus indicator on the screen.
    #[doc(alias = "GDK_DEVICE_TYPE_MASTER")]
    Master,
    /// Device is a slave (or physical) device.
    #[doc(alias = "GDK_DEVICE_TYPE_SLAVE")]
    Slave,
    /// Device is a physical device, currently not attached to
    ///  any virtual device.
    #[doc(alias = "GDK_DEVICE_TYPE_FLOATING")]
    Floating,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for DeviceType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "DeviceType::{}",
            match *self {
                Self::Master => "Master",
                Self::Slave => "Slave",
                Self::Floating => "Floating",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkDeviceType {
        match self {
            Self::Master => ffi::GDK_DEVICE_TYPE_MASTER,
            Self::Slave => ffi::GDK_DEVICE_TYPE_SLAVE,
            Self::Floating => ffi::GDK_DEVICE_TYPE_FLOATING,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkDeviceType> for DeviceType {
    unsafe fn from_glib(value: ffi::GdkDeviceType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_DEVICE_TYPE_MASTER => Self::Master,
            ffi::GDK_DEVICE_TYPE_SLAVE => Self::Slave,
            ffi::GDK_DEVICE_TYPE_FLOATING => Self::Floating,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DeviceType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_device_type_get_type()) }
    }
}

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

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

    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 DeviceType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Used in [`DragContext`][crate::DragContext] to the reason of a cancelled DND operation.
#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkDragCancelReason")]
pub enum DragCancelReason {
    /// There is no suitable drop target.
    #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")]
    NoTarget,
    /// Drag cancelled by the user
    #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")]
    UserCancelled,
    /// Unspecified error.
    #[doc(alias = "GDK_DRAG_CANCEL_ERROR")]
    Error,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
impl fmt::Display for DragCancelReason {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "DragCancelReason::{}",
            match *self {
                Self::NoTarget => "NoTarget",
                Self::UserCancelled => "UserCancelled",
                Self::Error => "Error",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
#[doc(hidden)]
impl IntoGlib for DragCancelReason {
    type GlibType = ffi::GdkDragCancelReason;

    fn into_glib(self) -> ffi::GdkDragCancelReason {
        match self {
            Self::NoTarget => ffi::GDK_DRAG_CANCEL_NO_TARGET,
            Self::UserCancelled => ffi::GDK_DRAG_CANCEL_USER_CANCELLED,
            Self::Error => ffi::GDK_DRAG_CANCEL_ERROR,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason {
    unsafe fn from_glib(value: ffi::GdkDragCancelReason) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_DRAG_CANCEL_NO_TARGET => Self::NoTarget,
            ffi::GDK_DRAG_CANCEL_USER_CANCELLED => Self::UserCancelled,
            ffi::GDK_DRAG_CANCEL_ERROR => Self::Error,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
impl StaticType for DragCancelReason {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_drag_cancel_reason_get_type()) }
    }
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
impl glib::value::ValueType for DragCancelReason {
    type Type = Self;
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
unsafe impl<'a> FromValue<'a> for DragCancelReason {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    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))
    }
}

#[cfg(any(feature = "v3_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
impl ToValue for DragCancelReason {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Used in [`DragContext`][crate::DragContext] to indicate the protocol according to
/// which DND is done.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkDragProtocol")]
pub enum DragProtocol {
    /// no protocol.
    #[doc(alias = "GDK_DRAG_PROTO_NONE")]
    None,
    /// The Motif DND protocol. No longer supported
    #[doc(alias = "GDK_DRAG_PROTO_MOTIF")]
    Motif,
    /// The Xdnd protocol.
    #[doc(alias = "GDK_DRAG_PROTO_XDND")]
    Xdnd,
    /// An extension to the Xdnd protocol for
    ///  unclaimed root window drops.
    #[doc(alias = "GDK_DRAG_PROTO_ROOTWIN")]
    Rootwin,
    /// The simple WM_DROPFILES protocol.
    #[doc(alias = "GDK_DRAG_PROTO_WIN32_DROPFILES")]
    Win32Dropfiles,
    /// The complex OLE2 DND protocol (not implemented).
    #[doc(alias = "GDK_DRAG_PROTO_OLE2")]
    Ole2,
    /// Intra-application DND.
    #[doc(alias = "GDK_DRAG_PROTO_LOCAL")]
    Local,
    /// Wayland DND protocol.
    #[doc(alias = "GDK_DRAG_PROTO_WAYLAND")]
    Wayland,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for DragProtocol {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "DragProtocol::{}",
            match *self {
                Self::None => "None",
                Self::Motif => "Motif",
                Self::Xdnd => "Xdnd",
                Self::Rootwin => "Rootwin",
                Self::Win32Dropfiles => "Win32Dropfiles",
                Self::Ole2 => "Ole2",
                Self::Local => "Local",
                Self::Wayland => "Wayland",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkDragProtocol {
        match self {
            Self::None => ffi::GDK_DRAG_PROTO_NONE,
            Self::Motif => ffi::GDK_DRAG_PROTO_MOTIF,
            Self::Xdnd => ffi::GDK_DRAG_PROTO_XDND,
            Self::Rootwin => ffi::GDK_DRAG_PROTO_ROOTWIN,
            Self::Win32Dropfiles => ffi::GDK_DRAG_PROTO_WIN32_DROPFILES,
            Self::Ole2 => ffi::GDK_DRAG_PROTO_OLE2,
            Self::Local => ffi::GDK_DRAG_PROTO_LOCAL,
            Self::Wayland => ffi::GDK_DRAG_PROTO_WAYLAND,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkDragProtocol> for DragProtocol {
    unsafe fn from_glib(value: ffi::GdkDragProtocol) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_DRAG_PROTO_NONE => Self::None,
            ffi::GDK_DRAG_PROTO_MOTIF => Self::Motif,
            ffi::GDK_DRAG_PROTO_XDND => Self::Xdnd,
            ffi::GDK_DRAG_PROTO_ROOTWIN => Self::Rootwin,
            ffi::GDK_DRAG_PROTO_WIN32_DROPFILES => Self::Win32Dropfiles,
            ffi::GDK_DRAG_PROTO_OLE2 => Self::Ole2,
            ffi::GDK_DRAG_PROTO_LOCAL => Self::Local,
            ffi::GDK_DRAG_PROTO_WAYLAND => Self::Wayland,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DragProtocol {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_drag_protocol_get_type()) }
    }
}

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

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

    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 DragProtocol {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the type of the event.
///
/// Do not confuse these events with the signals that GTK+ widgets emit.
/// Although many of these events result in corresponding signals being emitted,
/// the events are often transformed or filtered along the way.
///
/// In some language bindings, the values [`_2buttonPress`][Self::_2buttonPress] and
/// [`_3buttonPress`][Self::_3buttonPress] would translate into something syntactically
/// invalid (eg `Gdk.EventType.2ButtonPress`, where a
/// symbol is not allowed to start with a number). In that case, the
/// aliases [`DoubleButtonPress`][Self::DoubleButtonPress] and [`TripleButtonPress`][Self::TripleButtonPress] can
/// be used instead.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkEventType")]
pub enum EventType {
    /// a special code to indicate a null event.
    #[doc(alias = "GDK_NOTHING")]
    Nothing,
    /// the window manager has requested that the toplevel window be
    ///  hidden or destroyed, usually when the user clicks on a special icon in the
    ///  title bar.
    #[doc(alias = "GDK_DELETE")]
    Delete,
    /// the window has been destroyed.
    #[doc(alias = "GDK_DESTROY")]
    Destroy,
    /// all or part of the window has become visible and needs to be
    ///  redrawn.
    #[doc(alias = "GDK_EXPOSE")]
    Expose,
    /// the pointer (usually a mouse) has moved.
    #[doc(alias = "GDK_MOTION_NOTIFY")]
    MotionNotify,
    /// a mouse button has been pressed.
    #[doc(alias = "GDK_BUTTON_PRESS")]
    ButtonPress,
    /// alias for [`_2buttonPress`][Self::_2buttonPress], added in 3.6.
    #[doc(alias = "GDK_DOUBLE_BUTTON_PRESS")]
    DoubleButtonPress,
    /// alias for [`_3buttonPress`][Self::_3buttonPress], added in 3.6.
    #[doc(alias = "GDK_TRIPLE_BUTTON_PRESS")]
    TripleButtonPress,
    /// a mouse button has been released.
    #[doc(alias = "GDK_BUTTON_RELEASE")]
    ButtonRelease,
    /// a key has been pressed.
    #[doc(alias = "GDK_KEY_PRESS")]
    KeyPress,
    /// a key has been released.
    #[doc(alias = "GDK_KEY_RELEASE")]
    KeyRelease,
    /// the pointer has entered the window.
    #[doc(alias = "GDK_ENTER_NOTIFY")]
    EnterNotify,
    /// the pointer has left the window.
    #[doc(alias = "GDK_LEAVE_NOTIFY")]
    LeaveNotify,
    /// the keyboard focus has entered or left the window.
    #[doc(alias = "GDK_FOCUS_CHANGE")]
    FocusChange,
    /// the size, position or stacking order of the window has changed.
    ///  Note that GTK+ discards these events for [`WindowType::Child`][crate::WindowType::Child] windows.
    #[doc(alias = "GDK_CONFIGURE")]
    Configure,
    /// the window has been mapped.
    #[doc(alias = "GDK_MAP")]
    Map,
    /// the window has been unmapped.
    #[doc(alias = "GDK_UNMAP")]
    Unmap,
    /// a property on the window has been changed or deleted.
    #[doc(alias = "GDK_PROPERTY_NOTIFY")]
    PropertyNotify,
    /// the application has lost ownership of a selection.
    #[doc(alias = "GDK_SELECTION_CLEAR")]
    SelectionClear,
    /// another application has requested a selection.
    #[doc(alias = "GDK_SELECTION_REQUEST")]
    SelectionRequest,
    /// a selection has been received.
    #[doc(alias = "GDK_SELECTION_NOTIFY")]
    SelectionNotify,
    /// an input device has moved into contact with a sensing
    ///  surface (e.g. a touchscreen or graphics tablet).
    #[doc(alias = "GDK_PROXIMITY_IN")]
    ProximityIn,
    /// an input device has moved out of contact with a sensing
    ///  surface.
    #[doc(alias = "GDK_PROXIMITY_OUT")]
    ProximityOut,
    /// the mouse has entered the window while a drag is in progress.
    #[doc(alias = "GDK_DRAG_ENTER")]
    DragEnter,
    /// the mouse has left the window while a drag is in progress.
    #[doc(alias = "GDK_DRAG_LEAVE")]
    DragLeave,
    /// the mouse has moved in the window while a drag is in
    ///  progress.
    #[doc(alias = "GDK_DRAG_MOTION")]
    DragMotion,
    /// the status of the drag operation initiated by the window
    ///  has changed.
    #[doc(alias = "GDK_DRAG_STATUS")]
    DragStatus,
    /// a drop operation onto the window has started.
    #[doc(alias = "GDK_DROP_START")]
    DropStart,
    /// the drop operation initiated by the window has completed.
    #[doc(alias = "GDK_DROP_FINISHED")]
    DropFinished,
    /// a message has been received from another application.
    #[doc(alias = "GDK_CLIENT_EVENT")]
    ClientEvent,
    /// the window visibility status has changed.
    #[doc(alias = "GDK_VISIBILITY_NOTIFY")]
    VisibilityNotify,
    /// the scroll wheel was turned
    #[doc(alias = "GDK_SCROLL")]
    Scroll,
    /// the state of a window has changed. See [`WindowState`][crate::WindowState]
    ///  for the possible window states
    #[doc(alias = "GDK_WINDOW_STATE")]
    WindowState,
    /// a setting has been modified.
    #[doc(alias = "GDK_SETTING")]
    Setting,
    /// the owner of a selection has changed. This event type
    ///  was added in 2.6
    #[doc(alias = "GDK_OWNER_CHANGE")]
    OwnerChange,
    /// a pointer or keyboard grab was broken. This event type
    ///  was added in 2.8.
    #[doc(alias = "GDK_GRAB_BROKEN")]
    GrabBroken,
    /// the content of the window has been changed. This event type
    ///  was added in 2.14.
    #[doc(alias = "GDK_DAMAGE")]
    Damage,
    /// A new touch event sequence has just started. This event
    ///  type was added in 3.4.
    #[doc(alias = "GDK_TOUCH_BEGIN")]
    TouchBegin,
    /// A touch event sequence has been updated. This event type
    ///  was added in 3.4.
    #[doc(alias = "GDK_TOUCH_UPDATE")]
    TouchUpdate,
    /// A touch event sequence has finished. This event type
    ///  was added in 3.4.
    #[doc(alias = "GDK_TOUCH_END")]
    TouchEnd,
    /// A touch event sequence has been canceled. This event type
    ///  was added in 3.4.
    #[doc(alias = "GDK_TOUCH_CANCEL")]
    TouchCancel,
    /// A touchpad swipe gesture event, the current state
    ///  is determined by its phase field. This event type was added in 3.18.
    #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
    TouchpadSwipe,
    /// A touchpad pinch gesture event, the current state
    ///  is determined by its phase field. This event type was added in 3.18.
    #[doc(alias = "GDK_TOUCHPAD_PINCH")]
    TouchpadPinch,
    /// A tablet pad button press event. This event type
    ///  was added in 3.22.
    #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
    PadButtonPress,
    /// A tablet pad button release event. This event type
    ///  was added in 3.22.
    #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
    PadButtonRelease,
    /// A tablet pad axis event from a "ring". This event type was
    ///  added in 3.22.
    #[doc(alias = "GDK_PAD_RING")]
    PadRing,
    /// A tablet pad axis event from a "strip". This event type was
    ///  added in 3.22.
    #[doc(alias = "GDK_PAD_STRIP")]
    PadStrip,
    /// A tablet pad group mode change. This event type was
    ///  added in 3.22.
    #[doc(alias = "GDK_PAD_GROUP_MODE")]
    PadGroupMode,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for EventType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "EventType::{}",
            match *self {
                Self::Nothing => "Nothing",
                Self::Delete => "Delete",
                Self::Destroy => "Destroy",
                Self::Expose => "Expose",
                Self::MotionNotify => "MotionNotify",
                Self::ButtonPress => "ButtonPress",
                Self::DoubleButtonPress => "DoubleButtonPress",
                Self::TripleButtonPress => "TripleButtonPress",
                Self::ButtonRelease => "ButtonRelease",
                Self::KeyPress => "KeyPress",
                Self::KeyRelease => "KeyRelease",
                Self::EnterNotify => "EnterNotify",
                Self::LeaveNotify => "LeaveNotify",
                Self::FocusChange => "FocusChange",
                Self::Configure => "Configure",
                Self::Map => "Map",
                Self::Unmap => "Unmap",
                Self::PropertyNotify => "PropertyNotify",
                Self::SelectionClear => "SelectionClear",
                Self::SelectionRequest => "SelectionRequest",
                Self::SelectionNotify => "SelectionNotify",
                Self::ProximityIn => "ProximityIn",
                Self::ProximityOut => "ProximityOut",
                Self::DragEnter => "DragEnter",
                Self::DragLeave => "DragLeave",
                Self::DragMotion => "DragMotion",
                Self::DragStatus => "DragStatus",
                Self::DropStart => "DropStart",
                Self::DropFinished => "DropFinished",
                Self::ClientEvent => "ClientEvent",
                Self::VisibilityNotify => "VisibilityNotify",
                Self::Scroll => "Scroll",
                Self::WindowState => "WindowState",
                Self::Setting => "Setting",
                Self::OwnerChange => "OwnerChange",
                Self::GrabBroken => "GrabBroken",
                Self::Damage => "Damage",
                Self::TouchBegin => "TouchBegin",
                Self::TouchUpdate => "TouchUpdate",
                Self::TouchEnd => "TouchEnd",
                Self::TouchCancel => "TouchCancel",
                Self::TouchpadSwipe => "TouchpadSwipe",
                Self::TouchpadPinch => "TouchpadPinch",
                Self::PadButtonPress => "PadButtonPress",
                Self::PadButtonRelease => "PadButtonRelease",
                Self::PadRing => "PadRing",
                Self::PadStrip => "PadStrip",
                Self::PadGroupMode => "PadGroupMode",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkEventType {
        match self {
            Self::Nothing => ffi::GDK_NOTHING,
            Self::Delete => ffi::GDK_DELETE,
            Self::Destroy => ffi::GDK_DESTROY,
            Self::Expose => ffi::GDK_EXPOSE,
            Self::MotionNotify => ffi::GDK_MOTION_NOTIFY,
            Self::ButtonPress => ffi::GDK_BUTTON_PRESS,
            Self::DoubleButtonPress => ffi::GDK_DOUBLE_BUTTON_PRESS,
            Self::TripleButtonPress => ffi::GDK_TRIPLE_BUTTON_PRESS,
            Self::ButtonRelease => ffi::GDK_BUTTON_RELEASE,
            Self::KeyPress => ffi::GDK_KEY_PRESS,
            Self::KeyRelease => ffi::GDK_KEY_RELEASE,
            Self::EnterNotify => ffi::GDK_ENTER_NOTIFY,
            Self::LeaveNotify => ffi::GDK_LEAVE_NOTIFY,
            Self::FocusChange => ffi::GDK_FOCUS_CHANGE,
            Self::Configure => ffi::GDK_CONFIGURE,
            Self::Map => ffi::GDK_MAP,
            Self::Unmap => ffi::GDK_UNMAP,
            Self::PropertyNotify => ffi::GDK_PROPERTY_NOTIFY,
            Self::SelectionClear => ffi::GDK_SELECTION_CLEAR,
            Self::SelectionRequest => ffi::GDK_SELECTION_REQUEST,
            Self::SelectionNotify => ffi::GDK_SELECTION_NOTIFY,
            Self::ProximityIn => ffi::GDK_PROXIMITY_IN,
            Self::ProximityOut => ffi::GDK_PROXIMITY_OUT,
            Self::DragEnter => ffi::GDK_DRAG_ENTER,
            Self::DragLeave => ffi::GDK_DRAG_LEAVE,
            Self::DragMotion => ffi::GDK_DRAG_MOTION,
            Self::DragStatus => ffi::GDK_DRAG_STATUS,
            Self::DropStart => ffi::GDK_DROP_START,
            Self::DropFinished => ffi::GDK_DROP_FINISHED,
            Self::ClientEvent => ffi::GDK_CLIENT_EVENT,
            Self::VisibilityNotify => ffi::GDK_VISIBILITY_NOTIFY,
            Self::Scroll => ffi::GDK_SCROLL,
            Self::WindowState => ffi::GDK_WINDOW_STATE,
            Self::Setting => ffi::GDK_SETTING,
            Self::OwnerChange => ffi::GDK_OWNER_CHANGE,
            Self::GrabBroken => ffi::GDK_GRAB_BROKEN,
            Self::Damage => ffi::GDK_DAMAGE,
            Self::TouchBegin => ffi::GDK_TOUCH_BEGIN,
            Self::TouchUpdate => ffi::GDK_TOUCH_UPDATE,
            Self::TouchEnd => ffi::GDK_TOUCH_END,
            Self::TouchCancel => ffi::GDK_TOUCH_CANCEL,
            Self::TouchpadSwipe => ffi::GDK_TOUCHPAD_SWIPE,
            Self::TouchpadPinch => ffi::GDK_TOUCHPAD_PINCH,
            Self::PadButtonPress => ffi::GDK_PAD_BUTTON_PRESS,
            Self::PadButtonRelease => ffi::GDK_PAD_BUTTON_RELEASE,
            Self::PadRing => ffi::GDK_PAD_RING,
            Self::PadStrip => ffi::GDK_PAD_STRIP,
            Self::PadGroupMode => ffi::GDK_PAD_GROUP_MODE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkEventType> for EventType {
    unsafe fn from_glib(value: ffi::GdkEventType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_NOTHING => Self::Nothing,
            ffi::GDK_DELETE => Self::Delete,
            ffi::GDK_DESTROY => Self::Destroy,
            ffi::GDK_EXPOSE => Self::Expose,
            ffi::GDK_MOTION_NOTIFY => Self::MotionNotify,
            ffi::GDK_BUTTON_PRESS => Self::ButtonPress,
            ffi::GDK_DOUBLE_BUTTON_PRESS => Self::DoubleButtonPress,
            ffi::GDK_TRIPLE_BUTTON_PRESS => Self::TripleButtonPress,
            ffi::GDK_BUTTON_RELEASE => Self::ButtonRelease,
            ffi::GDK_KEY_PRESS => Self::KeyPress,
            ffi::GDK_KEY_RELEASE => Self::KeyRelease,
            ffi::GDK_ENTER_NOTIFY => Self::EnterNotify,
            ffi::GDK_LEAVE_NOTIFY => Self::LeaveNotify,
            ffi::GDK_FOCUS_CHANGE => Self::FocusChange,
            ffi::GDK_CONFIGURE => Self::Configure,
            ffi::GDK_MAP => Self::Map,
            ffi::GDK_UNMAP => Self::Unmap,
            ffi::GDK_PROPERTY_NOTIFY => Self::PropertyNotify,
            ffi::GDK_SELECTION_CLEAR => Self::SelectionClear,
            ffi::GDK_SELECTION_REQUEST => Self::SelectionRequest,
            ffi::GDK_SELECTION_NOTIFY => Self::SelectionNotify,
            ffi::GDK_PROXIMITY_IN => Self::ProximityIn,
            ffi::GDK_PROXIMITY_OUT => Self::ProximityOut,
            ffi::GDK_DRAG_ENTER => Self::DragEnter,
            ffi::GDK_DRAG_LEAVE => Self::DragLeave,
            ffi::GDK_DRAG_MOTION => Self::DragMotion,
            ffi::GDK_DRAG_STATUS => Self::DragStatus,
            ffi::GDK_DROP_START => Self::DropStart,
            ffi::GDK_DROP_FINISHED => Self::DropFinished,
            ffi::GDK_CLIENT_EVENT => Self::ClientEvent,
            ffi::GDK_VISIBILITY_NOTIFY => Self::VisibilityNotify,
            ffi::GDK_SCROLL => Self::Scroll,
            ffi::GDK_WINDOW_STATE => Self::WindowState,
            ffi::GDK_SETTING => Self::Setting,
            ffi::GDK_OWNER_CHANGE => Self::OwnerChange,
            ffi::GDK_GRAB_BROKEN => Self::GrabBroken,
            ffi::GDK_DAMAGE => Self::Damage,
            ffi::GDK_TOUCH_BEGIN => Self::TouchBegin,
            ffi::GDK_TOUCH_UPDATE => Self::TouchUpdate,
            ffi::GDK_TOUCH_END => Self::TouchEnd,
            ffi::GDK_TOUCH_CANCEL => Self::TouchCancel,
            ffi::GDK_TOUCHPAD_SWIPE => Self::TouchpadSwipe,
            ffi::GDK_TOUCHPAD_PINCH => Self::TouchpadPinch,
            ffi::GDK_PAD_BUTTON_PRESS => Self::PadButtonPress,
            ffi::GDK_PAD_BUTTON_RELEASE => Self::PadButtonRelease,
            ffi::GDK_PAD_RING => Self::PadRing,
            ffi::GDK_PAD_STRIP => Self::PadStrip,
            ffi::GDK_PAD_GROUP_MODE => Self::PadGroupMode,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_event_type_get_type()) }
    }
}

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

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

    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 EventType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Indicates which monitor (in a multi-head setup) a window should span over
/// when in fullscreen mode.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkFullscreenMode")]
pub enum FullscreenMode {
    /// Fullscreen on current monitor only.
    #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")]
    CurrentMonitor,
    /// Span across all monitors when fullscreen.
    #[doc(alias = "GDK_FULLSCREEN_ON_ALL_MONITORS")]
    AllMonitors,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for FullscreenMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "FullscreenMode::{}",
            match *self {
                Self::CurrentMonitor => "CurrentMonitor",
                Self::AllMonitors => "AllMonitors",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkFullscreenMode {
        match self {
            Self::CurrentMonitor => ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR,
            Self::AllMonitors => ffi::GDK_FULLSCREEN_ON_ALL_MONITORS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkFullscreenMode> for FullscreenMode {
    unsafe fn from_glib(value: ffi::GdkFullscreenMode) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR => Self::CurrentMonitor,
            ffi::GDK_FULLSCREEN_ON_ALL_MONITORS => Self::AllMonitors,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FullscreenMode {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) }
    }
}

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

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

    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 FullscreenMode {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Error enumeration for [`GLContext`][crate::GLContext].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkGLError")]
pub enum GLError {
    /// OpenGL support is not available
    #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")]
    NotAvailable,
    /// The requested visual format is not supported
    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")]
    UnsupportedFormat,
    /// The requested profile is not supported
    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")]
    UnsupportedProfile,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GLError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "GLError::{}",
            match *self {
                Self::NotAvailable => "NotAvailable",
                Self::UnsupportedFormat => "UnsupportedFormat",
                Self::UnsupportedProfile => "UnsupportedProfile",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkGLError {
        match self {
            Self::NotAvailable => ffi::GDK_GL_ERROR_NOT_AVAILABLE,
            Self::UnsupportedFormat => ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT,
            Self::UnsupportedProfile => ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkGLError> for GLError {
    unsafe fn from_glib(value: ffi::GdkGLError) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_GL_ERROR_NOT_AVAILABLE => Self::NotAvailable,
            ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
            ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Self::UnsupportedProfile,
            value => Self::__Unknown(value),
        }
    }
}

impl ErrorDomain for GLError {
    fn domain() -> Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gdk_gl_error_quark()) }
    }

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::GDK_GL_ERROR_NOT_AVAILABLE => Some(Self::NotAvailable),
            ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Some(Self::UnsupportedFormat),
            ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Some(Self::UnsupportedProfile),
            value => Some(Self::__Unknown(value)),
        }
    }
}

impl StaticType for GLError {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_gl_error_get_type()) }
    }
}

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

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

    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 GLError {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Defines how device grabs interact with other devices.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkGrabOwnership")]
pub enum GrabOwnership {
    /// All other devices’ events are allowed.
    #[doc(alias = "GDK_OWNERSHIP_NONE")]
    None,
    /// Other devices’ events are blocked for the grab window.
    #[doc(alias = "GDK_OWNERSHIP_WINDOW")]
    Window,
    /// Other devices’ events are blocked for the whole application.
    #[doc(alias = "GDK_OWNERSHIP_APPLICATION")]
    Application,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GrabOwnership {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "GrabOwnership::{}",
            match *self {
                Self::None => "None",
                Self::Window => "Window",
                Self::Application => "Application",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkGrabOwnership {
        match self {
            Self::None => ffi::GDK_OWNERSHIP_NONE,
            Self::Window => ffi::GDK_OWNERSHIP_WINDOW,
            Self::Application => ffi::GDK_OWNERSHIP_APPLICATION,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkGrabOwnership> for GrabOwnership {
    unsafe fn from_glib(value: ffi::GdkGrabOwnership) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_OWNERSHIP_NONE => Self::None,
            ffi::GDK_OWNERSHIP_WINDOW => Self::Window,
            ffi::GDK_OWNERSHIP_APPLICATION => Self::Application,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for GrabOwnership {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_grab_ownership_get_type()) }
    }
}

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

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

    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 GrabOwnership {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Returned by [`Device::grab()`][crate::Device::grab()], `gdk_pointer_grab()` and `gdk_keyboard_grab()` to
/// indicate success or the reason for the failure of the grab attempt.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkGrabStatus")]
pub enum GrabStatus {
    /// the resource was successfully grabbed.
    #[doc(alias = "GDK_GRAB_SUCCESS")]
    Success,
    /// the resource is actively grabbed by another client.
    #[doc(alias = "GDK_GRAB_ALREADY_GRABBED")]
    AlreadyGrabbed,
    /// the resource was grabbed more recently than the
    ///  specified time.
    #[doc(alias = "GDK_GRAB_INVALID_TIME")]
    InvalidTime,
    /// the grab window or the `confine_to` window are not
    ///  viewable.
    #[doc(alias = "GDK_GRAB_NOT_VIEWABLE")]
    NotViewable,
    /// the resource is frozen by an active grab of another client.
    #[doc(alias = "GDK_GRAB_FROZEN")]
    Frozen,
    /// the grab failed for some other reason. Since 3.16
    #[doc(alias = "GDK_GRAB_FAILED")]
    Failed,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GrabStatus {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "GrabStatus::{}",
            match *self {
                Self::Success => "Success",
                Self::AlreadyGrabbed => "AlreadyGrabbed",
                Self::InvalidTime => "InvalidTime",
                Self::NotViewable => "NotViewable",
                Self::Frozen => "Frozen",
                Self::Failed => "Failed",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkGrabStatus {
        match self {
            Self::Success => ffi::GDK_GRAB_SUCCESS,
            Self::AlreadyGrabbed => ffi::GDK_GRAB_ALREADY_GRABBED,
            Self::InvalidTime => ffi::GDK_GRAB_INVALID_TIME,
            Self::NotViewable => ffi::GDK_GRAB_NOT_VIEWABLE,
            Self::Frozen => ffi::GDK_GRAB_FROZEN,
            Self::Failed => ffi::GDK_GRAB_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkGrabStatus> for GrabStatus {
    unsafe fn from_glib(value: ffi::GdkGrabStatus) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_GRAB_SUCCESS => Self::Success,
            ffi::GDK_GRAB_ALREADY_GRABBED => Self::AlreadyGrabbed,
            ffi::GDK_GRAB_INVALID_TIME => Self::InvalidTime,
            ffi::GDK_GRAB_NOT_VIEWABLE => Self::NotViewable,
            ffi::GDK_GRAB_FROZEN => Self::Frozen,
            ffi::GDK_GRAB_FAILED => Self::Failed,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for GrabStatus {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_grab_status_get_type()) }
    }
}

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

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

    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 GrabStatus {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Defines the reference point of a window and the meaning of coordinates
/// passed to `gtk_window_move()`. See `gtk_window_move()` and the "implementation
/// notes" section of the
/// [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
/// specification for more details.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkGravity")]
pub enum Gravity {
    /// the reference point is at the top left corner.
    #[doc(alias = "GDK_GRAVITY_NORTH_WEST")]
    NorthWest,
    /// the reference point is in the middle of the top edge.
    #[doc(alias = "GDK_GRAVITY_NORTH")]
    North,
    /// the reference point is at the top right corner.
    #[doc(alias = "GDK_GRAVITY_NORTH_EAST")]
    NorthEast,
    /// the reference point is at the middle of the left edge.
    #[doc(alias = "GDK_GRAVITY_WEST")]
    West,
    /// the reference point is at the center of the window.
    #[doc(alias = "GDK_GRAVITY_CENTER")]
    Center,
    /// the reference point is at the middle of the right edge.
    #[doc(alias = "GDK_GRAVITY_EAST")]
    East,
    /// the reference point is at the lower left corner.
    #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")]
    SouthWest,
    /// the reference point is at the middle of the lower edge.
    #[doc(alias = "GDK_GRAVITY_SOUTH")]
    South,
    /// the reference point is at the lower right corner.
    #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")]
    SouthEast,
    /// the reference point is at the top left corner of the
    ///  window itself, ignoring window manager decorations.
    #[doc(alias = "GDK_GRAVITY_STATIC")]
    Static,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for Gravity {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Gravity::{}",
            match *self {
                Self::NorthWest => "NorthWest",
                Self::North => "North",
                Self::NorthEast => "NorthEast",
                Self::West => "West",
                Self::Center => "Center",
                Self::East => "East",
                Self::SouthWest => "SouthWest",
                Self::South => "South",
                Self::SouthEast => "SouthEast",
                Self::Static => "Static",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkGravity {
        match self {
            Self::NorthWest => ffi::GDK_GRAVITY_NORTH_WEST,
            Self::North => ffi::GDK_GRAVITY_NORTH,
            Self::NorthEast => ffi::GDK_GRAVITY_NORTH_EAST,
            Self::West => ffi::GDK_GRAVITY_WEST,
            Self::Center => ffi::GDK_GRAVITY_CENTER,
            Self::East => ffi::GDK_GRAVITY_EAST,
            Self::SouthWest => ffi::GDK_GRAVITY_SOUTH_WEST,
            Self::South => ffi::GDK_GRAVITY_SOUTH,
            Self::SouthEast => ffi::GDK_GRAVITY_SOUTH_EAST,
            Self::Static => ffi::GDK_GRAVITY_STATIC,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkGravity> for Gravity {
    unsafe fn from_glib(value: ffi::GdkGravity) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_GRAVITY_NORTH_WEST => Self::NorthWest,
            ffi::GDK_GRAVITY_NORTH => Self::North,
            ffi::GDK_GRAVITY_NORTH_EAST => Self::NorthEast,
            ffi::GDK_GRAVITY_WEST => Self::West,
            ffi::GDK_GRAVITY_CENTER => Self::Center,
            ffi::GDK_GRAVITY_EAST => Self::East,
            ffi::GDK_GRAVITY_SOUTH_WEST => Self::SouthWest,
            ffi::GDK_GRAVITY_SOUTH => Self::South,
            ffi::GDK_GRAVITY_SOUTH_EAST => Self::SouthEast,
            ffi::GDK_GRAVITY_STATIC => Self::Static,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Gravity {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_gravity_get_type()) }
    }
}

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

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

    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 Gravity {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// An enumeration that describes the mode of an input device.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkInputMode")]
pub enum InputMode {
    /// the device is disabled and will not report any events.
    #[doc(alias = "GDK_MODE_DISABLED")]
    Disabled,
    /// the device is enabled. The device’s coordinate space
    ///  maps to the entire screen.
    #[doc(alias = "GDK_MODE_SCREEN")]
    Screen,
    /// the device is enabled. The device’s coordinate space
    ///  is mapped to a single window. The manner in which this window
    ///  is chosen is undefined, but it will typically be the same
    ///  way in which the focus window for key events is determined.
    #[doc(alias = "GDK_MODE_WINDOW")]
    Window,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for InputMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "InputMode::{}",
            match *self {
                Self::Disabled => "Disabled",
                Self::Screen => "Screen",
                Self::Window => "Window",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkInputMode {
        match self {
            Self::Disabled => ffi::GDK_MODE_DISABLED,
            Self::Screen => ffi::GDK_MODE_SCREEN,
            Self::Window => ffi::GDK_MODE_WINDOW,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkInputMode> for InputMode {
    unsafe fn from_glib(value: ffi::GdkInputMode) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_MODE_DISABLED => Self::Disabled,
            ffi::GDK_MODE_SCREEN => Self::Screen,
            ffi::GDK_MODE_WINDOW => Self::Window,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for InputMode {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_input_mode_get_type()) }
    }
}

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

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

    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 InputMode {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// An enumeration describing the type of an input device in general terms.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkInputSource")]
pub enum InputSource {
    /// the device is a mouse. (This will be reported for the core
    ///  pointer, even if it is something else, such as a trackball.)
    #[doc(alias = "GDK_SOURCE_MOUSE")]
    Mouse,
    /// the device is a stylus of a graphics tablet or similar device.
    #[doc(alias = "GDK_SOURCE_PEN")]
    Pen,
    /// the device is an eraser. Typically, this would be the other end
    ///  of a stylus on a graphics tablet.
    #[doc(alias = "GDK_SOURCE_ERASER")]
    Eraser,
    /// the device is a graphics tablet “puck” or similar device.
    #[doc(alias = "GDK_SOURCE_CURSOR")]
    Cursor,
    /// the device is a keyboard.
    #[doc(alias = "GDK_SOURCE_KEYBOARD")]
    Keyboard,
    /// the device is a direct-input touch device, such
    ///  as a touchscreen or tablet. This device type has been added in 3.4.
    #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
    Touchscreen,
    /// the device is an indirect touch device, such
    ///  as a touchpad. This device type has been added in 3.4.
    #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
    Touchpad,
    /// the device is a trackpoint. This device type has been
    ///  added in 3.22
    #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
    Trackpoint,
    /// the device is a "pad", a collection of buttons,
    ///  rings and strips found in drawing tablets. This device type has been
    ///  added in 3.22.
    #[doc(alias = "GDK_SOURCE_TABLET_PAD")]
    TabletPad,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for InputSource {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "InputSource::{}",
            match *self {
                Self::Mouse => "Mouse",
                Self::Pen => "Pen",
                Self::Eraser => "Eraser",
                Self::Cursor => "Cursor",
                Self::Keyboard => "Keyboard",
                Self::Touchscreen => "Touchscreen",
                Self::Touchpad => "Touchpad",
                Self::Trackpoint => "Trackpoint",
                Self::TabletPad => "TabletPad",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkInputSource {
        match self {
            Self::Mouse => ffi::GDK_SOURCE_MOUSE,
            Self::Pen => ffi::GDK_SOURCE_PEN,
            Self::Eraser => ffi::GDK_SOURCE_ERASER,
            Self::Cursor => ffi::GDK_SOURCE_CURSOR,
            Self::Keyboard => ffi::GDK_SOURCE_KEYBOARD,
            Self::Touchscreen => ffi::GDK_SOURCE_TOUCHSCREEN,
            Self::Touchpad => ffi::GDK_SOURCE_TOUCHPAD,
            Self::Trackpoint => ffi::GDK_SOURCE_TRACKPOINT,
            Self::TabletPad => ffi::GDK_SOURCE_TABLET_PAD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkInputSource> for InputSource {
    unsafe fn from_glib(value: ffi::GdkInputSource) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_SOURCE_MOUSE => Self::Mouse,
            ffi::GDK_SOURCE_PEN => Self::Pen,
            ffi::GDK_SOURCE_ERASER => Self::Eraser,
            ffi::GDK_SOURCE_CURSOR => Self::Cursor,
            ffi::GDK_SOURCE_KEYBOARD => Self::Keyboard,
            ffi::GDK_SOURCE_TOUCHSCREEN => Self::Touchscreen,
            ffi::GDK_SOURCE_TOUCHPAD => Self::Touchpad,
            ffi::GDK_SOURCE_TRACKPOINT => Self::Trackpoint,
            ffi::GDK_SOURCE_TABLET_PAD => Self::TabletPad,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for InputSource {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_input_source_get_type()) }
    }
}

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

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

    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 InputSource {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// This enum is used with [`Keymap::modifier_mask()`][crate::Keymap::modifier_mask()]
/// in order to determine what modifiers the
/// currently used windowing system backend uses for particular
/// purposes. For example, on X11/Windows, the Control key is used for
/// invoking menu shortcuts (accelerators), whereas on Apple computers
/// it’s the Command key (which correspond to [`ModifierType::CONTROL_MASK`][crate::ModifierType::CONTROL_MASK] and
/// [`ModifierType::MOD2_MASK`][crate::ModifierType::MOD2_MASK], respectively).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkModifierIntent")]
pub enum ModifierIntent {
    /// the primary modifier used to invoke
    ///  menu accelerators.
    #[doc(alias = "GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR")]
    PrimaryAccelerator,
    /// the modifier used to invoke context menus.
    ///  Note that mouse button 3 always triggers context menus. When this modifier
    ///  is not 0, it additionally triggers context menus when used with mouse button 1.
    #[doc(alias = "GDK_MODIFIER_INTENT_CONTEXT_MENU")]
    ContextMenu,
    /// the modifier used to extend selections
    ///  using `modifier`-click or `modifier`-cursor-key
    #[doc(alias = "GDK_MODIFIER_INTENT_EXTEND_SELECTION")]
    ExtendSelection,
    /// the modifier used to modify selections,
    ///  which in most cases means toggling the clicked item into or out of the selection.
    #[doc(alias = "GDK_MODIFIER_INTENT_MODIFY_SELECTION")]
    ModifySelection,
    /// when any of these modifiers is pressed, the
    ///  key event cannot produce a symbol directly. This is meant to be used for
    ///  input methods, and for use cases like typeahead search.
    #[doc(alias = "GDK_MODIFIER_INTENT_NO_TEXT_INPUT")]
    NoTextInput,
    /// the modifier that switches between keyboard
    ///  groups (AltGr on X11/Windows and Option/Alt on OS X).
    #[doc(alias = "GDK_MODIFIER_INTENT_SHIFT_GROUP")]
    ShiftGroup,
    /// The set of modifier masks accepted
    /// as modifiers in accelerators. Needed because Command is mapped to MOD2 on
    /// OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
    /// mod key is problematic at best.
    /// Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125.
    #[doc(alias = "GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK")]
    DefaultModMask,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for ModifierIntent {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "ModifierIntent::{}",
            match *self {
                Self::PrimaryAccelerator => "PrimaryAccelerator",
                Self::ContextMenu => "ContextMenu",
                Self::ExtendSelection => "ExtendSelection",
                Self::ModifySelection => "ModifySelection",
                Self::NoTextInput => "NoTextInput",
                Self::ShiftGroup => "ShiftGroup",
                Self::DefaultModMask => "DefaultModMask",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkModifierIntent {
        match self {
            Self::PrimaryAccelerator => ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
            Self::ContextMenu => ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU,
            Self::ExtendSelection => ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION,
            Self::ModifySelection => ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION,
            Self::NoTextInput => ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
            Self::ShiftGroup => ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP,
            Self::DefaultModMask => ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkModifierIntent> for ModifierIntent {
    unsafe fn from_glib(value: ffi::GdkModifierIntent) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR => Self::PrimaryAccelerator,
            ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU => Self::ContextMenu,
            ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION => Self::ExtendSelection,
            ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION => Self::ModifySelection,
            ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT => Self::NoTextInput,
            ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP => Self::ShiftGroup,
            ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK => Self::DefaultModMask,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ModifierIntent {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_modifier_intent_get_type()) }
    }
}

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

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

    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 ModifierIntent {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the kind of crossing for [`EventCrossing`][crate::EventCrossing].
///
/// See the X11 protocol specification of LeaveNotify for
/// full details of crossing event generation.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkNotifyType")]
pub enum NotifyType {
    /// the window is entered from an ancestor or
    ///  left towards an ancestor.
    #[doc(alias = "GDK_NOTIFY_ANCESTOR")]
    Ancestor,
    /// the pointer moves between an ancestor and an
    ///  inferior of the window.
    #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
    Virtual,
    /// the window is entered from an inferior or
    ///  left towards an inferior.
    #[doc(alias = "GDK_NOTIFY_INFERIOR")]
    Inferior,
    /// the window is entered from or left towards
    ///  a window which is neither an ancestor nor an inferior.
    #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
    Nonlinear,
    /// the pointer moves between two windows
    ///  which are not ancestors of each other and the window is part of
    ///  the ancestor chain between one of these windows and their least
    ///  common ancestor.
    #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")]
    NonlinearVirtual,
    /// an unknown type of enter/leave event occurred.
    #[doc(alias = "GDK_NOTIFY_UNKNOWN")]
    Unknown,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for NotifyType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "NotifyType::{}",
            match *self {
                Self::Ancestor => "Ancestor",
                Self::Virtual => "Virtual",
                Self::Inferior => "Inferior",
                Self::Nonlinear => "Nonlinear",
                Self::NonlinearVirtual => "NonlinearVirtual",
                Self::Unknown => "Unknown",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkNotifyType {
        match self {
            Self::Ancestor => ffi::GDK_NOTIFY_ANCESTOR,
            Self::Virtual => ffi::GDK_NOTIFY_VIRTUAL,
            Self::Inferior => ffi::GDK_NOTIFY_INFERIOR,
            Self::Nonlinear => ffi::GDK_NOTIFY_NONLINEAR,
            Self::NonlinearVirtual => ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL,
            Self::Unknown => ffi::GDK_NOTIFY_UNKNOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkNotifyType> for NotifyType {
    unsafe fn from_glib(value: ffi::GdkNotifyType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_NOTIFY_ANCESTOR => Self::Ancestor,
            ffi::GDK_NOTIFY_VIRTUAL => Self::Virtual,
            ffi::GDK_NOTIFY_INFERIOR => Self::Inferior,
            ffi::GDK_NOTIFY_NONLINEAR => Self::Nonlinear,
            ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL => Self::NonlinearVirtual,
            ffi::GDK_NOTIFY_UNKNOWN => Self::Unknown,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NotifyType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_notify_type_get_type()) }
    }
}

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

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

    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 NotifyType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies why a selection ownership was changed.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkOwnerChange")]
pub enum OwnerChange {
    /// some other app claimed the ownership
    #[doc(alias = "GDK_OWNER_CHANGE_NEW_OWNER")]
    NewOwner,
    /// the window was destroyed
    #[doc(alias = "GDK_OWNER_CHANGE_DESTROY")]
    Destroy,
    /// the client was closed
    #[doc(alias = "GDK_OWNER_CHANGE_CLOSE")]
    Close,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for OwnerChange {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "OwnerChange::{}",
            match *self {
                Self::NewOwner => "NewOwner",
                Self::Destroy => "Destroy",
                Self::Close => "Close",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkOwnerChange {
        match self {
            Self::NewOwner => ffi::GDK_OWNER_CHANGE_NEW_OWNER,
            Self::Destroy => ffi::GDK_OWNER_CHANGE_DESTROY,
            Self::Close => ffi::GDK_OWNER_CHANGE_CLOSE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkOwnerChange> for OwnerChange {
    unsafe fn from_glib(value: ffi::GdkOwnerChange) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_OWNER_CHANGE_NEW_OWNER => Self::NewOwner,
            ffi::GDK_OWNER_CHANGE_DESTROY => Self::Destroy,
            ffi::GDK_OWNER_CHANGE_CLOSE => Self::Close,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for OwnerChange {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_owner_change_get_type()) }
    }
}

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

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

    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 OwnerChange {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Describes how existing data is combined with new data when
/// using `gdk_property_change()`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkPropMode")]
pub enum PropMode {
    /// the new data replaces the existing data.
    #[doc(alias = "GDK_PROP_MODE_REPLACE")]
    Replace,
    /// the new data is prepended to the existing data.
    #[doc(alias = "GDK_PROP_MODE_PREPEND")]
    Prepend,
    /// the new data is appended to the existing data.
    #[doc(alias = "GDK_PROP_MODE_APPEND")]
    Append,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for PropMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "PropMode::{}",
            match *self {
                Self::Replace => "Replace",
                Self::Prepend => "Prepend",
                Self::Append => "Append",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkPropMode {
        match self {
            Self::Replace => ffi::GDK_PROP_MODE_REPLACE,
            Self::Prepend => ffi::GDK_PROP_MODE_PREPEND,
            Self::Append => ffi::GDK_PROP_MODE_APPEND,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkPropMode> for PropMode {
    unsafe fn from_glib(value: ffi::GdkPropMode) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_PROP_MODE_REPLACE => Self::Replace,
            ffi::GDK_PROP_MODE_PREPEND => Self::Prepend,
            ffi::GDK_PROP_MODE_APPEND => Self::Append,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PropMode {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_prop_mode_get_type()) }
    }
}

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

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

    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 PropMode {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the type of a property change for a [`EventProperty`][crate::EventProperty].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkPropertyState")]
pub enum PropertyState {
    /// the property value was changed.
    #[doc(alias = "GDK_PROPERTY_NEW_VALUE")]
    NewValue,
    /// the property was deleted.
    #[doc(alias = "GDK_PROPERTY_DELETE")]
    Delete,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for PropertyState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "PropertyState::{}",
            match *self {
                Self::NewValue => "NewValue",
                Self::Delete => "Delete",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkPropertyState {
        match self {
            Self::NewValue => ffi::GDK_PROPERTY_NEW_VALUE,
            Self::Delete => ffi::GDK_PROPERTY_DELETE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkPropertyState> for PropertyState {
    unsafe fn from_glib(value: ffi::GdkPropertyState) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_PROPERTY_NEW_VALUE => Self::NewValue,
            ffi::GDK_PROPERTY_DELETE => Self::Delete,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PropertyState {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_property_state_get_type()) }
    }
}

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

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

    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 PropertyState {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the direction for [`EventScroll`][crate::EventScroll].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkScrollDirection")]
pub enum ScrollDirection {
    /// the window is scrolled up.
    #[doc(alias = "GDK_SCROLL_UP")]
    Up,
    /// the window is scrolled down.
    #[doc(alias = "GDK_SCROLL_DOWN")]
    Down,
    /// the window is scrolled to the left.
    #[doc(alias = "GDK_SCROLL_LEFT")]
    Left,
    /// the window is scrolled to the right.
    #[doc(alias = "GDK_SCROLL_RIGHT")]
    Right,
    /// the scrolling is determined by the delta values
    ///  in [`EventScroll`][crate::EventScroll]. See `gdk_event_get_scroll_deltas()`. Since: 3.4
    #[doc(alias = "GDK_SCROLL_SMOOTH")]
    Smooth,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for ScrollDirection {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "ScrollDirection::{}",
            match *self {
                Self::Up => "Up",
                Self::Down => "Down",
                Self::Left => "Left",
                Self::Right => "Right",
                Self::Smooth => "Smooth",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkScrollDirection {
        match self {
            Self::Up => ffi::GDK_SCROLL_UP,
            Self::Down => ffi::GDK_SCROLL_DOWN,
            Self::Left => ffi::GDK_SCROLL_LEFT,
            Self::Right => ffi::GDK_SCROLL_RIGHT,
            Self::Smooth => ffi::GDK_SCROLL_SMOOTH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkScrollDirection> for ScrollDirection {
    unsafe fn from_glib(value: ffi::GdkScrollDirection) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_SCROLL_UP => Self::Up,
            ffi::GDK_SCROLL_DOWN => Self::Down,
            ffi::GDK_SCROLL_LEFT => Self::Left,
            ffi::GDK_SCROLL_RIGHT => Self::Right,
            ffi::GDK_SCROLL_SMOOTH => Self::Smooth,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ScrollDirection {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) }
    }
}

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

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

    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 ScrollDirection {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the kind of modification applied to a setting in a
/// [`EventSetting`][crate::EventSetting].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkSettingAction")]
pub enum SettingAction {
    /// a setting was added.
    #[doc(alias = "GDK_SETTING_ACTION_NEW")]
    New,
    /// a setting was changed.
    #[doc(alias = "GDK_SETTING_ACTION_CHANGED")]
    Changed,
    /// a setting was deleted.
    #[doc(alias = "GDK_SETTING_ACTION_DELETED")]
    Deleted,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for SettingAction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "SettingAction::{}",
            match *self {
                Self::New => "New",
                Self::Changed => "Changed",
                Self::Deleted => "Deleted",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkSettingAction {
        match self {
            Self::New => ffi::GDK_SETTING_ACTION_NEW,
            Self::Changed => ffi::GDK_SETTING_ACTION_CHANGED,
            Self::Deleted => ffi::GDK_SETTING_ACTION_DELETED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkSettingAction> for SettingAction {
    unsafe fn from_glib(value: ffi::GdkSettingAction) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_SETTING_ACTION_NEW => Self::New,
            ffi::GDK_SETTING_ACTION_CHANGED => Self::Changed,
            ffi::GDK_SETTING_ACTION_DELETED => Self::Deleted,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SettingAction {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_setting_action_get_type()) }
    }
}

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

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

    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 SettingAction {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// This enumeration describes how the red, green and blue components
/// of physical pixels on an output device are laid out.
#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkSubpixelLayout")]
pub enum SubpixelLayout {
    /// The layout is not known
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")]
    Unknown,
    /// Not organized in this way
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")]
    None,
    /// The layout is horizontal, the order is RGB
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")]
    HorizontalRgb,
    /// The layout is horizontal, the order is BGR
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")]
    HorizontalBgr,
    /// The layout is vertical, the order is RGB
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")]
    VerticalRgb,
    /// The layout is vertical, the order is BGR
    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR")]
    VerticalBgr,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl fmt::Display for SubpixelLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "SubpixelLayout::{}",
            match *self {
                Self::Unknown => "Unknown",
                Self::None => "None",
                Self::HorizontalRgb => "HorizontalRgb",
                Self::HorizontalBgr => "HorizontalBgr",
                Self::VerticalRgb => "VerticalRgb",
                Self::VerticalBgr => "VerticalBgr",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl IntoGlib for SubpixelLayout {
    type GlibType = ffi::GdkSubpixelLayout;

    fn into_glib(self) -> ffi::GdkSubpixelLayout {
        match self {
            Self::Unknown => ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN,
            Self::None => ffi::GDK_SUBPIXEL_LAYOUT_NONE,
            Self::HorizontalRgb => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
            Self::HorizontalBgr => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
            Self::VerticalRgb => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
            Self::VerticalBgr => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout {
    unsafe fn from_glib(value: ffi::GdkSubpixelLayout) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN => Self::Unknown,
            ffi::GDK_SUBPIXEL_LAYOUT_NONE => Self::None,
            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB => Self::HorizontalRgb,
            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR => Self::HorizontalBgr,
            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB => Self::VerticalRgb,
            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR => Self::VerticalBgr,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl StaticType for SubpixelLayout {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_subpixel_layout_get_type()) }
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl glib::value::ValueType for SubpixelLayout {
    type Type = Self;
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
unsafe impl<'a> FromValue<'a> for SubpixelLayout {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    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))
    }
}

#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
impl ToValue for SubpixelLayout {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Specifies the visiblity status of a window for a [`EventVisibility`][crate::EventVisibility].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkVisibilityState")]
pub enum VisibilityState {
    /// the window is completely visible.
    #[doc(alias = "GDK_VISIBILITY_UNOBSCURED")]
    Unobscured,
    /// the window is partially visible.
    #[doc(alias = "GDK_VISIBILITY_PARTIAL")]
    Partial,
    /// the window is not visible at all.
    #[doc(alias = "GDK_VISIBILITY_FULLY_OBSCURED")]
    FullyObscured,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for VisibilityState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "VisibilityState::{}",
            match *self {
                Self::Unobscured => "Unobscured",
                Self::Partial => "Partial",
                Self::FullyObscured => "FullyObscured",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkVisibilityState {
        match self {
            Self::Unobscured => ffi::GDK_VISIBILITY_UNOBSCURED,
            Self::Partial => ffi::GDK_VISIBILITY_PARTIAL,
            Self::FullyObscured => ffi::GDK_VISIBILITY_FULLY_OBSCURED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkVisibilityState> for VisibilityState {
    unsafe fn from_glib(value: ffi::GdkVisibilityState) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_VISIBILITY_UNOBSCURED => Self::Unobscured,
            ffi::GDK_VISIBILITY_PARTIAL => Self::Partial,
            ffi::GDK_VISIBILITY_FULLY_OBSCURED => Self::FullyObscured,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for VisibilityState {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_visibility_state_get_type()) }
    }
}

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

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

    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 VisibilityState {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// A set of values that describe the manner in which the pixel values
/// for a visual are converted into RGB values for display.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkVisualType")]
pub enum VisualType {
    /// Each pixel value indexes a grayscale value
    ///  directly.
    #[doc(alias = "GDK_VISUAL_STATIC_GRAY")]
    StaticGray,
    /// Each pixel is an index into a color map that
    ///  maps pixel values into grayscale values. The color map can be
    ///  changed by an application.
    #[doc(alias = "GDK_VISUAL_GRAYSCALE")]
    Grayscale,
    /// Each pixel value is an index into a predefined,
    ///  unmodifiable color map that maps pixel values into RGB values.
    #[doc(alias = "GDK_VISUAL_STATIC_COLOR")]
    StaticColor,
    /// Each pixel is an index into a color map that
    ///  maps pixel values into rgb values. The color map can be changed by
    ///  an application.
    #[doc(alias = "GDK_VISUAL_PSEUDO_COLOR")]
    PseudoColor,
    /// Each pixel value directly contains red, green,
    ///  and blue components. Use [`Visual::red_pixel_details()`][crate::Visual::red_pixel_details()], etc,
    ///  to obtain information about how the components are assembled into
    ///  a pixel value.
    #[doc(alias = "GDK_VISUAL_TRUE_COLOR")]
    TrueColor,
    /// Each pixel value contains red, green, and blue
    ///  components as for [`TrueColor`][Self::TrueColor], but the components are
    ///  mapped via a color table into the final output table instead of
    ///  being converted directly.
    #[doc(alias = "GDK_VISUAL_DIRECT_COLOR")]
    DirectColor,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for VisualType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "VisualType::{}",
            match *self {
                Self::StaticGray => "StaticGray",
                Self::Grayscale => "Grayscale",
                Self::StaticColor => "StaticColor",
                Self::PseudoColor => "PseudoColor",
                Self::TrueColor => "TrueColor",
                Self::DirectColor => "DirectColor",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkVisualType {
        match self {
            Self::StaticGray => ffi::GDK_VISUAL_STATIC_GRAY,
            Self::Grayscale => ffi::GDK_VISUAL_GRAYSCALE,
            Self::StaticColor => ffi::GDK_VISUAL_STATIC_COLOR,
            Self::PseudoColor => ffi::GDK_VISUAL_PSEUDO_COLOR,
            Self::TrueColor => ffi::GDK_VISUAL_TRUE_COLOR,
            Self::DirectColor => ffi::GDK_VISUAL_DIRECT_COLOR,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkVisualType> for VisualType {
    unsafe fn from_glib(value: ffi::GdkVisualType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_VISUAL_STATIC_GRAY => Self::StaticGray,
            ffi::GDK_VISUAL_GRAYSCALE => Self::Grayscale,
            ffi::GDK_VISUAL_STATIC_COLOR => Self::StaticColor,
            ffi::GDK_VISUAL_PSEUDO_COLOR => Self::PseudoColor,
            ffi::GDK_VISUAL_TRUE_COLOR => Self::TrueColor,
            ffi::GDK_VISUAL_DIRECT_COLOR => Self::DirectColor,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for VisualType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_visual_type_get_type()) }
    }
}

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

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

    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 VisualType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Determines a window edge or corner.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkWindowEdge")]
pub enum WindowEdge {
    /// the top left corner.
    #[doc(alias = "GDK_WINDOW_EDGE_NORTH_WEST")]
    NorthWest,
    /// the top edge.
    #[doc(alias = "GDK_WINDOW_EDGE_NORTH")]
    North,
    /// the top right corner.
    #[doc(alias = "GDK_WINDOW_EDGE_NORTH_EAST")]
    NorthEast,
    /// the left edge.
    #[doc(alias = "GDK_WINDOW_EDGE_WEST")]
    West,
    /// the right edge.
    #[doc(alias = "GDK_WINDOW_EDGE_EAST")]
    East,
    /// the lower left corner.
    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_WEST")]
    SouthWest,
    /// the lower edge.
    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH")]
    South,
    /// the lower right corner.
    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_EAST")]
    SouthEast,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for WindowEdge {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "WindowEdge::{}",
            match *self {
                Self::NorthWest => "NorthWest",
                Self::North => "North",
                Self::NorthEast => "NorthEast",
                Self::West => "West",
                Self::East => "East",
                Self::SouthWest => "SouthWest",
                Self::South => "South",
                Self::SouthEast => "SouthEast",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkWindowEdge {
        match self {
            Self::NorthWest => ffi::GDK_WINDOW_EDGE_NORTH_WEST,
            Self::North => ffi::GDK_WINDOW_EDGE_NORTH,
            Self::NorthEast => ffi::GDK_WINDOW_EDGE_NORTH_EAST,
            Self::West => ffi::GDK_WINDOW_EDGE_WEST,
            Self::East => ffi::GDK_WINDOW_EDGE_EAST,
            Self::SouthWest => ffi::GDK_WINDOW_EDGE_SOUTH_WEST,
            Self::South => ffi::GDK_WINDOW_EDGE_SOUTH,
            Self::SouthEast => ffi::GDK_WINDOW_EDGE_SOUTH_EAST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkWindowEdge> for WindowEdge {
    unsafe fn from_glib(value: ffi::GdkWindowEdge) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_WINDOW_EDGE_NORTH_WEST => Self::NorthWest,
            ffi::GDK_WINDOW_EDGE_NORTH => Self::North,
            ffi::GDK_WINDOW_EDGE_NORTH_EAST => Self::NorthEast,
            ffi::GDK_WINDOW_EDGE_WEST => Self::West,
            ffi::GDK_WINDOW_EDGE_EAST => Self::East,
            ffi::GDK_WINDOW_EDGE_SOUTH_WEST => Self::SouthWest,
            ffi::GDK_WINDOW_EDGE_SOUTH => Self::South,
            ffi::GDK_WINDOW_EDGE_SOUTH_EAST => Self::SouthEast,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for WindowEdge {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_window_edge_get_type()) }
    }
}

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

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

    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 WindowEdge {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// Describes the kind of window.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkWindowType")]
pub enum WindowType {
    /// root window; this window has no parent, covers the entire
    ///  screen, and is created by the window system
    #[doc(alias = "GDK_WINDOW_ROOT")]
    Root,
    /// toplevel window (used to implement `GtkWindow`)
    #[doc(alias = "GDK_WINDOW_TOPLEVEL")]
    Toplevel,
    /// child window (used to implement e.g. `GtkEntry`)
    #[doc(alias = "GDK_WINDOW_CHILD")]
    Child,
    /// override redirect temporary window (used to implement
    ///  `GtkMenu`)
    #[doc(alias = "GDK_WINDOW_TEMP")]
    Temp,
    /// foreign window (see `gdk_window_foreign_new()`)
    #[doc(alias = "GDK_WINDOW_FOREIGN")]
    Foreign,
    /// offscreen window (see
    ///  [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18
    #[doc(alias = "GDK_WINDOW_OFFSCREEN")]
    Offscreen,
    /// subsurface-based window; This window is visually
    ///  tied to a toplevel, and is moved/stacked with it. Currently this window
    ///  type is only implemented in Wayland. Since 3.14
    #[doc(alias = "GDK_WINDOW_SUBSURFACE")]
    Subsurface,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for WindowType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "WindowType::{}",
            match *self {
                Self::Root => "Root",
                Self::Toplevel => "Toplevel",
                Self::Child => "Child",
                Self::Temp => "Temp",
                Self::Foreign => "Foreign",
                Self::Offscreen => "Offscreen",
                Self::Subsurface => "Subsurface",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkWindowType {
        match self {
            Self::Root => ffi::GDK_WINDOW_ROOT,
            Self::Toplevel => ffi::GDK_WINDOW_TOPLEVEL,
            Self::Child => ffi::GDK_WINDOW_CHILD,
            Self::Temp => ffi::GDK_WINDOW_TEMP,
            Self::Foreign => ffi::GDK_WINDOW_FOREIGN,
            Self::Offscreen => ffi::GDK_WINDOW_OFFSCREEN,
            Self::Subsurface => ffi::GDK_WINDOW_SUBSURFACE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkWindowType> for WindowType {
    unsafe fn from_glib(value: ffi::GdkWindowType) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_WINDOW_ROOT => Self::Root,
            ffi::GDK_WINDOW_TOPLEVEL => Self::Toplevel,
            ffi::GDK_WINDOW_CHILD => Self::Child,
            ffi::GDK_WINDOW_TEMP => Self::Temp,
            ffi::GDK_WINDOW_FOREIGN => Self::Foreign,
            ffi::GDK_WINDOW_OFFSCREEN => Self::Offscreen,
            ffi::GDK_WINDOW_SUBSURFACE => Self::Subsurface,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for WindowType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_window_type_get_type()) }
    }
}

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

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

    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 WindowType {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// These are hints for the window manager that indicate what type of function
/// the window has. The window manager can use this when determining decoration
/// and behaviour of the window. The hint must be set before mapping the window.
///
/// See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
/// specification for more details about window types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkWindowTypeHint")]
pub enum WindowTypeHint {
    /// Normal toplevel window.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_NORMAL")]
    Normal,
    /// Dialog window.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DIALOG")]
    Dialog,
    /// Window used to implement a menu; GTK+ uses
    ///  this hint only for torn-off menus, see `GtkTearoffMenuItem`.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_MENU")]
    Menu,
    /// Window used to implement toolbars.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLBAR")]
    Toolbar,
    /// Window used to display a splash
    ///  screen during application startup.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_SPLASHSCREEN")]
    Splashscreen,
    /// Utility windows which are not detached
    ///  toolbars or dialogs.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_UTILITY")]
    Utility,
    /// Used for creating dock or panel windows.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DOCK")]
    Dock,
    /// Used for creating the desktop background
    ///  window.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DESKTOP")]
    Desktop,
    /// A menu that belongs to a menubar.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU")]
    DropdownMenu,
    /// A menu that does not belong to a menubar,
    ///  e.g. a context menu.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_POPUP_MENU")]
    PopupMenu,
    /// A tooltip.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLTIP")]
    Tooltip,
    /// A notification - typically a “bubble”
    ///  that belongs to a status icon.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_NOTIFICATION")]
    Notification,
    /// A popup from a combo box.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_COMBO")]
    Combo,
    /// A window that is used to implement a DND cursor.
    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DND")]
    Dnd,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for WindowTypeHint {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "WindowTypeHint::{}",
            match *self {
                Self::Normal => "Normal",
                Self::Dialog => "Dialog",
                Self::Menu => "Menu",
                Self::Toolbar => "Toolbar",
                Self::Splashscreen => "Splashscreen",
                Self::Utility => "Utility",
                Self::Dock => "Dock",
                Self::Desktop => "Desktop",
                Self::DropdownMenu => "DropdownMenu",
                Self::PopupMenu => "PopupMenu",
                Self::Tooltip => "Tooltip",
                Self::Notification => "Notification",
                Self::Combo => "Combo",
                Self::Dnd => "Dnd",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkWindowTypeHint {
        match self {
            Self::Normal => ffi::GDK_WINDOW_TYPE_HINT_NORMAL,
            Self::Dialog => ffi::GDK_WINDOW_TYPE_HINT_DIALOG,
            Self::Menu => ffi::GDK_WINDOW_TYPE_HINT_MENU,
            Self::Toolbar => ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR,
            Self::Splashscreen => ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
            Self::Utility => ffi::GDK_WINDOW_TYPE_HINT_UTILITY,
            Self::Dock => ffi::GDK_WINDOW_TYPE_HINT_DOCK,
            Self::Desktop => ffi::GDK_WINDOW_TYPE_HINT_DESKTOP,
            Self::DropdownMenu => ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,
            Self::PopupMenu => ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU,
            Self::Tooltip => ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP,
            Self::Notification => ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION,
            Self::Combo => ffi::GDK_WINDOW_TYPE_HINT_COMBO,
            Self::Dnd => ffi::GDK_WINDOW_TYPE_HINT_DND,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkWindowTypeHint> for WindowTypeHint {
    unsafe fn from_glib(value: ffi::GdkWindowTypeHint) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_WINDOW_TYPE_HINT_NORMAL => Self::Normal,
            ffi::GDK_WINDOW_TYPE_HINT_DIALOG => Self::Dialog,
            ffi::GDK_WINDOW_TYPE_HINT_MENU => Self::Menu,
            ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR => Self::Toolbar,
            ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN => Self::Splashscreen,
            ffi::GDK_WINDOW_TYPE_HINT_UTILITY => Self::Utility,
            ffi::GDK_WINDOW_TYPE_HINT_DOCK => Self::Dock,
            ffi::GDK_WINDOW_TYPE_HINT_DESKTOP => Self::Desktop,
            ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU => Self::DropdownMenu,
            ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU => Self::PopupMenu,
            ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP => Self::Tooltip,
            ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION => Self::Notification,
            ffi::GDK_WINDOW_TYPE_HINT_COMBO => Self::Combo,
            ffi::GDK_WINDOW_TYPE_HINT_DND => Self::Dnd,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for WindowTypeHint {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_window_type_hint_get_type()) }
    }
}

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

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

    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 WindowTypeHint {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

/// [`InputOutput`][Self::InputOutput] windows are the standard kind of window you might expect.
/// Such windows receive events and are also displayed on screen.
/// [`InputOnly`][Self::InputOnly] windows are invisible; they are usually placed above other
/// windows in order to trap or filter the events. You can’t draw on
/// [`InputOnly`][Self::InputOnly] windows.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkWindowWindowClass")]
pub enum WindowWindowClass {
    /// window for graphics and events
    #[doc(alias = "GDK_INPUT_OUTPUT")]
    InputOutput,
    /// window for events only
    #[doc(alias = "GDK_INPUT_ONLY")]
    InputOnly,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for WindowWindowClass {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "WindowWindowClass::{}",
            match *self {
                Self::InputOutput => "InputOutput",
                Self::InputOnly => "InputOnly",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkWindowWindowClass {
        match self {
            Self::InputOutput => ffi::GDK_INPUT_OUTPUT,
            Self::InputOnly => ffi::GDK_INPUT_ONLY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkWindowWindowClass> for WindowWindowClass {
    unsafe fn from_glib(value: ffi::GdkWindowWindowClass) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::GDK_INPUT_OUTPUT => Self::InputOutput,
            ffi::GDK_INPUT_ONLY => Self::InputOnly,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for WindowWindowClass {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gdk_window_window_class_get_type()) }
    }
}

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

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

    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 WindowWindowClass {
    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
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}