-- | 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(..)                              ,


-- ** FillRule #enum:FillRule#

    FillRule(..)                            ,


-- ** GLUniformType #enum:GLUniformType#

    GLUniformType(..)                       ,


-- ** LineCap #enum:LineCap#

    LineCap(..)                             ,


-- ** LineJoin #enum:LineJoin#

    LineJoin(..)                            ,


-- ** MaskMode #enum:MaskMode#

    MaskMode(..)                            ,


-- ** PathDirection #enum:PathDirection#

    PathDirection(..)                       ,


-- ** PathOperation #enum:PathOperation#

    PathOperation(..)                       ,


-- ** 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.GHashTable as B.GHT
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.Kind as DK
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
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)

#else

#endif

-- 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
$cshowsPrec :: Int -> TransformCategory -> ShowS
showsPrec :: Int -> TransformCategory -> ShowS
$cshow :: TransformCategory -> String
show :: TransformCategory -> String
$cshowList :: [TransformCategory] -> ShowS
showList :: [TransformCategory] -> ShowS
Show, TransformCategory -> TransformCategory -> Bool
(TransformCategory -> TransformCategory -> Bool)
-> (TransformCategory -> TransformCategory -> Bool)
-> Eq TransformCategory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TransformCategory -> TransformCategory -> Bool
== :: TransformCategory -> TransformCategory -> Bool
$c/= :: TransformCategory -> TransformCategory -> Bool
/= :: 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
$cshowsPrec :: Int -> SerializationError -> ShowS
showsPrec :: Int -> SerializationError -> ShowS
$cshow :: SerializationError -> String
show :: SerializationError -> String
$cshowList :: [SerializationError] -> ShowS
showList :: [SerializationError] -> ShowS
Show, SerializationError -> SerializationError -> Bool
(SerializationError -> SerializationError -> Bool)
-> (SerializationError -> SerializationError -> Bool)
-> Eq SerializationError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SerializationError -> SerializationError -> Bool
== :: SerializationError -> SerializationError -> Bool
$c/= :: SerializationError -> SerializationError -> Bool
/= :: 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
$cshowsPrec :: Int -> ScalingFilter -> ShowS
showsPrec :: Int -> ScalingFilter -> ShowS
$cshow :: ScalingFilter -> String
show :: ScalingFilter -> String
$cshowList :: [ScalingFilter] -> ShowS
showList :: [ScalingFilter] -> ShowS
Show, ScalingFilter -> ScalingFilter -> Bool
(ScalingFilter -> ScalingFilter -> Bool)
-> (ScalingFilter -> ScalingFilter -> Bool) -> Eq ScalingFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScalingFilter -> ScalingFilter -> Bool
== :: ScalingFilter -> ScalingFilter -> Bool
$c/= :: ScalingFilter -> ScalingFilter -> Bool
/= :: 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
    | RenderNodeTypeTextureScaleNode
    -- ^ A node drawing a @GdkTexture@ scaled and filtered.
    -- 
    -- /Since: 4.10/
    | RenderNodeTypeMaskNode
    -- ^ A node that masks one child with another.
    -- 
    -- /Since: 4.10/
    | RenderNodeTypeFillNode
    -- ^ A node that fills a path.
    -- 
    -- /Since: 4.14/
    | RenderNodeTypeStrokeNode
    -- ^ A node that strokes a path.
    -- 
    -- /Since: 4.14/
    | RenderNodeTypeSubsurfaceNode
    -- ^ A node that possibly redirects part of the scene graph to a subsurface.
    -- 
    -- /Since: 4.14/
    | 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
$cshowsPrec :: Int -> RenderNodeType -> ShowS
showsPrec :: Int -> RenderNodeType -> ShowS
$cshow :: RenderNodeType -> String
show :: RenderNodeType -> String
$cshowList :: [RenderNodeType] -> ShowS
showList :: [RenderNodeType] -> ShowS
Show, RenderNodeType -> RenderNodeType -> Bool
(RenderNodeType -> RenderNodeType -> Bool)
-> (RenderNodeType -> RenderNodeType -> Bool) -> Eq RenderNodeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RenderNodeType -> RenderNodeType -> Bool
== :: RenderNodeType -> RenderNodeType -> Bool
$c/= :: RenderNodeType -> RenderNodeType -> Bool
/= :: 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 RenderNodeType
RenderNodeTypeTextureScaleNode = Int
26
    fromEnum RenderNodeType
RenderNodeTypeMaskNode = Int
27
    fromEnum RenderNodeType
RenderNodeTypeFillNode = Int
28
    fromEnum RenderNodeType
RenderNodeTypeStrokeNode = Int
29
    fromEnum RenderNodeType
RenderNodeTypeSubsurfaceNode = Int
30
    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
26 = RenderNodeType
RenderNodeTypeTextureScaleNode
    toEnum Int
27 = RenderNodeType
RenderNodeTypeMaskNode
    toEnum Int
28 = RenderNodeType
RenderNodeTypeFillNode
    toEnum Int
29 = RenderNodeType
RenderNodeTypeStrokeNode
    toEnum Int
30 = RenderNodeType
RenderNodeTypeSubsurfaceNode
    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 PathOperation
-- | Describes the segments of a @GskPath@.
-- 
-- More values may be added in the future.
-- 
-- /Since: 4.14/
data PathOperation = 
      PathOperationMove
    -- ^ A move-to operation, with 1 point describing the target point.
    | PathOperationClose
    -- ^ 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.
    | PathOperationLine
    -- ^ A line-to operation, with 2 points describing the start and
    --   end point of a straight line.
    | PathOperationQuad
    -- ^ 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.
    | PathOperationCubic
    -- ^ 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.
    | PathOperationConic
    -- ^ 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.
    | AnotherPathOperation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathOperation -> ShowS
[PathOperation] -> ShowS
PathOperation -> String
(Int -> PathOperation -> ShowS)
-> (PathOperation -> String)
-> ([PathOperation] -> ShowS)
-> Show PathOperation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PathOperation -> ShowS
showsPrec :: Int -> PathOperation -> ShowS
$cshow :: PathOperation -> String
show :: PathOperation -> String
$cshowList :: [PathOperation] -> ShowS
showList :: [PathOperation] -> ShowS
Show, PathOperation -> PathOperation -> Bool
(PathOperation -> PathOperation -> Bool)
-> (PathOperation -> PathOperation -> Bool) -> Eq PathOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PathOperation -> PathOperation -> Bool
== :: PathOperation -> PathOperation -> Bool
$c/= :: PathOperation -> PathOperation -> Bool
/= :: PathOperation -> PathOperation -> Bool
Eq)

instance P.Enum PathOperation where
    fromEnum :: PathOperation -> Int
fromEnum PathOperation
PathOperationMove = Int
0
    fromEnum PathOperation
PathOperationClose = Int
1
    fromEnum PathOperation
PathOperationLine = Int
2
    fromEnum PathOperation
PathOperationQuad = Int
3
    fromEnum PathOperation
PathOperationCubic = Int
4
    fromEnum PathOperation
PathOperationConic = Int
5
    fromEnum (AnotherPathOperation Int
k) = Int
k

    toEnum :: Int -> PathOperation
toEnum Int
0 = PathOperation
PathOperationMove
    toEnum Int
1 = PathOperation
PathOperationClose
    toEnum Int
2 = PathOperation
PathOperationLine
    toEnum Int
3 = PathOperation
PathOperationQuad
    toEnum Int
4 = PathOperation
PathOperationCubic
    toEnum Int
5 = PathOperation
PathOperationConic
    toEnum Int
k = Int -> PathOperation
AnotherPathOperation Int
k

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

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

foreign import ccall "gsk_path_operation_get_type" c_gsk_path_operation_get_type :: 
    IO GType

instance B.Types.TypedObject PathOperation where
    glibType :: IO GType
glibType = IO GType
c_gsk_path_operation_get_type

instance B.Types.BoxedEnum PathOperation

-- Enum PathDirection
-- | Used to pick one of the four tangents at a given point on the path.
-- 
-- Note that the directions for /@gSKPATHFROMSTART@/\//@gSKPATHTOEND@/ and
-- /@gSKPATHTOSTART@/\//@gSKPATHFROMEND@/ 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>
-- 
-- /Since: 4.14/
data PathDirection = 
      PathDirectionFromStart
    -- ^ The tangent in path direction of the incoming side
    --   of the path
    | PathDirectionToStart
    -- ^ The tangent against path direction of the incoming side
    --   of the path
    | PathDirectionToEnd
    -- ^ The tangent in path direction of the outgoing side
    --   of the path
    | PathDirectionFromEnd
    -- ^ The tangent against path direction of the outgoing
    --   side of the path
    | AnotherPathDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathDirection -> ShowS
[PathDirection] -> ShowS
PathDirection -> String
(Int -> PathDirection -> ShowS)
-> (PathDirection -> String)
-> ([PathDirection] -> ShowS)
-> Show PathDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PathDirection -> ShowS
showsPrec :: Int -> PathDirection -> ShowS
$cshow :: PathDirection -> String
show :: PathDirection -> String
$cshowList :: [PathDirection] -> ShowS
showList :: [PathDirection] -> ShowS
Show, PathDirection -> PathDirection -> Bool
(PathDirection -> PathDirection -> Bool)
-> (PathDirection -> PathDirection -> Bool) -> Eq PathDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PathDirection -> PathDirection -> Bool
== :: PathDirection -> PathDirection -> Bool
$c/= :: PathDirection -> PathDirection -> Bool
/= :: PathDirection -> PathDirection -> Bool
Eq)

instance P.Enum PathDirection where
    fromEnum :: PathDirection -> Int
fromEnum PathDirection
PathDirectionFromStart = Int
0
    fromEnum PathDirection
PathDirectionToStart = Int
1
    fromEnum PathDirection
PathDirectionToEnd = Int
2
    fromEnum PathDirection
PathDirectionFromEnd = Int
3
    fromEnum (AnotherPathDirection Int
k) = Int
k

    toEnum :: Int -> PathDirection
toEnum Int
0 = PathDirection
PathDirectionFromStart
    toEnum Int
1 = PathDirection
PathDirectionToStart
    toEnum Int
2 = PathDirection
PathDirectionToEnd
    toEnum Int
3 = PathDirection
PathDirectionFromEnd
    toEnum Int
k = Int -> PathDirection
AnotherPathDirection Int
k

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

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

foreign import ccall "gsk_path_direction_get_type" c_gsk_path_direction_get_type :: 
    IO GType

instance B.Types.TypedObject PathDirection where
    glibType :: IO GType
glibType = IO GType
c_gsk_path_direction_get_type

instance B.Types.BoxedEnum PathDirection

-- Enum MaskMode
-- | The mask modes available for mask nodes.
-- 
-- /Since: 4.10/
data MaskMode = 
      MaskModeAlpha
    -- ^ Use the alpha channel of the mask
    | MaskModeInvertedAlpha
    -- ^ Use the inverted alpha channel of the mask
    | MaskModeLuminance
    -- ^ Use the luminance of the mask,
    --     multiplied by mask alpha
    | MaskModeInvertedLuminance
    -- ^ Use the inverted luminance of the mask,
    --     multiplied by mask alpha
    | AnotherMaskMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MaskMode -> ShowS
[MaskMode] -> ShowS
MaskMode -> String
(Int -> MaskMode -> ShowS)
-> (MaskMode -> String) -> ([MaskMode] -> ShowS) -> Show MaskMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaskMode -> ShowS
showsPrec :: Int -> MaskMode -> ShowS
$cshow :: MaskMode -> String
show :: MaskMode -> String
$cshowList :: [MaskMode] -> ShowS
showList :: [MaskMode] -> ShowS
Show, MaskMode -> MaskMode -> Bool
(MaskMode -> MaskMode -> Bool)
-> (MaskMode -> MaskMode -> Bool) -> Eq MaskMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaskMode -> MaskMode -> Bool
== :: MaskMode -> MaskMode -> Bool
$c/= :: MaskMode -> MaskMode -> Bool
/= :: MaskMode -> MaskMode -> Bool
Eq)

instance P.Enum MaskMode where
    fromEnum :: MaskMode -> Int
fromEnum MaskMode
MaskModeAlpha = Int
0
    fromEnum MaskMode
MaskModeInvertedAlpha = Int
1
    fromEnum MaskMode
MaskModeLuminance = Int
2
    fromEnum MaskMode
MaskModeInvertedLuminance = Int
3
    fromEnum (AnotherMaskMode Int
k) = Int
k

    toEnum :: Int -> MaskMode
toEnum Int
0 = MaskMode
MaskModeAlpha
    toEnum Int
1 = MaskMode
MaskModeInvertedAlpha
    toEnum Int
2 = MaskMode
MaskModeLuminance
    toEnum Int
3 = MaskMode
MaskModeInvertedLuminance
    toEnum Int
k = Int -> MaskMode
AnotherMaskMode Int
k

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

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

foreign import ccall "gsk_mask_mode_get_type" c_gsk_mask_mode_get_type :: 
    IO GType

instance B.Types.TypedObject MaskMode where
    glibType :: IO GType
glibType = IO GType
c_gsk_mask_mode_get_type

instance B.Types.BoxedEnum MaskMode

-- Enum LineJoin
-- | 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>
-- 
-- /Since: 4.14/
data LineJoin = 
      LineJoinMiter
    -- ^ Use a sharp angled corner
    | LineJoinRound
    -- ^ Use a round join, the center of the circle is
    --   the join point
    | LineJoinBevel
    -- ^ use a cut-off join, the join is cut off at half
    --   the line width from the joint point
    | AnotherLineJoin Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LineJoin -> ShowS
[LineJoin] -> ShowS
LineJoin -> String
(Int -> LineJoin -> ShowS)
-> (LineJoin -> String) -> ([LineJoin] -> ShowS) -> Show LineJoin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LineJoin -> ShowS
showsPrec :: Int -> LineJoin -> ShowS
$cshow :: LineJoin -> String
show :: LineJoin -> String
$cshowList :: [LineJoin] -> ShowS
showList :: [LineJoin] -> ShowS
Show, LineJoin -> LineJoin -> Bool
(LineJoin -> LineJoin -> Bool)
-> (LineJoin -> LineJoin -> Bool) -> Eq LineJoin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LineJoin -> LineJoin -> Bool
== :: LineJoin -> LineJoin -> Bool
$c/= :: LineJoin -> LineJoin -> Bool
/= :: LineJoin -> LineJoin -> Bool
Eq)

instance P.Enum LineJoin where
    fromEnum :: LineJoin -> Int
fromEnum LineJoin
LineJoinMiter = Int
0
    fromEnum LineJoin
LineJoinRound = Int
1
    fromEnum LineJoin
LineJoinBevel = Int
2
    fromEnum (AnotherLineJoin Int
k) = Int
k

    toEnum :: Int -> LineJoin
toEnum Int
0 = LineJoin
LineJoinMiter
    toEnum Int
1 = LineJoin
LineJoinRound
    toEnum Int
2 = LineJoin
LineJoinBevel
    toEnum Int
k = Int -> LineJoin
AnotherLineJoin Int
k

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

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

foreign import ccall "gsk_line_join_get_type" c_gsk_line_join_get_type :: 
    IO GType

instance B.Types.TypedObject LineJoin where
    glibType :: IO GType
glibType = IO GType
c_gsk_line_join_get_type

instance B.Types.BoxedEnum LineJoin

-- Enum LineCap
-- | 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>
-- 
-- /Since: 4.14/
data LineCap = 
      LineCapButt
    -- ^ Start and stop the line exactly at the start
    --   and end point
    | LineCapRound
    -- ^ Use a round ending, the center of the circle
    --   is the start or end point
    | LineCapSquare
    -- ^ use squared ending, the center of the square
    --   is the start or end point
    | AnotherLineCap Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LineCap -> ShowS
[LineCap] -> ShowS
LineCap -> String
(Int -> LineCap -> ShowS)
-> (LineCap -> String) -> ([LineCap] -> ShowS) -> Show LineCap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LineCap -> ShowS
showsPrec :: Int -> LineCap -> ShowS
$cshow :: LineCap -> String
show :: LineCap -> String
$cshowList :: [LineCap] -> ShowS
showList :: [LineCap] -> ShowS
Show, LineCap -> LineCap -> Bool
(LineCap -> LineCap -> Bool)
-> (LineCap -> LineCap -> Bool) -> Eq LineCap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LineCap -> LineCap -> Bool
== :: LineCap -> LineCap -> Bool
$c/= :: LineCap -> LineCap -> Bool
/= :: LineCap -> LineCap -> Bool
Eq)

instance P.Enum LineCap where
    fromEnum :: LineCap -> Int
fromEnum LineCap
LineCapButt = Int
0
    fromEnum LineCap
LineCapRound = Int
1
    fromEnum LineCap
LineCapSquare = Int
2
    fromEnum (AnotherLineCap Int
k) = Int
k

    toEnum :: Int -> LineCap
toEnum Int
0 = LineCap
LineCapButt
    toEnum Int
1 = LineCap
LineCapRound
    toEnum Int
2 = LineCap
LineCapSquare
    toEnum Int
k = Int -> LineCap
AnotherLineCap Int
k

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

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

foreign import ccall "gsk_line_cap_get_type" c_gsk_line_cap_get_type :: 
    IO GType

instance B.Types.TypedObject LineCap where
    glibType :: IO GType
glibType = IO GType
c_gsk_line_cap_get_type

instance B.Types.BoxedEnum LineCap

-- Enum GLUniformType
{-# DEPRECATED GLUniformType ["(Since version 4.16)"] #-}
-- | 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
$cshowsPrec :: Int -> GLUniformType -> ShowS
showsPrec :: Int -> GLUniformType -> ShowS
$cshow :: GLUniformType -> String
show :: GLUniformType -> String
$cshowList :: [GLUniformType] -> ShowS
showList :: [GLUniformType] -> ShowS
Show, GLUniformType -> GLUniformType -> Bool
(GLUniformType -> GLUniformType -> Bool)
-> (GLUniformType -> GLUniformType -> Bool) -> Eq GLUniformType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GLUniformType -> GLUniformType -> Bool
== :: GLUniformType -> GLUniformType -> Bool
$c/= :: GLUniformType -> GLUniformType -> Bool
/= :: 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 FillRule
-- | Specifies 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.
-- 
-- /Since: 4.14/
data FillRule = 
      FillRuleWinding
    -- ^ 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.
    | FillRuleEvenOdd
    -- ^ 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.
    | AnotherFillRule Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FillRule -> ShowS
[FillRule] -> ShowS
FillRule -> String
(Int -> FillRule -> ShowS)
-> (FillRule -> String) -> ([FillRule] -> ShowS) -> Show FillRule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FillRule -> ShowS
showsPrec :: Int -> FillRule -> ShowS
$cshow :: FillRule -> String
show :: FillRule -> String
$cshowList :: [FillRule] -> ShowS
showList :: [FillRule] -> ShowS
Show, FillRule -> FillRule -> Bool
(FillRule -> FillRule -> Bool)
-> (FillRule -> FillRule -> Bool) -> Eq FillRule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FillRule -> FillRule -> Bool
== :: FillRule -> FillRule -> Bool
$c/= :: FillRule -> FillRule -> Bool
/= :: FillRule -> FillRule -> Bool
Eq)

instance P.Enum FillRule where
    fromEnum :: FillRule -> Int
fromEnum FillRule
FillRuleWinding = Int
0
    fromEnum FillRule
FillRuleEvenOdd = Int
1
    fromEnum (AnotherFillRule Int
k) = Int
k

    toEnum :: Int -> FillRule
toEnum Int
0 = FillRule
FillRuleWinding
    toEnum Int
1 = FillRule
FillRuleEvenOdd
    toEnum Int
k = Int -> FillRule
AnotherFillRule Int
k

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

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

foreign import ccall "gsk_fill_rule_get_type" c_gsk_fill_rule_get_type :: 
    IO GType

instance B.Types.TypedObject FillRule where
    glibType :: IO GType
glibType = IO GType
c_gsk_fill_rule_get_type

instance B.Types.BoxedEnum FillRule

-- 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
$cshowsPrec :: Int -> Corner -> ShowS
showsPrec :: Int -> Corner -> ShowS
$cshow :: Corner -> String
show :: Corner -> String
$cshowList :: [Corner] -> ShowS
showList :: [Corner] -> ShowS
Show, Corner -> Corner -> Bool
(Corner -> Corner -> Bool)
-> (Corner -> Corner -> Bool) -> Eq Corner
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Corner -> Corner -> Bool
== :: Corner -> Corner -> Bool
$c/= :: Corner -> Corner -> Bool
/= :: 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
$cshowsPrec :: Int -> BlendMode -> ShowS
showsPrec :: Int -> BlendMode -> ShowS
$cshow :: BlendMode -> String
show :: BlendMode -> String
$cshowList :: [BlendMode] -> ShowS
showList :: [BlendMode] -> ShowS
Show, BlendMode -> BlendMode -> Bool
(BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool) -> Eq BlendMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlendMode -> BlendMode -> Bool
== :: BlendMode -> BlendMode -> Bool
$c/= :: BlendMode -> BlendMode -> Bool
/= :: 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