#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Adw.Enums
(
AnimationState(..) ,
CenteringPolicy(..) ,
ColorScheme(..) ,
Easing(..) ,
FlapFoldPolicy(..) ,
FlapTransitionType(..) ,
FoldThresholdPolicy(..) ,
LeafletTransitionType(..) ,
NavigationDirection(..) ,
ResponseAppearance(..) ,
SqueezerTransitionType(..) ,
ToastPriority(..) ,
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
data ViewSwitcherPolicy =
ViewSwitcherPolicyNarrow
| ViewSwitcherPolicyWide
| AnotherViewSwitcherPolicy Int
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
data ToastPriority =
ToastPriorityNormal
| ToastPriorityHigh
| AnotherToastPriority Int
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
data SqueezerTransitionType =
SqueezerTransitionTypeNone
| SqueezerTransitionTypeCrossfade
| AnotherSqueezerTransitionType Int
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
data ResponseAppearance =
ResponseAppearanceDefault
| ResponseAppearanceSuggested
| ResponseAppearanceDestructive
| AnotherResponseAppearance Int
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
data NavigationDirection =
NavigationDirectionBack
| NavigationDirectionForward
| AnotherNavigationDirection Int
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
data LeafletTransitionType =
LeafletTransitionTypeOver
| LeafletTransitionTypeUnder
| LeafletTransitionTypeSlide
| AnotherLeafletTransitionType Int
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
data FoldThresholdPolicy =
FoldThresholdPolicyMinimum
| FoldThresholdPolicyNatural
| AnotherFoldThresholdPolicy Int
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
data FlapTransitionType =
FlapTransitionTypeOver
| FlapTransitionTypeUnder
| FlapTransitionTypeSlide
| AnotherFlapTransitionType Int
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
data FlapFoldPolicy =
FlapFoldPolicyNever
| FlapFoldPolicyAlways
| FlapFoldPolicyAuto
| AnotherFlapFoldPolicy Int
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
data Easing =
EasingLinear
| EasingEaseInQuad
| EasingEaseOutQuad
| EasingEaseInOutQuad
| EasingEaseInCubic
| EasingEaseOutCubic
| EasingEaseInOutCubic
| EasingEaseInQuart
| EasingEaseOutQuart
| EasingEaseInOutQuart
| EasingEaseInQuint
| EasingEaseOutQuint
| EasingEaseInOutQuint
| EasingEaseInSine
| EasingEaseOutSine
| EasingEaseInOutSine
| EasingEaseInExpo
| EasingEaseOutExpo
| EasingEaseInOutExpo
| EasingEaseInCirc
| EasingEaseOutCirc
| EasingEaseInOutCirc
| EasingEaseInElastic
| EasingEaseOutElastic
| EasingEaseInOutElastic
| EasingEaseInBack
| EasingEaseOutBack
| EasingEaseInOutBack
| EasingEaseInBounce
| EasingEaseOutBounce
| EasingEaseInOutBounce
| AnotherEasing Int
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
data ColorScheme =
ColorSchemeDefault
| ColorSchemeForceLight
| ColorSchemePreferLight
| ColorSchemePreferDark
| ColorSchemeForceDark
| AnotherColorScheme Int
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
data CenteringPolicy =
CenteringPolicyLoose
| CenteringPolicyStrict
| AnotherCenteringPolicy Int
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
data AnimationState =
AnimationStateIdle
| AnimationStatePaused
| AnimationStatePlaying
| AnimationStateFinished
| AnotherAnimationState Int
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