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

use glib::{prelude::*, translate::*};
use std::fmt;

/// The blend modes available for render nodes.
///
/// The implementation of each blend mode is deferred to the
/// rendering pipeline.
///
/// See <https://www.w3.org/TR/compositing-1/#blending> for more information
/// on blending and blend modes.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskBlendMode")]
pub enum BlendMode {
    /// The default blend mode, which specifies no blending
    #[doc(alias = "GSK_BLEND_MODE_DEFAULT")]
    Default,
    /// The source color is multiplied by the destination
    ///   and replaces the destination
    #[doc(alias = "GSK_BLEND_MODE_MULTIPLY")]
    Multiply,
    /// Multiplies the complements of the destination and source
    ///   color values, then complements the result.
    #[doc(alias = "GSK_BLEND_MODE_SCREEN")]
    Screen,
    /// Multiplies or screens the colors, depending on the
    ///   destination color value. This is the inverse of hard-list
    #[doc(alias = "GSK_BLEND_MODE_OVERLAY")]
    Overlay,
    /// Selects the darker of the destination and source colors
    #[doc(alias = "GSK_BLEND_MODE_DARKEN")]
    Darken,
    /// Selects the lighter of the destination and source colors
    #[doc(alias = "GSK_BLEND_MODE_LIGHTEN")]
    Lighten,
    /// Brightens the destination color to reflect the source color
    #[doc(alias = "GSK_BLEND_MODE_COLOR_DODGE")]
    ColorDodge,
    /// Darkens the destination color to reflect the source color
    #[doc(alias = "GSK_BLEND_MODE_COLOR_BURN")]
    ColorBurn,
    /// Multiplies or screens the colors, depending on the source color value
    #[doc(alias = "GSK_BLEND_MODE_HARD_LIGHT")]
    HardLight,
    /// Darkens or lightens the colors, depending on the source color value
    #[doc(alias = "GSK_BLEND_MODE_SOFT_LIGHT")]
    SoftLight,
    /// Subtracts the darker of the two constituent colors from the lighter color
    #[doc(alias = "GSK_BLEND_MODE_DIFFERENCE")]
    Difference,
    /// Produces an effect similar to that of the difference mode but lower in contrast
    #[doc(alias = "GSK_BLEND_MODE_EXCLUSION")]
    Exclusion,
    /// Creates a color with the hue and saturation of the source color and the luminosity of the destination color
    #[doc(alias = "GSK_BLEND_MODE_COLOR")]
    Color,
    /// Creates a color with the hue of the source color and the saturation and luminosity of the destination color
    #[doc(alias = "GSK_BLEND_MODE_HUE")]
    Hue,
    /// Creates a color with the saturation of the source color and the hue and luminosity of the destination color
    #[doc(alias = "GSK_BLEND_MODE_SATURATION")]
    Saturation,
    /// Creates a color with the luminosity of the source color and the hue and saturation of the destination color
    #[doc(alias = "GSK_BLEND_MODE_LUMINOSITY")]
    Luminosity,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for BlendMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "BlendMode::{}",
            match *self {
                Self::Default => "Default",
                Self::Multiply => "Multiply",
                Self::Screen => "Screen",
                Self::Overlay => "Overlay",
                Self::Darken => "Darken",
                Self::Lighten => "Lighten",
                Self::ColorDodge => "ColorDodge",
                Self::ColorBurn => "ColorBurn",
                Self::HardLight => "HardLight",
                Self::SoftLight => "SoftLight",
                Self::Difference => "Difference",
                Self::Exclusion => "Exclusion",
                Self::Color => "Color",
                Self::Hue => "Hue",
                Self::Saturation => "Saturation",
                Self::Luminosity => "Luminosity",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GskBlendMode {
        match self {
            Self::Default => ffi::GSK_BLEND_MODE_DEFAULT,
            Self::Multiply => ffi::GSK_BLEND_MODE_MULTIPLY,
            Self::Screen => ffi::GSK_BLEND_MODE_SCREEN,
            Self::Overlay => ffi::GSK_BLEND_MODE_OVERLAY,
            Self::Darken => ffi::GSK_BLEND_MODE_DARKEN,
            Self::Lighten => ffi::GSK_BLEND_MODE_LIGHTEN,
            Self::ColorDodge => ffi::GSK_BLEND_MODE_COLOR_DODGE,
            Self::ColorBurn => ffi::GSK_BLEND_MODE_COLOR_BURN,
            Self::HardLight => ffi::GSK_BLEND_MODE_HARD_LIGHT,
            Self::SoftLight => ffi::GSK_BLEND_MODE_SOFT_LIGHT,
            Self::Difference => ffi::GSK_BLEND_MODE_DIFFERENCE,
            Self::Exclusion => ffi::GSK_BLEND_MODE_EXCLUSION,
            Self::Color => ffi::GSK_BLEND_MODE_COLOR,
            Self::Hue => ffi::GSK_BLEND_MODE_HUE,
            Self::Saturation => ffi::GSK_BLEND_MODE_SATURATION,
            Self::Luminosity => ffi::GSK_BLEND_MODE_LUMINOSITY,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_BLEND_MODE_DEFAULT => Self::Default,
            ffi::GSK_BLEND_MODE_MULTIPLY => Self::Multiply,
            ffi::GSK_BLEND_MODE_SCREEN => Self::Screen,
            ffi::GSK_BLEND_MODE_OVERLAY => Self::Overlay,
            ffi::GSK_BLEND_MODE_DARKEN => Self::Darken,
            ffi::GSK_BLEND_MODE_LIGHTEN => Self::Lighten,
            ffi::GSK_BLEND_MODE_COLOR_DODGE => Self::ColorDodge,
            ffi::GSK_BLEND_MODE_COLOR_BURN => Self::ColorBurn,
            ffi::GSK_BLEND_MODE_HARD_LIGHT => Self::HardLight,
            ffi::GSK_BLEND_MODE_SOFT_LIGHT => Self::SoftLight,
            ffi::GSK_BLEND_MODE_DIFFERENCE => Self::Difference,
            ffi::GSK_BLEND_MODE_EXCLUSION => Self::Exclusion,
            ffi::GSK_BLEND_MODE_COLOR => Self::Color,
            ffi::GSK_BLEND_MODE_HUE => Self::Hue,
            ffi::GSK_BLEND_MODE_SATURATION => Self::Saturation,
            ffi::GSK_BLEND_MODE_LUMINOSITY => Self::Luminosity,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// The corner indices used by [`RoundedRect`][crate::RoundedRect].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskCorner")]
pub enum Corner {
    /// The top left corner
    #[doc(alias = "GSK_CORNER_TOP_LEFT")]
    TopLeft,
    /// The top right corner
    #[doc(alias = "GSK_CORNER_TOP_RIGHT")]
    TopRight,
    /// The bottom right corner
    #[doc(alias = "GSK_CORNER_BOTTOM_RIGHT")]
    BottomRight,
    /// The bottom left corner
    #[doc(alias = "GSK_CORNER_BOTTOM_LEFT")]
    BottomLeft,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for Corner {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Corner::{}",
            match *self {
                Self::TopLeft => "TopLeft",
                Self::TopRight => "TopRight",
                Self::BottomRight => "BottomRight",
                Self::BottomLeft => "BottomLeft",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GskCorner {
        match self {
            Self::TopLeft => ffi::GSK_CORNER_TOP_LEFT,
            Self::TopRight => ffi::GSK_CORNER_TOP_RIGHT,
            Self::BottomRight => ffi::GSK_CORNER_BOTTOM_RIGHT,
            Self::BottomLeft => ffi::GSK_CORNER_BOTTOM_LEFT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_CORNER_TOP_LEFT => Self::TopLeft,
            ffi::GSK_CORNER_TOP_RIGHT => Self::TopRight,
            ffi::GSK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
            ffi::GSK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// [`FillRule`][crate::FillRule] is used to select how paths are filled.
///
/// Whether or not a point is included in the fill is determined by taking
/// a ray from that point to infinity and looking at intersections with the
/// path. The ray can be in any direction, as long as it doesn't pass through
/// the end point of a segment or have a tricky intersection such as
/// intersecting tangent to the path.
///
/// (Note that filling is not actually implemented in this way. This
/// is just a description of the rule that is applied.)
///
/// New entries may be added in future versions.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskFillRule")]
pub enum FillRule {
    /// If the path crosses the ray from
    ///   left-to-right, counts +1. If the path crosses the ray
    ///   from right to left, counts -1. (Left and right are determined
    ///   from the perspective of looking along the ray from the starting
    ///   point.) If the total count is non-zero, the point will be filled.
    #[doc(alias = "GSK_FILL_RULE_WINDING")]
    Winding,
    /// Counts the total number of
    ///   intersections, without regard to the orientation of the contour. If
    ///   the total number of intersections is odd, the point will be
    ///   filled.
    #[doc(alias = "GSK_FILL_RULE_EVEN_ODD")]
    EvenOdd,
    #[doc(hidden)]
    __Unknown(i32),
}

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

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for FillRule {
    type GlibType = ffi::GskFillRule;

    #[inline]
    fn into_glib(self) -> ffi::GskFillRule {
        match self {
            Self::Winding => ffi::GSK_FILL_RULE_WINDING,
            Self::EvenOdd => ffi::GSK_FILL_RULE_EVEN_ODD,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_FILL_RULE_WINDING => Self::Winding,
            ffi::GSK_FILL_RULE_EVEN_ODD => Self::EvenOdd,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// This defines the types of the uniforms that `GskGLShaders`
/// declare.
///
/// It defines both what the type is called in the GLSL shader
/// code, and what the corresponding C type is on the Gtk side.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskGLUniformType")]
pub enum GLUniformType {
    /// No type, used for uninitialized or unspecified values.
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_NONE")]
    None,
    /// A float uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_FLOAT")]
    Float,
    /// A GLSL int / gint32 uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_INT")]
    Int,
    /// A GLSL uint / guint32 uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_UINT")]
    Uint,
    /// A GLSL bool / gboolean uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_BOOL")]
    Bool,
    /// A GLSL vec2 / graphene_vec2_t uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC2")]
    Vec2,
    /// A GLSL vec3 / graphene_vec3_t uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC3")]
    Vec3,
    /// A GLSL vec4 / graphene_vec4_t uniform
    #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC4")]
    Vec4,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GLUniformType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "GLUniformType::{}",
            match *self {
                Self::None => "None",
                Self::Float => "Float",
                Self::Int => "Int",
                Self::Uint => "Uint",
                Self::Bool => "Bool",
                Self::Vec2 => "Vec2",
                Self::Vec3 => "Vec3",
                Self::Vec4 => "Vec4",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GskGLUniformType {
        match self {
            Self::None => ffi::GSK_GL_UNIFORM_TYPE_NONE,
            Self::Float => ffi::GSK_GL_UNIFORM_TYPE_FLOAT,
            Self::Int => ffi::GSK_GL_UNIFORM_TYPE_INT,
            Self::Uint => ffi::GSK_GL_UNIFORM_TYPE_UINT,
            Self::Bool => ffi::GSK_GL_UNIFORM_TYPE_BOOL,
            Self::Vec2 => ffi::GSK_GL_UNIFORM_TYPE_VEC2,
            Self::Vec3 => ffi::GSK_GL_UNIFORM_TYPE_VEC3,
            Self::Vec4 => ffi::GSK_GL_UNIFORM_TYPE_VEC4,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_GL_UNIFORM_TYPE_NONE => Self::None,
            ffi::GSK_GL_UNIFORM_TYPE_FLOAT => Self::Float,
            ffi::GSK_GL_UNIFORM_TYPE_INT => Self::Int,
            ffi::GSK_GL_UNIFORM_TYPE_UINT => Self::Uint,
            ffi::GSK_GL_UNIFORM_TYPE_BOOL => Self::Bool,
            ffi::GSK_GL_UNIFORM_TYPE_VEC2 => Self::Vec2,
            ffi::GSK_GL_UNIFORM_TYPE_VEC3 => Self::Vec3,
            ffi::GSK_GL_UNIFORM_TYPE_VEC4 => Self::Vec4,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Specifies how to render the start and end points of contours or
/// dashes when stroking.
///
/// The default line cap style is `GSK_LINE_CAP_BUTT`.
///
/// New entries may be added in future versions.
///
/// <figure>
///   <picture>
///     <source srcset="caps-dark.png" media="(prefers-color-scheme: dark)">
///     <img alt="Line Cap Styles" src="caps-light.png">
///   </picture>
///   <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption>
/// </figure>
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskLineCap")]
pub enum LineCap {
    /// Start and stop the line exactly at the start
    ///   and end point
    #[doc(alias = "GSK_LINE_CAP_BUTT")]
    Butt,
    /// Use a round ending, the center of the circle
    ///   is the start or end point
    #[doc(alias = "GSK_LINE_CAP_ROUND")]
    Round,
    /// use squared ending, the center of the square
    ///   is the start or end point
    #[doc(alias = "GSK_LINE_CAP_SQUARE")]
    Square,
    #[doc(hidden)]
    __Unknown(i32),
}

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

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for LineCap {
    type GlibType = ffi::GskLineCap;

    #[inline]
    fn into_glib(self) -> ffi::GskLineCap {
        match self {
            Self::Butt => ffi::GSK_LINE_CAP_BUTT,
            Self::Round => ffi::GSK_LINE_CAP_ROUND,
            Self::Square => ffi::GSK_LINE_CAP_SQUARE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_LINE_CAP_BUTT => Self::Butt,
            ffi::GSK_LINE_CAP_ROUND => Self::Round,
            ffi::GSK_LINE_CAP_SQUARE => Self::Square,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Specifies how to render the junction of two lines when stroking.
///
/// The default line join style is `GSK_LINE_JOIN_MITER`.
///
/// New entries may be added in future versions.
///
/// <figure>
///   <picture>
///     <source srcset="join-dark.png" media="(prefers-color-scheme: dark)">
///     <img alt="Line Join Styles" src="join-light.png">
///   </picture>
///   <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption>
/// </figure>
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskLineJoin")]
pub enum LineJoin {
    /// Use a sharp angled corner
    #[doc(alias = "GSK_LINE_JOIN_MITER")]
    Miter,
    /// Use a round join, the center of the circle is
    ///   the join point
    #[doc(alias = "GSK_LINE_JOIN_ROUND")]
    Round,
    /// use a cut-off join, the join is cut off at half
    ///   the line width from the joint point
    #[doc(alias = "GSK_LINE_JOIN_BEVEL")]
    Bevel,
    #[doc(hidden)]
    __Unknown(i32),
}

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

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for LineJoin {
    type GlibType = ffi::GskLineJoin;

    #[inline]
    fn into_glib(self) -> ffi::GskLineJoin {
        match self {
            Self::Miter => ffi::GSK_LINE_JOIN_MITER,
            Self::Round => ffi::GSK_LINE_JOIN_ROUND,
            Self::Bevel => ffi::GSK_LINE_JOIN_BEVEL,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_LINE_JOIN_MITER => Self::Miter,
            ffi::GSK_LINE_JOIN_ROUND => Self::Round,
            ffi::GSK_LINE_JOIN_BEVEL => Self::Bevel,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// The mask modes available for mask nodes.
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskMaskMode")]
pub enum MaskMode {
    /// Use the alpha channel of the mask
    #[doc(alias = "GSK_MASK_MODE_ALPHA")]
    Alpha,
    /// Use the inverted alpha channel of the mask
    #[doc(alias = "GSK_MASK_MODE_INVERTED_ALPHA")]
    InvertedAlpha,
    /// Use the luminance of the mask,
    ///     multiplied by mask alpha
    #[doc(alias = "GSK_MASK_MODE_LUMINANCE")]
    Luminance,
    /// Use the inverted luminance of the mask,
    ///     multiplied by mask alpha
    #[doc(alias = "GSK_MASK_MODE_INVERTED_LUMINANCE")]
    InvertedLuminance,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl fmt::Display for MaskMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "MaskMode::{}",
            match *self {
                Self::Alpha => "Alpha",
                Self::InvertedAlpha => "InvertedAlpha",
                Self::Luminance => "Luminance",
                Self::InvertedLuminance => "InvertedLuminance",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl IntoGlib for MaskMode {
    type GlibType = ffi::GskMaskMode;

    #[inline]
    fn into_glib(self) -> ffi::GskMaskMode {
        match self {
            Self::Alpha => ffi::GSK_MASK_MODE_ALPHA,
            Self::InvertedAlpha => ffi::GSK_MASK_MODE_INVERTED_ALPHA,
            Self::Luminance => ffi::GSK_MASK_MODE_LUMINANCE,
            Self::InvertedLuminance => ffi::GSK_MASK_MODE_INVERTED_LUMINANCE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_MASK_MODE_ALPHA => Self::Alpha,
            ffi::GSK_MASK_MODE_INVERTED_ALPHA => Self::InvertedAlpha,
            ffi::GSK_MASK_MODE_LUMINANCE => Self::Luminance,
            ffi::GSK_MASK_MODE_INVERTED_LUMINANCE => Self::InvertedLuminance,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// The values of the [`PathDirection`][crate::PathDirection] enum are used to pick one
/// of the four tangents at a given point on the path.
///
/// Note that the directions for @GSK_PATH_FROM_START/@GSK_PATH_TO_END and
/// @GSK_PATH_TO_START/@GSK_PATH_FROM_END will coincide for smooth points.
/// Only sharp turns will exhibit four different directions.
///
/// <picture>
///   <source srcset="directions-dark.png" media="(prefers-color-scheme: dark)">
///   <img alt="Path Tangents" src="directions-light.png">
/// </picture>
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskPathDirection")]
pub enum PathDirection {
    /// The tangent in path direction of the incoming side
    ///   of the path
    #[doc(alias = "GSK_PATH_FROM_START")]
    FromStart,
    /// The tangent against path direction of the incoming side
    ///   of the path
    #[doc(alias = "GSK_PATH_TO_START")]
    ToStart,
    /// The tangent in path direction of the outgoing side
    ///   of the path
    #[doc(alias = "GSK_PATH_TO_END")]
    ToEnd,
    /// The tangent against path direction of the outgoing
    ///   side of the path
    #[doc(alias = "GSK_PATH_FROM_END")]
    FromEnd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl fmt::Display for PathDirection {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "PathDirection::{}",
            match *self {
                Self::FromStart => "FromStart",
                Self::ToStart => "ToStart",
                Self::ToEnd => "ToEnd",
                Self::FromEnd => "FromEnd",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for PathDirection {
    type GlibType = ffi::GskPathDirection;

    #[inline]
    fn into_glib(self) -> ffi::GskPathDirection {
        match self {
            Self::FromStart => ffi::GSK_PATH_FROM_START,
            Self::ToStart => ffi::GSK_PATH_TO_START,
            Self::ToEnd => ffi::GSK_PATH_TO_END,
            Self::FromEnd => ffi::GSK_PATH_FROM_END,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_PATH_FROM_START => Self::FromStart,
            ffi::GSK_PATH_TO_START => Self::ToStart,
            ffi::GSK_PATH_TO_END => Self::ToEnd,
            ffi::GSK_PATH_FROM_END => Self::FromEnd,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Path operations are used to describe the segments of a [`Path`][crate::Path].
///
/// More values may be added in the future.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskPathOperation")]
pub enum PathOperation {
    /// A move-to operation, with 1 point describing the target point.
    #[doc(alias = "GSK_PATH_MOVE")]
    Move,
    /// A close operation ending the current contour with a line back
    ///   to the starting point. Two points describe the start and end of the line.
    #[doc(alias = "GSK_PATH_CLOSE")]
    Close,
    /// A line-to operation, with 2 points describing the start and
    ///   end point of a straight line.
    #[doc(alias = "GSK_PATH_LINE")]
    Line,
    /// A curve-to operation describing a quadratic Bézier curve
    ///   with 3 points describing the start point, the control point and the end
    ///   point of the curve.
    #[doc(alias = "GSK_PATH_QUAD")]
    Quad,
    /// A curve-to operation describing a cubic Bézier curve with 4
    ///   points describing the start point, the two control points and the end point
    ///   of the curve.
    #[doc(alias = "GSK_PATH_CUBIC")]
    Cubic,
    /// A rational quadratic Bézier curve with 3 points describing
    ///   the start point, control point and end point of the curve. A weight for the
    ///   curve will be passed, too.
    #[doc(alias = "GSK_PATH_CONIC")]
    Conic,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl fmt::Display for PathOperation {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "PathOperation::{}",
            match *self {
                Self::Move => "Move",
                Self::Close => "Close",
                Self::Line => "Line",
                Self::Quad => "Quad",
                Self::Cubic => "Cubic",
                Self::Conic => "Conic",
                _ => "Unknown",
            }
        )
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for PathOperation {
    type GlibType = ffi::GskPathOperation;

    #[inline]
    fn into_glib(self) -> ffi::GskPathOperation {
        match self {
            Self::Move => ffi::GSK_PATH_MOVE,
            Self::Close => ffi::GSK_PATH_CLOSE,
            Self::Line => ffi::GSK_PATH_LINE,
            Self::Quad => ffi::GSK_PATH_QUAD,
            Self::Cubic => ffi::GSK_PATH_CUBIC,
            Self::Conic => ffi::GSK_PATH_CONIC,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_PATH_MOVE => Self::Move,
            ffi::GSK_PATH_CLOSE => Self::Close,
            ffi::GSK_PATH_LINE => Self::Line,
            ffi::GSK_PATH_QUAD => Self::Quad,
            ffi::GSK_PATH_CUBIC => Self::Cubic,
            ffi::GSK_PATH_CONIC => Self::Conic,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// The type of a node determines what the node is rendering.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskRenderNodeType")]
pub enum RenderNodeType {
    /// Error type. No node will ever have this type.
    #[doc(alias = "GSK_NOT_A_RENDER_NODE")]
    NotARenderNode,
    /// A node containing a stack of children
    #[doc(alias = "GSK_CONTAINER_NODE")]
    ContainerNode,
    /// A node drawing a [`cairo::Surface`][crate::cairo::Surface]
    #[doc(alias = "GSK_CAIRO_NODE")]
    CairoNode,
    /// A node drawing a single color rectangle
    #[doc(alias = "GSK_COLOR_NODE")]
    ColorNode,
    /// A node drawing a linear gradient
    #[doc(alias = "GSK_LINEAR_GRADIENT_NODE")]
    LinearGradientNode,
    /// A node drawing a repeating linear gradient
    #[doc(alias = "GSK_REPEATING_LINEAR_GRADIENT_NODE")]
    RepeatingLinearGradientNode,
    /// A node drawing a radial gradient
    #[doc(alias = "GSK_RADIAL_GRADIENT_NODE")]
    RadialGradientNode,
    /// A node drawing a repeating radial gradient
    #[doc(alias = "GSK_REPEATING_RADIAL_GRADIENT_NODE")]
    RepeatingRadialGradientNode,
    /// A node drawing a conic gradient
    #[doc(alias = "GSK_CONIC_GRADIENT_NODE")]
    ConicGradientNode,
    /// A node stroking a border around an area
    #[doc(alias = "GSK_BORDER_NODE")]
    BorderNode,
    /// A node drawing a [`gdk::Texture`][crate::gdk::Texture]
    #[doc(alias = "GSK_TEXTURE_NODE")]
    TextureNode,
    /// A node drawing an inset shadow
    #[doc(alias = "GSK_INSET_SHADOW_NODE")]
    InsetShadowNode,
    /// A node drawing an outset shadow
    #[doc(alias = "GSK_OUTSET_SHADOW_NODE")]
    OutsetShadowNode,
    /// A node that renders its child after applying a matrix transform
    #[doc(alias = "GSK_TRANSFORM_NODE")]
    TransformNode,
    /// A node that changes the opacity of its child
    #[doc(alias = "GSK_OPACITY_NODE")]
    OpacityNode,
    /// A node that applies a color matrix to every pixel
    #[doc(alias = "GSK_COLOR_MATRIX_NODE")]
    ColorMatrixNode,
    /// A node that repeats the child's contents
    #[doc(alias = "GSK_REPEAT_NODE")]
    RepeatNode,
    /// A node that clips its child to a rectangular area
    #[doc(alias = "GSK_CLIP_NODE")]
    ClipNode,
    /// A node that clips its child to a rounded rectangle
    #[doc(alias = "GSK_ROUNDED_CLIP_NODE")]
    RoundedClipNode,
    /// A node that draws a shadow below its child
    #[doc(alias = "GSK_SHADOW_NODE")]
    ShadowNode,
    /// A node that blends two children together
    #[doc(alias = "GSK_BLEND_NODE")]
    BlendNode,
    /// A node that cross-fades between two children
    #[doc(alias = "GSK_CROSS_FADE_NODE")]
    CrossFadeNode,
    /// A node containing a glyph string
    #[doc(alias = "GSK_TEXT_NODE")]
    TextNode,
    /// A node that applies a blur
    #[doc(alias = "GSK_BLUR_NODE")]
    BlurNode,
    /// Debug information that does not affect the rendering
    #[doc(alias = "GSK_DEBUG_NODE")]
    DebugNode,
    /// A node that uses OpenGL fragment shaders to render
    #[doc(alias = "GSK_GL_SHADER_NODE")]
    GlShaderNode,
    /// A node drawing a [`gdk::Texture`][crate::gdk::Texture] scaled and filtered (Since: 4.10)
    #[doc(alias = "GSK_TEXTURE_SCALE_NODE")]
    TextureScaleNode,
    /// A node that masks one child with another (Since: 4.10)
    #[doc(alias = "GSK_MASK_NODE")]
    MaskNode,
    /// A node that fills a path
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GSK_FILL_NODE")]
    FillNode,
    /// A node that strokes a path
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GSK_STROKE_NODE")]
    StrokeNode,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RenderNodeType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "RenderNodeType::{}",
            match *self {
                Self::NotARenderNode => "NotARenderNode",
                Self::ContainerNode => "ContainerNode",
                Self::CairoNode => "CairoNode",
                Self::ColorNode => "ColorNode",
                Self::LinearGradientNode => "LinearGradientNode",
                Self::RepeatingLinearGradientNode => "RepeatingLinearGradientNode",
                Self::RadialGradientNode => "RadialGradientNode",
                Self::RepeatingRadialGradientNode => "RepeatingRadialGradientNode",
                Self::ConicGradientNode => "ConicGradientNode",
                Self::BorderNode => "BorderNode",
                Self::TextureNode => "TextureNode",
                Self::InsetShadowNode => "InsetShadowNode",
                Self::OutsetShadowNode => "OutsetShadowNode",
                Self::TransformNode => "TransformNode",
                Self::OpacityNode => "OpacityNode",
                Self::ColorMatrixNode => "ColorMatrixNode",
                Self::RepeatNode => "RepeatNode",
                Self::ClipNode => "ClipNode",
                Self::RoundedClipNode => "RoundedClipNode",
                Self::ShadowNode => "ShadowNode",
                Self::BlendNode => "BlendNode",
                Self::CrossFadeNode => "CrossFadeNode",
                Self::TextNode => "TextNode",
                Self::BlurNode => "BlurNode",
                Self::DebugNode => "DebugNode",
                Self::GlShaderNode => "GlShaderNode",
                Self::TextureScaleNode => "TextureScaleNode",
                Self::MaskNode => "MaskNode",
                #[cfg(feature = "v4_14")]
                Self::FillNode => "FillNode",
                #[cfg(feature = "v4_14")]
                Self::StrokeNode => "StrokeNode",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::GskRenderNodeType {
        match self {
            Self::NotARenderNode => ffi::GSK_NOT_A_RENDER_NODE,
            Self::ContainerNode => ffi::GSK_CONTAINER_NODE,
            Self::CairoNode => ffi::GSK_CAIRO_NODE,
            Self::ColorNode => ffi::GSK_COLOR_NODE,
            Self::LinearGradientNode => ffi::GSK_LINEAR_GRADIENT_NODE,
            Self::RepeatingLinearGradientNode => ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE,
            Self::RadialGradientNode => ffi::GSK_RADIAL_GRADIENT_NODE,
            Self::RepeatingRadialGradientNode => ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE,
            Self::ConicGradientNode => ffi::GSK_CONIC_GRADIENT_NODE,
            Self::BorderNode => ffi::GSK_BORDER_NODE,
            Self::TextureNode => ffi::GSK_TEXTURE_NODE,
            Self::InsetShadowNode => ffi::GSK_INSET_SHADOW_NODE,
            Self::OutsetShadowNode => ffi::GSK_OUTSET_SHADOW_NODE,
            Self::TransformNode => ffi::GSK_TRANSFORM_NODE,
            Self::OpacityNode => ffi::GSK_OPACITY_NODE,
            Self::ColorMatrixNode => ffi::GSK_COLOR_MATRIX_NODE,
            Self::RepeatNode => ffi::GSK_REPEAT_NODE,
            Self::ClipNode => ffi::GSK_CLIP_NODE,
            Self::RoundedClipNode => ffi::GSK_ROUNDED_CLIP_NODE,
            Self::ShadowNode => ffi::GSK_SHADOW_NODE,
            Self::BlendNode => ffi::GSK_BLEND_NODE,
            Self::CrossFadeNode => ffi::GSK_CROSS_FADE_NODE,
            Self::TextNode => ffi::GSK_TEXT_NODE,
            Self::BlurNode => ffi::GSK_BLUR_NODE,
            Self::DebugNode => ffi::GSK_DEBUG_NODE,
            Self::GlShaderNode => ffi::GSK_GL_SHADER_NODE,
            Self::TextureScaleNode => ffi::GSK_TEXTURE_SCALE_NODE,
            Self::MaskNode => ffi::GSK_MASK_NODE,
            #[cfg(feature = "v4_14")]
            Self::FillNode => ffi::GSK_FILL_NODE,
            #[cfg(feature = "v4_14")]
            Self::StrokeNode => ffi::GSK_STROKE_NODE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_NOT_A_RENDER_NODE => Self::NotARenderNode,
            ffi::GSK_CONTAINER_NODE => Self::ContainerNode,
            ffi::GSK_CAIRO_NODE => Self::CairoNode,
            ffi::GSK_COLOR_NODE => Self::ColorNode,
            ffi::GSK_LINEAR_GRADIENT_NODE => Self::LinearGradientNode,
            ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE => Self::RepeatingLinearGradientNode,
            ffi::GSK_RADIAL_GRADIENT_NODE => Self::RadialGradientNode,
            ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE => Self::RepeatingRadialGradientNode,
            ffi::GSK_CONIC_GRADIENT_NODE => Self::ConicGradientNode,
            ffi::GSK_BORDER_NODE => Self::BorderNode,
            ffi::GSK_TEXTURE_NODE => Self::TextureNode,
            ffi::GSK_INSET_SHADOW_NODE => Self::InsetShadowNode,
            ffi::GSK_OUTSET_SHADOW_NODE => Self::OutsetShadowNode,
            ffi::GSK_TRANSFORM_NODE => Self::TransformNode,
            ffi::GSK_OPACITY_NODE => Self::OpacityNode,
            ffi::GSK_COLOR_MATRIX_NODE => Self::ColorMatrixNode,
            ffi::GSK_REPEAT_NODE => Self::RepeatNode,
            ffi::GSK_CLIP_NODE => Self::ClipNode,
            ffi::GSK_ROUNDED_CLIP_NODE => Self::RoundedClipNode,
            ffi::GSK_SHADOW_NODE => Self::ShadowNode,
            ffi::GSK_BLEND_NODE => Self::BlendNode,
            ffi::GSK_CROSS_FADE_NODE => Self::CrossFadeNode,
            ffi::GSK_TEXT_NODE => Self::TextNode,
            ffi::GSK_BLUR_NODE => Self::BlurNode,
            ffi::GSK_DEBUG_NODE => Self::DebugNode,
            ffi::GSK_GL_SHADER_NODE => Self::GlShaderNode,
            ffi::GSK_TEXTURE_SCALE_NODE => Self::TextureScaleNode,
            ffi::GSK_MASK_NODE => Self::MaskNode,
            #[cfg(feature = "v4_14")]
            ffi::GSK_FILL_NODE => Self::FillNode,
            #[cfg(feature = "v4_14")]
            ffi::GSK_STROKE_NODE => Self::StrokeNode,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// The filters used when scaling texture data.
///
/// The actual implementation of each filter is deferred to the
/// rendering pipeline.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskScalingFilter")]
pub enum ScalingFilter {
    /// linear interpolation filter
    #[doc(alias = "GSK_SCALING_FILTER_LINEAR")]
    Linear,
    /// nearest neighbor interpolation filter
    #[doc(alias = "GSK_SCALING_FILTER_NEAREST")]
    Nearest,
    /// linear interpolation along each axis,
    ///   plus mipmap generation, with linear interpolation along the mipmap
    ///   levels
    #[doc(alias = "GSK_SCALING_FILTER_TRILINEAR")]
    Trilinear,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    #[inline]
    fn into_glib(self) -> ffi::GskScalingFilter {
        match self {
            Self::Linear => ffi::GSK_SCALING_FILTER_LINEAR,
            Self::Nearest => ffi::GSK_SCALING_FILTER_NEAREST,
            Self::Trilinear => ffi::GSK_SCALING_FILTER_TRILINEAR,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_SCALING_FILTER_LINEAR => Self::Linear,
            ffi::GSK_SCALING_FILTER_NEAREST => Self::Nearest,
            ffi::GSK_SCALING_FILTER_TRILINEAR => Self::Trilinear,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Errors that can happen during (de)serialization.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskSerializationError")]
pub enum SerializationError {
    /// The format can not be identified
    #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_FORMAT")]
    UnsupportedFormat,
    /// The version of the data is not
    ///   understood
    #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_VERSION")]
    UnsupportedVersion,
    /// The given data may not exist in
    ///   a proper serialization
    #[doc(alias = "GSK_SERIALIZATION_INVALID_DATA")]
    InvalidData,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    #[inline]
    fn into_glib(self) -> ffi::GskSerializationError {
        match self {
            Self::UnsupportedFormat => ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT,
            Self::UnsupportedVersion => ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION,
            Self::InvalidData => ffi::GSK_SERIALIZATION_INVALID_DATA,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
            ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION => Self::UnsupportedVersion,
            ffi::GSK_SERIALIZATION_INVALID_DATA => Self::InvalidData,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/// The categories of matrices relevant for GSK and GTK.
///
/// Note that any category includes matrices of all later categories.
/// So if you want to for example check if a matrix is a 2D matrix,
/// `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
///
/// Also keep in mind that rounding errors may cause matrices to not
/// conform to their categories. Otherwise, matrix operations done via
/// multiplication will not worsen categories. So for the matrix
/// multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GskTransformCategory")]
pub enum TransformCategory {
    /// The category of the matrix has not been
    ///   determined.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_UNKNOWN")]
    Unknown,
    /// Analyzing the matrix concluded that it does
    ///   not fit in any other category.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_ANY")]
    Any,
    /// The matrix is a 3D matrix. This means that
    ///   the w column (the last column) has the values (0, 0, 0, 1).
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_3D")]
    _3d,
    /// The matrix is a 2D matrix. This is equivalent
    ///   to graphene_matrix_is_2d() returning [`true`]. In particular, this
    ///   means that Cairo can deal with the matrix.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D")]
    _2d,
    /// The matrix is a combination of 2D scale
    ///   and 2D translation operations. In particular, this means that any
    ///   rectangle can be transformed exactly using this matrix.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_AFFINE")]
    _2dAffine,
    /// The matrix is a 2D translation.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_TRANSLATE")]
    _2dTranslate,
    /// The matrix is the identity matrix.
    #[doc(alias = "GSK_TRANSFORM_CATEGORY_IDENTITY")]
    Identity,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for TransformCategory {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "TransformCategory::{}",
            match *self {
                Self::Unknown => "Unknown",
                Self::Any => "Any",
                Self::_3d => "_3d",
                Self::_2d => "_2d",
                Self::_2dAffine => "_2dAffine",
                Self::_2dTranslate => "_2dTranslate",
                Self::Identity => "Identity",
                _ => "Unknown",
            }
        )
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GskTransformCategory {
        match self {
            Self::Unknown => ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN,
            Self::Any => ffi::GSK_TRANSFORM_CATEGORY_ANY,
            Self::_3d => ffi::GSK_TRANSFORM_CATEGORY_3D,
            Self::_2d => ffi::GSK_TRANSFORM_CATEGORY_2D,
            Self::_2dAffine => ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE,
            Self::_2dTranslate => ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE,
            Self::Identity => ffi::GSK_TRANSFORM_CATEGORY_IDENTITY,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN => Self::Unknown,
            ffi::GSK_TRANSFORM_CATEGORY_ANY => Self::Any,
            ffi::GSK_TRANSFORM_CATEGORY_3D => Self::_3d,
            ffi::GSK_TRANSFORM_CATEGORY_2D => Self::_2d,
            ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE => Self::_2dAffine,
            ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE => Self::_2dTranslate,
            ffi::GSK_TRANSFORM_CATEGORY_IDENTITY => Self::Identity,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

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

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

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

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