#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Adw.Enums
(
CenteringPolicy(..) ,
ColorScheme(..) ,
FlapFoldPolicy(..) ,
FlapTransitionType(..) ,
FoldThresholdPolicy(..) ,
LeafletTransitionType(..) ,
NavigationDirection(..) ,
SqueezerTransitionType(..) ,
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
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
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
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 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
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 "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 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
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 "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
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 "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
showList :: [FoldThresholdPolicy] -> ShowS
$cshowList :: [FoldThresholdPolicy] -> ShowS
show :: FoldThresholdPolicy -> String
$cshow :: FoldThresholdPolicy -> String
showsPrec :: Int -> FoldThresholdPolicy -> ShowS
$cshowsPrec :: Int -> FoldThresholdPolicy -> ShowS
Show, FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
(FoldThresholdPolicy -> FoldThresholdPolicy -> Bool)
-> (FoldThresholdPolicy -> FoldThresholdPolicy -> Bool)
-> Eq FoldThresholdPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
$c/= :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
== :: FoldThresholdPolicy -> FoldThresholdPolicy -> Bool
$c== :: 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
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 "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
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 "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 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
showList :: [ColorScheme] -> ShowS
$cshowList :: [ColorScheme] -> ShowS
show :: ColorScheme -> String
$cshow :: ColorScheme -> String
showsPrec :: Int -> ColorScheme -> ShowS
$cshowsPrec :: Int -> ColorScheme -> ShowS
Show, ColorScheme -> ColorScheme -> Bool
(ColorScheme -> ColorScheme -> Bool)
-> (ColorScheme -> ColorScheme -> Bool) -> Eq ColorScheme
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColorScheme -> ColorScheme -> Bool
$c/= :: ColorScheme -> ColorScheme -> Bool
== :: ColorScheme -> ColorScheme -> Bool
$c== :: 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
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 "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