-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.ManagedPtr as B.ManagedPtr
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 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


-- 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 WriteFlagsDefault = 0
    fromEnum (AnotherWriteFlags k :: Int
k) = Int
k

    toEnum :: Int -> WriteFlags
toEnum 0 = WriteFlags
WriteFlagsDefault
    toEnum k :: Int
k = Int -> WriteFlags
AnotherWriteFlags Int
k

instance P.Ord WriteFlags where
    compare :: WriteFlags -> WriteFlags -> Ordering
compare a :: WriteFlags
a b :: 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)

foreign import ccall "vte_write_flags_get_type" c_vte_write_flags_get_type :: 
    IO GType

instance BoxedEnum WriteFlags where
    boxedEnumType :: WriteFlags -> IO GType
boxedEnumType _ = IO GType
c_vte_write_flags_get_type

-- 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 TextBlinkModeNever = 0
    fromEnum TextBlinkModeFocused = 1
    fromEnum TextBlinkModeUnfocused = 2
    fromEnum TextBlinkModeAlways = 3
    fromEnum (AnotherTextBlinkMode k :: Int
k) = Int
k

    toEnum :: Int -> TextBlinkMode
toEnum 0 = TextBlinkMode
TextBlinkModeNever
    toEnum 1 = TextBlinkMode
TextBlinkModeFocused
    toEnum 2 = TextBlinkMode
TextBlinkModeUnfocused
    toEnum 3 = TextBlinkMode
TextBlinkModeAlways
    toEnum k :: Int
k = Int -> TextBlinkMode
AnotherTextBlinkMode Int
k

instance P.Ord TextBlinkMode where
    compare :: TextBlinkMode -> TextBlinkMode -> Ordering
compare a :: TextBlinkMode
a b :: 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)

foreign import ccall "vte_text_blink_mode_get_type" c_vte_text_blink_mode_get_type :: 
    IO GType

instance BoxedEnum TextBlinkMode where
    boxedEnumType :: TextBlinkMode -> IO GType
boxedEnumType _ = IO GType
c_vte_text_blink_mode_get_type

-- 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 RegexErrorIncompatible = 2147483646
    fromEnum RegexErrorNotSupported = 2147483647
    fromEnum (AnotherRegexError k :: Int
k) = Int
k

    toEnum :: Int -> RegexError
toEnum 2147483646 = RegexError
RegexErrorIncompatible
    toEnum 2147483647 = RegexError
RegexErrorNotSupported
    toEnum k :: Int
k = Int -> RegexError
AnotherRegexError Int
k

instance P.Ord RegexError where
    compare :: RegexError -> RegexError -> Ordering
compare a :: RegexError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "vte_regex_error_get_type" c_vte_regex_error_get_type :: 
    IO GType

instance BoxedEnum RegexError where
    boxedEnumType :: RegexError -> IO GType
boxedEnumType _ = IO GType
c_vte_regex_error_get_type

-- 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 PtyErrorPtyHelperFailed = 0
    fromEnum PtyErrorPty98Failed = 1
    fromEnum (AnotherPtyError k :: Int
k) = Int
k

    toEnum :: Int -> PtyError
toEnum 0 = PtyError
PtyErrorPtyHelperFailed
    toEnum 1 = PtyError
PtyErrorPty98Failed
    toEnum k :: Int
k = Int -> PtyError
AnotherPtyError Int
k

instance P.Ord PtyError where
    compare :: PtyError -> PtyError -> Ordering
compare a :: PtyError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "vte_pty_error_get_type" c_vte_pty_error_get_type :: 
    IO GType

instance BoxedEnum PtyError where
    boxedEnumType :: PtyError -> IO GType
boxedEnumType _ = IO GType
c_vte_pty_error_get_type

-- Enum Format
-- | An enumeratio 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 FormatText = 1
    fromEnum FormatHtml = 2
    fromEnum (AnotherFormat k :: Int
k) = Int
k

    toEnum :: Int -> Format
toEnum 1 = Format
FormatText
    toEnum 2 = Format
FormatHtml
    toEnum k :: Int
k = Int -> Format
AnotherFormat Int
k

instance P.Ord Format where
    compare :: Format -> Format -> Ordering
compare a :: Format
a b :: 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)

foreign import ccall "vte_format_get_type" c_vte_format_get_type :: 
    IO GType

instance BoxedEnum Format where
    boxedEnumType :: Format -> IO GType
boxedEnumType _ = IO GType
c_vte_format_get_type

-- 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 EraseBindingAuto = 0
    fromEnum EraseBindingAsciiBackspace = 1
    fromEnum EraseBindingAsciiDelete = 2
    fromEnum EraseBindingDeleteSequence = 3
    fromEnum EraseBindingTty = 4
    fromEnum (AnotherEraseBinding k :: Int
k) = Int
k

    toEnum :: Int -> EraseBinding
toEnum 0 = EraseBinding
EraseBindingAuto
    toEnum 1 = EraseBinding
EraseBindingAsciiBackspace
    toEnum 2 = EraseBinding
EraseBindingAsciiDelete
    toEnum 3 = EraseBinding
EraseBindingDeleteSequence
    toEnum 4 = EraseBinding
EraseBindingTty
    toEnum k :: Int
k = Int -> EraseBinding
AnotherEraseBinding Int
k

instance P.Ord EraseBinding where
    compare :: EraseBinding -> EraseBinding -> Ordering
compare a :: EraseBinding
a b :: 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)

foreign import ccall "vte_erase_binding_get_type" c_vte_erase_binding_get_type :: 
    IO GType

instance BoxedEnum EraseBinding where
    boxedEnumType :: EraseBinding -> IO GType
boxedEnumType _ = IO GType
c_vte_erase_binding_get_type

-- 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 CursorShapeBlock = 0
    fromEnum CursorShapeIbeam = 1
    fromEnum CursorShapeUnderline = 2
    fromEnum (AnotherCursorShape k :: Int
k) = Int
k

    toEnum :: Int -> CursorShape
toEnum 0 = CursorShape
CursorShapeBlock
    toEnum 1 = CursorShape
CursorShapeIbeam
    toEnum 2 = CursorShape
CursorShapeUnderline
    toEnum k :: Int
k = Int -> CursorShape
AnotherCursorShape Int
k

instance P.Ord CursorShape where
    compare :: CursorShape -> CursorShape -> Ordering
compare a :: CursorShape
a b :: 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)

foreign import ccall "vte_cursor_shape_get_type" c_vte_cursor_shape_get_type :: 
    IO GType

instance BoxedEnum CursorShape where
    boxedEnumType :: CursorShape -> IO GType
boxedEnumType _ = IO GType
c_vte_cursor_shape_get_type

-- 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 CursorBlinkModeSystem = 0
    fromEnum CursorBlinkModeOn = 1
    fromEnum CursorBlinkModeOff = 2
    fromEnum (AnotherCursorBlinkMode k :: Int
k) = Int
k

    toEnum :: Int -> CursorBlinkMode
toEnum 0 = CursorBlinkMode
CursorBlinkModeSystem
    toEnum 1 = CursorBlinkMode
CursorBlinkModeOn
    toEnum 2 = CursorBlinkMode
CursorBlinkModeOff
    toEnum k :: Int
k = Int -> CursorBlinkMode
AnotherCursorBlinkMode Int
k

instance P.Ord CursorBlinkMode where
    compare :: CursorBlinkMode -> CursorBlinkMode -> Ordering
compare a :: CursorBlinkMode
a b :: 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)

foreign import ccall "vte_cursor_blink_mode_get_type" c_vte_cursor_blink_mode_get_type :: 
    IO GType

instance BoxedEnum CursorBlinkMode where
    boxedEnumType :: CursorBlinkMode -> IO GType
boxedEnumType _ = IO GType
c_vte_cursor_blink_mode_get_type