-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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(..)                              ,


-- ** 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.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.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


-- 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
-- mutliplication 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 :: 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 :: (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 t'GI.Cairo.Structs.Surface.Surface'
    | RenderNodeTypeColorNode
    -- ^ A node drawing a single color rectangle
    | RenderNodeTypeLinearGradientNode
    -- ^ A node drawing a linear gradient
    | RenderNodeTypeRepeatingLinearGradientNode
    -- ^ A node drawing a repeating linear gradient
    | RenderNodeTypeBorderNode
    -- ^ A node stroking a border around an area
    | RenderNodeTypeTextureNode
    -- ^ A node drawing a t'GI.Gdk.Objects.Texture.Texture'
    | 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
    | 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
RenderNodeTypeBorderNode = Int
6
    fromEnum RenderNodeType
RenderNodeTypeTextureNode = Int
7
    fromEnum RenderNodeType
RenderNodeTypeInsetShadowNode = Int
8
    fromEnum RenderNodeType
RenderNodeTypeOutsetShadowNode = Int
9
    fromEnum RenderNodeType
RenderNodeTypeTransformNode = Int
10
    fromEnum RenderNodeType
RenderNodeTypeOpacityNode = Int
11
    fromEnum RenderNodeType
RenderNodeTypeColorMatrixNode = Int
12
    fromEnum RenderNodeType
RenderNodeTypeRepeatNode = Int
13
    fromEnum RenderNodeType
RenderNodeTypeClipNode = Int
14
    fromEnum RenderNodeType
RenderNodeTypeRoundedClipNode = Int
15
    fromEnum RenderNodeType
RenderNodeTypeShadowNode = Int
16
    fromEnum RenderNodeType
RenderNodeTypeBlendNode = Int
17
    fromEnum RenderNodeType
RenderNodeTypeCrossFadeNode = Int
18
    fromEnum RenderNodeType
RenderNodeTypeTextNode = Int
19
    fromEnum RenderNodeType
RenderNodeTypeBlurNode = Int
20
    fromEnum RenderNodeType
RenderNodeTypeDebugNode = Int
21
    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
RenderNodeTypeBorderNode
    toEnum Int
7 = RenderNodeType
RenderNodeTypeTextureNode
    toEnum Int
8 = RenderNodeType
RenderNodeTypeInsetShadowNode
    toEnum Int
9 = RenderNodeType
RenderNodeTypeOutsetShadowNode
    toEnum Int
10 = RenderNodeType
RenderNodeTypeTransformNode
    toEnum Int
11 = RenderNodeType
RenderNodeTypeOpacityNode
    toEnum Int
12 = RenderNodeType
RenderNodeTypeColorMatrixNode
    toEnum Int
13 = RenderNodeType
RenderNodeTypeRepeatNode
    toEnum Int
14 = RenderNodeType
RenderNodeTypeClipNode
    toEnum Int
15 = RenderNodeType
RenderNodeTypeRoundedClipNode
    toEnum Int
16 = RenderNodeType
RenderNodeTypeShadowNode
    toEnum Int
17 = RenderNodeType
RenderNodeTypeBlendNode
    toEnum Int
18 = RenderNodeType
RenderNodeTypeCrossFadeNode
    toEnum Int
19 = RenderNodeType
RenderNodeTypeTextNode
    toEnum Int
20 = RenderNodeType
RenderNodeTypeBlurNode
    toEnum Int
21 = RenderNodeType
RenderNodeTypeDebugNode
    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 Corner
-- | The corner indices used by t'GI.Gsk.Structs.RoundedRect.RoundedRect'.
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.
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
    -- ^ ...
    | BlendModeOverlay
    -- ^ ...
    | BlendModeDarken
    -- ^ ...
    | BlendModeLighten
    -- ^ ...
    | BlendModeColorDodge
    -- ^ ...
    | BlendModeColorBurn
    -- ^ ...
    | BlendModeHardLight
    -- ^ ...
    | BlendModeSoftLight
    -- ^ ...
    | BlendModeDifference
    -- ^ ...
    | BlendModeExclusion
    -- ^ ...
    | BlendModeColor
    -- ^ ...
    | BlendModeHue
    -- ^ ...
    | BlendModeSaturation
    -- ^ ...
    | BlendModeLuminosity
    -- ^ ...
    | 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