-- | 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.Adw.Enums
    ( 

 -- * Enumerations


-- ** AnimationState #enum:AnimationState#

    AnimationState(..)                      ,


-- ** CenteringPolicy #enum:CenteringPolicy#

    CenteringPolicy(..)                     ,


-- ** ColorScheme #enum:ColorScheme#

    ColorScheme(..)                         ,


-- ** Easing #enum:Easing#

    Easing(..)                              ,


-- ** FlapFoldPolicy #enum:FlapFoldPolicy#

    FlapFoldPolicy(..)                      ,


-- ** FlapTransitionType #enum:FlapTransitionType#

    FlapTransitionType(..)                  ,


-- ** FoldThresholdPolicy #enum:FoldThresholdPolicy#

    FoldThresholdPolicy(..)                 ,


-- ** LeafletTransitionType #enum:LeafletTransitionType#

    LeafletTransitionType(..)               ,


-- ** NavigationDirection #enum:NavigationDirection#

    NavigationDirection(..)                 ,


-- ** ResponseAppearance #enum:ResponseAppearance#

    ResponseAppearance(..)                  ,


-- ** SqueezerTransitionType #enum:SqueezerTransitionType#

    SqueezerTransitionType(..)              ,


-- ** ToastPriority #enum:ToastPriority#

    ToastPriority(..)                       ,


-- ** 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.Kind as DK
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@/].
data ViewSwitcherPolicy = 
      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
ViewSwitcherPolicyNarrow = Int
0
    fromEnum ViewSwitcherPolicy
ViewSwitcherPolicyWide = Int
1
    fromEnum (AnotherViewSwitcherPolicy Int
k) = Int
k

    toEnum :: Int -> ViewSwitcherPolicy
toEnum Int
0 = ViewSwitcherPolicy
ViewSwitcherPolicyNarrow
    toEnum Int
1 = 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 "adw_view_switcher_policy_get_type" c_adw_view_switcher_policy_get_type :: 
    IO GType

instance B.Types.TypedObject ViewSwitcherPolicy where
    glibType :: IO GType
glibType = IO GType
c_adw_view_switcher_policy_get_type

instance B.Types.BoxedEnum ViewSwitcherPolicy

-- Enum ToastPriority
-- | [class/@toast@/] behavior when another toast is already displayed.
data ToastPriority = 
      ToastPriorityNormal
    -- ^ the toast will be queued if another toast is
    --   already displayed.
    | ToastPriorityHigh
    -- ^ the toast will be displayed immediately, pushing
    --   the previous toast into the queue instead.
    | AnotherToastPriority Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ToastPriority -> ShowS
[ToastPriority] -> ShowS
ToastPriority -> String
(Int -> ToastPriority -> ShowS)
-> (ToastPriority -> String)
-> ([ToastPriority] -> ShowS)
-> Show ToastPriority
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ToastPriority -> ShowS
showsPrec :: Int -> ToastPriority -> ShowS
$cshow :: ToastPriority -> String
show :: ToastPriority -> String
$cshowList :: [ToastPriority] -> ShowS
showList :: [ToastPriority] -> ShowS
Show, ToastPriority -> ToastPriority -> Bool
(ToastPriority -> ToastPriority -> Bool)
-> (ToastPriority -> ToastPriority -> Bool) -> Eq ToastPriority
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ToastPriority -> ToastPriority -> Bool
== :: ToastPriority -> ToastPriority -> Bool
$c/= :: ToastPriority -> ToastPriority -> Bool
/= :: ToastPriority -> ToastPriority -> Bool
Eq)

instance P.Enum ToastPriority where
    fromEnum :: ToastPriority -> Int
fromEnum ToastPriority
ToastPriorityNormal = Int
0
    fromEnum ToastPriority
ToastPriorityHigh = Int
1
    fromEnum (AnotherToastPriority Int
k) = Int
k

    toEnum :: Int -> ToastPriority
toEnum Int
0 = ToastPriority
ToastPriorityNormal
    toEnum Int
1 = ToastPriority
ToastPriorityHigh
    toEnum Int
k = Int -> ToastPriority
AnotherToastPriority Int
k

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

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

foreign import ccall "adw_toast_priority_get_type" c_adw_toast_priority_get_type :: 
    IO GType

instance B.Types.TypedObject ToastPriority where
    glibType :: IO GType
glibType = IO GType
c_adw_toast_priority_get_type

instance B.Types.BoxedEnum ToastPriority

-- Enum SqueezerTransitionType
-- | Describes the possible transitions in a [class/@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
$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 "adw_squeezer_transition_type_get_type" c_adw_squeezer_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject SqueezerTransitionType where
    glibType :: IO GType
glibType = IO GType
c_adw_squeezer_transition_type_get_type

instance B.Types.BoxedEnum SqueezerTransitionType

-- Enum ResponseAppearance
-- | Describes the possible styles of [class/@messageDialog@/] response buttons.
-- 
-- See [method/@messageDialog@/.set_response_appearance].
-- 
-- /Since: 1.2/
data ResponseAppearance = 
      ResponseAppearanceDefault
    -- ^ the default appearance.
    | ResponseAppearanceSuggested
    -- ^ used to denote important responses such as the
    --     affirmative action.
    | ResponseAppearanceDestructive
    -- ^ used to draw attention to the potentially damaging
    --     consequences of using the response. This appearance acts as a warning to
    --     the user.
    | AnotherResponseAppearance Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ResponseAppearance -> ShowS
[ResponseAppearance] -> ShowS
ResponseAppearance -> String
(Int -> ResponseAppearance -> ShowS)
-> (ResponseAppearance -> String)
-> ([ResponseAppearance] -> ShowS)
-> Show ResponseAppearance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ResponseAppearance -> ShowS
showsPrec :: Int -> ResponseAppearance -> ShowS
$cshow :: ResponseAppearance -> String
show :: ResponseAppearance -> String
$cshowList :: [ResponseAppearance] -> ShowS
showList :: [ResponseAppearance] -> ShowS
Show, ResponseAppearance -> ResponseAppearance -> Bool
(ResponseAppearance -> ResponseAppearance -> Bool)
-> (ResponseAppearance -> ResponseAppearance -> Bool)
-> Eq ResponseAppearance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ResponseAppearance -> ResponseAppearance -> Bool
== :: ResponseAppearance -> ResponseAppearance -> Bool
$c/= :: ResponseAppearance -> ResponseAppearance -> Bool
/= :: ResponseAppearance -> ResponseAppearance -> Bool
Eq)

instance P.Enum ResponseAppearance where
    fromEnum :: ResponseAppearance -> Int
fromEnum ResponseAppearance
ResponseAppearanceDefault = Int
0
    fromEnum ResponseAppearance
ResponseAppearanceSuggested = Int
1
    fromEnum ResponseAppearance
ResponseAppearanceDestructive = Int
2
    fromEnum (AnotherResponseAppearance Int
k) = Int
k

    toEnum :: Int -> ResponseAppearance
toEnum Int
0 = ResponseAppearance
ResponseAppearanceDefault
    toEnum Int
1 = ResponseAppearance
ResponseAppearanceSuggested
    toEnum Int
2 = ResponseAppearance
ResponseAppearanceDestructive
    toEnum Int
k = Int -> ResponseAppearance
AnotherResponseAppearance Int
k

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

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

foreign import ccall "adw_response_appearance_get_type" c_adw_response_appearance_get_type :: 
    IO GType

instance B.Types.TypedObject ResponseAppearance where
    glibType :: IO GType
glibType = IO GType
c_adw_response_appearance_get_type

instance B.Types.BoxedEnum ResponseAppearance

-- Enum NavigationDirection
-- | Describes the direction of a swipe navigation gesture.
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 "adw_navigation_direction_get_type" c_adw_navigation_direction_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationDirection where
    glibType :: IO GType
glibType = IO GType
c_adw_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.
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 "adw_leaflet_transition_type_get_type" c_adw_leaflet_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject LeafletTransitionType where
    glibType :: IO GType
glibType = IO GType
c_adw_leaflet_transition_type_get_type

instance B.Types.BoxedEnum LeafletTransitionType

-- Enum FoldThresholdPolicy
-- | Determines when [class/@flap@/] and [class/@leaflet@/] will fold.
data FoldThresholdPolicy = 
      FoldThresholdPolicyMinimum
    -- ^ Folding is based on the minimum size
    | FoldThresholdPolicyNatural
    -- ^ Folding is based on the natural size
    | AnotherFoldThresholdPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FoldThresholdPolicy -> ShowS
[FoldThresholdPolicy] -> ShowS
FoldThresholdPolicy -> String
(Int -> FoldThresholdPolicy -> ShowS)
-> (FoldThresholdPolicy -> String)
-> ([FoldThresholdPolicy] -> ShowS)
-> Show FoldThresholdPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FoldThresholdPolicy -> ShowS
showsPrec :: Int -> FoldThresholdPolicy -> ShowS
$cshow :: FoldThresholdPolicy -> String
show :: FoldThresholdPolicy -> String
$cshowList :: [FoldThresholdPolicy] -> ShowS
showList :: [FoldThresholdPolicy] -> ShowS
Show, FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
(FoldThresholdPolicy -> FoldThresholdPolicy -> Bool)
-> (FoldThresholdPolicy -> FoldThresholdPolicy -> Bool)
-> Eq FoldThresholdPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
== :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
$c/= :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
/= :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
Eq)

instance P.Enum FoldThresholdPolicy where
    fromEnum :: FoldThresholdPolicy -> Int
fromEnum FoldThresholdPolicy
FoldThresholdPolicyMinimum = Int
0
    fromEnum FoldThresholdPolicy
FoldThresholdPolicyNatural = Int
1
    fromEnum (AnotherFoldThresholdPolicy Int
k) = Int
k

    toEnum :: Int -> FoldThresholdPolicy
toEnum Int
0 = FoldThresholdPolicy
FoldThresholdPolicyMinimum
    toEnum Int
1 = FoldThresholdPolicy
FoldThresholdPolicyNatural
    toEnum Int
k = Int -> FoldThresholdPolicy
AnotherFoldThresholdPolicy Int
k

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

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

foreign import ccall "adw_fold_threshold_policy_get_type" c_adw_fold_threshold_policy_get_type :: 
    IO GType

instance B.Types.TypedObject FoldThresholdPolicy where
    glibType :: IO GType
glibType = IO GType
c_adw_fold_threshold_policy_get_type

instance B.Types.BoxedEnum FoldThresholdPolicy

-- Enum FlapTransitionType
-- | Describes transitions types of a [class/@flap@/] widget.
-- 
-- It determines the type of animation when transitioning 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.
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 "adw_flap_transition_type_get_type" c_adw_flap_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject FlapTransitionType where
    glibType :: IO GType
glibType = IO GType
c_adw_flap_transition_type_get_type

instance B.Types.BoxedEnum FlapTransitionType

-- Enum FlapFoldPolicy
-- | Describes the possible folding behavior of a [class/@flap@/] widget.
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 "adw_flap_fold_policy_get_type" c_adw_flap_fold_policy_get_type :: 
    IO GType

instance B.Types.TypedObject FlapFoldPolicy where
    glibType :: IO GType
glibType = IO GType
c_adw_flap_fold_policy_get_type

instance B.Types.BoxedEnum FlapFoldPolicy

-- Enum Easing
-- | Describes the available easing functions for use with
-- [class/@timedAnimation@/].
-- 
-- New values may be added to this enumeration over time.
data Easing = 
      EasingLinear
    -- ^ Linear tweening.
    | EasingEaseInQuad
    -- ^ Quadratic tweening.
    | EasingEaseOutQuad
    -- ^ Quadratic tweening, inverse of @ADW_EASE_IN_QUAD@.
    | EasingEaseInOutQuad
    -- ^ Quadratic tweening, combining @ADW_EASE_IN_QUAD@ and
    --   @ADW_EASE_OUT_QUAD@.
    | EasingEaseInCubic
    -- ^ Cubic tweening.
    | EasingEaseOutCubic
    -- ^ Cubic tweening, inverse of @ADW_EASE_IN_CUBIC@.
    | EasingEaseInOutCubic
    -- ^ Cubic tweening, combining @ADW_EASE_IN_CUBIC@ and
    --   @ADW_EASE_OUT_CUBIC@.
    | EasingEaseInQuart
    -- ^ Quartic tweening.
    | EasingEaseOutQuart
    -- ^ Quartic tweening, inverse of @ADW_EASE_IN_QUART@.
    | EasingEaseInOutQuart
    -- ^ Quartic tweening, combining @ADW_EASE_IN_QUART@ and
    --   @ADW_EASE_OUT_QUART@.
    | EasingEaseInQuint
    -- ^ Quintic tweening.
    | EasingEaseOutQuint
    -- ^ Quintic tweening, inverse of @ADW_EASE_IN_QUINT@.
    | EasingEaseInOutQuint
    -- ^ Quintic tweening, combining @ADW_EASE_IN_QUINT@ and
    --   @ADW_EASE_OUT_QUINT@.
    | EasingEaseInSine
    -- ^ Sine wave tweening.
    | EasingEaseOutSine
    -- ^ Sine wave tweening, inverse of @ADW_EASE_IN_SINE@.
    | EasingEaseInOutSine
    -- ^ Sine wave tweening, combining @ADW_EASE_IN_SINE@ and
    --   @ADW_EASE_OUT_SINE@.
    | EasingEaseInExpo
    -- ^ Exponential tweening.
    | EasingEaseOutExpo
    -- ^ Exponential tweening, inverse of @ADW_EASE_IN_EXPO@.
    | EasingEaseInOutExpo
    -- ^ Exponential tweening, combining @ADW_EASE_IN_EXPO@ and
    --   @ADW_EASE_OUT_EXPO@.
    | EasingEaseInCirc
    -- ^ Circular tweening.
    | EasingEaseOutCirc
    -- ^ Circular tweening, inverse of @ADW_EASE_IN_CIRC@.
    | EasingEaseInOutCirc
    -- ^ Circular tweening, combining @ADW_EASE_IN_CIRC@ and
    --   @ADW_EASE_OUT_CIRC@.
    | EasingEaseInElastic
    -- ^ Elastic tweening, with offshoot on start.
    | EasingEaseOutElastic
    -- ^ Elastic tweening, with offshoot on end, inverse of
    --   @ADW_EASE_IN_ELASTIC@.
    | EasingEaseInOutElastic
    -- ^ Elastic tweening, with offshoot on both ends,
    --   combining @ADW_EASE_IN_ELASTIC@ and @ADW_EASE_OUT_ELASTIC@.
    | EasingEaseInBack
    -- ^ Overshooting cubic tweening, with backtracking on start.
    | EasingEaseOutBack
    -- ^ Overshooting cubic tweening, with backtracking on end,
    --   inverse of @ADW_EASE_IN_BACK@.
    | EasingEaseInOutBack
    -- ^ Overshooting cubic tweening, with backtracking on both
    --   ends, combining @ADW_EASE_IN_BACK@ and @ADW_EASE_OUT_BACK@.
    | EasingEaseInBounce
    -- ^ Exponentially decaying parabolic (bounce) tweening,
    --   on start.
    | EasingEaseOutBounce
    -- ^ Exponentially decaying parabolic (bounce) tweening,
    --   with bounce on end, inverse of @ADW_EASE_IN_BOUNCE@.
    | EasingEaseInOutBounce
    -- ^ Exponentially decaying parabolic (bounce) tweening,
    --   with bounce on both ends, combining @ADW_EASE_IN_BOUNCE@ and
    --   @ADW_EASE_OUT_BOUNCE@.
    | AnotherEasing Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Easing -> ShowS
[Easing] -> ShowS
Easing -> String
(Int -> Easing -> ShowS)
-> (Easing -> String) -> ([Easing] -> ShowS) -> Show Easing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Easing -> ShowS
showsPrec :: Int -> Easing -> ShowS
$cshow :: Easing -> String
show :: Easing -> String
$cshowList :: [Easing] -> ShowS
showList :: [Easing] -> ShowS
Show, Easing -> Easing -> Bool
(Easing -> Easing -> Bool)
-> (Easing -> Easing -> Bool) -> Eq Easing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Easing -> Easing -> Bool
== :: Easing -> Easing -> Bool
$c/= :: Easing -> Easing -> Bool
/= :: Easing -> Easing -> Bool
Eq)

instance P.Enum Easing where
    fromEnum :: Easing -> Int
fromEnum Easing
EasingLinear = Int
0
    fromEnum Easing
EasingEaseInQuad = Int
1
    fromEnum Easing
EasingEaseOutQuad = Int
2
    fromEnum Easing
EasingEaseInOutQuad = Int
3
    fromEnum Easing
EasingEaseInCubic = Int
4
    fromEnum Easing
EasingEaseOutCubic = Int
5
    fromEnum Easing
EasingEaseInOutCubic = Int
6
    fromEnum Easing
EasingEaseInQuart = Int
7
    fromEnum Easing
EasingEaseOutQuart = Int
8
    fromEnum Easing
EasingEaseInOutQuart = Int
9
    fromEnum Easing
EasingEaseInQuint = Int
10
    fromEnum Easing
EasingEaseOutQuint = Int
11
    fromEnum Easing
EasingEaseInOutQuint = Int
12
    fromEnum Easing
EasingEaseInSine = Int
13
    fromEnum Easing
EasingEaseOutSine = Int
14
    fromEnum Easing
EasingEaseInOutSine = Int
15
    fromEnum Easing
EasingEaseInExpo = Int
16
    fromEnum Easing
EasingEaseOutExpo = Int
17
    fromEnum Easing
EasingEaseInOutExpo = Int
18
    fromEnum Easing
EasingEaseInCirc = Int
19
    fromEnum Easing
EasingEaseOutCirc = Int
20
    fromEnum Easing
EasingEaseInOutCirc = Int
21
    fromEnum Easing
EasingEaseInElastic = Int
22
    fromEnum Easing
EasingEaseOutElastic = Int
23
    fromEnum Easing
EasingEaseInOutElastic = Int
24
    fromEnum Easing
EasingEaseInBack = Int
25
    fromEnum Easing
EasingEaseOutBack = Int
26
    fromEnum Easing
EasingEaseInOutBack = Int
27
    fromEnum Easing
EasingEaseInBounce = Int
28
    fromEnum Easing
EasingEaseOutBounce = Int
29
    fromEnum Easing
EasingEaseInOutBounce = Int
30
    fromEnum (AnotherEasing Int
k) = Int
k

    toEnum :: Int -> Easing
toEnum Int
0 = Easing
EasingLinear
    toEnum Int
1 = Easing
EasingEaseInQuad
    toEnum Int
2 = Easing
EasingEaseOutQuad
    toEnum Int
3 = Easing
EasingEaseInOutQuad
    toEnum Int
4 = Easing
EasingEaseInCubic
    toEnum Int
5 = Easing
EasingEaseOutCubic
    toEnum Int
6 = Easing
EasingEaseInOutCubic
    toEnum Int
7 = Easing
EasingEaseInQuart
    toEnum Int
8 = Easing
EasingEaseOutQuart
    toEnum Int
9 = Easing
EasingEaseInOutQuart
    toEnum Int
10 = Easing
EasingEaseInQuint
    toEnum Int
11 = Easing
EasingEaseOutQuint
    toEnum Int
12 = Easing
EasingEaseInOutQuint
    toEnum Int
13 = Easing
EasingEaseInSine
    toEnum Int
14 = Easing
EasingEaseOutSine
    toEnum Int
15 = Easing
EasingEaseInOutSine
    toEnum Int
16 = Easing
EasingEaseInExpo
    toEnum Int
17 = Easing
EasingEaseOutExpo
    toEnum Int
18 = Easing
EasingEaseInOutExpo
    toEnum Int
19 = Easing
EasingEaseInCirc
    toEnum Int
20 = Easing
EasingEaseOutCirc
    toEnum Int
21 = Easing
EasingEaseInOutCirc
    toEnum Int
22 = Easing
EasingEaseInElastic
    toEnum Int
23 = Easing
EasingEaseOutElastic
    toEnum Int
24 = Easing
EasingEaseInOutElastic
    toEnum Int
25 = Easing
EasingEaseInBack
    toEnum Int
26 = Easing
EasingEaseOutBack
    toEnum Int
27 = Easing
EasingEaseInOutBack
    toEnum Int
28 = Easing
EasingEaseInBounce
    toEnum Int
29 = Easing
EasingEaseOutBounce
    toEnum Int
30 = Easing
EasingEaseInOutBounce
    toEnum Int
k = Int -> Easing
AnotherEasing Int
k

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

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

foreign import ccall "adw_easing_get_type" c_adw_easing_get_type :: 
    IO GType

instance B.Types.TypedObject Easing where
    glibType :: IO GType
glibType = IO GType
c_adw_easing_get_type

instance B.Types.BoxedEnum Easing

-- Enum ColorScheme
-- | Application color schemes for [property/@styleManager@/:color-scheme].
data ColorScheme = 
      ColorSchemeDefault
    -- ^ Inherit the parent color-scheme. When set on the
    --   @AdwStyleManager@ returned by @/StyleManager.get_default/@, it\'s
    --   equivalent to @ADW_COLOR_SCHEME_PREFER_LIGHT@.
    | ColorSchemeForceLight
    -- ^ Always use light appearance.
    | ColorSchemePreferLight
    -- ^ Use light appearance unless the system
    --   prefers dark colors.
    | ColorSchemePreferDark
    -- ^ Use dark appearance unless the system prefers
    --   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 "adw_color_scheme_get_type" c_adw_color_scheme_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum ColorScheme

-- Enum CenteringPolicy
-- | Describes title centering behavior of a [class/@headerBar@/] widget.
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 "adw_centering_policy_get_type" c_adw_centering_policy_get_type :: 
    IO GType

instance B.Types.TypedObject CenteringPolicy where
    glibType :: IO GType
glibType = IO GType
c_adw_centering_policy_get_type

instance B.Types.BoxedEnum CenteringPolicy

-- Enum AnimationState
-- | Describes the possible states of an [class/@animation@/].
-- 
-- The state can be controlled with [method/@animation@/.play],
-- [method/@animation@/.pause], [method/@animation@/.resume],
-- [method/@animation@/.reset] and [method/@animation@/.skip].
data AnimationState = 
      AnimationStateIdle
    -- ^ The animation hasn\'t started yet.
    | AnimationStatePaused
    -- ^ The animation has been paused.
    | AnimationStatePlaying
    -- ^ The animation is currently playing.
    | AnimationStateFinished
    -- ^ The animation has finished.
    | AnotherAnimationState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnimationState -> ShowS
[AnimationState] -> ShowS
AnimationState -> String
(Int -> AnimationState -> ShowS)
-> (AnimationState -> String)
-> ([AnimationState] -> ShowS)
-> Show AnimationState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnimationState -> ShowS
showsPrec :: Int -> AnimationState -> ShowS
$cshow :: AnimationState -> String
show :: AnimationState -> String
$cshowList :: [AnimationState] -> ShowS
showList :: [AnimationState] -> ShowS
Show, AnimationState -> AnimationState -> Bool
(AnimationState -> AnimationState -> Bool)
-> (AnimationState -> AnimationState -> Bool) -> Eq AnimationState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnimationState -> AnimationState -> Bool
== :: AnimationState -> AnimationState -> Bool
$c/= :: AnimationState -> AnimationState -> Bool
/= :: AnimationState -> AnimationState -> Bool
Eq)

instance P.Enum AnimationState where
    fromEnum :: AnimationState -> Int
fromEnum AnimationState
AnimationStateIdle = Int
0
    fromEnum AnimationState
AnimationStatePaused = Int
1
    fromEnum AnimationState
AnimationStatePlaying = Int
2
    fromEnum AnimationState
AnimationStateFinished = Int
3
    fromEnum (AnotherAnimationState Int
k) = Int
k

    toEnum :: Int -> AnimationState
toEnum Int
0 = AnimationState
AnimationStateIdle
    toEnum Int
1 = AnimationState
AnimationStatePaused
    toEnum Int
2 = AnimationState
AnimationStatePlaying
    toEnum Int
3 = AnimationState
AnimationStateFinished
    toEnum Int
k = Int -> AnimationState
AnotherAnimationState Int
k

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

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

foreign import ccall "adw_animation_state_get_type" c_adw_animation_state_get_type :: 
    IO GType

instance B.Types.TypedObject AnimationState where
    glibType :: IO GType
glibType = IO GType
c_adw_animation_state_get_type

instance B.Types.BoxedEnum AnimationState