-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gsk.Enums
    ( 

 -- * Enumerations


-- ** BlendMode #enum:BlendMode#

    BlendMode(..)                           ,


-- ** Corner #enum:Corner#

    Corner(..)                              ,


-- ** GLUniformType #enum:GLUniformType#

    GLUniformType(..)                       ,


-- ** RenderNodeType #enum:RenderNodeType#

    RenderNodeType(..)                      ,


-- ** ScalingFilter #enum:ScalingFilter#

    ScalingFilter(..)                       ,


-- ** SerializationError #enum:SerializationError#

    SerializationError(..)                  ,
    catchSerializationError                 ,
    handleSerializationError                ,


-- ** TransformCategory #enum:TransformCategory#

    TransformCategory(..)                   ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum TransformCategory
-- | 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))@.
data TransformCategory = 
      TransformCategoryUnknown
    -- ^ The category of the matrix has not been
    --   determined.
    | TransformCategoryAny
    -- ^ Analyzing the matrix concluded that it does
    --   not fit in any other category.
    | TransformCategory3d
    -- ^ The matrix is a 3D matrix. This means that
    --   the w column (the last column) has the values (0, 0, 0, 1).
    | TransformCategory2d
    -- ^ The matrix is a 2D matrix. This is equivalent
    --   to 'GI.Graphene.Structs.Matrix.matrixIs2d' returning 'P.True'. In particular, this
    --   means that Cairo can deal with the matrix.
    | TransformCategory2dAffine
    -- ^ 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.
    | TransformCategory2dTranslate
    -- ^ The matrix is a 2D translation.
    | TransformCategoryIdentity
    -- ^ The matrix is the identity matrix.
    | AnotherTransformCategory Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TransformCategory -> ShowS
[TransformCategory] -> ShowS
TransformCategory -> String
(Int -> TransformCategory -> ShowS)
-> (TransformCategory -> String)
-> ([TransformCategory] -> ShowS)
-> Show TransformCategory
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TransformCategory] -> ShowS
$cshowList :: [TransformCategory] -> ShowS
show :: TransformCategory -> String
$cshow :: TransformCategory -> String
showsPrec :: Int -> TransformCategory -> ShowS
$cshowsPrec :: Int -> TransformCategory -> ShowS
Show, TransformCategory -> TransformCategory -> Bool
(TransformCategory -> TransformCategory -> Bool)
-> (TransformCategory -> TransformCategory -> Bool)
-> Eq TransformCategory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TransformCategory -> TransformCategory -> Bool
$c/= :: TransformCategory -> TransformCategory -> Bool
== :: TransformCategory -> TransformCategory -> Bool
$c== :: TransformCategory -> TransformCategory -> Bool
Eq)

instance P.Enum TransformCategory where
    fromEnum :: TransformCategory -> Int
fromEnum TransformCategory
TransformCategoryUnknown = Int
0
    fromEnum TransformCategory
TransformCategoryAny = Int
1
    fromEnum TransformCategory
TransformCategory3d = Int
2
    fromEnum TransformCategory
TransformCategory2d = Int
3
    fromEnum TransformCategory
TransformCategory2dAffine = Int
4
    fromEnum TransformCategory
TransformCategory2dTranslate = Int
5
    fromEnum TransformCategory
TransformCategoryIdentity = Int
6
    fromEnum (AnotherTransformCategory Int
k) = Int
k

    toEnum :: Int -> TransformCategory
toEnum Int
0 = TransformCategory
TransformCategoryUnknown
    toEnum Int
1 = TransformCategory
TransformCategoryAny
    toEnum Int
2 = TransformCategory
TransformCategory3d
    toEnum Int
3 = TransformCategory
TransformCategory2d
    toEnum Int
4 = TransformCategory
TransformCategory2dAffine
    toEnum Int
5 = TransformCategory
TransformCategory2dTranslate
    toEnum Int
6 = TransformCategory
TransformCategoryIdentity
    toEnum Int
k = Int -> TransformCategory
AnotherTransformCategory Int
k

instance P.Ord TransformCategory where
    compare :: TransformCategory -> TransformCategory -> Ordering
compare TransformCategory
a TransformCategory
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TransformCategory -> Int
forall a. Enum a => a -> Int
P.fromEnum TransformCategory
a) (TransformCategory -> Int
forall a. Enum a => a -> Int
P.fromEnum TransformCategory
b)

type instance O.ParentTypes TransformCategory = '[]
instance O.HasParentTypes TransformCategory

foreign import ccall "gsk_transform_category_get_type" c_gsk_transform_category_get_type :: 
    IO GType

instance B.Types.TypedObject TransformCategory where
    glibType :: IO GType
glibType = IO GType
c_gsk_transform_category_get_type

instance B.Types.BoxedEnum TransformCategory

-- Enum SerializationError
-- | Errors that can happen during (de)serialization.
data SerializationError = 
      SerializationErrorUnsupportedFormat
    -- ^ The format can not be identified
    | SerializationErrorUnsupportedVersion
    -- ^ The version of the data is not
    --   understood
    | SerializationErrorInvalidData
    -- ^ The given data may not exist in
    --   a proper serialization
    | AnotherSerializationError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SerializationError -> ShowS
[SerializationError] -> ShowS
SerializationError -> String
(Int -> SerializationError -> ShowS)
-> (SerializationError -> String)
-> ([SerializationError] -> ShowS)
-> Show SerializationError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SerializationError] -> ShowS
$cshowList :: [SerializationError] -> ShowS
show :: SerializationError -> String
$cshow :: SerializationError -> String
showsPrec :: Int -> SerializationError -> ShowS
$cshowsPrec :: Int -> SerializationError -> ShowS
Show, SerializationError -> SerializationError -> Bool
(SerializationError -> SerializationError -> Bool)
-> (SerializationError -> SerializationError -> Bool)
-> Eq SerializationError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SerializationError -> SerializationError -> Bool
$c/= :: SerializationError -> SerializationError -> Bool
== :: SerializationError -> SerializationError -> Bool
$c== :: SerializationError -> SerializationError -> Bool
Eq)

instance P.Enum SerializationError where
    fromEnum :: SerializationError -> Int
fromEnum SerializationError
SerializationErrorUnsupportedFormat = Int
0
    fromEnum SerializationError
SerializationErrorUnsupportedVersion = Int
1
    fromEnum SerializationError
SerializationErrorInvalidData = Int
2
    fromEnum (AnotherSerializationError Int
k) = Int
k

    toEnum :: Int -> SerializationError
toEnum Int
0 = SerializationError
SerializationErrorUnsupportedFormat
    toEnum Int
1 = SerializationError
SerializationErrorUnsupportedVersion
    toEnum Int
2 = SerializationError
SerializationErrorInvalidData
    toEnum Int
k = Int -> SerializationError
AnotherSerializationError Int
k

instance P.Ord SerializationError where
    compare :: SerializationError -> SerializationError -> Ordering
compare SerializationError
a SerializationError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SerializationError -> Int
forall a. Enum a => a -> Int
P.fromEnum SerializationError
a) (SerializationError -> Int
forall a. Enum a => a -> Int
P.fromEnum SerializationError
b)

instance GErrorClass SerializationError where
    gerrorClassDomain :: SerializationError -> Text
gerrorClassDomain SerializationError
_ = Text
"gsk-serialization-error-quark"

-- | Catch exceptions of type `SerializationError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchSerializationError ::
    IO a ->
    (SerializationError -> GErrorMessage -> IO a) ->
    IO a
catchSerializationError :: forall a. IO a -> (SerializationError -> Text -> IO a) -> IO a
catchSerializationError = IO a -> (SerializationError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `SerializationError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleSerializationError ::
    (SerializationError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleSerializationError :: forall a. (SerializationError -> Text -> IO a) -> IO a -> IO a
handleSerializationError = (SerializationError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes SerializationError = '[]
instance O.HasParentTypes SerializationError

foreign import ccall "gsk_serialization_error_get_type" c_gsk_serialization_error_get_type :: 
    IO GType

instance B.Types.TypedObject SerializationError where
    glibType :: IO GType
glibType = IO GType
c_gsk_serialization_error_get_type

instance B.Types.BoxedEnum SerializationError

-- Enum ScalingFilter
-- | The filters used when scaling texture data.
-- 
-- The actual implementation of each filter is deferred to the
-- rendering pipeline.
data ScalingFilter = 
      ScalingFilterLinear
    -- ^ linear interpolation filter
    | ScalingFilterNearest
    -- ^ nearest neighbor interpolation filter
    | ScalingFilterTrilinear
    -- ^ linear interpolation along each axis,
    --   plus mipmap generation, with linear interpolation along the mipmap
    --   levels
    | AnotherScalingFilter Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScalingFilter -> ShowS
[ScalingFilter] -> ShowS
ScalingFilter -> String
(Int -> ScalingFilter -> ShowS)
-> (ScalingFilter -> String)
-> ([ScalingFilter] -> ShowS)
-> Show ScalingFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScalingFilter] -> ShowS
$cshowList :: [ScalingFilter] -> ShowS
show :: ScalingFilter -> String
$cshow :: ScalingFilter -> String
showsPrec :: Int -> ScalingFilter -> ShowS
$cshowsPrec :: Int -> ScalingFilter -> ShowS
Show, ScalingFilter -> ScalingFilter -> Bool
(ScalingFilter -> ScalingFilter -> Bool)
-> (ScalingFilter -> ScalingFilter -> Bool) -> Eq ScalingFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScalingFilter -> ScalingFilter -> Bool
$c/= :: ScalingFilter -> ScalingFilter -> Bool
== :: ScalingFilter -> ScalingFilter -> Bool
$c== :: ScalingFilter -> ScalingFilter -> Bool
Eq)

instance P.Enum ScalingFilter where
    fromEnum :: ScalingFilter -> Int
fromEnum ScalingFilter
ScalingFilterLinear = Int
0
    fromEnum ScalingFilter
ScalingFilterNearest = Int
1
    fromEnum ScalingFilter
ScalingFilterTrilinear = Int
2
    fromEnum (AnotherScalingFilter Int
k) = Int
k

    toEnum :: Int -> ScalingFilter
toEnum Int
0 = ScalingFilter
ScalingFilterLinear
    toEnum Int
1 = ScalingFilter
ScalingFilterNearest
    toEnum Int
2 = ScalingFilter
ScalingFilterTrilinear
    toEnum Int
k = Int -> ScalingFilter
AnotherScalingFilter Int
k

instance P.Ord ScalingFilter where
    compare :: ScalingFilter -> ScalingFilter -> Ordering
compare ScalingFilter
a ScalingFilter
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScalingFilter -> Int
forall a. Enum a => a -> Int
P.fromEnum ScalingFilter
a) (ScalingFilter -> Int
forall a. Enum a => a -> Int
P.fromEnum ScalingFilter
b)

type instance O.ParentTypes ScalingFilter = '[]
instance O.HasParentTypes ScalingFilter

foreign import ccall "gsk_scaling_filter_get_type" c_gsk_scaling_filter_get_type :: 
    IO GType

instance B.Types.TypedObject ScalingFilter where
    glibType :: IO GType
glibType = IO GType
c_gsk_scaling_filter_get_type

instance B.Types.BoxedEnum ScalingFilter

-- Enum RenderNodeType
-- | The type of a node determines what the node is rendering.
data RenderNodeType = 
      RenderNodeTypeNotARenderNode
    -- ^ Error type. No node will ever have this type.
    | RenderNodeTypeContainerNode
    -- ^ A node containing a stack of children
    | RenderNodeTypeCairoNode
    -- ^ A node drawing a @cairo_surface_t@
    | RenderNodeTypeColorNode
    -- ^ A node drawing a single color rectangle
    | RenderNodeTypeLinearGradientNode
    -- ^ A node drawing a linear gradient
    | RenderNodeTypeRepeatingLinearGradientNode
    -- ^ A node drawing a repeating linear gradient
    | RenderNodeTypeRadialGradientNode
    -- ^ A node drawing a radial gradient
    | RenderNodeTypeRepeatingRadialGradientNode
    -- ^ A node drawing a repeating radial gradient
    | RenderNodeTypeConicGradientNode
    -- ^ A node drawing a conic gradient
    | RenderNodeTypeBorderNode
    -- ^ A node stroking a border around an area
    | RenderNodeTypeTextureNode
    -- ^ A node drawing a @GdkTexture@
    | RenderNodeTypeInsetShadowNode
    -- ^ A node drawing an inset shadow
    | RenderNodeTypeOutsetShadowNode
    -- ^ A node drawing an outset shadow
    | RenderNodeTypeTransformNode
    -- ^ A node that renders its child after applying a matrix transform
    | RenderNodeTypeOpacityNode
    -- ^ A node that changes the opacity of its child
    | RenderNodeTypeColorMatrixNode
    -- ^ A node that applies a color matrix to every pixel
    | RenderNodeTypeRepeatNode
    -- ^ A node that repeats the child\'s contents
    | RenderNodeTypeClipNode
    -- ^ A node that clips its child to a rectangular area
    | RenderNodeTypeRoundedClipNode
    -- ^ A node that clips its child to a rounded rectangle
    | RenderNodeTypeShadowNode
    -- ^ A node that draws a shadow below its child
    | RenderNodeTypeBlendNode
    -- ^ A node that blends two children together
    | RenderNodeTypeCrossFadeNode
    -- ^ A node that cross-fades between two children
    | RenderNodeTypeTextNode
    -- ^ A node containing a glyph string
    | RenderNodeTypeBlurNode
    -- ^ A node that applies a blur
    | RenderNodeTypeDebugNode
    -- ^ Debug information that does not affect the rendering
    | RenderNodeTypeGlShaderNode
    -- ^ A node that uses OpenGL fragment shaders to render
    | AnotherRenderNodeType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RenderNodeType -> ShowS
[RenderNodeType] -> ShowS
RenderNodeType -> String
(Int -> RenderNodeType -> ShowS)
-> (RenderNodeType -> String)
-> ([RenderNodeType] -> ShowS)
-> Show RenderNodeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RenderNodeType] -> ShowS
$cshowList :: [RenderNodeType] -> ShowS
show :: RenderNodeType -> String
$cshow :: RenderNodeType -> String
showsPrec :: Int -> RenderNodeType -> ShowS
$cshowsPrec :: Int -> RenderNodeType -> ShowS
Show, RenderNodeType -> RenderNodeType -> Bool
(RenderNodeType -> RenderNodeType -> Bool)
-> (RenderNodeType -> RenderNodeType -> Bool) -> Eq RenderNodeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RenderNodeType -> RenderNodeType -> Bool
$c/= :: RenderNodeType -> RenderNodeType -> Bool
== :: RenderNodeType -> RenderNodeType -> Bool
$c== :: RenderNodeType -> RenderNodeType -> Bool
Eq)

instance P.Enum RenderNodeType where
    fromEnum :: RenderNodeType -> Int
fromEnum RenderNodeType
RenderNodeTypeNotARenderNode = Int
0
    fromEnum RenderNodeType
RenderNodeTypeContainerNode = Int
1
    fromEnum RenderNodeType
RenderNodeTypeCairoNode = Int
2
    fromEnum RenderNodeType
RenderNodeTypeColorNode = Int
3
    fromEnum RenderNodeType
RenderNodeTypeLinearGradientNode = Int
4
    fromEnum RenderNodeType
RenderNodeTypeRepeatingLinearGradientNode = Int
5
    fromEnum RenderNodeType
RenderNodeTypeRadialGradientNode = Int
6
    fromEnum RenderNodeType
RenderNodeTypeRepeatingRadialGradientNode = Int
7
    fromEnum RenderNodeType
RenderNodeTypeConicGradientNode = Int
8
    fromEnum RenderNodeType
RenderNodeTypeBorderNode = Int
9
    fromEnum RenderNodeType
RenderNodeTypeTextureNode = Int
10
    fromEnum RenderNodeType
RenderNodeTypeInsetShadowNode = Int
11
    fromEnum RenderNodeType
RenderNodeTypeOutsetShadowNode = Int
12
    fromEnum RenderNodeType
RenderNodeTypeTransformNode = Int
13
    fromEnum RenderNodeType
RenderNodeTypeOpacityNode = Int
14
    fromEnum RenderNodeType
RenderNodeTypeColorMatrixNode = Int
15
    fromEnum RenderNodeType
RenderNodeTypeRepeatNode = Int
16
    fromEnum RenderNodeType
RenderNodeTypeClipNode = Int
17
    fromEnum RenderNodeType
RenderNodeTypeRoundedClipNode = Int
18
    fromEnum RenderNodeType
RenderNodeTypeShadowNode = Int
19
    fromEnum RenderNodeType
RenderNodeTypeBlendNode = Int
20
    fromEnum RenderNodeType
RenderNodeTypeCrossFadeNode = Int
21
    fromEnum RenderNodeType
RenderNodeTypeTextNode = Int
22
    fromEnum RenderNodeType
RenderNodeTypeBlurNode = Int
23
    fromEnum RenderNodeType
RenderNodeTypeDebugNode = Int
24
    fromEnum RenderNodeType
RenderNodeTypeGlShaderNode = Int
25
    fromEnum (AnotherRenderNodeType Int
k) = Int
k

    toEnum :: Int -> RenderNodeType
toEnum Int
0 = RenderNodeType
RenderNodeTypeNotARenderNode
    toEnum Int
1 = RenderNodeType
RenderNodeTypeContainerNode
    toEnum Int
2 = RenderNodeType
RenderNodeTypeCairoNode
    toEnum Int
3 = RenderNodeType
RenderNodeTypeColorNode
    toEnum Int
4 = RenderNodeType
RenderNodeTypeLinearGradientNode
    toEnum Int
5 = RenderNodeType
RenderNodeTypeRepeatingLinearGradientNode
    toEnum Int
6 = RenderNodeType
RenderNodeTypeRadialGradientNode
    toEnum Int
7 = RenderNodeType
RenderNodeTypeRepeatingRadialGradientNode
    toEnum Int
8 = RenderNodeType
RenderNodeTypeConicGradientNode
    toEnum Int
9 = RenderNodeType
RenderNodeTypeBorderNode
    toEnum Int
10 = RenderNodeType
RenderNodeTypeTextureNode
    toEnum Int
11 = RenderNodeType
RenderNodeTypeInsetShadowNode
    toEnum Int
12 = RenderNodeType
RenderNodeTypeOutsetShadowNode
    toEnum Int
13 = RenderNodeType
RenderNodeTypeTransformNode
    toEnum Int
14 = RenderNodeType
RenderNodeTypeOpacityNode
    toEnum Int
15 = RenderNodeType
RenderNodeTypeColorMatrixNode
    toEnum Int
16 = RenderNodeType
RenderNodeTypeRepeatNode
    toEnum Int
17 = RenderNodeType
RenderNodeTypeClipNode
    toEnum Int
18 = RenderNodeType
RenderNodeTypeRoundedClipNode
    toEnum Int
19 = RenderNodeType
RenderNodeTypeShadowNode
    toEnum Int
20 = RenderNodeType
RenderNodeTypeBlendNode
    toEnum Int
21 = RenderNodeType
RenderNodeTypeCrossFadeNode
    toEnum Int
22 = RenderNodeType
RenderNodeTypeTextNode
    toEnum Int
23 = RenderNodeType
RenderNodeTypeBlurNode
    toEnum Int
24 = RenderNodeType
RenderNodeTypeDebugNode
    toEnum Int
25 = RenderNodeType
RenderNodeTypeGlShaderNode
    toEnum Int
k = Int -> RenderNodeType
AnotherRenderNodeType Int
k

instance P.Ord RenderNodeType where
    compare :: RenderNodeType -> RenderNodeType -> Ordering
compare RenderNodeType
a RenderNodeType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RenderNodeType -> Int
forall a. Enum a => a -> Int
P.fromEnum RenderNodeType
a) (RenderNodeType -> Int
forall a. Enum a => a -> Int
P.fromEnum RenderNodeType
b)

type instance O.ParentTypes RenderNodeType = '[]
instance O.HasParentTypes RenderNodeType

foreign import ccall "gsk_render_node_type_get_type" c_gsk_render_node_type_get_type :: 
    IO GType

instance B.Types.TypedObject RenderNodeType where
    glibType :: IO GType
glibType = IO GType
c_gsk_render_node_type_get_type

instance B.Types.BoxedEnum RenderNodeType

-- Enum GLUniformType
-- | 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.
data GLUniformType = 
      GLUniformTypeNone
    -- ^ No type, used for uninitialized or unspecified values.
    | GLUniformTypeFloat
    -- ^ A float uniform
    | GLUniformTypeInt
    -- ^ A GLSL int \/ gint32 uniform
    | GLUniformTypeUint
    -- ^ A GLSL uint \/ guint32 uniform
    | GLUniformTypeBool
    -- ^ A GLSL bool \/ gboolean uniform
    | GLUniformTypeVec2
    -- ^ A GLSL vec2 \/ graphene_vec2_t uniform
    | GLUniformTypeVec3
    -- ^ A GLSL vec3 \/ graphene_vec3_t uniform
    | GLUniformTypeVec4
    -- ^ A GLSL vec4 \/ graphene_vec4_t uniform
    | AnotherGLUniformType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GLUniformType -> ShowS
[GLUniformType] -> ShowS
GLUniformType -> String
(Int -> GLUniformType -> ShowS)
-> (GLUniformType -> String)
-> ([GLUniformType] -> ShowS)
-> Show GLUniformType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GLUniformType] -> ShowS
$cshowList :: [GLUniformType] -> ShowS
show :: GLUniformType -> String
$cshow :: GLUniformType -> String
showsPrec :: Int -> GLUniformType -> ShowS
$cshowsPrec :: Int -> GLUniformType -> ShowS
Show, GLUniformType -> GLUniformType -> Bool
(GLUniformType -> GLUniformType -> Bool)
-> (GLUniformType -> GLUniformType -> Bool) -> Eq GLUniformType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GLUniformType -> GLUniformType -> Bool
$c/= :: GLUniformType -> GLUniformType -> Bool
== :: GLUniformType -> GLUniformType -> Bool
$c== :: GLUniformType -> GLUniformType -> Bool
Eq)

instance P.Enum GLUniformType where
    fromEnum :: GLUniformType -> Int
fromEnum GLUniformType
GLUniformTypeNone = Int
0
    fromEnum GLUniformType
GLUniformTypeFloat = Int
1
    fromEnum GLUniformType
GLUniformTypeInt = Int
2
    fromEnum GLUniformType
GLUniformTypeUint = Int
3
    fromEnum GLUniformType
GLUniformTypeBool = Int
4
    fromEnum GLUniformType
GLUniformTypeVec2 = Int
5
    fromEnum GLUniformType
GLUniformTypeVec3 = Int
6
    fromEnum GLUniformType
GLUniformTypeVec4 = Int
7
    fromEnum (AnotherGLUniformType Int
k) = Int
k

    toEnum :: Int -> GLUniformType
toEnum Int
0 = GLUniformType
GLUniformTypeNone
    toEnum Int
1 = GLUniformType
GLUniformTypeFloat
    toEnum Int
2 = GLUniformType
GLUniformTypeInt
    toEnum Int
3 = GLUniformType
GLUniformTypeUint
    toEnum Int
4 = GLUniformType
GLUniformTypeBool
    toEnum Int
5 = GLUniformType
GLUniformTypeVec2
    toEnum Int
6 = GLUniformType
GLUniformTypeVec3
    toEnum Int
7 = GLUniformType
GLUniformTypeVec4
    toEnum Int
k = Int -> GLUniformType
AnotherGLUniformType Int
k

instance P.Ord GLUniformType where
    compare :: GLUniformType -> GLUniformType -> Ordering
compare GLUniformType
a GLUniformType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GLUniformType -> Int
forall a. Enum a => a -> Int
P.fromEnum GLUniformType
a) (GLUniformType -> Int
forall a. Enum a => a -> Int
P.fromEnum GLUniformType
b)

type instance O.ParentTypes GLUniformType = '[]
instance O.HasParentTypes GLUniformType

foreign import ccall "gsk_gl_uniform_type_get_type" c_gsk_gl_uniform_type_get_type :: 
    IO GType

instance B.Types.TypedObject GLUniformType where
    glibType :: IO GType
glibType = IO GType
c_gsk_gl_uniform_type_get_type

instance B.Types.BoxedEnum GLUniformType

-- Enum Corner
-- | The corner indices used by @GskRoundedRect@.
data Corner = 
      CornerTopLeft
    -- ^ The top left corner
    | CornerTopRight
    -- ^ The top right corner
    | CornerBottomRight
    -- ^ The bottom right corner
    | CornerBottomLeft
    -- ^ The bottom left corner
    | AnotherCorner Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Corner -> ShowS
[Corner] -> ShowS
Corner -> String
(Int -> Corner -> ShowS)
-> (Corner -> String) -> ([Corner] -> ShowS) -> Show Corner
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Corner] -> ShowS
$cshowList :: [Corner] -> ShowS
show :: Corner -> String
$cshow :: Corner -> String
showsPrec :: Int -> Corner -> ShowS
$cshowsPrec :: Int -> Corner -> ShowS
Show, Corner -> Corner -> Bool
(Corner -> Corner -> Bool)
-> (Corner -> Corner -> Bool) -> Eq Corner
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Corner -> Corner -> Bool
$c/= :: Corner -> Corner -> Bool
== :: Corner -> Corner -> Bool
$c== :: Corner -> Corner -> Bool
Eq)

instance P.Enum Corner where
    fromEnum :: Corner -> Int
fromEnum Corner
CornerTopLeft = Int
0
    fromEnum Corner
CornerTopRight = Int
1
    fromEnum Corner
CornerBottomRight = Int
2
    fromEnum Corner
CornerBottomLeft = Int
3
    fromEnum (AnotherCorner Int
k) = Int
k

    toEnum :: Int -> Corner
toEnum Int
0 = Corner
CornerTopLeft
    toEnum Int
1 = Corner
CornerTopRight
    toEnum Int
2 = Corner
CornerBottomRight
    toEnum Int
3 = Corner
CornerBottomLeft
    toEnum Int
k = Int -> Corner
AnotherCorner Int
k

instance P.Ord Corner where
    compare :: Corner -> Corner -> Ordering
compare Corner
a Corner
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Corner -> Int
forall a. Enum a => a -> Int
P.fromEnum Corner
a) (Corner -> Int
forall a. Enum a => a -> Int
P.fromEnum Corner
b)

type instance O.ParentTypes Corner = '[]
instance O.HasParentTypes Corner

foreign import ccall "gsk_corner_get_type" c_gsk_corner_get_type :: 
    IO GType

instance B.Types.TypedObject Corner where
    glibType :: IO GType
glibType = IO GType
c_gsk_corner_get_type

instance B.Types.BoxedEnum Corner

-- Enum BlendMode
-- | 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.
data BlendMode = 
      BlendModeDefault
    -- ^ The default blend mode, which specifies no blending
    | BlendModeMultiply
    -- ^ The source color is multiplied by the destination
    --   and replaces the destination
    | BlendModeScreen
    -- ^ Multiplies the complements of the destination and source
    --   color values, then complements the result.
    | BlendModeOverlay
    -- ^ Multiplies or screens the colors, depending on the
    --   destination color value. This is the inverse of hard-list
    | BlendModeDarken
    -- ^ Selects the darker of the destination and source colors
    | BlendModeLighten
    -- ^ Selects the lighter of the destination and source colors
    | BlendModeColorDodge
    -- ^ Brightens the destination color to reflect the source color
    | BlendModeColorBurn
    -- ^ Darkens the destination color to reflect the source color
    | BlendModeHardLight
    -- ^ Multiplies or screens the colors, depending on the source color value
    | BlendModeSoftLight
    -- ^ Darkens or lightens the colors, depending on the source color value
    | BlendModeDifference
    -- ^ Subtracts the darker of the two constituent colors from the lighter color
    | BlendModeExclusion
    -- ^ Produces an effect similar to that of the difference mode but lower in contrast
    | BlendModeColor
    -- ^ Creates a color with the hue and saturation of the source color and the luminosity of the destination color
    | BlendModeHue
    -- ^ Creates a color with the hue of the source color and the saturation and luminosity of the destination color
    | BlendModeSaturation
    -- ^ Creates a color with the saturation of the source color and the hue and luminosity of the destination color
    | BlendModeLuminosity
    -- ^ Creates a color with the luminosity of the source color and the hue and saturation of the destination color
    | AnotherBlendMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BlendMode -> ShowS
[BlendMode] -> ShowS
BlendMode -> String
(Int -> BlendMode -> ShowS)
-> (BlendMode -> String)
-> ([BlendMode] -> ShowS)
-> Show BlendMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlendMode] -> ShowS
$cshowList :: [BlendMode] -> ShowS
show :: BlendMode -> String
$cshow :: BlendMode -> String
showsPrec :: Int -> BlendMode -> ShowS
$cshowsPrec :: Int -> BlendMode -> ShowS
Show, BlendMode -> BlendMode -> Bool
(BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool) -> Eq BlendMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlendMode -> BlendMode -> Bool
$c/= :: BlendMode -> BlendMode -> Bool
== :: BlendMode -> BlendMode -> Bool
$c== :: BlendMode -> BlendMode -> Bool
Eq)

instance P.Enum BlendMode where
    fromEnum :: BlendMode -> Int
fromEnum BlendMode
BlendModeDefault = Int
0
    fromEnum BlendMode
BlendModeMultiply = Int
1
    fromEnum BlendMode
BlendModeScreen = Int
2
    fromEnum BlendMode
BlendModeOverlay = Int
3
    fromEnum BlendMode
BlendModeDarken = Int
4
    fromEnum BlendMode
BlendModeLighten = Int
5
    fromEnum BlendMode
BlendModeColorDodge = Int
6
    fromEnum BlendMode
BlendModeColorBurn = Int
7
    fromEnum BlendMode
BlendModeHardLight = Int
8
    fromEnum BlendMode
BlendModeSoftLight = Int
9
    fromEnum BlendMode
BlendModeDifference = Int
10
    fromEnum BlendMode
BlendModeExclusion = Int
11
    fromEnum BlendMode
BlendModeColor = Int
12
    fromEnum BlendMode
BlendModeHue = Int
13
    fromEnum BlendMode
BlendModeSaturation = Int
14
    fromEnum BlendMode
BlendModeLuminosity = Int
15
    fromEnum (AnotherBlendMode Int
k) = Int
k

    toEnum :: Int -> BlendMode
toEnum Int
0 = BlendMode
BlendModeDefault
    toEnum Int
1 = BlendMode
BlendModeMultiply
    toEnum Int
2 = BlendMode
BlendModeScreen
    toEnum Int
3 = BlendMode
BlendModeOverlay
    toEnum Int
4 = BlendMode
BlendModeDarken
    toEnum Int
5 = BlendMode
BlendModeLighten
    toEnum Int
6 = BlendMode
BlendModeColorDodge
    toEnum Int
7 = BlendMode
BlendModeColorBurn
    toEnum Int
8 = BlendMode
BlendModeHardLight
    toEnum Int
9 = BlendMode
BlendModeSoftLight
    toEnum Int
10 = BlendMode
BlendModeDifference
    toEnum Int
11 = BlendMode
BlendModeExclusion
    toEnum Int
12 = BlendMode
BlendModeColor
    toEnum Int
13 = BlendMode
BlendModeHue
    toEnum Int
14 = BlendMode
BlendModeSaturation
    toEnum Int
15 = BlendMode
BlendModeLuminosity
    toEnum Int
k = Int -> BlendMode
AnotherBlendMode Int
k

instance P.Ord BlendMode where
    compare :: BlendMode -> BlendMode -> Ordering
compare BlendMode
a BlendMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BlendMode -> Int
forall a. Enum a => a -> Int
P.fromEnum BlendMode
a) (BlendMode -> Int
forall a. Enum a => a -> Int
P.fromEnum BlendMode
b)

type instance O.ParentTypes BlendMode = '[]
instance O.HasParentTypes BlendMode

foreign import ccall "gsk_blend_mode_get_type" c_gsk_blend_mode_get_type :: 
    IO GType

instance B.Types.TypedObject BlendMode where
    glibType :: IO GType
glibType = IO GType
c_gsk_blend_mode_get_type

instance B.Types.BoxedEnum BlendMode