#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vte.Enums
(
CursorBlinkMode(..) ,
CursorShape(..) ,
EraseBinding(..) ,
Format(..) ,
PtyError(..) ,
catchPtyError ,
handlePtyError ,
RegexError(..) ,
catchRegexError ,
handleRegexError ,
TextBlinkMode(..) ,
WriteFlags(..) ,
) 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 WriteFlags =
WriteFlagsDefault
| AnotherWriteFlags Int
deriving (Int -> WriteFlags -> ShowS
[WriteFlags] -> ShowS
WriteFlags -> String
(Int -> WriteFlags -> ShowS)
-> (WriteFlags -> String)
-> ([WriteFlags] -> ShowS)
-> Show WriteFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WriteFlags] -> ShowS
$cshowList :: [WriteFlags] -> ShowS
show :: WriteFlags -> String
$cshow :: WriteFlags -> String
showsPrec :: Int -> WriteFlags -> ShowS
$cshowsPrec :: Int -> WriteFlags -> ShowS
Show, WriteFlags -> WriteFlags -> Bool
(WriteFlags -> WriteFlags -> Bool)
-> (WriteFlags -> WriteFlags -> Bool) -> Eq WriteFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WriteFlags -> WriteFlags -> Bool
$c/= :: WriteFlags -> WriteFlags -> Bool
== :: WriteFlags -> WriteFlags -> Bool
$c== :: WriteFlags -> WriteFlags -> Bool
Eq)
instance P.Enum WriteFlags where
fromEnum :: WriteFlags -> Int
fromEnum WriteFlags
WriteFlagsDefault = Int
0
fromEnum (AnotherWriteFlags Int
k) = Int
k
toEnum :: Int -> WriteFlags
toEnum Int
0 = WriteFlags
WriteFlagsDefault
toEnum Int
k = Int -> WriteFlags
AnotherWriteFlags Int
k
instance P.Ord WriteFlags where
compare :: WriteFlags -> WriteFlags -> Ordering
compare WriteFlags
a WriteFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WriteFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum WriteFlags
a) (WriteFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum WriteFlags
b)
type instance O.ParentTypes WriteFlags = '[]
instance O.HasParentTypes WriteFlags
foreign import ccall "vte_write_flags_get_type" c_vte_write_flags_get_type ::
IO GType
instance B.Types.TypedObject WriteFlags where
glibType :: IO GType
glibType = IO GType
c_vte_write_flags_get_type
instance B.Types.BoxedEnum WriteFlags
data TextBlinkMode =
TextBlinkModeNever
| TextBlinkModeFocused
| TextBlinkModeUnfocused
| TextBlinkModeAlways
| AnotherTextBlinkMode Int
deriving (Int -> TextBlinkMode -> ShowS
[TextBlinkMode] -> ShowS
TextBlinkMode -> String
(Int -> TextBlinkMode -> ShowS)
-> (TextBlinkMode -> String)
-> ([TextBlinkMode] -> ShowS)
-> Show TextBlinkMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextBlinkMode] -> ShowS
$cshowList :: [TextBlinkMode] -> ShowS
show :: TextBlinkMode -> String
$cshow :: TextBlinkMode -> String
showsPrec :: Int -> TextBlinkMode -> ShowS
$cshowsPrec :: Int -> TextBlinkMode -> ShowS
Show, TextBlinkMode -> TextBlinkMode -> Bool
(TextBlinkMode -> TextBlinkMode -> Bool)
-> (TextBlinkMode -> TextBlinkMode -> Bool) -> Eq TextBlinkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextBlinkMode -> TextBlinkMode -> Bool
$c/= :: TextBlinkMode -> TextBlinkMode -> Bool
== :: TextBlinkMode -> TextBlinkMode -> Bool
$c== :: TextBlinkMode -> TextBlinkMode -> Bool
Eq)
instance P.Enum TextBlinkMode where
fromEnum :: TextBlinkMode -> Int
fromEnum TextBlinkMode
TextBlinkModeNever = Int
0
fromEnum TextBlinkMode
TextBlinkModeFocused = Int
1
fromEnum TextBlinkMode
TextBlinkModeUnfocused = Int
2
fromEnum TextBlinkMode
TextBlinkModeAlways = Int
3
fromEnum (AnotherTextBlinkMode Int
k) = Int
k
toEnum :: Int -> TextBlinkMode
toEnum Int
0 = TextBlinkMode
TextBlinkModeNever
toEnum Int
1 = TextBlinkMode
TextBlinkModeFocused
toEnum Int
2 = TextBlinkMode
TextBlinkModeUnfocused
toEnum Int
3 = TextBlinkMode
TextBlinkModeAlways
toEnum Int
k = Int -> TextBlinkMode
AnotherTextBlinkMode Int
k
instance P.Ord TextBlinkMode where
compare :: TextBlinkMode -> TextBlinkMode -> Ordering
compare TextBlinkMode
a TextBlinkMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextBlinkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TextBlinkMode
a) (TextBlinkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TextBlinkMode
b)
type instance O.ParentTypes TextBlinkMode = '[]
instance O.HasParentTypes TextBlinkMode
foreign import ccall "vte_text_blink_mode_get_type" c_vte_text_blink_mode_get_type ::
IO GType
instance B.Types.TypedObject TextBlinkMode where
glibType :: IO GType
glibType = IO GType
c_vte_text_blink_mode_get_type
instance B.Types.BoxedEnum TextBlinkMode
data RegexError =
RegexErrorIncompatible
| RegexErrorNotSupported
| AnotherRegexError Int
deriving (Int -> RegexError -> ShowS
[RegexError] -> ShowS
RegexError -> String
(Int -> RegexError -> ShowS)
-> (RegexError -> String)
-> ([RegexError] -> ShowS)
-> Show RegexError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexError] -> ShowS
$cshowList :: [RegexError] -> ShowS
show :: RegexError -> String
$cshow :: RegexError -> String
showsPrec :: Int -> RegexError -> ShowS
$cshowsPrec :: Int -> RegexError -> ShowS
Show, RegexError -> RegexError -> Bool
(RegexError -> RegexError -> Bool)
-> (RegexError -> RegexError -> Bool) -> Eq RegexError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexError -> RegexError -> Bool
$c/= :: RegexError -> RegexError -> Bool
== :: RegexError -> RegexError -> Bool
$c== :: RegexError -> RegexError -> Bool
Eq)
instance P.Enum RegexError where
fromEnum :: RegexError -> Int
fromEnum RegexError
RegexErrorIncompatible = Int
2147483646
fromEnum RegexError
RegexErrorNotSupported = Int
2147483647
fromEnum (AnotherRegexError Int
k) = Int
k
toEnum :: Int -> RegexError
toEnum Int
2147483646 = RegexError
RegexErrorIncompatible
toEnum Int
2147483647 = RegexError
RegexErrorNotSupported
toEnum Int
k = Int -> RegexError
AnotherRegexError Int
k
instance P.Ord RegexError where
compare :: RegexError -> RegexError -> Ordering
compare RegexError
a RegexError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RegexError -> Int
forall a. Enum a => a -> Int
P.fromEnum RegexError
a) (RegexError -> Int
forall a. Enum a => a -> Int
P.fromEnum RegexError
b)
instance GErrorClass RegexError where
gerrorClassDomain :: RegexError -> Text
gerrorClassDomain RegexError
_ = Text
"vte-regex-error"
catchRegexError ::
IO a ->
(RegexError -> GErrorMessage -> IO a) ->
IO a
catchRegexError :: forall a. IO a -> (RegexError -> Text -> IO a) -> IO a
catchRegexError = IO a -> (RegexError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleRegexError ::
(RegexError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleRegexError :: forall a. (RegexError -> Text -> IO a) -> IO a -> IO a
handleRegexError = (RegexError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes RegexError = '[]
instance O.HasParentTypes RegexError
foreign import ccall "vte_regex_error_get_type" c_vte_regex_error_get_type ::
IO GType
instance B.Types.TypedObject RegexError where
glibType :: IO GType
glibType = IO GType
c_vte_regex_error_get_type
instance B.Types.BoxedEnum RegexError
data PtyError =
PtyErrorPtyHelperFailed
| PtyErrorPty98Failed
| AnotherPtyError Int
deriving (Int -> PtyError -> ShowS
[PtyError] -> ShowS
PtyError -> String
(Int -> PtyError -> ShowS)
-> (PtyError -> String) -> ([PtyError] -> ShowS) -> Show PtyError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PtyError] -> ShowS
$cshowList :: [PtyError] -> ShowS
show :: PtyError -> String
$cshow :: PtyError -> String
showsPrec :: Int -> PtyError -> ShowS
$cshowsPrec :: Int -> PtyError -> ShowS
Show, PtyError -> PtyError -> Bool
(PtyError -> PtyError -> Bool)
-> (PtyError -> PtyError -> Bool) -> Eq PtyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PtyError -> PtyError -> Bool
$c/= :: PtyError -> PtyError -> Bool
== :: PtyError -> PtyError -> Bool
$c== :: PtyError -> PtyError -> Bool
Eq)
instance P.Enum PtyError where
fromEnum :: PtyError -> Int
fromEnum PtyError
PtyErrorPtyHelperFailed = Int
0
fromEnum PtyError
PtyErrorPty98Failed = Int
1
fromEnum (AnotherPtyError Int
k) = Int
k
toEnum :: Int -> PtyError
toEnum Int
0 = PtyError
PtyErrorPtyHelperFailed
toEnum Int
1 = PtyError
PtyErrorPty98Failed
toEnum Int
k = Int -> PtyError
AnotherPtyError Int
k
instance P.Ord PtyError where
compare :: PtyError -> PtyError -> Ordering
compare PtyError
a PtyError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PtyError -> Int
forall a. Enum a => a -> Int
P.fromEnum PtyError
a) (PtyError -> Int
forall a. Enum a => a -> Int
P.fromEnum PtyError
b)
instance GErrorClass PtyError where
gerrorClassDomain :: PtyError -> Text
gerrorClassDomain PtyError
_ = Text
"vte-pty-error"
catchPtyError ::
IO a ->
(PtyError -> GErrorMessage -> IO a) ->
IO a
catchPtyError :: forall a. IO a -> (PtyError -> Text -> IO a) -> IO a
catchPtyError = IO a -> (PtyError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handlePtyError ::
(PtyError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handlePtyError :: forall a. (PtyError -> Text -> IO a) -> IO a -> IO a
handlePtyError = (PtyError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes PtyError = '[]
instance O.HasParentTypes PtyError
foreign import ccall "vte_pty_error_get_type" c_vte_pty_error_get_type ::
IO GType
instance B.Types.TypedObject PtyError where
glibType :: IO GType
glibType = IO GType
c_vte_pty_error_get_type
instance B.Types.BoxedEnum PtyError
data Format =
FormatText
| FormatHtml
| AnotherFormat Int
deriving (Int -> Format -> ShowS
[Format] -> ShowS
Format -> String
(Int -> Format -> ShowS)
-> (Format -> String) -> ([Format] -> ShowS) -> Show Format
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Format] -> ShowS
$cshowList :: [Format] -> ShowS
show :: Format -> String
$cshow :: Format -> String
showsPrec :: Int -> Format -> ShowS
$cshowsPrec :: Int -> Format -> ShowS
Show, Format -> Format -> Bool
(Format -> Format -> Bool)
-> (Format -> Format -> Bool) -> Eq Format
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Format -> Format -> Bool
$c/= :: Format -> Format -> Bool
== :: Format -> Format -> Bool
$c== :: Format -> Format -> Bool
Eq)
instance P.Enum Format where
fromEnum :: Format -> Int
fromEnum Format
FormatText = Int
1
fromEnum Format
FormatHtml = Int
2
fromEnum (AnotherFormat Int
k) = Int
k
toEnum :: Int -> Format
toEnum Int
1 = Format
FormatText
toEnum Int
2 = Format
FormatHtml
toEnum Int
k = Int -> Format
AnotherFormat Int
k
instance P.Ord Format where
compare :: Format -> Format -> Ordering
compare Format
a Format
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Format -> Int
forall a. Enum a => a -> Int
P.fromEnum Format
a) (Format -> Int
forall a. Enum a => a -> Int
P.fromEnum Format
b)
type instance O.ParentTypes Format = '[]
instance O.HasParentTypes Format
foreign import ccall "vte_format_get_type" c_vte_format_get_type ::
IO GType
instance B.Types.TypedObject Format where
glibType :: IO GType
glibType = IO GType
c_vte_format_get_type
instance B.Types.BoxedEnum Format
data EraseBinding =
EraseBindingAuto
| EraseBindingAsciiBackspace
| EraseBindingAsciiDelete
| EraseBindingDeleteSequence
| EraseBindingTty
| AnotherEraseBinding Int
deriving (Int -> EraseBinding -> ShowS
[EraseBinding] -> ShowS
EraseBinding -> String
(Int -> EraseBinding -> ShowS)
-> (EraseBinding -> String)
-> ([EraseBinding] -> ShowS)
-> Show EraseBinding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EraseBinding] -> ShowS
$cshowList :: [EraseBinding] -> ShowS
show :: EraseBinding -> String
$cshow :: EraseBinding -> String
showsPrec :: Int -> EraseBinding -> ShowS
$cshowsPrec :: Int -> EraseBinding -> ShowS
Show, EraseBinding -> EraseBinding -> Bool
(EraseBinding -> EraseBinding -> Bool)
-> (EraseBinding -> EraseBinding -> Bool) -> Eq EraseBinding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EraseBinding -> EraseBinding -> Bool
$c/= :: EraseBinding -> EraseBinding -> Bool
== :: EraseBinding -> EraseBinding -> Bool
$c== :: EraseBinding -> EraseBinding -> Bool
Eq)
instance P.Enum EraseBinding where
fromEnum :: EraseBinding -> Int
fromEnum EraseBinding
EraseBindingAuto = Int
0
fromEnum EraseBinding
EraseBindingAsciiBackspace = Int
1
fromEnum EraseBinding
EraseBindingAsciiDelete = Int
2
fromEnum EraseBinding
EraseBindingDeleteSequence = Int
3
fromEnum EraseBinding
EraseBindingTty = Int
4
fromEnum (AnotherEraseBinding Int
k) = Int
k
toEnum :: Int -> EraseBinding
toEnum Int
0 = EraseBinding
EraseBindingAuto
toEnum Int
1 = EraseBinding
EraseBindingAsciiBackspace
toEnum Int
2 = EraseBinding
EraseBindingAsciiDelete
toEnum Int
3 = EraseBinding
EraseBindingDeleteSequence
toEnum Int
4 = EraseBinding
EraseBindingTty
toEnum Int
k = Int -> EraseBinding
AnotherEraseBinding Int
k
instance P.Ord EraseBinding where
compare :: EraseBinding -> EraseBinding -> Ordering
compare EraseBinding
a EraseBinding
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EraseBinding -> Int
forall a. Enum a => a -> Int
P.fromEnum EraseBinding
a) (EraseBinding -> Int
forall a. Enum a => a -> Int
P.fromEnum EraseBinding
b)
type instance O.ParentTypes EraseBinding = '[]
instance O.HasParentTypes EraseBinding
foreign import ccall "vte_erase_binding_get_type" c_vte_erase_binding_get_type ::
IO GType
instance B.Types.TypedObject EraseBinding where
glibType :: IO GType
glibType = IO GType
c_vte_erase_binding_get_type
instance B.Types.BoxedEnum EraseBinding
data CursorShape =
CursorShapeBlock
| CursorShapeIbeam
| CursorShapeUnderline
| AnotherCursorShape Int
deriving (Int -> CursorShape -> ShowS
[CursorShape] -> ShowS
CursorShape -> String
(Int -> CursorShape -> ShowS)
-> (CursorShape -> String)
-> ([CursorShape] -> ShowS)
-> Show CursorShape
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CursorShape] -> ShowS
$cshowList :: [CursorShape] -> ShowS
show :: CursorShape -> String
$cshow :: CursorShape -> String
showsPrec :: Int -> CursorShape -> ShowS
$cshowsPrec :: Int -> CursorShape -> ShowS
Show, CursorShape -> CursorShape -> Bool
(CursorShape -> CursorShape -> Bool)
-> (CursorShape -> CursorShape -> Bool) -> Eq CursorShape
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CursorShape -> CursorShape -> Bool
$c/= :: CursorShape -> CursorShape -> Bool
== :: CursorShape -> CursorShape -> Bool
$c== :: CursorShape -> CursorShape -> Bool
Eq)
instance P.Enum CursorShape where
fromEnum :: CursorShape -> Int
fromEnum CursorShape
CursorShapeBlock = Int
0
fromEnum CursorShape
CursorShapeIbeam = Int
1
fromEnum CursorShape
CursorShapeUnderline = Int
2
fromEnum (AnotherCursorShape Int
k) = Int
k
toEnum :: Int -> CursorShape
toEnum Int
0 = CursorShape
CursorShapeBlock
toEnum Int
1 = CursorShape
CursorShapeIbeam
toEnum Int
2 = CursorShape
CursorShapeUnderline
toEnum Int
k = Int -> CursorShape
AnotherCursorShape Int
k
instance P.Ord CursorShape where
compare :: CursorShape -> CursorShape -> Ordering
compare CursorShape
a CursorShape
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CursorShape -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorShape
a) (CursorShape -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorShape
b)
type instance O.ParentTypes CursorShape = '[]
instance O.HasParentTypes CursorShape
foreign import ccall "vte_cursor_shape_get_type" c_vte_cursor_shape_get_type ::
IO GType
instance B.Types.TypedObject CursorShape where
glibType :: IO GType
glibType = IO GType
c_vte_cursor_shape_get_type
instance B.Types.BoxedEnum CursorShape
data CursorBlinkMode =
CursorBlinkModeSystem
| CursorBlinkModeOn
| CursorBlinkModeOff
| AnotherCursorBlinkMode Int
deriving (Int -> CursorBlinkMode -> ShowS
[CursorBlinkMode] -> ShowS
CursorBlinkMode -> String
(Int -> CursorBlinkMode -> ShowS)
-> (CursorBlinkMode -> String)
-> ([CursorBlinkMode] -> ShowS)
-> Show CursorBlinkMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CursorBlinkMode] -> ShowS
$cshowList :: [CursorBlinkMode] -> ShowS
show :: CursorBlinkMode -> String
$cshow :: CursorBlinkMode -> String
showsPrec :: Int -> CursorBlinkMode -> ShowS
$cshowsPrec :: Int -> CursorBlinkMode -> ShowS
Show, CursorBlinkMode -> CursorBlinkMode -> Bool
(CursorBlinkMode -> CursorBlinkMode -> Bool)
-> (CursorBlinkMode -> CursorBlinkMode -> Bool)
-> Eq CursorBlinkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CursorBlinkMode -> CursorBlinkMode -> Bool
$c/= :: CursorBlinkMode -> CursorBlinkMode -> Bool
== :: CursorBlinkMode -> CursorBlinkMode -> Bool
$c== :: CursorBlinkMode -> CursorBlinkMode -> Bool
Eq)
instance P.Enum CursorBlinkMode where
fromEnum :: CursorBlinkMode -> Int
fromEnum CursorBlinkMode
CursorBlinkModeSystem = Int
0
fromEnum CursorBlinkMode
CursorBlinkModeOn = Int
1
fromEnum CursorBlinkMode
CursorBlinkModeOff = Int
2
fromEnum (AnotherCursorBlinkMode Int
k) = Int
k
toEnum :: Int -> CursorBlinkMode
toEnum Int
0 = CursorBlinkMode
CursorBlinkModeSystem
toEnum Int
1 = CursorBlinkMode
CursorBlinkModeOn
toEnum Int
2 = CursorBlinkMode
CursorBlinkModeOff
toEnum Int
k = Int -> CursorBlinkMode
AnotherCursorBlinkMode Int
k
instance P.Ord CursorBlinkMode where
compare :: CursorBlinkMode -> CursorBlinkMode -> Ordering
compare CursorBlinkMode
a CursorBlinkMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CursorBlinkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorBlinkMode
a) (CursorBlinkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorBlinkMode
b)
type instance O.ParentTypes CursorBlinkMode = '[]
instance O.HasParentTypes CursorBlinkMode
foreign import ccall "vte_cursor_blink_mode_get_type" c_vte_cursor_blink_mode_get_type ::
IO GType
instance B.Types.TypedObject CursorBlinkMode where
glibType :: IO GType
glibType = IO GType
c_vte_cursor_blink_mode_get_type
instance B.Types.BoxedEnum CursorBlinkMode