-- | 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.Clutter.Enums
    ( 

 -- * Enumerations


-- ** ActorAlign #enum:ActorAlign#

    ActorAlign(..)                          ,


-- ** AlignAxis #enum:AlignAxis#

    AlignAxis(..)                           ,


-- ** AnimationMode #enum:AnimationMode#

    AnimationMode(..)                       ,


-- ** BinAlignment #enum:BinAlignment#

    BinAlignment(..)                        ,


-- ** BindCoordinate #enum:BindCoordinate#

    BindCoordinate(..)                      ,


-- ** BoxAlignment #enum:BoxAlignment#

    BoxAlignment(..)                        ,


-- ** ContentGravity #enum:ContentGravity#

    ContentGravity(..)                      ,


-- ** DragAxis #enum:DragAxis#

    DragAxis(..)                            ,


-- ** EventType #enum:EventType#

    EventType(..)                           ,


-- ** FlowOrientation #enum:FlowOrientation#

    FlowOrientation(..)                     ,


-- ** GestureTriggerEdge #enum:GestureTriggerEdge#

    GestureTriggerEdge(..)                  ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** GridPosition #enum:GridPosition#

    GridPosition(..)                        ,


-- ** ImageError #enum:ImageError#

    ImageError(..)                          ,
    catchImageError                         ,
    handleImageError                        ,


-- ** InitError #enum:InitError#

    InitError(..)                           ,
    catchInitError                          ,
    handleInitError                         ,


-- ** InputAxis #enum:InputAxis#

    InputAxis(..)                           ,


-- ** InputDeviceType #enum:InputDeviceType#

    InputDeviceType(..)                     ,


-- ** InputMode #enum:InputMode#

    InputMode(..)                           ,


-- ** Interpolation #enum:Interpolation#

    Interpolation(..)                       ,


-- ** LongPressState #enum:LongPressState#

    LongPressState(..)                      ,


-- ** Orientation #enum:Orientation#

    Orientation(..)                         ,


-- ** PanAxis #enum:PanAxis#

    PanAxis(..)                             ,


-- ** PathNodeType #enum:PathNodeType#

    PathNodeType(..)                        ,


-- ** PickMode #enum:PickMode#

    PickMode(..)                            ,


-- ** RequestMode #enum:RequestMode#

    RequestMode(..)                         ,


-- ** RotateAxis #enum:RotateAxis#

    RotateAxis(..)                          ,


-- ** RotateDirection #enum:RotateDirection#

    RotateDirection(..)                     ,


-- ** ScalingFilter #enum:ScalingFilter#

    ScalingFilter(..)                       ,


-- ** ScriptError #enum:ScriptError#

    ScriptError(..)                         ,
    catchScriptError                        ,
    handleScriptError                       ,


-- ** ScrollDirection #enum:ScrollDirection#

    ScrollDirection(..)                     ,


-- ** ScrollSource #enum:ScrollSource#

    ScrollSource(..)                        ,


-- ** ShaderError #enum:ShaderError#

    ShaderError(..)                         ,
    catchShaderError                        ,
    handleShaderError                       ,


-- ** ShaderType #enum:ShaderType#

    ShaderType(..)                          ,


-- ** SnapEdge #enum:SnapEdge#

    SnapEdge(..)                            ,


-- ** StaticColor #enum:StaticColor#

    StaticColor(..)                         ,


-- ** StepMode #enum:StepMode#

    StepMode(..)                            ,


-- ** TableAlignment #enum:TableAlignment#

    TableAlignment(..)                      ,


-- ** TextDirection #enum:TextDirection#

    TextDirection(..)                       ,


-- ** TextureError #enum:TextureError#

    TextureError(..)                        ,
    catchTextureError                       ,
    handleTextureError                      ,


-- ** TextureQuality #enum:TextureQuality#

    TextureQuality(..)                      ,


-- ** TimelineDirection #enum:TimelineDirection#

    TimelineDirection(..)                   ,


-- ** TouchpadGesturePhase #enum:TouchpadGesturePhase#

    TouchpadGesturePhase(..)                ,


-- ** UnitType #enum:UnitType#

    UnitType(..)                            ,


-- ** ZoomAxis #enum:ZoomAxis#

    ZoomAxis(..)                            ,




    ) 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.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 ZoomAxis
-- | The axis of the constraint that should be applied by the
-- zooming action.
-- 
-- /Since: 1.12/
data ZoomAxis = 
      ZoomAxisXAxis
    -- ^ Scale only on the X axis
    | ZoomAxisYAxis
    -- ^ Scale only on the Y axis
    | ZoomAxisBoth
    -- ^ Scale on both axis
    | AnotherZoomAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ZoomAxis -> ShowS
[ZoomAxis] -> ShowS
ZoomAxis -> String
(Int -> ZoomAxis -> ShowS)
-> (ZoomAxis -> String) -> ([ZoomAxis] -> ShowS) -> Show ZoomAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ZoomAxis -> ShowS
showsPrec :: Int -> ZoomAxis -> ShowS
$cshow :: ZoomAxis -> String
show :: ZoomAxis -> String
$cshowList :: [ZoomAxis] -> ShowS
showList :: [ZoomAxis] -> ShowS
Show, ZoomAxis -> ZoomAxis -> Bool
(ZoomAxis -> ZoomAxis -> Bool)
-> (ZoomAxis -> ZoomAxis -> Bool) -> Eq ZoomAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ZoomAxis -> ZoomAxis -> Bool
== :: ZoomAxis -> ZoomAxis -> Bool
$c/= :: ZoomAxis -> ZoomAxis -> Bool
/= :: ZoomAxis -> ZoomAxis -> Bool
Eq)

instance P.Enum ZoomAxis where
    fromEnum :: ZoomAxis -> Int
fromEnum ZoomAxis
ZoomAxisXAxis = Int
0
    fromEnum ZoomAxis
ZoomAxisYAxis = Int
1
    fromEnum ZoomAxis
ZoomAxisBoth = Int
2
    fromEnum (AnotherZoomAxis Int
k) = Int
k

    toEnum :: Int -> ZoomAxis
toEnum Int
0 = ZoomAxis
ZoomAxisXAxis
    toEnum Int
1 = ZoomAxis
ZoomAxisYAxis
    toEnum Int
2 = ZoomAxis
ZoomAxisBoth
    toEnum Int
k = Int -> ZoomAxis
AnotherZoomAxis Int
k

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

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

foreign import ccall "clutter_zoom_axis_get_type" c_clutter_zoom_axis_get_type :: 
    IO GType

instance B.Types.TypedObject ZoomAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_zoom_axis_get_type

instance B.Types.BoxedEnum ZoomAxis

-- Enum UnitType
-- | The type of unit in which a value is expressed
-- 
-- This enumeration might be expanded at later date
-- 
-- /Since: 1.0/
data UnitType = 
      UnitTypePixel
    -- ^ Unit expressed in pixels (with subpixel precision)
    | UnitTypeEm
    -- ^ Unit expressed in em
    | UnitTypeMm
    -- ^ Unit expressed in millimeters
    | UnitTypePoint
    -- ^ Unit expressed in points
    | UnitTypeCm
    -- ^ Unit expressed in centimeters
    | AnotherUnitType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UnitType -> ShowS
[UnitType] -> ShowS
UnitType -> String
(Int -> UnitType -> ShowS)
-> (UnitType -> String) -> ([UnitType] -> ShowS) -> Show UnitType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnitType -> ShowS
showsPrec :: Int -> UnitType -> ShowS
$cshow :: UnitType -> String
show :: UnitType -> String
$cshowList :: [UnitType] -> ShowS
showList :: [UnitType] -> ShowS
Show, UnitType -> UnitType -> Bool
(UnitType -> UnitType -> Bool)
-> (UnitType -> UnitType -> Bool) -> Eq UnitType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnitType -> UnitType -> Bool
== :: UnitType -> UnitType -> Bool
$c/= :: UnitType -> UnitType -> Bool
/= :: UnitType -> UnitType -> Bool
Eq)

instance P.Enum UnitType where
    fromEnum :: UnitType -> Int
fromEnum UnitType
UnitTypePixel = Int
0
    fromEnum UnitType
UnitTypeEm = Int
1
    fromEnum UnitType
UnitTypeMm = Int
2
    fromEnum UnitType
UnitTypePoint = Int
3
    fromEnum UnitType
UnitTypeCm = Int
4
    fromEnum (AnotherUnitType Int
k) = Int
k

    toEnum :: Int -> UnitType
toEnum Int
0 = UnitType
UnitTypePixel
    toEnum Int
1 = UnitType
UnitTypeEm
    toEnum Int
2 = UnitType
UnitTypeMm
    toEnum Int
3 = UnitType
UnitTypePoint
    toEnum Int
4 = UnitType
UnitTypeCm
    toEnum Int
k = Int -> UnitType
AnotherUnitType Int
k

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

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

foreign import ccall "clutter_unit_type_get_type" c_clutter_unit_type_get_type :: 
    IO GType

instance B.Types.TypedObject UnitType where
    glibType :: IO GType
glibType = IO GType
c_clutter_unit_type_get_type

instance B.Types.BoxedEnum UnitType

-- Enum TouchpadGesturePhase
-- | The phase of a touchpad gesture event. All gestures are guaranteed to
-- begin with an event of type 'GI.Clutter.Enums.TouchpadGesturePhaseBegin',
-- followed by a number of 'GI.Clutter.Enums.TouchpadGesturePhaseUpdate' (possibly 0).
-- 
-- A finished gesture may have 2 possible outcomes, an event with phase
-- 'GI.Clutter.Enums.TouchpadGesturePhaseEnd' will be emitted when the gesture is
-- considered successful, this should be used as the hint to perform any
-- permanent changes.
-- 
-- Cancelled gestures may be so for a variety of reasons, due to hardware,
-- or due to the gesture recognition layers hinting the gesture did not
-- finish resolutely (eg. a 3rd finger being added during a pinch gesture).
-- In these cases, the last event with report the phase
-- 'GI.Clutter.Enums.TouchpadGesturePhaseCancel', this should be used as a hint
-- to undo any visible\/permanent changes that were done throughout the
-- progress of the gesture.
-- 
-- See also t'GI.Clutter.Structs.TouchpadPinchEvent.TouchpadPinchEvent' and t'GI.Clutter.Structs.TouchpadPinchEvent.TouchpadPinchEvent'.
-- 
-- /Since: 1.24/
data TouchpadGesturePhase = 
      TouchpadGesturePhaseBegin
    -- ^ The gesture has begun.
    | TouchpadGesturePhaseUpdate
    -- ^ The gesture has been updated.
    | TouchpadGesturePhaseEnd
    -- ^ The gesture was finished, changes
    --   should be permanently applied.
    | TouchpadGesturePhaseCancel
    -- ^ The gesture was cancelled, all
    --   changes should be undone.
    | AnotherTouchpadGesturePhase Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TouchpadGesturePhase -> ShowS
[TouchpadGesturePhase] -> ShowS
TouchpadGesturePhase -> String
(Int -> TouchpadGesturePhase -> ShowS)
-> (TouchpadGesturePhase -> String)
-> ([TouchpadGesturePhase] -> ShowS)
-> Show TouchpadGesturePhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TouchpadGesturePhase -> ShowS
showsPrec :: Int -> TouchpadGesturePhase -> ShowS
$cshow :: TouchpadGesturePhase -> String
show :: TouchpadGesturePhase -> String
$cshowList :: [TouchpadGesturePhase] -> ShowS
showList :: [TouchpadGesturePhase] -> ShowS
Show, TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
(TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> Eq TouchpadGesturePhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
$c/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
Eq)

instance P.Enum TouchpadGesturePhase where
    fromEnum :: TouchpadGesturePhase -> Int
fromEnum TouchpadGesturePhase
TouchpadGesturePhaseBegin = Int
0
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseUpdate = Int
1
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseEnd = Int
2
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseCancel = Int
3
    fromEnum (AnotherTouchpadGesturePhase Int
k) = Int
k

    toEnum :: Int -> TouchpadGesturePhase
toEnum Int
0 = TouchpadGesturePhase
TouchpadGesturePhaseBegin
    toEnum Int
1 = TouchpadGesturePhase
TouchpadGesturePhaseUpdate
    toEnum Int
2 = TouchpadGesturePhase
TouchpadGesturePhaseEnd
    toEnum Int
3 = TouchpadGesturePhase
TouchpadGesturePhaseCancel
    toEnum Int
k = Int -> TouchpadGesturePhase
AnotherTouchpadGesturePhase Int
k

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

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

foreign import ccall "clutter_touchpad_gesture_phase_get_type" c_clutter_touchpad_gesture_phase_get_type :: 
    IO GType

instance B.Types.TypedObject TouchpadGesturePhase where
    glibType :: IO GType
glibType = IO GType
c_clutter_touchpad_gesture_phase_get_type

instance B.Types.BoxedEnum TouchpadGesturePhase

-- Enum TimelineDirection
-- | The direction of a t'GI.Clutter.Objects.Timeline.Timeline'
-- 
-- /Since: 0.6/
data TimelineDirection = 
      TimelineDirectionForward
    -- ^ forward direction for a timeline
    | TimelineDirectionBackward
    -- ^ backward direction for a timeline
    | AnotherTimelineDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TimelineDirection -> ShowS
[TimelineDirection] -> ShowS
TimelineDirection -> String
(Int -> TimelineDirection -> ShowS)
-> (TimelineDirection -> String)
-> ([TimelineDirection] -> ShowS)
-> Show TimelineDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TimelineDirection -> ShowS
showsPrec :: Int -> TimelineDirection -> ShowS
$cshow :: TimelineDirection -> String
show :: TimelineDirection -> String
$cshowList :: [TimelineDirection] -> ShowS
showList :: [TimelineDirection] -> ShowS
Show, TimelineDirection -> TimelineDirection -> Bool
(TimelineDirection -> TimelineDirection -> Bool)
-> (TimelineDirection -> TimelineDirection -> Bool)
-> Eq TimelineDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimelineDirection -> TimelineDirection -> Bool
== :: TimelineDirection -> TimelineDirection -> Bool
$c/= :: TimelineDirection -> TimelineDirection -> Bool
/= :: TimelineDirection -> TimelineDirection -> Bool
Eq)

instance P.Enum TimelineDirection where
    fromEnum :: TimelineDirection -> Int
fromEnum TimelineDirection
TimelineDirectionForward = Int
0
    fromEnum TimelineDirection
TimelineDirectionBackward = Int
1
    fromEnum (AnotherTimelineDirection Int
k) = Int
k

    toEnum :: Int -> TimelineDirection
toEnum Int
0 = TimelineDirection
TimelineDirectionForward
    toEnum Int
1 = TimelineDirection
TimelineDirectionBackward
    toEnum Int
k = Int -> TimelineDirection
AnotherTimelineDirection Int
k

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

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

foreign import ccall "clutter_timeline_direction_get_type" c_clutter_timeline_direction_get_type :: 
    IO GType

instance B.Types.TypedObject TimelineDirection where
    glibType :: IO GType
glibType = IO GType
c_clutter_timeline_direction_get_type

instance B.Types.BoxedEnum TimelineDirection

-- Enum TextureQuality
{-# DEPRECATED TextureQuality ["(Since version 1.22)","The t'GI.Clutter.Objects.Texture.Texture' class was the only used ot","  this API; use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorSetContentScalingFilters'","  instead."] #-}
-- | Enumaration controlling the texture quality.
-- 
-- /Since: 0.8/
data TextureQuality = 
      TextureQualityLow
    -- ^ fastest rendering will use nearest neighbour
    --   interpolation when rendering. good setting.
    | TextureQualityMedium
    -- ^ higher quality rendering without using
    --   extra resources.
    | TextureQualityHigh
    -- ^ render the texture with the best quality
    --   available using extra memory.
    | AnotherTextureQuality Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureQuality -> ShowS
[TextureQuality] -> ShowS
TextureQuality -> String
(Int -> TextureQuality -> ShowS)
-> (TextureQuality -> String)
-> ([TextureQuality] -> ShowS)
-> Show TextureQuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureQuality -> ShowS
showsPrec :: Int -> TextureQuality -> ShowS
$cshow :: TextureQuality -> String
show :: TextureQuality -> String
$cshowList :: [TextureQuality] -> ShowS
showList :: [TextureQuality] -> ShowS
Show, TextureQuality -> TextureQuality -> Bool
(TextureQuality -> TextureQuality -> Bool)
-> (TextureQuality -> TextureQuality -> Bool) -> Eq TextureQuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureQuality -> TextureQuality -> Bool
== :: TextureQuality -> TextureQuality -> Bool
$c/= :: TextureQuality -> TextureQuality -> Bool
/= :: TextureQuality -> TextureQuality -> Bool
Eq)

instance P.Enum TextureQuality where
    fromEnum :: TextureQuality -> Int
fromEnum TextureQuality
TextureQualityLow = Int
0
    fromEnum TextureQuality
TextureQualityMedium = Int
1
    fromEnum TextureQuality
TextureQualityHigh = Int
2
    fromEnum (AnotherTextureQuality Int
k) = Int
k

    toEnum :: Int -> TextureQuality
toEnum Int
0 = TextureQuality
TextureQualityLow
    toEnum Int
1 = TextureQuality
TextureQualityMedium
    toEnum Int
2 = TextureQuality
TextureQualityHigh
    toEnum Int
k = Int -> TextureQuality
AnotherTextureQuality Int
k

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

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

foreign import ccall "clutter_texture_quality_get_type" c_clutter_texture_quality_get_type :: 
    IO GType

instance B.Types.TypedObject TextureQuality where
    glibType :: IO GType
glibType = IO GType
c_clutter_texture_quality_get_type

instance B.Types.BoxedEnum TextureQuality

-- Enum TextureError
-- | Error enumeration for t'GI.Clutter.Objects.Texture.Texture'
-- 
-- /Since: 0.4/
data TextureError = 
      TextureErrorOutOfMemory
    -- ^ OOM condition
    | TextureErrorNoYuv
    -- ^ YUV operation attempted but no YUV support
    --   found
    | TextureErrorBadFormat
    -- ^ The requested format for
    -- clutter_texture_set_from_rgb_data or
    -- clutter_texture_set_from_yuv_data is unsupported.
    | AnotherTextureError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureError -> ShowS
[TextureError] -> ShowS
TextureError -> String
(Int -> TextureError -> ShowS)
-> (TextureError -> String)
-> ([TextureError] -> ShowS)
-> Show TextureError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureError -> ShowS
showsPrec :: Int -> TextureError -> ShowS
$cshow :: TextureError -> String
show :: TextureError -> String
$cshowList :: [TextureError] -> ShowS
showList :: [TextureError] -> ShowS
Show, TextureError -> TextureError -> Bool
(TextureError -> TextureError -> Bool)
-> (TextureError -> TextureError -> Bool) -> Eq TextureError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureError -> TextureError -> Bool
== :: TextureError -> TextureError -> Bool
$c/= :: TextureError -> TextureError -> Bool
/= :: TextureError -> TextureError -> Bool
Eq)

instance P.Enum TextureError where
    fromEnum :: TextureError -> Int
fromEnum TextureError
TextureErrorOutOfMemory = Int
0
    fromEnum TextureError
TextureErrorNoYuv = Int
1
    fromEnum TextureError
TextureErrorBadFormat = Int
2
    fromEnum (AnotherTextureError Int
k) = Int
k

    toEnum :: Int -> TextureError
toEnum Int
0 = TextureError
TextureErrorOutOfMemory
    toEnum Int
1 = TextureError
TextureErrorNoYuv
    toEnum Int
2 = TextureError
TextureErrorBadFormat
    toEnum Int
k = Int -> TextureError
AnotherTextureError Int
k

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

instance GErrorClass TextureError where
    gerrorClassDomain :: TextureError -> Text
gerrorClassDomain TextureError
_ = Text
"clutter-texture-error-quark"

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

-- | Handle exceptions of type `TextureError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleTextureError ::
    (TextureError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleTextureError :: forall a. (TextureError -> Text -> IO a) -> IO a -> IO a
handleTextureError = (TextureError -> 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 TextureError = '[]
instance O.HasParentTypes TextureError

foreign import ccall "clutter_texture_error_get_type" c_clutter_texture_error_get_type :: 
    IO GType

instance B.Types.TypedObject TextureError where
    glibType :: IO GType
glibType = IO GType
c_clutter_texture_error_get_type

instance B.Types.BoxedEnum TextureError

-- Enum TextDirection
-- | The text direction to be used by t'GI.Clutter.Objects.Actor.Actor's
-- 
-- /Since: 1.2/
data TextDirection = 
      TextDirectionDefault
    -- ^ Use the default setting, as returned
    --   by 'GI.Clutter.Functions.getDefaultTextDirection'
    | TextDirectionLtr
    -- ^ Use left-to-right text direction
    | TextDirectionRtl
    -- ^ Use right-to-left text direction
    | AnotherTextDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextDirection -> ShowS
[TextDirection] -> ShowS
TextDirection -> String
(Int -> TextDirection -> ShowS)
-> (TextDirection -> String)
-> ([TextDirection] -> ShowS)
-> Show TextDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextDirection -> ShowS
showsPrec :: Int -> TextDirection -> ShowS
$cshow :: TextDirection -> String
show :: TextDirection -> String
$cshowList :: [TextDirection] -> ShowS
showList :: [TextDirection] -> ShowS
Show, TextDirection -> TextDirection -> Bool
(TextDirection -> TextDirection -> Bool)
-> (TextDirection -> TextDirection -> Bool) -> Eq TextDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextDirection -> TextDirection -> Bool
== :: TextDirection -> TextDirection -> Bool
$c/= :: TextDirection -> TextDirection -> Bool
/= :: TextDirection -> TextDirection -> Bool
Eq)

instance P.Enum TextDirection where
    fromEnum :: TextDirection -> Int
fromEnum TextDirection
TextDirectionDefault = Int
0
    fromEnum TextDirection
TextDirectionLtr = Int
1
    fromEnum TextDirection
TextDirectionRtl = Int
2
    fromEnum (AnotherTextDirection Int
k) = Int
k

    toEnum :: Int -> TextDirection
toEnum Int
0 = TextDirection
TextDirectionDefault
    toEnum Int
1 = TextDirection
TextDirectionLtr
    toEnum Int
2 = TextDirection
TextDirectionRtl
    toEnum Int
k = Int -> TextDirection
AnotherTextDirection Int
k

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

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

foreign import ccall "clutter_text_direction_get_type" c_clutter_text_direction_get_type :: 
    IO GType

instance B.Types.TypedObject TextDirection where
    glibType :: IO GType
glibType = IO GType
c_clutter_text_direction_get_type

instance B.Types.BoxedEnum TextDirection

-- Enum TableAlignment
{-# DEPRECATED TableAlignment ["(Since version 1.22)","Use the alignment properties of t'GI.Clutter.Objects.Actor.Actor'"] #-}
-- | The alignment policies available on each axis of the t'GI.Clutter.Objects.TableLayout.TableLayout'
-- 
-- /Since: 1.4/
data TableAlignment = 
      TableAlignmentStart
    -- ^ Align the child to the top or to the
    --   left of a cell in the table, depending on the axis
    | TableAlignmentCenter
    -- ^ Align the child to the center of
    --   a cell in the table
    | TableAlignmentEnd
    -- ^ Align the child to the bottom or to the
    --   right of a cell in the table, depending on the axis
    | AnotherTableAlignment Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TableAlignment -> ShowS
[TableAlignment] -> ShowS
TableAlignment -> String
(Int -> TableAlignment -> ShowS)
-> (TableAlignment -> String)
-> ([TableAlignment] -> ShowS)
-> Show TableAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableAlignment -> ShowS
showsPrec :: Int -> TableAlignment -> ShowS
$cshow :: TableAlignment -> String
show :: TableAlignment -> String
$cshowList :: [TableAlignment] -> ShowS
showList :: [TableAlignment] -> ShowS
Show, TableAlignment -> TableAlignment -> Bool
(TableAlignment -> TableAlignment -> Bool)
-> (TableAlignment -> TableAlignment -> Bool) -> Eq TableAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableAlignment -> TableAlignment -> Bool
== :: TableAlignment -> TableAlignment -> Bool
$c/= :: TableAlignment -> TableAlignment -> Bool
/= :: TableAlignment -> TableAlignment -> Bool
Eq)

instance P.Enum TableAlignment where
    fromEnum :: TableAlignment -> Int
fromEnum TableAlignment
TableAlignmentStart = Int
0
    fromEnum TableAlignment
TableAlignmentCenter = Int
1
    fromEnum TableAlignment
TableAlignmentEnd = Int
2
    fromEnum (AnotherTableAlignment Int
k) = Int
k

    toEnum :: Int -> TableAlignment
toEnum Int
0 = TableAlignment
TableAlignmentStart
    toEnum Int
1 = TableAlignment
TableAlignmentCenter
    toEnum Int
2 = TableAlignment
TableAlignmentEnd
    toEnum Int
k = Int -> TableAlignment
AnotherTableAlignment Int
k

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

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

foreign import ccall "clutter_table_alignment_get_type" c_clutter_table_alignment_get_type :: 
    IO GType

instance B.Types.TypedObject TableAlignment where
    glibType :: IO GType
glibType = IO GType
c_clutter_table_alignment_get_type

instance B.Types.BoxedEnum TableAlignment

-- Enum StepMode
-- | Change the value transition of a step function.
-- 
-- See 'GI.Clutter.Objects.Timeline.timelineSetStepProgress'.
-- 
-- /Since: 1.12/
data StepMode = 
      StepModeStart
    -- ^ The change in the value of a
    --   @/CLUTTER_STEP/@ progress mode should occur at the start of
    --   the transition
    | StepModeEnd
    -- ^ The change in the value of a
    --   @/CLUTTER_STEP/@ progress mode should occur at the end of
    --   the transition
    | AnotherStepMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StepMode -> ShowS
[StepMode] -> ShowS
StepMode -> String
(Int -> StepMode -> ShowS)
-> (StepMode -> String) -> ([StepMode] -> ShowS) -> Show StepMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StepMode -> ShowS
showsPrec :: Int -> StepMode -> ShowS
$cshow :: StepMode -> String
show :: StepMode -> String
$cshowList :: [StepMode] -> ShowS
showList :: [StepMode] -> ShowS
Show, StepMode -> StepMode -> Bool
(StepMode -> StepMode -> Bool)
-> (StepMode -> StepMode -> Bool) -> Eq StepMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StepMode -> StepMode -> Bool
== :: StepMode -> StepMode -> Bool
$c/= :: StepMode -> StepMode -> Bool
/= :: StepMode -> StepMode -> Bool
Eq)

instance P.Enum StepMode where
    fromEnum :: StepMode -> Int
fromEnum StepMode
StepModeStart = Int
0
    fromEnum StepMode
StepModeEnd = Int
1
    fromEnum (AnotherStepMode Int
k) = Int
k

    toEnum :: Int -> StepMode
toEnum Int
0 = StepMode
StepModeStart
    toEnum Int
1 = StepMode
StepModeEnd
    toEnum Int
k = Int -> StepMode
AnotherStepMode Int
k

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

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

foreign import ccall "clutter_step_mode_get_type" c_clutter_step_mode_get_type :: 
    IO GType

instance B.Types.TypedObject StepMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_step_mode_get_type

instance B.Types.BoxedEnum StepMode

-- Enum StaticColor
-- | Named colors, for accessing global colors defined by Clutter
-- 
-- /Since: 1.6/
data StaticColor = 
      StaticColorWhite
    -- ^ White color (ffffffff)
    | StaticColorBlack
    -- ^ Black color (000000ff)
    | StaticColorRed
    -- ^ Red color (ff0000ff)
    | StaticColorDarkRed
    -- ^ Dark red color (800000ff)
    | StaticColorGreen
    -- ^ Green color (00ff00ff)
    | StaticColorDarkGreen
    -- ^ Dark green color (008000ff)
    | StaticColorBlue
    -- ^ Blue color (0000ffff)
    | StaticColorDarkBlue
    -- ^ Dark blue color (000080ff)
    | StaticColorCyan
    -- ^ Cyan color (00ffffff)
    | StaticColorDarkCyan
    -- ^ Dark cyan color (008080ff)
    | StaticColorMagenta
    -- ^ Magenta color (ff00ffff)
    | StaticColorDarkMagenta
    -- ^ Dark magenta color (800080ff)
    | StaticColorYellow
    -- ^ Yellow color (ffff00ff)
    | StaticColorDarkYellow
    -- ^ Dark yellow color (808000ff)
    | StaticColorGray
    -- ^ Gray color (a0a0a4ff)
    | StaticColorDarkGray
    -- ^ Dark Gray color (808080ff)
    | StaticColorLightGray
    -- ^ Light gray color (c0c0c0ff)
    | StaticColorButter
    -- ^ Butter color (edd400ff)
    | StaticColorButterLight
    -- ^ Light butter color (fce94fff)
    | StaticColorButterDark
    -- ^ Dark butter color (c4a000ff)
    | StaticColorOrange
    -- ^ Orange color (f57900ff)
    | StaticColorOrangeLight
    -- ^ Light orange color (fcaf3fff)
    | StaticColorOrangeDark
    -- ^ Dark orange color (ce5c00ff)
    | StaticColorChocolate
    -- ^ Chocolate color (c17d11ff)
    | StaticColorChocolateLight
    -- ^ Light chocolate color (e9b96eff)
    | StaticColorChocolateDark
    -- ^ Dark chocolate color (8f5902ff)
    | StaticColorChameleon
    -- ^ Chameleon color (73d216ff)
    | StaticColorChameleonLight
    -- ^ Light chameleon color (8ae234ff)
    | StaticColorChameleonDark
    -- ^ Dark chameleon color (4e9a06ff)
    | StaticColorSkyBlue
    -- ^ Sky color (3465a4ff)
    | StaticColorSkyBlueLight
    -- ^ Light sky color (729fcfff)
    | StaticColorSkyBlueDark
    -- ^ Dark sky color (204a87ff)
    | StaticColorPlum
    -- ^ Plum color (75507bff)
    | StaticColorPlumLight
    -- ^ Light plum color (ad7fa8ff)
    | StaticColorPlumDark
    -- ^ Dark plum color (5c3566ff)
    | StaticColorScarletRed
    -- ^ Scarlet red color (cc0000ff)
    | StaticColorScarletRedLight
    -- ^ Light scarlet red color (ef2929ff)
    | StaticColorScarletRedDark
    -- ^ Dark scarlet red color (a40000ff)
    | StaticColorAluminium1
    -- ^ Aluminium, first variant (eeeeecff)
    | StaticColorAluminium2
    -- ^ Aluminium, second variant (d3d7cfff)
    | StaticColorAluminium3
    -- ^ Aluminium, third variant (babdb6ff)
    | StaticColorAluminium4
    -- ^ Aluminium, fourth variant (888a85ff)
    | StaticColorAluminium5
    -- ^ Aluminium, fifth variant (555753ff)
    | StaticColorAluminium6
    -- ^ Aluminium, sixth variant (2e3436ff)
    | StaticColorTransparent
    -- ^ Transparent color (00000000)
    | AnotherStaticColor Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StaticColor -> ShowS
[StaticColor] -> ShowS
StaticColor -> String
(Int -> StaticColor -> ShowS)
-> (StaticColor -> String)
-> ([StaticColor] -> ShowS)
-> Show StaticColor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StaticColor -> ShowS
showsPrec :: Int -> StaticColor -> ShowS
$cshow :: StaticColor -> String
show :: StaticColor -> String
$cshowList :: [StaticColor] -> ShowS
showList :: [StaticColor] -> ShowS
Show, StaticColor -> StaticColor -> Bool
(StaticColor -> StaticColor -> Bool)
-> (StaticColor -> StaticColor -> Bool) -> Eq StaticColor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticColor -> StaticColor -> Bool
== :: StaticColor -> StaticColor -> Bool
$c/= :: StaticColor -> StaticColor -> Bool
/= :: StaticColor -> StaticColor -> Bool
Eq)

instance P.Enum StaticColor where
    fromEnum :: StaticColor -> Int
fromEnum StaticColor
StaticColorWhite = Int
0
    fromEnum StaticColor
StaticColorBlack = Int
1
    fromEnum StaticColor
StaticColorRed = Int
2
    fromEnum StaticColor
StaticColorDarkRed = Int
3
    fromEnum StaticColor
StaticColorGreen = Int
4
    fromEnum StaticColor
StaticColorDarkGreen = Int
5
    fromEnum StaticColor
StaticColorBlue = Int
6
    fromEnum StaticColor
StaticColorDarkBlue = Int
7
    fromEnum StaticColor
StaticColorCyan = Int
8
    fromEnum StaticColor
StaticColorDarkCyan = Int
9
    fromEnum StaticColor
StaticColorMagenta = Int
10
    fromEnum StaticColor
StaticColorDarkMagenta = Int
11
    fromEnum StaticColor
StaticColorYellow = Int
12
    fromEnum StaticColor
StaticColorDarkYellow = Int
13
    fromEnum StaticColor
StaticColorGray = Int
14
    fromEnum StaticColor
StaticColorDarkGray = Int
15
    fromEnum StaticColor
StaticColorLightGray = Int
16
    fromEnum StaticColor
StaticColorButter = Int
17
    fromEnum StaticColor
StaticColorButterLight = Int
18
    fromEnum StaticColor
StaticColorButterDark = Int
19
    fromEnum StaticColor
StaticColorOrange = Int
20
    fromEnum StaticColor
StaticColorOrangeLight = Int
21
    fromEnum StaticColor
StaticColorOrangeDark = Int
22
    fromEnum StaticColor
StaticColorChocolate = Int
23
    fromEnum StaticColor
StaticColorChocolateLight = Int
24
    fromEnum StaticColor
StaticColorChocolateDark = Int
25
    fromEnum StaticColor
StaticColorChameleon = Int
26
    fromEnum StaticColor
StaticColorChameleonLight = Int
27
    fromEnum StaticColor
StaticColorChameleonDark = Int
28
    fromEnum StaticColor
StaticColorSkyBlue = Int
29
    fromEnum StaticColor
StaticColorSkyBlueLight = Int
30
    fromEnum StaticColor
StaticColorSkyBlueDark = Int
31
    fromEnum StaticColor
StaticColorPlum = Int
32
    fromEnum StaticColor
StaticColorPlumLight = Int
33
    fromEnum StaticColor
StaticColorPlumDark = Int
34
    fromEnum StaticColor
StaticColorScarletRed = Int
35
    fromEnum StaticColor
StaticColorScarletRedLight = Int
36
    fromEnum StaticColor
StaticColorScarletRedDark = Int
37
    fromEnum StaticColor
StaticColorAluminium1 = Int
38
    fromEnum StaticColor
StaticColorAluminium2 = Int
39
    fromEnum StaticColor
StaticColorAluminium3 = Int
40
    fromEnum StaticColor
StaticColorAluminium4 = Int
41
    fromEnum StaticColor
StaticColorAluminium5 = Int
42
    fromEnum StaticColor
StaticColorAluminium6 = Int
43
    fromEnum StaticColor
StaticColorTransparent = Int
44
    fromEnum (AnotherStaticColor Int
k) = Int
k

    toEnum :: Int -> StaticColor
toEnum Int
0 = StaticColor
StaticColorWhite
    toEnum Int
1 = StaticColor
StaticColorBlack
    toEnum Int
2 = StaticColor
StaticColorRed
    toEnum Int
3 = StaticColor
StaticColorDarkRed
    toEnum Int
4 = StaticColor
StaticColorGreen
    toEnum Int
5 = StaticColor
StaticColorDarkGreen
    toEnum Int
6 = StaticColor
StaticColorBlue
    toEnum Int
7 = StaticColor
StaticColorDarkBlue
    toEnum Int
8 = StaticColor
StaticColorCyan
    toEnum Int
9 = StaticColor
StaticColorDarkCyan
    toEnum Int
10 = StaticColor
StaticColorMagenta
    toEnum Int
11 = StaticColor
StaticColorDarkMagenta
    toEnum Int
12 = StaticColor
StaticColorYellow
    toEnum Int
13 = StaticColor
StaticColorDarkYellow
    toEnum Int
14 = StaticColor
StaticColorGray
    toEnum Int
15 = StaticColor
StaticColorDarkGray
    toEnum Int
16 = StaticColor
StaticColorLightGray
    toEnum Int
17 = StaticColor
StaticColorButter
    toEnum Int
18 = StaticColor
StaticColorButterLight
    toEnum Int
19 = StaticColor
StaticColorButterDark
    toEnum Int
20 = StaticColor
StaticColorOrange
    toEnum Int
21 = StaticColor
StaticColorOrangeLight
    toEnum Int
22 = StaticColor
StaticColorOrangeDark
    toEnum Int
23 = StaticColor
StaticColorChocolate
    toEnum Int
24 = StaticColor
StaticColorChocolateLight
    toEnum Int
25 = StaticColor
StaticColorChocolateDark
    toEnum Int
26 = StaticColor
StaticColorChameleon
    toEnum Int
27 = StaticColor
StaticColorChameleonLight
    toEnum Int
28 = StaticColor
StaticColorChameleonDark
    toEnum Int
29 = StaticColor
StaticColorSkyBlue
    toEnum Int
30 = StaticColor
StaticColorSkyBlueLight
    toEnum Int
31 = StaticColor
StaticColorSkyBlueDark
    toEnum Int
32 = StaticColor
StaticColorPlum
    toEnum Int
33 = StaticColor
StaticColorPlumLight
    toEnum Int
34 = StaticColor
StaticColorPlumDark
    toEnum Int
35 = StaticColor
StaticColorScarletRed
    toEnum Int
36 = StaticColor
StaticColorScarletRedLight
    toEnum Int
37 = StaticColor
StaticColorScarletRedDark
    toEnum Int
38 = StaticColor
StaticColorAluminium1
    toEnum Int
39 = StaticColor
StaticColorAluminium2
    toEnum Int
40 = StaticColor
StaticColorAluminium3
    toEnum Int
41 = StaticColor
StaticColorAluminium4
    toEnum Int
42 = StaticColor
StaticColorAluminium5
    toEnum Int
43 = StaticColor
StaticColorAluminium6
    toEnum Int
44 = StaticColor
StaticColorTransparent
    toEnum Int
k = Int -> StaticColor
AnotherStaticColor Int
k

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

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

foreign import ccall "clutter_static_color_get_type" c_clutter_static_color_get_type :: 
    IO GType

instance B.Types.TypedObject StaticColor where
    glibType :: IO GType
glibType = IO GType
c_clutter_static_color_get_type

instance B.Types.BoxedEnum StaticColor

-- Enum SnapEdge
-- | The edge to snap
-- 
-- /Since: 1.6/
data SnapEdge = 
      SnapEdgeTop
    -- ^ the top edge
    | SnapEdgeRight
    -- ^ the right edge
    | SnapEdgeBottom
    -- ^ the bottom edge
    | SnapEdgeLeft
    -- ^ the left edge
    | AnotherSnapEdge Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SnapEdge -> ShowS
[SnapEdge] -> ShowS
SnapEdge -> String
(Int -> SnapEdge -> ShowS)
-> (SnapEdge -> String) -> ([SnapEdge] -> ShowS) -> Show SnapEdge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SnapEdge -> ShowS
showsPrec :: Int -> SnapEdge -> ShowS
$cshow :: SnapEdge -> String
show :: SnapEdge -> String
$cshowList :: [SnapEdge] -> ShowS
showList :: [SnapEdge] -> ShowS
Show, SnapEdge -> SnapEdge -> Bool
(SnapEdge -> SnapEdge -> Bool)
-> (SnapEdge -> SnapEdge -> Bool) -> Eq SnapEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SnapEdge -> SnapEdge -> Bool
== :: SnapEdge -> SnapEdge -> Bool
$c/= :: SnapEdge -> SnapEdge -> Bool
/= :: SnapEdge -> SnapEdge -> Bool
Eq)

instance P.Enum SnapEdge where
    fromEnum :: SnapEdge -> Int
fromEnum SnapEdge
SnapEdgeTop = Int
0
    fromEnum SnapEdge
SnapEdgeRight = Int
1
    fromEnum SnapEdge
SnapEdgeBottom = Int
2
    fromEnum SnapEdge
SnapEdgeLeft = Int
3
    fromEnum (AnotherSnapEdge Int
k) = Int
k

    toEnum :: Int -> SnapEdge
toEnum Int
0 = SnapEdge
SnapEdgeTop
    toEnum Int
1 = SnapEdge
SnapEdgeRight
    toEnum Int
2 = SnapEdge
SnapEdgeBottom
    toEnum Int
3 = SnapEdge
SnapEdgeLeft
    toEnum Int
k = Int -> SnapEdge
AnotherSnapEdge Int
k

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

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

foreign import ccall "clutter_snap_edge_get_type" c_clutter_snap_edge_get_type :: 
    IO GType

instance B.Types.TypedObject SnapEdge where
    glibType :: IO GType
glibType = IO GType
c_clutter_snap_edge_get_type

instance B.Types.BoxedEnum SnapEdge

-- Enum ShaderType
-- | The type of GLSL shader program
-- 
-- /Since: 1.4/
data ShaderType = 
      ShaderTypeVertexShader
    -- ^ a vertex shader
    | ShaderTypeFragmentShader
    -- ^ a fragment shader
    | AnotherShaderType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShaderType -> ShowS
[ShaderType] -> ShowS
ShaderType -> String
(Int -> ShaderType -> ShowS)
-> (ShaderType -> String)
-> ([ShaderType] -> ShowS)
-> Show ShaderType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderType -> ShowS
showsPrec :: Int -> ShaderType -> ShowS
$cshow :: ShaderType -> String
show :: ShaderType -> String
$cshowList :: [ShaderType] -> ShowS
showList :: [ShaderType] -> ShowS
Show, ShaderType -> ShaderType -> Bool
(ShaderType -> ShaderType -> Bool)
-> (ShaderType -> ShaderType -> Bool) -> Eq ShaderType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderType -> ShaderType -> Bool
== :: ShaderType -> ShaderType -> Bool
$c/= :: ShaderType -> ShaderType -> Bool
/= :: ShaderType -> ShaderType -> Bool
Eq)

instance P.Enum ShaderType where
    fromEnum :: ShaderType -> Int
fromEnum ShaderType
ShaderTypeVertexShader = Int
0
    fromEnum ShaderType
ShaderTypeFragmentShader = Int
1
    fromEnum (AnotherShaderType Int
k) = Int
k

    toEnum :: Int -> ShaderType
toEnum Int
0 = ShaderType
ShaderTypeVertexShader
    toEnum Int
1 = ShaderType
ShaderTypeFragmentShader
    toEnum Int
k = Int -> ShaderType
AnotherShaderType Int
k

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

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

foreign import ccall "clutter_shader_type_get_type" c_clutter_shader_type_get_type :: 
    IO GType

instance B.Types.TypedObject ShaderType where
    glibType :: IO GType
glibType = IO GType
c_clutter_shader_type_get_type

instance B.Types.BoxedEnum ShaderType

-- Enum ShaderError
{-# DEPRECATED ShaderError ["(Since version 1.8)"] #-}
-- | t'GI.Clutter.Objects.Shader.Shader' error enumeration
-- 
-- /Since: 0.6/
data ShaderError = 
      ShaderErrorNoAsm
    -- ^ No ASM shaders support
    | ShaderErrorNoGlsl
    -- ^ No GLSL shaders support
    | ShaderErrorCompile
    -- ^ Compilation error
    | AnotherShaderError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShaderError -> ShowS
[ShaderError] -> ShowS
ShaderError -> String
(Int -> ShaderError -> ShowS)
-> (ShaderError -> String)
-> ([ShaderError] -> ShowS)
-> Show ShaderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderError -> ShowS
showsPrec :: Int -> ShaderError -> ShowS
$cshow :: ShaderError -> String
show :: ShaderError -> String
$cshowList :: [ShaderError] -> ShowS
showList :: [ShaderError] -> ShowS
Show, ShaderError -> ShaderError -> Bool
(ShaderError -> ShaderError -> Bool)
-> (ShaderError -> ShaderError -> Bool) -> Eq ShaderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderError -> ShaderError -> Bool
== :: ShaderError -> ShaderError -> Bool
$c/= :: ShaderError -> ShaderError -> Bool
/= :: ShaderError -> ShaderError -> Bool
Eq)

instance P.Enum ShaderError where
    fromEnum :: ShaderError -> Int
fromEnum ShaderError
ShaderErrorNoAsm = Int
0
    fromEnum ShaderError
ShaderErrorNoGlsl = Int
1
    fromEnum ShaderError
ShaderErrorCompile = Int
2
    fromEnum (AnotherShaderError Int
k) = Int
k

    toEnum :: Int -> ShaderError
toEnum Int
0 = ShaderError
ShaderErrorNoAsm
    toEnum Int
1 = ShaderError
ShaderErrorNoGlsl
    toEnum Int
2 = ShaderError
ShaderErrorCompile
    toEnum Int
k = Int -> ShaderError
AnotherShaderError Int
k

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

instance GErrorClass ShaderError where
    gerrorClassDomain :: ShaderError -> Text
gerrorClassDomain ShaderError
_ = Text
"clutter-shader-error"

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

-- | Handle exceptions of type `ShaderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleShaderError ::
    (ShaderError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleShaderError :: forall a. (ShaderError -> Text -> IO a) -> IO a -> IO a
handleShaderError = (ShaderError -> 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 ShaderError = '[]
instance O.HasParentTypes ShaderError

foreign import ccall "clutter_shader_error_get_type" c_clutter_shader_error_get_type :: 
    IO GType

instance B.Types.TypedObject ShaderError where
    glibType :: IO GType
glibType = IO GType
c_clutter_shader_error_get_type

instance B.Types.BoxedEnum ShaderError

-- Enum ScrollSource
-- | The scroll source determines the source of the scroll event. Keep in mind
-- that the source device t'GI.Clutter.Enums.InputDeviceType' is not enough to infer
-- the scroll source.
-- 
-- /Since: 1.26/
data ScrollSource = 
      ScrollSourceUnknown
    -- ^ Source of scroll events is unknown.
    | ScrollSourceWheel
    -- ^ The scroll event is originated by a mouse wheel.
    | ScrollSourceFinger
    -- ^ The scroll event is originated by one or more
    --   fingers on the device (eg. touchpads).
    | ScrollSourceContinuous
    -- ^ The scroll event is originated by the
    --   motion of some device (eg. a scroll button is set).
    | AnotherScrollSource Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollSource -> ShowS
[ScrollSource] -> ShowS
ScrollSource -> String
(Int -> ScrollSource -> ShowS)
-> (ScrollSource -> String)
-> ([ScrollSource] -> ShowS)
-> Show ScrollSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScrollSource -> ShowS
showsPrec :: Int -> ScrollSource -> ShowS
$cshow :: ScrollSource -> String
show :: ScrollSource -> String
$cshowList :: [ScrollSource] -> ShowS
showList :: [ScrollSource] -> ShowS
Show, ScrollSource -> ScrollSource -> Bool
(ScrollSource -> ScrollSource -> Bool)
-> (ScrollSource -> ScrollSource -> Bool) -> Eq ScrollSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScrollSource -> ScrollSource -> Bool
== :: ScrollSource -> ScrollSource -> Bool
$c/= :: ScrollSource -> ScrollSource -> Bool
/= :: ScrollSource -> ScrollSource -> Bool
Eq)

instance P.Enum ScrollSource where
    fromEnum :: ScrollSource -> Int
fromEnum ScrollSource
ScrollSourceUnknown = Int
0
    fromEnum ScrollSource
ScrollSourceWheel = Int
1
    fromEnum ScrollSource
ScrollSourceFinger = Int
2
    fromEnum ScrollSource
ScrollSourceContinuous = Int
3
    fromEnum (AnotherScrollSource Int
k) = Int
k

    toEnum :: Int -> ScrollSource
toEnum Int
0 = ScrollSource
ScrollSourceUnknown
    toEnum Int
1 = ScrollSource
ScrollSourceWheel
    toEnum Int
2 = ScrollSource
ScrollSourceFinger
    toEnum Int
3 = ScrollSource
ScrollSourceContinuous
    toEnum Int
k = Int -> ScrollSource
AnotherScrollSource Int
k

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

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

foreign import ccall "clutter_scroll_source_get_type" c_clutter_scroll_source_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollSource where
    glibType :: IO GType
glibType = IO GType
c_clutter_scroll_source_get_type

instance B.Types.BoxedEnum ScrollSource

-- Enum ScrollDirection
-- | Direction of a pointer scroll event.
-- 
-- The 'GI.Clutter.Enums.ScrollDirectionSmooth' value implies that the t'GI.Clutter.Structs.ScrollEvent.ScrollEvent'
-- has precise scrolling delta information.
-- 
-- /Since: 0.4/
data ScrollDirection = 
      ScrollDirectionUp
    -- ^ Scroll up
    | ScrollDirectionDown
    -- ^ Scroll down
    | ScrollDirectionLeft
    -- ^ Scroll left
    | ScrollDirectionRight
    -- ^ Scroll right
    | ScrollDirectionSmooth
    -- ^ Precise scrolling delta (available in 1.10)
    | AnotherScrollDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollDirection -> ShowS
[ScrollDirection] -> ShowS
ScrollDirection -> String
(Int -> ScrollDirection -> ShowS)
-> (ScrollDirection -> String)
-> ([ScrollDirection] -> ShowS)
-> Show ScrollDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScrollDirection -> ShowS
showsPrec :: Int -> ScrollDirection -> ShowS
$cshow :: ScrollDirection -> String
show :: ScrollDirection -> String
$cshowList :: [ScrollDirection] -> ShowS
showList :: [ScrollDirection] -> ShowS
Show, ScrollDirection -> ScrollDirection -> Bool
(ScrollDirection -> ScrollDirection -> Bool)
-> (ScrollDirection -> ScrollDirection -> Bool)
-> Eq ScrollDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScrollDirection -> ScrollDirection -> Bool
== :: ScrollDirection -> ScrollDirection -> Bool
$c/= :: ScrollDirection -> ScrollDirection -> Bool
/= :: ScrollDirection -> ScrollDirection -> Bool
Eq)

instance P.Enum ScrollDirection where
    fromEnum :: ScrollDirection -> Int
fromEnum ScrollDirection
ScrollDirectionUp = Int
0
    fromEnum ScrollDirection
ScrollDirectionDown = Int
1
    fromEnum ScrollDirection
ScrollDirectionLeft = Int
2
    fromEnum ScrollDirection
ScrollDirectionRight = Int
3
    fromEnum ScrollDirection
ScrollDirectionSmooth = Int
4
    fromEnum (AnotherScrollDirection Int
k) = Int
k

    toEnum :: Int -> ScrollDirection
toEnum Int
0 = ScrollDirection
ScrollDirectionUp
    toEnum Int
1 = ScrollDirection
ScrollDirectionDown
    toEnum Int
2 = ScrollDirection
ScrollDirectionLeft
    toEnum Int
3 = ScrollDirection
ScrollDirectionRight
    toEnum Int
4 = ScrollDirection
ScrollDirectionSmooth
    toEnum Int
k = Int -> ScrollDirection
AnotherScrollDirection Int
k

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

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

foreign import ccall "clutter_scroll_direction_get_type" c_clutter_scroll_direction_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollDirection where
    glibType :: IO GType
glibType = IO GType
c_clutter_scroll_direction_get_type

instance B.Types.BoxedEnum ScrollDirection

-- Enum ScriptError
-- | t'GI.Clutter.Objects.Script.Script' error enumeration.
-- 
-- /Since: 0.6/
data ScriptError = 
      ScriptErrorTypeFunction
    -- ^ Type function not found
    --   or invalid
    | ScriptErrorProperty
    -- ^ Property not found or invalid
    | ScriptErrorValue
    -- ^ Invalid value
    | AnotherScriptError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScriptError -> ShowS
[ScriptError] -> ShowS
ScriptError -> String
(Int -> ScriptError -> ShowS)
-> (ScriptError -> String)
-> ([ScriptError] -> ShowS)
-> Show ScriptError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScriptError -> ShowS
showsPrec :: Int -> ScriptError -> ShowS
$cshow :: ScriptError -> String
show :: ScriptError -> String
$cshowList :: [ScriptError] -> ShowS
showList :: [ScriptError] -> ShowS
Show, ScriptError -> ScriptError -> Bool
(ScriptError -> ScriptError -> Bool)
-> (ScriptError -> ScriptError -> Bool) -> Eq ScriptError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScriptError -> ScriptError -> Bool
== :: ScriptError -> ScriptError -> Bool
$c/= :: ScriptError -> ScriptError -> Bool
/= :: ScriptError -> ScriptError -> Bool
Eq)

instance P.Enum ScriptError where
    fromEnum :: ScriptError -> Int
fromEnum ScriptError
ScriptErrorTypeFunction = Int
0
    fromEnum ScriptError
ScriptErrorProperty = Int
1
    fromEnum ScriptError
ScriptErrorValue = Int
2
    fromEnum (AnotherScriptError Int
k) = Int
k

    toEnum :: Int -> ScriptError
toEnum Int
0 = ScriptError
ScriptErrorTypeFunction
    toEnum Int
1 = ScriptError
ScriptErrorProperty
    toEnum Int
2 = ScriptError
ScriptErrorValue
    toEnum Int
k = Int -> ScriptError
AnotherScriptError Int
k

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

instance GErrorClass ScriptError where
    gerrorClassDomain :: ScriptError -> Text
gerrorClassDomain ScriptError
_ = Text
"clutter-script-error"

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

-- | Handle exceptions of type `ScriptError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleScriptError ::
    (ScriptError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleScriptError :: forall a. (ScriptError -> Text -> IO a) -> IO a -> IO a
handleScriptError = (ScriptError -> 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 ScriptError = '[]
instance O.HasParentTypes ScriptError

foreign import ccall "clutter_script_error_get_type" c_clutter_script_error_get_type :: 
    IO GType

instance B.Types.TypedObject ScriptError where
    glibType :: IO GType
glibType = IO GType
c_clutter_script_error_get_type

instance B.Types.BoxedEnum ScriptError

-- Enum ScalingFilter
-- | The scaling filters to be used with the [Actor:minificationFilter]("GI.Clutter.Objects.Actor#g:attr:minificationFilter")
-- and [Actor:magnificationFilter]("GI.Clutter.Objects.Actor#g:attr:magnificationFilter") properties.
-- 
-- /Since: 1.10/
data ScalingFilter = 
      ScalingFilterLinear
    -- ^ Linear interpolation filter
    | ScalingFilterNearest
    -- ^ Nearest neighbor interpolation filter
    | ScalingFilterTrilinear
    -- ^ Trilinear minification filter, with
    --   mipmap generation; this filter linearly interpolates on every axis,
    --   as well as between 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 "clutter_scaling_filter_get_type" c_clutter_scaling_filter_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum ScalingFilter

-- Enum RotateDirection
{-# DEPRECATED RotateDirection ["(Since version 1.22)"] #-}
-- | Direction of a rotation.
-- 
-- /Since: 0.4/
data RotateDirection = 
      RotateDirectionCw
    -- ^ Clockwise rotation
    | RotateDirectionCcw
    -- ^ Counter-clockwise rotation
    | AnotherRotateDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RotateDirection -> ShowS
[RotateDirection] -> ShowS
RotateDirection -> String
(Int -> RotateDirection -> ShowS)
-> (RotateDirection -> String)
-> ([RotateDirection] -> ShowS)
-> Show RotateDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RotateDirection -> ShowS
showsPrec :: Int -> RotateDirection -> ShowS
$cshow :: RotateDirection -> String
show :: RotateDirection -> String
$cshowList :: [RotateDirection] -> ShowS
showList :: [RotateDirection] -> ShowS
Show, RotateDirection -> RotateDirection -> Bool
(RotateDirection -> RotateDirection -> Bool)
-> (RotateDirection -> RotateDirection -> Bool)
-> Eq RotateDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RotateDirection -> RotateDirection -> Bool
== :: RotateDirection -> RotateDirection -> Bool
$c/= :: RotateDirection -> RotateDirection -> Bool
/= :: RotateDirection -> RotateDirection -> Bool
Eq)

instance P.Enum RotateDirection where
    fromEnum :: RotateDirection -> Int
fromEnum RotateDirection
RotateDirectionCw = Int
0
    fromEnum RotateDirection
RotateDirectionCcw = Int
1
    fromEnum (AnotherRotateDirection Int
k) = Int
k

    toEnum :: Int -> RotateDirection
toEnum Int
0 = RotateDirection
RotateDirectionCw
    toEnum Int
1 = RotateDirection
RotateDirectionCcw
    toEnum Int
k = Int -> RotateDirection
AnotherRotateDirection Int
k

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

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

foreign import ccall "clutter_rotate_direction_get_type" c_clutter_rotate_direction_get_type :: 
    IO GType

instance B.Types.TypedObject RotateDirection where
    glibType :: IO GType
glibType = IO GType
c_clutter_rotate_direction_get_type

instance B.Types.BoxedEnum RotateDirection

-- Enum RotateAxis
-- | Axis of a rotation.
-- 
-- /Since: 0.4/
data RotateAxis = 
      RotateAxisXAxis
    -- ^ Rotate around the X axis
    | RotateAxisYAxis
    -- ^ Rotate around the Y axis
    | RotateAxisZAxis
    -- ^ Rotate around the Z axis
    | AnotherRotateAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RotateAxis -> ShowS
[RotateAxis] -> ShowS
RotateAxis -> String
(Int -> RotateAxis -> ShowS)
-> (RotateAxis -> String)
-> ([RotateAxis] -> ShowS)
-> Show RotateAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RotateAxis -> ShowS
showsPrec :: Int -> RotateAxis -> ShowS
$cshow :: RotateAxis -> String
show :: RotateAxis -> String
$cshowList :: [RotateAxis] -> ShowS
showList :: [RotateAxis] -> ShowS
Show, RotateAxis -> RotateAxis -> Bool
(RotateAxis -> RotateAxis -> Bool)
-> (RotateAxis -> RotateAxis -> Bool) -> Eq RotateAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RotateAxis -> RotateAxis -> Bool
== :: RotateAxis -> RotateAxis -> Bool
$c/= :: RotateAxis -> RotateAxis -> Bool
/= :: RotateAxis -> RotateAxis -> Bool
Eq)

instance P.Enum RotateAxis where
    fromEnum :: RotateAxis -> Int
fromEnum RotateAxis
RotateAxisXAxis = Int
0
    fromEnum RotateAxis
RotateAxisYAxis = Int
1
    fromEnum RotateAxis
RotateAxisZAxis = Int
2
    fromEnum (AnotherRotateAxis Int
k) = Int
k

    toEnum :: Int -> RotateAxis
toEnum Int
0 = RotateAxis
RotateAxisXAxis
    toEnum Int
1 = RotateAxis
RotateAxisYAxis
    toEnum Int
2 = RotateAxis
RotateAxisZAxis
    toEnum Int
k = Int -> RotateAxis
AnotherRotateAxis Int
k

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

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

foreign import ccall "clutter_rotate_axis_get_type" c_clutter_rotate_axis_get_type :: 
    IO GType

instance B.Types.TypedObject RotateAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_rotate_axis_get_type

instance B.Types.BoxedEnum RotateAxis

-- Enum RequestMode
-- | Specifies the type of requests for a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 0.8/
data RequestMode = 
      RequestModeHeightForWidth
    -- ^ Height for width requests
    | RequestModeWidthForHeight
    -- ^ Width for height requests
    | RequestModeContentSize
    -- ^ Use the preferred size of the
    --   t'GI.Clutter.Interfaces.Content.Content', if it has any (available since 1.22)
    | AnotherRequestMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RequestMode -> ShowS
[RequestMode] -> ShowS
RequestMode -> String
(Int -> RequestMode -> ShowS)
-> (RequestMode -> String)
-> ([RequestMode] -> ShowS)
-> Show RequestMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestMode -> ShowS
showsPrec :: Int -> RequestMode -> ShowS
$cshow :: RequestMode -> String
show :: RequestMode -> String
$cshowList :: [RequestMode] -> ShowS
showList :: [RequestMode] -> ShowS
Show, RequestMode -> RequestMode -> Bool
(RequestMode -> RequestMode -> Bool)
-> (RequestMode -> RequestMode -> Bool) -> Eq RequestMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestMode -> RequestMode -> Bool
== :: RequestMode -> RequestMode -> Bool
$c/= :: RequestMode -> RequestMode -> Bool
/= :: RequestMode -> RequestMode -> Bool
Eq)

instance P.Enum RequestMode where
    fromEnum :: RequestMode -> Int
fromEnum RequestMode
RequestModeHeightForWidth = Int
0
    fromEnum RequestMode
RequestModeWidthForHeight = Int
1
    fromEnum RequestMode
RequestModeContentSize = Int
2
    fromEnum (AnotherRequestMode Int
k) = Int
k

    toEnum :: Int -> RequestMode
toEnum Int
0 = RequestMode
RequestModeHeightForWidth
    toEnum Int
1 = RequestMode
RequestModeWidthForHeight
    toEnum Int
2 = RequestMode
RequestModeContentSize
    toEnum Int
k = Int -> RequestMode
AnotherRequestMode Int
k

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

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

foreign import ccall "clutter_request_mode_get_type" c_clutter_request_mode_get_type :: 
    IO GType

instance B.Types.TypedObject RequestMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_request_mode_get_type

instance B.Types.BoxedEnum RequestMode

-- Enum PickMode
-- | Controls the paint cycle of the scene graph when in pick mode
-- 
-- /Since: 1.0/
data PickMode = 
      PickModeNone
    -- ^ Do not paint any actor
    | PickModeReactive
    -- ^ Paint only the reactive actors
    | PickModeAll
    -- ^ Paint all actors
    | AnotherPickMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PickMode -> ShowS
[PickMode] -> ShowS
PickMode -> String
(Int -> PickMode -> ShowS)
-> (PickMode -> String) -> ([PickMode] -> ShowS) -> Show PickMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PickMode -> ShowS
showsPrec :: Int -> PickMode -> ShowS
$cshow :: PickMode -> String
show :: PickMode -> String
$cshowList :: [PickMode] -> ShowS
showList :: [PickMode] -> ShowS
Show, PickMode -> PickMode -> Bool
(PickMode -> PickMode -> Bool)
-> (PickMode -> PickMode -> Bool) -> Eq PickMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PickMode -> PickMode -> Bool
== :: PickMode -> PickMode -> Bool
$c/= :: PickMode -> PickMode -> Bool
/= :: PickMode -> PickMode -> Bool
Eq)

instance P.Enum PickMode where
    fromEnum :: PickMode -> Int
fromEnum PickMode
PickModeNone = Int
0
    fromEnum PickMode
PickModeReactive = Int
1
    fromEnum PickMode
PickModeAll = Int
2
    fromEnum (AnotherPickMode Int
k) = Int
k

    toEnum :: Int -> PickMode
toEnum Int
0 = PickMode
PickModeNone
    toEnum Int
1 = PickMode
PickModeReactive
    toEnum Int
2 = PickMode
PickModeAll
    toEnum Int
k = Int -> PickMode
AnotherPickMode Int
k

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

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

foreign import ccall "clutter_pick_mode_get_type" c_clutter_pick_mode_get_type :: 
    IO GType

instance B.Types.TypedObject PickMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_pick_mode_get_type

instance B.Types.BoxedEnum PickMode

-- Enum PathNodeType
-- | Types of nodes in a t'GI.Clutter.Objects.Path.Path'.
-- 
-- /Since: 1.0/
data PathNodeType = 
      PathNodeTypeMoveTo
    -- ^ jump to the given position
    | PathNodeTypeLineTo
    -- ^ create a line from the last node to the
    --   given position
    | PathNodeTypeCurveTo
    -- ^ bezier curve using the last position and
    --   three control points.
    | PathNodeTypeClose
    -- ^ create a line from the last node to the last
    --   'GI.Clutter.Enums.PathNodeTypeMoveTo' node.
    | PathNodeTypeRelMoveTo
    -- ^ same as 'GI.Clutter.Enums.PathNodeTypeMoveTo' but with
    --   coordinates relative to the last node.
    | PathNodeTypeRelLineTo
    -- ^ same as 'GI.Clutter.Enums.PathNodeTypeLineTo' but with
    --   coordinates relative to the last node.
    | PathNodeTypeRelCurveTo
    -- ^ same as 'GI.Clutter.Enums.PathNodeTypeCurveTo' but with
    --   coordinates relative to the last node.
    | AnotherPathNodeType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathNodeType -> ShowS
[PathNodeType] -> ShowS
PathNodeType -> String
(Int -> PathNodeType -> ShowS)
-> (PathNodeType -> String)
-> ([PathNodeType] -> ShowS)
-> Show PathNodeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PathNodeType -> ShowS
showsPrec :: Int -> PathNodeType -> ShowS
$cshow :: PathNodeType -> String
show :: PathNodeType -> String
$cshowList :: [PathNodeType] -> ShowS
showList :: [PathNodeType] -> ShowS
Show, PathNodeType -> PathNodeType -> Bool
(PathNodeType -> PathNodeType -> Bool)
-> (PathNodeType -> PathNodeType -> Bool) -> Eq PathNodeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PathNodeType -> PathNodeType -> Bool
== :: PathNodeType -> PathNodeType -> Bool
$c/= :: PathNodeType -> PathNodeType -> Bool
/= :: PathNodeType -> PathNodeType -> Bool
Eq)

instance P.Enum PathNodeType where
    fromEnum :: PathNodeType -> Int
fromEnum PathNodeType
PathNodeTypeMoveTo = Int
0
    fromEnum PathNodeType
PathNodeTypeLineTo = Int
1
    fromEnum PathNodeType
PathNodeTypeCurveTo = Int
2
    fromEnum PathNodeType
PathNodeTypeClose = Int
3
    fromEnum PathNodeType
PathNodeTypeRelMoveTo = Int
32
    fromEnum PathNodeType
PathNodeTypeRelLineTo = Int
33
    fromEnum PathNodeType
PathNodeTypeRelCurveTo = Int
34
    fromEnum (AnotherPathNodeType Int
k) = Int
k

    toEnum :: Int -> PathNodeType
toEnum Int
0 = PathNodeType
PathNodeTypeMoveTo
    toEnum Int
1 = PathNodeType
PathNodeTypeLineTo
    toEnum Int
2 = PathNodeType
PathNodeTypeCurveTo
    toEnum Int
3 = PathNodeType
PathNodeTypeClose
    toEnum Int
32 = PathNodeType
PathNodeTypeRelMoveTo
    toEnum Int
33 = PathNodeType
PathNodeTypeRelLineTo
    toEnum Int
34 = PathNodeType
PathNodeTypeRelCurveTo
    toEnum Int
k = Int -> PathNodeType
AnotherPathNodeType Int
k

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

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

foreign import ccall "clutter_path_node_type_get_type" c_clutter_path_node_type_get_type :: 
    IO GType

instance B.Types.TypedObject PathNodeType where
    glibType :: IO GType
glibType = IO GType
c_clutter_path_node_type_get_type

instance B.Types.BoxedEnum PathNodeType

-- Enum PanAxis
-- | The axis of the constraint that should be applied on the
-- panning action
-- 
-- /Since: 1.12/
data PanAxis = 
      PanAxisAxisNone
    -- ^ No constraint
    | PanAxisXAxis
    -- ^ Set a constraint on the X axis
    | PanAxisYAxis
    -- ^ Set a constraint on the Y axis
    | PanAxisAxisAuto
    -- ^ Constrain panning automatically based on initial
    --   movement (available since 1.24)
    | AnotherPanAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PanAxis -> ShowS
[PanAxis] -> ShowS
PanAxis -> String
(Int -> PanAxis -> ShowS)
-> (PanAxis -> String) -> ([PanAxis] -> ShowS) -> Show PanAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PanAxis -> ShowS
showsPrec :: Int -> PanAxis -> ShowS
$cshow :: PanAxis -> String
show :: PanAxis -> String
$cshowList :: [PanAxis] -> ShowS
showList :: [PanAxis] -> ShowS
Show, PanAxis -> PanAxis -> Bool
(PanAxis -> PanAxis -> Bool)
-> (PanAxis -> PanAxis -> Bool) -> Eq PanAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PanAxis -> PanAxis -> Bool
== :: PanAxis -> PanAxis -> Bool
$c/= :: PanAxis -> PanAxis -> Bool
/= :: PanAxis -> PanAxis -> Bool
Eq)

instance P.Enum PanAxis where
    fromEnum :: PanAxis -> Int
fromEnum PanAxis
PanAxisAxisNone = Int
0
    fromEnum PanAxis
PanAxisXAxis = Int
1
    fromEnum PanAxis
PanAxisYAxis = Int
2
    fromEnum PanAxis
PanAxisAxisAuto = Int
3
    fromEnum (AnotherPanAxis Int
k) = Int
k

    toEnum :: Int -> PanAxis
toEnum Int
0 = PanAxis
PanAxisAxisNone
    toEnum Int
1 = PanAxis
PanAxisXAxis
    toEnum Int
2 = PanAxis
PanAxisYAxis
    toEnum Int
3 = PanAxis
PanAxisAxisAuto
    toEnum Int
k = Int -> PanAxis
AnotherPanAxis Int
k

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

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

foreign import ccall "clutter_pan_axis_get_type" c_clutter_pan_axis_get_type :: 
    IO GType

instance B.Types.TypedObject PanAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_pan_axis_get_type

instance B.Types.BoxedEnum PanAxis

-- Enum Orientation
-- | Represents the orientation of actors or layout managers.
-- 
-- /Since: 1.12/
data Orientation = 
      OrientationHorizontal
    -- ^ An horizontal orientation
    | OrientationVertical
    -- ^ A vertical orientation
    | AnotherOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Orientation -> ShowS
[Orientation] -> ShowS
Orientation -> String
(Int -> Orientation -> ShowS)
-> (Orientation -> String)
-> ([Orientation] -> ShowS)
-> Show Orientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Orientation -> ShowS
showsPrec :: Int -> Orientation -> ShowS
$cshow :: Orientation -> String
show :: Orientation -> String
$cshowList :: [Orientation] -> ShowS
showList :: [Orientation] -> ShowS
Show, Orientation -> Orientation -> Bool
(Orientation -> Orientation -> Bool)
-> (Orientation -> Orientation -> Bool) -> Eq Orientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Orientation -> Orientation -> Bool
== :: Orientation -> Orientation -> Bool
$c/= :: Orientation -> Orientation -> Bool
/= :: Orientation -> Orientation -> Bool
Eq)

instance P.Enum Orientation where
    fromEnum :: Orientation -> Int
fromEnum Orientation
OrientationHorizontal = Int
0
    fromEnum Orientation
OrientationVertical = Int
1
    fromEnum (AnotherOrientation Int
k) = Int
k

    toEnum :: Int -> Orientation
toEnum Int
0 = Orientation
OrientationHorizontal
    toEnum Int
1 = Orientation
OrientationVertical
    toEnum Int
k = Int -> Orientation
AnotherOrientation Int
k

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

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

foreign import ccall "clutter_orientation_get_type" c_clutter_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject Orientation where
    glibType :: IO GType
glibType = IO GType
c_clutter_orientation_get_type

instance B.Types.BoxedEnum Orientation

-- Enum LongPressState
-- | The states for the [ClickAction::longPress]("GI.Clutter.Objects.ClickAction#g:signal:longPress") signal.
-- 
-- /Since: 1.8/
data LongPressState = 
      LongPressStateQuery
    -- ^ Queries the action whether it supports
    --   long presses
    | LongPressStateActivate
    -- ^ Activates the action on a long press
    | LongPressStateCancel
    -- ^ The long press was cancelled
    | AnotherLongPressState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LongPressState -> ShowS
[LongPressState] -> ShowS
LongPressState -> String
(Int -> LongPressState -> ShowS)
-> (LongPressState -> String)
-> ([LongPressState] -> ShowS)
-> Show LongPressState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LongPressState -> ShowS
showsPrec :: Int -> LongPressState -> ShowS
$cshow :: LongPressState -> String
show :: LongPressState -> String
$cshowList :: [LongPressState] -> ShowS
showList :: [LongPressState] -> ShowS
Show, LongPressState -> LongPressState -> Bool
(LongPressState -> LongPressState -> Bool)
-> (LongPressState -> LongPressState -> Bool) -> Eq LongPressState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LongPressState -> LongPressState -> Bool
== :: LongPressState -> LongPressState -> Bool
$c/= :: LongPressState -> LongPressState -> Bool
/= :: LongPressState -> LongPressState -> Bool
Eq)

instance P.Enum LongPressState where
    fromEnum :: LongPressState -> Int
fromEnum LongPressState
LongPressStateQuery = Int
0
    fromEnum LongPressState
LongPressStateActivate = Int
1
    fromEnum LongPressState
LongPressStateCancel = Int
2
    fromEnum (AnotherLongPressState Int
k) = Int
k

    toEnum :: Int -> LongPressState
toEnum Int
0 = LongPressState
LongPressStateQuery
    toEnum Int
1 = LongPressState
LongPressStateActivate
    toEnum Int
2 = LongPressState
LongPressStateCancel
    toEnum Int
k = Int -> LongPressState
AnotherLongPressState Int
k

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

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

foreign import ccall "clutter_long_press_state_get_type" c_clutter_long_press_state_get_type :: 
    IO GType

instance B.Types.TypedObject LongPressState where
    glibType :: IO GType
glibType = IO GType
c_clutter_long_press_state_get_type

instance B.Types.BoxedEnum LongPressState

-- Enum Interpolation
{-# DEPRECATED Interpolation ["(Since version 1.22)"] #-}
-- | The mode of interpolation between key frames
-- 
-- /Since: 1.2/
data Interpolation = 
      InterpolationLinear
    -- ^ linear interpolation
    | InterpolationCubic
    -- ^ cubic interpolation
    | AnotherInterpolation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Interpolation -> ShowS
[Interpolation] -> ShowS
Interpolation -> String
(Int -> Interpolation -> ShowS)
-> (Interpolation -> String)
-> ([Interpolation] -> ShowS)
-> Show Interpolation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Interpolation -> ShowS
showsPrec :: Int -> Interpolation -> ShowS
$cshow :: Interpolation -> String
show :: Interpolation -> String
$cshowList :: [Interpolation] -> ShowS
showList :: [Interpolation] -> ShowS
Show, Interpolation -> Interpolation -> Bool
(Interpolation -> Interpolation -> Bool)
-> (Interpolation -> Interpolation -> Bool) -> Eq Interpolation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Interpolation -> Interpolation -> Bool
== :: Interpolation -> Interpolation -> Bool
$c/= :: Interpolation -> Interpolation -> Bool
/= :: Interpolation -> Interpolation -> Bool
Eq)

instance P.Enum Interpolation where
    fromEnum :: Interpolation -> Int
fromEnum Interpolation
InterpolationLinear = Int
0
    fromEnum Interpolation
InterpolationCubic = Int
1
    fromEnum (AnotherInterpolation Int
k) = Int
k

    toEnum :: Int -> Interpolation
toEnum Int
0 = Interpolation
InterpolationLinear
    toEnum Int
1 = Interpolation
InterpolationCubic
    toEnum Int
k = Int -> Interpolation
AnotherInterpolation Int
k

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

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

foreign import ccall "clutter_interpolation_get_type" c_clutter_interpolation_get_type :: 
    IO GType

instance B.Types.TypedObject Interpolation where
    glibType :: IO GType
glibType = IO GType
c_clutter_interpolation_get_type

instance B.Types.BoxedEnum Interpolation

-- Enum InputMode
-- | The mode for input devices available.
-- 
-- /Since: 1.6/
data InputMode = 
      InputModeMaster
    -- ^ A master, virtual device
    | InputModeSlave
    -- ^ A slave, physical device, attached to
    --   a master device
    | InputModeFloating
    -- ^ A slave, physical device, not attached
    --   to a master device
    | AnotherInputMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputMode -> ShowS
[InputMode] -> ShowS
InputMode -> String
(Int -> InputMode -> ShowS)
-> (InputMode -> String)
-> ([InputMode] -> ShowS)
-> Show InputMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputMode -> ShowS
showsPrec :: Int -> InputMode -> ShowS
$cshow :: InputMode -> String
show :: InputMode -> String
$cshowList :: [InputMode] -> ShowS
showList :: [InputMode] -> ShowS
Show, InputMode -> InputMode -> Bool
(InputMode -> InputMode -> Bool)
-> (InputMode -> InputMode -> Bool) -> Eq InputMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputMode -> InputMode -> Bool
== :: InputMode -> InputMode -> Bool
$c/= :: InputMode -> InputMode -> Bool
/= :: InputMode -> InputMode -> Bool
Eq)

instance P.Enum InputMode where
    fromEnum :: InputMode -> Int
fromEnum InputMode
InputModeMaster = Int
0
    fromEnum InputMode
InputModeSlave = Int
1
    fromEnum InputMode
InputModeFloating = Int
2
    fromEnum (AnotherInputMode Int
k) = Int
k

    toEnum :: Int -> InputMode
toEnum Int
0 = InputMode
InputModeMaster
    toEnum Int
1 = InputMode
InputModeSlave
    toEnum Int
2 = InputMode
InputModeFloating
    toEnum Int
k = Int -> InputMode
AnotherInputMode Int
k

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

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

foreign import ccall "clutter_input_mode_get_type" c_clutter_input_mode_get_type :: 
    IO GType

instance B.Types.TypedObject InputMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_input_mode_get_type

instance B.Types.BoxedEnum InputMode

-- Enum InputDeviceType
-- | The types of input devices available.
-- 
-- The t'GI.Clutter.Enums.InputDeviceType' enumeration can be extended at later
-- date; not every platform supports every input device type.
-- 
-- /Since: 1.0/
data InputDeviceType = 
      InputDeviceTypePointerDevice
    -- ^ A pointer device
    | InputDeviceTypeKeyboardDevice
    -- ^ A keyboard device
    | InputDeviceTypeExtensionDevice
    -- ^ A generic extension device
    | InputDeviceTypeJoystickDevice
    -- ^ A joystick device
    | InputDeviceTypeTabletDevice
    -- ^ A tablet device
    | InputDeviceTypeTouchpadDevice
    -- ^ A touchpad device
    | InputDeviceTypeTouchscreenDevice
    -- ^ A touch screen device
    | InputDeviceTypePenDevice
    -- ^ A pen device
    | InputDeviceTypeEraserDevice
    -- ^ An eraser device
    | InputDeviceTypeCursorDevice
    -- ^ A cursor device
    | InputDeviceTypeNDeviceTypes
    -- ^ The number of device types
    | AnotherInputDeviceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputDeviceType -> ShowS
[InputDeviceType] -> ShowS
InputDeviceType -> String
(Int -> InputDeviceType -> ShowS)
-> (InputDeviceType -> String)
-> ([InputDeviceType] -> ShowS)
-> Show InputDeviceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputDeviceType -> ShowS
showsPrec :: Int -> InputDeviceType -> ShowS
$cshow :: InputDeviceType -> String
show :: InputDeviceType -> String
$cshowList :: [InputDeviceType] -> ShowS
showList :: [InputDeviceType] -> ShowS
Show, InputDeviceType -> InputDeviceType -> Bool
(InputDeviceType -> InputDeviceType -> Bool)
-> (InputDeviceType -> InputDeviceType -> Bool)
-> Eq InputDeviceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputDeviceType -> InputDeviceType -> Bool
== :: InputDeviceType -> InputDeviceType -> Bool
$c/= :: InputDeviceType -> InputDeviceType -> Bool
/= :: InputDeviceType -> InputDeviceType -> Bool
Eq)

instance P.Enum InputDeviceType where
    fromEnum :: InputDeviceType -> Int
fromEnum InputDeviceType
InputDeviceTypePointerDevice = Int
0
    fromEnum InputDeviceType
InputDeviceTypeKeyboardDevice = Int
1
    fromEnum InputDeviceType
InputDeviceTypeExtensionDevice = Int
2
    fromEnum InputDeviceType
InputDeviceTypeJoystickDevice = Int
3
    fromEnum InputDeviceType
InputDeviceTypeTabletDevice = Int
4
    fromEnum InputDeviceType
InputDeviceTypeTouchpadDevice = Int
5
    fromEnum InputDeviceType
InputDeviceTypeTouchscreenDevice = Int
6
    fromEnum InputDeviceType
InputDeviceTypePenDevice = Int
7
    fromEnum InputDeviceType
InputDeviceTypeEraserDevice = Int
8
    fromEnum InputDeviceType
InputDeviceTypeCursorDevice = Int
9
    fromEnum InputDeviceType
InputDeviceTypeNDeviceTypes = Int
10
    fromEnum (AnotherInputDeviceType Int
k) = Int
k

    toEnum :: Int -> InputDeviceType
toEnum Int
0 = InputDeviceType
InputDeviceTypePointerDevice
    toEnum Int
1 = InputDeviceType
InputDeviceTypeKeyboardDevice
    toEnum Int
2 = InputDeviceType
InputDeviceTypeExtensionDevice
    toEnum Int
3 = InputDeviceType
InputDeviceTypeJoystickDevice
    toEnum Int
4 = InputDeviceType
InputDeviceTypeTabletDevice
    toEnum Int
5 = InputDeviceType
InputDeviceTypeTouchpadDevice
    toEnum Int
6 = InputDeviceType
InputDeviceTypeTouchscreenDevice
    toEnum Int
7 = InputDeviceType
InputDeviceTypePenDevice
    toEnum Int
8 = InputDeviceType
InputDeviceTypeEraserDevice
    toEnum Int
9 = InputDeviceType
InputDeviceTypeCursorDevice
    toEnum Int
10 = InputDeviceType
InputDeviceTypeNDeviceTypes
    toEnum Int
k = Int -> InputDeviceType
AnotherInputDeviceType Int
k

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

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

foreign import ccall "clutter_input_device_type_get_type" c_clutter_input_device_type_get_type :: 
    IO GType

instance B.Types.TypedObject InputDeviceType where
    glibType :: IO GType
glibType = IO GType
c_clutter_input_device_type_get_type

instance B.Types.BoxedEnum InputDeviceType

-- Enum InputAxis
-- | The type of axes Clutter recognizes on a t'GI.Clutter.Objects.InputDevice.InputDevice'
-- 
-- /Since: 1.6/
data InputAxis = 
      InputAxisIgnore
    -- ^ Unused axis
    | InputAxisX
    -- ^ The position on the X axis
    | InputAxisY
    -- ^ The position of the Y axis
    | InputAxisPressure
    -- ^ The pressure information
    | InputAxisXtilt
    -- ^ The tilt on the X axis
    | InputAxisYtilt
    -- ^ The tile on the Y axis
    | InputAxisWheel
    -- ^ A wheel
    | InputAxisDistance
    -- ^ Distance (Since 1.12)
    | InputAxisLast
    -- ^ Last value of the enumeration; this value is
    --   useful when iterating over the enumeration values (Since 1.12)
    | AnotherInputAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputAxis -> ShowS
[InputAxis] -> ShowS
InputAxis -> String
(Int -> InputAxis -> ShowS)
-> (InputAxis -> String)
-> ([InputAxis] -> ShowS)
-> Show InputAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputAxis -> ShowS
showsPrec :: Int -> InputAxis -> ShowS
$cshow :: InputAxis -> String
show :: InputAxis -> String
$cshowList :: [InputAxis] -> ShowS
showList :: [InputAxis] -> ShowS
Show, InputAxis -> InputAxis -> Bool
(InputAxis -> InputAxis -> Bool)
-> (InputAxis -> InputAxis -> Bool) -> Eq InputAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputAxis -> InputAxis -> Bool
== :: InputAxis -> InputAxis -> Bool
$c/= :: InputAxis -> InputAxis -> Bool
/= :: InputAxis -> InputAxis -> Bool
Eq)

instance P.Enum InputAxis where
    fromEnum :: InputAxis -> Int
fromEnum InputAxis
InputAxisIgnore = Int
0
    fromEnum InputAxis
InputAxisX = Int
1
    fromEnum InputAxis
InputAxisY = Int
2
    fromEnum InputAxis
InputAxisPressure = Int
3
    fromEnum InputAxis
InputAxisXtilt = Int
4
    fromEnum InputAxis
InputAxisYtilt = Int
5
    fromEnum InputAxis
InputAxisWheel = Int
6
    fromEnum InputAxis
InputAxisDistance = Int
7
    fromEnum InputAxis
InputAxisLast = Int
8
    fromEnum (AnotherInputAxis Int
k) = Int
k

    toEnum :: Int -> InputAxis
toEnum Int
0 = InputAxis
InputAxisIgnore
    toEnum Int
1 = InputAxis
InputAxisX
    toEnum Int
2 = InputAxis
InputAxisY
    toEnum Int
3 = InputAxis
InputAxisPressure
    toEnum Int
4 = InputAxis
InputAxisXtilt
    toEnum Int
5 = InputAxis
InputAxisYtilt
    toEnum Int
6 = InputAxis
InputAxisWheel
    toEnum Int
7 = InputAxis
InputAxisDistance
    toEnum Int
8 = InputAxis
InputAxisLast
    toEnum Int
k = Int -> InputAxis
AnotherInputAxis Int
k

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

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

foreign import ccall "clutter_input_axis_get_type" c_clutter_input_axis_get_type :: 
    IO GType

instance B.Types.TypedObject InputAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_input_axis_get_type

instance B.Types.BoxedEnum InputAxis

-- Enum InitError
-- | Error conditions returned by 'GI.Clutter.Functions.init' and 'GI.Clutter.Functions.initWithArgs'.
-- 
-- /Since: 0.2/
data InitError = 
      InitErrorSuccess
    -- ^ Initialisation successful
    | InitErrorErrorUnknown
    -- ^ Unknown error
    | InitErrorErrorThreads
    -- ^ Thread initialisation failed
    | InitErrorErrorBackend
    -- ^ Backend initialisation failed
    | InitErrorErrorInternal
    -- ^ Internal error
    | AnotherInitError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InitError -> ShowS
[InitError] -> ShowS
InitError -> String
(Int -> InitError -> ShowS)
-> (InitError -> String)
-> ([InitError] -> ShowS)
-> Show InitError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InitError -> ShowS
showsPrec :: Int -> InitError -> ShowS
$cshow :: InitError -> String
show :: InitError -> String
$cshowList :: [InitError] -> ShowS
showList :: [InitError] -> ShowS
Show, InitError -> InitError -> Bool
(InitError -> InitError -> Bool)
-> (InitError -> InitError -> Bool) -> Eq InitError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitError -> InitError -> Bool
== :: InitError -> InitError -> Bool
$c/= :: InitError -> InitError -> Bool
/= :: InitError -> InitError -> Bool
Eq)

instance P.Enum InitError where
    fromEnum :: InitError -> Int
fromEnum InitError
InitErrorSuccess = Int
1
    fromEnum InitError
InitErrorErrorUnknown = Int
0
    fromEnum InitError
InitErrorErrorThreads = Int
-1
    fromEnum InitError
InitErrorErrorBackend = Int
-2
    fromEnum InitError
InitErrorErrorInternal = Int
-3
    fromEnum (AnotherInitError Int
k) = Int
k

    toEnum :: Int -> InitError
toEnum Int
1 = InitError
InitErrorSuccess
    toEnum Int
0 = InitError
InitErrorErrorUnknown
    toEnum Int
-1 = InitError
InitErrorErrorThreads
    toEnum Int
-2 = InitError
InitErrorErrorBackend
    toEnum Int
-3 = InitError
InitErrorErrorInternal
    toEnum Int
k = Int -> InitError
AnotherInitError Int
k

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

instance GErrorClass InitError where
    gerrorClassDomain :: InitError -> Text
gerrorClassDomain InitError
_ = Text
"clutter-init-error-quark"

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

-- | Handle exceptions of type `InitError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleInitError ::
    (InitError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleInitError :: forall a. (InitError -> Text -> IO a) -> IO a -> IO a
handleInitError = (InitError -> 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 InitError = '[]
instance O.HasParentTypes InitError

foreign import ccall "clutter_init_error_get_type" c_clutter_init_error_get_type :: 
    IO GType

instance B.Types.TypedObject InitError where
    glibType :: IO GType
glibType = IO GType
c_clutter_init_error_get_type

instance B.Types.BoxedEnum InitError

-- Enum ImageError
-- | Error enumeration for t'GI.Clutter.Objects.Image.Image'.
-- 
-- /Since: 1.10/
data ImageError = 
      ImageErrorData
    -- ^ Invalid data passed to the
    --   'GI.Clutter.Objects.Image.imageSetData' function.
    | AnotherImageError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ImageError -> ShowS
[ImageError] -> ShowS
ImageError -> String
(Int -> ImageError -> ShowS)
-> (ImageError -> String)
-> ([ImageError] -> ShowS)
-> Show ImageError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImageError -> ShowS
showsPrec :: Int -> ImageError -> ShowS
$cshow :: ImageError -> String
show :: ImageError -> String
$cshowList :: [ImageError] -> ShowS
showList :: [ImageError] -> ShowS
Show, ImageError -> ImageError -> Bool
(ImageError -> ImageError -> Bool)
-> (ImageError -> ImageError -> Bool) -> Eq ImageError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageError -> ImageError -> Bool
== :: ImageError -> ImageError -> Bool
$c/= :: ImageError -> ImageError -> Bool
/= :: ImageError -> ImageError -> Bool
Eq)

instance P.Enum ImageError where
    fromEnum :: ImageError -> Int
fromEnum ImageError
ImageErrorData = Int
0
    fromEnum (AnotherImageError Int
k) = Int
k

    toEnum :: Int -> ImageError
toEnum Int
0 = ImageError
ImageErrorData
    toEnum Int
k = Int -> ImageError
AnotherImageError Int
k

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

instance GErrorClass ImageError where
    gerrorClassDomain :: ImageError -> Text
gerrorClassDomain ImageError
_ = Text
"clutter-image-error-quark"

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

-- | Handle exceptions of type `ImageError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleImageError ::
    (ImageError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleImageError :: forall a. (ImageError -> Text -> IO a) -> IO a -> IO a
handleImageError = (ImageError -> 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 ImageError = '[]
instance O.HasParentTypes ImageError

foreign import ccall "clutter_image_error_get_type" c_clutter_image_error_get_type :: 
    IO GType

instance B.Types.TypedObject ImageError where
    glibType :: IO GType
glibType = IO GType
c_clutter_image_error_get_type

instance B.Types.BoxedEnum ImageError

-- Enum GridPosition
-- | Grid position modes.
-- 
-- /Since: 1.12/
data GridPosition = 
      GridPositionLeft
    -- ^ left position
    | GridPositionRight
    -- ^ right position
    | GridPositionTop
    -- ^ top position
    | GridPositionBottom
    -- ^ bottom position
    | AnotherGridPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GridPosition -> ShowS
[GridPosition] -> ShowS
GridPosition -> String
(Int -> GridPosition -> ShowS)
-> (GridPosition -> String)
-> ([GridPosition] -> ShowS)
-> Show GridPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GridPosition -> ShowS
showsPrec :: Int -> GridPosition -> ShowS
$cshow :: GridPosition -> String
show :: GridPosition -> String
$cshowList :: [GridPosition] -> ShowS
showList :: [GridPosition] -> ShowS
Show, GridPosition -> GridPosition -> Bool
(GridPosition -> GridPosition -> Bool)
-> (GridPosition -> GridPosition -> Bool) -> Eq GridPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GridPosition -> GridPosition -> Bool
== :: GridPosition -> GridPosition -> Bool
$c/= :: GridPosition -> GridPosition -> Bool
/= :: GridPosition -> GridPosition -> Bool
Eq)

instance P.Enum GridPosition where
    fromEnum :: GridPosition -> Int
fromEnum GridPosition
GridPositionLeft = Int
0
    fromEnum GridPosition
GridPositionRight = Int
1
    fromEnum GridPosition
GridPositionTop = Int
2
    fromEnum GridPosition
GridPositionBottom = Int
3
    fromEnum (AnotherGridPosition Int
k) = Int
k

    toEnum :: Int -> GridPosition
toEnum Int
0 = GridPosition
GridPositionLeft
    toEnum Int
1 = GridPosition
GridPositionRight
    toEnum Int
2 = GridPosition
GridPositionTop
    toEnum Int
3 = GridPosition
GridPositionBottom
    toEnum Int
k = Int -> GridPosition
AnotherGridPosition Int
k

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

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

foreign import ccall "clutter_grid_position_get_type" c_clutter_grid_position_get_type :: 
    IO GType

instance B.Types.TypedObject GridPosition where
    glibType :: IO GType
glibType = IO GType
c_clutter_grid_position_get_type

instance B.Types.BoxedEnum GridPosition

-- Enum Gravity
{-# DEPRECATED Gravity ["(Since version 1.22)","Use the normalized t'GI.Clutter.Objects.Actor.Actor' pivot point instead"] #-}
-- | Gravity of the scaling operations. When a gravity different than
-- 'GI.Clutter.Enums.GravityNone' is used, an actor is scaled keeping the position
-- of the specified portion at the same coordinates.
-- 
-- /Since: 0.2/
data Gravity = 
      GravityNone
    -- ^ Do not apply any gravity
    | GravityNorth
    -- ^ Scale from topmost downwards
    | GravityNorthEast
    -- ^ Scale from the top right corner
    | GravityEast
    -- ^ Scale from the right side
    | GravitySouthEast
    -- ^ Scale from the bottom right corner
    | GravitySouth
    -- ^ Scale from the bottom upwards
    | GravitySouthWest
    -- ^ Scale from the bottom left corner
    | GravityWest
    -- ^ Scale from the left side
    | GravityNorthWest
    -- ^ Scale from the top left corner
    | GravityCenter
    -- ^ Scale from the center.
    | AnotherGravity Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Gravity -> ShowS
[Gravity] -> ShowS
Gravity -> String
(Int -> Gravity -> ShowS)
-> (Gravity -> String) -> ([Gravity] -> ShowS) -> Show Gravity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Gravity -> ShowS
showsPrec :: Int -> Gravity -> ShowS
$cshow :: Gravity -> String
show :: Gravity -> String
$cshowList :: [Gravity] -> ShowS
showList :: [Gravity] -> ShowS
Show, Gravity -> Gravity -> Bool
(Gravity -> Gravity -> Bool)
-> (Gravity -> Gravity -> Bool) -> Eq Gravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Gravity -> Gravity -> Bool
== :: Gravity -> Gravity -> Bool
$c/= :: Gravity -> Gravity -> Bool
/= :: Gravity -> Gravity -> Bool
Eq)

instance P.Enum Gravity where
    fromEnum :: Gravity -> Int
fromEnum Gravity
GravityNone = Int
0
    fromEnum Gravity
GravityNorth = Int
1
    fromEnum Gravity
GravityNorthEast = Int
2
    fromEnum Gravity
GravityEast = Int
3
    fromEnum Gravity
GravitySouthEast = Int
4
    fromEnum Gravity
GravitySouth = Int
5
    fromEnum Gravity
GravitySouthWest = Int
6
    fromEnum Gravity
GravityWest = Int
7
    fromEnum Gravity
GravityNorthWest = Int
8
    fromEnum Gravity
GravityCenter = Int
9
    fromEnum (AnotherGravity Int
k) = Int
k

    toEnum :: Int -> Gravity
toEnum Int
0 = Gravity
GravityNone
    toEnum Int
1 = Gravity
GravityNorth
    toEnum Int
2 = Gravity
GravityNorthEast
    toEnum Int
3 = Gravity
GravityEast
    toEnum Int
4 = Gravity
GravitySouthEast
    toEnum Int
5 = Gravity
GravitySouth
    toEnum Int
6 = Gravity
GravitySouthWest
    toEnum Int
7 = Gravity
GravityWest
    toEnum Int
8 = Gravity
GravityNorthWest
    toEnum Int
9 = Gravity
GravityCenter
    toEnum Int
k = Int -> Gravity
AnotherGravity Int
k

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

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

foreign import ccall "clutter_gravity_get_type" c_clutter_gravity_get_type :: 
    IO GType

instance B.Types.TypedObject Gravity where
    glibType :: IO GType
glibType = IO GType
c_clutter_gravity_get_type

instance B.Types.BoxedEnum Gravity

-- Enum GestureTriggerEdge
-- | Enum passed to the 'GI.Clutter.Objects.GestureAction.gestureActionSetThresholdTriggerEdge'
-- function.
-- 
-- /Since: 1.18/
data GestureTriggerEdge = 
      GestureTriggerEdgeNone
    -- ^ Tell t'GI.Clutter.Objects.GestureAction.GestureAction' that
    -- the gesture must begin immediately and there\'s no drag limit that
    -- will cause its cancellation;
    | GestureTriggerEdgeAfter
    -- ^ Tell t'GI.Clutter.Objects.GestureAction.GestureAction' that
    -- it needs to wait until the drag threshold has been exceeded before
    -- considering that the gesture has begun;
    | GestureTriggerEdgeBefore
    -- ^ Tell t'GI.Clutter.Objects.GestureAction.GestureAction' that
    -- the gesture must begin immediately and that it must be cancelled
    -- once the drag exceed the configured threshold.
    | AnotherGestureTriggerEdge Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GestureTriggerEdge -> ShowS
[GestureTriggerEdge] -> ShowS
GestureTriggerEdge -> String
(Int -> GestureTriggerEdge -> ShowS)
-> (GestureTriggerEdge -> String)
-> ([GestureTriggerEdge] -> ShowS)
-> Show GestureTriggerEdge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GestureTriggerEdge -> ShowS
showsPrec :: Int -> GestureTriggerEdge -> ShowS
$cshow :: GestureTriggerEdge -> String
show :: GestureTriggerEdge -> String
$cshowList :: [GestureTriggerEdge] -> ShowS
showList :: [GestureTriggerEdge] -> ShowS
Show, GestureTriggerEdge -> GestureTriggerEdge -> Bool
(GestureTriggerEdge -> GestureTriggerEdge -> Bool)
-> (GestureTriggerEdge -> GestureTriggerEdge -> Bool)
-> Eq GestureTriggerEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GestureTriggerEdge -> GestureTriggerEdge -> Bool
== :: GestureTriggerEdge -> GestureTriggerEdge -> Bool
$c/= :: GestureTriggerEdge -> GestureTriggerEdge -> Bool
/= :: GestureTriggerEdge -> GestureTriggerEdge -> Bool
Eq)

instance P.Enum GestureTriggerEdge where
    fromEnum :: GestureTriggerEdge -> Int
fromEnum GestureTriggerEdge
GestureTriggerEdgeNone = Int
0
    fromEnum GestureTriggerEdge
GestureTriggerEdgeAfter = Int
1
    fromEnum GestureTriggerEdge
GestureTriggerEdgeBefore = Int
2
    fromEnum (AnotherGestureTriggerEdge Int
k) = Int
k

    toEnum :: Int -> GestureTriggerEdge
toEnum Int
0 = GestureTriggerEdge
GestureTriggerEdgeNone
    toEnum Int
1 = GestureTriggerEdge
GestureTriggerEdgeAfter
    toEnum Int
2 = GestureTriggerEdge
GestureTriggerEdgeBefore
    toEnum Int
k = Int -> GestureTriggerEdge
AnotherGestureTriggerEdge Int
k

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

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

foreign import ccall "clutter_gesture_trigger_edge_get_type" c_clutter_gesture_trigger_edge_get_type :: 
    IO GType

instance B.Types.TypedObject GestureTriggerEdge where
    glibType :: IO GType
glibType = IO GType
c_clutter_gesture_trigger_edge_get_type

instance B.Types.BoxedEnum GestureTriggerEdge

-- Enum FlowOrientation
-- | The direction of the arrangement of the children inside
-- a t'GI.Clutter.Objects.FlowLayout.FlowLayout'
-- 
-- /Since: 1.2/
data FlowOrientation = 
      FlowOrientationHorizontal
    -- ^ Arrange the children of the flow layout
    --   horizontally first
    | FlowOrientationVertical
    -- ^ Arrange the children of the flow layout
    --   vertically first
    | AnotherFlowOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FlowOrientation -> ShowS
[FlowOrientation] -> ShowS
FlowOrientation -> String
(Int -> FlowOrientation -> ShowS)
-> (FlowOrientation -> String)
-> ([FlowOrientation] -> ShowS)
-> Show FlowOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FlowOrientation -> ShowS
showsPrec :: Int -> FlowOrientation -> ShowS
$cshow :: FlowOrientation -> String
show :: FlowOrientation -> String
$cshowList :: [FlowOrientation] -> ShowS
showList :: [FlowOrientation] -> ShowS
Show, FlowOrientation -> FlowOrientation -> Bool
(FlowOrientation -> FlowOrientation -> Bool)
-> (FlowOrientation -> FlowOrientation -> Bool)
-> Eq FlowOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FlowOrientation -> FlowOrientation -> Bool
== :: FlowOrientation -> FlowOrientation -> Bool
$c/= :: FlowOrientation -> FlowOrientation -> Bool
/= :: FlowOrientation -> FlowOrientation -> Bool
Eq)

instance P.Enum FlowOrientation where
    fromEnum :: FlowOrientation -> Int
fromEnum FlowOrientation
FlowOrientationHorizontal = Int
0
    fromEnum FlowOrientation
FlowOrientationVertical = Int
1
    fromEnum (AnotherFlowOrientation Int
k) = Int
k

    toEnum :: Int -> FlowOrientation
toEnum Int
0 = FlowOrientation
FlowOrientationHorizontal
    toEnum Int
1 = FlowOrientation
FlowOrientationVertical
    toEnum Int
k = Int -> FlowOrientation
AnotherFlowOrientation Int
k

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

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

foreign import ccall "clutter_flow_orientation_get_type" c_clutter_flow_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject FlowOrientation where
    glibType :: IO GType
glibType = IO GType
c_clutter_flow_orientation_get_type

instance B.Types.BoxedEnum FlowOrientation

-- Enum EventType
-- | Types of events.
-- 
-- /Since: 0.4/
data EventType = 
      EventTypeNothing
    -- ^ Empty event
    | EventTypeKeyPress
    -- ^ Key press event
    | EventTypeKeyRelease
    -- ^ Key release event
    | EventTypeMotion
    -- ^ Pointer motion event
    | EventTypeEnter
    -- ^ Actor enter event
    | EventTypeLeave
    -- ^ Actor leave event
    | EventTypeButtonPress
    -- ^ Pointer button press event
    | EventTypeButtonRelease
    -- ^ Pointer button release event
    | EventTypeScroll
    -- ^ Pointer scroll event
    | EventTypeStageState
    -- ^ Stage state change event
    | EventTypeDestroyNotify
    -- ^ Destroy notification event
    | EventTypeClientMessage
    -- ^ Client message event
    | EventTypeDelete
    -- ^ Stage delete event
    | EventTypeTouchBegin
    -- ^ A new touch event sequence has started;
    --   event added in 1.10
    | EventTypeTouchUpdate
    -- ^ A touch event sequence has been updated;
    --   event added in 1.10
    | EventTypeTouchEnd
    -- ^ A touch event sequence has finished;
    --   event added in 1.10
    | EventTypeTouchCancel
    -- ^ A touch event sequence has been canceled;
    --   event added in 1.10
    | EventTypeTouchpadPinch
    -- ^ A pinch gesture event, the current state is
    --   determined by its phase field; event added in 1.24
    | EventTypeTouchpadSwipe
    -- ^ A swipe gesture event, the current state is
    --   determined by its phase field; event added in 1.24
    | EventTypeEventLast
    -- ^ Marks the end of the t'GI.Clutter.Enums.EventType' enumeration;
    --   added in 1.10
    | AnotherEventType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventType -> ShowS
[EventType] -> ShowS
EventType -> String
(Int -> EventType -> ShowS)
-> (EventType -> String)
-> ([EventType] -> ShowS)
-> Show EventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventType -> ShowS
showsPrec :: Int -> EventType -> ShowS
$cshow :: EventType -> String
show :: EventType -> String
$cshowList :: [EventType] -> ShowS
showList :: [EventType] -> ShowS
Show, EventType -> EventType -> Bool
(EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool) -> Eq EventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventType -> EventType -> Bool
== :: EventType -> EventType -> Bool
$c/= :: EventType -> EventType -> Bool
/= :: EventType -> EventType -> Bool
Eq)

instance P.Enum EventType where
    fromEnum :: EventType -> Int
fromEnum EventType
EventTypeNothing = Int
0
    fromEnum EventType
EventTypeKeyPress = Int
1
    fromEnum EventType
EventTypeKeyRelease = Int
2
    fromEnum EventType
EventTypeMotion = Int
3
    fromEnum EventType
EventTypeEnter = Int
4
    fromEnum EventType
EventTypeLeave = Int
5
    fromEnum EventType
EventTypeButtonPress = Int
6
    fromEnum EventType
EventTypeButtonRelease = Int
7
    fromEnum EventType
EventTypeScroll = Int
8
    fromEnum EventType
EventTypeStageState = Int
9
    fromEnum EventType
EventTypeDestroyNotify = Int
10
    fromEnum EventType
EventTypeClientMessage = Int
11
    fromEnum EventType
EventTypeDelete = Int
12
    fromEnum EventType
EventTypeTouchBegin = Int
13
    fromEnum EventType
EventTypeTouchUpdate = Int
14
    fromEnum EventType
EventTypeTouchEnd = Int
15
    fromEnum EventType
EventTypeTouchCancel = Int
16
    fromEnum EventType
EventTypeTouchpadPinch = Int
17
    fromEnum EventType
EventTypeTouchpadSwipe = Int
18
    fromEnum EventType
EventTypeEventLast = Int
19
    fromEnum (AnotherEventType Int
k) = Int
k

    toEnum :: Int -> EventType
toEnum Int
0 = EventType
EventTypeNothing
    toEnum Int
1 = EventType
EventTypeKeyPress
    toEnum Int
2 = EventType
EventTypeKeyRelease
    toEnum Int
3 = EventType
EventTypeMotion
    toEnum Int
4 = EventType
EventTypeEnter
    toEnum Int
5 = EventType
EventTypeLeave
    toEnum Int
6 = EventType
EventTypeButtonPress
    toEnum Int
7 = EventType
EventTypeButtonRelease
    toEnum Int
8 = EventType
EventTypeScroll
    toEnum Int
9 = EventType
EventTypeStageState
    toEnum Int
10 = EventType
EventTypeDestroyNotify
    toEnum Int
11 = EventType
EventTypeClientMessage
    toEnum Int
12 = EventType
EventTypeDelete
    toEnum Int
13 = EventType
EventTypeTouchBegin
    toEnum Int
14 = EventType
EventTypeTouchUpdate
    toEnum Int
15 = EventType
EventTypeTouchEnd
    toEnum Int
16 = EventType
EventTypeTouchCancel
    toEnum Int
17 = EventType
EventTypeTouchpadPinch
    toEnum Int
18 = EventType
EventTypeTouchpadSwipe
    toEnum Int
19 = EventType
EventTypeEventLast
    toEnum Int
k = Int -> EventType
AnotherEventType Int
k

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

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

foreign import ccall "clutter_event_type_get_type" c_clutter_event_type_get_type :: 
    IO GType

instance B.Types.TypedObject EventType where
    glibType :: IO GType
glibType = IO GType
c_clutter_event_type_get_type

instance B.Types.BoxedEnum EventType

-- Enum DragAxis
-- | The axis of the constraint that should be applied on the
-- dragging action
-- 
-- /Since: 1.4/
data DragAxis = 
      DragAxisAxisNone
    -- ^ No constraint
    | DragAxisXAxis
    -- ^ Set a constraint on the X axis
    | DragAxisYAxis
    -- ^ Set a constraint on the Y axis
    | AnotherDragAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DragAxis -> ShowS
[DragAxis] -> ShowS
DragAxis -> String
(Int -> DragAxis -> ShowS)
-> (DragAxis -> String) -> ([DragAxis] -> ShowS) -> Show DragAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DragAxis -> ShowS
showsPrec :: Int -> DragAxis -> ShowS
$cshow :: DragAxis -> String
show :: DragAxis -> String
$cshowList :: [DragAxis] -> ShowS
showList :: [DragAxis] -> ShowS
Show, DragAxis -> DragAxis -> Bool
(DragAxis -> DragAxis -> Bool)
-> (DragAxis -> DragAxis -> Bool) -> Eq DragAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DragAxis -> DragAxis -> Bool
== :: DragAxis -> DragAxis -> Bool
$c/= :: DragAxis -> DragAxis -> Bool
/= :: DragAxis -> DragAxis -> Bool
Eq)

instance P.Enum DragAxis where
    fromEnum :: DragAxis -> Int
fromEnum DragAxis
DragAxisAxisNone = Int
0
    fromEnum DragAxis
DragAxisXAxis = Int
1
    fromEnum DragAxis
DragAxisYAxis = Int
2
    fromEnum (AnotherDragAxis Int
k) = Int
k

    toEnum :: Int -> DragAxis
toEnum Int
0 = DragAxis
DragAxisAxisNone
    toEnum Int
1 = DragAxis
DragAxisXAxis
    toEnum Int
2 = DragAxis
DragAxisYAxis
    toEnum Int
k = Int -> DragAxis
AnotherDragAxis Int
k

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

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

foreign import ccall "clutter_drag_axis_get_type" c_clutter_drag_axis_get_type :: 
    IO GType

instance B.Types.TypedObject DragAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_drag_axis_get_type

instance B.Types.BoxedEnum DragAxis

-- Enum ContentGravity
-- | Controls the alignment of the t'GI.Clutter.Interfaces.Content.Content' inside a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
data ContentGravity = 
      ContentGravityTopLeft
    -- ^ Align the content to the top left corner
    | ContentGravityTop
    -- ^ Align the content to the top edge
    | ContentGravityTopRight
    -- ^ Align the content to the top right corner
    | ContentGravityLeft
    -- ^ Align the content to the left edge
    | ContentGravityCenter
    -- ^ Align the content to the center
    | ContentGravityRight
    -- ^ Align the content to the right edge
    | ContentGravityBottomLeft
    -- ^ Align the content to the bottom left corner
    | ContentGravityBottom
    -- ^ Align the content to the bottom edge
    | ContentGravityBottomRight
    -- ^ Align the content to the bottom right corner
    | ContentGravityResizeFill
    -- ^ Resize the content to fill the allocation
    | ContentGravityResizeAspect
    -- ^ Resize the content to remain within the
    --   allocation, while maintaining the aspect ratio
    | AnotherContentGravity Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ContentGravity -> ShowS
[ContentGravity] -> ShowS
ContentGravity -> String
(Int -> ContentGravity -> ShowS)
-> (ContentGravity -> String)
-> ([ContentGravity] -> ShowS)
-> Show ContentGravity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentGravity -> ShowS
showsPrec :: Int -> ContentGravity -> ShowS
$cshow :: ContentGravity -> String
show :: ContentGravity -> String
$cshowList :: [ContentGravity] -> ShowS
showList :: [ContentGravity] -> ShowS
Show, ContentGravity -> ContentGravity -> Bool
(ContentGravity -> ContentGravity -> Bool)
-> (ContentGravity -> ContentGravity -> Bool) -> Eq ContentGravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentGravity -> ContentGravity -> Bool
== :: ContentGravity -> ContentGravity -> Bool
$c/= :: ContentGravity -> ContentGravity -> Bool
/= :: ContentGravity -> ContentGravity -> Bool
Eq)

instance P.Enum ContentGravity where
    fromEnum :: ContentGravity -> Int
fromEnum ContentGravity
ContentGravityTopLeft = Int
0
    fromEnum ContentGravity
ContentGravityTop = Int
1
    fromEnum ContentGravity
ContentGravityTopRight = Int
2
    fromEnum ContentGravity
ContentGravityLeft = Int
3
    fromEnum ContentGravity
ContentGravityCenter = Int
4
    fromEnum ContentGravity
ContentGravityRight = Int
5
    fromEnum ContentGravity
ContentGravityBottomLeft = Int
6
    fromEnum ContentGravity
ContentGravityBottom = Int
7
    fromEnum ContentGravity
ContentGravityBottomRight = Int
8
    fromEnum ContentGravity
ContentGravityResizeFill = Int
9
    fromEnum ContentGravity
ContentGravityResizeAspect = Int
10
    fromEnum (AnotherContentGravity Int
k) = Int
k

    toEnum :: Int -> ContentGravity
toEnum Int
0 = ContentGravity
ContentGravityTopLeft
    toEnum Int
1 = ContentGravity
ContentGravityTop
    toEnum Int
2 = ContentGravity
ContentGravityTopRight
    toEnum Int
3 = ContentGravity
ContentGravityLeft
    toEnum Int
4 = ContentGravity
ContentGravityCenter
    toEnum Int
5 = ContentGravity
ContentGravityRight
    toEnum Int
6 = ContentGravity
ContentGravityBottomLeft
    toEnum Int
7 = ContentGravity
ContentGravityBottom
    toEnum Int
8 = ContentGravity
ContentGravityBottomRight
    toEnum Int
9 = ContentGravity
ContentGravityResizeFill
    toEnum Int
10 = ContentGravity
ContentGravityResizeAspect
    toEnum Int
k = Int -> ContentGravity
AnotherContentGravity Int
k

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

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

foreign import ccall "clutter_content_gravity_get_type" c_clutter_content_gravity_get_type :: 
    IO GType

instance B.Types.TypedObject ContentGravity where
    glibType :: IO GType
glibType = IO GType
c_clutter_content_gravity_get_type

instance B.Types.BoxedEnum ContentGravity

-- Enum BoxAlignment
-- | The alignment policies available on each axis of the t'GI.Clutter.Objects.BoxLayout.BoxLayout'
-- 
-- /Since: 1.2/
data BoxAlignment = 
      BoxAlignmentStart
    -- ^ Align the child to the top or to
    --   to the left, depending on the used axis
    | BoxAlignmentEnd
    -- ^ Align the child to the bottom or to
    --   the right, depending on the used axis
    | BoxAlignmentCenter
    -- ^ Align the child to the center
    | AnotherBoxAlignment Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BoxAlignment -> ShowS
[BoxAlignment] -> ShowS
BoxAlignment -> String
(Int -> BoxAlignment -> ShowS)
-> (BoxAlignment -> String)
-> ([BoxAlignment] -> ShowS)
-> Show BoxAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoxAlignment -> ShowS
showsPrec :: Int -> BoxAlignment -> ShowS
$cshow :: BoxAlignment -> String
show :: BoxAlignment -> String
$cshowList :: [BoxAlignment] -> ShowS
showList :: [BoxAlignment] -> ShowS
Show, BoxAlignment -> BoxAlignment -> Bool
(BoxAlignment -> BoxAlignment -> Bool)
-> (BoxAlignment -> BoxAlignment -> Bool) -> Eq BoxAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoxAlignment -> BoxAlignment -> Bool
== :: BoxAlignment -> BoxAlignment -> Bool
$c/= :: BoxAlignment -> BoxAlignment -> Bool
/= :: BoxAlignment -> BoxAlignment -> Bool
Eq)

instance P.Enum BoxAlignment where
    fromEnum :: BoxAlignment -> Int
fromEnum BoxAlignment
BoxAlignmentStart = Int
0
    fromEnum BoxAlignment
BoxAlignmentEnd = Int
1
    fromEnum BoxAlignment
BoxAlignmentCenter = Int
2
    fromEnum (AnotherBoxAlignment Int
k) = Int
k

    toEnum :: Int -> BoxAlignment
toEnum Int
0 = BoxAlignment
BoxAlignmentStart
    toEnum Int
1 = BoxAlignment
BoxAlignmentEnd
    toEnum Int
2 = BoxAlignment
BoxAlignmentCenter
    toEnum Int
k = Int -> BoxAlignment
AnotherBoxAlignment Int
k

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

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

foreign import ccall "clutter_box_alignment_get_type" c_clutter_box_alignment_get_type :: 
    IO GType

instance B.Types.TypedObject BoxAlignment where
    glibType :: IO GType
glibType = IO GType
c_clutter_box_alignment_get_type

instance B.Types.BoxedEnum BoxAlignment

-- Enum BindCoordinate
-- | Specifies which property should be used in a binding
-- 
-- /Since: 1.4/
data BindCoordinate = 
      BindCoordinateX
    -- ^ Bind the X coordinate
    | BindCoordinateY
    -- ^ Bind the Y coordinate
    | BindCoordinateWidth
    -- ^ Bind the width
    | BindCoordinateHeight
    -- ^ Bind the height
    | BindCoordinatePosition
    -- ^ Equivalent to to 'GI.Clutter.Enums.BindCoordinateX' and
    --   'GI.Clutter.Enums.BindCoordinateY' (added in Clutter 1.6)
    | BindCoordinateSize
    -- ^ Equivalent to 'GI.Clutter.Enums.BindCoordinateWidth' and
    --   'GI.Clutter.Enums.BindCoordinateHeight' (added in Clutter 1.6)
    | BindCoordinateAll
    -- ^ Equivalent to 'GI.Clutter.Enums.BindCoordinatePosition' and
    --   'GI.Clutter.Enums.BindCoordinateSize' (added in Clutter 1.10)
    | AnotherBindCoordinate Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BindCoordinate -> ShowS
[BindCoordinate] -> ShowS
BindCoordinate -> String
(Int -> BindCoordinate -> ShowS)
-> (BindCoordinate -> String)
-> ([BindCoordinate] -> ShowS)
-> Show BindCoordinate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BindCoordinate -> ShowS
showsPrec :: Int -> BindCoordinate -> ShowS
$cshow :: BindCoordinate -> String
show :: BindCoordinate -> String
$cshowList :: [BindCoordinate] -> ShowS
showList :: [BindCoordinate] -> ShowS
Show, BindCoordinate -> BindCoordinate -> Bool
(BindCoordinate -> BindCoordinate -> Bool)
-> (BindCoordinate -> BindCoordinate -> Bool) -> Eq BindCoordinate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BindCoordinate -> BindCoordinate -> Bool
== :: BindCoordinate -> BindCoordinate -> Bool
$c/= :: BindCoordinate -> BindCoordinate -> Bool
/= :: BindCoordinate -> BindCoordinate -> Bool
Eq)

instance P.Enum BindCoordinate where
    fromEnum :: BindCoordinate -> Int
fromEnum BindCoordinate
BindCoordinateX = Int
0
    fromEnum BindCoordinate
BindCoordinateY = Int
1
    fromEnum BindCoordinate
BindCoordinateWidth = Int
2
    fromEnum BindCoordinate
BindCoordinateHeight = Int
3
    fromEnum BindCoordinate
BindCoordinatePosition = Int
4
    fromEnum BindCoordinate
BindCoordinateSize = Int
5
    fromEnum BindCoordinate
BindCoordinateAll = Int
6
    fromEnum (AnotherBindCoordinate Int
k) = Int
k

    toEnum :: Int -> BindCoordinate
toEnum Int
0 = BindCoordinate
BindCoordinateX
    toEnum Int
1 = BindCoordinate
BindCoordinateY
    toEnum Int
2 = BindCoordinate
BindCoordinateWidth
    toEnum Int
3 = BindCoordinate
BindCoordinateHeight
    toEnum Int
4 = BindCoordinate
BindCoordinatePosition
    toEnum Int
5 = BindCoordinate
BindCoordinateSize
    toEnum Int
6 = BindCoordinate
BindCoordinateAll
    toEnum Int
k = Int -> BindCoordinate
AnotherBindCoordinate Int
k

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

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

foreign import ccall "clutter_bind_coordinate_get_type" c_clutter_bind_coordinate_get_type :: 
    IO GType

instance B.Types.TypedObject BindCoordinate where
    glibType :: IO GType
glibType = IO GType
c_clutter_bind_coordinate_get_type

instance B.Types.BoxedEnum BindCoordinate

-- Enum BinAlignment
{-# DEPRECATED BinAlignment ["(Since version 1.12)","Use t'GI.Clutter.Enums.ActorAlign' and the t'GI.Clutter.Objects.Actor.Actor'","  API instead"] #-}
-- | The alignment policies available on each axis for t'GI.Clutter.Objects.BinLayout.BinLayout'
-- 
-- /Since: 1.2/
data BinAlignment = 
      BinAlignmentFixed
    -- ^ Fixed position alignment; the
    --   t'GI.Clutter.Objects.BinLayout.BinLayout' will honour the fixed position provided
    --   by the actors themselves when allocating them
    | BinAlignmentFill
    -- ^ Fill the allocation size
    | BinAlignmentStart
    -- ^ Position the actors at the top
    --   or left side of the container, depending on the axis
    | BinAlignmentEnd
    -- ^ Position the actors at the bottom
    --   or right side of the container, depending on the axis
    | BinAlignmentCenter
    -- ^ Position the actors at the
    --   center of the container, depending on the axis
    | AnotherBinAlignment Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BinAlignment -> ShowS
[BinAlignment] -> ShowS
BinAlignment -> String
(Int -> BinAlignment -> ShowS)
-> (BinAlignment -> String)
-> ([BinAlignment] -> ShowS)
-> Show BinAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BinAlignment -> ShowS
showsPrec :: Int -> BinAlignment -> ShowS
$cshow :: BinAlignment -> String
show :: BinAlignment -> String
$cshowList :: [BinAlignment] -> ShowS
showList :: [BinAlignment] -> ShowS
Show, BinAlignment -> BinAlignment -> Bool
(BinAlignment -> BinAlignment -> Bool)
-> (BinAlignment -> BinAlignment -> Bool) -> Eq BinAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinAlignment -> BinAlignment -> Bool
== :: BinAlignment -> BinAlignment -> Bool
$c/= :: BinAlignment -> BinAlignment -> Bool
/= :: BinAlignment -> BinAlignment -> Bool
Eq)

instance P.Enum BinAlignment where
    fromEnum :: BinAlignment -> Int
fromEnum BinAlignment
BinAlignmentFixed = Int
0
    fromEnum BinAlignment
BinAlignmentFill = Int
1
    fromEnum BinAlignment
BinAlignmentStart = Int
2
    fromEnum BinAlignment
BinAlignmentEnd = Int
3
    fromEnum BinAlignment
BinAlignmentCenter = Int
4
    fromEnum (AnotherBinAlignment Int
k) = Int
k

    toEnum :: Int -> BinAlignment
toEnum Int
0 = BinAlignment
BinAlignmentFixed
    toEnum Int
1 = BinAlignment
BinAlignmentFill
    toEnum Int
2 = BinAlignment
BinAlignmentStart
    toEnum Int
3 = BinAlignment
BinAlignmentEnd
    toEnum Int
4 = BinAlignment
BinAlignmentCenter
    toEnum Int
k = Int -> BinAlignment
AnotherBinAlignment Int
k

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

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

foreign import ccall "clutter_bin_alignment_get_type" c_clutter_bin_alignment_get_type :: 
    IO GType

instance B.Types.TypedObject BinAlignment where
    glibType :: IO GType
glibType = IO GType
c_clutter_bin_alignment_get_type

instance B.Types.BoxedEnum BinAlignment

-- Enum AnimationMode
-- | The animation modes used by t'GI.Clutter.Objects.Alpha.Alpha' and t'GI.Clutter.Objects.Animation.Animation'. This
-- enumeration can be expanded in later versions of Clutter.
-- 
-- \<figure id=\"easing-modes\">
--   \<title>Easing modes provided by Clutter\<\/title>
--   \<graphic fileref=\"easing-modes.png\" format=\"PNG\"\/>
-- \<\/figure>
-- 
-- Every global alpha function registered using @/clutter_alpha_register_func()/@
-- or 'GI.Clutter.Objects.Alpha.alphaRegisterFunc' will have a logical id greater than
-- 'GI.Clutter.Enums.AnimationModeAnimationLast'.
-- 
-- /Since: 1.0/
data AnimationMode = 
      AnimationModeCustomMode
    -- ^ custom progress function
    | AnimationModeLinear
    -- ^ linear tweening
    | AnimationModeEaseInQuad
    -- ^ quadratic tweening
    | AnimationModeEaseOutQuad
    -- ^ quadratic tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInQuad'
    | AnimationModeEaseInOutQuad
    -- ^ quadratic tweening, combininig
    --    'GI.Clutter.Enums.AnimationModeEaseInQuad' and 'GI.Clutter.Enums.AnimationModeEaseOutQuad'
    | AnimationModeEaseInCubic
    -- ^ cubic tweening
    | AnimationModeEaseOutCubic
    -- ^ cubic tweening, invers of
    --    'GI.Clutter.Enums.AnimationModeEaseInCubic'
    | AnimationModeEaseInOutCubic
    -- ^ cubic tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInCubic' and 'GI.Clutter.Enums.AnimationModeEaseOutCubic'
    | AnimationModeEaseInQuart
    -- ^ quartic tweening
    | AnimationModeEaseOutQuart
    -- ^ quartic tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInQuart'
    | AnimationModeEaseInOutQuart
    -- ^ quartic tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInQuart' and 'GI.Clutter.Enums.AnimationModeEaseOutQuart'
    | AnimationModeEaseInQuint
    -- ^ quintic tweening
    | AnimationModeEaseOutQuint
    -- ^ quintic tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInQuint'
    | AnimationModeEaseInOutQuint
    -- ^ fifth power tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInQuint' and 'GI.Clutter.Enums.AnimationModeEaseOutQuint'
    | AnimationModeEaseInSine
    -- ^ sinusoidal tweening
    | AnimationModeEaseOutSine
    -- ^ sinusoidal tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInSine'
    | AnimationModeEaseInOutSine
    -- ^ sine wave tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInSine' and 'GI.Clutter.Enums.AnimationModeEaseOutSine'
    | AnimationModeEaseInExpo
    -- ^ exponential tweening
    | AnimationModeEaseOutExpo
    -- ^ exponential tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInExpo'
    | AnimationModeEaseInOutExpo
    -- ^ exponential tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInExpo' and 'GI.Clutter.Enums.AnimationModeEaseOutExpo'
    | AnimationModeEaseInCirc
    -- ^ circular tweening
    | AnimationModeEaseOutCirc
    -- ^ circular tweening, inverse of
    --    'GI.Clutter.Enums.AnimationModeEaseInCirc'
    | AnimationModeEaseInOutCirc
    -- ^ circular tweening, combining
    --    'GI.Clutter.Enums.AnimationModeEaseInCirc' and 'GI.Clutter.Enums.AnimationModeEaseOutCirc'
    | AnimationModeEaseInElastic
    -- ^ elastic tweening, with offshoot on start
    | AnimationModeEaseOutElastic
    -- ^ elastic tweening, with offshoot on end
    | AnimationModeEaseInOutElastic
    -- ^ elastic tweening with offshoot on both ends
    | AnimationModeEaseInBack
    -- ^ overshooting cubic tweening, with
    --   backtracking on start
    | AnimationModeEaseOutBack
    -- ^ overshooting cubic tweening, with
    --   backtracking on end
    | AnimationModeEaseInOutBack
    -- ^ overshooting cubic tweening, with
    --   backtracking on both ends
    | AnimationModeEaseInBounce
    -- ^ exponentially decaying parabolic (bounce)
    --   tweening, with bounce on start
    | AnimationModeEaseOutBounce
    -- ^ exponentially decaying parabolic (bounce)
    --   tweening, with bounce on end
    | AnimationModeEaseInOutBounce
    -- ^ exponentially decaying parabolic (bounce)
    --   tweening, with bounce on both ends
    | AnimationModeSteps
    -- ^ parametrized step function; see 'GI.Clutter.Objects.Timeline.timelineSetStepProgress'
    --   for further details. (Since 1.12)
    | AnimationModeStepStart
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeSteps' with a number of steps
    --   equal to 1, and a step mode of 'GI.Clutter.Enums.StepModeStart'. (Since 1.12)
    | AnimationModeStepEnd
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeSteps' with a number of steps
    --   equal to 1, and a step mode of 'GI.Clutter.Enums.StepModeEnd'. (Since 1.12)
    | AnimationModeCubicBezier
    -- ^ cubic bezier between (0, 0) and (1, 1) with two
    --   control points; see 'GI.Clutter.Objects.Timeline.timelineSetCubicBezierProgress'. (Since 1.12)
    | AnimationModeEase
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeCubicBezier' with control points
    --   in (0.25, 0.1) and (0.25, 1.0). (Since 1.12)
    | AnimationModeEaseIn
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeCubicBezier' with control points
    --   in (0.42, 0) and (1.0, 1.0). (Since 1.12)
    | AnimationModeEaseOut
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeCubicBezier' with control points
    --   in (0, 0) and (0.58, 1.0). (Since 1.12)
    | AnimationModeEaseInOut
    -- ^ equivalent to 'GI.Clutter.Enums.AnimationModeCubicBezier' with control points
    --   in (0.42, 0) and (0.58, 1.0). (Since 1.12)
    | AnimationModeAnimationLast
    -- ^ last animation mode, used as a guard for
    --   registered global alpha functions
    | AnotherAnimationMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnimationMode -> ShowS
[AnimationMode] -> ShowS
AnimationMode -> String
(Int -> AnimationMode -> ShowS)
-> (AnimationMode -> String)
-> ([AnimationMode] -> ShowS)
-> Show AnimationMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnimationMode -> ShowS
showsPrec :: Int -> AnimationMode -> ShowS
$cshow :: AnimationMode -> String
show :: AnimationMode -> String
$cshowList :: [AnimationMode] -> ShowS
showList :: [AnimationMode] -> ShowS
Show, AnimationMode -> AnimationMode -> Bool
(AnimationMode -> AnimationMode -> Bool)
-> (AnimationMode -> AnimationMode -> Bool) -> Eq AnimationMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnimationMode -> AnimationMode -> Bool
== :: AnimationMode -> AnimationMode -> Bool
$c/= :: AnimationMode -> AnimationMode -> Bool
/= :: AnimationMode -> AnimationMode -> Bool
Eq)

instance P.Enum AnimationMode where
    fromEnum :: AnimationMode -> Int
fromEnum AnimationMode
AnimationModeCustomMode = Int
0
    fromEnum AnimationMode
AnimationModeLinear = Int
1
    fromEnum AnimationMode
AnimationModeEaseInQuad = Int
2
    fromEnum AnimationMode
AnimationModeEaseOutQuad = Int
3
    fromEnum AnimationMode
AnimationModeEaseInOutQuad = Int
4
    fromEnum AnimationMode
AnimationModeEaseInCubic = Int
5
    fromEnum AnimationMode
AnimationModeEaseOutCubic = Int
6
    fromEnum AnimationMode
AnimationModeEaseInOutCubic = Int
7
    fromEnum AnimationMode
AnimationModeEaseInQuart = Int
8
    fromEnum AnimationMode
AnimationModeEaseOutQuart = Int
9
    fromEnum AnimationMode
AnimationModeEaseInOutQuart = Int
10
    fromEnum AnimationMode
AnimationModeEaseInQuint = Int
11
    fromEnum AnimationMode
AnimationModeEaseOutQuint = Int
12
    fromEnum AnimationMode
AnimationModeEaseInOutQuint = Int
13
    fromEnum AnimationMode
AnimationModeEaseInSine = Int
14
    fromEnum AnimationMode
AnimationModeEaseOutSine = Int
15
    fromEnum AnimationMode
AnimationModeEaseInOutSine = Int
16
    fromEnum AnimationMode
AnimationModeEaseInExpo = Int
17
    fromEnum AnimationMode
AnimationModeEaseOutExpo = Int
18
    fromEnum AnimationMode
AnimationModeEaseInOutExpo = Int
19
    fromEnum AnimationMode
AnimationModeEaseInCirc = Int
20
    fromEnum AnimationMode
AnimationModeEaseOutCirc = Int
21
    fromEnum AnimationMode
AnimationModeEaseInOutCirc = Int
22
    fromEnum AnimationMode
AnimationModeEaseInElastic = Int
23
    fromEnum AnimationMode
AnimationModeEaseOutElastic = Int
24
    fromEnum AnimationMode
AnimationModeEaseInOutElastic = Int
25
    fromEnum AnimationMode
AnimationModeEaseInBack = Int
26
    fromEnum AnimationMode
AnimationModeEaseOutBack = Int
27
    fromEnum AnimationMode
AnimationModeEaseInOutBack = Int
28
    fromEnum AnimationMode
AnimationModeEaseInBounce = Int
29
    fromEnum AnimationMode
AnimationModeEaseOutBounce = Int
30
    fromEnum AnimationMode
AnimationModeEaseInOutBounce = Int
31
    fromEnum AnimationMode
AnimationModeSteps = Int
32
    fromEnum AnimationMode
AnimationModeStepStart = Int
33
    fromEnum AnimationMode
AnimationModeStepEnd = Int
34
    fromEnum AnimationMode
AnimationModeCubicBezier = Int
35
    fromEnum AnimationMode
AnimationModeEase = Int
36
    fromEnum AnimationMode
AnimationModeEaseIn = Int
37
    fromEnum AnimationMode
AnimationModeEaseOut = Int
38
    fromEnum AnimationMode
AnimationModeEaseInOut = Int
39
    fromEnum AnimationMode
AnimationModeAnimationLast = Int
40
    fromEnum (AnotherAnimationMode Int
k) = Int
k

    toEnum :: Int -> AnimationMode
toEnum Int
0 = AnimationMode
AnimationModeCustomMode
    toEnum Int
1 = AnimationMode
AnimationModeLinear
    toEnum Int
2 = AnimationMode
AnimationModeEaseInQuad
    toEnum Int
3 = AnimationMode
AnimationModeEaseOutQuad
    toEnum Int
4 = AnimationMode
AnimationModeEaseInOutQuad
    toEnum Int
5 = AnimationMode
AnimationModeEaseInCubic
    toEnum Int
6 = AnimationMode
AnimationModeEaseOutCubic
    toEnum Int
7 = AnimationMode
AnimationModeEaseInOutCubic
    toEnum Int
8 = AnimationMode
AnimationModeEaseInQuart
    toEnum Int
9 = AnimationMode
AnimationModeEaseOutQuart
    toEnum Int
10 = AnimationMode
AnimationModeEaseInOutQuart
    toEnum Int
11 = AnimationMode
AnimationModeEaseInQuint
    toEnum Int
12 = AnimationMode
AnimationModeEaseOutQuint
    toEnum Int
13 = AnimationMode
AnimationModeEaseInOutQuint
    toEnum Int
14 = AnimationMode
AnimationModeEaseInSine
    toEnum Int
15 = AnimationMode
AnimationModeEaseOutSine
    toEnum Int
16 = AnimationMode
AnimationModeEaseInOutSine
    toEnum Int
17 = AnimationMode
AnimationModeEaseInExpo
    toEnum Int
18 = AnimationMode
AnimationModeEaseOutExpo
    toEnum Int
19 = AnimationMode
AnimationModeEaseInOutExpo
    toEnum Int
20 = AnimationMode
AnimationModeEaseInCirc
    toEnum Int
21 = AnimationMode
AnimationModeEaseOutCirc
    toEnum Int
22 = AnimationMode
AnimationModeEaseInOutCirc
    toEnum Int
23 = AnimationMode
AnimationModeEaseInElastic
    toEnum Int
24 = AnimationMode
AnimationModeEaseOutElastic
    toEnum Int
25 = AnimationMode
AnimationModeEaseInOutElastic
    toEnum Int
26 = AnimationMode
AnimationModeEaseInBack
    toEnum Int
27 = AnimationMode
AnimationModeEaseOutBack
    toEnum Int
28 = AnimationMode
AnimationModeEaseInOutBack
    toEnum Int
29 = AnimationMode
AnimationModeEaseInBounce
    toEnum Int
30 = AnimationMode
AnimationModeEaseOutBounce
    toEnum Int
31 = AnimationMode
AnimationModeEaseInOutBounce
    toEnum Int
32 = AnimationMode
AnimationModeSteps
    toEnum Int
33 = AnimationMode
AnimationModeStepStart
    toEnum Int
34 = AnimationMode
AnimationModeStepEnd
    toEnum Int
35 = AnimationMode
AnimationModeCubicBezier
    toEnum Int
36 = AnimationMode
AnimationModeEase
    toEnum Int
37 = AnimationMode
AnimationModeEaseIn
    toEnum Int
38 = AnimationMode
AnimationModeEaseOut
    toEnum Int
39 = AnimationMode
AnimationModeEaseInOut
    toEnum Int
40 = AnimationMode
AnimationModeAnimationLast
    toEnum Int
k = Int -> AnimationMode
AnotherAnimationMode Int
k

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

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

foreign import ccall "clutter_animation_mode_get_type" c_clutter_animation_mode_get_type :: 
    IO GType

instance B.Types.TypedObject AnimationMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_animation_mode_get_type

instance B.Types.BoxedEnum AnimationMode

-- Enum AlignAxis
-- | Specifies the axis on which t'GI.Clutter.Objects.AlignConstraint.AlignConstraint' should maintain
-- the alignment.
-- 
-- /Since: 1.4/
data AlignAxis = 
      AlignAxisXAxis
    -- ^ Maintain the alignment on the X axis
    | AlignAxisYAxis
    -- ^ Maintain the alignment on the Y axis
    | AlignAxisBoth
    -- ^ Maintain the alignment on both the X and Y axis
    | AnotherAlignAxis Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AlignAxis -> ShowS
[AlignAxis] -> ShowS
AlignAxis -> String
(Int -> AlignAxis -> ShowS)
-> (AlignAxis -> String)
-> ([AlignAxis] -> ShowS)
-> Show AlignAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlignAxis -> ShowS
showsPrec :: Int -> AlignAxis -> ShowS
$cshow :: AlignAxis -> String
show :: AlignAxis -> String
$cshowList :: [AlignAxis] -> ShowS
showList :: [AlignAxis] -> ShowS
Show, AlignAxis -> AlignAxis -> Bool
(AlignAxis -> AlignAxis -> Bool)
-> (AlignAxis -> AlignAxis -> Bool) -> Eq AlignAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlignAxis -> AlignAxis -> Bool
== :: AlignAxis -> AlignAxis -> Bool
$c/= :: AlignAxis -> AlignAxis -> Bool
/= :: AlignAxis -> AlignAxis -> Bool
Eq)

instance P.Enum AlignAxis where
    fromEnum :: AlignAxis -> Int
fromEnum AlignAxis
AlignAxisXAxis = Int
0
    fromEnum AlignAxis
AlignAxisYAxis = Int
1
    fromEnum AlignAxis
AlignAxisBoth = Int
2
    fromEnum (AnotherAlignAxis Int
k) = Int
k

    toEnum :: Int -> AlignAxis
toEnum Int
0 = AlignAxis
AlignAxisXAxis
    toEnum Int
1 = AlignAxis
AlignAxisYAxis
    toEnum Int
2 = AlignAxis
AlignAxisBoth
    toEnum Int
k = Int -> AlignAxis
AnotherAlignAxis Int
k

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

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

foreign import ccall "clutter_align_axis_get_type" c_clutter_align_axis_get_type :: 
    IO GType

instance B.Types.TypedObject AlignAxis where
    glibType :: IO GType
glibType = IO GType
c_clutter_align_axis_get_type

instance B.Types.BoxedEnum AlignAxis

-- Enum ActorAlign
-- | Controls how a t'GI.Clutter.Objects.Actor.Actor' should align itself inside the extra space
-- assigned to it during the allocation.
-- 
-- Alignment only matters if the allocated space given to an actor is
-- bigger than its natural size; for example, when the [Actor:xExpand]("GI.Clutter.Objects.Actor#g:attr:xExpand")
-- or the [Actor:yExpand]("GI.Clutter.Objects.Actor#g:attr:yExpand") properties of t'GI.Clutter.Objects.Actor.Actor' are set to 'P.True'.
-- 
-- /Since: 1.10/
data ActorAlign = 
      ActorAlignFill
    -- ^ Stretch to cover the whole allocated space
    | ActorAlignStart
    -- ^ Snap to left or top side, leaving space
    --   to the right or bottom. For horizontal layouts, in right-to-left
    --   locales this should be reversed.
    | ActorAlignCenter
    -- ^ Center the actor inside the allocation
    | ActorAlignEnd
    -- ^ Snap to right or bottom side, leaving space
    --   to the left or top. For horizontal layouts, in right-to-left locales
    --   this should be reversed.
    | AnotherActorAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActorAlign -> ShowS
[ActorAlign] -> ShowS
ActorAlign -> String
(Int -> ActorAlign -> ShowS)
-> (ActorAlign -> String)
-> ([ActorAlign] -> ShowS)
-> Show ActorAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ActorAlign -> ShowS
showsPrec :: Int -> ActorAlign -> ShowS
$cshow :: ActorAlign -> String
show :: ActorAlign -> String
$cshowList :: [ActorAlign] -> ShowS
showList :: [ActorAlign] -> ShowS
Show, ActorAlign -> ActorAlign -> Bool
(ActorAlign -> ActorAlign -> Bool)
-> (ActorAlign -> ActorAlign -> Bool) -> Eq ActorAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActorAlign -> ActorAlign -> Bool
== :: ActorAlign -> ActorAlign -> Bool
$c/= :: ActorAlign -> ActorAlign -> Bool
/= :: ActorAlign -> ActorAlign -> Bool
Eq)

instance P.Enum ActorAlign where
    fromEnum :: ActorAlign -> Int
fromEnum ActorAlign
ActorAlignFill = Int
0
    fromEnum ActorAlign
ActorAlignStart = Int
1
    fromEnum ActorAlign
ActorAlignCenter = Int
2
    fromEnum ActorAlign
ActorAlignEnd = Int
3
    fromEnum (AnotherActorAlign Int
k) = Int
k

    toEnum :: Int -> ActorAlign
toEnum Int
0 = ActorAlign
ActorAlignFill
    toEnum Int
1 = ActorAlign
ActorAlignStart
    toEnum Int
2 = ActorAlign
ActorAlignCenter
    toEnum Int
3 = ActorAlign
ActorAlignEnd
    toEnum Int
k = Int -> ActorAlign
AnotherActorAlign Int
k

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

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

foreign import ccall "clutter_actor_align_get_type" c_clutter_actor_align_get_type :: 
    IO GType

instance B.Types.TypedObject ActorAlign where
    glibType :: IO GType
glibType = IO GType
c_clutter_actor_align_get_type

instance B.Types.BoxedEnum ActorAlign