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

 -- * Enumerations


-- ** CursorBlinkMode #enum:CursorBlinkMode#

    CursorBlinkMode(..)                     ,


-- ** CursorShape #enum:CursorShape#

    CursorShape(..)                         ,


-- ** EraseBinding #enum:EraseBinding#

    EraseBinding(..)                        ,


-- ** Format #enum:Format#

    Format(..)                              ,


-- ** PtyError #enum:PtyError#

    PtyError(..)                            ,
    catchPtyError                           ,
    handlePtyError                          ,


-- ** RegexError #enum:RegexError#

    RegexError(..)                          ,
    catchRegexError                         ,
    handleRegexError                        ,


-- ** TextBlinkMode #enum:TextBlinkMode#

    TextBlinkMode(..)                       ,


-- ** WriteFlags #enum:WriteFlags#

    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


-- Enum WriteFlags
-- | A flag type to determine how terminal contents should be written
-- to an output stream.
data WriteFlags = 
      WriteFlagsDefault
    -- ^ Write contents as UTF-8 text.  This is the default.
    | AnotherWriteFlags Int
    -- ^ Catch-all for unknown values
    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

-- Enum TextBlinkMode
-- | An enumerated type which can be used to indicate whether the terminal allows
-- the text contents to be blinked.
-- 
-- /Since: 0.52/
data TextBlinkMode = 
      TextBlinkModeNever
    -- ^ Do not blink the text.
    | TextBlinkModeFocused
    -- ^ Allow blinking text only if the terminal is focused.
    | TextBlinkModeUnfocused
    -- ^ Allow blinking text only if the terminal is unfocused.
    | TextBlinkModeAlways
    -- ^ Allow blinking text. This is the default.
    | AnotherTextBlinkMode Int
    -- ^ Catch-all for unknown values
    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

-- Enum RegexError
-- | An enum type for regex errors. In addition to the values listed above,
-- any PCRE2 error values may occur.
-- 
-- /Since: 0.46/
data RegexError = 
      RegexErrorIncompatible
    -- ^ The PCRE2 library was built without
    --   Unicode support which is required for VTE
    | RegexErrorNotSupported
    -- ^ Regexes are not supported because VTE was
    --   built without PCRE2 support
    | AnotherRegexError Int
    -- ^ Catch-all for unknown values
    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"

-- | Catch exceptions of type `RegexError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
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

-- | Handle exceptions of type `RegexError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
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

-- Enum PtyError
-- | /No description available in the introspection data./
data PtyError = 
      PtyErrorPtyHelperFailed
    -- ^ Obsolete. Deprecated: 0.42
    | PtyErrorPty98Failed
    -- ^ failure when using PTY98 to allocate the PTY
    | AnotherPtyError Int
    -- ^ Catch-all for unknown values
    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"

-- | Catch exceptions of type `PtyError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
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

-- | Handle exceptions of type `PtyError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
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

-- Enum Format
-- | An enumeration type that can be used to specify the format the selection
-- should be copied to the clipboard in.
-- 
-- /Since: 0.50/
data Format = 
      FormatText
    -- ^ Export as plain text
    | FormatHtml
    -- ^ Export as HTML formatted text
    | AnotherFormat Int
    -- ^ Catch-all for unknown values
    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

-- Enum EraseBinding
-- | An enumerated type which can be used to indicate which string the terminal
-- should send to an application when the user presses the Delete or Backspace
-- keys.
data EraseBinding = 
      EraseBindingAuto
    -- ^ For backspace, attempt to determine the right value from the terminal\'s IO settings.  For delete, use the control sequence.
    | EraseBindingAsciiBackspace
    -- ^ Send an ASCII backspace character (0x08).
    | EraseBindingAsciiDelete
    -- ^ Send an ASCII delete character (0x7F).
    | EraseBindingDeleteSequence
    -- ^ Send the \"\@/@7@/\" control sequence.
    | EraseBindingTty
    -- ^ Send terminal\'s \"erase\" setting.
    | AnotherEraseBinding Int
    -- ^ Catch-all for unknown values
    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

-- Enum CursorShape
-- | An enumerated type which can be used to indicate what should the terminal
-- draw at the cursor position.
data CursorShape = 
      CursorShapeBlock
    -- ^ Draw a block cursor.  This is the default.
    | CursorShapeIbeam
    -- ^ Draw a vertical bar on the left side of character.
    -- This is similar to the default cursor for other GTK+ widgets.
    | CursorShapeUnderline
    -- ^ Draw a horizontal bar below the character.
    | AnotherCursorShape Int
    -- ^ Catch-all for unknown values
    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

-- Enum CursorBlinkMode
-- | An enumerated type which can be used to indicate the cursor blink mode
-- for the terminal.
data CursorBlinkMode = 
      CursorBlinkModeSystem
    -- ^ Follow GTK+ settings for cursor blinking.
    | CursorBlinkModeOn
    -- ^ Cursor blinks.
    | CursorBlinkModeOff
    -- ^ Cursor does not blink.
    | AnotherCursorBlinkMode Int
    -- ^ Catch-all for unknown values
    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