Enums.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

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.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 (Show, Eq)

instance P.Enum WriteFlags where
    fromEnum WriteFlagsDefault = 0
    fromEnum (AnotherWriteFlags k) = k

    toEnum 0 = WriteFlagsDefault
    toEnum k = AnotherWriteFlags k

instance P.Ord WriteFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_write_flags_get_type" c_vte_write_flags_get_type :: 
    IO GType

instance BoxedEnum WriteFlags where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum TextBlinkMode where
    fromEnum TextBlinkModeNever = 0
    fromEnum TextBlinkModeFocused = 1
    fromEnum TextBlinkModeUnfocused = 2
    fromEnum TextBlinkModeAlways = 3
    fromEnum (AnotherTextBlinkMode k) = k

    toEnum 0 = TextBlinkModeNever
    toEnum 1 = TextBlinkModeFocused
    toEnum 2 = TextBlinkModeUnfocused
    toEnum 3 = TextBlinkModeAlways
    toEnum k = AnotherTextBlinkMode k

instance P.Ord TextBlinkMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_text_blink_mode_get_type" c_vte_text_blink_mode_get_type :: 
    IO GType

instance BoxedEnum TextBlinkMode where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum RegexError where
    fromEnum RegexErrorIncompatible = 2147483646
    fromEnum RegexErrorNotSupported = 2147483647
    fromEnum (AnotherRegexError k) = k

    toEnum 2147483646 = RegexErrorIncompatible
    toEnum 2147483647 = RegexErrorNotSupported
    toEnum k = AnotherRegexError k

instance P.Ord RegexError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass RegexError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "vte_regex_error_get_type" c_vte_regex_error_get_type :: 
    IO GType

instance BoxedEnum RegexError where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum PtyError where
    fromEnum PtyErrorPtyHelperFailed = 0
    fromEnum PtyErrorPty98Failed = 1
    fromEnum (AnotherPtyError k) = k

    toEnum 0 = PtyErrorPtyHelperFailed
    toEnum 1 = PtyErrorPty98Failed
    toEnum k = AnotherPtyError k

instance P.Ord PtyError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass PtyError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "vte_pty_error_get_type" c_vte_pty_error_get_type :: 
    IO GType

instance BoxedEnum PtyError where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum Format where
    fromEnum FormatText = 1
    fromEnum FormatHtml = 2
    fromEnum (AnotherFormat k) = k

    toEnum 1 = FormatText
    toEnum 2 = FormatHtml
    toEnum k = AnotherFormat k

instance P.Ord Format where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_format_get_type" c_vte_format_get_type :: 
    IO GType

instance BoxedEnum Format where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum EraseBinding where
    fromEnum EraseBindingAuto = 0
    fromEnum EraseBindingAsciiBackspace = 1
    fromEnum EraseBindingAsciiDelete = 2
    fromEnum EraseBindingDeleteSequence = 3
    fromEnum EraseBindingTty = 4
    fromEnum (AnotherEraseBinding k) = k

    toEnum 0 = EraseBindingAuto
    toEnum 1 = EraseBindingAsciiBackspace
    toEnum 2 = EraseBindingAsciiDelete
    toEnum 3 = EraseBindingDeleteSequence
    toEnum 4 = EraseBindingTty
    toEnum k = AnotherEraseBinding k

instance P.Ord EraseBinding where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_erase_binding_get_type" c_vte_erase_binding_get_type :: 
    IO GType

instance BoxedEnum EraseBinding where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum CursorShape where
    fromEnum CursorShapeBlock = 0
    fromEnum CursorShapeIbeam = 1
    fromEnum CursorShapeUnderline = 2
    fromEnum (AnotherCursorShape k) = k

    toEnum 0 = CursorShapeBlock
    toEnum 1 = CursorShapeIbeam
    toEnum 2 = CursorShapeUnderline
    toEnum k = AnotherCursorShape k

instance P.Ord CursorShape where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_cursor_shape_get_type" c_vte_cursor_shape_get_type :: 
    IO GType

instance BoxedEnum CursorShape where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum CursorBlinkMode where
    fromEnum CursorBlinkModeSystem = 0
    fromEnum CursorBlinkModeOn = 1
    fromEnum CursorBlinkModeOff = 2
    fromEnum (AnotherCursorBlinkMode k) = k

    toEnum 0 = CursorBlinkModeSystem
    toEnum 1 = CursorBlinkModeOn
    toEnum 2 = CursorBlinkModeOff
    toEnum k = AnotherCursorBlinkMode k

instance P.Ord CursorBlinkMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "vte_cursor_blink_mode_get_type" c_vte_cursor_blink_mode_get_type :: 
    IO GType

instance BoxedEnum CursorBlinkMode where
    boxedEnumType _ = c_vte_cursor_blink_mode_get_type