-- | 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.Flags
    ( 

 -- * Flags


-- ** ActorFlags #flag:ActorFlags#

    ActorFlags(..)                          ,


-- ** AllocationFlags #flag:AllocationFlags#

    AllocationFlags(..)                     ,


-- ** ContentRepeat #flag:ContentRepeat#

    ContentRepeat(..)                       ,


-- ** EffectPaintFlags #flag:EffectPaintFlags#

    EffectPaintFlags(..)                    ,


-- ** EventFlags #flag:EventFlags#

    EventFlags(..)                          ,


-- ** FeatureFlags #flag:FeatureFlags#

    FeatureFlags(..)                        ,


-- ** FontFlags #flag:FontFlags#

    FontFlags(..)                           ,


-- ** ModifierType #flag:ModifierType#

    ModifierType(..)                        ,


-- ** OffscreenRedirect #flag:OffscreenRedirect#

    OffscreenRedirect(..)                   ,


-- ** RepaintFlags #flag:RepaintFlags#

    RepaintFlags(..)                        ,


-- ** ScrollFinishFlags #flag:ScrollFinishFlags#

    ScrollFinishFlags(..)                   ,


-- ** ScrollMode #flag:ScrollMode#

    ScrollMode(..)                          ,


-- ** StageState #flag:StageState#

    StageState(..)                          ,


-- ** SwipeDirection #flag:SwipeDirection#

    SwipeDirection(..)                      ,


-- ** TextureFlags #flag:TextureFlags#

    TextureFlags(..)                        ,




    ) 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


-- Flags TextureFlags
{-# DEPRECATED TextureFlags ["(Since version 1.22)","The t'GI.Clutter.Objects.Texture.Texture' class was the only user of","  this API"] #-}
-- | Flags for 'GI.Clutter.Objects.Texture.textureSetFromRgbData' and
-- 'GI.Clutter.Objects.Texture.textureSetFromYuvData'.
-- 
-- /Since: 0.4/
data TextureFlags = 
      TextureFlagsNone
    -- ^ No flags
    | TextureFlagsRgbFlagBgr
    -- ^ Unused flag
    | TextureFlagsRgbFlagPremult
    -- ^ Unused flag
    | TextureFlagsYuvFlagYuv2
    -- ^ Unused flag
    | AnotherTextureFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureFlags -> ShowS
[TextureFlags] -> ShowS
TextureFlags -> String
(Int -> TextureFlags -> ShowS)
-> (TextureFlags -> String)
-> ([TextureFlags] -> ShowS)
-> Show TextureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureFlags -> ShowS
showsPrec :: Int -> TextureFlags -> ShowS
$cshow :: TextureFlags -> String
show :: TextureFlags -> String
$cshowList :: [TextureFlags] -> ShowS
showList :: [TextureFlags] -> ShowS
Show, TextureFlags -> TextureFlags -> Bool
(TextureFlags -> TextureFlags -> Bool)
-> (TextureFlags -> TextureFlags -> Bool) -> Eq TextureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureFlags -> TextureFlags -> Bool
== :: TextureFlags -> TextureFlags -> Bool
$c/= :: TextureFlags -> TextureFlags -> Bool
/= :: TextureFlags -> TextureFlags -> Bool
Eq)

instance P.Enum TextureFlags where
    fromEnum :: TextureFlags -> Int
fromEnum TextureFlags
TextureFlagsNone = Int
0
    fromEnum TextureFlags
TextureFlagsRgbFlagBgr = Int
2
    fromEnum TextureFlags
TextureFlagsRgbFlagPremult = Int
4
    fromEnum TextureFlags
TextureFlagsYuvFlagYuv2 = Int
8
    fromEnum (AnotherTextureFlags Int
k) = Int
k

    toEnum :: Int -> TextureFlags
toEnum Int
0 = TextureFlags
TextureFlagsNone
    toEnum Int
2 = TextureFlags
TextureFlagsRgbFlagBgr
    toEnum Int
4 = TextureFlags
TextureFlagsRgbFlagPremult
    toEnum Int
8 = TextureFlags
TextureFlagsYuvFlagYuv2
    toEnum Int
k = Int -> TextureFlags
AnotherTextureFlags Int
k

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

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

foreign import ccall "clutter_texture_flags_get_type" c_clutter_texture_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TextureFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_texture_flags_get_type

instance B.Types.BoxedFlags TextureFlags

instance IsGFlag TextureFlags

-- Flags SwipeDirection
-- | The main direction of the swipe gesture
-- 
-- /Since: 1.8/
data SwipeDirection = 
      SwipeDirectionUp
    -- ^ Upwards swipe gesture
    | SwipeDirectionDown
    -- ^ Downwards swipe gesture
    | SwipeDirectionLeft
    -- ^ Leftwards swipe gesture
    | SwipeDirectionRight
    -- ^ Rightwards swipe gesture
    | AnotherSwipeDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SwipeDirection -> ShowS
[SwipeDirection] -> ShowS
SwipeDirection -> String
(Int -> SwipeDirection -> ShowS)
-> (SwipeDirection -> String)
-> ([SwipeDirection] -> ShowS)
-> Show SwipeDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SwipeDirection -> ShowS
showsPrec :: Int -> SwipeDirection -> ShowS
$cshow :: SwipeDirection -> String
show :: SwipeDirection -> String
$cshowList :: [SwipeDirection] -> ShowS
showList :: [SwipeDirection] -> ShowS
Show, SwipeDirection -> SwipeDirection -> Bool
(SwipeDirection -> SwipeDirection -> Bool)
-> (SwipeDirection -> SwipeDirection -> Bool) -> Eq SwipeDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SwipeDirection -> SwipeDirection -> Bool
== :: SwipeDirection -> SwipeDirection -> Bool
$c/= :: SwipeDirection -> SwipeDirection -> Bool
/= :: SwipeDirection -> SwipeDirection -> Bool
Eq)

instance P.Enum SwipeDirection where
    fromEnum :: SwipeDirection -> Int
fromEnum SwipeDirection
SwipeDirectionUp = Int
1
    fromEnum SwipeDirection
SwipeDirectionDown = Int
2
    fromEnum SwipeDirection
SwipeDirectionLeft = Int
4
    fromEnum SwipeDirection
SwipeDirectionRight = Int
8
    fromEnum (AnotherSwipeDirection Int
k) = Int
k

    toEnum :: Int -> SwipeDirection
toEnum Int
1 = SwipeDirection
SwipeDirectionUp
    toEnum Int
2 = SwipeDirection
SwipeDirectionDown
    toEnum Int
4 = SwipeDirection
SwipeDirectionLeft
    toEnum Int
8 = SwipeDirection
SwipeDirectionRight
    toEnum Int
k = Int -> SwipeDirection
AnotherSwipeDirection Int
k

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

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

foreign import ccall "clutter_swipe_direction_get_type" c_clutter_swipe_direction_get_type :: 
    IO GType

instance B.Types.TypedObject SwipeDirection where
    glibType :: IO GType
glibType = IO GType
c_clutter_swipe_direction_get_type

instance B.Types.BoxedFlags SwipeDirection

instance IsGFlag SwipeDirection

-- Flags StageState
-- | Stage state masks, used by the t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeStageState'.
-- 
-- /Since: 0.4/
data StageState = 
      StageStateFullscreen
    -- ^ Fullscreen mask
    | StageStateOffscreen
    -- ^ Offscreen mask (deprecated)
    | StageStateActivated
    -- ^ Activated mask
    | AnotherStageState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StageState -> ShowS
[StageState] -> ShowS
StageState -> String
(Int -> StageState -> ShowS)
-> (StageState -> String)
-> ([StageState] -> ShowS)
-> Show StageState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StageState -> ShowS
showsPrec :: Int -> StageState -> ShowS
$cshow :: StageState -> String
show :: StageState -> String
$cshowList :: [StageState] -> ShowS
showList :: [StageState] -> ShowS
Show, StageState -> StageState -> Bool
(StageState -> StageState -> Bool)
-> (StageState -> StageState -> Bool) -> Eq StageState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StageState -> StageState -> Bool
== :: StageState -> StageState -> Bool
$c/= :: StageState -> StageState -> Bool
/= :: StageState -> StageState -> Bool
Eq)

instance P.Enum StageState where
    fromEnum :: StageState -> Int
fromEnum StageState
StageStateFullscreen = Int
2
    fromEnum StageState
StageStateOffscreen = Int
4
    fromEnum StageState
StageStateActivated = Int
8
    fromEnum (AnotherStageState Int
k) = Int
k

    toEnum :: Int -> StageState
toEnum Int
2 = StageState
StageStateFullscreen
    toEnum Int
4 = StageState
StageStateOffscreen
    toEnum Int
8 = StageState
StageStateActivated
    toEnum Int
k = Int -> StageState
AnotherStageState Int
k

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

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

foreign import ccall "clutter_stage_state_get_type" c_clutter_stage_state_get_type :: 
    IO GType

instance B.Types.TypedObject StageState where
    glibType :: IO GType
glibType = IO GType
c_clutter_stage_state_get_type

instance B.Types.BoxedFlags StageState

instance IsGFlag StageState

-- Flags ScrollMode
-- | Scroll modes.
-- 
-- /Since: 1.12/
data ScrollMode = 
      ScrollModeNone
    -- ^ Ignore scrolling
    | ScrollModeHorizontally
    -- ^ Scroll only horizontally
    | ScrollModeVertically
    -- ^ Scroll only vertically
    | ScrollModeBoth
    -- ^ Scroll in both directions
    | AnotherScrollMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollMode -> ShowS
[ScrollMode] -> ShowS
ScrollMode -> String
(Int -> ScrollMode -> ShowS)
-> (ScrollMode -> String)
-> ([ScrollMode] -> ShowS)
-> Show ScrollMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScrollMode -> ShowS
showsPrec :: Int -> ScrollMode -> ShowS
$cshow :: ScrollMode -> String
show :: ScrollMode -> String
$cshowList :: [ScrollMode] -> ShowS
showList :: [ScrollMode] -> ShowS
Show, ScrollMode -> ScrollMode -> Bool
(ScrollMode -> ScrollMode -> Bool)
-> (ScrollMode -> ScrollMode -> Bool) -> Eq ScrollMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScrollMode -> ScrollMode -> Bool
== :: ScrollMode -> ScrollMode -> Bool
$c/= :: ScrollMode -> ScrollMode -> Bool
/= :: ScrollMode -> ScrollMode -> Bool
Eq)

instance P.Enum ScrollMode where
    fromEnum :: ScrollMode -> Int
fromEnum ScrollMode
ScrollModeNone = Int
0
    fromEnum ScrollMode
ScrollModeHorizontally = Int
1
    fromEnum ScrollMode
ScrollModeVertically = Int
2
    fromEnum ScrollMode
ScrollModeBoth = Int
3
    fromEnum (AnotherScrollMode Int
k) = Int
k

    toEnum :: Int -> ScrollMode
toEnum Int
0 = ScrollMode
ScrollModeNone
    toEnum Int
1 = ScrollMode
ScrollModeHorizontally
    toEnum Int
2 = ScrollMode
ScrollModeVertically
    toEnum Int
3 = ScrollMode
ScrollModeBoth
    toEnum Int
k = Int -> ScrollMode
AnotherScrollMode Int
k

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

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

foreign import ccall "clutter_scroll_mode_get_type" c_clutter_scroll_mode_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollMode where
    glibType :: IO GType
glibType = IO GType
c_clutter_scroll_mode_get_type

instance B.Types.BoxedFlags ScrollMode

instance IsGFlag ScrollMode

-- Flags ScrollFinishFlags
-- | Flags used to notify the axes that were stopped in a t'GI.Clutter.Structs.ScrollEvent.ScrollEvent'.
-- These can be used to trigger post-scroll effects like kinetic scrolling.
-- 
-- /Since: 1.26/
data ScrollFinishFlags = 
      ScrollFinishFlagsNone
    -- ^ no axis was stopped.
    | ScrollFinishFlagsHorizontal
    -- ^ The horizontal axis stopped.
    | ScrollFinishFlagsVertical
    -- ^ The vertical axis stopped.
    | AnotherScrollFinishFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollFinishFlags -> ShowS
[ScrollFinishFlags] -> ShowS
ScrollFinishFlags -> String
(Int -> ScrollFinishFlags -> ShowS)
-> (ScrollFinishFlags -> String)
-> ([ScrollFinishFlags] -> ShowS)
-> Show ScrollFinishFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScrollFinishFlags -> ShowS
showsPrec :: Int -> ScrollFinishFlags -> ShowS
$cshow :: ScrollFinishFlags -> String
show :: ScrollFinishFlags -> String
$cshowList :: [ScrollFinishFlags] -> ShowS
showList :: [ScrollFinishFlags] -> ShowS
Show, ScrollFinishFlags -> ScrollFinishFlags -> Bool
(ScrollFinishFlags -> ScrollFinishFlags -> Bool)
-> (ScrollFinishFlags -> ScrollFinishFlags -> Bool)
-> Eq ScrollFinishFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScrollFinishFlags -> ScrollFinishFlags -> Bool
== :: ScrollFinishFlags -> ScrollFinishFlags -> Bool
$c/= :: ScrollFinishFlags -> ScrollFinishFlags -> Bool
/= :: ScrollFinishFlags -> ScrollFinishFlags -> Bool
Eq)

instance P.Enum ScrollFinishFlags where
    fromEnum :: ScrollFinishFlags -> Int
fromEnum ScrollFinishFlags
ScrollFinishFlagsNone = Int
0
    fromEnum ScrollFinishFlags
ScrollFinishFlagsHorizontal = Int
1
    fromEnum ScrollFinishFlags
ScrollFinishFlagsVertical = Int
2
    fromEnum (AnotherScrollFinishFlags Int
k) = Int
k

    toEnum :: Int -> ScrollFinishFlags
toEnum Int
0 = ScrollFinishFlags
ScrollFinishFlagsNone
    toEnum Int
1 = ScrollFinishFlags
ScrollFinishFlagsHorizontal
    toEnum Int
2 = ScrollFinishFlags
ScrollFinishFlagsVertical
    toEnum Int
k = Int -> ScrollFinishFlags
AnotherScrollFinishFlags Int
k

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

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

foreign import ccall "clutter_scroll_finish_flags_get_type" c_clutter_scroll_finish_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollFinishFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_scroll_finish_flags_get_type

instance B.Types.BoxedFlags ScrollFinishFlags

instance IsGFlag ScrollFinishFlags

-- Flags RepaintFlags
-- | Flags to pass to 'GI.Clutter.Functions.threadsAddRepaintFuncFull'.
-- 
-- /Since: 1.10/
data RepaintFlags = 
      RepaintFlagsPrePaint
    -- ^ Run the repaint function prior to
    --   painting the stages
    | RepaintFlagsPostPaint
    -- ^ Run the repaint function after
    --   painting the stages
    | RepaintFlagsQueueRedrawOnAdd
    -- ^ Ensure that a new frame
    --   is queued after adding the repaint function
    | AnotherRepaintFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepaintFlags -> ShowS
[RepaintFlags] -> ShowS
RepaintFlags -> String
(Int -> RepaintFlags -> ShowS)
-> (RepaintFlags -> String)
-> ([RepaintFlags] -> ShowS)
-> Show RepaintFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepaintFlags -> ShowS
showsPrec :: Int -> RepaintFlags -> ShowS
$cshow :: RepaintFlags -> String
show :: RepaintFlags -> String
$cshowList :: [RepaintFlags] -> ShowS
showList :: [RepaintFlags] -> ShowS
Show, RepaintFlags -> RepaintFlags -> Bool
(RepaintFlags -> RepaintFlags -> Bool)
-> (RepaintFlags -> RepaintFlags -> Bool) -> Eq RepaintFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepaintFlags -> RepaintFlags -> Bool
== :: RepaintFlags -> RepaintFlags -> Bool
$c/= :: RepaintFlags -> RepaintFlags -> Bool
/= :: RepaintFlags -> RepaintFlags -> Bool
Eq)

instance P.Enum RepaintFlags where
    fromEnum :: RepaintFlags -> Int
fromEnum RepaintFlags
RepaintFlagsPrePaint = Int
1
    fromEnum RepaintFlags
RepaintFlagsPostPaint = Int
2
    fromEnum RepaintFlags
RepaintFlagsQueueRedrawOnAdd = Int
4
    fromEnum (AnotherRepaintFlags Int
k) = Int
k

    toEnum :: Int -> RepaintFlags
toEnum Int
1 = RepaintFlags
RepaintFlagsPrePaint
    toEnum Int
2 = RepaintFlags
RepaintFlagsPostPaint
    toEnum Int
4 = RepaintFlags
RepaintFlagsQueueRedrawOnAdd
    toEnum Int
k = Int -> RepaintFlags
AnotherRepaintFlags Int
k

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

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

foreign import ccall "clutter_repaint_flags_get_type" c_clutter_repaint_flags_get_type :: 
    IO GType

instance B.Types.TypedObject RepaintFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_repaint_flags_get_type

instance B.Types.BoxedFlags RepaintFlags

instance IsGFlag RepaintFlags

-- Flags OffscreenRedirect
-- | Possible flags to pass to 'GI.Clutter.Objects.Actor.actorSetOffscreenRedirect'.
-- 
-- /Since: 1.8/
data OffscreenRedirect = 
      OffscreenRedirectAutomaticForOpacity
    -- ^ Only redirect
    --   the actor if it is semi-transparent and its @/has_overlaps()/@
    --   virtual returns 'P.True'. This is the default.
    | OffscreenRedirectAlways
    -- ^ Always redirect the actor to an
    --   offscreen buffer even if it is fully opaque.
    | AnotherOffscreenRedirect Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OffscreenRedirect -> ShowS
[OffscreenRedirect] -> ShowS
OffscreenRedirect -> String
(Int -> OffscreenRedirect -> ShowS)
-> (OffscreenRedirect -> String)
-> ([OffscreenRedirect] -> ShowS)
-> Show OffscreenRedirect
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OffscreenRedirect -> ShowS
showsPrec :: Int -> OffscreenRedirect -> ShowS
$cshow :: OffscreenRedirect -> String
show :: OffscreenRedirect -> String
$cshowList :: [OffscreenRedirect] -> ShowS
showList :: [OffscreenRedirect] -> ShowS
Show, OffscreenRedirect -> OffscreenRedirect -> Bool
(OffscreenRedirect -> OffscreenRedirect -> Bool)
-> (OffscreenRedirect -> OffscreenRedirect -> Bool)
-> Eq OffscreenRedirect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OffscreenRedirect -> OffscreenRedirect -> Bool
== :: OffscreenRedirect -> OffscreenRedirect -> Bool
$c/= :: OffscreenRedirect -> OffscreenRedirect -> Bool
/= :: OffscreenRedirect -> OffscreenRedirect -> Bool
Eq)

instance P.Enum OffscreenRedirect where
    fromEnum :: OffscreenRedirect -> Int
fromEnum OffscreenRedirect
OffscreenRedirectAutomaticForOpacity = Int
1
    fromEnum OffscreenRedirect
OffscreenRedirectAlways = Int
2
    fromEnum (AnotherOffscreenRedirect Int
k) = Int
k

    toEnum :: Int -> OffscreenRedirect
toEnum Int
1 = OffscreenRedirect
OffscreenRedirectAutomaticForOpacity
    toEnum Int
2 = OffscreenRedirect
OffscreenRedirectAlways
    toEnum Int
k = Int -> OffscreenRedirect
AnotherOffscreenRedirect Int
k

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

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

foreign import ccall "clutter_offscreen_redirect_get_type" c_clutter_offscreen_redirect_get_type :: 
    IO GType

instance B.Types.TypedObject OffscreenRedirect where
    glibType :: IO GType
glibType = IO GType
c_clutter_offscreen_redirect_get_type

instance B.Types.BoxedFlags OffscreenRedirect

instance IsGFlag OffscreenRedirect

-- Flags ModifierType
-- | Masks applied to a t'GI.Clutter.Unions.Event.Event' by modifiers.
-- 
-- Note that Clutter may add internal values to events which include
-- reserved values such as 'GI.Clutter.Flags.ModifierTypeModifierReserved13Mask'.  Your code
-- should preserve and ignore them.  You can use 'GI.Clutter.Flags.ModifierTypeModifierMask' to
-- remove all reserved values.
-- 
-- /Since: 0.4/
data ModifierType = 
      ModifierTypeShiftMask
    -- ^ Mask applied by the Shift key
    | ModifierTypeLockMask
    -- ^ Mask applied by the Caps Lock key
    | ModifierTypeControlMask
    -- ^ Mask applied by the Control key
    | ModifierTypeMod1Mask
    -- ^ Mask applied by the first Mod key
    | ModifierTypeMod2Mask
    -- ^ Mask applied by the second Mod key
    | ModifierTypeMod3Mask
    -- ^ Mask applied by the third Mod key
    | ModifierTypeMod4Mask
    -- ^ Mask applied by the fourth Mod key
    | ModifierTypeMod5Mask
    -- ^ Mask applied by the fifth Mod key
    | ModifierTypeButton1Mask
    -- ^ Mask applied by the first pointer button
    | ModifierTypeButton2Mask
    -- ^ Mask applied by the second pointer button
    | ModifierTypeButton3Mask
    -- ^ Mask applied by the third pointer button
    | ModifierTypeButton4Mask
    -- ^ Mask applied by the fourth pointer button
    | ModifierTypeButton5Mask
    -- ^ Mask applied by the fifth pointer button
    | ModifierTypeModifierReserved13Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved14Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved15Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved16Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved17Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved18Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved19Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved20Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved21Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved22Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved23Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved24Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeModifierReserved25Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeSuperMask
    -- ^ Mask applied by the Super key
    | ModifierTypeHyperMask
    -- ^ Mask applied by the Hyper key
    | ModifierTypeMetaMask
    -- ^ Mask applied by the Meta key
    | ModifierTypeModifierReserved29Mask
    -- ^ /No description available in the introspection data./
    | ModifierTypeReleaseMask
    -- ^ Mask applied during release
    | ModifierTypeModifierMask
    -- ^ A mask covering all modifier types
    | AnotherModifierType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ModifierType -> ShowS
[ModifierType] -> ShowS
ModifierType -> String
(Int -> ModifierType -> ShowS)
-> (ModifierType -> String)
-> ([ModifierType] -> ShowS)
-> Show ModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModifierType -> ShowS
showsPrec :: Int -> ModifierType -> ShowS
$cshow :: ModifierType -> String
show :: ModifierType -> String
$cshowList :: [ModifierType] -> ShowS
showList :: [ModifierType] -> ShowS
Show, ModifierType -> ModifierType -> Bool
(ModifierType -> ModifierType -> Bool)
-> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModifierType -> ModifierType -> Bool
== :: ModifierType -> ModifierType -> Bool
$c/= :: ModifierType -> ModifierType -> Bool
/= :: ModifierType -> ModifierType -> Bool
Eq)

instance P.Enum ModifierType where
    fromEnum :: ModifierType -> Int
fromEnum ModifierType
ModifierTypeShiftMask = Int
1
    fromEnum ModifierType
ModifierTypeLockMask = Int
2
    fromEnum ModifierType
ModifierTypeControlMask = Int
4
    fromEnum ModifierType
ModifierTypeMod1Mask = Int
8
    fromEnum ModifierType
ModifierTypeMod2Mask = Int
16
    fromEnum ModifierType
ModifierTypeMod3Mask = Int
32
    fromEnum ModifierType
ModifierTypeMod4Mask = Int
64
    fromEnum ModifierType
ModifierTypeMod5Mask = Int
128
    fromEnum ModifierType
ModifierTypeButton1Mask = Int
256
    fromEnum ModifierType
ModifierTypeButton2Mask = Int
512
    fromEnum ModifierType
ModifierTypeButton3Mask = Int
1024
    fromEnum ModifierType
ModifierTypeButton4Mask = Int
2048
    fromEnum ModifierType
ModifierTypeButton5Mask = Int
4096
    fromEnum ModifierType
ModifierTypeModifierReserved13Mask = Int
8192
    fromEnum ModifierType
ModifierTypeModifierReserved14Mask = Int
16384
    fromEnum ModifierType
ModifierTypeModifierReserved15Mask = Int
32768
    fromEnum ModifierType
ModifierTypeModifierReserved16Mask = Int
65536
    fromEnum ModifierType
ModifierTypeModifierReserved17Mask = Int
131072
    fromEnum ModifierType
ModifierTypeModifierReserved18Mask = Int
262144
    fromEnum ModifierType
ModifierTypeModifierReserved19Mask = Int
524288
    fromEnum ModifierType
ModifierTypeModifierReserved20Mask = Int
1048576
    fromEnum ModifierType
ModifierTypeModifierReserved21Mask = Int
2097152
    fromEnum ModifierType
ModifierTypeModifierReserved22Mask = Int
4194304
    fromEnum ModifierType
ModifierTypeModifierReserved23Mask = Int
8388608
    fromEnum ModifierType
ModifierTypeModifierReserved24Mask = Int
16777216
    fromEnum ModifierType
ModifierTypeModifierReserved25Mask = Int
33554432
    fromEnum ModifierType
ModifierTypeSuperMask = Int
67108864
    fromEnum ModifierType
ModifierTypeHyperMask = Int
134217728
    fromEnum ModifierType
ModifierTypeMetaMask = Int
268435456
    fromEnum ModifierType
ModifierTypeModifierReserved29Mask = Int
536870912
    fromEnum ModifierType
ModifierTypeReleaseMask = Int
1073741824
    fromEnum ModifierType
ModifierTypeModifierMask = Int
1543512063
    fromEnum (AnotherModifierType Int
k) = Int
k

    toEnum :: Int -> ModifierType
toEnum Int
1 = ModifierType
ModifierTypeShiftMask
    toEnum Int
2 = ModifierType
ModifierTypeLockMask
    toEnum Int
4 = ModifierType
ModifierTypeControlMask
    toEnum Int
8 = ModifierType
ModifierTypeMod1Mask
    toEnum Int
16 = ModifierType
ModifierTypeMod2Mask
    toEnum Int
32 = ModifierType
ModifierTypeMod3Mask
    toEnum Int
64 = ModifierType
ModifierTypeMod4Mask
    toEnum Int
128 = ModifierType
ModifierTypeMod5Mask
    toEnum Int
256 = ModifierType
ModifierTypeButton1Mask
    toEnum Int
512 = ModifierType
ModifierTypeButton2Mask
    toEnum Int
1024 = ModifierType
ModifierTypeButton3Mask
    toEnum Int
2048 = ModifierType
ModifierTypeButton4Mask
    toEnum Int
4096 = ModifierType
ModifierTypeButton5Mask
    toEnum Int
8192 = ModifierType
ModifierTypeModifierReserved13Mask
    toEnum Int
16384 = ModifierType
ModifierTypeModifierReserved14Mask
    toEnum Int
32768 = ModifierType
ModifierTypeModifierReserved15Mask
    toEnum Int
65536 = ModifierType
ModifierTypeModifierReserved16Mask
    toEnum Int
131072 = ModifierType
ModifierTypeModifierReserved17Mask
    toEnum Int
262144 = ModifierType
ModifierTypeModifierReserved18Mask
    toEnum Int
524288 = ModifierType
ModifierTypeModifierReserved19Mask
    toEnum Int
1048576 = ModifierType
ModifierTypeModifierReserved20Mask
    toEnum Int
2097152 = ModifierType
ModifierTypeModifierReserved21Mask
    toEnum Int
4194304 = ModifierType
ModifierTypeModifierReserved22Mask
    toEnum Int
8388608 = ModifierType
ModifierTypeModifierReserved23Mask
    toEnum Int
16777216 = ModifierType
ModifierTypeModifierReserved24Mask
    toEnum Int
33554432 = ModifierType
ModifierTypeModifierReserved25Mask
    toEnum Int
67108864 = ModifierType
ModifierTypeSuperMask
    toEnum Int
134217728 = ModifierType
ModifierTypeHyperMask
    toEnum Int
268435456 = ModifierType
ModifierTypeMetaMask
    toEnum Int
536870912 = ModifierType
ModifierTypeModifierReserved29Mask
    toEnum Int
1073741824 = ModifierType
ModifierTypeReleaseMask
    toEnum Int
1543512063 = ModifierType
ModifierTypeModifierMask
    toEnum Int
k = Int -> ModifierType
AnotherModifierType Int
k

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

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

foreign import ccall "clutter_modifier_type_get_type" c_clutter_modifier_type_get_type :: 
    IO GType

instance B.Types.TypedObject ModifierType where
    glibType :: IO GType
glibType = IO GType
c_clutter_modifier_type_get_type

instance B.Types.BoxedFlags ModifierType

instance IsGFlag ModifierType

-- Flags FontFlags
{-# DEPRECATED FontFlags ["(Since version 1.22)","Use t'GI.Cairo.Structs.FontOptions.FontOptions' instead"] #-}
-- | Runtime flags to change the font quality. To be used with
-- 'GI.Clutter.Functions.setFontFlags'.
-- 
-- /Since: 1.0/
data FontFlags = 
      FontFlagsMipmapping
    -- ^ Set to use mipmaps for the glyph cache textures.
    | FontFlagsHinting
    -- ^ Set to enable hinting on the glyphs.
    | AnotherFontFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontFlags -> ShowS
[FontFlags] -> ShowS
FontFlags -> String
(Int -> FontFlags -> ShowS)
-> (FontFlags -> String)
-> ([FontFlags] -> ShowS)
-> Show FontFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FontFlags -> ShowS
showsPrec :: Int -> FontFlags -> ShowS
$cshow :: FontFlags -> String
show :: FontFlags -> String
$cshowList :: [FontFlags] -> ShowS
showList :: [FontFlags] -> ShowS
Show, FontFlags -> FontFlags -> Bool
(FontFlags -> FontFlags -> Bool)
-> (FontFlags -> FontFlags -> Bool) -> Eq FontFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FontFlags -> FontFlags -> Bool
== :: FontFlags -> FontFlags -> Bool
$c/= :: FontFlags -> FontFlags -> Bool
/= :: FontFlags -> FontFlags -> Bool
Eq)

instance P.Enum FontFlags where
    fromEnum :: FontFlags -> Int
fromEnum FontFlags
FontFlagsMipmapping = Int
1
    fromEnum FontFlags
FontFlagsHinting = Int
2
    fromEnum (AnotherFontFlags Int
k) = Int
k

    toEnum :: Int -> FontFlags
toEnum Int
1 = FontFlags
FontFlagsMipmapping
    toEnum Int
2 = FontFlags
FontFlagsHinting
    toEnum Int
k = Int -> FontFlags
AnotherFontFlags Int
k

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

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

foreign import ccall "clutter_font_flags_get_type" c_clutter_font_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FontFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_font_flags_get_type

instance B.Types.BoxedFlags FontFlags

instance IsGFlag FontFlags

-- Flags FeatureFlags
-- | Runtime flags indicating specific features available via Clutter window
-- system and graphics backend.
-- 
-- /Since: 0.4/
data FeatureFlags = 
      FeatureFlagsTextureNpot
    -- ^ Set if NPOTS textures supported.
    | FeatureFlagsSyncToVblank
    -- ^ Set if vblank syncing supported.
    | FeatureFlagsTextureYuv
    -- ^ Set if YUV based textures supported.
    | FeatureFlagsTextureReadPixels
    -- ^ Set if texture pixels can be read.
    | FeatureFlagsStageStatic
    -- ^ Set if stage size if fixed (i.e framebuffer)
    | FeatureFlagsStageUserResize
    -- ^ Set if stage is able to be user resized.
    | FeatureFlagsStageCursor
    -- ^ Set if stage has a graphical cursor.
    | FeatureFlagsShadersGlsl
    -- ^ Set if the backend supports GLSL shaders.
    | FeatureFlagsOffscreen
    -- ^ Set if the backend supports offscreen rendering.
    | FeatureFlagsStageMultiple
    -- ^ Set if multiple stages are supported.
    | FeatureFlagsSwapEvents
    -- ^ Set if the GLX_INTEL_swap_event is supported.
    | AnotherFeatureFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FeatureFlags -> ShowS
[FeatureFlags] -> ShowS
FeatureFlags -> String
(Int -> FeatureFlags -> ShowS)
-> (FeatureFlags -> String)
-> ([FeatureFlags] -> ShowS)
-> Show FeatureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FeatureFlags -> ShowS
showsPrec :: Int -> FeatureFlags -> ShowS
$cshow :: FeatureFlags -> String
show :: FeatureFlags -> String
$cshowList :: [FeatureFlags] -> ShowS
showList :: [FeatureFlags] -> ShowS
Show, FeatureFlags -> FeatureFlags -> Bool
(FeatureFlags -> FeatureFlags -> Bool)
-> (FeatureFlags -> FeatureFlags -> Bool) -> Eq FeatureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FeatureFlags -> FeatureFlags -> Bool
== :: FeatureFlags -> FeatureFlags -> Bool
$c/= :: FeatureFlags -> FeatureFlags -> Bool
/= :: FeatureFlags -> FeatureFlags -> Bool
Eq)

instance P.Enum FeatureFlags where
    fromEnum :: FeatureFlags -> Int
fromEnum FeatureFlags
FeatureFlagsTextureNpot = Int
4
    fromEnum FeatureFlags
FeatureFlagsSyncToVblank = Int
8
    fromEnum FeatureFlags
FeatureFlagsTextureYuv = Int
16
    fromEnum FeatureFlags
FeatureFlagsTextureReadPixels = Int
32
    fromEnum FeatureFlags
FeatureFlagsStageStatic = Int
64
    fromEnum FeatureFlags
FeatureFlagsStageUserResize = Int
128
    fromEnum FeatureFlags
FeatureFlagsStageCursor = Int
256
    fromEnum FeatureFlags
FeatureFlagsShadersGlsl = Int
512
    fromEnum FeatureFlags
FeatureFlagsOffscreen = Int
1024
    fromEnum FeatureFlags
FeatureFlagsStageMultiple = Int
2048
    fromEnum FeatureFlags
FeatureFlagsSwapEvents = Int
4096
    fromEnum (AnotherFeatureFlags Int
k) = Int
k

    toEnum :: Int -> FeatureFlags
toEnum Int
4 = FeatureFlags
FeatureFlagsTextureNpot
    toEnum Int
8 = FeatureFlags
FeatureFlagsSyncToVblank
    toEnum Int
16 = FeatureFlags
FeatureFlagsTextureYuv
    toEnum Int
32 = FeatureFlags
FeatureFlagsTextureReadPixels
    toEnum Int
64 = FeatureFlags
FeatureFlagsStageStatic
    toEnum Int
128 = FeatureFlags
FeatureFlagsStageUserResize
    toEnum Int
256 = FeatureFlags
FeatureFlagsStageCursor
    toEnum Int
512 = FeatureFlags
FeatureFlagsShadersGlsl
    toEnum Int
1024 = FeatureFlags
FeatureFlagsOffscreen
    toEnum Int
2048 = FeatureFlags
FeatureFlagsStageMultiple
    toEnum Int
4096 = FeatureFlags
FeatureFlagsSwapEvents
    toEnum Int
k = Int -> FeatureFlags
AnotherFeatureFlags Int
k

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

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

foreign import ccall "clutter_feature_flags_get_type" c_clutter_feature_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FeatureFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_feature_flags_get_type

instance B.Types.BoxedFlags FeatureFlags

instance IsGFlag FeatureFlags

-- Flags EventFlags
-- | Flags for the t'GI.Clutter.Unions.Event.Event'
-- 
-- /Since: 0.6/
data EventFlags = 
      EventFlagsNone
    -- ^ No flag set
    | EventFlagsFlagSynthetic
    -- ^ Synthetic event
    | AnotherEventFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventFlags -> ShowS
[EventFlags] -> ShowS
EventFlags -> String
(Int -> EventFlags -> ShowS)
-> (EventFlags -> String)
-> ([EventFlags] -> ShowS)
-> Show EventFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventFlags -> ShowS
showsPrec :: Int -> EventFlags -> ShowS
$cshow :: EventFlags -> String
show :: EventFlags -> String
$cshowList :: [EventFlags] -> ShowS
showList :: [EventFlags] -> ShowS
Show, EventFlags -> EventFlags -> Bool
(EventFlags -> EventFlags -> Bool)
-> (EventFlags -> EventFlags -> Bool) -> Eq EventFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventFlags -> EventFlags -> Bool
== :: EventFlags -> EventFlags -> Bool
$c/= :: EventFlags -> EventFlags -> Bool
/= :: EventFlags -> EventFlags -> Bool
Eq)

instance P.Enum EventFlags where
    fromEnum :: EventFlags -> Int
fromEnum EventFlags
EventFlagsNone = Int
0
    fromEnum EventFlags
EventFlagsFlagSynthetic = Int
1
    fromEnum (AnotherEventFlags Int
k) = Int
k

    toEnum :: Int -> EventFlags
toEnum Int
0 = EventFlags
EventFlagsNone
    toEnum Int
1 = EventFlags
EventFlagsFlagSynthetic
    toEnum Int
k = Int -> EventFlags
AnotherEventFlags Int
k

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

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

foreign import ccall "clutter_event_flags_get_type" c_clutter_event_flags_get_type :: 
    IO GType

instance B.Types.TypedObject EventFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_event_flags_get_type

instance B.Types.BoxedFlags EventFlags

instance IsGFlag EventFlags

-- Flags EffectPaintFlags
-- | Flags passed to the ‘paint’ or ‘pick’ method of t'GI.Clutter.Objects.Effect.Effect'.
data EffectPaintFlags = 
      EffectPaintFlagsActorDirty
    -- ^ The actor or one of its children
    --   has queued a redraw before this paint. This implies that the effect
    --   should call 'GI.Clutter.Objects.Actor.actorContinuePaint' to chain to the next
    --   effect and can not cache any results from a previous paint.
    | AnotherEffectPaintFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EffectPaintFlags -> ShowS
[EffectPaintFlags] -> ShowS
EffectPaintFlags -> String
(Int -> EffectPaintFlags -> ShowS)
-> (EffectPaintFlags -> String)
-> ([EffectPaintFlags] -> ShowS)
-> Show EffectPaintFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EffectPaintFlags -> ShowS
showsPrec :: Int -> EffectPaintFlags -> ShowS
$cshow :: EffectPaintFlags -> String
show :: EffectPaintFlags -> String
$cshowList :: [EffectPaintFlags] -> ShowS
showList :: [EffectPaintFlags] -> ShowS
Show, EffectPaintFlags -> EffectPaintFlags -> Bool
(EffectPaintFlags -> EffectPaintFlags -> Bool)
-> (EffectPaintFlags -> EffectPaintFlags -> Bool)
-> Eq EffectPaintFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EffectPaintFlags -> EffectPaintFlags -> Bool
== :: EffectPaintFlags -> EffectPaintFlags -> Bool
$c/= :: EffectPaintFlags -> EffectPaintFlags -> Bool
/= :: EffectPaintFlags -> EffectPaintFlags -> Bool
Eq)

instance P.Enum EffectPaintFlags where
    fromEnum :: EffectPaintFlags -> Int
fromEnum EffectPaintFlags
EffectPaintFlagsActorDirty = Int
1
    fromEnum (AnotherEffectPaintFlags Int
k) = Int
k

    toEnum :: Int -> EffectPaintFlags
toEnum Int
1 = EffectPaintFlags
EffectPaintFlagsActorDirty
    toEnum Int
k = Int -> EffectPaintFlags
AnotherEffectPaintFlags Int
k

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

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

foreign import ccall "clutter_effect_paint_flags_get_type" c_clutter_effect_paint_flags_get_type :: 
    IO GType

instance B.Types.TypedObject EffectPaintFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_effect_paint_flags_get_type

instance B.Types.BoxedFlags EffectPaintFlags

instance IsGFlag EffectPaintFlags

-- Flags ContentRepeat
-- | Content repeat modes.
-- 
-- /Since: 1.12/
data ContentRepeat = 
      ContentRepeatNone
    -- ^ No repeat
    | ContentRepeatXAxis
    -- ^ Repeat the content on the X axis
    | ContentRepeatYAxis
    -- ^ Repeat the content on the Y axis
    | ContentRepeatBoth
    -- ^ Repeat the content on both axis
    | AnotherContentRepeat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ContentRepeat -> ShowS
[ContentRepeat] -> ShowS
ContentRepeat -> String
(Int -> ContentRepeat -> ShowS)
-> (ContentRepeat -> String)
-> ([ContentRepeat] -> ShowS)
-> Show ContentRepeat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentRepeat -> ShowS
showsPrec :: Int -> ContentRepeat -> ShowS
$cshow :: ContentRepeat -> String
show :: ContentRepeat -> String
$cshowList :: [ContentRepeat] -> ShowS
showList :: [ContentRepeat] -> ShowS
Show, ContentRepeat -> ContentRepeat -> Bool
(ContentRepeat -> ContentRepeat -> Bool)
-> (ContentRepeat -> ContentRepeat -> Bool) -> Eq ContentRepeat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentRepeat -> ContentRepeat -> Bool
== :: ContentRepeat -> ContentRepeat -> Bool
$c/= :: ContentRepeat -> ContentRepeat -> Bool
/= :: ContentRepeat -> ContentRepeat -> Bool
Eq)

instance P.Enum ContentRepeat where
    fromEnum :: ContentRepeat -> Int
fromEnum ContentRepeat
ContentRepeatNone = Int
0
    fromEnum ContentRepeat
ContentRepeatXAxis = Int
1
    fromEnum ContentRepeat
ContentRepeatYAxis = Int
2
    fromEnum ContentRepeat
ContentRepeatBoth = Int
3
    fromEnum (AnotherContentRepeat Int
k) = Int
k

    toEnum :: Int -> ContentRepeat
toEnum Int
0 = ContentRepeat
ContentRepeatNone
    toEnum Int
1 = ContentRepeat
ContentRepeatXAxis
    toEnum Int
2 = ContentRepeat
ContentRepeatYAxis
    toEnum Int
3 = ContentRepeat
ContentRepeatBoth
    toEnum Int
k = Int -> ContentRepeat
AnotherContentRepeat Int
k

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

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

foreign import ccall "clutter_content_repeat_get_type" c_clutter_content_repeat_get_type :: 
    IO GType

instance B.Types.TypedObject ContentRepeat where
    glibType :: IO GType
glibType = IO GType
c_clutter_content_repeat_get_type

instance B.Types.BoxedFlags ContentRepeat

instance IsGFlag ContentRepeat

-- Flags AllocationFlags
-- | Flags passed to the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@() virtual function
-- and to the 'GI.Clutter.Objects.Actor.actorAllocate' function.
-- 
-- /Since: 1.0/
data AllocationFlags = 
      AllocationFlagsAllocationNone
    -- ^ No flag set
    | AllocationFlagsAbsoluteOriginChanged
    -- ^ Whether the absolute origin of the
    --   actor has changed; this implies that any ancestor of the actor has
    --   been moved.
    | AllocationFlagsDelegateLayout
    -- ^ Whether the allocation should be delegated
    --   to the t'GI.Clutter.Objects.LayoutManager.LayoutManager' instance stored inside the
    --   [Actor:layoutManager]("GI.Clutter.Objects.Actor#g:attr:layoutManager") property of t'GI.Clutter.Objects.Actor.Actor'. This flag
    --   should only be used if you are subclassing t'GI.Clutter.Objects.Actor.Actor' and
    --   overriding the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@() virtual function, but
    --   you wish to use the default implementation of the virtual function
    --   inside t'GI.Clutter.Objects.Actor.Actor'. Added in Clutter 1.10.
    | AnotherAllocationFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AllocationFlags -> ShowS
[AllocationFlags] -> ShowS
AllocationFlags -> String
(Int -> AllocationFlags -> ShowS)
-> (AllocationFlags -> String)
-> ([AllocationFlags] -> ShowS)
-> Show AllocationFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AllocationFlags -> ShowS
showsPrec :: Int -> AllocationFlags -> ShowS
$cshow :: AllocationFlags -> String
show :: AllocationFlags -> String
$cshowList :: [AllocationFlags] -> ShowS
showList :: [AllocationFlags] -> ShowS
Show, AllocationFlags -> AllocationFlags -> Bool
(AllocationFlags -> AllocationFlags -> Bool)
-> (AllocationFlags -> AllocationFlags -> Bool)
-> Eq AllocationFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AllocationFlags -> AllocationFlags -> Bool
== :: AllocationFlags -> AllocationFlags -> Bool
$c/= :: AllocationFlags -> AllocationFlags -> Bool
/= :: AllocationFlags -> AllocationFlags -> Bool
Eq)

instance P.Enum AllocationFlags where
    fromEnum :: AllocationFlags -> Int
fromEnum AllocationFlags
AllocationFlagsAllocationNone = Int
0
    fromEnum AllocationFlags
AllocationFlagsAbsoluteOriginChanged = Int
2
    fromEnum AllocationFlags
AllocationFlagsDelegateLayout = Int
4
    fromEnum (AnotherAllocationFlags Int
k) = Int
k

    toEnum :: Int -> AllocationFlags
toEnum Int
0 = AllocationFlags
AllocationFlagsAllocationNone
    toEnum Int
2 = AllocationFlags
AllocationFlagsAbsoluteOriginChanged
    toEnum Int
4 = AllocationFlags
AllocationFlagsDelegateLayout
    toEnum Int
k = Int -> AllocationFlags
AnotherAllocationFlags Int
k

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

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

foreign import ccall "clutter_allocation_flags_get_type" c_clutter_allocation_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AllocationFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_allocation_flags_get_type

instance B.Types.BoxedFlags AllocationFlags

instance IsGFlag AllocationFlags

-- Flags ActorFlags
-- | Flags used to signal the state of an actor.
data ActorFlags = 
      ActorFlagsMapped
    -- ^ the actor will be painted (is visible, and inside
    --   a toplevel, and all parents visible)
    | ActorFlagsRealized
    -- ^ the resources associated to the actor have been
    --   allocated
    | ActorFlagsReactive
    -- ^ the actor \'reacts\' to mouse events emmitting event
    --   signals
    | ActorFlagsVisible
    -- ^ the actor has been shown by the application program
    | ActorFlagsNoLayout
    -- ^ the actor provides an explicit layout management
    --   policy for its children; this flag will prevent Clutter from automatic
    --   queueing of relayout and will defer all layouting to the actor itself
    | AnotherActorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActorFlags -> ShowS
[ActorFlags] -> ShowS
ActorFlags -> String
(Int -> ActorFlags -> ShowS)
-> (ActorFlags -> String)
-> ([ActorFlags] -> ShowS)
-> Show ActorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ActorFlags -> ShowS
showsPrec :: Int -> ActorFlags -> ShowS
$cshow :: ActorFlags -> String
show :: ActorFlags -> String
$cshowList :: [ActorFlags] -> ShowS
showList :: [ActorFlags] -> ShowS
Show, ActorFlags -> ActorFlags -> Bool
(ActorFlags -> ActorFlags -> Bool)
-> (ActorFlags -> ActorFlags -> Bool) -> Eq ActorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActorFlags -> ActorFlags -> Bool
== :: ActorFlags -> ActorFlags -> Bool
$c/= :: ActorFlags -> ActorFlags -> Bool
/= :: ActorFlags -> ActorFlags -> Bool
Eq)

instance P.Enum ActorFlags where
    fromEnum :: ActorFlags -> Int
fromEnum ActorFlags
ActorFlagsMapped = Int
2
    fromEnum ActorFlags
ActorFlagsRealized = Int
4
    fromEnum ActorFlags
ActorFlagsReactive = Int
8
    fromEnum ActorFlags
ActorFlagsVisible = Int
16
    fromEnum ActorFlags
ActorFlagsNoLayout = Int
32
    fromEnum (AnotherActorFlags Int
k) = Int
k

    toEnum :: Int -> ActorFlags
toEnum Int
2 = ActorFlags
ActorFlagsMapped
    toEnum Int
4 = ActorFlags
ActorFlagsRealized
    toEnum Int
8 = ActorFlags
ActorFlagsReactive
    toEnum Int
16 = ActorFlags
ActorFlagsVisible
    toEnum Int
32 = ActorFlags
ActorFlagsNoLayout
    toEnum Int
k = Int -> ActorFlags
AnotherActorFlags Int
k

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

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

foreign import ccall "clutter_actor_flags_get_type" c_clutter_actor_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ActorFlags where
    glibType :: IO GType
glibType = IO GType
c_clutter_actor_flags_get_type

instance B.Types.BoxedFlags ActorFlags

instance IsGFlag ActorFlags