#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Handy.Enums
(
CenteringPolicy(..) ,
DeckTransitionType(..) ,
FlapFoldPolicy(..) ,
FlapTransitionType(..) ,
HeaderGroupChildType(..) ,
LeafletTransitionType(..) ,
NavigationDirection(..) ,
SqueezerTransitionType(..) ,
ViewSwitcherPolicy(..) ,
) 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.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
data ViewSwitcherPolicy =
ViewSwitcherPolicyAuto
| ViewSwitcherPolicyNarrow
| ViewSwitcherPolicyWide
| AnotherViewSwitcherPolicy Int
deriving (Int -> ViewSwitcherPolicy -> ShowS
[ViewSwitcherPolicy] -> ShowS
ViewSwitcherPolicy -> String
(Int -> ViewSwitcherPolicy -> ShowS)
-> (ViewSwitcherPolicy -> String)
-> ([ViewSwitcherPolicy] -> ShowS)
-> Show ViewSwitcherPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ViewSwitcherPolicy] -> ShowS
$cshowList :: [ViewSwitcherPolicy] -> ShowS
show :: ViewSwitcherPolicy -> String
$cshow :: ViewSwitcherPolicy -> String
showsPrec :: Int -> ViewSwitcherPolicy -> ShowS
$cshowsPrec :: Int -> ViewSwitcherPolicy -> ShowS
Show, ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
(ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool)
-> (ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool)
-> Eq ViewSwitcherPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
$c/= :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
== :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
$c== :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
Eq)
instance P.Enum ViewSwitcherPolicy where
fromEnum :: ViewSwitcherPolicy -> Int
fromEnum ViewSwitcherPolicy
ViewSwitcherPolicyAuto = Int
0
fromEnum ViewSwitcherPolicy
ViewSwitcherPolicyNarrow = Int
1
fromEnum ViewSwitcherPolicy
ViewSwitcherPolicyWide = Int
2
fromEnum (AnotherViewSwitcherPolicy Int
k) = Int
k
toEnum :: Int -> ViewSwitcherPolicy
toEnum Int
0 = ViewSwitcherPolicy
ViewSwitcherPolicyAuto
toEnum Int
1 = ViewSwitcherPolicy
ViewSwitcherPolicyNarrow
toEnum Int
2 = ViewSwitcherPolicy
ViewSwitcherPolicyWide
toEnum Int
k = Int -> ViewSwitcherPolicy
AnotherViewSwitcherPolicy Int
k
instance P.Ord ViewSwitcherPolicy where
compare :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Ordering
compare ViewSwitcherPolicy
a ViewSwitcherPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ViewSwitcherPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ViewSwitcherPolicy
a) (ViewSwitcherPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ViewSwitcherPolicy
b)
type instance O.ParentTypes ViewSwitcherPolicy = '[]
instance O.HasParentTypes ViewSwitcherPolicy
foreign import ccall "hdy_view_switcher_policy_get_type" c_hdy_view_switcher_policy_get_type ::
IO GType
instance B.Types.TypedObject ViewSwitcherPolicy where
glibType :: IO GType
glibType = IO GType
c_hdy_view_switcher_policy_get_type
instance B.Types.BoxedEnum ViewSwitcherPolicy
data SqueezerTransitionType =
SqueezerTransitionTypeNone
| SqueezerTransitionTypeCrossfade
| AnotherSqueezerTransitionType Int
deriving (Int -> SqueezerTransitionType -> ShowS
[SqueezerTransitionType] -> ShowS
SqueezerTransitionType -> String
(Int -> SqueezerTransitionType -> ShowS)
-> (SqueezerTransitionType -> String)
-> ([SqueezerTransitionType] -> ShowS)
-> Show SqueezerTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SqueezerTransitionType] -> ShowS
$cshowList :: [SqueezerTransitionType] -> ShowS
show :: SqueezerTransitionType -> String
$cshow :: SqueezerTransitionType -> String
showsPrec :: Int -> SqueezerTransitionType -> ShowS
$cshowsPrec :: Int -> SqueezerTransitionType -> ShowS
Show, SqueezerTransitionType -> SqueezerTransitionType -> Bool
(SqueezerTransitionType -> SqueezerTransitionType -> Bool)
-> (SqueezerTransitionType -> SqueezerTransitionType -> Bool)
-> Eq SqueezerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
$c/= :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
== :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
$c== :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
Eq)
instance P.Enum SqueezerTransitionType where
fromEnum :: SqueezerTransitionType -> Int
fromEnum SqueezerTransitionType
SqueezerTransitionTypeNone = Int
0
fromEnum SqueezerTransitionType
SqueezerTransitionTypeCrossfade = Int
1
fromEnum (AnotherSqueezerTransitionType Int
k) = Int
k
toEnum :: Int -> SqueezerTransitionType
toEnum Int
0 = SqueezerTransitionType
SqueezerTransitionTypeNone
toEnum Int
1 = SqueezerTransitionType
SqueezerTransitionTypeCrossfade
toEnum Int
k = Int -> SqueezerTransitionType
AnotherSqueezerTransitionType Int
k
instance P.Ord SqueezerTransitionType where
compare :: SqueezerTransitionType -> SqueezerTransitionType -> Ordering
compare SqueezerTransitionType
a SqueezerTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SqueezerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum SqueezerTransitionType
a) (SqueezerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum SqueezerTransitionType
b)
type instance O.ParentTypes SqueezerTransitionType = '[]
instance O.HasParentTypes SqueezerTransitionType
foreign import ccall "hdy_squeezer_transition_type_get_type" c_hdy_squeezer_transition_type_get_type ::
IO GType
instance B.Types.TypedObject SqueezerTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_squeezer_transition_type_get_type
instance B.Types.BoxedEnum SqueezerTransitionType
data NavigationDirection =
NavigationDirectionBack
| NavigationDirectionForward
| AnotherNavigationDirection Int
deriving (Int -> NavigationDirection -> ShowS
[NavigationDirection] -> ShowS
NavigationDirection -> String
(Int -> NavigationDirection -> ShowS)
-> (NavigationDirection -> String)
-> ([NavigationDirection] -> ShowS)
-> Show NavigationDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationDirection] -> ShowS
$cshowList :: [NavigationDirection] -> ShowS
show :: NavigationDirection -> String
$cshow :: NavigationDirection -> String
showsPrec :: Int -> NavigationDirection -> ShowS
$cshowsPrec :: Int -> NavigationDirection -> ShowS
Show, NavigationDirection -> NavigationDirection -> Bool
(NavigationDirection -> NavigationDirection -> Bool)
-> (NavigationDirection -> NavigationDirection -> Bool)
-> Eq NavigationDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationDirection -> NavigationDirection -> Bool
$c/= :: NavigationDirection -> NavigationDirection -> Bool
== :: NavigationDirection -> NavigationDirection -> Bool
$c== :: NavigationDirection -> NavigationDirection -> Bool
Eq)
instance P.Enum NavigationDirection where
fromEnum :: NavigationDirection -> Int
fromEnum NavigationDirection
NavigationDirectionBack = Int
0
fromEnum NavigationDirection
NavigationDirectionForward = Int
1
fromEnum (AnotherNavigationDirection Int
k) = Int
k
toEnum :: Int -> NavigationDirection
toEnum Int
0 = NavigationDirection
NavigationDirectionBack
toEnum Int
1 = NavigationDirection
NavigationDirectionForward
toEnum Int
k = Int -> NavigationDirection
AnotherNavigationDirection Int
k
instance P.Ord NavigationDirection where
compare :: NavigationDirection -> NavigationDirection -> Ordering
compare NavigationDirection
a NavigationDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NavigationDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationDirection
a) (NavigationDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationDirection
b)
type instance O.ParentTypes NavigationDirection = '[]
instance O.HasParentTypes NavigationDirection
foreign import ccall "hdy_navigation_direction_get_type" c_hdy_navigation_direction_get_type ::
IO GType
instance B.Types.TypedObject NavigationDirection where
glibType :: IO GType
glibType = IO GType
c_hdy_navigation_direction_get_type
instance B.Types.BoxedEnum NavigationDirection
data LeafletTransitionType =
LeafletTransitionTypeOver
| LeafletTransitionTypeUnder
| LeafletTransitionTypeSlide
| AnotherLeafletTransitionType Int
deriving (Int -> LeafletTransitionType -> ShowS
[LeafletTransitionType] -> ShowS
LeafletTransitionType -> String
(Int -> LeafletTransitionType -> ShowS)
-> (LeafletTransitionType -> String)
-> ([LeafletTransitionType] -> ShowS)
-> Show LeafletTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LeafletTransitionType] -> ShowS
$cshowList :: [LeafletTransitionType] -> ShowS
show :: LeafletTransitionType -> String
$cshow :: LeafletTransitionType -> String
showsPrec :: Int -> LeafletTransitionType -> ShowS
$cshowsPrec :: Int -> LeafletTransitionType -> ShowS
Show, LeafletTransitionType -> LeafletTransitionType -> Bool
(LeafletTransitionType -> LeafletTransitionType -> Bool)
-> (LeafletTransitionType -> LeafletTransitionType -> Bool)
-> Eq LeafletTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LeafletTransitionType -> LeafletTransitionType -> Bool
$c/= :: LeafletTransitionType -> LeafletTransitionType -> Bool
== :: LeafletTransitionType -> LeafletTransitionType -> Bool
$c== :: LeafletTransitionType -> LeafletTransitionType -> Bool
Eq)
instance P.Enum LeafletTransitionType where
fromEnum :: LeafletTransitionType -> Int
fromEnum LeafletTransitionType
LeafletTransitionTypeOver = Int
0
fromEnum LeafletTransitionType
LeafletTransitionTypeUnder = Int
1
fromEnum LeafletTransitionType
LeafletTransitionTypeSlide = Int
2
fromEnum (AnotherLeafletTransitionType Int
k) = Int
k
toEnum :: Int -> LeafletTransitionType
toEnum Int
0 = LeafletTransitionType
LeafletTransitionTypeOver
toEnum Int
1 = LeafletTransitionType
LeafletTransitionTypeUnder
toEnum Int
2 = LeafletTransitionType
LeafletTransitionTypeSlide
toEnum Int
k = Int -> LeafletTransitionType
AnotherLeafletTransitionType Int
k
instance P.Ord LeafletTransitionType where
compare :: LeafletTransitionType -> LeafletTransitionType -> Ordering
compare LeafletTransitionType
a LeafletTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LeafletTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletTransitionType
a) (LeafletTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletTransitionType
b)
type instance O.ParentTypes LeafletTransitionType = '[]
instance O.HasParentTypes LeafletTransitionType
foreign import ccall "hdy_leaflet_transition_type_get_type" c_hdy_leaflet_transition_type_get_type ::
IO GType
instance B.Types.TypedObject LeafletTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_leaflet_transition_type_get_type
instance B.Types.BoxedEnum LeafletTransitionType
data =
|
|
| Int
deriving (Int -> HeaderGroupChildType -> ShowS
[HeaderGroupChildType] -> ShowS
HeaderGroupChildType -> String
(Int -> HeaderGroupChildType -> ShowS)
-> (HeaderGroupChildType -> String)
-> ([HeaderGroupChildType] -> ShowS)
-> Show HeaderGroupChildType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HeaderGroupChildType] -> ShowS
$cshowList :: [HeaderGroupChildType] -> ShowS
show :: HeaderGroupChildType -> String
$cshow :: HeaderGroupChildType -> String
showsPrec :: Int -> HeaderGroupChildType -> ShowS
$cshowsPrec :: Int -> HeaderGroupChildType -> ShowS
Show, HeaderGroupChildType -> HeaderGroupChildType -> Bool
(HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> (HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> Eq HeaderGroupChildType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
$c/= :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
== :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
$c== :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
Eq)
instance P.Enum HeaderGroupChildType where
fromEnum :: HeaderGroupChildType -> Int
fromEnum HeaderGroupChildType
HeaderGroupChildTypeHeaderBar = Int
0
fromEnum HeaderGroupChildType
HeaderGroupChildTypeGtkHeaderBar = Int
1
fromEnum HeaderGroupChildType
HeaderGroupChildTypeHeaderGroup = Int
2
fromEnum (AnotherHeaderGroupChildType Int
k) = Int
k
toEnum :: Int -> HeaderGroupChildType
toEnum Int
0 = HeaderGroupChildType
HeaderGroupChildTypeHeaderBar
toEnum Int
1 = HeaderGroupChildType
HeaderGroupChildTypeGtkHeaderBar
toEnum Int
2 = HeaderGroupChildType
HeaderGroupChildTypeHeaderGroup
toEnum Int
k = Int -> HeaderGroupChildType
AnotherHeaderGroupChildType Int
k
instance P.Ord HeaderGroupChildType where
compare :: HeaderGroupChildType -> HeaderGroupChildType -> Ordering
compare HeaderGroupChildType
a HeaderGroupChildType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (HeaderGroupChildType -> Int
forall a. Enum a => a -> Int
P.fromEnum HeaderGroupChildType
a) (HeaderGroupChildType -> Int
forall a. Enum a => a -> Int
P.fromEnum HeaderGroupChildType
b)
type instance O.ParentTypes HeaderGroupChildType = '[]
instance O.HasParentTypes HeaderGroupChildType
foreign import ccall "hdy_header_group_child_type_get_type" ::
IO GType
instance B.Types.TypedObject HeaderGroupChildType where
glibType :: IO GType
glibType = IO GType
c_hdy_header_group_child_type_get_type
instance B.Types.BoxedEnum HeaderGroupChildType
data FlapTransitionType =
FlapTransitionTypeOver
| FlapTransitionTypeUnder
| FlapTransitionTypeSlide
| AnotherFlapTransitionType Int
deriving (Int -> FlapTransitionType -> ShowS
[FlapTransitionType] -> ShowS
FlapTransitionType -> String
(Int -> FlapTransitionType -> ShowS)
-> (FlapTransitionType -> String)
-> ([FlapTransitionType] -> ShowS)
-> Show FlapTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FlapTransitionType] -> ShowS
$cshowList :: [FlapTransitionType] -> ShowS
show :: FlapTransitionType -> String
$cshow :: FlapTransitionType -> String
showsPrec :: Int -> FlapTransitionType -> ShowS
$cshowsPrec :: Int -> FlapTransitionType -> ShowS
Show, FlapTransitionType -> FlapTransitionType -> Bool
(FlapTransitionType -> FlapTransitionType -> Bool)
-> (FlapTransitionType -> FlapTransitionType -> Bool)
-> Eq FlapTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlapTransitionType -> FlapTransitionType -> Bool
$c/= :: FlapTransitionType -> FlapTransitionType -> Bool
== :: FlapTransitionType -> FlapTransitionType -> Bool
$c== :: FlapTransitionType -> FlapTransitionType -> Bool
Eq)
instance P.Enum FlapTransitionType where
fromEnum :: FlapTransitionType -> Int
fromEnum FlapTransitionType
FlapTransitionTypeOver = Int
0
fromEnum FlapTransitionType
FlapTransitionTypeUnder = Int
1
fromEnum FlapTransitionType
FlapTransitionTypeSlide = Int
2
fromEnum (AnotherFlapTransitionType Int
k) = Int
k
toEnum :: Int -> FlapTransitionType
toEnum Int
0 = FlapTransitionType
FlapTransitionTypeOver
toEnum Int
1 = FlapTransitionType
FlapTransitionTypeUnder
toEnum Int
2 = FlapTransitionType
FlapTransitionTypeSlide
toEnum Int
k = Int -> FlapTransitionType
AnotherFlapTransitionType Int
k
instance P.Ord FlapTransitionType where
compare :: FlapTransitionType -> FlapTransitionType -> Ordering
compare FlapTransitionType
a FlapTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FlapTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum FlapTransitionType
a) (FlapTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum FlapTransitionType
b)
type instance O.ParentTypes FlapTransitionType = '[]
instance O.HasParentTypes FlapTransitionType
foreign import ccall "hdy_flap_transition_type_get_type" c_hdy_flap_transition_type_get_type ::
IO GType
instance B.Types.TypedObject FlapTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_flap_transition_type_get_type
instance B.Types.BoxedEnum FlapTransitionType
data FlapFoldPolicy =
FlapFoldPolicyNever
| FlapFoldPolicyAlways
| FlapFoldPolicyAuto
| AnotherFlapFoldPolicy Int
deriving (Int -> FlapFoldPolicy -> ShowS
[FlapFoldPolicy] -> ShowS
FlapFoldPolicy -> String
(Int -> FlapFoldPolicy -> ShowS)
-> (FlapFoldPolicy -> String)
-> ([FlapFoldPolicy] -> ShowS)
-> Show FlapFoldPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FlapFoldPolicy] -> ShowS
$cshowList :: [FlapFoldPolicy] -> ShowS
show :: FlapFoldPolicy -> String
$cshow :: FlapFoldPolicy -> String
showsPrec :: Int -> FlapFoldPolicy -> ShowS
$cshowsPrec :: Int -> FlapFoldPolicy -> ShowS
Show, FlapFoldPolicy -> FlapFoldPolicy -> Bool
(FlapFoldPolicy -> FlapFoldPolicy -> Bool)
-> (FlapFoldPolicy -> FlapFoldPolicy -> Bool) -> Eq FlapFoldPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
$c/= :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
== :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
$c== :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
Eq)
instance P.Enum FlapFoldPolicy where
fromEnum :: FlapFoldPolicy -> Int
fromEnum FlapFoldPolicy
FlapFoldPolicyNever = Int
0
fromEnum FlapFoldPolicy
FlapFoldPolicyAlways = Int
1
fromEnum FlapFoldPolicy
FlapFoldPolicyAuto = Int
2
fromEnum (AnotherFlapFoldPolicy Int
k) = Int
k
toEnum :: Int -> FlapFoldPolicy
toEnum Int
0 = FlapFoldPolicy
FlapFoldPolicyNever
toEnum Int
1 = FlapFoldPolicy
FlapFoldPolicyAlways
toEnum Int
2 = FlapFoldPolicy
FlapFoldPolicyAuto
toEnum Int
k = Int -> FlapFoldPolicy
AnotherFlapFoldPolicy Int
k
instance P.Ord FlapFoldPolicy where
compare :: FlapFoldPolicy -> FlapFoldPolicy -> Ordering
compare FlapFoldPolicy
a FlapFoldPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FlapFoldPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum FlapFoldPolicy
a) (FlapFoldPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum FlapFoldPolicy
b)
type instance O.ParentTypes FlapFoldPolicy = '[]
instance O.HasParentTypes FlapFoldPolicy
foreign import ccall "hdy_flap_fold_policy_get_type" c_hdy_flap_fold_policy_get_type ::
IO GType
instance B.Types.TypedObject FlapFoldPolicy where
glibType :: IO GType
glibType = IO GType
c_hdy_flap_fold_policy_get_type
instance B.Types.BoxedEnum FlapFoldPolicy
data DeckTransitionType =
DeckTransitionTypeOver
| DeckTransitionTypeUnder
| DeckTransitionTypeSlide
| AnotherDeckTransitionType Int
deriving (Int -> DeckTransitionType -> ShowS
[DeckTransitionType] -> ShowS
DeckTransitionType -> String
(Int -> DeckTransitionType -> ShowS)
-> (DeckTransitionType -> String)
-> ([DeckTransitionType] -> ShowS)
-> Show DeckTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeckTransitionType] -> ShowS
$cshowList :: [DeckTransitionType] -> ShowS
show :: DeckTransitionType -> String
$cshow :: DeckTransitionType -> String
showsPrec :: Int -> DeckTransitionType -> ShowS
$cshowsPrec :: Int -> DeckTransitionType -> ShowS
Show, DeckTransitionType -> DeckTransitionType -> Bool
(DeckTransitionType -> DeckTransitionType -> Bool)
-> (DeckTransitionType -> DeckTransitionType -> Bool)
-> Eq DeckTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeckTransitionType -> DeckTransitionType -> Bool
$c/= :: DeckTransitionType -> DeckTransitionType -> Bool
== :: DeckTransitionType -> DeckTransitionType -> Bool
$c== :: DeckTransitionType -> DeckTransitionType -> Bool
Eq)
instance P.Enum DeckTransitionType where
fromEnum :: DeckTransitionType -> Int
fromEnum DeckTransitionType
DeckTransitionTypeOver = Int
0
fromEnum DeckTransitionType
DeckTransitionTypeUnder = Int
1
fromEnum DeckTransitionType
DeckTransitionTypeSlide = Int
2
fromEnum (AnotherDeckTransitionType Int
k) = Int
k
toEnum :: Int -> DeckTransitionType
toEnum Int
0 = DeckTransitionType
DeckTransitionTypeOver
toEnum Int
1 = DeckTransitionType
DeckTransitionTypeUnder
toEnum Int
2 = DeckTransitionType
DeckTransitionTypeSlide
toEnum Int
k = Int -> DeckTransitionType
AnotherDeckTransitionType Int
k
instance P.Ord DeckTransitionType where
compare :: DeckTransitionType -> DeckTransitionType -> Ordering
compare DeckTransitionType
a DeckTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeckTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeckTransitionType
a) (DeckTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeckTransitionType
b)
type instance O.ParentTypes DeckTransitionType = '[]
instance O.HasParentTypes DeckTransitionType
foreign import ccall "hdy_deck_transition_type_get_type" c_hdy_deck_transition_type_get_type ::
IO GType
instance B.Types.TypedObject DeckTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_deck_transition_type_get_type
instance B.Types.BoxedEnum DeckTransitionType
data CenteringPolicy =
CenteringPolicyLoose
| CenteringPolicyStrict
| AnotherCenteringPolicy Int
deriving (Int -> CenteringPolicy -> ShowS
[CenteringPolicy] -> ShowS
CenteringPolicy -> String
(Int -> CenteringPolicy -> ShowS)
-> (CenteringPolicy -> String)
-> ([CenteringPolicy] -> ShowS)
-> Show CenteringPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CenteringPolicy] -> ShowS
$cshowList :: [CenteringPolicy] -> ShowS
show :: CenteringPolicy -> String
$cshow :: CenteringPolicy -> String
showsPrec :: Int -> CenteringPolicy -> ShowS
$cshowsPrec :: Int -> CenteringPolicy -> ShowS
Show, CenteringPolicy -> CenteringPolicy -> Bool
(CenteringPolicy -> CenteringPolicy -> Bool)
-> (CenteringPolicy -> CenteringPolicy -> Bool)
-> Eq CenteringPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CenteringPolicy -> CenteringPolicy -> Bool
$c/= :: CenteringPolicy -> CenteringPolicy -> Bool
== :: CenteringPolicy -> CenteringPolicy -> Bool
$c== :: CenteringPolicy -> CenteringPolicy -> Bool
Eq)
instance P.Enum CenteringPolicy where
fromEnum :: CenteringPolicy -> Int
fromEnum CenteringPolicy
CenteringPolicyLoose = Int
0
fromEnum CenteringPolicy
CenteringPolicyStrict = Int
1
fromEnum (AnotherCenteringPolicy Int
k) = Int
k
toEnum :: Int -> CenteringPolicy
toEnum Int
0 = CenteringPolicy
CenteringPolicyLoose
toEnum Int
1 = CenteringPolicy
CenteringPolicyStrict
toEnum Int
k = Int -> CenteringPolicy
AnotherCenteringPolicy Int
k
instance P.Ord CenteringPolicy where
compare :: CenteringPolicy -> CenteringPolicy -> Ordering
compare CenteringPolicy
a CenteringPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CenteringPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum CenteringPolicy
a) (CenteringPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum CenteringPolicy
b)
type instance O.ParentTypes CenteringPolicy = '[]
instance O.HasParentTypes CenteringPolicy
foreign import ccall "hdy_centering_policy_get_type" c_hdy_centering_policy_get_type ::
IO GType
instance B.Types.TypedObject CenteringPolicy where
glibType :: IO GType
glibType = IO GType
c_hdy_centering_policy_get_type
instance B.Types.BoxedEnum CenteringPolicy