// 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::{prelude::*, translate::*};
use std::fmt;

/// Defines how device axes are interpreted by GTK.
///
/// 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 as the scroll x delta
    #[doc(alias = "GDK_AXIS_DELTA_X")]
    DeltaX,
    /// the axis is used as the scroll y delta
    #[doc(alias = "GDK_AXIS_DELTA_Y")]
    DeltaY,
    /// 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
    #[doc(alias = "GDK_AXIS_DISTANCE")]
    Distance,
    /// the axis is used for pen rotation information
    #[doc(alias = "GDK_AXIS_ROTATION")]
    Rotation,
    /// the axis is used for pen slider information
    #[doc(alias = "GDK_AXIS_SLIDER")]
    Slider,
    #[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::DeltaX => "DeltaX",
                Self::DeltaY => "DeltaY",
                Self::Pressure => "Pressure",
                Self::Xtilt => "Xtilt",
                Self::Ytilt => "Ytilt",
                Self::Wheel => "Wheel",
                Self::Distance => "Distance",
                Self::Rotation => "Rotation",
                Self::Slider => "Slider",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    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::DeltaX => ffi::GDK_AXIS_DELTA_X,
            Self::DeltaY => ffi::GDK_AXIS_DELTA_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::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkAxisUse> for AxisUse {
    #[inline]
    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_DELTA_X => Self::DeltaX,
            ffi::GDK_AXIS_DELTA_Y => Self::DeltaY,
            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,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Specifies the crossing mode for enter and leave events.
#[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 surface.
    #[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 surface.
    #[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 surface.
    #[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;

    #[inline]
    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 {
    #[inline]
    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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// A pad feature.
#[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),
}

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

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

    #[inline]
    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,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature {
    #[inline]
    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),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Indicates the specific type of tool being used being a tablet. Such as an
/// airbrush, pencil, etc.
#[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),
}

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

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

    #[inline]
    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,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType {
    #[inline]
    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),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Used in [`Drag`][crate::Drag] to the reason of a cancelled DND operation.
#[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),
}

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

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

    #[inline]
    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,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason {
    #[inline]
    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),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Specifies the type of the event.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkEventType")]
pub enum EventType {
    /// the window manager has requested that the toplevel surface be
    ///   hidden or destroyed, usually when the user clicks on a special icon in the
    ///   title bar.
    #[doc(alias = "GDK_DELETE")]
    Delete,
    /// 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,
    /// 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 surface.
    #[doc(alias = "GDK_ENTER_NOTIFY")]
    EnterNotify,
    /// the pointer has left the surface.
    #[doc(alias = "GDK_LEAVE_NOTIFY")]
    LeaveNotify,
    /// the keyboard focus has entered or left the surface.
    #[doc(alias = "GDK_FOCUS_CHANGE")]
    FocusChange,
    /// 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 surface while a drag is in progress.
    #[doc(alias = "GDK_DRAG_ENTER")]
    DragEnter,
    /// the mouse has left the surface while a drag is in progress.
    #[doc(alias = "GDK_DRAG_LEAVE")]
    DragLeave,
    /// the mouse has moved in the surface while a drag is in
    ///   progress.
    #[doc(alias = "GDK_DRAG_MOTION")]
    DragMotion,
    /// a drop operation onto the surface has started.
    #[doc(alias = "GDK_DROP_START")]
    DropStart,
    /// the scroll wheel was turned
    #[doc(alias = "GDK_SCROLL")]
    Scroll,
    /// a pointer or keyboard grab was broken.
    #[doc(alias = "GDK_GRAB_BROKEN")]
    GrabBroken,
    /// A new touch event sequence has just started.
    #[doc(alias = "GDK_TOUCH_BEGIN")]
    TouchBegin,
    /// A touch event sequence has been updated.
    #[doc(alias = "GDK_TOUCH_UPDATE")]
    TouchUpdate,
    /// A touch event sequence has finished.
    #[doc(alias = "GDK_TOUCH_END")]
    TouchEnd,
    /// A touch event sequence has been canceled.
    #[doc(alias = "GDK_TOUCH_CANCEL")]
    TouchCancel,
    /// A touchpad swipe gesture event, the current state
    ///   is determined by its phase field.
    #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
    TouchpadSwipe,
    /// A touchpad pinch gesture event, the current state
    ///   is determined by its phase field.
    #[doc(alias = "GDK_TOUCHPAD_PINCH")]
    TouchpadPinch,
    /// A tablet pad button press event.
    #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
    PadButtonPress,
    /// A tablet pad button release event.
    #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
    PadButtonRelease,
    /// A tablet pad axis event from a "ring".
    #[doc(alias = "GDK_PAD_RING")]
    PadRing,
    /// A tablet pad axis event from a "strip".
    #[doc(alias = "GDK_PAD_STRIP")]
    PadStrip,
    /// A tablet pad group mode change.
    #[doc(alias = "GDK_PAD_GROUP_MODE")]
    PadGroupMode,
    /// A touchpad hold gesture event, the current state
    ///   is determined by its phase field. Since: 4.6
    #[cfg(feature = "v4_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
    #[doc(alias = "GDK_TOUCHPAD_HOLD")]
    TouchpadHold,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for EventType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "EventType::{}",
            match *self {
                Self::Delete => "Delete",
                Self::MotionNotify => "MotionNotify",
                Self::ButtonPress => "ButtonPress",
                Self::ButtonRelease => "ButtonRelease",
                Self::KeyPress => "KeyPress",
                Self::KeyRelease => "KeyRelease",
                Self::EnterNotify => "EnterNotify",
                Self::LeaveNotify => "LeaveNotify",
                Self::FocusChange => "FocusChange",
                Self::ProximityIn => "ProximityIn",
                Self::ProximityOut => "ProximityOut",
                Self::DragEnter => "DragEnter",
                Self::DragLeave => "DragLeave",
                Self::DragMotion => "DragMotion",
                Self::DropStart => "DropStart",
                Self::Scroll => "Scroll",
                Self::GrabBroken => "GrabBroken",
                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",
                #[cfg(feature = "v4_8")]
                Self::TouchpadHold => "TouchpadHold",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkEventType {
        match self {
            Self::Delete => ffi::GDK_DELETE,
            Self::MotionNotify => ffi::GDK_MOTION_NOTIFY,
            Self::ButtonPress => ffi::GDK_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::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::DropStart => ffi::GDK_DROP_START,
            Self::Scroll => ffi::GDK_SCROLL,
            Self::GrabBroken => ffi::GDK_GRAB_BROKEN,
            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,
            #[cfg(feature = "v4_8")]
            Self::TouchpadHold => ffi::GDK_TOUCHPAD_HOLD,
            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_DELETE => Self::Delete,
            ffi::GDK_MOTION_NOTIFY => Self::MotionNotify,
            ffi::GDK_BUTTON_PRESS => Self::ButtonPress,
            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_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_DROP_START => Self::DropStart,
            ffi::GDK_SCROLL => Self::Scroll,
            ffi::GDK_GRAB_BROKEN => Self::GrabBroken,
            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,
            #[cfg(feature = "v4_8")]
            ffi::GDK_TOUCHPAD_HOLD => Self::TouchpadHold,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Indicates which monitor a surface 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;

    #[inline]
    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 {
    #[inline]
    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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// 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,
    /// The shader compilation failed
    #[doc(alias = "GDK_GL_ERROR_COMPILATION_FAILED")]
    CompilationFailed,
    /// The shader linking failed
    #[doc(alias = "GDK_GL_ERROR_LINK_FAILED")]
    LinkFailed,
    #[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",
                Self::CompilationFailed => "CompilationFailed",
                Self::LinkFailed => "LinkFailed",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    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::CompilationFailed => ffi::GDK_GL_ERROR_COMPILATION_FAILED,
            Self::LinkFailed => ffi::GDK_GL_ERROR_LINK_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkGLError> for GLError {
    #[inline]
    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,
            ffi::GDK_GL_ERROR_COMPILATION_FAILED => Self::CompilationFailed,
            ffi::GDK_GL_ERROR_LINK_FAILED => Self::LinkFailed,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for GLError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

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

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Defines the reference point of a surface and is used in [`PopupLayout`][crate::PopupLayout].
#[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 surface.
    #[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
    ///  surface 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;

    #[inline]
    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 {
    #[inline]
    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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_gravity_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// 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 a keyboard.
    #[doc(alias = "GDK_SOURCE_KEYBOARD")]
    Keyboard,
    /// the device is a direct-input touch device, such
    ///   as a touchscreen or tablet
    #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
    Touchscreen,
    /// the device is an indirect touch device, such
    ///   as a touchpad
    #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
    Touchpad,
    /// the device is a trackpoint
    #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
    Trackpoint,
    /// the device is a "pad", a collection of buttons,
    ///   rings and strips found in drawing tablets
    #[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::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;

    #[inline]
    fn into_glib(self) -> ffi::GdkInputSource {
        match self {
            Self::Mouse => ffi::GDK_SOURCE_MOUSE,
            Self::Pen => ffi::GDK_SOURCE_PEN,
            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 {
    #[inline]
    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_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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_input_source_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// Describes how well an event matches a given keyval and modifiers.
///
/// [`KeyMatch`][crate::KeyMatch] values are returned by [`KeyEvent::matches()`][crate::KeyEvent::matches()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkKeyMatch")]
pub enum KeyMatch {
    /// The key event does not match
    #[doc(alias = "GDK_KEY_MATCH_NONE")]
    None,
    /// The key event matches if keyboard state
    ///   (specifically, the currently active group) is ignored
    #[doc(alias = "GDK_KEY_MATCH_PARTIAL")]
    Partial,
    /// The key event matches
    #[doc(alias = "GDK_KEY_MATCH_EXACT")]
    Exact,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    #[inline]
    fn into_glib(self) -> ffi::GdkKeyMatch {
        match self {
            Self::None => ffi::GDK_KEY_MATCH_NONE,
            Self::Partial => ffi::GDK_KEY_MATCH_PARTIAL,
            Self::Exact => ffi::GDK_KEY_MATCH_EXACT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GDK_KEY_MATCH_NONE => Self::None,
            ffi::GDK_KEY_MATCH_PARTIAL => Self::Partial,
            ffi::GDK_KEY_MATCH_EXACT => Self::Exact,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// [`MemoryFormat`][crate::MemoryFormat] describes formats that image data can have in memory.
///
/// It describes formats by listing the contents of the memory passed to it.
/// So GDK_MEMORY_A8R8G8B8 will be 1 byte (8 bits) of alpha, followed by a
/// byte each of red, green and blue. It is not endian-dependent, so
/// CAIRO_FORMAT_ARGB32 is represented by different `GdkMemoryFormats`
/// on architectures with different endiannesses.
///
/// Its naming is modelled after
/// [VkFormat](https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VkFormat)
/// for details).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkMemoryFormat")]
pub enum MemoryFormat {
    /// 4 bytes; for blue, green, red, alpha.
    ///   The color values are premultiplied with the alpha value.
    #[doc(alias = "GDK_MEMORY_B8G8R8A8_PREMULTIPLIED")]
    B8g8r8a8Premultiplied,
    /// 4 bytes; for alpha, red, green, blue.
    ///   The color values are premultiplied with the alpha value.
    #[doc(alias = "GDK_MEMORY_A8R8G8B8_PREMULTIPLIED")]
    A8r8g8b8Premultiplied,
    /// 4 bytes; for red, green, blue, alpha
    ///   The color values are premultiplied with the alpha value.
    #[doc(alias = "GDK_MEMORY_R8G8B8A8_PREMULTIPLIED")]
    R8g8b8a8Premultiplied,
    /// 4 bytes; for blue, green, red, alpha.
    #[doc(alias = "GDK_MEMORY_B8G8R8A8")]
    B8g8r8a8,
    /// 4 bytes; for alpha, red, green, blue.
    #[doc(alias = "GDK_MEMORY_A8R8G8B8")]
    A8r8g8b8,
    /// 4 bytes; for red, green, blue, alpha.
    #[doc(alias = "GDK_MEMORY_R8G8B8A8")]
    R8g8b8a8,
    /// 4 bytes; for alpha, blue, green, red.
    #[doc(alias = "GDK_MEMORY_A8B8G8R8")]
    A8b8g8r8,
    /// 3 bytes; for red, green, blue. The data is opaque.
    #[doc(alias = "GDK_MEMORY_R8G8B8")]
    R8g8b8,
    /// 3 bytes; for blue, green, red. The data is opaque.
    #[doc(alias = "GDK_MEMORY_B8G8R8")]
    B8g8r8,
    /// 3 guint16 values; for red, green, blue. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16")]
    R16g16b16,
    /// 4 guint16 values; for red, green,
    ///   blue, alpha. The color values are premultiplied with the alpha value.
    ///  Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16A16_PREMULTIPLIED")]
    R16g16b16a16Premultiplied,
    /// 4 guint16 values; for red, green, blue, alpha.
    ///  Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16A16")]
    R16g16b16a16,
    /// 3 half-float values; for red, green, blue.
    ///   The data is opaque. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16_FLOAT")]
    R16g16b16Float,
    /// 4 half-float values; for
    ///   red, green, blue and alpha. The color values are premultiplied with
    ///   the alpha value. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED")]
    R16g16b16a16FloatPremultiplied,
    /// 4 half-float values; for red, green,
    ///   blue and alpha. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT")]
    R16g16b16a16Float,
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R32G32B32_FLOAT")]
    R32g32b32Float,
    /// 4 float values; for
    ///   red, green, blue and alpha. The color values are premultiplied with
    ///   the alpha value. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED")]
    R32g32b32a32FloatPremultiplied,
    /// 4 float values; for red, green, blue and
    ///   alpha. Since: 4.6
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT")]
    R32g32b32a32Float,
    /// 2 bytes; for grayscale, alpha. The color
    ///   values are premultiplied with the alpha value. Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G8A8_PREMULTIPLIED")]
    G8a8Premultiplied,
    /// 2 bytes; for grayscale, alpha. Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G8A8")]
    G8a8,
    /// One byte; for grayscale. The data is opaque.
    ///   Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G8")]
    G8,
    /// 2 guint16 values; for grayscale, alpha.
    ///  The color values are premultiplied with the alpha value. Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G16A16_PREMULTIPLIED")]
    G16a16Premultiplied,
    /// 2 guint16 values; for grayscale, alpha. Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G16A16")]
    G16a16,
    /// One guint16 value; for grayscale. The data is opaque.
    ///   Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_G16")]
    G16,
    /// One byte; for alpha.
    ///   Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_A8")]
    A8,
    /// One guint16 value; for alpha.
    ///   Since: 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_A16")]
    A16,
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_A16_FLOAT")]
    A16Float,
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GDK_MEMORY_A32_FLOAT")]
    A32Float,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for MemoryFormat {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "MemoryFormat::{}",
            match *self {
                Self::B8g8r8a8Premultiplied => "B8g8r8a8Premultiplied",
                Self::A8r8g8b8Premultiplied => "A8r8g8b8Premultiplied",
                Self::R8g8b8a8Premultiplied => "R8g8b8a8Premultiplied",
                Self::B8g8r8a8 => "B8g8r8a8",
                Self::A8r8g8b8 => "A8r8g8b8",
                Self::R8g8b8a8 => "R8g8b8a8",
                Self::A8b8g8r8 => "A8b8g8r8",
                Self::R8g8b8 => "R8g8b8",
                Self::B8g8r8 => "B8g8r8",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16 => "R16g16b16",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16a16Premultiplied => "R16g16b16a16Premultiplied",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16a16 => "R16g16b16a16",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16Float => "R16g16b16Float",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16a16FloatPremultiplied => "R16g16b16a16FloatPremultiplied",
                #[cfg(feature = "v4_6")]
                Self::R16g16b16a16Float => "R16g16b16a16Float",
                #[cfg(feature = "v4_6")]
                Self::R32g32b32Float => "R32g32b32Float",
                #[cfg(feature = "v4_6")]
                Self::R32g32b32a32FloatPremultiplied => "R32g32b32a32FloatPremultiplied",
                #[cfg(feature = "v4_6")]
                Self::R32g32b32a32Float => "R32g32b32a32Float",
                #[cfg(feature = "v4_12")]
                Self::G8a8Premultiplied => "G8a8Premultiplied",
                #[cfg(feature = "v4_12")]
                Self::G8a8 => "G8a8",
                #[cfg(feature = "v4_12")]
                Self::G8 => "G8",
                #[cfg(feature = "v4_12")]
                Self::G16a16Premultiplied => "G16a16Premultiplied",
                #[cfg(feature = "v4_12")]
                Self::G16a16 => "G16a16",
                #[cfg(feature = "v4_12")]
                Self::G16 => "G16",
                #[cfg(feature = "v4_12")]
                Self::A8 => "A8",
                #[cfg(feature = "v4_12")]
                Self::A16 => "A16",
                #[cfg(feature = "v4_12")]
                Self::A16Float => "A16Float",
                #[cfg(feature = "v4_12")]
                Self::A32Float => "A32Float",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GdkMemoryFormat {
        match self {
            Self::B8g8r8a8Premultiplied => ffi::GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
            Self::A8r8g8b8Premultiplied => ffi::GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
            Self::R8g8b8a8Premultiplied => ffi::GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
            Self::B8g8r8a8 => ffi::GDK_MEMORY_B8G8R8A8,
            Self::A8r8g8b8 => ffi::GDK_MEMORY_A8R8G8B8,
            Self::R8g8b8a8 => ffi::GDK_MEMORY_R8G8B8A8,
            Self::A8b8g8r8 => ffi::GDK_MEMORY_A8B8G8R8,
            Self::R8g8b8 => ffi::GDK_MEMORY_R8G8B8,
            Self::B8g8r8 => ffi::GDK_MEMORY_B8G8R8,
            #[cfg(feature = "v4_6")]
            Self::R16g16b16 => ffi::GDK_MEMORY_R16G16B16,
            #[cfg(feature = "v4_6")]
            Self::R16g16b16a16Premultiplied => ffi::GDK_MEMORY_R16G16B16A16_PREMULTIPLIED,
            #[cfg(feature = "v4_6")]
            Self::R16g16b16a16 => ffi::GDK_MEMORY_R16G16B16A16,
            #[cfg(feature = "v4_6")]
            Self::R16g16b16Float => ffi::GDK_MEMORY_R16G16B16_FLOAT,
            #[cfg(feature = "v4_6")]
            Self::R16g16b16a16FloatPremultiplied => {
                ffi::GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED
            }
            #[cfg(feature = "v4_6")]
            Self::R16g16b16a16Float => ffi::GDK_MEMORY_R16G16B16A16_FLOAT,
            #[cfg(feature = "v4_6")]
            Self::R32g32b32Float => ffi::GDK_MEMORY_R32G32B32_FLOAT,
            #[cfg(feature = "v4_6")]
            Self::R32g32b32a32FloatPremultiplied => {
                ffi::GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED
            }
            #[cfg(feature = "v4_6")]
            Self::R32g32b32a32Float => ffi::GDK_MEMORY_R32G32B32A32_FLOAT,
            #[cfg(feature = "v4_12")]
            Self::G8a8Premultiplied => ffi::GDK_MEMORY_G8A8_PREMULTIPLIED,
            #[cfg(feature = "v4_12")]
            Self::G8a8 => ffi::GDK_MEMORY_G8A8,
            #[cfg(feature = "v4_12")]
            Self::G8 => ffi::GDK_MEMORY_G8,
            #[cfg(feature = "v4_12")]
            Self::G16a16Premultiplied => ffi::GDK_MEMORY_G16A16_PREMULTIPLIED,
            #[cfg(feature = "v4_12")]
            Self::G16a16 => ffi::GDK_MEMORY_G16A16,
            #[cfg(feature = "v4_12")]
            Self::G16 => ffi::GDK_MEMORY_G16,
            #[cfg(feature = "v4_12")]
            Self::A8 => ffi::GDK_MEMORY_A8,
            #[cfg(feature = "v4_12")]
            Self::A16 => ffi::GDK_MEMORY_A16,
            #[cfg(feature = "v4_12")]
            Self::A16Float => ffi::GDK_MEMORY_A16_FLOAT,
            #[cfg(feature = "v4_12")]
            Self::A32Float => ffi::GDK_MEMORY_A32_FLOAT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GDK_MEMORY_B8G8R8A8_PREMULTIPLIED => Self::B8g8r8a8Premultiplied,
            ffi::GDK_MEMORY_A8R8G8B8_PREMULTIPLIED => Self::A8r8g8b8Premultiplied,
            ffi::GDK_MEMORY_R8G8B8A8_PREMULTIPLIED => Self::R8g8b8a8Premultiplied,
            ffi::GDK_MEMORY_B8G8R8A8 => Self::B8g8r8a8,
            ffi::GDK_MEMORY_A8R8G8B8 => Self::A8r8g8b8,
            ffi::GDK_MEMORY_R8G8B8A8 => Self::R8g8b8a8,
            ffi::GDK_MEMORY_A8B8G8R8 => Self::A8b8g8r8,
            ffi::GDK_MEMORY_R8G8B8 => Self::R8g8b8,
            ffi::GDK_MEMORY_B8G8R8 => Self::B8g8r8,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16 => Self::R16g16b16,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16A16_PREMULTIPLIED => Self::R16g16b16a16Premultiplied,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16A16 => Self::R16g16b16a16,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16_FLOAT => Self::R16g16b16Float,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED => {
                Self::R16g16b16a16FloatPremultiplied
            }
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R16G16B16A16_FLOAT => Self::R16g16b16a16Float,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R32G32B32_FLOAT => Self::R32g32b32Float,
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED => {
                Self::R32g32b32a32FloatPremultiplied
            }
            #[cfg(feature = "v4_6")]
            ffi::GDK_MEMORY_R32G32B32A32_FLOAT => Self::R32g32b32a32Float,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G8A8_PREMULTIPLIED => Self::G8a8Premultiplied,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G8A8 => Self::G8a8,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G8 => Self::G8,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G16A16_PREMULTIPLIED => Self::G16a16Premultiplied,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G16A16 => Self::G16a16,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_G16 => Self::G16,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_A8 => Self::A8,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_A16 => Self::A16,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_A16_FLOAT => Self::A16Float,
            #[cfg(feature = "v4_12")]
            ffi::GDK_MEMORY_A32_FLOAT => Self::A32Float,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Specifies the kind of crossing for enter and leave events.
///
/// 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 surface 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 surface.
    #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
    Virtual,
    /// the surface is entered from an inferior or
    ///   left towards an inferior.
    #[doc(alias = "GDK_NOTIFY_INFERIOR")]
    Inferior,
    /// the surface is entered from or left towards
    ///   a surface which is neither an ancestor nor an inferior.
    #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
    Nonlinear,
    /// the pointer moves between two surfaces
    ///   which are not ancestors of each other and the surface is part of
    ///   the ancestor chain between one of these surfaces 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;

    #[inline]
    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 {
    #[inline]
    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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_notify_type_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// Specifies the direction for scroll events.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkScrollDirection")]
pub enum ScrollDirection {
    /// the surface is scrolled up.
    #[doc(alias = "GDK_SCROLL_UP")]
    Up,
    /// the surface is scrolled down.
    #[doc(alias = "GDK_SCROLL_DOWN")]
    Down,
    /// the surface is scrolled to the left.
    #[doc(alias = "GDK_SCROLL_LEFT")]
    Left,
    /// the surface is scrolled to the right.
    #[doc(alias = "GDK_SCROLL_RIGHT")]
    Right,
    /// the scrolling is determined by the delta values
    ///   in scroll events. See gdk_scroll_event_get_deltas()
    #[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;

    #[inline]
    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 {
    #[inline]
    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 {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) }
    }
}

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

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

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

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

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

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

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

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

/// Specifies the unit of scroll deltas.
///
/// When you get [`Wheel`][Self::Wheel], a delta of 1.0 means 1 wheel detent
/// click in the south direction, 2.0 means 2 wheel detent clicks in the south
/// direction... This is the same logic for negative values but in the north
/// direction.
///
/// If you get [`Surface`][Self::Surface], are managing a scrollable view and get a
/// value of 123, you have to scroll 123 surface logical pixels right if it's
/// @delta_x or down if it's @delta_y. This is the same logic for negative values
/// but you have to scroll left instead of right if it's @delta_x and up instead
/// of down if it's @delta_y.
///
/// 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
/// final scale factor of your graphical interface (the product of the desktop
/// scale factor and eventually a custom scale factor in your app).
#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkScrollUnit")]
pub enum ScrollUnit {
    /// The delta is in number of wheel clicks.
    #[doc(alias = "GDK_SCROLL_UNIT_WHEEL")]
    Wheel,
    /// The delta is in surface pixels to scroll directly
    ///   on screen.
    #[doc(alias = "GDK_SCROLL_UNIT_SURFACE")]
    Surface,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl fmt::Display for ScrollUnit {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "ScrollUnit::{}",
            match *self {
                Self::Wheel => "Wheel",
                Self::Surface => "Surface",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl IntoGlib for ScrollUnit {
    type GlibType = ffi::GdkScrollUnit;

    #[inline]
    fn into_glib(self) -> ffi::GdkScrollUnit {
        match self {
            Self::Wheel => ffi::GDK_SCROLL_UNIT_WHEEL,
            Self::Surface => ffi::GDK_SCROLL_UNIT_SURFACE,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkScrollUnit> for ScrollUnit {
    #[inline]
    unsafe fn from_glib(value: ffi::GdkScrollUnit) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GDK_SCROLL_UNIT_WHEEL => Self::Wheel,
            ffi::GDK_SCROLL_UNIT_SURFACE => Self::Surface,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl StaticType for ScrollUnit {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_scroll_unit_get_type()) }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::HasParamSpec for ScrollUnit {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

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

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::value::ValueType for ScrollUnit {
    type Type = Self;
}

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

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

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

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

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl From<ScrollUnit> for glib::Value {
    #[inline]
    fn from(v: ScrollUnit) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// This enumeration describes how the red, green and blue components
/// of physical pixels on an output device are laid out.
#[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),
}

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

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

    #[inline]
    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,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout {
    #[inline]
    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),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Determines a surface edge or corner.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkSurfaceEdge")]
pub enum SurfaceEdge {
    /// the top left corner.
    #[doc(alias = "GDK_SURFACE_EDGE_NORTH_WEST")]
    NorthWest,
    /// the top edge.
    #[doc(alias = "GDK_SURFACE_EDGE_NORTH")]
    North,
    /// the top right corner.
    #[doc(alias = "GDK_SURFACE_EDGE_NORTH_EAST")]
    NorthEast,
    /// the left edge.
    #[doc(alias = "GDK_SURFACE_EDGE_WEST")]
    West,
    /// the right edge.
    #[doc(alias = "GDK_SURFACE_EDGE_EAST")]
    East,
    /// the lower left corner.
    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH_WEST")]
    SouthWest,
    /// the lower edge.
    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH")]
    South,
    /// the lower right corner.
    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH_EAST")]
    SouthEast,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for SurfaceEdge {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "SurfaceEdge::{}",
            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 SurfaceEdge {
    type GlibType = ffi::GdkSurfaceEdge;

    #[inline]
    fn into_glib(self) -> ffi::GdkSurfaceEdge {
        match self {
            Self::NorthWest => ffi::GDK_SURFACE_EDGE_NORTH_WEST,
            Self::North => ffi::GDK_SURFACE_EDGE_NORTH,
            Self::NorthEast => ffi::GDK_SURFACE_EDGE_NORTH_EAST,
            Self::West => ffi::GDK_SURFACE_EDGE_WEST,
            Self::East => ffi::GDK_SURFACE_EDGE_EAST,
            Self::SouthWest => ffi::GDK_SURFACE_EDGE_SOUTH_WEST,
            Self::South => ffi::GDK_SURFACE_EDGE_SOUTH,
            Self::SouthEast => ffi::GDK_SURFACE_EDGE_SOUTH_EAST,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GDK_SURFACE_EDGE_NORTH_WEST => Self::NorthWest,
            ffi::GDK_SURFACE_EDGE_NORTH => Self::North,
            ffi::GDK_SURFACE_EDGE_NORTH_EAST => Self::NorthEast,
            ffi::GDK_SURFACE_EDGE_WEST => Self::West,
            ffi::GDK_SURFACE_EDGE_EAST => Self::East,
            ffi::GDK_SURFACE_EDGE_SOUTH_WEST => Self::SouthWest,
            ffi::GDK_SURFACE_EDGE_SOUTH => Self::South,
            ffi::GDK_SURFACE_EDGE_SOUTH_EAST => Self::SouthEast,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Possible errors that can be returned by [`Texture`][crate::Texture] constructors.
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkTextureError")]
pub enum TextureError {
    /// Not enough memory to handle this image
    #[doc(alias = "GDK_TEXTURE_ERROR_TOO_LARGE")]
    TooLarge,
    /// The image data appears corrupted
    #[doc(alias = "GDK_TEXTURE_ERROR_CORRUPT_IMAGE")]
    CorruptImage,
    /// The image contains features
    ///   that cannot be loaded
    #[doc(alias = "GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT")]
    UnsupportedContent,
    /// The image format is not supported
    #[doc(alias = "GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT")]
    UnsupportedFormat,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl fmt::Display for TextureError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "TextureError::{}",
            match *self {
                Self::TooLarge => "TooLarge",
                Self::CorruptImage => "CorruptImage",
                Self::UnsupportedContent => "UnsupportedContent",
                Self::UnsupportedFormat => "UnsupportedFormat",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl IntoGlib for TextureError {
    type GlibType = ffi::GdkTextureError;

    #[inline]
    fn into_glib(self) -> ffi::GdkTextureError {
        match self {
            Self::TooLarge => ffi::GDK_TEXTURE_ERROR_TOO_LARGE,
            Self::CorruptImage => ffi::GDK_TEXTURE_ERROR_CORRUPT_IMAGE,
            Self::UnsupportedContent => ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT,
            Self::UnsupportedFormat => ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkTextureError> for TextureError {
    #[inline]
    unsafe fn from_glib(value: ffi::GdkTextureError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GDK_TEXTURE_ERROR_TOO_LARGE => Self::TooLarge,
            ffi::GDK_TEXTURE_ERROR_CORRUPT_IMAGE => Self::CorruptImage,
            ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT => Self::UnsupportedContent,
            ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::error::ErrorDomain for TextureError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

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

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl StaticType for TextureError {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_texture_error_get_type()) }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::HasParamSpec for TextureError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

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

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::value::ValueType for TextureError {
    type Type = Self;
}

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

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

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

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

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl From<TextureError> for glib::Value {
    #[inline]
    fn from(v: TextureError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkTitlebarGesture")]
pub enum TitlebarGesture {
    #[doc(alias = "GDK_TITLEBAR_GESTURE_DOUBLE_CLICK")]
    DoubleClick,
    #[doc(alias = "GDK_TITLEBAR_GESTURE_RIGHT_CLICK")]
    RightClick,
    #[doc(alias = "GDK_TITLEBAR_GESTURE_MIDDLE_CLICK")]
    MiddleClick,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
impl fmt::Display for TitlebarGesture {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "TitlebarGesture::{}",
            match *self {
                Self::DoubleClick => "DoubleClick",
                Self::RightClick => "RightClick",
                Self::MiddleClick => "MiddleClick",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
#[doc(hidden)]
impl IntoGlib for TitlebarGesture {
    type GlibType = ffi::GdkTitlebarGesture;

    #[inline]
    fn into_glib(self) -> ffi::GdkTitlebarGesture {
        match self {
            Self::DoubleClick => ffi::GDK_TITLEBAR_GESTURE_DOUBLE_CLICK,
            Self::RightClick => ffi::GDK_TITLEBAR_GESTURE_RIGHT_CLICK,
            Self::MiddleClick => ffi::GDK_TITLEBAR_GESTURE_MIDDLE_CLICK,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkTitlebarGesture> for TitlebarGesture {
    #[inline]
    unsafe fn from_glib(value: ffi::GdkTitlebarGesture) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GDK_TITLEBAR_GESTURE_DOUBLE_CLICK => Self::DoubleClick,
            ffi::GDK_TITLEBAR_GESTURE_RIGHT_CLICK => Self::RightClick,
            ffi::GDK_TITLEBAR_GESTURE_MIDDLE_CLICK => Self::MiddleClick,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
impl StaticType for TitlebarGesture {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gdk_titlebar_gesture_get_type()) }
    }
}

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
impl glib::HasParamSpec for TitlebarGesture {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

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

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
impl glib::value::ValueType for TitlebarGesture {
    type Type = Self;
}

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

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

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

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

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
impl From<TitlebarGesture> for glib::Value {
    #[inline]
    fn from(v: TitlebarGesture) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Specifies the current state of a touchpad gesture.
///
/// All gestures are guaranteed to begin with an event with phase
/// [`Begin`][Self::Begin], followed by 0 or several events
/// with phase [`Update`][Self::Update].
///
/// A finished gesture may have 2 possible outcomes, an event with phase
/// [`End`][Self::End] will be emitted when the gesture is
/// considered successful, this should be used as the hint to perform any
/// permanent changes.
///
/// Cancelled gestures may be so for a variety of reasons, due to hardware
/// or the compositor, or due to the gesture recognition layers hinting the
/// gesture did not finish resolutely (eg. a 3rd finger being added during
/// a pinch gesture). In these cases, the last event will report the phase
/// [`Cancel`][Self::Cancel], this should be used as a hint
/// to undo any visible/permanent changes that were done throughout the
/// progress of the gesture.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkTouchpadGesturePhase")]
pub enum TouchpadGesturePhase {
    /// The gesture has begun.
    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_BEGIN")]
    Begin,
    /// The gesture has been updated.
    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_UPDATE")]
    Update,
    /// The gesture was finished, changes
    ///   should be permanently applied.
    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_END")]
    End,
    /// The gesture was cancelled, all
    ///   changes should be undone.
    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_CANCEL")]
    Cancel,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for TouchpadGesturePhase {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "TouchpadGesturePhase::{}",
            match *self {
                Self::Begin => "Begin",
                Self::Update => "Update",
                Self::End => "End",
                Self::Cancel => "Cancel",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkTouchpadGesturePhase {
        match self {
            Self::Begin => ffi::GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
            Self::Update => ffi::GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
            Self::End => ffi::GDK_TOUCHPAD_GESTURE_PHASE_END,
            Self::Cancel => ffi::GDK_TOUCHPAD_GESTURE_PHASE_CANCEL,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GDK_TOUCHPAD_GESTURE_PHASE_BEGIN => Self::Begin,
            ffi::GDK_TOUCHPAD_GESTURE_PHASE_UPDATE => Self::Update,
            ffi::GDK_TOUCHPAD_GESTURE_PHASE_END => Self::End,
            ffi::GDK_TOUCHPAD_GESTURE_PHASE_CANCEL => Self::Cancel,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Error enumeration for [`VulkanContext`][crate::VulkanContext].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GdkVulkanError")]
pub enum VulkanError {
    /// Vulkan is not supported on this backend or has not been
    ///   compiled in.
    #[doc(alias = "GDK_VULKAN_ERROR_UNSUPPORTED")]
    Unsupported,
    /// Vulkan support is not available on this Surface
    #[doc(alias = "GDK_VULKAN_ERROR_NOT_AVAILABLE")]
    NotAvailable,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    #[inline]
    fn into_glib(self) -> ffi::GdkVulkanError {
        match self {
            Self::Unsupported => ffi::GDK_VULKAN_ERROR_UNSUPPORTED,
            Self::NotAvailable => ffi::GDK_VULKAN_ERROR_NOT_AVAILABLE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GDK_VULKAN_ERROR_UNSUPPORTED => Self::Unsupported,
            ffi::GDK_VULKAN_ERROR_NOT_AVAILABLE => Self::NotAvailable,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for VulkanError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

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

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

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

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

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

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

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

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

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

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

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