#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Handy.Enums
(
ArrowsDirection(..) ,
Fold(..) ,
LeafletChildTransitionType(..) ,
LeafletModeTransitionType(..) ,
) 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.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 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 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 LeafletModeTransitionTypeNone = 0
fromEnum LeafletModeTransitionTypeSlide = 1
fromEnum (AnotherLeafletModeTransitionType k :: Int
k) = Int
k
toEnum :: Int -> LeafletModeTransitionType
toEnum 0 = LeafletModeTransitionType
LeafletModeTransitionTypeNone
toEnum 1 = LeafletModeTransitionType
LeafletModeTransitionTypeSlide
toEnum k :: Int
k = Int -> LeafletModeTransitionType
AnotherLeafletModeTransitionType Int
k
instance P.Ord LeafletModeTransitionType where
compare :: LeafletModeTransitionType -> LeafletModeTransitionType -> Ordering
compare a :: LeafletModeTransitionType
a b :: 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)
foreign import ccall "hdy_leaflet_mode_transition_type_get_type" c_hdy_leaflet_mode_transition_type_get_type ::
IO GType
instance BoxedEnum LeafletModeTransitionType where
boxedEnumType :: LeafletModeTransitionType -> IO GType
boxedEnumType _ = IO GType
c_hdy_leaflet_mode_transition_type_get_type
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 LeafletChildTransitionTypeNone = 0
fromEnum LeafletChildTransitionTypeCrossfade = 1
fromEnum LeafletChildTransitionTypeSlide = 2
fromEnum LeafletChildTransitionTypeOver = 3
fromEnum LeafletChildTransitionTypeUnder = 4
fromEnum (AnotherLeafletChildTransitionType k :: Int
k) = Int
k
toEnum :: Int -> LeafletChildTransitionType
toEnum 0 = LeafletChildTransitionType
LeafletChildTransitionTypeNone
toEnum 1 = LeafletChildTransitionType
LeafletChildTransitionTypeCrossfade
toEnum 2 = LeafletChildTransitionType
LeafletChildTransitionTypeSlide
toEnum 3 = LeafletChildTransitionType
LeafletChildTransitionTypeOver
toEnum 4 = LeafletChildTransitionType
LeafletChildTransitionTypeUnder
toEnum k :: Int
k = Int -> LeafletChildTransitionType
AnotherLeafletChildTransitionType Int
k
instance P.Ord LeafletChildTransitionType where
compare :: LeafletChildTransitionType
-> LeafletChildTransitionType -> Ordering
compare a :: LeafletChildTransitionType
a b :: 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)
foreign import ccall "hdy_leaflet_child_transition_type_get_type" c_hdy_leaflet_child_transition_type_get_type ::
IO GType
instance BoxedEnum LeafletChildTransitionType where
boxedEnumType :: LeafletChildTransitionType -> IO GType
boxedEnumType _ = IO GType
c_hdy_leaflet_child_transition_type_get_type
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 FoldUnfolded = 0
fromEnum FoldFolded = 1
fromEnum (AnotherFold k :: Int
k) = Int
k
toEnum :: Int -> Fold
toEnum 0 = Fold
FoldUnfolded
toEnum 1 = Fold
FoldFolded
toEnum k :: Int
k = Int -> Fold
AnotherFold Int
k
instance P.Ord Fold where
compare :: Fold -> Fold -> Ordering
compare a :: Fold
a b :: 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)
foreign import ccall "hdy_fold_get_type" c_hdy_fold_get_type ::
IO GType
instance BoxedEnum Fold where
boxedEnumType :: Fold -> IO GType
boxedEnumType _ = IO GType
c_hdy_fold_get_type
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 ArrowsDirectionUp = 0
fromEnum ArrowsDirectionDown = 1
fromEnum ArrowsDirectionLeft = 2
fromEnum ArrowsDirectionRight = 3
fromEnum (AnotherArrowsDirection k :: Int
k) = Int
k
toEnum :: Int -> ArrowsDirection
toEnum 0 = ArrowsDirection
ArrowsDirectionUp
toEnum 1 = ArrowsDirection
ArrowsDirectionDown
toEnum 2 = ArrowsDirection
ArrowsDirectionLeft
toEnum 3 = ArrowsDirection
ArrowsDirectionRight
toEnum k :: Int
k = Int -> ArrowsDirection
AnotherArrowsDirection Int
k
instance P.Ord ArrowsDirection where
compare :: ArrowsDirection -> ArrowsDirection -> Ordering
compare a :: ArrowsDirection
a b :: 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)
foreign import ccall "hdy_arrows_direction_get_type" c_hdy_arrows_direction_get_type ::
IO GType
instance BoxedEnum ArrowsDirection where
boxedEnumType :: ArrowsDirection -> IO GType
boxedEnumType _ = IO GType
c_hdy_arrows_direction_get_type