#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Handy.Enums
(
ArrowsDirection(..) ,
CenteringPolicy(..) ,
Fold(..) ,
LeafletChildTransitionType(..) ,
LeafletModeTransitionType(..) ,
LeafletTransitionType(..) ,
PaginatorIndicatorStyle(..) ,
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.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.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
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 PaginatorIndicatorStyle =
PaginatorIndicatorStyleNone
| PaginatorIndicatorStyleDots
| PaginatorIndicatorStyleLines
| AnotherPaginatorIndicatorStyle Int
deriving (Int -> PaginatorIndicatorStyle -> ShowS
[PaginatorIndicatorStyle] -> ShowS
PaginatorIndicatorStyle -> String
(Int -> PaginatorIndicatorStyle -> ShowS)
-> (PaginatorIndicatorStyle -> String)
-> ([PaginatorIndicatorStyle] -> ShowS)
-> Show PaginatorIndicatorStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PaginatorIndicatorStyle] -> ShowS
$cshowList :: [PaginatorIndicatorStyle] -> ShowS
show :: PaginatorIndicatorStyle -> String
$cshow :: PaginatorIndicatorStyle -> String
showsPrec :: Int -> PaginatorIndicatorStyle -> ShowS
$cshowsPrec :: Int -> PaginatorIndicatorStyle -> ShowS
Show, PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool
(PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool)
-> (PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool)
-> Eq PaginatorIndicatorStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool
$c/= :: PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool
== :: PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool
$c== :: PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Bool
Eq)
instance P.Enum PaginatorIndicatorStyle where
fromEnum :: PaginatorIndicatorStyle -> Int
fromEnum PaginatorIndicatorStyle
PaginatorIndicatorStyleNone = Int
0
fromEnum PaginatorIndicatorStyle
PaginatorIndicatorStyleDots = Int
1
fromEnum PaginatorIndicatorStyle
PaginatorIndicatorStyleLines = Int
2
fromEnum (AnotherPaginatorIndicatorStyle Int
k) = Int
k
toEnum :: Int -> PaginatorIndicatorStyle
toEnum Int
0 = PaginatorIndicatorStyle
PaginatorIndicatorStyleNone
toEnum Int
1 = PaginatorIndicatorStyle
PaginatorIndicatorStyleDots
toEnum Int
2 = PaginatorIndicatorStyle
PaginatorIndicatorStyleLines
toEnum Int
k = Int -> PaginatorIndicatorStyle
AnotherPaginatorIndicatorStyle Int
k
instance P.Ord PaginatorIndicatorStyle where
compare :: PaginatorIndicatorStyle -> PaginatorIndicatorStyle -> Ordering
compare PaginatorIndicatorStyle
a PaginatorIndicatorStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PaginatorIndicatorStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum PaginatorIndicatorStyle
a) (PaginatorIndicatorStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum PaginatorIndicatorStyle
b)
type instance O.ParentTypes PaginatorIndicatorStyle = '[]
instance O.HasParentTypes PaginatorIndicatorStyle
foreign import ccall "hdy_paginator_indicator_style_get_type" c_hdy_paginator_indicator_style_get_type ::
IO GType
instance B.Types.TypedObject PaginatorIndicatorStyle where
glibType :: IO GType
glibType = IO GType
c_hdy_paginator_indicator_style_get_type
instance B.Types.BoxedEnum PaginatorIndicatorStyle
data LeafletTransitionType =
LeafletTransitionTypeNone
| LeafletTransitionTypeSlide
| LeafletTransitionTypeOver
| LeafletTransitionTypeUnder
| 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
LeafletTransitionTypeNone = Int
0
fromEnum LeafletTransitionType
LeafletTransitionTypeSlide = Int
1
fromEnum LeafletTransitionType
LeafletTransitionTypeOver = Int
2
fromEnum LeafletTransitionType
LeafletTransitionTypeUnder = Int
3
fromEnum (AnotherLeafletTransitionType Int
k) = Int
k
toEnum :: Int -> LeafletTransitionType
toEnum Int
0 = LeafletTransitionType
LeafletTransitionTypeNone
toEnum Int
1 = LeafletTransitionType
LeafletTransitionTypeSlide
toEnum Int
2 = LeafletTransitionType
LeafletTransitionTypeOver
toEnum Int
3 = LeafletTransitionType
LeafletTransitionTypeUnder
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
{-# DEPRECATED LeafletModeTransitionType ["(Since version 0.0.12)","Use t'GI.Handy.Enums.LeafletTransitionType'"] #-}
data LeafletModeTransitionType =
LeafletModeTransitionTypeNone
| LeafletModeTransitionTypeSlide
| AnotherLeafletModeTransitionType Int
deriving (Int -> LeafletModeTransitionType -> ShowS
[LeafletModeTransitionType] -> ShowS
LeafletModeTransitionType -> String
(Int -> LeafletModeTransitionType -> ShowS)
-> (LeafletModeTransitionType -> String)
-> ([LeafletModeTransitionType] -> ShowS)
-> Show LeafletModeTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LeafletModeTransitionType] -> ShowS
$cshowList :: [LeafletModeTransitionType] -> ShowS
show :: LeafletModeTransitionType -> String
$cshow :: LeafletModeTransitionType -> String
showsPrec :: Int -> LeafletModeTransitionType -> ShowS
$cshowsPrec :: Int -> LeafletModeTransitionType -> ShowS
Show, LeafletModeTransitionType -> LeafletModeTransitionType -> Bool
(LeafletModeTransitionType -> LeafletModeTransitionType -> Bool)
-> (LeafletModeTransitionType -> LeafletModeTransitionType -> Bool)
-> Eq LeafletModeTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LeafletModeTransitionType -> LeafletModeTransitionType -> Bool
$c/= :: LeafletModeTransitionType -> LeafletModeTransitionType -> Bool
== :: LeafletModeTransitionType -> LeafletModeTransitionType -> Bool
$c== :: LeafletModeTransitionType -> LeafletModeTransitionType -> Bool
Eq)
instance P.Enum LeafletModeTransitionType where
fromEnum :: LeafletModeTransitionType -> Int
fromEnum LeafletModeTransitionType
LeafletModeTransitionTypeNone = Int
0
fromEnum LeafletModeTransitionType
LeafletModeTransitionTypeSlide = Int
1
fromEnum (AnotherLeafletModeTransitionType Int
k) = Int
k
toEnum :: Int -> LeafletModeTransitionType
toEnum Int
0 = LeafletModeTransitionType
LeafletModeTransitionTypeNone
toEnum Int
1 = LeafletModeTransitionType
LeafletModeTransitionTypeSlide
toEnum Int
k = Int -> LeafletModeTransitionType
AnotherLeafletModeTransitionType Int
k
instance P.Ord LeafletModeTransitionType where
compare :: LeafletModeTransitionType -> LeafletModeTransitionType -> Ordering
compare LeafletModeTransitionType
a LeafletModeTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LeafletModeTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletModeTransitionType
a) (LeafletModeTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletModeTransitionType
b)
type instance O.ParentTypes LeafletModeTransitionType = '[]
instance O.HasParentTypes LeafletModeTransitionType
foreign import ccall "hdy_leaflet_mode_transition_type_get_type" c_hdy_leaflet_mode_transition_type_get_type ::
IO GType
instance B.Types.TypedObject LeafletModeTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_leaflet_mode_transition_type_get_type
instance B.Types.BoxedEnum LeafletModeTransitionType
{-# DEPRECATED LeafletChildTransitionType ["(Since version 0.0.12)","Use t'GI.Handy.Enums.LeafletTransitionType'"] #-}
data LeafletChildTransitionType =
LeafletChildTransitionTypeNone
| LeafletChildTransitionTypeCrossfade
| LeafletChildTransitionTypeSlide
| LeafletChildTransitionTypeOver
| LeafletChildTransitionTypeUnder
| AnotherLeafletChildTransitionType Int
deriving (Int -> LeafletChildTransitionType -> ShowS
[LeafletChildTransitionType] -> ShowS
LeafletChildTransitionType -> String
(Int -> LeafletChildTransitionType -> ShowS)
-> (LeafletChildTransitionType -> String)
-> ([LeafletChildTransitionType] -> ShowS)
-> Show LeafletChildTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LeafletChildTransitionType] -> ShowS
$cshowList :: [LeafletChildTransitionType] -> ShowS
show :: LeafletChildTransitionType -> String
$cshow :: LeafletChildTransitionType -> String
showsPrec :: Int -> LeafletChildTransitionType -> ShowS
$cshowsPrec :: Int -> LeafletChildTransitionType -> ShowS
Show, LeafletChildTransitionType -> LeafletChildTransitionType -> Bool
(LeafletChildTransitionType -> LeafletChildTransitionType -> Bool)
-> (LeafletChildTransitionType
-> LeafletChildTransitionType -> Bool)
-> Eq LeafletChildTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LeafletChildTransitionType -> LeafletChildTransitionType -> Bool
$c/= :: LeafletChildTransitionType -> LeafletChildTransitionType -> Bool
== :: LeafletChildTransitionType -> LeafletChildTransitionType -> Bool
$c== :: LeafletChildTransitionType -> LeafletChildTransitionType -> Bool
Eq)
instance P.Enum LeafletChildTransitionType where
fromEnum :: LeafletChildTransitionType -> Int
fromEnum LeafletChildTransitionType
LeafletChildTransitionTypeNone = Int
0
fromEnum LeafletChildTransitionType
LeafletChildTransitionTypeCrossfade = Int
1
fromEnum LeafletChildTransitionType
LeafletChildTransitionTypeSlide = Int
2
fromEnum LeafletChildTransitionType
LeafletChildTransitionTypeOver = Int
3
fromEnum LeafletChildTransitionType
LeafletChildTransitionTypeUnder = Int
4
fromEnum (AnotherLeafletChildTransitionType Int
k) = Int
k
toEnum :: Int -> LeafletChildTransitionType
toEnum Int
0 = LeafletChildTransitionType
LeafletChildTransitionTypeNone
toEnum Int
1 = LeafletChildTransitionType
LeafletChildTransitionTypeCrossfade
toEnum Int
2 = LeafletChildTransitionType
LeafletChildTransitionTypeSlide
toEnum Int
3 = LeafletChildTransitionType
LeafletChildTransitionTypeOver
toEnum Int
4 = LeafletChildTransitionType
LeafletChildTransitionTypeUnder
toEnum Int
k = Int -> LeafletChildTransitionType
AnotherLeafletChildTransitionType Int
k
instance P.Ord LeafletChildTransitionType where
compare :: LeafletChildTransitionType
-> LeafletChildTransitionType -> Ordering
compare LeafletChildTransitionType
a LeafletChildTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LeafletChildTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletChildTransitionType
a) (LeafletChildTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum LeafletChildTransitionType
b)
type instance O.ParentTypes LeafletChildTransitionType = '[]
instance O.HasParentTypes LeafletChildTransitionType
foreign import ccall "hdy_leaflet_child_transition_type_get_type" c_hdy_leaflet_child_transition_type_get_type ::
IO GType
instance B.Types.TypedObject LeafletChildTransitionType where
glibType :: IO GType
glibType = IO GType
c_hdy_leaflet_child_transition_type_get_type
instance B.Types.BoxedEnum LeafletChildTransitionType
data Fold =
FoldUnfolded
| FoldFolded
| AnotherFold Int
deriving (Int -> Fold -> ShowS
[Fold] -> ShowS
Fold -> String
(Int -> Fold -> ShowS)
-> (Fold -> String) -> ([Fold] -> ShowS) -> Show Fold
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fold] -> ShowS
$cshowList :: [Fold] -> ShowS
show :: Fold -> String
$cshow :: Fold -> String
showsPrec :: Int -> Fold -> ShowS
$cshowsPrec :: Int -> Fold -> ShowS
Show, Fold -> Fold -> Bool
(Fold -> Fold -> Bool) -> (Fold -> Fold -> Bool) -> Eq Fold
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fold -> Fold -> Bool
$c/= :: Fold -> Fold -> Bool
== :: Fold -> Fold -> Bool
$c== :: Fold -> Fold -> Bool
Eq)
instance P.Enum Fold where
fromEnum :: Fold -> Int
fromEnum Fold
FoldUnfolded = Int
0
fromEnum Fold
FoldFolded = Int
1
fromEnum (AnotherFold Int
k) = Int
k
toEnum :: Int -> Fold
toEnum Int
0 = Fold
FoldUnfolded
toEnum Int
1 = Fold
FoldFolded
toEnum Int
k = Int -> Fold
AnotherFold Int
k
instance P.Ord Fold where
compare :: Fold -> Fold -> Ordering
compare Fold
a Fold
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Fold -> Int
forall a. Enum a => a -> Int
P.fromEnum Fold
a) (Fold -> Int
forall a. Enum a => a -> Int
P.fromEnum Fold
b)
type instance O.ParentTypes Fold = '[]
instance O.HasParentTypes Fold
foreign import ccall "hdy_fold_get_type" c_hdy_fold_get_type ::
IO GType
instance B.Types.TypedObject Fold where
glibType :: IO GType
glibType = IO GType
c_hdy_fold_get_type
instance B.Types.BoxedEnum Fold
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
data ArrowsDirection =
ArrowsDirectionUp
| ArrowsDirectionDown
| ArrowsDirectionLeft
| ArrowsDirectionRight
| AnotherArrowsDirection Int
deriving (Int -> ArrowsDirection -> ShowS
[ArrowsDirection] -> ShowS
ArrowsDirection -> String
(Int -> ArrowsDirection -> ShowS)
-> (ArrowsDirection -> String)
-> ([ArrowsDirection] -> ShowS)
-> Show ArrowsDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowsDirection] -> ShowS
$cshowList :: [ArrowsDirection] -> ShowS
show :: ArrowsDirection -> String
$cshow :: ArrowsDirection -> String
showsPrec :: Int -> ArrowsDirection -> ShowS
$cshowsPrec :: Int -> ArrowsDirection -> ShowS
Show, ArrowsDirection -> ArrowsDirection -> Bool
(ArrowsDirection -> ArrowsDirection -> Bool)
-> (ArrowsDirection -> ArrowsDirection -> Bool)
-> Eq ArrowsDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowsDirection -> ArrowsDirection -> Bool
$c/= :: ArrowsDirection -> ArrowsDirection -> Bool
== :: ArrowsDirection -> ArrowsDirection -> Bool
$c== :: ArrowsDirection -> ArrowsDirection -> Bool
Eq)
instance P.Enum ArrowsDirection where
fromEnum :: ArrowsDirection -> Int
fromEnum ArrowsDirection
ArrowsDirectionUp = Int
0
fromEnum ArrowsDirection
ArrowsDirectionDown = Int
1
fromEnum ArrowsDirection
ArrowsDirectionLeft = Int
2
fromEnum ArrowsDirection
ArrowsDirectionRight = Int
3
fromEnum (AnotherArrowsDirection Int
k) = Int
k
toEnum :: Int -> ArrowsDirection
toEnum Int
0 = ArrowsDirection
ArrowsDirectionUp
toEnum Int
1 = ArrowsDirection
ArrowsDirectionDown
toEnum Int
2 = ArrowsDirection
ArrowsDirectionLeft
toEnum Int
3 = ArrowsDirection
ArrowsDirectionRight
toEnum Int
k = Int -> ArrowsDirection
AnotherArrowsDirection Int
k
instance P.Ord ArrowsDirection where
compare :: ArrowsDirection -> ArrowsDirection -> Ordering
compare ArrowsDirection
a ArrowsDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ArrowsDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowsDirection
a) (ArrowsDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowsDirection
b)
type instance O.ParentTypes ArrowsDirection = '[]
instance O.HasParentTypes ArrowsDirection
foreign import ccall "hdy_arrows_direction_get_type" c_hdy_arrows_direction_get_type ::
IO GType
instance B.Types.TypedObject ArrowsDirection where
glibType :: IO GType
glibType = IO GType
c_hdy_arrows_direction_get_type
instance B.Types.BoxedEnum ArrowsDirection