-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Handy.Enums
    ( 

 -- * Enumerations
-- ** ArrowsDirection #enum:ArrowsDirection#

    ArrowsDirection(..)                     ,


-- ** Fold #enum:Fold#

    Fold(..)                                ,


-- ** LeafletChildTransitionType #enum:LeafletChildTransitionType#

    LeafletChildTransitionType(..)          ,


-- ** LeafletModeTransitionType #enum:LeafletModeTransitionType#

    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


-- Enum LeafletModeTransitionType
-- | These enumeration values describe the possible transitions between pages in a
-- t'GI.Handy.Objects.Leaflet.Leaflet' widget.
-- 
-- New values may be added to this enumeration over time.
data LeafletModeTransitionType = 
      LeafletModeTransitionTypeNone
    -- ^ No transition
    | LeafletModeTransitionTypeSlide
    -- ^ Slide from left, right, up or down according to the orientation, text direction and the children order
    | AnotherLeafletModeTransitionType Int
    -- ^ Catch-all for unknown values
    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

-- Enum LeafletChildTransitionType
-- | These enumeration values describe the possible transitions between pages in a
-- t'GI.Handy.Objects.Leaflet.Leaflet' widget.
-- 
-- New values may be added to this enumeration over time.
data LeafletChildTransitionType = 
      LeafletChildTransitionTypeNone
    -- ^ No transition
    | LeafletChildTransitionTypeCrossfade
    -- ^ A cross-fade
    | LeafletChildTransitionTypeSlide
    -- ^ Slide from left, right, up or down according to the orientation, text direction and the children order
    | LeafletChildTransitionTypeOver
    -- ^ Cover the old page or uncover the new page, sliding from or towards the end according to orientation, text direction and children order
    | LeafletChildTransitionTypeUnder
    -- ^ Uncover the new page or cover the old page, sliding from or towards the start according to orientation, text direction and children order
    | AnotherLeafletChildTransitionType Int
    -- ^ Catch-all for unknown values
    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

-- Enum Fold
-- | Represents the fold of widgets and other objects which can be switched
-- between folded and unfolded state on the fly, like HdyLeaflet.
data Fold = 
      FoldUnfolded
    -- ^ The element isn\'t folded
    | FoldFolded
    -- ^ The element is folded
    | AnotherFold Int
    -- ^ Catch-all for unknown values
    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

-- Enum ArrowsDirection
-- | /No description available in the introspection data./
data ArrowsDirection = 
      ArrowsDirectionUp
    -- ^ Arrows point upwards.
    | ArrowsDirectionDown
    -- ^ Arrows point to the left.
    | ArrowsDirectionLeft
    -- ^ Arrows point to the right.
    | ArrowsDirectionRight
    -- ^ Arrows point downwards
    | AnotherArrowsDirection Int
    -- ^ Catch-all for unknown values
    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