// 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 bitflags::bitflags;
use glib::{translate::*, value::FromValue, value::ToValue, StaticType, Type};
use std::fmt;

bitflags! {
    /// Positioning hints for aligning a surface relative to a rectangle.
    ///
    /// These hints determine how the surface should be positioned in the case that
    /// the surface would fall off-screen if placed in its ideal position.
    ///
    /// For example, [`FLIP_X`][Self::FLIP_X] will replace [`Gravity::NorthWest`][crate::Gravity::NorthWest] with
    /// [`Gravity::NorthEast`][crate::Gravity::NorthEast] and vice versa if the surface extends beyond the left
    /// or right edges of the monitor.
    ///
    /// If [`SLIDE_X`][Self::SLIDE_X] is set, the surface can be shifted horizontally to fit
    /// on-screen. If [`RESIZE_X`][Self::RESIZE_X] is set, the surface can be shrunken
    /// horizontally to fit.
    ///
    /// In general, when multiple flags are set, flipping should take precedence over
    /// sliding, which should take precedence over resizing.
    #[doc(alias = "GdkAnchorHints")]
    pub struct AnchorHints: u32 {
        /// allow flipping anchors horizontally
        #[doc(alias = "GDK_ANCHOR_FLIP_X")]
        const FLIP_X = ffi::GDK_ANCHOR_FLIP_X as _;
        /// allow flipping anchors vertically
        #[doc(alias = "GDK_ANCHOR_FLIP_Y")]
        const FLIP_Y = ffi::GDK_ANCHOR_FLIP_Y as _;
        /// allow sliding surface horizontally
        #[doc(alias = "GDK_ANCHOR_SLIDE_X")]
        const SLIDE_X = ffi::GDK_ANCHOR_SLIDE_X as _;
        /// allow sliding surface vertically
        #[doc(alias = "GDK_ANCHOR_SLIDE_Y")]
        const SLIDE_Y = ffi::GDK_ANCHOR_SLIDE_Y as _;
        /// allow resizing surface horizontally
        #[doc(alias = "GDK_ANCHOR_RESIZE_X")]
        const RESIZE_X = ffi::GDK_ANCHOR_RESIZE_X as _;
        /// allow resizing surface vertically
        #[doc(alias = "GDK_ANCHOR_RESIZE_Y")]
        const RESIZE_Y = ffi::GDK_ANCHOR_RESIZE_Y as _;
        /// allow flipping anchors on both axes
        #[doc(alias = "GDK_ANCHOR_FLIP")]
        const FLIP = ffi::GDK_ANCHOR_FLIP as _;
        /// allow sliding surface on both axes
        #[doc(alias = "GDK_ANCHOR_SLIDE")]
        const SLIDE = ffi::GDK_ANCHOR_SLIDE as _;
        /// allow resizing surface on both axes
        #[doc(alias = "GDK_ANCHOR_RESIZE")]
        const RESIZE = ffi::GDK_ANCHOR_RESIZE as _;
    }
}

impl fmt::Display for AnchorHints {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkAnchorHints {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for AnchorHints {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for AnchorHints {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Flags describing the current capabilities of a device/tool.
    #[doc(alias = "GdkAxisFlags")]
    pub struct AxisFlags: u32 {
        /// X axis is present
        #[doc(alias = "GDK_AXIS_FLAG_X")]
        const X = ffi::GDK_AXIS_FLAG_X as _;
        /// Y axis is present
        #[doc(alias = "GDK_AXIS_FLAG_Y")]
        const Y = ffi::GDK_AXIS_FLAG_Y as _;
        /// Scroll X delta axis is present
        #[doc(alias = "GDK_AXIS_FLAG_DELTA_X")]
        const DELTA_X = ffi::GDK_AXIS_FLAG_DELTA_X as _;
        /// Scroll Y delta axis is present
        #[doc(alias = "GDK_AXIS_FLAG_DELTA_Y")]
        const DELTA_Y = ffi::GDK_AXIS_FLAG_DELTA_Y as _;
        /// Pressure axis is present
        #[doc(alias = "GDK_AXIS_FLAG_PRESSURE")]
        const PRESSURE = ffi::GDK_AXIS_FLAG_PRESSURE as _;
        /// X tilt axis is present
        #[doc(alias = "GDK_AXIS_FLAG_XTILT")]
        const XTILT = ffi::GDK_AXIS_FLAG_XTILT as _;
        /// Y tilt axis is present
        #[doc(alias = "GDK_AXIS_FLAG_YTILT")]
        const YTILT = ffi::GDK_AXIS_FLAG_YTILT as _;
        /// Wheel axis is present
        #[doc(alias = "GDK_AXIS_FLAG_WHEEL")]
        const WHEEL = ffi::GDK_AXIS_FLAG_WHEEL as _;
        /// Distance axis is present
        #[doc(alias = "GDK_AXIS_FLAG_DISTANCE")]
        const DISTANCE = ffi::GDK_AXIS_FLAG_DISTANCE as _;
        /// Z-axis rotation is present
        #[doc(alias = "GDK_AXIS_FLAG_ROTATION")]
        const ROTATION = ffi::GDK_AXIS_FLAG_ROTATION as _;
        /// Slider axis is present
        #[doc(alias = "GDK_AXIS_FLAG_SLIDER")]
        const SLIDER = ffi::GDK_AXIS_FLAG_SLIDER as _;
    }
}

impl fmt::Display for AxisFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkAxisFlags {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for AxisFlags {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for AxisFlags {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Used in [`Drop`][crate::Drop] and [`Drag`][crate::Drag] to indicate the actions that the
    /// destination can and should do with the dropped data.
    #[doc(alias = "GdkDragAction")]
    pub struct DragAction: u32 {
        /// Copy the data.
        #[doc(alias = "GDK_ACTION_COPY")]
        const COPY = ffi::GDK_ACTION_COPY as _;
        /// Move the data, i.e. first copy it, then delete
        ///   it from the source using the DELETE target of the X selection protocol.
        #[doc(alias = "GDK_ACTION_MOVE")]
        const MOVE = ffi::GDK_ACTION_MOVE as _;
        /// Add a link to the data. Note that this is only
        ///   useful if source and destination agree on what it means, and is not
        ///   supported on all platforms.
        #[doc(alias = "GDK_ACTION_LINK")]
        const LINK = ffi::GDK_ACTION_LINK as _;
        /// Ask the user what to do with the data.
        #[doc(alias = "GDK_ACTION_ASK")]
        const ASK = ffi::GDK_ACTION_ASK as _;
    }
}

impl DragAction {
    #[doc(alias = "gdk_drag_action_is_unique")]
    pub fn is_unique(self) -> bool {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gdk_drag_action_is_unique(self.into_glib())) }
    }
}

impl fmt::Display for DragAction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkDragAction {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for DragAction {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for DragAction {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Used to represent the different paint clock phases that can be requested.
    ///
    /// The elements of the enumeration correspond to the signals of [`FrameClock`][crate::FrameClock].
    #[doc(alias = "GdkFrameClockPhase")]
    pub struct FrameClockPhase: u32 {
        /// no phase
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_NONE")]
        const NONE = ffi::GDK_FRAME_CLOCK_PHASE_NONE as _;
        /// corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS")]
        const FLUSH_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS as _;
        /// corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT")]
        const BEFORE_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT as _;
        /// corresponds to GdkFrameClock::update.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_UPDATE")]
        const UPDATE = ffi::GDK_FRAME_CLOCK_PHASE_UPDATE as _;
        /// corresponds to GdkFrameClock::layout. Should not be handled by applications.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_LAYOUT")]
        const LAYOUT = ffi::GDK_FRAME_CLOCK_PHASE_LAYOUT as _;
        /// corresponds to GdkFrameClock::paint.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_PAINT")]
        const PAINT = ffi::GDK_FRAME_CLOCK_PHASE_PAINT as _;
        /// corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS")]
        const RESUME_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS as _;
        /// corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
        #[doc(alias = "GDK_FRAME_CLOCK_PHASE_AFTER_PAINT")]
        const AFTER_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_AFTER_PAINT as _;
    }
}

impl fmt::Display for FrameClockPhase {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkFrameClockPhase {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for FrameClockPhase {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for FrameClockPhase {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

#[cfg(any(feature = "v4_6", feature = "dox"))]
bitflags! {
    /// The list of the different APIs that GdkGLContext can potentially support.
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
    #[doc(alias = "GdkGLAPI")]
    pub struct GLAPI: u32 {
        /// The OpenGL API
        #[doc(alias = "GDK_GL_API_GL")]
        const GL = ffi::GDK_GL_API_GL as _;
        /// The OpenGL ES API
        #[doc(alias = "GDK_GL_API_GLES")]
        const GLES = ffi::GDK_GL_API_GLES as _;
    }
}

#[cfg(any(feature = "v4_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
impl fmt::Display for GLAPI {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkGLAPI {
        self.bits()
    }
}

#[cfg(any(feature = "v4_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl FromGlib<ffi::GdkGLAPI> for GLAPI {
    #[inline]
    unsafe fn from_glib(value: ffi::GdkGLAPI) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

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

#[cfg(any(feature = "v4_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
impl glib::HasParamSpec for GLAPI {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

#[cfg(any(feature = "v4_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
unsafe impl<'a> FromValue<'a> for GLAPI {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Flags to indicate the state of modifier keys and mouse buttons
    /// in events.
    ///
    /// Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
    /// Apple, CapsLock or ShiftLock.
    ///
    /// Note that GDK may add internal values to events which include values outside
    /// of this enumeration. Your code should preserve and ignore them.  You can use
    /// `GDK_MODIFIER_MASK` to remove all private values.
    #[doc(alias = "GdkModifierType")]
    pub struct ModifierType: u32 {
        /// the Shift key.
        #[doc(alias = "GDK_SHIFT_MASK")]
        const SHIFT_MASK = ffi::GDK_SHIFT_MASK as _;
        /// a Lock key (depending on the modifier mapping of the
        ///  X server this may either be CapsLock or ShiftLock).
        #[doc(alias = "GDK_LOCK_MASK")]
        const LOCK_MASK = ffi::GDK_LOCK_MASK as _;
        /// the Control key.
        #[doc(alias = "GDK_CONTROL_MASK")]
        const CONTROL_MASK = ffi::GDK_CONTROL_MASK as _;
        /// the fourth modifier key (it depends on the modifier
        ///  mapping of the X server which key is interpreted as this modifier, but
        ///  normally it is the Alt key).
        #[doc(alias = "GDK_ALT_MASK")]
        const ALT_MASK = ffi::GDK_ALT_MASK as _;
        /// the first mouse button.
        #[doc(alias = "GDK_BUTTON1_MASK")]
        const BUTTON1_MASK = ffi::GDK_BUTTON1_MASK as _;
        /// the second mouse button.
        #[doc(alias = "GDK_BUTTON2_MASK")]
        const BUTTON2_MASK = ffi::GDK_BUTTON2_MASK as _;
        /// the third mouse button.
        #[doc(alias = "GDK_BUTTON3_MASK")]
        const BUTTON3_MASK = ffi::GDK_BUTTON3_MASK as _;
        /// the fourth mouse button.
        #[doc(alias = "GDK_BUTTON4_MASK")]
        const BUTTON4_MASK = ffi::GDK_BUTTON4_MASK as _;
        /// the fifth mouse button.
        #[doc(alias = "GDK_BUTTON5_MASK")]
        const BUTTON5_MASK = ffi::GDK_BUTTON5_MASK as _;
        /// the Super modifier
        #[doc(alias = "GDK_SUPER_MASK")]
        const SUPER_MASK = ffi::GDK_SUPER_MASK as _;
        /// the Hyper modifier
        #[doc(alias = "GDK_HYPER_MASK")]
        const HYPER_MASK = ffi::GDK_HYPER_MASK as _;
        /// the Meta modifier
        #[doc(alias = "GDK_META_MASK")]
        const META_MASK = ffi::GDK_META_MASK as _;
    }
}

impl fmt::Display for ModifierType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkModifierType {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for ModifierType {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for ModifierType {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Flags about a paintable object.
    ///
    /// Implementations use these for optimizations such as caching.
    #[doc(alias = "GdkPaintableFlags")]
    pub struct PaintableFlags: u32 {
        /// The size is immutable.
        ///   The [`invalidate-size`][struct@crate::GdkPaintable#invalidate-size] signal will never be
        ///   emitted.
        #[doc(alias = "GDK_PAINTABLE_STATIC_SIZE")]
        const SIZE = ffi::GDK_PAINTABLE_STATIC_SIZE as _;
        /// The content is immutable.
        ///   The [`invalidate-contents`][struct@crate::GdkPaintable#invalidate-contents] signal will never be
        ///   emitted.
        #[doc(alias = "GDK_PAINTABLE_STATIC_CONTENTS")]
        const CONTENTS = ffi::GDK_PAINTABLE_STATIC_CONTENTS as _;
    }
}

impl fmt::Display for PaintableFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkPaintableFlags {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for PaintableFlags {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for PaintableFlags {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Flags describing the seat capabilities.
    #[doc(alias = "GdkSeatCapabilities")]
    pub struct SeatCapabilities: u32 {
        /// No input capabilities
        #[doc(alias = "GDK_SEAT_CAPABILITY_NONE")]
        const NONE = ffi::GDK_SEAT_CAPABILITY_NONE as _;
        /// The seat has a pointer (e.g. mouse)
        #[doc(alias = "GDK_SEAT_CAPABILITY_POINTER")]
        const POINTER = ffi::GDK_SEAT_CAPABILITY_POINTER as _;
        /// The seat has touchscreen(s) attached
        #[doc(alias = "GDK_SEAT_CAPABILITY_TOUCH")]
        const TOUCH = ffi::GDK_SEAT_CAPABILITY_TOUCH as _;
        /// The seat has drawing tablet(s) attached
        #[doc(alias = "GDK_SEAT_CAPABILITY_TABLET_STYLUS")]
        const TABLET_STYLUS = ffi::GDK_SEAT_CAPABILITY_TABLET_STYLUS as _;
        /// The seat has keyboard(s) attached
        #[doc(alias = "GDK_SEAT_CAPABILITY_KEYBOARD")]
        const KEYBOARD = ffi::GDK_SEAT_CAPABILITY_KEYBOARD as _;
        /// The seat has drawing tablet pad(s) attached
        #[doc(alias = "GDK_SEAT_CAPABILITY_TABLET_PAD")]
        const TABLET_PAD = ffi::GDK_SEAT_CAPABILITY_TABLET_PAD as _;
        /// The union of all pointing capabilities
        #[doc(alias = "GDK_SEAT_CAPABILITY_ALL_POINTING")]
        const ALL_POINTING = ffi::GDK_SEAT_CAPABILITY_ALL_POINTING as _;
        /// The union of all capabilities
        #[doc(alias = "GDK_SEAT_CAPABILITY_ALL")]
        const ALL = ffi::GDK_SEAT_CAPABILITY_ALL as _;
    }
}

impl fmt::Display for SeatCapabilities {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkSeatCapabilities {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for SeatCapabilities {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for SeatCapabilities {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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

bitflags! {
    /// Specifies the state of a toplevel surface.
    ///
    /// On platforms that support information about individual edges, the
    /// [`TILED`][Self::TILED] state will be set whenever any of the individual
    /// tiled states is set. On platforms that lack that support, the tiled state
    /// will give an indication of tiledness without any of the per-edge states
    /// being set.
    #[doc(alias = "GdkToplevelState")]
    pub struct ToplevelState: u32 {
        /// the surface is minimized
        #[doc(alias = "GDK_TOPLEVEL_STATE_MINIMIZED")]
        const MINIMIZED = ffi::GDK_TOPLEVEL_STATE_MINIMIZED as _;
        /// the surface is maximized
        #[doc(alias = "GDK_TOPLEVEL_STATE_MAXIMIZED")]
        const MAXIMIZED = ffi::GDK_TOPLEVEL_STATE_MAXIMIZED as _;
        /// the surface is sticky
        #[doc(alias = "GDK_TOPLEVEL_STATE_STICKY")]
        const STICKY = ffi::GDK_TOPLEVEL_STATE_STICKY as _;
        /// the surface is maximized without decorations
        #[doc(alias = "GDK_TOPLEVEL_STATE_FULLSCREEN")]
        const FULLSCREEN = ffi::GDK_TOPLEVEL_STATE_FULLSCREEN as _;
        /// the surface is kept above other surfaces
        #[doc(alias = "GDK_TOPLEVEL_STATE_ABOVE")]
        const ABOVE = ffi::GDK_TOPLEVEL_STATE_ABOVE as _;
        /// the surface is kept below other surfaces
        #[doc(alias = "GDK_TOPLEVEL_STATE_BELOW")]
        const BELOW = ffi::GDK_TOPLEVEL_STATE_BELOW as _;
        /// the surface is presented as focused (with active decorations)
        #[doc(alias = "GDK_TOPLEVEL_STATE_FOCUSED")]
        const FOCUSED = ffi::GDK_TOPLEVEL_STATE_FOCUSED as _;
        /// the surface is in a tiled state
        #[doc(alias = "GDK_TOPLEVEL_STATE_TILED")]
        const TILED = ffi::GDK_TOPLEVEL_STATE_TILED as _;
        /// whether the top edge is tiled
        #[doc(alias = "GDK_TOPLEVEL_STATE_TOP_TILED")]
        const TOP_TILED = ffi::GDK_TOPLEVEL_STATE_TOP_TILED as _;
        /// whether the top edge is resizable
        #[doc(alias = "GDK_TOPLEVEL_STATE_TOP_RESIZABLE")]
        const TOP_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_TOP_RESIZABLE as _;
        /// whether the right edge is tiled
        #[doc(alias = "GDK_TOPLEVEL_STATE_RIGHT_TILED")]
        const RIGHT_TILED = ffi::GDK_TOPLEVEL_STATE_RIGHT_TILED as _;
        /// whether the right edge is resizable
        #[doc(alias = "GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE")]
        const RIGHT_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE as _;
        /// whether the bottom edge is tiled
        #[doc(alias = "GDK_TOPLEVEL_STATE_BOTTOM_TILED")]
        const BOTTOM_TILED = ffi::GDK_TOPLEVEL_STATE_BOTTOM_TILED as _;
        /// whether the bottom edge is resizable
        #[doc(alias = "GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE")]
        const BOTTOM_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE as _;
        /// whether the left edge is tiled
        #[doc(alias = "GDK_TOPLEVEL_STATE_LEFT_TILED")]
        const LEFT_TILED = ffi::GDK_TOPLEVEL_STATE_LEFT_TILED as _;
        /// whether the left edge is resizable
        #[doc(alias = "GDK_TOPLEVEL_STATE_LEFT_RESIZABLE")]
        const LEFT_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_LEFT_RESIZABLE as _;
    }
}

impl fmt::Display for ToplevelState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GdkToplevelState {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for ToplevelState {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name| Self::ParamSpec::builder(name)
    }
}

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

unsafe impl<'a> FromValue<'a> for ToplevelState {
    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_flags(value.to_glib_none().0))
    }
}

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

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

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