-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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


-- ** CenteringPolicy #enum:CenteringPolicy#

    CenteringPolicy(..)                     ,


-- ** ColorScheme #enum:ColorScheme#

    ColorScheme(..)                         ,


-- ** DeckTransitionType #enum:DeckTransitionType#

    DeckTransitionType(..)                  ,


-- ** FlapFoldPolicy #enum:FlapFoldPolicy#

    FlapFoldPolicy(..)                      ,


-- ** FlapTransitionType #enum:FlapTransitionType#

    FlapTransitionType(..)                  ,


-- ** HeaderGroupChildType #enum:HeaderGroupChildType#

    HeaderGroupChildType(..)                ,


-- ** LeafletTransitionType #enum:LeafletTransitionType#

    LeafletTransitionType(..)               ,


-- ** NavigationDirection #enum:NavigationDirection#

    NavigationDirection(..)                 ,


-- ** 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.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.GHashTable as B.GHT
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


-- Enum ViewSwitcherPolicy
-- | Describes the adaptive modes of [class/@viewSwitcher@/].
-- 
-- /Since: 1.0/
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
$cshowsPrec :: Int -> ViewSwitcherPolicy -> ShowS
showsPrec :: Int -> ViewSwitcherPolicy -> ShowS
$cshow :: ViewSwitcherPolicy -> String
show :: ViewSwitcherPolicy -> String
$cshowList :: [ViewSwitcherPolicy] -> ShowS
showList :: [ViewSwitcherPolicy] -> ShowS
Show, ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
(ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool)
-> (ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool)
-> Eq ViewSwitcherPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
== :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
$c/= :: ViewSwitcherPolicy -> ViewSwitcherPolicy -> Bool
/= :: 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
-- | Describes the possible transitions in a [class/@squeezer@/] widget.
-- 
-- /Since: 1.0/
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
$cshowsPrec :: Int -> SqueezerTransitionType -> ShowS
showsPrec :: Int -> SqueezerTransitionType -> ShowS
$cshow :: SqueezerTransitionType -> String
show :: SqueezerTransitionType -> String
$cshowList :: [SqueezerTransitionType] -> ShowS
showList :: [SqueezerTransitionType] -> ShowS
Show, SqueezerTransitionType -> SqueezerTransitionType -> Bool
(SqueezerTransitionType -> SqueezerTransitionType -> Bool)
-> (SqueezerTransitionType -> SqueezerTransitionType -> Bool)
-> Eq SqueezerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
== :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
$c/= :: SqueezerTransitionType -> SqueezerTransitionType -> Bool
/= :: 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 NavigationDirection
-- | Describes the direction of a swipe navigation gesture.
-- 
-- /Since: 1.0/
data NavigationDirection = 
      NavigationDirectionBack
    -- ^ Corresponds to start or top, depending on
    --   orientation and text direction
    | NavigationDirectionForward
    -- ^ Corresponds to end or bottom, depending on
    --   orientation and text direction
    | AnotherNavigationDirection Int
    -- ^ Catch-all for unknown values
    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
$cshowsPrec :: Int -> NavigationDirection -> ShowS
showsPrec :: Int -> NavigationDirection -> ShowS
$cshow :: NavigationDirection -> String
show :: NavigationDirection -> String
$cshowList :: [NavigationDirection] -> ShowS
showList :: [NavigationDirection] -> ShowS
Show, NavigationDirection -> NavigationDirection -> Bool
(NavigationDirection -> NavigationDirection -> Bool)
-> (NavigationDirection -> NavigationDirection -> Bool)
-> Eq NavigationDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NavigationDirection -> NavigationDirection -> Bool
== :: NavigationDirection -> NavigationDirection -> Bool
$c/= :: NavigationDirection -> NavigationDirection -> Bool
/= :: 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

-- Enum LeafletTransitionType
-- | Describes the possible transitions in a [class/@leaflet@/] widget.
-- 
-- New values may be added to this enumeration over time.
-- 
-- /Since: 1.0/
data LeafletTransitionType = 
      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
    | LeafletTransitionTypeSlide
    -- ^ Slide from left, right, up or down
    --   according to the orientation, text direction and the 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
$cshowsPrec :: Int -> LeafletTransitionType -> ShowS
showsPrec :: Int -> LeafletTransitionType -> ShowS
$cshow :: LeafletTransitionType -> String
show :: LeafletTransitionType -> String
$cshowList :: [LeafletTransitionType] -> ShowS
showList :: [LeafletTransitionType] -> ShowS
Show, LeafletTransitionType -> LeafletTransitionType -> Bool
(LeafletTransitionType -> LeafletTransitionType -> Bool)
-> (LeafletTransitionType -> LeafletTransitionType -> Bool)
-> Eq LeafletTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LeafletTransitionType -> LeafletTransitionType -> Bool
== :: LeafletTransitionType -> LeafletTransitionType -> Bool
$c/= :: LeafletTransitionType -> LeafletTransitionType -> Bool
/= :: 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

-- Enum HeaderGroupChildType
-- | Describes the child types handled by [class/@headerGroup@/].
-- 
-- New values may be added to this enumeration over time.
-- 
-- /Since: 1.0/
data HeaderGroupChildType = 
      HeaderGroupChildTypeHeaderBar
    -- ^ The child is a [class/@headerBar@/]
    | HeaderGroupChildTypeGtkHeaderBar
    -- ^ The child is a
    --   t'GI.Gtk.Objects.HeaderBar.HeaderBar'
    | HeaderGroupChildTypeHeaderGroup
    -- ^ The child is a
    --   [class/@headerGroup@/]
    | AnotherHeaderGroupChildType Int
    -- ^ Catch-all for unknown values
    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
$cshowsPrec :: Int -> HeaderGroupChildType -> ShowS
showsPrec :: Int -> HeaderGroupChildType -> ShowS
$cshow :: HeaderGroupChildType -> String
show :: HeaderGroupChildType -> String
$cshowList :: [HeaderGroupChildType] -> ShowS
showList :: [HeaderGroupChildType] -> ShowS
Show, HeaderGroupChildType -> HeaderGroupChildType -> Bool
(HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> (HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> Eq HeaderGroupChildType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
== :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
$c/= :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
/= :: 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" c_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

-- Enum FlapTransitionType
-- | Describes transitions types of a [class/@flap@/] widget.
-- 
-- These enumeration values describe the possible transitions between children
-- in a [class/@flap@/] widget, as well as which areas can be swiped via
-- [property/@flap@/:swipe-to-open] and [property/@flap@/:swipe-to-close].
-- 
-- New values may be added to this enum over time.
-- 
-- /Since: 1.2/
data FlapTransitionType = 
      FlapTransitionTypeOver
    -- ^ The flap slides over the content, which is
    --   dimmed. When folded, only the flap can be swiped.
    | FlapTransitionTypeUnder
    -- ^ The content slides over the flap. Only the
    --   content can be swiped.
    | FlapTransitionTypeSlide
    -- ^ The flap slides offscreen when hidden,
    --   neither the flap nor content overlap each other. Both widgets can be
    --   swiped.
    | AnotherFlapTransitionType Int
    -- ^ Catch-all for unknown values
    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
$cshowsPrec :: Int -> FlapTransitionType -> ShowS
showsPrec :: Int -> FlapTransitionType -> ShowS
$cshow :: FlapTransitionType -> String
show :: FlapTransitionType -> String
$cshowList :: [FlapTransitionType] -> ShowS
showList :: [FlapTransitionType] -> ShowS
Show, FlapTransitionType -> FlapTransitionType -> Bool
(FlapTransitionType -> FlapTransitionType -> Bool)
-> (FlapTransitionType -> FlapTransitionType -> Bool)
-> Eq FlapTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FlapTransitionType -> FlapTransitionType -> Bool
== :: FlapTransitionType -> FlapTransitionType -> Bool
$c/= :: FlapTransitionType -> FlapTransitionType -> Bool
/= :: 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

-- Enum FlapFoldPolicy
-- | Describes the possible folding behavior of a [class/@flap@/] widget.
-- 
-- /Since: 1.2/
data FlapFoldPolicy = 
      FlapFoldPolicyNever
    -- ^ Disable folding, the flap cannot reach narrow
    --   sizes.
    | FlapFoldPolicyAlways
    -- ^ Keep the flap always folded.
    | FlapFoldPolicyAuto
    -- ^ Fold and unfold the flap based on available
    --   space.
    | AnotherFlapFoldPolicy Int
    -- ^ Catch-all for unknown values
    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
$cshowsPrec :: Int -> FlapFoldPolicy -> ShowS
showsPrec :: Int -> FlapFoldPolicy -> ShowS
$cshow :: FlapFoldPolicy -> String
show :: FlapFoldPolicy -> String
$cshowList :: [FlapFoldPolicy] -> ShowS
showList :: [FlapFoldPolicy] -> ShowS
Show, FlapFoldPolicy -> FlapFoldPolicy -> Bool
(FlapFoldPolicy -> FlapFoldPolicy -> Bool)
-> (FlapFoldPolicy -> FlapFoldPolicy -> Bool) -> Eq FlapFoldPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
== :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
$c/= :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
/= :: 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

-- Enum DeckTransitionType
-- | Describes the possible transitions in a [class/@deck@/] widget.
-- 
-- New values may be added to this enumeration over time.
-- 
-- /Since: 1.0/
data DeckTransitionType = 
      DeckTransitionTypeOver
    -- ^ Cover the old page or uncover the new page,
    --   sliding from or towards the end according to orientation, text direction
    --   and children order
    | DeckTransitionTypeUnder
    -- ^ Uncover the new page or cover the old page,
    --   sliding from or towards the start according to orientation, text direction
    --   and children order
    | DeckTransitionTypeSlide
    -- ^ Slide from left, right, up or down according
    --   to the orientation, text direction and the children order
    | AnotherDeckTransitionType Int
    -- ^ Catch-all for unknown values
    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
$cshowsPrec :: Int -> DeckTransitionType -> ShowS
showsPrec :: Int -> DeckTransitionType -> ShowS
$cshow :: DeckTransitionType -> String
show :: DeckTransitionType -> String
$cshowList :: [DeckTransitionType] -> ShowS
showList :: [DeckTransitionType] -> ShowS
Show, DeckTransitionType -> DeckTransitionType -> Bool
(DeckTransitionType -> DeckTransitionType -> Bool)
-> (DeckTransitionType -> DeckTransitionType -> Bool)
-> Eq DeckTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeckTransitionType -> DeckTransitionType -> Bool
== :: DeckTransitionType -> DeckTransitionType -> Bool
$c/= :: DeckTransitionType -> DeckTransitionType -> Bool
/= :: 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

-- Enum ColorScheme
-- | Application color schemes for [property/@styleManager@/:color-scheme].
-- 
-- /Since: 1.6/
data ColorScheme = 
      ColorSchemeDefault
    -- ^ Inherit the parent color-scheme. When set on the
    --   [class/@styleManager@/] returned by @/StyleManager.get_default/@, it\'s
    --   equivalent to @HDY_COLOR_SCHEME_FORCE_LIGHT@.
    | ColorSchemeForceLight
    -- ^ Always use light appearance.
    | ColorSchemePreferLight
    -- ^ Use light appearance unless the system
    --   prefers dark colors.
    | ColorSchemePreferDark
    -- ^ Use dark appearance unless the system prefers
    --   light colors.
    | ColorSchemeForceDark
    -- ^ Always use dark appearance.
    | AnotherColorScheme Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ColorScheme -> ShowS
[ColorScheme] -> ShowS
ColorScheme -> String
(Int -> ColorScheme -> ShowS)
-> (ColorScheme -> String)
-> ([ColorScheme] -> ShowS)
-> Show ColorScheme
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColorScheme -> ShowS
showsPrec :: Int -> ColorScheme -> ShowS
$cshow :: ColorScheme -> String
show :: ColorScheme -> String
$cshowList :: [ColorScheme] -> ShowS
showList :: [ColorScheme] -> ShowS
Show, ColorScheme -> ColorScheme -> Bool
(ColorScheme -> ColorScheme -> Bool)
-> (ColorScheme -> ColorScheme -> Bool) -> Eq ColorScheme
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColorScheme -> ColorScheme -> Bool
== :: ColorScheme -> ColorScheme -> Bool
$c/= :: ColorScheme -> ColorScheme -> Bool
/= :: ColorScheme -> ColorScheme -> Bool
Eq)

instance P.Enum ColorScheme where
    fromEnum :: ColorScheme -> Int
fromEnum ColorScheme
ColorSchemeDefault = Int
0
    fromEnum ColorScheme
ColorSchemeForceLight = Int
1
    fromEnum ColorScheme
ColorSchemePreferLight = Int
2
    fromEnum ColorScheme
ColorSchemePreferDark = Int
3
    fromEnum ColorScheme
ColorSchemeForceDark = Int
4
    fromEnum (AnotherColorScheme Int
k) = Int
k

    toEnum :: Int -> ColorScheme
toEnum Int
0 = ColorScheme
ColorSchemeDefault
    toEnum Int
1 = ColorScheme
ColorSchemeForceLight
    toEnum Int
2 = ColorScheme
ColorSchemePreferLight
    toEnum Int
3 = ColorScheme
ColorSchemePreferDark
    toEnum Int
4 = ColorScheme
ColorSchemeForceDark
    toEnum Int
k = Int -> ColorScheme
AnotherColorScheme Int
k

instance P.Ord ColorScheme where
    compare :: ColorScheme -> ColorScheme -> Ordering
compare ColorScheme
a ColorScheme
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ColorScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum ColorScheme
a) (ColorScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum ColorScheme
b)

type instance O.ParentTypes ColorScheme = '[]
instance O.HasParentTypes ColorScheme

foreign import ccall "hdy_color_scheme_get_type" c_hdy_color_scheme_get_type :: 
    IO GType

instance B.Types.TypedObject ColorScheme where
    glibType :: IO GType
glibType = IO GType
c_hdy_color_scheme_get_type

instance B.Types.BoxedEnum ColorScheme

-- Enum CenteringPolicy
-- | Describes title centering behavior of a [class/@headerBar@/] widget.
-- 
-- /Since: 1.0/
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
$cshowsPrec :: Int -> CenteringPolicy -> ShowS
showsPrec :: Int -> CenteringPolicy -> ShowS
$cshow :: CenteringPolicy -> String
show :: CenteringPolicy -> String
$cshowList :: [CenteringPolicy] -> ShowS
showList :: [CenteringPolicy] -> ShowS
Show, CenteringPolicy -> CenteringPolicy -> Bool
(CenteringPolicy -> CenteringPolicy -> Bool)
-> (CenteringPolicy -> CenteringPolicy -> Bool)
-> Eq CenteringPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CenteringPolicy -> CenteringPolicy -> Bool
== :: CenteringPolicy -> CenteringPolicy -> Bool
$c/= :: CenteringPolicy -> CenteringPolicy -> Bool
/= :: 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