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


-- ** 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.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
-- | /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 NavigationDirection
-- | Represents direction of a swipe navigation gesture in t'GI.Handy.Objects.Deck.Deck' and
-- t'GI.Handy.Objects.Leaflet.Leaflet'.
-- 
-- /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
showList :: [NavigationDirection] -> ShowS
$cshowList :: [NavigationDirection] -> ShowS
show :: NavigationDirection -> String
$cshow :: NavigationDirection -> String
showsPrec :: Int -> NavigationDirection -> ShowS
$cshowsPrec :: Int -> NavigationDirection -> ShowS
Show, NavigationDirection -> NavigationDirection -> Bool
(NavigationDirection -> NavigationDirection -> Bool)
-> (NavigationDirection -> NavigationDirection -> Bool)
-> Eq NavigationDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationDirection -> NavigationDirection -> Bool
$c/= :: NavigationDirection -> NavigationDirection -> Bool
== :: NavigationDirection -> NavigationDirection -> Bool
$c== :: 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
-- | 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 = 
      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
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
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
-- | This enumeration value describes the child types handled by t'GI.Handy.Objects.HeaderGroup.HeaderGroup'.
-- 
-- New values may be added to this enumeration over time.
-- 
-- /Since: 1.0/
data HeaderGroupChildType = 
      HeaderGroupChildTypeHeaderBar
    -- ^ The child is a t'GI.Handy.Objects.HeaderBar.HeaderBar'
    | HeaderGroupChildTypeGtkHeaderBar
    -- ^ The child is a t'GI.Gtk.Objects.HeaderBar.HeaderBar'
    | HeaderGroupChildTypeHeaderGroup
    -- ^ The child is a t'GI.Handy.Objects.HeaderGroup.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
showList :: [HeaderGroupChildType] -> ShowS
$cshowList :: [HeaderGroupChildType] -> ShowS
show :: HeaderGroupChildType -> String
$cshow :: HeaderGroupChildType -> String
showsPrec :: Int -> HeaderGroupChildType -> ShowS
$cshowsPrec :: Int -> HeaderGroupChildType -> ShowS
Show, HeaderGroupChildType -> HeaderGroupChildType -> Bool
(HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> (HeaderGroupChildType -> HeaderGroupChildType -> Bool)
-> Eq HeaderGroupChildType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
$c/= :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
== :: HeaderGroupChildType -> HeaderGroupChildType -> Bool
$c== :: 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
-- | These enumeration values describe the possible transitions between children
-- in a t'GI.Handy.Objects.Flap.Flap' widget, as well as which areas can be swiped via
-- t'GI.Handy.Objects.Flap.Flap':@/swipe-to-open/@ and t'GI.Handy.Objects.Flap.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
showList :: [FlapTransitionType] -> ShowS
$cshowList :: [FlapTransitionType] -> ShowS
show :: FlapTransitionType -> String
$cshow :: FlapTransitionType -> String
showsPrec :: Int -> FlapTransitionType -> ShowS
$cshowsPrec :: Int -> FlapTransitionType -> ShowS
Show, FlapTransitionType -> FlapTransitionType -> Bool
(FlapTransitionType -> FlapTransitionType -> Bool)
-> (FlapTransitionType -> FlapTransitionType -> Bool)
-> Eq FlapTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlapTransitionType -> FlapTransitionType -> Bool
$c/= :: FlapTransitionType -> FlapTransitionType -> Bool
== :: FlapTransitionType -> FlapTransitionType -> Bool
$c== :: 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
-- | These enumeration values describe the possible folding behavior in a t'GI.Handy.Objects.Flap.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
showList :: [FlapFoldPolicy] -> ShowS
$cshowList :: [FlapFoldPolicy] -> ShowS
show :: FlapFoldPolicy -> String
$cshow :: FlapFoldPolicy -> String
showsPrec :: Int -> FlapFoldPolicy -> ShowS
$cshowsPrec :: Int -> FlapFoldPolicy -> ShowS
Show, FlapFoldPolicy -> FlapFoldPolicy -> Bool
(FlapFoldPolicy -> FlapFoldPolicy -> Bool)
-> (FlapFoldPolicy -> FlapFoldPolicy -> Bool) -> Eq FlapFoldPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
$c/= :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
== :: FlapFoldPolicy -> FlapFoldPolicy -> Bool
$c== :: 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
-- | This enumeration value describes the possible transitions between children
-- in a t'GI.Handy.Objects.Deck.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
showList :: [DeckTransitionType] -> ShowS
$cshowList :: [DeckTransitionType] -> ShowS
show :: DeckTransitionType -> String
$cshow :: DeckTransitionType -> String
showsPrec :: Int -> DeckTransitionType -> ShowS
$cshowsPrec :: Int -> DeckTransitionType -> ShowS
Show, DeckTransitionType -> DeckTransitionType -> Bool
(DeckTransitionType -> DeckTransitionType -> Bool)
-> (DeckTransitionType -> DeckTransitionType -> Bool)
-> Eq DeckTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeckTransitionType -> DeckTransitionType -> Bool
$c/= :: DeckTransitionType -> DeckTransitionType -> Bool
== :: DeckTransitionType -> DeckTransitionType -> Bool
$c== :: 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 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