// 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! {
    /// Types of user actions that may be blocked by [`Application`][crate::Application].
    ///
    /// See [`GtkApplicationExt::inhibit()`][crate::prelude::GtkApplicationExt::inhibit()].
    #[doc(alias = "GtkApplicationInhibitFlags")]
    pub struct ApplicationInhibitFlags: u32 {
        /// Inhibit ending the user session
        ///   by logging out or by shutting down the computer
        #[doc(alias = "GTK_APPLICATION_INHIBIT_LOGOUT")]
        const LOGOUT = ffi::GTK_APPLICATION_INHIBIT_LOGOUT as _;
        /// Inhibit user switching
        #[doc(alias = "GTK_APPLICATION_INHIBIT_SWITCH")]
        const SWITCH = ffi::GTK_APPLICATION_INHIBIT_SWITCH as _;
        /// Inhibit suspending the
        ///   session or computer
        #[doc(alias = "GTK_APPLICATION_INHIBIT_SUSPEND")]
        const SUSPEND = ffi::GTK_APPLICATION_INHIBIT_SUSPEND as _;
        /// Inhibit the session being
        ///   marked as idle (and possibly locked)
        #[doc(alias = "GTK_APPLICATION_INHIBIT_IDLE")]
        const IDLE = ffi::GTK_APPLICATION_INHIBIT_IDLE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for ApplicationInhibitFlags {
    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 ApplicationInhibitFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ApplicationInhibitFlags {
    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 ApplicationInhibitFlags {
    #[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<ApplicationInhibitFlags> for glib::Value {
    #[inline]
    fn from(v: ApplicationInhibitFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// The list of flags that can be passed to gtk_builder_create_closure().
    ///
    /// New values may be added in the future for new features, so external
    /// implementations of [`BuilderScope`][crate::BuilderScope] should test the flags
    /// for unknown values and raise a [`BuilderError::InvalidAttribute`][crate::BuilderError::InvalidAttribute] error
    /// when they encounter one.
    #[doc(alias = "GtkBuilderClosureFlags")]
    pub struct BuilderClosureFlags: u32 {
        /// The closure should be created swapped. See
        ///   g_cclosure_new_swap() for details.
        #[doc(alias = "GTK_BUILDER_CLOSURE_SWAPPED")]
        const SWAPPED = ffi::GTK_BUILDER_CLOSURE_SWAPPED as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for BuilderClosureFlags {
    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 BuilderClosureFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for BuilderClosureFlags {
    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 BuilderClosureFlags {
    #[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<BuilderClosureFlags> for glib::Value {
    #[inline]
    fn from(v: BuilderClosureFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Tells how a cell is to be rendered.
    #[doc(alias = "GtkCellRendererState")]
    pub struct CellRendererState: u32 {
        /// The cell is currently selected, and
        ///  probably has a selection colored background to render to.
        #[doc(alias = "GTK_CELL_RENDERER_SELECTED")]
        const SELECTED = ffi::GTK_CELL_RENDERER_SELECTED as _;
        /// The mouse is hovering over the cell.
        #[doc(alias = "GTK_CELL_RENDERER_PRELIT")]
        const PRELIT = ffi::GTK_CELL_RENDERER_PRELIT as _;
        /// The cell is drawn in an insensitive manner
        #[doc(alias = "GTK_CELL_RENDERER_INSENSITIVE")]
        const INSENSITIVE = ffi::GTK_CELL_RENDERER_INSENSITIVE as _;
        /// The cell is in a sorted row
        #[doc(alias = "GTK_CELL_RENDERER_SORTED")]
        const SORTED = ffi::GTK_CELL_RENDERER_SORTED as _;
        /// The cell is in the focus row.
        #[doc(alias = "GTK_CELL_RENDERER_FOCUSED")]
        const FOCUSED = ffi::GTK_CELL_RENDERER_FOCUSED as _;
        /// The cell is in a row that can be expanded
        #[doc(alias = "GTK_CELL_RENDERER_EXPANDABLE")]
        const EXPANDABLE = ffi::GTK_CELL_RENDERER_EXPANDABLE as _;
        /// The cell is in a row that is expanded
        #[doc(alias = "GTK_CELL_RENDERER_EXPANDED")]
        const EXPANDED = ffi::GTK_CELL_RENDERER_EXPANDED as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for CellRendererState {
    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 CellRendererState {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for CellRendererState {
    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 CellRendererState {
    #[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<CellRendererState> for glib::Value {
    #[inline]
    fn from(v: CellRendererState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags to use with gtk_set_debug_flags().
    ///
    /// Settings these flags causes GTK to print out different
    /// types of debugging information. Some of these flags are
    /// only available when GTK has been configured with `-Ddebug=true`.
    #[doc(alias = "GtkDebugFlags")]
    pub struct DebugFlags: u32 {
        /// Information about GtkTextView
        #[doc(alias = "GTK_DEBUG_TEXT")]
        const TEXT = ffi::GTK_DEBUG_TEXT as _;
        /// Information about GtkTreeView
        #[doc(alias = "GTK_DEBUG_TREE")]
        const TREE = ffi::GTK_DEBUG_TREE as _;
        /// Information about keyboard shortcuts
        #[doc(alias = "GTK_DEBUG_KEYBINDINGS")]
        const KEYBINDINGS = ffi::GTK_DEBUG_KEYBINDINGS as _;
        /// Information about modules and extensions
        #[doc(alias = "GTK_DEBUG_MODULES")]
        const MODULES = ffi::GTK_DEBUG_MODULES as _;
        /// Information about size allocation
        #[doc(alias = "GTK_DEBUG_GEOMETRY")]
        const GEOMETRY = ffi::GTK_DEBUG_GEOMETRY as _;
        /// Information about icon themes
        #[doc(alias = "GTK_DEBUG_ICONTHEME")]
        const ICONTHEME = ffi::GTK_DEBUG_ICONTHEME as _;
        /// Information about printing
        #[doc(alias = "GTK_DEBUG_PRINTING")]
        const PRINTING = ffi::GTK_DEBUG_PRINTING as _;
        /// Trace GtkBuilder operation
        #[doc(alias = "GTK_DEBUG_BUILDER")]
        const BUILDER = ffi::GTK_DEBUG_BUILDER as _;
        /// Information about size requests
        #[doc(alias = "GTK_DEBUG_SIZE_REQUEST")]
        const SIZE_REQUEST = ffi::GTK_DEBUG_SIZE_REQUEST as _;
        /// Disable the style property cache
        #[doc(alias = "GTK_DEBUG_NO_CSS_CACHE")]
        const NO_CSS_CACHE = ffi::GTK_DEBUG_NO_CSS_CACHE as _;
        /// Open the GTK inspector
        #[doc(alias = "GTK_DEBUG_INTERACTIVE")]
        const INTERACTIVE = ffi::GTK_DEBUG_INTERACTIVE as _;
        /// Pretend the pointer is a touchscreen
        #[doc(alias = "GTK_DEBUG_TOUCHSCREEN")]
        const TOUCHSCREEN = ffi::GTK_DEBUG_TOUCHSCREEN as _;
        /// Information about actions and menu models
        #[doc(alias = "GTK_DEBUG_ACTIONS")]
        const ACTIONS = ffi::GTK_DEBUG_ACTIONS as _;
        /// Information from layout managers
        #[doc(alias = "GTK_DEBUG_LAYOUT")]
        const LAYOUT = ffi::GTK_DEBUG_LAYOUT as _;
        /// Include debug render nodes in the generated snapshots
        #[doc(alias = "GTK_DEBUG_SNAPSHOT")]
        const SNAPSHOT = ffi::GTK_DEBUG_SNAPSHOT as _;
        /// Information from the constraints solver
        #[doc(alias = "GTK_DEBUG_CONSTRAINTS")]
        const CONSTRAINTS = ffi::GTK_DEBUG_CONSTRAINTS as _;
        /// Log unused GtkBuilder objects
        #[doc(alias = "GTK_DEBUG_BUILDER_OBJECTS")]
        const BUILDER_OBJECTS = ffi::GTK_DEBUG_BUILDER_OBJECTS as _;
        /// Information about accessibility state changes
        #[doc(alias = "GTK_DEBUG_A11Y")]
        const A11Y = ffi::GTK_DEBUG_A11Y as _;
        /// Information about icon fallback. Since: 4.2
        #[doc(alias = "GTK_DEBUG_ICONFALLBACK")]
        const ICONFALLBACK = ffi::GTK_DEBUG_ICONFALLBACK as _;
        #[cfg(any(feature = "v4_8", feature = "dox"))]
        #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_8")))]
        #[doc(alias = "GTK_DEBUG_INVERT_TEXT_DIR")]
        const INVERT_TEXT_DIR = ffi::GTK_DEBUG_INVERT_TEXT_DIR as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for DebugFlags {
    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 DebugFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for DebugFlags {
    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 DebugFlags {
    #[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<DebugFlags> for glib::Value {
    #[inline]
    fn from(v: DebugFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags used to influence dialog construction.
    #[doc(alias = "GtkDialogFlags")]
    pub struct DialogFlags: u32 {
        /// Make the constructed dialog modal
        #[doc(alias = "GTK_DIALOG_MODAL")]
        const MODAL = ffi::GTK_DIALOG_MODAL as _;
        /// Destroy the dialog when its parent is destroyed
        #[doc(alias = "GTK_DIALOG_DESTROY_WITH_PARENT")]
        const DESTROY_WITH_PARENT = ffi::GTK_DIALOG_DESTROY_WITH_PARENT as _;
        /// Create dialog with actions in header
        ///   bar instead of action area
        #[doc(alias = "GTK_DIALOG_USE_HEADER_BAR")]
        const USE_HEADER_BAR = ffi::GTK_DIALOG_USE_HEADER_BAR as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for DialogFlags {
    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 DialogFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for DialogFlags {
    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 DialogFlags {
    #[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<DialogFlags> for glib::Value {
    #[inline]
    fn from(v: DialogFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Describes the behavior of a [`EventControllerScroll`][crate::EventControllerScroll].
    #[doc(alias = "GtkEventControllerScrollFlags")]
    pub struct EventControllerScrollFlags: u32 {
        /// Don't emit scroll.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_NONE")]
        const NONE = ffi::GTK_EVENT_CONTROLLER_SCROLL_NONE as _;
        /// Emit scroll with vertical deltas.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL")]
        const VERTICAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_VERTICAL as _;
        /// Emit scroll with horizontal deltas.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL")]
        const HORIZONTAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL as _;
        /// Only emit deltas that are multiples of 1.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE")]
        const DISCRETE = ffi::GTK_EVENT_CONTROLLER_SCROLL_DISCRETE as _;
        /// Emit ::decelerate after continuous scroll finishes.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_KINETIC")]
        const KINETIC = ffi::GTK_EVENT_CONTROLLER_SCROLL_KINETIC as _;
        /// Emit scroll on both axes.
        #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES")]
        const BOTH_AXES = ffi::GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for EventControllerScrollFlags {
    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 EventControllerScrollFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for EventControllerScrollFlags {
    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 EventControllerScrollFlags {
    #[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<EventControllerScrollFlags> for glib::Value {
    #[inline]
    fn from(v: EventControllerScrollFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Specifies the granularity of font selection
    /// that is desired in a [`FontChooser`][crate::FontChooser].
    ///
    /// This enumeration may be extended in the future; applications should
    /// ignore unknown values.
    #[doc(alias = "GtkFontChooserLevel")]
    pub struct FontChooserLevel: u32 {
        /// Allow selecting a font family
        #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FAMILY")]
        const FAMILY = ffi::GTK_FONT_CHOOSER_LEVEL_FAMILY as _;
        /// Allow selecting a specific font face
        #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_STYLE")]
        const STYLE = ffi::GTK_FONT_CHOOSER_LEVEL_STYLE as _;
        /// Allow selecting a specific font size
        #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_SIZE")]
        const SIZE = ffi::GTK_FONT_CHOOSER_LEVEL_SIZE as _;
        /// Allow changing OpenType font variation axes
        #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_VARIATIONS")]
        const VARIATIONS = ffi::GTK_FONT_CHOOSER_LEVEL_VARIATIONS as _;
        /// Allow selecting specific OpenType font features
        #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FEATURES")]
        const FEATURES = ffi::GTK_FONT_CHOOSER_LEVEL_FEATURES as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for FontChooserLevel {
    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 FontChooserLevel {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for FontChooserLevel {
    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 FontChooserLevel {
    #[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<FontChooserLevel> for glib::Value {
    #[inline]
    fn from(v: FontChooserLevel) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Used to specify options for gtk_icon_theme_lookup_icon().
    #[doc(alias = "GtkIconLookupFlags")]
    pub struct IconLookupFlags: u32 {
        /// Try to always load regular icons, even
        ///   when symbolic icon names are given
        #[doc(alias = "GTK_ICON_LOOKUP_FORCE_REGULAR")]
        const FORCE_REGULAR = ffi::GTK_ICON_LOOKUP_FORCE_REGULAR as _;
        /// Try to always load symbolic icons, even
        ///   when regular icon names are given
        #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SYMBOLIC")]
        const FORCE_SYMBOLIC = ffi::GTK_ICON_LOOKUP_FORCE_SYMBOLIC as _;
        /// Starts loading the texture in the background
        ///   so it is ready when later needed.
        #[doc(alias = "GTK_ICON_LOOKUP_PRELOAD")]
        const PRELOAD = ffi::GTK_ICON_LOOKUP_PRELOAD as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for IconLookupFlags {
    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 IconLookupFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for IconLookupFlags {
    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 IconLookupFlags {
    #[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<IconLookupFlags> for glib::Value {
    #[inline]
    fn from(v: IconLookupFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Describes hints that might be taken into account by input methods
    /// or applications.
    ///
    /// Note that input methods may already tailor their behaviour according
    /// to the [`InputPurpose`][crate::InputPurpose] of the entry.
    ///
    /// Some common sense is expected when using these flags - mixing
    /// [`LOWERCASE`][Self::LOWERCASE] with any of the uppercase hints makes no sense.
    ///
    /// This enumeration may be extended in the future; input methods should
    /// ignore unknown values.
    #[doc(alias = "GtkInputHints")]
    pub struct InputHints: u32 {
        /// No special behaviour suggested
        #[doc(alias = "GTK_INPUT_HINT_NONE")]
        const NONE = ffi::GTK_INPUT_HINT_NONE as _;
        /// Suggest checking for typos
        #[doc(alias = "GTK_INPUT_HINT_SPELLCHECK")]
        const SPELLCHECK = ffi::GTK_INPUT_HINT_SPELLCHECK as _;
        /// Suggest not checking for typos
        #[doc(alias = "GTK_INPUT_HINT_NO_SPELLCHECK")]
        const NO_SPELLCHECK = ffi::GTK_INPUT_HINT_NO_SPELLCHECK as _;
        /// Suggest word completion
        #[doc(alias = "GTK_INPUT_HINT_WORD_COMPLETION")]
        const WORD_COMPLETION = ffi::GTK_INPUT_HINT_WORD_COMPLETION as _;
        /// Suggest to convert all text to lowercase
        #[doc(alias = "GTK_INPUT_HINT_LOWERCASE")]
        const LOWERCASE = ffi::GTK_INPUT_HINT_LOWERCASE as _;
        /// Suggest to capitalize all text
        #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_CHARS")]
        const UPPERCASE_CHARS = ffi::GTK_INPUT_HINT_UPPERCASE_CHARS as _;
        /// Suggest to capitalize the first
        ///   character of each word
        #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_WORDS")]
        const UPPERCASE_WORDS = ffi::GTK_INPUT_HINT_UPPERCASE_WORDS as _;
        /// Suggest to capitalize the
        ///   first word of each sentence
        #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_SENTENCES")]
        const UPPERCASE_SENTENCES = ffi::GTK_INPUT_HINT_UPPERCASE_SENTENCES as _;
        /// Suggest to not show an onscreen keyboard
        ///   (e.g for a calculator that already has all the keys).
        #[doc(alias = "GTK_INPUT_HINT_INHIBIT_OSK")]
        const INHIBIT_OSK = ffi::GTK_INPUT_HINT_INHIBIT_OSK as _;
        /// The text is vertical
        #[doc(alias = "GTK_INPUT_HINT_VERTICAL_WRITING")]
        const VERTICAL_WRITING = ffi::GTK_INPUT_HINT_VERTICAL_WRITING as _;
        /// Suggest offering Emoji support
        #[doc(alias = "GTK_INPUT_HINT_EMOJI")]
        const EMOJI = ffi::GTK_INPUT_HINT_EMOJI as _;
        /// Suggest not offering Emoji support
        #[doc(alias = "GTK_INPUT_HINT_NO_EMOJI")]
        const NO_EMOJI = ffi::GTK_INPUT_HINT_NO_EMOJI as _;
        /// Request that the input method should not
        ///    update personalized data (like typing history)
        #[doc(alias = "GTK_INPUT_HINT_PRIVATE")]
        const PRIVATE = ffi::GTK_INPUT_HINT_PRIVATE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for InputHints {
    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 InputHints {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for InputHints {
    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 InputHints {
    #[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<InputHints> for glib::Value {
    #[inline]
    fn from(v: InputHints) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags that influence the behavior of [`WidgetExt::pick()`][crate::prelude::WidgetExt::pick()].
    #[doc(alias = "GtkPickFlags")]
    pub struct PickFlags: u32 {
        /// The default behavior, include widgets that are receiving events
        #[doc(alias = "GTK_PICK_DEFAULT")]
        const DEFAULT = ffi::GTK_PICK_DEFAULT as _;
        /// Include widgets that are insensitive
        #[doc(alias = "GTK_PICK_INSENSITIVE")]
        const INSENSITIVE = ffi::GTK_PICK_INSENSITIVE as _;
        /// Include widgets that are marked as non-targetable. See [`can-target`][struct@crate::Widget#can-target]
        #[doc(alias = "GTK_PICK_NON_TARGETABLE")]
        const NON_TARGETABLE = ffi::GTK_PICK_NON_TARGETABLE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for PickFlags {
    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 PickFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PickFlags {
    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 PickFlags {
    #[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<PickFlags> for glib::Value {
    #[inline]
    fn from(v: PickFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags that affect how popover menus are created from
    /// a menu model.
    #[doc(alias = "GtkPopoverMenuFlags")]
    pub struct PopoverMenuFlags: u32 {
        /// Create submenus as nested
        ///    popovers. Without this flag, submenus are created as
        ///    sliding pages that replace the main menu.
        #[doc(alias = "GTK_POPOVER_MENU_NESTED")]
        const NESTED = ffi::GTK_POPOVER_MENU_NESTED as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for PopoverMenuFlags {
    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 PopoverMenuFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PopoverMenuFlags {
    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 PopoverMenuFlags {
    #[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<PopoverMenuFlags> for glib::Value {
    #[inline]
    fn from(v: PopoverMenuFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

#[cfg(any(target_os = "linux", feature = "dox"))]
bitflags! {
    /// Specifies which features the print dialog should offer.
    ///
    /// If neither [`GENERATE_PDF`][Self::GENERATE_PDF] nor
    /// [`GENERATE_PS`][Self::GENERATE_PS] is specified, GTK assumes that all
    /// formats are supported.
    #[cfg_attr(feature = "dox", doc(cfg(target_os = "linux")))]
    #[doc(alias = "GtkPrintCapabilities")]
    pub struct PrintCapabilities: u32 {
        /// Print dialog will offer printing even/odd pages.
        #[doc(alias = "GTK_PRINT_CAPABILITY_PAGE_SET")]
        const PAGE_SET = ffi::GTK_PRINT_CAPABILITY_PAGE_SET as _;
        /// Print dialog will allow to print multiple copies.
        #[doc(alias = "GTK_PRINT_CAPABILITY_COPIES")]
        const COPIES = ffi::GTK_PRINT_CAPABILITY_COPIES as _;
        /// Print dialog will allow to collate multiple copies.
        #[doc(alias = "GTK_PRINT_CAPABILITY_COLLATE")]
        const COLLATE = ffi::GTK_PRINT_CAPABILITY_COLLATE as _;
        /// Print dialog will allow to print pages in reverse order.
        #[doc(alias = "GTK_PRINT_CAPABILITY_REVERSE")]
        const REVERSE = ffi::GTK_PRINT_CAPABILITY_REVERSE as _;
        /// Print dialog will allow to scale the output.
        #[doc(alias = "GTK_PRINT_CAPABILITY_SCALE")]
        const SCALE = ffi::GTK_PRINT_CAPABILITY_SCALE as _;
        /// The program will send the document to
        ///   the printer in PDF format
        #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PDF")]
        const GENERATE_PDF = ffi::GTK_PRINT_CAPABILITY_GENERATE_PDF as _;
        /// The program will send the document to
        ///   the printer in Postscript format
        #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PS")]
        const GENERATE_PS = ffi::GTK_PRINT_CAPABILITY_GENERATE_PS as _;
        /// Print dialog will offer a preview
        #[doc(alias = "GTK_PRINT_CAPABILITY_PREVIEW")]
        const PREVIEW = ffi::GTK_PRINT_CAPABILITY_PREVIEW as _;
        /// Print dialog will offer printing multiple
        ///   pages per sheet
        #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP")]
        const NUMBER_UP = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP as _;
        /// Print dialog will allow to rearrange
        ///   pages when printing multiple pages per sheet
        #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT")]
        const NUMBER_UP_LAYOUT = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT as _;
    }
}

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

#[cfg(any(target_os = "linux", feature = "dox"))]
#[doc(hidden)]
impl IntoGlib for PrintCapabilities {
    type GlibType = ffi::GtkPrintCapabilities;

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

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

#[cfg(any(target_os = "linux", feature = "dox"))]
impl StaticType for PrintCapabilities {
    #[inline]
    fn static_type() -> Type {
        unsafe { from_glib(ffi::gtk_print_capabilities_get_type()) }
    }
}

#[cfg(any(target_os = "linux", feature = "dox"))]
impl glib::HasParamSpec for PrintCapabilities {
    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(target_os = "linux", feature = "dox"))]
impl glib::value::ValueType for PrintCapabilities {
    type Type = Self;
}

#[cfg(any(target_os = "linux", feature = "dox"))]
unsafe impl<'a> FromValue<'a> for PrintCapabilities {
    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(target_os = "linux", feature = "dox"))]
impl ToValue for PrintCapabilities {
    #[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(target_os = "linux", feature = "dox"))]
impl From<PrintCapabilities> for glib::Value {
    #[inline]
    fn from(v: PrintCapabilities) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// List of flags that can be passed to action activation.
    ///
    /// More flags may be added in the future.
    #[doc(alias = "GtkShortcutActionFlags")]
    pub struct ShortcutActionFlags: u32 {
        /// The action is the only
        ///   action that can be activated. If this flag is not set,
        ///   a future activation may select a different action.
        #[doc(alias = "GTK_SHORTCUT_ACTION_EXCLUSIVE")]
        const EXCLUSIVE = ffi::GTK_SHORTCUT_ACTION_EXCLUSIVE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for ShortcutActionFlags {
    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 ShortcutActionFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for ShortcutActionFlags {
    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 ShortcutActionFlags {
    #[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<ShortcutActionFlags> for glib::Value {
    #[inline]
    fn from(v: ShortcutActionFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Describes a widget state.
    ///
    /// Widget states are used to match the widget against CSS pseudo-classes.
    /// Note that GTK extends the regular CSS classes and sometimes uses
    /// different names.
    #[doc(alias = "GtkStateFlags")]
    pub struct StateFlags: u32 {
        /// State during normal operation
        #[doc(alias = "GTK_STATE_FLAG_NORMAL")]
        const NORMAL = ffi::GTK_STATE_FLAG_NORMAL as _;
        /// Widget is active
        #[doc(alias = "GTK_STATE_FLAG_ACTIVE")]
        const ACTIVE = ffi::GTK_STATE_FLAG_ACTIVE as _;
        /// Widget has a mouse pointer over it
        #[doc(alias = "GTK_STATE_FLAG_PRELIGHT")]
        const PRELIGHT = ffi::GTK_STATE_FLAG_PRELIGHT as _;
        /// Widget is selected
        #[doc(alias = "GTK_STATE_FLAG_SELECTED")]
        const SELECTED = ffi::GTK_STATE_FLAG_SELECTED as _;
        /// Widget is insensitive
        #[doc(alias = "GTK_STATE_FLAG_INSENSITIVE")]
        const INSENSITIVE = ffi::GTK_STATE_FLAG_INSENSITIVE as _;
        /// Widget is inconsistent
        #[doc(alias = "GTK_STATE_FLAG_INCONSISTENT")]
        const INCONSISTENT = ffi::GTK_STATE_FLAG_INCONSISTENT as _;
        /// Widget has the keyboard focus
        #[doc(alias = "GTK_STATE_FLAG_FOCUSED")]
        const FOCUSED = ffi::GTK_STATE_FLAG_FOCUSED as _;
        /// Widget is in a background toplevel window
        #[doc(alias = "GTK_STATE_FLAG_BACKDROP")]
        const BACKDROP = ffi::GTK_STATE_FLAG_BACKDROP as _;
        /// Widget is in left-to-right text direction
        #[doc(alias = "GTK_STATE_FLAG_DIR_LTR")]
        const DIR_LTR = ffi::GTK_STATE_FLAG_DIR_LTR as _;
        /// Widget is in right-to-left text direction
        #[doc(alias = "GTK_STATE_FLAG_DIR_RTL")]
        const DIR_RTL = ffi::GTK_STATE_FLAG_DIR_RTL as _;
        /// Widget is a link
        #[doc(alias = "GTK_STATE_FLAG_LINK")]
        const LINK = ffi::GTK_STATE_FLAG_LINK as _;
        /// The location the widget points to has already been visited
        #[doc(alias = "GTK_STATE_FLAG_VISITED")]
        const VISITED = ffi::GTK_STATE_FLAG_VISITED as _;
        /// Widget is checked
        #[doc(alias = "GTK_STATE_FLAG_CHECKED")]
        const CHECKED = ffi::GTK_STATE_FLAG_CHECKED as _;
        /// Widget is highlighted as a drop target for DND
        #[doc(alias = "GTK_STATE_FLAG_DROP_ACTIVE")]
        const DROP_ACTIVE = ffi::GTK_STATE_FLAG_DROP_ACTIVE as _;
        /// Widget has the visible focus
        #[doc(alias = "GTK_STATE_FLAG_FOCUS_VISIBLE")]
        const FOCUS_VISIBLE = ffi::GTK_STATE_FLAG_FOCUS_VISIBLE as _;
        /// Widget contains the keyboard focus
        #[doc(alias = "GTK_STATE_FLAG_FOCUS_WITHIN")]
        const FOCUS_WITHIN = ffi::GTK_STATE_FLAG_FOCUS_WITHIN as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for StateFlags {
    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 StateFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for StateFlags {
    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 StateFlags {
    #[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<StateFlags> for glib::Value {
    #[inline]
    fn from(v: StateFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags that modify the behavior of gtk_style_context_to_string().
    ///
    /// New values may be added to this enumeration.
    #[doc(alias = "GtkStyleContextPrintFlags")]
    pub struct StyleContextPrintFlags: u32 {
        /// Default value.
        #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_NONE")]
        const NONE = ffi::GTK_STYLE_CONTEXT_PRINT_NONE as _;
        /// Print the entire tree of
        ///   CSS nodes starting at the style context's node
        #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_RECURSE")]
        const RECURSE = ffi::GTK_STYLE_CONTEXT_PRINT_RECURSE as _;
        /// Show the values of the
        ///   CSS properties for each node
        #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE")]
        const SHOW_STYLE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE as _;
        /// Show information about
        ///   what changes affect the styles
        #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE")]
        const SHOW_CHANGE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for StyleContextPrintFlags {
    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 StyleContextPrintFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for StyleContextPrintFlags {
    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 StyleContextPrintFlags {
    #[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<StyleContextPrintFlags> for glib::Value {
    #[inline]
    fn from(v: StyleContextPrintFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// Flags affecting how a search is done.
    ///
    /// If neither [`VISIBLE_ONLY`][Self::VISIBLE_ONLY] nor [`TEXT_ONLY`][Self::TEXT_ONLY] are
    /// enabled, the match must be exact; the special 0xFFFC character will match
    /// embedded paintables or child widgets.
    #[doc(alias = "GtkTextSearchFlags")]
    pub struct TextSearchFlags: u32 {
        /// Search only visible data. A search match may
        /// have invisible text interspersed.
        #[doc(alias = "GTK_TEXT_SEARCH_VISIBLE_ONLY")]
        const VISIBLE_ONLY = ffi::GTK_TEXT_SEARCH_VISIBLE_ONLY as _;
        /// Search only text. A match may have paintables or
        /// child widgets mixed inside the matched range.
        #[doc(alias = "GTK_TEXT_SEARCH_TEXT_ONLY")]
        const TEXT_ONLY = ffi::GTK_TEXT_SEARCH_TEXT_ONLY as _;
        /// The text will be matched regardless of
        /// what case it is in.
        #[doc(alias = "GTK_TEXT_SEARCH_CASE_INSENSITIVE")]
        const CASE_INSENSITIVE = ffi::GTK_TEXT_SEARCH_CASE_INSENSITIVE as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for TextSearchFlags {
    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 TextSearchFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for TextSearchFlags {
    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 TextSearchFlags {
    #[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<TextSearchFlags> for glib::Value {
    #[inline]
    fn from(v: TextSearchFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// These flags indicate various properties of a [`TreeModel`][crate::TreeModel].
    ///
    /// They are returned by [`TreeModelExt::flags()`][crate::prelude::TreeModelExt::flags()], and must be
    /// static for the lifetime of the object. A more complete description
    /// of [`ITERS_PERSIST`][Self::ITERS_PERSIST] can be found in the overview of
    /// this section.
    #[doc(alias = "GtkTreeModelFlags")]
    pub struct TreeModelFlags: u32 {
        /// iterators survive all signals
        ///   emitted by the tree
        #[doc(alias = "GTK_TREE_MODEL_ITERS_PERSIST")]
        const ITERS_PERSIST = ffi::GTK_TREE_MODEL_ITERS_PERSIST as _;
        /// the model is a list only, and never
        ///   has children
        #[doc(alias = "GTK_TREE_MODEL_LIST_ONLY")]
        const LIST_ONLY = ffi::GTK_TREE_MODEL_LIST_ONLY as _;
    }
}

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

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

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

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

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

impl glib::HasParamSpec for TreeModelFlags {
    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 TreeModelFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for TreeModelFlags {
    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 TreeModelFlags {
    #[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<TreeModelFlags> for glib::Value {
    #[inline]
    fn from(v: TreeModelFlags) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}