-- | 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


-- ** Align #enum:Align#

    Align(..)                               ,


-- ** CursorBlinkMode #enum:CursorBlinkMode#

    CursorBlinkMode(..)                     ,


-- ** CursorShape #enum:CursorShape#

    CursorShape(..)                         ,


-- ** EraseBinding #enum:EraseBinding#

    EraseBinding(..)                        ,


-- ** Format #enum:Format#

    Format(..)                              ,


-- ** ProgressHint #enum:ProgressHint#

    ProgressHint(..)                        ,


-- ** PropertyId #enum:PropertyId#

    PropertyId(..)                          ,


-- ** PropertyType #enum:PropertyType#

    PropertyType(..)                        ,


-- ** 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.GHashTable as B.GHT
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.Kind as DK
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
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)

#else

#endif

-- 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
$cshowsPrec :: Int -> WriteFlags -> ShowS
showsPrec :: Int -> WriteFlags -> ShowS
$cshow :: WriteFlags -> String
show :: WriteFlags -> String
$cshowList :: [WriteFlags] -> ShowS
showList :: [WriteFlags] -> ShowS
Show, WriteFlags -> WriteFlags -> Bool
(WriteFlags -> WriteFlags -> Bool)
-> (WriteFlags -> WriteFlags -> Bool) -> Eq WriteFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WriteFlags -> WriteFlags -> Bool
== :: WriteFlags -> WriteFlags -> Bool
$c/= :: WriteFlags -> WriteFlags -> Bool
/= :: 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
$cshowsPrec :: Int -> TextBlinkMode -> ShowS
showsPrec :: Int -> TextBlinkMode -> ShowS
$cshow :: TextBlinkMode -> String
show :: TextBlinkMode -> String
$cshowList :: [TextBlinkMode] -> ShowS
showList :: [TextBlinkMode] -> ShowS
Show, TextBlinkMode -> TextBlinkMode -> Bool
(TextBlinkMode -> TextBlinkMode -> Bool)
-> (TextBlinkMode -> TextBlinkMode -> Bool) -> Eq TextBlinkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextBlinkMode -> TextBlinkMode -> Bool
== :: TextBlinkMode -> TextBlinkMode -> Bool
$c/= :: TextBlinkMode -> TextBlinkMode -> Bool
/= :: 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
$cshowsPrec :: Int -> RegexError -> ShowS
showsPrec :: Int -> RegexError -> ShowS
$cshow :: RegexError -> String
show :: RegexError -> String
$cshowList :: [RegexError] -> ShowS
showList :: [RegexError] -> ShowS
Show, RegexError -> RegexError -> Bool
(RegexError -> RegexError -> Bool)
-> (RegexError -> RegexError -> Bool) -> Eq RegexError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegexError -> RegexError -> Bool
== :: RegexError -> RegexError -> Bool
$c/= :: RegexError -> RegexError -> Bool
/= :: 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
$cshowsPrec :: Int -> PtyError -> ShowS
showsPrec :: Int -> PtyError -> ShowS
$cshow :: PtyError -> String
show :: PtyError -> String
$cshowList :: [PtyError] -> ShowS
showList :: [PtyError] -> ShowS
Show, PtyError -> PtyError -> Bool
(PtyError -> PtyError -> Bool)
-> (PtyError -> PtyError -> Bool) -> Eq PtyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PtyError -> PtyError -> Bool
== :: PtyError -> PtyError -> Bool
$c/= :: PtyError -> PtyError -> Bool
/= :: 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 PropertyType
-- | An enumeration type describing types of properties.
-- 
-- /Since: 0.78/
data PropertyType = 
      PropertyTypeValueless
    -- ^ no value, use for signalling
    | PropertyTypeBool
    -- ^ a bool
    | PropertyTypeInt
    -- ^ a signed 64-bit integer
    | PropertyTypeUint
    -- ^ an unsigned 64-bit integer
    | PropertyTypeDouble
    -- ^ a finite double-precision floating point number
    | PropertyTypeRgb
    -- ^ a color
    | PropertyTypeRgba
    -- ^ a color with alpha
    | PropertyTypeString
    -- ^ a string
    | PropertyTypeData
    -- ^ binary data
    | PropertyTypeUuid
    -- ^ a UUID
    | PropertyTypeUri
    -- ^ a URI
    | PropertyTypeImage
    -- ^ an image. Since: 0.80
    | AnotherPropertyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PropertyType -> ShowS
[PropertyType] -> ShowS
PropertyType -> String
(Int -> PropertyType -> ShowS)
-> (PropertyType -> String)
-> ([PropertyType] -> ShowS)
-> Show PropertyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyType -> ShowS
showsPrec :: Int -> PropertyType -> ShowS
$cshow :: PropertyType -> String
show :: PropertyType -> String
$cshowList :: [PropertyType] -> ShowS
showList :: [PropertyType] -> ShowS
Show, PropertyType -> PropertyType -> Bool
(PropertyType -> PropertyType -> Bool)
-> (PropertyType -> PropertyType -> Bool) -> Eq PropertyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyType -> PropertyType -> Bool
== :: PropertyType -> PropertyType -> Bool
$c/= :: PropertyType -> PropertyType -> Bool
/= :: PropertyType -> PropertyType -> Bool
Eq)

instance P.Enum PropertyType where
    fromEnum :: PropertyType -> Int
fromEnum PropertyType
PropertyTypeValueless = Int
0
    fromEnum PropertyType
PropertyTypeBool = Int
1
    fromEnum PropertyType
PropertyTypeInt = Int
2
    fromEnum PropertyType
PropertyTypeUint = Int
3
    fromEnum PropertyType
PropertyTypeDouble = Int
4
    fromEnum PropertyType
PropertyTypeRgb = Int
5
    fromEnum PropertyType
PropertyTypeRgba = Int
6
    fromEnum PropertyType
PropertyTypeString = Int
7
    fromEnum PropertyType
PropertyTypeData = Int
8
    fromEnum PropertyType
PropertyTypeUuid = Int
9
    fromEnum PropertyType
PropertyTypeUri = Int
10
    fromEnum PropertyType
PropertyTypeImage = Int
11
    fromEnum (AnotherPropertyType Int
k) = Int
k

    toEnum :: Int -> PropertyType
toEnum Int
0 = PropertyType
PropertyTypeValueless
    toEnum Int
1 = PropertyType
PropertyTypeBool
    toEnum Int
2 = PropertyType
PropertyTypeInt
    toEnum Int
3 = PropertyType
PropertyTypeUint
    toEnum Int
4 = PropertyType
PropertyTypeDouble
    toEnum Int
5 = PropertyType
PropertyTypeRgb
    toEnum Int
6 = PropertyType
PropertyTypeRgba
    toEnum Int
7 = PropertyType
PropertyTypeString
    toEnum Int
8 = PropertyType
PropertyTypeData
    toEnum Int
9 = PropertyType
PropertyTypeUuid
    toEnum Int
10 = PropertyType
PropertyTypeUri
    toEnum Int
11 = PropertyType
PropertyTypeImage
    toEnum Int
k = Int -> PropertyType
AnotherPropertyType Int
k

instance P.Ord PropertyType where
    compare :: PropertyType -> PropertyType -> Ordering
compare PropertyType
a PropertyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropertyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyType
a) (PropertyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyType
b)

type instance O.ParentTypes PropertyType = '[]
instance O.HasParentTypes PropertyType

foreign import ccall "vte_property_type_get_type" c_vte_property_type_get_type :: 
    IO GType

instance B.Types.TypedObject PropertyType where
    glibType :: IO GType
glibType = IO GType
c_vte_property_type_get_type

instance B.Types.BoxedEnum PropertyType

-- Enum PropertyId
-- | An enum containing the IDs of the always-installed termprops.
-- 
-- /Since: 0.78/
data PropertyId = 
      PropertyIdCurrentDirectoryUri
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_CURRENT_DIRECTORY_URI' termprop
    | PropertyIdCurrentFileUri
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_CURRENT_FILE_URI' termprop
    | PropertyIdXtermTitle
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_XTERM_TITLE' termprop
    | PropertyIdContainerName
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_CONTAINER_NAME' termprop
    | PropertyIdContainerRuntime
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_CONTAINER_RUNTIME' termprop
    | PropertyIdContainerUid
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_CONTAINER_UID' termprop
    | PropertyIdShellPrecmd
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_SHELL_PRECMD' termprop
    | PropertyIdShellPreexec
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_SHELL_PREEXEC' termprop
    | PropertyIdShellPostexec
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_SHELL_POSTEXEC' termprop
    | PropertyIdProgressHint
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_PROGRESS_HINT' termprop. Since: 0.80
    | PropertyIdProgressValue
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_PROGRESS_VALUE' termprop. Since: 0.80
    | PropertyIdIconColor
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_ICON_COLOR' termprop. Since: 0.80
    | PropertyIdIconImage
    -- ^ the ID of the 'GI.Vte.Constants.TERMPROP_ICON_IMAGE' termprop. Since: 0.80
    | AnotherPropertyId Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PropertyId -> ShowS
[PropertyId] -> ShowS
PropertyId -> String
(Int -> PropertyId -> ShowS)
-> (PropertyId -> String)
-> ([PropertyId] -> ShowS)
-> Show PropertyId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyId -> ShowS
showsPrec :: Int -> PropertyId -> ShowS
$cshow :: PropertyId -> String
show :: PropertyId -> String
$cshowList :: [PropertyId] -> ShowS
showList :: [PropertyId] -> ShowS
Show, PropertyId -> PropertyId -> Bool
(PropertyId -> PropertyId -> Bool)
-> (PropertyId -> PropertyId -> Bool) -> Eq PropertyId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyId -> PropertyId -> Bool
== :: PropertyId -> PropertyId -> Bool
$c/= :: PropertyId -> PropertyId -> Bool
/= :: PropertyId -> PropertyId -> Bool
Eq)

instance P.Enum PropertyId where
    fromEnum :: PropertyId -> Int
fromEnum PropertyId
PropertyIdCurrentDirectoryUri = Int
0
    fromEnum PropertyId
PropertyIdCurrentFileUri = Int
1
    fromEnum PropertyId
PropertyIdXtermTitle = Int
2
    fromEnum PropertyId
PropertyIdContainerName = Int
3
    fromEnum PropertyId
PropertyIdContainerRuntime = Int
4
    fromEnum PropertyId
PropertyIdContainerUid = Int
5
    fromEnum PropertyId
PropertyIdShellPrecmd = Int
6
    fromEnum PropertyId
PropertyIdShellPreexec = Int
7
    fromEnum PropertyId
PropertyIdShellPostexec = Int
8
    fromEnum PropertyId
PropertyIdProgressHint = Int
9
    fromEnum PropertyId
PropertyIdProgressValue = Int
10
    fromEnum PropertyId
PropertyIdIconColor = Int
11
    fromEnum PropertyId
PropertyIdIconImage = Int
12
    fromEnum (AnotherPropertyId Int
k) = Int
k

    toEnum :: Int -> PropertyId
toEnum Int
0 = PropertyId
PropertyIdCurrentDirectoryUri
    toEnum Int
1 = PropertyId
PropertyIdCurrentFileUri
    toEnum Int
2 = PropertyId
PropertyIdXtermTitle
    toEnum Int
3 = PropertyId
PropertyIdContainerName
    toEnum Int
4 = PropertyId
PropertyIdContainerRuntime
    toEnum Int
5 = PropertyId
PropertyIdContainerUid
    toEnum Int
6 = PropertyId
PropertyIdShellPrecmd
    toEnum Int
7 = PropertyId
PropertyIdShellPreexec
    toEnum Int
8 = PropertyId
PropertyIdShellPostexec
    toEnum Int
9 = PropertyId
PropertyIdProgressHint
    toEnum Int
10 = PropertyId
PropertyIdProgressValue
    toEnum Int
11 = PropertyId
PropertyIdIconColor
    toEnum Int
12 = PropertyId
PropertyIdIconImage
    toEnum Int
k = Int -> PropertyId
AnotherPropertyId Int
k

instance P.Ord PropertyId where
    compare :: PropertyId -> PropertyId -> Ordering
compare PropertyId
a PropertyId
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropertyId -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyId
a) (PropertyId -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyId
b)

type instance O.ParentTypes PropertyId = '[]
instance O.HasParentTypes PropertyId

foreign import ccall "vte_property_id_get_type" c_vte_property_id_get_type :: 
    IO GType

instance B.Types.TypedObject PropertyId where
    glibType :: IO GType
glibType = IO GType
c_vte_property_id_get_type

instance B.Types.BoxedEnum PropertyId

-- Enum ProgressHint
-- | An enum describing how to interpret progress state, for the
-- 'GI.Vte.Constants.TERMPROP_PROGRESS_HINT' termprop.
-- 
-- /Since: 0.80/
data ProgressHint = 
      ProgressHintInactive
    -- ^ no progress current
    | ProgressHintActive
    -- ^ progress is normal
    | ProgressHintError
    -- ^ progress is aborted by an error
    | ProgressHintIndeterminate
    -- ^ progress is indeterminate
    | ProgressHintPaused
    -- ^ progress is paused
    | AnotherProgressHint Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ProgressHint -> ShowS
[ProgressHint] -> ShowS
ProgressHint -> String
(Int -> ProgressHint -> ShowS)
-> (ProgressHint -> String)
-> ([ProgressHint] -> ShowS)
-> Show ProgressHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProgressHint -> ShowS
showsPrec :: Int -> ProgressHint -> ShowS
$cshow :: ProgressHint -> String
show :: ProgressHint -> String
$cshowList :: [ProgressHint] -> ShowS
showList :: [ProgressHint] -> ShowS
Show, ProgressHint -> ProgressHint -> Bool
(ProgressHint -> ProgressHint -> Bool)
-> (ProgressHint -> ProgressHint -> Bool) -> Eq ProgressHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProgressHint -> ProgressHint -> Bool
== :: ProgressHint -> ProgressHint -> Bool
$c/= :: ProgressHint -> ProgressHint -> Bool
/= :: ProgressHint -> ProgressHint -> Bool
Eq)

instance P.Enum ProgressHint where
    fromEnum :: ProgressHint -> Int
fromEnum ProgressHint
ProgressHintInactive = Int
0
    fromEnum ProgressHint
ProgressHintActive = Int
1
    fromEnum ProgressHint
ProgressHintError = Int
2
    fromEnum ProgressHint
ProgressHintIndeterminate = Int
3
    fromEnum ProgressHint
ProgressHintPaused = Int
4
    fromEnum (AnotherProgressHint Int
k) = Int
k

    toEnum :: Int -> ProgressHint
toEnum Int
0 = ProgressHint
ProgressHintInactive
    toEnum Int
1 = ProgressHint
ProgressHintActive
    toEnum Int
2 = ProgressHint
ProgressHintError
    toEnum Int
3 = ProgressHint
ProgressHintIndeterminate
    toEnum Int
4 = ProgressHint
ProgressHintPaused
    toEnum Int
k = Int -> ProgressHint
AnotherProgressHint Int
k

instance P.Ord ProgressHint where
    compare :: ProgressHint -> ProgressHint -> Ordering
compare ProgressHint
a ProgressHint
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ProgressHint -> Int
forall a. Enum a => a -> Int
P.fromEnum ProgressHint
a) (ProgressHint -> Int
forall a. Enum a => a -> Int
P.fromEnum ProgressHint
b)

type instance O.ParentTypes ProgressHint = '[]
instance O.HasParentTypes ProgressHint

foreign import ccall "vte_progress_hint_get_type" c_vte_progress_hint_get_type :: 
    IO GType

instance B.Types.TypedObject ProgressHint where
    glibType :: IO GType
glibType = IO GType
c_vte_progress_hint_get_type

instance B.Types.BoxedEnum ProgressHint

-- 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
$cshowsPrec :: Int -> Format -> ShowS
showsPrec :: Int -> Format -> ShowS
$cshow :: Format -> String
show :: Format -> String
$cshowList :: [Format] -> ShowS
showList :: [Format] -> ShowS
Show, Format -> Format -> Bool
(Format -> Format -> Bool)
-> (Format -> Format -> Bool) -> Eq Format
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Format -> Format -> Bool
== :: Format -> Format -> Bool
$c/= :: Format -> Format -> Bool
/= :: 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
$cshowsPrec :: Int -> EraseBinding -> ShowS
showsPrec :: Int -> EraseBinding -> ShowS
$cshow :: EraseBinding -> String
show :: EraseBinding -> String
$cshowList :: [EraseBinding] -> ShowS
showList :: [EraseBinding] -> ShowS
Show, EraseBinding -> EraseBinding -> Bool
(EraseBinding -> EraseBinding -> Bool)
-> (EraseBinding -> EraseBinding -> Bool) -> Eq EraseBinding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EraseBinding -> EraseBinding -> Bool
== :: EraseBinding -> EraseBinding -> Bool
$c/= :: EraseBinding -> EraseBinding -> Bool
/= :: 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
$cshowsPrec :: Int -> CursorShape -> ShowS
showsPrec :: Int -> CursorShape -> ShowS
$cshow :: CursorShape -> String
show :: CursorShape -> String
$cshowList :: [CursorShape] -> ShowS
showList :: [CursorShape] -> ShowS
Show, CursorShape -> CursorShape -> Bool
(CursorShape -> CursorShape -> Bool)
-> (CursorShape -> CursorShape -> Bool) -> Eq CursorShape
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CursorShape -> CursorShape -> Bool
== :: CursorShape -> CursorShape -> Bool
$c/= :: CursorShape -> CursorShape -> Bool
/= :: 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
$cshowsPrec :: Int -> CursorBlinkMode -> ShowS
showsPrec :: Int -> CursorBlinkMode -> ShowS
$cshow :: CursorBlinkMode -> String
show :: CursorBlinkMode -> String
$cshowList :: [CursorBlinkMode] -> ShowS
showList :: [CursorBlinkMode] -> ShowS
Show, CursorBlinkMode -> CursorBlinkMode -> Bool
(CursorBlinkMode -> CursorBlinkMode -> Bool)
-> (CursorBlinkMode -> CursorBlinkMode -> Bool)
-> Eq CursorBlinkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CursorBlinkMode -> CursorBlinkMode -> Bool
== :: CursorBlinkMode -> CursorBlinkMode -> Bool
$c/= :: CursorBlinkMode -> CursorBlinkMode -> Bool
/= :: 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

-- Enum Align
-- | An enumeration type that can be used to specify how the terminal
-- uses extra allocated space.
-- 
-- /Since: 0.76/
data Align = 
      AlignStart
    -- ^ align to left\/top
    | AlignCenter
    -- ^ align to centre
    | AlignEnd
    -- ^ align to right\/bottom
    | AnotherAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Align -> ShowS
[Align] -> ShowS
Align -> String
(Int -> Align -> ShowS)
-> (Align -> String) -> ([Align] -> ShowS) -> Show Align
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Align -> ShowS
showsPrec :: Int -> Align -> ShowS
$cshow :: Align -> String
show :: Align -> String
$cshowList :: [Align] -> ShowS
showList :: [Align] -> ShowS
Show, Align -> Align -> Bool
(Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Align -> Align -> Bool
== :: Align -> Align -> Bool
$c/= :: Align -> Align -> Bool
/= :: Align -> Align -> Bool
Eq)

instance P.Enum Align where
    fromEnum :: Align -> Int
fromEnum Align
AlignStart = Int
0
    fromEnum Align
AlignCenter = Int
1
    fromEnum Align
AlignEnd = Int
2
    fromEnum (AnotherAlign Int
k) = Int
k

    toEnum :: Int -> Align
toEnum Int
0 = Align
AlignStart
    toEnum Int
1 = Align
AlignCenter
    toEnum Int
2 = Align
AlignEnd
    toEnum Int
k = Int -> Align
AnotherAlign Int
k

instance P.Ord Align where
    compare :: Align -> Align -> Ordering
compare Align
a Align
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
a) (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
b)

type instance O.ParentTypes Align = '[]
instance O.HasParentTypes Align

foreign import ccall "vte_align_get_type" c_vte_align_get_type :: 
    IO GType

instance B.Types.TypedObject Align where
    glibType :: IO GType
glibType = IO GType
c_vte_align_get_type

instance B.Types.BoxedEnum Align