#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Flags
(
ActorFlags(..) ,
AllocationFlags(..) ,
ContentRepeat(..) ,
EffectPaintFlags(..) ,
EventFlags(..) ,
FeatureFlags(..) ,
FontFlags(..) ,
ModifierType(..) ,
OffscreenRedirect(..) ,
RepaintFlags(..) ,
ScrollFinishFlags(..) ,
ScrollMode(..) ,
StageState(..) ,
SwipeDirection(..) ,
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
{-# DEPRECATED TextureFlags ["(Since version 1.22)","The t'GI.Clutter.Objects.Texture.Texture' class was the only user of"," this API"] #-}
data TextureFlags =
TextureFlagsNone
| TextureFlagsRgbFlagBgr
| TextureFlagsRgbFlagPremult
| TextureFlagsYuvFlagYuv2
| AnotherTextureFlags Int
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
data SwipeDirection =
SwipeDirectionUp
| SwipeDirectionDown
| SwipeDirectionLeft
| SwipeDirectionRight
| AnotherSwipeDirection Int
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
data StageState =
StageStateFullscreen
| StageStateOffscreen
| StageStateActivated
| AnotherStageState Int
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
data ScrollMode =
ScrollModeNone
| ScrollModeHorizontally
| ScrollModeVertically
| ScrollModeBoth
| AnotherScrollMode Int
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
data ScrollFinishFlags =
ScrollFinishFlagsNone
| ScrollFinishFlagsHorizontal
| ScrollFinishFlagsVertical
| AnotherScrollFinishFlags Int
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
data RepaintFlags =
RepaintFlagsPrePaint
| RepaintFlagsPostPaint
| RepaintFlagsQueueRedrawOnAdd
| AnotherRepaintFlags Int
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
data OffscreenRedirect =
OffscreenRedirectAutomaticForOpacity
| OffscreenRedirectAlways
| AnotherOffscreenRedirect Int
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
data ModifierType =
ModifierTypeShiftMask
| ModifierTypeLockMask
| ModifierTypeControlMask
| ModifierTypeMod1Mask
| ModifierTypeMod2Mask
| ModifierTypeMod3Mask
| ModifierTypeMod4Mask
| ModifierTypeMod5Mask
| ModifierTypeButton1Mask
| ModifierTypeButton2Mask
| ModifierTypeButton3Mask
| ModifierTypeButton4Mask
| ModifierTypeButton5Mask
| ModifierTypeModifierReserved13Mask
| ModifierTypeModifierReserved14Mask
| ModifierTypeModifierReserved15Mask
| ModifierTypeModifierReserved16Mask
| ModifierTypeModifierReserved17Mask
| ModifierTypeModifierReserved18Mask
| ModifierTypeModifierReserved19Mask
| ModifierTypeModifierReserved20Mask
| ModifierTypeModifierReserved21Mask
| ModifierTypeModifierReserved22Mask
| ModifierTypeModifierReserved23Mask
| ModifierTypeModifierReserved24Mask
| ModifierTypeModifierReserved25Mask
| ModifierTypeSuperMask
| ModifierTypeHyperMask
| ModifierTypeMetaMask
| ModifierTypeModifierReserved29Mask
| ModifierTypeReleaseMask
| ModifierTypeModifierMask
| AnotherModifierType Int
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
{-# DEPRECATED FontFlags ["(Since version 1.22)","Use t'GI.Cairo.Structs.FontOptions.FontOptions' instead"] #-}
data FontFlags =
FontFlagsMipmapping
| FontFlagsHinting
| AnotherFontFlags Int
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
data FeatureFlags =
FeatureFlagsTextureNpot
| FeatureFlagsSyncToVblank
| FeatureFlagsTextureYuv
| FeatureFlagsTextureReadPixels
| FeatureFlagsStageStatic
| FeatureFlagsStageUserResize
| FeatureFlagsStageCursor
| FeatureFlagsShadersGlsl
| FeatureFlagsOffscreen
| FeatureFlagsStageMultiple
| FeatureFlagsSwapEvents
| AnotherFeatureFlags Int
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
data EventFlags =
EventFlagsNone
| EventFlagsFlagSynthetic
| AnotherEventFlags Int
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
data EffectPaintFlags =
EffectPaintFlagsActorDirty
| AnotherEffectPaintFlags Int
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
data ContentRepeat =
ContentRepeatNone
| ContentRepeatXAxis
| ContentRepeatYAxis
| ContentRepeatBoth
| AnotherContentRepeat Int
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
data AllocationFlags =
AllocationFlagsAllocationNone
| AllocationFlagsAbsoluteOriginChanged
| AllocationFlagsDelegateLayout
| AnotherAllocationFlags Int
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
data ActorFlags =
ActorFlagsMapped
| ActorFlagsRealized
| ActorFlagsReactive
| ActorFlagsVisible
| ActorFlagsNoLayout
| AnotherActorFlags Int
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