-- | 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(..)                     ,


-- ** CenteringPolicy #enum:CenteringPolicy#

    CenteringPolicy(..)                     ,


-- ** Fold #enum:Fold#

    Fold(..)                                ,


-- ** LeafletChildTransitionType #enum:LeafletChildTransitionType#

    LeafletChildTransitionType(..)          ,


-- ** LeafletModeTransitionType #enum:LeafletModeTransitionType#

    LeafletModeTransitionType(..)           ,


-- ** LeafletTransitionType #enum:LeafletTransitionType#

    LeafletTransitionType(..)               ,


-- ** PaginatorIndicatorStyle #enum:PaginatorIndicatorStyle#

    PaginatorIndicatorStyle(..)             ,


-- ** SqueezerTransitionType #enum:SqueezerTransitionType#

    SqueezerTransitionType(..)              ,


-- ** ViewSwitcherPolicy #enum:ViewSwitcherPolicy#

    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


-- Enum ViewSwitcherPolicy
-- | /No description available in the introspection data./
data ViewSwitcherPolicy = 
      ViewSwitcherPolicyAuto
    -- ^ Automatically adapt to the best fitting mode
    | ViewSwitcherPolicyNarrow
    -- ^ Force the narrow mode
    | ViewSwitcherPolicyWide
    -- ^ Force the wide mode
    | AnotherViewSwitcherPolicy Int
    -- ^ Catch-all for unknown values
    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

-- Enum SqueezerTransitionType
-- | These enumeration values describe the possible transitions between children
-- in a t'GI.Handy.Objects.Squeezer.Squeezer' widget.
data SqueezerTransitionType = 
      SqueezerTransitionTypeNone
    -- ^ No transition
    | SqueezerTransitionTypeCrossfade
    -- ^ A cross-fade
    | AnotherSqueezerTransitionType Int
    -- ^ Catch-all for unknown values
    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

-- Enum PaginatorIndicatorStyle
-- | These enumeration values describe the possible page indicator styles in a
-- t'GI.Handy.Objects.Paginator.Paginator' widget.
-- 
-- New values may be added to this enumeration over time.
data PaginatorIndicatorStyle = 
      PaginatorIndicatorStyleNone
    -- ^ No indicators
    | PaginatorIndicatorStyleDots
    -- ^ Each page is represented by a dot. Active dot gradually becomes larger and more opaque.
    | PaginatorIndicatorStyleLines
    -- ^ Each page is represented by a thin and long line, and active view is shown with another line that moves between them
    | AnotherPaginatorIndicatorStyle Int
    -- ^ Catch-all for unknown values
    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

-- Enum LeafletTransitionType
-- | This enumeration value describes the possible transitions between modes and
-- children in a t'GI.Handy.Objects.Leaflet.Leaflet' widget.
-- 
-- New values may be added to this enumeration over time.
-- 
-- /Since: 0.0.12/
data LeafletTransitionType = 
      LeafletTransitionTypeNone
    -- ^ No transition
    | LeafletTransitionTypeSlide
    -- ^ Slide from left, right, up or down according to the orientation, text direction and the children order
    | LeafletTransitionTypeOver
    -- ^ Cover the old page or uncover the new page, sliding from or towards the end according to orientation, text direction and children order
    | LeafletTransitionTypeUnder
    -- ^ Uncover the new page or cover the old page, sliding from or towards the start according to orientation, text direction and children order
    | AnotherLeafletTransitionType Int
    -- ^ Catch-all for unknown values
    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

-- Enum LeafletModeTransitionType
{-# DEPRECATED LeafletModeTransitionType ["(Since version 0.0.12)","Use t'GI.Handy.Enums.LeafletTransitionType'"] #-}
-- | These enumeration values describe the possible transitions between pages in a
-- t'GI.Handy.Objects.Leaflet.Leaflet' widget.
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 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

-- Enum LeafletChildTransitionType
{-# DEPRECATED LeafletChildTransitionType ["(Since version 0.0.12)","Use t'GI.Handy.Enums.LeafletTransitionType'"] #-}
-- | These enumeration values describe the possible transitions between pages in a
-- t'GI.Handy.Objects.Leaflet.Leaflet' widget.
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 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

-- 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 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

-- Enum CenteringPolicy
-- | /No description available in the introspection data./
data CenteringPolicy = 
      CenteringPolicyLoose
    -- ^ Keep the title centered when possible
    | CenteringPolicyStrict
    -- ^ Keep the title centered at all cost
    | AnotherCenteringPolicy Int
    -- ^ Catch-all for unknown values
    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

-- 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 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