gi-vte 2.91.19 → 2.91.21

raw patch · 23 files changed

+13674/−9 lines, 23 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/Vte.hs +58/−0
• GI/Vte/Callbacks.hs +289/−0
• GI/Vte/Constants.hs +84/−0
• GI/Vte/Enums.hs +452/−0
• GI/Vte/Enums.hs-boot +48/−0
• GI/Vte/Flags.hs +107/−0
• GI/Vte/Flags.hs-boot +28/−0
• GI/Vte/Functions.hs +200/−0
• GI/Vte/Objects.hs +43/−0
• GI/Vte/Objects/Pty.hs +729/−0
• GI/Vte/Objects/Pty.hs-boot +59/−0
• GI/Vte/Objects/Terminal.hs +10445/−0
• GI/Vte/Objects/Terminal.hs-boot +527/−0
• GI/Vte/Structs.hs +43/−0
• GI/Vte/Structs/CharAttributes.hs +88/−0
• GI/Vte/Structs/CharAttributes.hs-boot +26/−0
• GI/Vte/Structs/Regex.hs +366/−0
• GI/Vte/Structs/Regex.hs-boot +38/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-vte.cabal +20/−7
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 2.91.21+++ Update to haskell-gi(-base) 0.22++### 2.91.20+++ Update stack version to 12.10+ ### 2.91.19  + Properly annotate the return value of [terminalGetWindowTitle](https://hackage.haskell.org/package/gi-vte-2.91.19/docs/GI-Vte-Objects-Terminal.html#v:terminalGetWindowTitle) as nullable.

@@ -0,0 +1,58 @@+++{- |+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+    (     module GI.Vte.Callbacks                 ,+    module GI.Vte.Constants                 ,+    module GI.Vte.Enums                     ,+    module GI.Vte.Flags                     ,+    module GI.Vte.Functions                 ,+    module GI.Vte.Objects                   ,+    module GI.Vte.Structs                   ,++++    module Data.GI.Base                     ,+++    ) where++import GI.Vte.Callbacks+import GI.Vte.Constants+import GI.Vte.Enums+import GI.Vte.Flags+import GI.Vte.Functions+import GI.Vte.Objects+import GI.Vte.Structs++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+++import Data.GI.Base+

@@ -0,0 +1,289 @@+++{- |+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.Callbacks+    ( ++ -- * Signals+-- ** SelectionFunc #signal:SelectionFunc#++    C_SelectionFunc                         ,+    SelectionFunc                           ,+    SelectionFunc_WithClosures              ,+    drop_closures_SelectionFunc             ,+    dynamic_SelectionFunc                   ,+    genClosure_SelectionFunc                ,+    mk_SelectionFunc                        ,+    noSelectionFunc                         ,+    noSelectionFunc_WithClosures            ,+    wrap_SelectionFunc                      ,+++-- ** TerminalSpawnAsyncCallback #signal:TerminalSpawnAsyncCallback#++    C_TerminalSpawnAsyncCallback            ,+    TerminalSpawnAsyncCallback              ,+    TerminalSpawnAsyncCallback_WithClosures ,+    drop_closures_TerminalSpawnAsyncCallback,+    dynamic_TerminalSpawnAsyncCallback      ,+    genClosure_TerminalSpawnAsyncCallback   ,+    mk_TerminalSpawnAsyncCallback           ,+    noTerminalSpawnAsyncCallback            ,+    noTerminalSpawnAsyncCallback_WithClosures,+    wrap_TerminalSpawnAsyncCallback         ,+++++    ) 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++import {-# SOURCE #-} qualified GI.Vte.Objects.Terminal as Vte.Terminal++-- callback TerminalSpawnAsyncCallback+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pid", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data that was passed to vte_terminal_spawn_async", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Callback for vte_terminal_spawn_async().\n\nOn success, @pid contains the PID of the spawned process, and @error\nis %NULL.\nOn failure, @pid is -1 and @error contains the error information.", sinceVersion = Just "0.48"}}+-- | Type for the callback on the (unwrapped) C side.+type C_TerminalSpawnAsyncCallback =+    Ptr Vte.Terminal.Terminal ->+    Int32 ->+    Ptr GError ->+    Ptr () ->+    IO ()++-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pid", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data that was passed to vte_terminal_spawn_async", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_TerminalSpawnAsyncCallback :: FunPtr C_TerminalSpawnAsyncCallback -> C_TerminalSpawnAsyncCallback++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_TerminalSpawnAsyncCallback ::+    (B.CallStack.HasCallStack, MonadIO m, Vte.Terminal.IsTerminal a) =>+    FunPtr C_TerminalSpawnAsyncCallback+    -> a+    {- ^ /@terminal@/: the 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@pid@/: a @/GPid/@ -}+    -> GError+    {- ^ /@error@/: a 'GError', or 'Nothing' -}+    -> Ptr ()+    {- ^ /@userData@/: user data that was passed to vte_terminal_spawn_async -}+    -> m ()+dynamic_TerminalSpawnAsyncCallback __funPtr terminal pid error_ userData = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    error_' <- unsafeManagedPtrGetPtr error_+    (__dynamic_C_TerminalSpawnAsyncCallback __funPtr) terminal' pid error_' userData+    touchManagedPtr terminal+    touchManagedPtr error_+    return ()++-- | Generate a function pointer callable from C code, from a `C_TerminalSpawnAsyncCallback`.+foreign import ccall "wrapper"+    mk_TerminalSpawnAsyncCallback :: C_TerminalSpawnAsyncCallback -> IO (FunPtr C_TerminalSpawnAsyncCallback)++{- |+Callback for @/vte_terminal_spawn_async()/@.++On success, /@pid@/ contains the PID of the spawned process, and /@error@/+is 'Nothing'.+On failure, /@pid@/ is -1 and /@error@/ contains the error information.++/Since: 0.48/+-}+type TerminalSpawnAsyncCallback =+    Vte.Terminal.Terminal+    {- ^ /@terminal@/: the 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@pid@/: a @/GPid/@ -}+    -> GError+    {- ^ /@error@/: a 'GError', or 'Nothing' -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalSpawnAsyncCallback`@.+noTerminalSpawnAsyncCallback :: Maybe TerminalSpawnAsyncCallback+noTerminalSpawnAsyncCallback = Nothing++{- |+Callback for @/vte_terminal_spawn_async()/@.++On success, /@pid@/ contains the PID of the spawned process, and /@error@/+is 'Nothing'.+On failure, /@pid@/ is -1 and /@error@/ contains the error information.++/Since: 0.48/+-}+type TerminalSpawnAsyncCallback_WithClosures =+    Vte.Terminal.Terminal+    {- ^ /@terminal@/: the 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@pid@/: a @/GPid/@ -}+    -> GError+    {- ^ /@error@/: a 'GError', or 'Nothing' -}+    -> Ptr ()+    {- ^ /@userData@/: user data that was passed to vte_terminal_spawn_async -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalSpawnAsyncCallback_WithClosures`@.+noTerminalSpawnAsyncCallback_WithClosures :: Maybe TerminalSpawnAsyncCallback_WithClosures+noTerminalSpawnAsyncCallback_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_TerminalSpawnAsyncCallback :: TerminalSpawnAsyncCallback -> TerminalSpawnAsyncCallback_WithClosures+drop_closures_TerminalSpawnAsyncCallback _f terminal pid error_ _ = _f terminal pid error_++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalSpawnAsyncCallback :: MonadIO m => TerminalSpawnAsyncCallback -> m (GClosure C_TerminalSpawnAsyncCallback)+genClosure_TerminalSpawnAsyncCallback cb = liftIO $ do+    let cb' = drop_closures_TerminalSpawnAsyncCallback cb+    let cb'' = wrap_TerminalSpawnAsyncCallback Nothing cb'+    mk_TerminalSpawnAsyncCallback cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalSpawnAsyncCallback` into a `C_TerminalSpawnAsyncCallback`.+wrap_TerminalSpawnAsyncCallback ::+    Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback)) ->+    TerminalSpawnAsyncCallback_WithClosures ->+    C_TerminalSpawnAsyncCallback+wrap_TerminalSpawnAsyncCallback funptrptr _cb terminal pid error_ userData = do+    terminal' <- (newObject Vte.Terminal.Terminal) terminal+    error_' <- (newBoxed GError) error_+    _cb  terminal' pid error_' userData+    maybeReleaseFunPtr funptrptr+++-- callback SelectionFunc+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if cell has to be selected; %FALSE if otherwise.", sinceVersion = Nothing}, args = [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "terminal in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "column in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "row in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Specifies the type of a selection function used to check whether\na cell has to be selected or not.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_SelectionFunc =+    Ptr Vte.Terminal.Terminal ->+    CLong ->+    CLong ->+    Ptr () ->+    IO CInt++-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "terminal in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "column in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "row in which the cell is.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_SelectionFunc :: FunPtr C_SelectionFunc -> C_SelectionFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_SelectionFunc ::+    (B.CallStack.HasCallStack, MonadIO m, Vte.Terminal.IsTerminal a) =>+    FunPtr C_SelectionFunc+    -> a+    {- ^ /@terminal@/: terminal in which the cell is. -}+    -> CLong+    {- ^ /@column@/: column in which the cell is. -}+    -> CLong+    {- ^ /@row@/: row in which the cell is. -}+    -> Ptr ()+    {- ^ /@data@/: user data. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if cell has to be selected; 'False' if otherwise. -}+dynamic_SelectionFunc __funPtr terminal column row data_ = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- (__dynamic_C_SelectionFunc __funPtr) terminal' column row data_+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++-- | Generate a function pointer callable from C code, from a `C_SelectionFunc`.+foreign import ccall "wrapper"+    mk_SelectionFunc :: C_SelectionFunc -> IO (FunPtr C_SelectionFunc)++{- |+Specifies the type of a selection function used to check whether+a cell has to be selected or not.+-}+type SelectionFunc =+    Vte.Terminal.Terminal+    {- ^ /@terminal@/: terminal in which the cell is. -}+    -> CLong+    {- ^ /@column@/: column in which the cell is. -}+    -> CLong+    {- ^ /@row@/: row in which the cell is. -}+    -> IO Bool+    {- ^ __Returns:__ 'True' if cell has to be selected; 'False' if otherwise. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `SelectionFunc`@.+noSelectionFunc :: Maybe SelectionFunc+noSelectionFunc = Nothing++{- |+Specifies the type of a selection function used to check whether+a cell has to be selected or not.+-}+type SelectionFunc_WithClosures =+    Vte.Terminal.Terminal+    {- ^ /@terminal@/: terminal in which the cell is. -}+    -> CLong+    {- ^ /@column@/: column in which the cell is. -}+    -> CLong+    {- ^ /@row@/: row in which the cell is. -}+    -> Ptr ()+    {- ^ /@data@/: user data. -}+    -> IO Bool+    {- ^ __Returns:__ 'True' if cell has to be selected; 'False' if otherwise. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `SelectionFunc_WithClosures`@.+noSelectionFunc_WithClosures :: Maybe SelectionFunc_WithClosures+noSelectionFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_SelectionFunc :: SelectionFunc -> SelectionFunc_WithClosures+drop_closures_SelectionFunc _f terminal column row _ = _f terminal column row++-- | Wrap the callback into a `GClosure`.+genClosure_SelectionFunc :: MonadIO m => SelectionFunc -> m (GClosure C_SelectionFunc)+genClosure_SelectionFunc cb = liftIO $ do+    let cb' = drop_closures_SelectionFunc cb+    let cb'' = wrap_SelectionFunc Nothing cb'+    mk_SelectionFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `SelectionFunc` into a `C_SelectionFunc`.+wrap_SelectionFunc ::+    Maybe (Ptr (FunPtr C_SelectionFunc)) ->+    SelectionFunc_WithClosures ->+    C_SelectionFunc+wrap_SelectionFunc funptrptr _cb terminal column row data_ = do+    terminal' <- (newObject Vte.Terminal.Terminal) terminal+    result <- _cb  terminal' column row data_+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++

@@ -0,0 +1,84 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+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.Constants+    ( +    pattern TEST_FLAGS_NONE                 ,+    pattern TEST_FLAGS_ALL                  ,+    pattern SPAWN_NO_PARENT_ENVV            ,+    pattern REGEX_FLAGS_DEFAULT             ,+    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,++    ) 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+++{- |+/No description available in the introspection data./+-}+pattern TEST_FLAGS_NONE = 0 :: Word64++{- |+/No description available in the introspection data./+-}+pattern TEST_FLAGS_ALL = 18446744073709551615 :: Word64++{- |+/No description available in the introspection data./+-}+pattern SPAWN_NO_PARENT_ENVV = 33554432 :: Int32++{- |+/No description available in the introspection data./+-}+pattern REGEX_FLAGS_DEFAULT = 1075314688 :: Int32++{- |+The minor version number of the VTE library+(e.g. in version 3.1.4 this is 1).+-}+pattern MINOR_VERSION = 56 :: Int32++{- |+The micro version number of the VTE library+(e.g. in version 3.1.4 this is 4).+-}+pattern MICRO_VERSION = 3 :: Int32++{- |+The major version number of the VTE library+(e.g. in version 3.1.4 this is 3).+-}+pattern MAJOR_VERSION = 0 :: Int32++

@@ -0,0 +1,452 @@+++{- |+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++

@@ -0,0 +1,48 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Vte.Enums 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++data WriteFlags+instance P.Enum WriteFlags where+instance BoxedEnum WriteFlags where+data TextBlinkMode+instance P.Enum TextBlinkMode where+instance BoxedEnum TextBlinkMode where+data RegexError+instance P.Enum RegexError where+instance BoxedEnum RegexError where+data PtyError+instance P.Enum PtyError where+instance BoxedEnum PtyError where+data Format+instance P.Enum Format where+instance BoxedEnum Format where+data EraseBinding+instance P.Enum EraseBinding where+instance BoxedEnum EraseBinding where+data CursorShape+instance P.Enum CursorShape where+instance BoxedEnum CursorShape where+data CursorBlinkMode+instance P.Enum CursorBlinkMode where+instance BoxedEnum CursorBlinkMode where

@@ -0,0 +1,107 @@+++{- |+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.Flags+    ( ++ -- * Flags+-- ** PtyFlags #flag:PtyFlags#++    PtyFlags(..)                            ,+++++    ) 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+++-- Flags PtyFlags+{- |+/No description available in the introspection data./+-}+data PtyFlags = +      PtyFlagsNoLastlog+    {- ^+    Unused. Deprecated: 0.38+    -}+    | PtyFlagsNoUtmp+    {- ^+    Unused. Deprecated: 0.38+    -}+    | PtyFlagsNoWtmp+    {- ^+    Unused. Deprecated: 0.38+    -}+    | PtyFlagsNoHelper+    {- ^+    Unused. Deprecated: 0.38+    -}+    | PtyFlagsNoFallback+    {- ^+    Unused. Deprecated: 0.38+    -}+    | PtyFlagsDefault+    {- ^+    the default flags+    -}+    | AnotherPtyFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum PtyFlags where+    fromEnum PtyFlagsNoLastlog = 1+    fromEnum PtyFlagsNoUtmp = 2+    fromEnum PtyFlagsNoWtmp = 4+    fromEnum PtyFlagsNoHelper = 8+    fromEnum PtyFlagsNoFallback = 16+    fromEnum PtyFlagsDefault = 0+    fromEnum (AnotherPtyFlags k) = k++    toEnum 1 = PtyFlagsNoLastlog+    toEnum 2 = PtyFlagsNoUtmp+    toEnum 4 = PtyFlagsNoWtmp+    toEnum 8 = PtyFlagsNoHelper+    toEnum 16 = PtyFlagsNoFallback+    toEnum 0 = PtyFlagsDefault+    toEnum k = AnotherPtyFlags k++instance P.Ord PtyFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "vte_pty_flags_get_type" c_vte_pty_flags_get_type :: +    IO GType++instance BoxedFlags PtyFlags where+    boxedFlagsType _ = c_vte_pty_flags_get_type++instance IsGFlag PtyFlags++

@@ -0,0 +1,28 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Vte.Flags 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++data PtyFlags+instance P.Enum PtyFlags where+instance BoxedFlags PtyFlags where+instance IsGFlag PtyFlags

@@ -0,0 +1,200 @@+++{- |+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.Functions+    ( ++ -- * Methods+-- ** getFeatures #method:getFeatures#++    getFeatures                             ,+++-- ** getMajorVersion #method:getMajorVersion#++    getMajorVersion                         ,+++-- ** getMicroVersion #method:getMicroVersion#++    getMicroVersion                         ,+++-- ** getMinorVersion #method:getMinorVersion#++    getMinorVersion                         ,+++-- ** getUserShell #method:getUserShell#++    getUserShell                            ,+++++    ) 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+++-- function vte_get_user_shell+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TFileName)+-- throws : False+-- Skip return : False++foreign import ccall "vte_get_user_shell" vte_get_user_shell :: +    IO CString++{- |+Gets the user\'s shell, or 'Nothing'. In the latter case, the+system default (usually \"\/bin\/sh\") should be used.+-}+getUserShell ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [Char]+    {- ^ __Returns:__ a newly allocated string with the+  user\'s shell, or 'Nothing' -}+getUserShell  = liftIO $ do+    result <- vte_get_user_shell+    checkUnexpectedReturnNULL "getUserShell" result+    result' <- cstringToString result+    freeMem result+    return result'+++-- function vte_get_minor_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_get_minor_version" vte_get_minor_version :: +    IO Word32++{- |+Returns the minor version of the VTE library at runtime.+Contrast this with 'GI.Vte.Constants.MINOR_VERSION' which represents+the version of the VTE library that the code was compiled+with.++/Since: 0.40/+-}+getMinorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the minor version -}+getMinorVersion  = liftIO $ do+    result <- vte_get_minor_version+    return result+++-- function vte_get_micro_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_get_micro_version" vte_get_micro_version :: +    IO Word32++{- |+Returns the micro version of the VTE library at runtime.+Contrast this with 'GI.Vte.Constants.MICRO_VERSION' which represents+the version of the VTE library that the code was compiled+with.++/Since: 0.40/+-}+getMicroVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the micro version -}+getMicroVersion  = liftIO $ do+    result <- vte_get_micro_version+    return result+++-- function vte_get_major_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_get_major_version" vte_get_major_version :: +    IO Word32++{- |+Returns the major version of the VTE library at runtime.+Contrast this with 'GI.Vte.Constants.MAJOR_VERSION' which represents+the version of the VTE library that the code was compiled+with.++/Since: 0.40/+-}+getMajorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the major version -}+getMajorVersion  = liftIO $ do+    result <- vte_get_major_version+    return result+++-- function vte_get_features+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_get_features" vte_get_features :: +    IO CString++{- |+Gets a list of features vte was compiled with.++/Since: 0.40/+-}+getFeatures ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m T.Text+    {- ^ __Returns:__ a string with features -}+getFeatures  = liftIO $ do+    result <- vte_get_features+    checkUnexpectedReturnNULL "getFeatures" result+    result' <- cstringToText result+    return result'+++

@@ -0,0 +1,43 @@+++{- |+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.Objects+    (     module GI.Vte.Objects.Pty               ,+    module GI.Vte.Objects.Terminal          ,+++    ) where++import GI.Vte.Objects.Pty+import GI.Vte.Objects.Terminal++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+++

@@ -0,0 +1,729 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Vte.Objects.Pty+    ( +#if ENABLE_OVERLOADING+    PtySpawnAsyncMethodInfo                 ,+#endif++-- * Exported types+    Pty(..)                                 ,+    IsPty                                   ,+    toPty                                   ,+    noPty                                   ,+++ -- * Methods+-- ** childSetup #method:childSetup#++#if ENABLE_OVERLOADING+    PtyChildSetupMethodInfo                 ,+#endif+    ptyChildSetup                           ,+++-- ** close #method:close#++#if ENABLE_OVERLOADING+    PtyCloseMethodInfo                      ,+#endif+    ptyClose                                ,+++-- ** getFd #method:getFd#++#if ENABLE_OVERLOADING+    PtyGetFdMethodInfo                      ,+#endif+    ptyGetFd                                ,+++-- ** getSize #method:getSize#++#if ENABLE_OVERLOADING+    PtyGetSizeMethodInfo                    ,+#endif+    ptyGetSize                              ,+++-- ** newForeignSync #method:newForeignSync#++    ptyNewForeignSync                       ,+++-- ** newSync #method:newSync#++    ptyNewSync                              ,+++-- ** setSize #method:setSize#++#if ENABLE_OVERLOADING+    PtySetSizeMethodInfo                    ,+#endif+    ptySetSize                              ,+++-- ** setUtf8 #method:setUtf8#++#if ENABLE_OVERLOADING+    PtySetUtf8MethodInfo                    ,+#endif+    ptySetUtf8                              ,+++-- ** spawnFinish #method:spawnFinish#++#if ENABLE_OVERLOADING+    PtySpawnFinishMethodInfo                ,+#endif+    ptySpawnFinish                          ,+++++ -- * Properties+-- ** fd #attr:fd#+{- | The file descriptor of the PTY master.+-}+#if ENABLE_OVERLOADING+    PtyFdPropertyInfo                       ,+#endif+    constructPtyFd                          ,+    getPtyFd                                ,+#if ENABLE_OVERLOADING+    ptyFd                                   ,+#endif+++-- ** flags #attr:flags#+{- | Flags.+-}+#if ENABLE_OVERLOADING+    PtyFlagsPropertyInfo                    ,+#endif+    constructPtyFlags                       ,+    getPtyFlags                             ,+#if ENABLE_OVERLOADING+    ptyFlags                                ,+#endif+++++    ) 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++import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult+import qualified GI.Gio.Interfaces.Initable as Gio.Initable+import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable+import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags++-- | Memory-managed wrapper type.+newtype Pty = Pty (ManagedPtr Pty)+foreign import ccall "vte_pty_get_type"+    c_vte_pty_get_type :: IO GType++instance GObject Pty where+    gobjectType = c_vte_pty_get_type+    ++-- | Type class for types which can be safely cast to `Pty`, for instance with `toPty`.+class (GObject o, O.IsDescendantOf Pty o) => IsPty o+instance (GObject o, O.IsDescendantOf Pty o) => IsPty o++instance O.HasParentTypes Pty+type instance O.ParentTypes Pty = '[GObject.Object.Object, Gio.Initable.Initable]++-- | Cast to `Pty`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPty :: (MonadIO m, IsPty o) => o -> m Pty+toPty = liftIO . unsafeCastTo Pty++-- | A convenience alias for `Nothing` :: `Maybe` `Pty`.+noPty :: Maybe Pty+noPty = Nothing++#if ENABLE_OVERLOADING+type family ResolvePtyMethod (t :: Symbol) (o :: *) :: * where+    ResolvePtyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePtyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePtyMethod "childSetup" o = PtyChildSetupMethodInfo+    ResolvePtyMethod "close" o = PtyCloseMethodInfo+    ResolvePtyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePtyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePtyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePtyMethod "init" o = Gio.Initable.InitableInitMethodInfo+    ResolvePtyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePtyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePtyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePtyMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePtyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePtyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePtyMethod "spawnAsync" o = PtySpawnAsyncMethodInfo+    ResolvePtyMethod "spawnFinish" o = PtySpawnFinishMethodInfo+    ResolvePtyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePtyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePtyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePtyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePtyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePtyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePtyMethod "getFd" o = PtyGetFdMethodInfo+    ResolvePtyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePtyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePtyMethod "getSize" o = PtyGetSizeMethodInfo+    ResolvePtyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePtyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePtyMethod "setSize" o = PtySetSizeMethodInfo+    ResolvePtyMethod "setUtf8" o = PtySetUtf8MethodInfo+    ResolvePtyMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePtyMethod t Pty, O.MethodInfo info Pty p) => OL.IsLabel t (Pty -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "fd"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@fd@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pty #fd+@+-}+getPtyFd :: (MonadIO m, IsPty o) => o -> m Int32+getPtyFd obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "fd"++{- |+Construct a `GValueConstruct` with valid value for the “@fd@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPtyFd :: (IsPty o) => Int32 -> IO (GValueConstruct o)+constructPtyFd val = B.Properties.constructObjectPropertyInt32 "fd" val++#if ENABLE_OVERLOADING+data PtyFdPropertyInfo+instance AttrInfo PtyFdPropertyInfo where+    type AttrAllowedOps PtyFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PtyFdPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PtyFdPropertyInfo = IsPty+    type AttrGetType PtyFdPropertyInfo = Int32+    type AttrLabel PtyFdPropertyInfo = "fd"+    type AttrOrigin PtyFdPropertyInfo = Pty+    attrGet _ = getPtyFd+    attrSet _ = undefined+    attrConstruct _ = constructPtyFd+    attrClear _ = undefined+#endif++-- VVV Prop "flags"+   -- Type: TInterface (Name {namespace = "Vte", name = "PtyFlags"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@flags@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pty #flags+@+-}+getPtyFlags :: (MonadIO m, IsPty o) => o -> m [Vte.Flags.PtyFlags]+getPtyFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags"++{- |+Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPtyFlags :: (IsPty o) => [Vte.Flags.PtyFlags] -> IO (GValueConstruct o)+constructPtyFlags val = B.Properties.constructObjectPropertyFlags "flags" val++#if ENABLE_OVERLOADING+data PtyFlagsPropertyInfo+instance AttrInfo PtyFlagsPropertyInfo where+    type AttrAllowedOps PtyFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PtyFlagsPropertyInfo = (~) [Vte.Flags.PtyFlags]+    type AttrBaseTypeConstraint PtyFlagsPropertyInfo = IsPty+    type AttrGetType PtyFlagsPropertyInfo = [Vte.Flags.PtyFlags]+    type AttrLabel PtyFlagsPropertyInfo = "flags"+    type AttrOrigin PtyFlagsPropertyInfo = Pty+    attrGet _ = getPtyFlags+    attrSet _ = undefined+    attrConstruct _ = constructPtyFlags+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Pty+type instance O.AttributeList Pty = PtyAttributeList+type PtyAttributeList = ('[ '("fd", PtyFdPropertyInfo), '("flags", PtyFlagsPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+ptyFd :: AttrLabelProxy "fd"+ptyFd = AttrLabelProxy++ptyFlags :: AttrLabelProxy "flags"+ptyFlags = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Pty = PtySignalList+type PtySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Pty::new_foreign_sync+-- method type : Constructor+-- Args : [Arg {argCName = "fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file descriptor to the PTY", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Pty"}))+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_new_foreign_sync" vte_pty_new_foreign_sync :: +    Int32 ->                                -- fd : TBasicType TInt+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pty)++{- |+Creates a new 'GI.Vte.Objects.Pty.Pty' for the PTY master /@fd@/.++No entry will be made in the lastlog, utmp or wtmp system files.++Note that the newly created 'GI.Vte.Objects.Pty.Pty' will take ownership of /@fd@/+and close it on finalize.+-}+ptyNewForeignSync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>+    Int32+    {- ^ /@fd@/: a file descriptor to the PTY -}+    -> Maybe (a)+    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}+    -> m Pty+    {- ^ __Returns:__ a new 'GI.Vte.Objects.Pty.Pty' for /@fd@/, or 'Nothing' on error with /@error@/ filled in /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptyNewForeignSync fd cancellable = liftIO $ do+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ vte_pty_new_foreign_sync fd maybeCancellable+        checkUnexpectedReturnNULL "ptyNewForeignSync" result+        result' <- (wrapObject Pty) result+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method Pty::new_sync+-- method type : Constructor+-- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "Vte", name = "PtyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #VtePtyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Pty"}))+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_new_sync" vte_pty_new_sync :: +    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pty)++{- |+Allocates a new pseudo-terminal.++You can later use @/fork()/@ or the 'GI.GLib.Functions.spawnAsync' family of functions+to start a process on the PTY.++If using @/fork()/@, you MUST call 'GI.Vte.Objects.Pty.ptyChildSetup' in the child.++If using 'GI.GLib.Functions.spawnAsync' and friends, you MUST either use+'GI.Vte.Objects.Pty.ptyChildSetup' directly as the child setup function, or call+'GI.Vte.Objects.Pty.ptyChildSetup' from your own child setup function supplied.++When using 'GI.Vte.Objects.Terminal.terminalSpawnSync' with a custom child setup+function, 'GI.Vte.Objects.Pty.ptyChildSetup' will be called before the supplied+function; you must not call it again.++Also, you MUST pass the 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' flag.+-}+ptyNewSync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>+    [Vte.Flags.PtyFlags]+    {- ^ /@flags@/: flags from 'GI.Vte.Flags.PtyFlags' -}+    -> Maybe (a)+    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}+    -> m Pty+    {- ^ __Returns:__ a new 'GI.Vte.Objects.Pty.Pty', or 'Nothing' on error with /@error@/ filled in /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptyNewSync flags cancellable = liftIO $ do+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ vte_pty_new_sync flags' maybeCancellable+        checkUnexpectedReturnNULL "ptyNewSync" result+        result' <- (wrapObject Pty) result+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method Pty::child_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_pty_child_setup" vte_pty_child_setup :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    IO ()++{- |+FIXMEchpe+-}+ptyChildSetup ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> m ()+ptyChildSetup pty = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    vte_pty_child_setup pty'+    touchManagedPtr pty+    return ()++#if ENABLE_OVERLOADING+data PtyChildSetupMethodInfo+instance (signature ~ (m ()), MonadIO m, IsPty a) => O.MethodInfo PtyChildSetupMethodInfo a signature where+    overloadedMethod _ = ptyChildSetup++#endif++-- method Pty::close+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_pty_close" vte_pty_close :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    IO ()++{-# DEPRECATED ptyClose ["(Since version 0.42)"] #-}+{- |+Since 0.42 this is a no-op.+-}+ptyClose ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> m ()+ptyClose pty = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    vte_pty_close pty'+    touchManagedPtr pty+    return ()++#if ENABLE_OVERLOADING+data PtyCloseMethodInfo+instance (signature ~ (m ()), MonadIO m, IsPty a) => O.MethodInfo PtyCloseMethodInfo a signature where+    overloadedMethod _ = ptyClose++#endif++-- method Pty::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_pty_get_fd" vte_pty_get_fd :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    IO Int32++{- |+/No description available in the introspection data./+-}+ptyGetFd ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> m Int32+    {- ^ __Returns:__ the file descriptor of the PTY master in /@pty@/. The+  file descriptor belongs to /@pty@/ and must not be closed -}+ptyGetFd pty = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    result <- vte_pty_get_fd pty'+    touchManagedPtr pty+    return result++#if ENABLE_OVERLOADING+data PtyGetFdMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPty a) => O.MethodInfo PtyGetFdMethodInfo a signature where+    overloadedMethod _ = ptyGetFd++#endif++-- method Pty::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the number of rows, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "columns", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the number of columns, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_get_size" vte_pty_get_size :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    Ptr Int32 ->                            -- rows : TBasicType TInt+    Ptr Int32 ->                            -- columns : TBasicType TInt+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Reads the pseudo terminal\'s window size.++If getting the window size failed, /@error@/ will be set to a 'GI.GLib.Enums.IOError'.+-}+ptyGetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> m ((Int32, Int32))+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptyGetSize pty = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    rows <- allocMem :: IO (Ptr Int32)+    columns <- allocMem :: IO (Ptr Int32)+    onException (do+        _ <- propagateGError $ vte_pty_get_size pty' rows columns+        rows' <- peek rows+        columns' <- peek columns+        touchManagedPtr pty+        freeMem rows+        freeMem columns+        return (rows', columns')+     ) (do+        freeMem rows+        freeMem columns+     )++#if ENABLE_OVERLOADING+data PtyGetSizeMethodInfo+instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsPty a) => O.MethodInfo PtyGetSizeMethodInfo a signature where+    overloadedMethod _ = ptyGetSize++#endif++-- method Pty::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "columns", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of columns", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_set_size" vte_pty_set_size :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    Int32 ->                                -- rows : TBasicType TInt+    Int32 ->                                -- columns : TBasicType TInt+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Attempts to resize the pseudo terminal\'s window size.  If successful, the+OS kernel will send @/SIGWINCH/@ to the child process group.++If setting the window size failed, /@error@/ will be set to a 'GI.GLib.Enums.IOError'.+-}+ptySetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> Int32+    {- ^ /@rows@/: the desired number of rows -}+    -> Int32+    {- ^ /@columns@/: the desired number of columns -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptySetSize pty rows columns = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    onException (do+        _ <- propagateGError $ vte_pty_set_size pty' rows columns+        touchManagedPtr pty+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data PtySetSizeMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsPty a) => O.MethodInfo PtySetSizeMethodInfo a signature where+    overloadedMethod _ = ptySetSize++#endif++-- method Pty::set_utf8+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "utf8", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the pty is in UTF-8 mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_set_utf8" vte_pty_set_utf8 :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    CInt ->                                 -- utf8 : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Tells the kernel whether the terminal is UTF-8 or not, in case it can make+use of the info.  Linux 2.6.5 or so defines IUTF8 to make the line+discipline do multibyte backspace correctly.+-}+ptySetUtf8 ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> Bool+    {- ^ /@utf8@/: whether or not the pty is in UTF-8 mode -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptySetUtf8 pty utf8 = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    let utf8' = (fromIntegral . fromEnum) utf8+    onException (do+        _ <- propagateGError $ vte_pty_set_utf8 pty' utf8'+        touchManagedPtr pty+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data PtySetUtf8MethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsPty a) => O.MethodInfo PtySetUtf8MethodInfo a signature where+    overloadedMethod _ = ptySetUtf8++#endif++-- XXX Could not generate method Pty::spawn_async+-- Error was : Bad introspection data: "Closure not found! Callable\n  { returnType = Nothing\n  , returnMayBeNull = False\n  , returnTransfer = TransferNothing\n  , returnDocumentation =\n      Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n  , args =\n      [ Arg\n          { argCName = \"pty\"\n          , argType = TInterface Name { namespace = \"Vte\" , name = \"Pty\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"a #VtePty\" , sinceVersion = Nothing }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"working_directory\"\n          , argType = TBasicType TUTF8\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"the name of a directory the command should start\\n  in, or %NULL to use the current working directory\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"argv\"\n          , argType = TCArray True (-1) (-1) (TBasicType TFileName)\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"child's argument vector\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"envv\"\n          , argType = TCArray True (-1) (-1) (TBasicType TFileName)\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"a list of environment\\n  variables to be added to the environment before starting the process, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"spawn_flags\"\n          , argType =\n              TInterface Name { namespace = \"GLib\" , name = \"SpawnFlags\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"flags from #GSpawnFlags\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup\"\n          , argType =\n              TInterface\n                Name { namespace = \"GLib\" , name = \"SpawnChildSetupFunc\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"an extra child setup function to run in the child just before exec(), or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeNotified\n          , argClosure = 6\n          , argDestroy = 7\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup_data\"\n          , argType = TBasicType TPtr\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"user data for @child_setup, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeNotified\n          , argClosure = 5\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup_data_destroy\"\n          , argType =\n              TInterface Name { namespace = \"GLib\" , name = \"DestroyNotify\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just \"a #GDestroyNotify for @child_setup_data, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeAsync\n          , argClosure = -1\n          , argDestroy = 6\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"timeout\"\n          , argType = TBasicType TInt\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just \"a timeout value in ms, or -1 to wait indefinitely\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"cancellable\"\n          , argType =\n              TInterface Name { namespace = \"Gio\" , name = \"Cancellable\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"a #GCancellable, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"callback\"\n          , argType =\n              TInterface Name { namespace = \"Gio\" , name = \"AsyncReadyCallback\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n          , argScope = ScopeTypeAsync\n          , argClosure = 11\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"user_data\"\n          , argType = TBasicType TPtr\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      ]\n  , skipReturn = False\n  , callableThrows = False\n  , callableDeprecated = Nothing\n  , callableDocumentation =\n      Documentation\n        { rawDocText =\n            Just\n              \"Starts the specified command under the pseudo-terminal @pty.\\nThe @argv and @envv lists should be %NULL-terminated.\\nThe \\\"TERM\\\" environment variable is automatically set to a default value,\\nbut can be overridden from @envv.\\n@pty_flags controls logging the session to the specified system log files.\\n\\nNote that %G_SPAWN_DO_NOT_REAP_CHILD will always be added to @spawn_flags.\\n\\nNote that all open file descriptors will be closed in the child. If you want\\nto keep some file descriptor open for use in the child process, you need to\\nuse a child setup function that unsets the FD_CLOEXEC flag on that file\\ndescriptor.\\n\\nSee vte_pty_new(), g_spawn_async() and vte_terminal_watch_child() for more information.\"\n        , sinceVersion = Just \"0.48\"\n        }\n  }\nfromList\n  [ ( 6\n    , Arg\n        { argCName = \"child_setup\"\n        , argType =\n            TInterface\n              Name { namespace = \"GLib\" , name = \"SpawnChildSetupFunc\" }\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argDoc =\n            Documentation\n              { rawDocText =\n                  Just\n                    \"an extra child setup function to run in the child just before exec(), or %NULL\"\n              , sinceVersion = Nothing\n              }\n        , argScope = ScopeTypeNotified\n        , argClosure = 6\n        , argDestroy = 7\n        , argCallerAllocates = False\n        , transfer = TransferNothing\n        }\n    )\n  , ( 11\n    , Arg\n        { argCName = \"callback\"\n        , argType =\n            TInterface Name { namespace = \"Gio\" , name = \"AsyncReadyCallback\" }\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argDoc =\n            Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n        , argScope = ScopeTypeAsync\n        , argClosure = 11\n        , argDestroy = -1\n        , argCallerAllocates = False\n        , transfer = TransferNothing\n        }\n    )\n  ]\n5"+#if ENABLE_OVERLOADING+-- XXX: Dummy instance, since code generation failed.+-- Please file a bug at http://github.com/haskell-gi/haskell-gi.+data PtySpawnAsyncMethodInfo+instance (p ~ (), o ~ O.MethodResolutionFailed "spawnAsync" Pty) => O.MethodInfo PtySpawnAsyncMethodInfo o p where+    overloadedMethod _ = undefined+#endif++-- method Pty::spawn_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VtePty", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_pid", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the child PID, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_pty_spawn_finish" vte_pty_spawn_finish :: +    Ptr Pty ->                              -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})+    Ptr Int32 ->                            -- child_pid : TBasicType TInt+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+/No description available in the introspection data./++/Since: 0.48/+-}+ptySpawnFinish ::+    (B.CallStack.HasCallStack, MonadIO m, IsPty a, Gio.AsyncResult.IsAsyncResult b) =>+    a+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty' -}+    -> b+    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}+    -> m (Int32)+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+ptySpawnFinish pty result_ = liftIO $ do+    pty' <- unsafeManagedPtrCastPtr pty+    result_' <- unsafeManagedPtrCastPtr result_+    childPid <- allocMem :: IO (Ptr Int32)+    onException (do+        _ <- propagateGError $ vte_pty_spawn_finish pty' result_' childPid+        childPid' <- peek childPid+        touchManagedPtr pty+        touchManagedPtr result_+        freeMem childPid+        return childPid'+     ) (do+        freeMem childPid+     )++#if ENABLE_OVERLOADING+data PtySpawnFinishMethodInfo+instance (signature ~ (b -> m (Int32)), MonadIO m, IsPty a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo PtySpawnFinishMethodInfo a signature where+    overloadedMethod _ = ptySpawnFinish++#endif++

@@ -0,0 +1,59 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Vte.Objects.Pty 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++newtype Pty = Pty (ManagedPtr Pty)+instance GObject Pty where+class (GObject o, O.IsDescendantOf Pty o) => IsPty o+instance (GObject o, O.IsDescendantOf Pty o) => IsPty o+instance O.HasParentTypes Pty+#if ENABLE_OVERLOADING+data PtyFdPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PtyFlagsPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PtyChildSetupMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtyCloseMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtyGetFdMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtyGetSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtySetSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtySetUtf8MethodInfo+#endif+#if ENABLE_OVERLOADING+data PtySpawnAsyncMethodInfo+#endif+#if ENABLE_OVERLOADING+data PtySpawnFinishMethodInfo+#endif

@@ -0,0 +1,10445 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Vte.Objects.Terminal+    ( +#if ENABLE_OVERLOADING+    TerminalGetTextMethodInfo               ,+#endif+#if ENABLE_OVERLOADING+    TerminalGetTextIncludeTrailingSpacesMethodInfo,+#endif+#if ENABLE_OVERLOADING+    TerminalGetTextRangeMethodInfo          ,+#endif++-- * Exported types+    Terminal(..)                            ,+    IsTerminal                              ,+    toTerminal                              ,+    noTerminal                              ,+++ -- * Methods+-- ** copyClipboard #method:copyClipboard#++#if ENABLE_OVERLOADING+    TerminalCopyClipboardMethodInfo         ,+#endif+    terminalCopyClipboard                   ,+++-- ** copyClipboardFormat #method:copyClipboardFormat#++#if ENABLE_OVERLOADING+    TerminalCopyClipboardFormatMethodInfo   ,+#endif+    terminalCopyClipboardFormat             ,+++-- ** copyPrimary #method:copyPrimary#++#if ENABLE_OVERLOADING+    TerminalCopyPrimaryMethodInfo           ,+#endif+    terminalCopyPrimary                     ,+++-- ** feed #method:feed#++#if ENABLE_OVERLOADING+    TerminalFeedMethodInfo                  ,+#endif+    terminalFeed                            ,+++-- ** feedChild #method:feedChild#++#if ENABLE_OVERLOADING+    TerminalFeedChildMethodInfo             ,+#endif+    terminalFeedChild                       ,+++-- ** feedChildBinary #method:feedChildBinary#++#if ENABLE_OVERLOADING+    TerminalFeedChildBinaryMethodInfo       ,+#endif+    terminalFeedChildBinary                 ,+++-- ** getAllowBold #method:getAllowBold#++#if ENABLE_OVERLOADING+    TerminalGetAllowBoldMethodInfo          ,+#endif+    terminalGetAllowBold                    ,+++-- ** getAllowHyperlink #method:getAllowHyperlink#++#if ENABLE_OVERLOADING+    TerminalGetAllowHyperlinkMethodInfo     ,+#endif+    terminalGetAllowHyperlink               ,+++-- ** getAudibleBell #method:getAudibleBell#++#if ENABLE_OVERLOADING+    TerminalGetAudibleBellMethodInfo        ,+#endif+    terminalGetAudibleBell                  ,+++-- ** getBoldIsBright #method:getBoldIsBright#++#if ENABLE_OVERLOADING+    TerminalGetBoldIsBrightMethodInfo       ,+#endif+    terminalGetBoldIsBright                 ,+++-- ** getCellHeightScale #method:getCellHeightScale#++#if ENABLE_OVERLOADING+    TerminalGetCellHeightScaleMethodInfo    ,+#endif+    terminalGetCellHeightScale              ,+++-- ** getCellWidthScale #method:getCellWidthScale#++#if ENABLE_OVERLOADING+    TerminalGetCellWidthScaleMethodInfo     ,+#endif+    terminalGetCellWidthScale               ,+++-- ** getCharHeight #method:getCharHeight#++#if ENABLE_OVERLOADING+    TerminalGetCharHeightMethodInfo         ,+#endif+    terminalGetCharHeight                   ,+++-- ** getCharWidth #method:getCharWidth#++#if ENABLE_OVERLOADING+    TerminalGetCharWidthMethodInfo          ,+#endif+    terminalGetCharWidth                    ,+++-- ** getCjkAmbiguousWidth #method:getCjkAmbiguousWidth#++#if ENABLE_OVERLOADING+    TerminalGetCjkAmbiguousWidthMethodInfo  ,+#endif+    terminalGetCjkAmbiguousWidth            ,+++-- ** getColorBackgroundForDraw #method:getColorBackgroundForDraw#++#if ENABLE_OVERLOADING+    TerminalGetColorBackgroundForDrawMethodInfo,+#endif+    terminalGetColorBackgroundForDraw       ,+++-- ** getColumnCount #method:getColumnCount#++#if ENABLE_OVERLOADING+    TerminalGetColumnCountMethodInfo        ,+#endif+    terminalGetColumnCount                  ,+++-- ** getCurrentDirectoryUri #method:getCurrentDirectoryUri#++#if ENABLE_OVERLOADING+    TerminalGetCurrentDirectoryUriMethodInfo,+#endif+    terminalGetCurrentDirectoryUri          ,+++-- ** getCurrentFileUri #method:getCurrentFileUri#++#if ENABLE_OVERLOADING+    TerminalGetCurrentFileUriMethodInfo     ,+#endif+    terminalGetCurrentFileUri               ,+++-- ** getCursorBlinkMode #method:getCursorBlinkMode#++#if ENABLE_OVERLOADING+    TerminalGetCursorBlinkModeMethodInfo    ,+#endif+    terminalGetCursorBlinkMode              ,+++-- ** getCursorPosition #method:getCursorPosition#++#if ENABLE_OVERLOADING+    TerminalGetCursorPositionMethodInfo     ,+#endif+    terminalGetCursorPosition               ,+++-- ** getCursorShape #method:getCursorShape#++#if ENABLE_OVERLOADING+    TerminalGetCursorShapeMethodInfo        ,+#endif+    terminalGetCursorShape                  ,+++-- ** getEncoding #method:getEncoding#++#if ENABLE_OVERLOADING+    TerminalGetEncodingMethodInfo           ,+#endif+    terminalGetEncoding                     ,+++-- ** getFont #method:getFont#++#if ENABLE_OVERLOADING+    TerminalGetFontMethodInfo               ,+#endif+    terminalGetFont                         ,+++-- ** getFontScale #method:getFontScale#++#if ENABLE_OVERLOADING+    TerminalGetFontScaleMethodInfo          ,+#endif+    terminalGetFontScale                    ,+++-- ** getGeometryHints #method:getGeometryHints#++#if ENABLE_OVERLOADING+    TerminalGetGeometryHintsMethodInfo      ,+#endif+    terminalGetGeometryHints                ,+++-- ** getHasSelection #method:getHasSelection#++#if ENABLE_OVERLOADING+    TerminalGetHasSelectionMethodInfo       ,+#endif+    terminalGetHasSelection                 ,+++-- ** getIconTitle #method:getIconTitle#++#if ENABLE_OVERLOADING+    TerminalGetIconTitleMethodInfo          ,+#endif+    terminalGetIconTitle                    ,+++-- ** getInputEnabled #method:getInputEnabled#++#if ENABLE_OVERLOADING+    TerminalGetInputEnabledMethodInfo       ,+#endif+    terminalGetInputEnabled                 ,+++-- ** getMouseAutohide #method:getMouseAutohide#++#if ENABLE_OVERLOADING+    TerminalGetMouseAutohideMethodInfo      ,+#endif+    terminalGetMouseAutohide                ,+++-- ** getPty #method:getPty#++#if ENABLE_OVERLOADING+    TerminalGetPtyMethodInfo                ,+#endif+    terminalGetPty                          ,+++-- ** getRewrapOnResize #method:getRewrapOnResize#++#if ENABLE_OVERLOADING+    TerminalGetRewrapOnResizeMethodInfo     ,+#endif+    terminalGetRewrapOnResize               ,+++-- ** getRowCount #method:getRowCount#++#if ENABLE_OVERLOADING+    TerminalGetRowCountMethodInfo           ,+#endif+    terminalGetRowCount                     ,+++-- ** getScrollOnKeystroke #method:getScrollOnKeystroke#++#if ENABLE_OVERLOADING+    TerminalGetScrollOnKeystrokeMethodInfo  ,+#endif+    terminalGetScrollOnKeystroke            ,+++-- ** getScrollOnOutput #method:getScrollOnOutput#++#if ENABLE_OVERLOADING+    TerminalGetScrollOnOutputMethodInfo     ,+#endif+    terminalGetScrollOnOutput               ,+++-- ** getScrollbackLines #method:getScrollbackLines#++#if ENABLE_OVERLOADING+    TerminalGetScrollbackLinesMethodInfo    ,+#endif+    terminalGetScrollbackLines              ,+++-- ** getTextBlinkMode #method:getTextBlinkMode#++#if ENABLE_OVERLOADING+    TerminalGetTextBlinkModeMethodInfo      ,+#endif+    terminalGetTextBlinkMode                ,+++-- ** getWindowTitle #method:getWindowTitle#++#if ENABLE_OVERLOADING+    TerminalGetWindowTitleMethodInfo        ,+#endif+    terminalGetWindowTitle                  ,+++-- ** getWordCharExceptions #method:getWordCharExceptions#++#if ENABLE_OVERLOADING+    TerminalGetWordCharExceptionsMethodInfo ,+#endif+    terminalGetWordCharExceptions           ,+++-- ** hyperlinkCheckEvent #method:hyperlinkCheckEvent#++#if ENABLE_OVERLOADING+    TerminalHyperlinkCheckEventMethodInfo   ,+#endif+    terminalHyperlinkCheckEvent             ,+++-- ** matchAddGregex #method:matchAddGregex#++#if ENABLE_OVERLOADING+    TerminalMatchAddGregexMethodInfo        ,+#endif+    terminalMatchAddGregex                  ,+++-- ** matchAddRegex #method:matchAddRegex#++#if ENABLE_OVERLOADING+    TerminalMatchAddRegexMethodInfo         ,+#endif+    terminalMatchAddRegex                   ,+++-- ** matchCheck #method:matchCheck#++#if ENABLE_OVERLOADING+    TerminalMatchCheckMethodInfo            ,+#endif+    terminalMatchCheck                      ,+++-- ** matchCheckEvent #method:matchCheckEvent#++#if ENABLE_OVERLOADING+    TerminalMatchCheckEventMethodInfo       ,+#endif+    terminalMatchCheckEvent                 ,+++-- ** matchRemove #method:matchRemove#++#if ENABLE_OVERLOADING+    TerminalMatchRemoveMethodInfo           ,+#endif+    terminalMatchRemove                     ,+++-- ** matchRemoveAll #method:matchRemoveAll#++#if ENABLE_OVERLOADING+    TerminalMatchRemoveAllMethodInfo        ,+#endif+    terminalMatchRemoveAll                  ,+++-- ** matchSetCursor #method:matchSetCursor#++#if ENABLE_OVERLOADING+    TerminalMatchSetCursorMethodInfo        ,+#endif+    terminalMatchSetCursor                  ,+++-- ** matchSetCursorName #method:matchSetCursorName#++#if ENABLE_OVERLOADING+    TerminalMatchSetCursorNameMethodInfo    ,+#endif+    terminalMatchSetCursorName              ,+++-- ** matchSetCursorType #method:matchSetCursorType#++#if ENABLE_OVERLOADING+    TerminalMatchSetCursorTypeMethodInfo    ,+#endif+    terminalMatchSetCursorType              ,+++-- ** new #method:new#++    terminalNew                             ,+++-- ** pasteClipboard #method:pasteClipboard#++#if ENABLE_OVERLOADING+    TerminalPasteClipboardMethodInfo        ,+#endif+    terminalPasteClipboard                  ,+++-- ** pastePrimary #method:pastePrimary#++#if ENABLE_OVERLOADING+    TerminalPastePrimaryMethodInfo          ,+#endif+    terminalPastePrimary                    ,+++-- ** ptyNewSync #method:ptyNewSync#++#if ENABLE_OVERLOADING+    TerminalPtyNewSyncMethodInfo            ,+#endif+    terminalPtyNewSync                      ,+++-- ** reset #method:reset#++#if ENABLE_OVERLOADING+    TerminalResetMethodInfo                 ,+#endif+    terminalReset                           ,+++-- ** searchFindNext #method:searchFindNext#++#if ENABLE_OVERLOADING+    TerminalSearchFindNextMethodInfo        ,+#endif+    terminalSearchFindNext                  ,+++-- ** searchFindPrevious #method:searchFindPrevious#++#if ENABLE_OVERLOADING+    TerminalSearchFindPreviousMethodInfo    ,+#endif+    terminalSearchFindPrevious              ,+++-- ** searchGetGregex #method:searchGetGregex#++#if ENABLE_OVERLOADING+    TerminalSearchGetGregexMethodInfo       ,+#endif+    terminalSearchGetGregex                 ,+++-- ** searchGetRegex #method:searchGetRegex#++#if ENABLE_OVERLOADING+    TerminalSearchGetRegexMethodInfo        ,+#endif+    terminalSearchGetRegex                  ,+++-- ** searchGetWrapAround #method:searchGetWrapAround#++#if ENABLE_OVERLOADING+    TerminalSearchGetWrapAroundMethodInfo   ,+#endif+    terminalSearchGetWrapAround             ,+++-- ** searchSetGregex #method:searchSetGregex#++#if ENABLE_OVERLOADING+    TerminalSearchSetGregexMethodInfo       ,+#endif+    terminalSearchSetGregex                 ,+++-- ** searchSetRegex #method:searchSetRegex#++#if ENABLE_OVERLOADING+    TerminalSearchSetRegexMethodInfo        ,+#endif+    terminalSearchSetRegex                  ,+++-- ** searchSetWrapAround #method:searchSetWrapAround#++#if ENABLE_OVERLOADING+    TerminalSearchSetWrapAroundMethodInfo   ,+#endif+    terminalSearchSetWrapAround             ,+++-- ** selectAll #method:selectAll#++#if ENABLE_OVERLOADING+    TerminalSelectAllMethodInfo             ,+#endif+    terminalSelectAll                       ,+++-- ** setAllowBold #method:setAllowBold#++#if ENABLE_OVERLOADING+    TerminalSetAllowBoldMethodInfo          ,+#endif+    terminalSetAllowBold                    ,+++-- ** setAllowHyperlink #method:setAllowHyperlink#++#if ENABLE_OVERLOADING+    TerminalSetAllowHyperlinkMethodInfo     ,+#endif+    terminalSetAllowHyperlink               ,+++-- ** setAudibleBell #method:setAudibleBell#++#if ENABLE_OVERLOADING+    TerminalSetAudibleBellMethodInfo        ,+#endif+    terminalSetAudibleBell                  ,+++-- ** setBackspaceBinding #method:setBackspaceBinding#++#if ENABLE_OVERLOADING+    TerminalSetBackspaceBindingMethodInfo   ,+#endif+    terminalSetBackspaceBinding             ,+++-- ** setBoldIsBright #method:setBoldIsBright#++#if ENABLE_OVERLOADING+    TerminalSetBoldIsBrightMethodInfo       ,+#endif+    terminalSetBoldIsBright                 ,+++-- ** setCellHeightScale #method:setCellHeightScale#++#if ENABLE_OVERLOADING+    TerminalSetCellHeightScaleMethodInfo    ,+#endif+    terminalSetCellHeightScale              ,+++-- ** setCellWidthScale #method:setCellWidthScale#++#if ENABLE_OVERLOADING+    TerminalSetCellWidthScaleMethodInfo     ,+#endif+    terminalSetCellWidthScale               ,+++-- ** setCjkAmbiguousWidth #method:setCjkAmbiguousWidth#++#if ENABLE_OVERLOADING+    TerminalSetCjkAmbiguousWidthMethodInfo  ,+#endif+    terminalSetCjkAmbiguousWidth            ,+++-- ** setClearBackground #method:setClearBackground#++#if ENABLE_OVERLOADING+    TerminalSetClearBackgroundMethodInfo    ,+#endif+    terminalSetClearBackground              ,+++-- ** setColorBackground #method:setColorBackground#++#if ENABLE_OVERLOADING+    TerminalSetColorBackgroundMethodInfo    ,+#endif+    terminalSetColorBackground              ,+++-- ** setColorBold #method:setColorBold#++#if ENABLE_OVERLOADING+    TerminalSetColorBoldMethodInfo          ,+#endif+    terminalSetColorBold                    ,+++-- ** setColorCursor #method:setColorCursor#++#if ENABLE_OVERLOADING+    TerminalSetColorCursorMethodInfo        ,+#endif+    terminalSetColorCursor                  ,+++-- ** setColorCursorForeground #method:setColorCursorForeground#++#if ENABLE_OVERLOADING+    TerminalSetColorCursorForegroundMethodInfo,+#endif+    terminalSetColorCursorForeground        ,+++-- ** setColorForeground #method:setColorForeground#++#if ENABLE_OVERLOADING+    TerminalSetColorForegroundMethodInfo    ,+#endif+    terminalSetColorForeground              ,+++-- ** setColorHighlight #method:setColorHighlight#++#if ENABLE_OVERLOADING+    TerminalSetColorHighlightMethodInfo     ,+#endif+    terminalSetColorHighlight               ,+++-- ** setColorHighlightForeground #method:setColorHighlightForeground#++#if ENABLE_OVERLOADING+    TerminalSetColorHighlightForegroundMethodInfo,+#endif+    terminalSetColorHighlightForeground     ,+++-- ** setColors #method:setColors#++#if ENABLE_OVERLOADING+    TerminalSetColorsMethodInfo             ,+#endif+    terminalSetColors                       ,+++-- ** setCursorBlinkMode #method:setCursorBlinkMode#++#if ENABLE_OVERLOADING+    TerminalSetCursorBlinkModeMethodInfo    ,+#endif+    terminalSetCursorBlinkMode              ,+++-- ** setCursorShape #method:setCursorShape#++#if ENABLE_OVERLOADING+    TerminalSetCursorShapeMethodInfo        ,+#endif+    terminalSetCursorShape                  ,+++-- ** setDefaultColors #method:setDefaultColors#++#if ENABLE_OVERLOADING+    TerminalSetDefaultColorsMethodInfo      ,+#endif+    terminalSetDefaultColors                ,+++-- ** setDeleteBinding #method:setDeleteBinding#++#if ENABLE_OVERLOADING+    TerminalSetDeleteBindingMethodInfo      ,+#endif+    terminalSetDeleteBinding                ,+++-- ** setEncoding #method:setEncoding#++#if ENABLE_OVERLOADING+    TerminalSetEncodingMethodInfo           ,+#endif+    terminalSetEncoding                     ,+++-- ** setFont #method:setFont#++#if ENABLE_OVERLOADING+    TerminalSetFontMethodInfo               ,+#endif+    terminalSetFont                         ,+++-- ** setFontScale #method:setFontScale#++#if ENABLE_OVERLOADING+    TerminalSetFontScaleMethodInfo          ,+#endif+    terminalSetFontScale                    ,+++-- ** setGeometryHintsForWindow #method:setGeometryHintsForWindow#++#if ENABLE_OVERLOADING+    TerminalSetGeometryHintsForWindowMethodInfo,+#endif+    terminalSetGeometryHintsForWindow       ,+++-- ** setInputEnabled #method:setInputEnabled#++#if ENABLE_OVERLOADING+    TerminalSetInputEnabledMethodInfo       ,+#endif+    terminalSetInputEnabled                 ,+++-- ** setMouseAutohide #method:setMouseAutohide#++#if ENABLE_OVERLOADING+    TerminalSetMouseAutohideMethodInfo      ,+#endif+    terminalSetMouseAutohide                ,+++-- ** setPty #method:setPty#++#if ENABLE_OVERLOADING+    TerminalSetPtyMethodInfo                ,+#endif+    terminalSetPty                          ,+++-- ** setRewrapOnResize #method:setRewrapOnResize#++#if ENABLE_OVERLOADING+    TerminalSetRewrapOnResizeMethodInfo     ,+#endif+    terminalSetRewrapOnResize               ,+++-- ** setScrollOnKeystroke #method:setScrollOnKeystroke#++#if ENABLE_OVERLOADING+    TerminalSetScrollOnKeystrokeMethodInfo  ,+#endif+    terminalSetScrollOnKeystroke            ,+++-- ** setScrollOnOutput #method:setScrollOnOutput#++#if ENABLE_OVERLOADING+    TerminalSetScrollOnOutputMethodInfo     ,+#endif+    terminalSetScrollOnOutput               ,+++-- ** setScrollSpeed #method:setScrollSpeed#++#if ENABLE_OVERLOADING+    TerminalSetScrollSpeedMethodInfo        ,+#endif+    terminalSetScrollSpeed                  ,+++-- ** setScrollbackLines #method:setScrollbackLines#++#if ENABLE_OVERLOADING+    TerminalSetScrollbackLinesMethodInfo    ,+#endif+    terminalSetScrollbackLines              ,+++-- ** setSize #method:setSize#++#if ENABLE_OVERLOADING+    TerminalSetSizeMethodInfo               ,+#endif+    terminalSetSize                         ,+++-- ** setTextBlinkMode #method:setTextBlinkMode#++#if ENABLE_OVERLOADING+    TerminalSetTextBlinkModeMethodInfo      ,+#endif+    terminalSetTextBlinkMode                ,+++-- ** setWordCharExceptions #method:setWordCharExceptions#++#if ENABLE_OVERLOADING+    TerminalSetWordCharExceptionsMethodInfo ,+#endif+    terminalSetWordCharExceptions           ,+++-- ** spawnSync #method:spawnSync#++#if ENABLE_OVERLOADING+    TerminalSpawnSyncMethodInfo             ,+#endif+    terminalSpawnSync                       ,+++-- ** unselectAll #method:unselectAll#++#if ENABLE_OVERLOADING+    TerminalUnselectAllMethodInfo           ,+#endif+    terminalUnselectAll                     ,+++-- ** watchChild #method:watchChild#++#if ENABLE_OVERLOADING+    TerminalWatchChildMethodInfo            ,+#endif+    terminalWatchChild                      ,+++-- ** writeContentsSync #method:writeContentsSync#++#if ENABLE_OVERLOADING+    TerminalWriteContentsSyncMethodInfo     ,+#endif+    terminalWriteContentsSync               ,+++++ -- * Properties+-- ** allowBold #attr:allowBold#+{- | Controls whether or not the terminal will attempt to draw bold text.+This may happen either by using a bold font variant, or by+repainting text with a different offset.+-}+#if ENABLE_OVERLOADING+    TerminalAllowBoldPropertyInfo           ,+#endif+    constructTerminalAllowBold              ,+    getTerminalAllowBold                    ,+    setTerminalAllowBold                    ,+#if ENABLE_OVERLOADING+    terminalAllowBold                       ,+#endif+++-- ** allowHyperlink #attr:allowHyperlink#+{- | Controls whether or not hyperlinks (OSC 8 escape sequence) are recognized and displayed.++/Since: 0.50/+-}+#if ENABLE_OVERLOADING+    TerminalAllowHyperlinkPropertyInfo      ,+#endif+    constructTerminalAllowHyperlink         ,+    getTerminalAllowHyperlink               ,+    setTerminalAllowHyperlink               ,+#if ENABLE_OVERLOADING+    terminalAllowHyperlink                  ,+#endif+++-- ** audibleBell #attr:audibleBell#+{- | Controls whether or not the terminal will beep when the child outputs the+\"bl\" sequence.+-}+#if ENABLE_OVERLOADING+    TerminalAudibleBellPropertyInfo         ,+#endif+    constructTerminalAudibleBell            ,+    getTerminalAudibleBell                  ,+    setTerminalAudibleBell                  ,+#if ENABLE_OVERLOADING+    terminalAudibleBell                     ,+#endif+++-- ** backspaceBinding #attr:backspaceBinding#+{- | Controls what string or control sequence the terminal sends to its child+when the user presses the backspace key.+-}+#if ENABLE_OVERLOADING+    TerminalBackspaceBindingPropertyInfo    ,+#endif+    constructTerminalBackspaceBinding       ,+    getTerminalBackspaceBinding             ,+    setTerminalBackspaceBinding             ,+#if ENABLE_OVERLOADING+    terminalBackspaceBinding                ,+#endif+++-- ** boldIsBright #attr:boldIsBright#+{- | Whether the SGR 1 attribute also switches to the bright counterpart+of the first 8 palette colors, in addition to making them bold (legacy behavior)+or if SGR 1 only enables bold and leaves the color intact.++/Since: 0.52/+-}+#if ENABLE_OVERLOADING+    TerminalBoldIsBrightPropertyInfo        ,+#endif+    constructTerminalBoldIsBright           ,+    getTerminalBoldIsBright                 ,+    setTerminalBoldIsBright                 ,+#if ENABLE_OVERLOADING+    terminalBoldIsBright                    ,+#endif+++-- ** cellHeightScale #attr:cellHeightScale#+{- | Scale factor for the cell height, to increase line spacing. (The font\'s height is not affected.)++/Since: 0.52/+-}+#if ENABLE_OVERLOADING+    TerminalCellHeightScalePropertyInfo     ,+#endif+    constructTerminalCellHeightScale        ,+    getTerminalCellHeightScale              ,+    setTerminalCellHeightScale              ,+#if ENABLE_OVERLOADING+    terminalCellHeightScale                 ,+#endif+++-- ** cellWidthScale #attr:cellWidthScale#+{- | Scale factor for the cell width, to increase letter spacing. (The font\'s width is not affected.)++/Since: 0.52/+-}+#if ENABLE_OVERLOADING+    TerminalCellWidthScalePropertyInfo      ,+#endif+    constructTerminalCellWidthScale         ,+    getTerminalCellWidthScale               ,+    setTerminalCellWidthScale               ,+#if ENABLE_OVERLOADING+    terminalCellWidthScale                  ,+#endif+++-- ** cjkAmbiguousWidth #attr:cjkAmbiguousWidth#+{- | This setting controls whether ambiguous-width characters are narrow or wide.+(Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',+the width of ambiguous-width characters is fixed and determined by the encoding+itself.)++This setting only takes effect the next time the terminal is reset, either+via escape sequence or with 'GI.Vte.Objects.Terminal.terminalReset'.+-}+#if ENABLE_OVERLOADING+    TerminalCjkAmbiguousWidthPropertyInfo   ,+#endif+    constructTerminalCjkAmbiguousWidth      ,+    getTerminalCjkAmbiguousWidth            ,+    setTerminalCjkAmbiguousWidth            ,+#if ENABLE_OVERLOADING+    terminalCjkAmbiguousWidth               ,+#endif+++-- ** currentDirectoryUri #attr:currentDirectoryUri#+{- | The current directory URI, or 'Nothing' if unset.+-}+#if ENABLE_OVERLOADING+    TerminalCurrentDirectoryUriPropertyInfo ,+#endif+    getTerminalCurrentDirectoryUri          ,+#if ENABLE_OVERLOADING+    terminalCurrentDirectoryUri             ,+#endif+++-- ** currentFileUri #attr:currentFileUri#+{- | The current file URI, or 'Nothing' if unset.+-}+#if ENABLE_OVERLOADING+    TerminalCurrentFileUriPropertyInfo      ,+#endif+    getTerminalCurrentFileUri               ,+#if ENABLE_OVERLOADING+    terminalCurrentFileUri                  ,+#endif+++-- ** cursorBlinkMode #attr:cursorBlinkMode#+{- | Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'+will use the 'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.+-}+#if ENABLE_OVERLOADING+    TerminalCursorBlinkModePropertyInfo     ,+#endif+    constructTerminalCursorBlinkMode        ,+    getTerminalCursorBlinkMode              ,+    setTerminalCursorBlinkMode              ,+#if ENABLE_OVERLOADING+    terminalCursorBlinkMode                 ,+#endif+++-- ** cursorShape #attr:cursorShape#+{- | Controls the shape of the cursor.+-}+#if ENABLE_OVERLOADING+    TerminalCursorShapePropertyInfo         ,+#endif+    constructTerminalCursorShape            ,+    getTerminalCursorShape                  ,+    setTerminalCursorShape                  ,+#if ENABLE_OVERLOADING+    terminalCursorShape                     ,+#endif+++-- ** deleteBinding #attr:deleteBinding#+{- | Controls what string or control sequence the terminal sends to its child+when the user presses the delete key.+-}+#if ENABLE_OVERLOADING+    TerminalDeleteBindingPropertyInfo       ,+#endif+    constructTerminalDeleteBinding          ,+    getTerminalDeleteBinding                ,+    setTerminalDeleteBinding                ,+#if ENABLE_OVERLOADING+    terminalDeleteBinding                   ,+#endif+++-- ** encoding #attr:encoding#+{- | Controls the encoding the terminal will expect data from the child to+be encoded with.  For certain terminal types, applications executing in the+terminal can change the encoding.  The default is defined by the+application\'s locale settings.+-}+#if ENABLE_OVERLOADING+    TerminalEncodingPropertyInfo            ,+#endif+    clearTerminalEncoding                   ,+    constructTerminalEncoding               ,+    getTerminalEncoding                     ,+    setTerminalEncoding                     ,+#if ENABLE_OVERLOADING+    terminalEncoding                        ,+#endif+++-- ** fontDesc #attr:fontDesc#+{- | Specifies the font used for rendering all text displayed by the terminal,+overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal+will immediately attempt to load the desired font, retrieve its+metrics, and attempt to resize itself to keep the same number of rows+and columns.+-}+#if ENABLE_OVERLOADING+    TerminalFontDescPropertyInfo            ,+#endif+    clearTerminalFontDesc                   ,+    constructTerminalFontDesc               ,+    getTerminalFontDesc                     ,+    setTerminalFontDesc                     ,+#if ENABLE_OVERLOADING+    terminalFontDesc                        ,+#endif+++-- ** fontScale #attr:fontScale#+{- | The terminal\'s font scale.+-}+#if ENABLE_OVERLOADING+    TerminalFontScalePropertyInfo           ,+#endif+    constructTerminalFontScale              ,+    getTerminalFontScale                    ,+    setTerminalFontScale                    ,+#if ENABLE_OVERLOADING+    terminalFontScale                       ,+#endif+++-- ** hyperlinkHoverUri #attr:hyperlinkHoverUri#+{- | The currently hovered hyperlink URI, or 'Nothing' if unset.++/Since: 0.50/+-}+#if ENABLE_OVERLOADING+    TerminalHyperlinkHoverUriPropertyInfo   ,+#endif+    getTerminalHyperlinkHoverUri            ,+#if ENABLE_OVERLOADING+    terminalHyperlinkHoverUri               ,+#endif+++-- ** iconTitle #attr:iconTitle#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    TerminalIconTitlePropertyInfo           ,+#endif+    getTerminalIconTitle                    ,+#if ENABLE_OVERLOADING+    terminalIconTitle                       ,+#endif+++-- ** inputEnabled #attr:inputEnabled#+{- | Controls whether the terminal allows user input. When user input is disabled,+key press and mouse button press and motion events are not sent to the+terminal\'s child.+-}+#if ENABLE_OVERLOADING+    TerminalInputEnabledPropertyInfo        ,+#endif+    constructTerminalInputEnabled           ,+    getTerminalInputEnabled                 ,+    setTerminalInputEnabled                 ,+#if ENABLE_OVERLOADING+    terminalInputEnabled                    ,+#endif+++-- ** pointerAutohide #attr:pointerAutohide#+{- | Controls the value of the terminal\'s mouse autohide setting.  When autohiding+is enabled, the mouse cursor will be hidden when the user presses a key and+shown when the user moves the mouse.+-}+#if ENABLE_OVERLOADING+    TerminalPointerAutohidePropertyInfo     ,+#endif+    constructTerminalPointerAutohide        ,+    getTerminalPointerAutohide              ,+    setTerminalPointerAutohide              ,+#if ENABLE_OVERLOADING+    terminalPointerAutohide                 ,+#endif+++-- ** pty #attr:pty#+{- | The PTY object for the terminal.+-}+#if ENABLE_OVERLOADING+    TerminalPtyPropertyInfo                 ,+#endif+    clearTerminalPty                        ,+    constructTerminalPty                    ,+    getTerminalPty                          ,+    setTerminalPty                          ,+#if ENABLE_OVERLOADING+    terminalPty                             ,+#endif+++-- ** rewrapOnResize #attr:rewrapOnResize#+{- | Controls whether or not the terminal will rewrap its contents, including+the scrollback buffer, whenever the terminal\'s width changes.+-}+#if ENABLE_OVERLOADING+    TerminalRewrapOnResizePropertyInfo      ,+#endif+    constructTerminalRewrapOnResize         ,+    getTerminalRewrapOnResize               ,+    setTerminalRewrapOnResize               ,+#if ENABLE_OVERLOADING+    terminalRewrapOnResize                  ,+#endif+++-- ** scrollOnKeystroke #attr:scrollOnKeystroke#+{- | Controls whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the user presses a key.  Modifier keys do not+trigger this behavior.+-}+#if ENABLE_OVERLOADING+    TerminalScrollOnKeystrokePropertyInfo   ,+#endif+    constructTerminalScrollOnKeystroke      ,+    getTerminalScrollOnKeystroke            ,+    setTerminalScrollOnKeystroke            ,+#if ENABLE_OVERLOADING+    terminalScrollOnKeystroke               ,+#endif+++-- ** scrollOnOutput #attr:scrollOnOutput#+{- | Controls whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the new data is received from the child.+-}+#if ENABLE_OVERLOADING+    TerminalScrollOnOutputPropertyInfo      ,+#endif+    constructTerminalScrollOnOutput         ,+    getTerminalScrollOnOutput               ,+    setTerminalScrollOnOutput               ,+#if ENABLE_OVERLOADING+    terminalScrollOnOutput                  ,+#endif+++-- ** scrollSpeed #attr:scrollSpeed#+{- | The number of lines by which the buffer is moved when+scrolling with a mouse wheel on top of the terminal+Setting it to zero will cause the buffer to be moved by an+amount depending on the number of visible rows the widget+can display.+-}+#if ENABLE_OVERLOADING+    TerminalScrollSpeedPropertyInfo         ,+#endif+    constructTerminalScrollSpeed            ,+    getTerminalScrollSpeed                  ,+    setTerminalScrollSpeed                  ,+#if ENABLE_OVERLOADING+    terminalScrollSpeed                     ,+#endif+++-- ** scrollbackLines #attr:scrollbackLines#+{- | The length of the scrollback buffer used by the terminal.  The size of+the scrollback buffer will be set to the larger of this value and the number+of visible rows the widget can display, so 0 can safely be used to disable+scrollback.  Note that this setting only affects the normal screen buffer.+For terminal types which have an alternate screen buffer, no scrollback is+allowed on the alternate screen buffer.+-}+#if ENABLE_OVERLOADING+    TerminalScrollbackLinesPropertyInfo     ,+#endif+    constructTerminalScrollbackLines        ,+    getTerminalScrollbackLines              ,+    setTerminalScrollbackLines              ,+#if ENABLE_OVERLOADING+    terminalScrollbackLines                 ,+#endif+++-- ** textBlinkMode #attr:textBlinkMode#+{- | Controls whether or not the terminal will allow blinking text.++/Since: 0.52/+-}+#if ENABLE_OVERLOADING+    TerminalTextBlinkModePropertyInfo       ,+#endif+    constructTerminalTextBlinkMode          ,+    getTerminalTextBlinkMode                ,+    setTerminalTextBlinkMode                ,+#if ENABLE_OVERLOADING+    terminalTextBlinkMode                   ,+#endif+++-- ** windowTitle #attr:windowTitle#+{- | The terminal\'s title.+-}+#if ENABLE_OVERLOADING+    TerminalWindowTitlePropertyInfo         ,+#endif+    getTerminalWindowTitle                  ,+#if ENABLE_OVERLOADING+    terminalWindowTitle                     ,+#endif+++-- ** wordCharExceptions #attr:wordCharExceptions#+{- | The set of characters which will be considered parts of a word+when doing word-wise selection, in addition to the default which only+considers alphanumeric characters part of a word.++If 'Nothing', a built-in set is used.++/Since: 0.40/+-}+#if ENABLE_OVERLOADING+    TerminalWordCharExceptionsPropertyInfo  ,+#endif+    getTerminalWordCharExceptions           ,+#if ENABLE_OVERLOADING+    terminalWordCharExceptions              ,+#endif+++++ -- * Signals+-- ** bell #signal:bell#++    C_TerminalBellCallback                  ,+    TerminalBellCallback                    ,+#if ENABLE_OVERLOADING+    TerminalBellSignalInfo                  ,+#endif+    afterTerminalBell                       ,+    genClosure_TerminalBell                 ,+    mk_TerminalBellCallback                 ,+    noTerminalBellCallback                  ,+    onTerminalBell                          ,+    wrap_TerminalBellCallback               ,+++-- ** charSizeChanged #signal:charSizeChanged#++    C_TerminalCharSizeChangedCallback       ,+    TerminalCharSizeChangedCallback         ,+#if ENABLE_OVERLOADING+    TerminalCharSizeChangedSignalInfo       ,+#endif+    afterTerminalCharSizeChanged            ,+    genClosure_TerminalCharSizeChanged      ,+    mk_TerminalCharSizeChangedCallback      ,+    noTerminalCharSizeChangedCallback       ,+    onTerminalCharSizeChanged               ,+    wrap_TerminalCharSizeChangedCallback    ,+++-- ** childExited #signal:childExited#++    C_TerminalChildExitedCallback           ,+    TerminalChildExitedCallback             ,+#if ENABLE_OVERLOADING+    TerminalChildExitedSignalInfo           ,+#endif+    afterTerminalChildExited                ,+    genClosure_TerminalChildExited          ,+    mk_TerminalChildExitedCallback          ,+    noTerminalChildExitedCallback           ,+    onTerminalChildExited                   ,+    wrap_TerminalChildExitedCallback        ,+++-- ** commit #signal:commit#++    C_TerminalCommitCallback                ,+    TerminalCommitCallback                  ,+#if ENABLE_OVERLOADING+    TerminalCommitSignalInfo                ,+#endif+    afterTerminalCommit                     ,+    genClosure_TerminalCommit               ,+    mk_TerminalCommitCallback               ,+    noTerminalCommitCallback                ,+    onTerminalCommit                        ,+    wrap_TerminalCommitCallback             ,+++-- ** contentsChanged #signal:contentsChanged#++    C_TerminalContentsChangedCallback       ,+    TerminalContentsChangedCallback         ,+#if ENABLE_OVERLOADING+    TerminalContentsChangedSignalInfo       ,+#endif+    afterTerminalContentsChanged            ,+    genClosure_TerminalContentsChanged      ,+    mk_TerminalContentsChangedCallback      ,+    noTerminalContentsChangedCallback       ,+    onTerminalContentsChanged               ,+    wrap_TerminalContentsChangedCallback    ,+++-- ** copyClipboard #signal:copyClipboard#++    C_TerminalCopyClipboardCallback         ,+    TerminalCopyClipboardCallback           ,+#if ENABLE_OVERLOADING+    TerminalCopyClipboardSignalInfo         ,+#endif+    afterTerminalCopyClipboard              ,+    genClosure_TerminalCopyClipboard        ,+    mk_TerminalCopyClipboardCallback        ,+    noTerminalCopyClipboardCallback         ,+    onTerminalCopyClipboard                 ,+    wrap_TerminalCopyClipboardCallback      ,+++-- ** currentDirectoryUriChanged #signal:currentDirectoryUriChanged#++    C_TerminalCurrentDirectoryUriChangedCallback,+    TerminalCurrentDirectoryUriChangedCallback,+#if ENABLE_OVERLOADING+    TerminalCurrentDirectoryUriChangedSignalInfo,+#endif+    afterTerminalCurrentDirectoryUriChanged ,+    genClosure_TerminalCurrentDirectoryUriChanged,+    mk_TerminalCurrentDirectoryUriChangedCallback,+    noTerminalCurrentDirectoryUriChangedCallback,+    onTerminalCurrentDirectoryUriChanged    ,+    wrap_TerminalCurrentDirectoryUriChangedCallback,+++-- ** currentFileUriChanged #signal:currentFileUriChanged#++    C_TerminalCurrentFileUriChangedCallback ,+    TerminalCurrentFileUriChangedCallback   ,+#if ENABLE_OVERLOADING+    TerminalCurrentFileUriChangedSignalInfo ,+#endif+    afterTerminalCurrentFileUriChanged      ,+    genClosure_TerminalCurrentFileUriChanged,+    mk_TerminalCurrentFileUriChangedCallback,+    noTerminalCurrentFileUriChangedCallback ,+    onTerminalCurrentFileUriChanged         ,+    wrap_TerminalCurrentFileUriChangedCallback,+++-- ** cursorMoved #signal:cursorMoved#++    C_TerminalCursorMovedCallback           ,+    TerminalCursorMovedCallback             ,+#if ENABLE_OVERLOADING+    TerminalCursorMovedSignalInfo           ,+#endif+    afterTerminalCursorMoved                ,+    genClosure_TerminalCursorMoved          ,+    mk_TerminalCursorMovedCallback          ,+    noTerminalCursorMovedCallback           ,+    onTerminalCursorMoved                   ,+    wrap_TerminalCursorMovedCallback        ,+++-- ** decreaseFontSize #signal:decreaseFontSize#++    C_TerminalDecreaseFontSizeCallback      ,+    TerminalDecreaseFontSizeCallback        ,+#if ENABLE_OVERLOADING+    TerminalDecreaseFontSizeSignalInfo      ,+#endif+    afterTerminalDecreaseFontSize           ,+    genClosure_TerminalDecreaseFontSize     ,+    mk_TerminalDecreaseFontSizeCallback     ,+    noTerminalDecreaseFontSizeCallback      ,+    onTerminalDecreaseFontSize              ,+    wrap_TerminalDecreaseFontSizeCallback   ,+++-- ** deiconifyWindow #signal:deiconifyWindow#++    C_TerminalDeiconifyWindowCallback       ,+    TerminalDeiconifyWindowCallback         ,+#if ENABLE_OVERLOADING+    TerminalDeiconifyWindowSignalInfo       ,+#endif+    afterTerminalDeiconifyWindow            ,+    genClosure_TerminalDeiconifyWindow      ,+    mk_TerminalDeiconifyWindowCallback      ,+    noTerminalDeiconifyWindowCallback       ,+    onTerminalDeiconifyWindow               ,+    wrap_TerminalDeiconifyWindowCallback    ,+++-- ** encodingChanged #signal:encodingChanged#++    C_TerminalEncodingChangedCallback       ,+    TerminalEncodingChangedCallback         ,+#if ENABLE_OVERLOADING+    TerminalEncodingChangedSignalInfo       ,+#endif+    afterTerminalEncodingChanged            ,+    genClosure_TerminalEncodingChanged      ,+    mk_TerminalEncodingChangedCallback      ,+    noTerminalEncodingChangedCallback       ,+    onTerminalEncodingChanged               ,+    wrap_TerminalEncodingChangedCallback    ,+++-- ** eof #signal:eof#++    C_TerminalEofCallback                   ,+    TerminalEofCallback                     ,+#if ENABLE_OVERLOADING+    TerminalEofSignalInfo                   ,+#endif+    afterTerminalEof                        ,+    genClosure_TerminalEof                  ,+    mk_TerminalEofCallback                  ,+    noTerminalEofCallback                   ,+    onTerminalEof                           ,+    wrap_TerminalEofCallback                ,+++-- ** hyperlinkHoverUriChanged #signal:hyperlinkHoverUriChanged#++    C_TerminalHyperlinkHoverUriChangedCallback,+    TerminalHyperlinkHoverUriChangedCallback,+#if ENABLE_OVERLOADING+    TerminalHyperlinkHoverUriChangedSignalInfo,+#endif+    afterTerminalHyperlinkHoverUriChanged   ,+    genClosure_TerminalHyperlinkHoverUriChanged,+    mk_TerminalHyperlinkHoverUriChangedCallback,+    noTerminalHyperlinkHoverUriChangedCallback,+    onTerminalHyperlinkHoverUriChanged      ,+    wrap_TerminalHyperlinkHoverUriChangedCallback,+++-- ** iconTitleChanged #signal:iconTitleChanged#++    C_TerminalIconTitleChangedCallback      ,+    TerminalIconTitleChangedCallback        ,+#if ENABLE_OVERLOADING+    TerminalIconTitleChangedSignalInfo      ,+#endif+    afterTerminalIconTitleChanged           ,+    genClosure_TerminalIconTitleChanged     ,+    mk_TerminalIconTitleChangedCallback     ,+    noTerminalIconTitleChangedCallback      ,+    onTerminalIconTitleChanged              ,+    wrap_TerminalIconTitleChangedCallback   ,+++-- ** iconifyWindow #signal:iconifyWindow#++    C_TerminalIconifyWindowCallback         ,+    TerminalIconifyWindowCallback           ,+#if ENABLE_OVERLOADING+    TerminalIconifyWindowSignalInfo         ,+#endif+    afterTerminalIconifyWindow              ,+    genClosure_TerminalIconifyWindow        ,+    mk_TerminalIconifyWindowCallback        ,+    noTerminalIconifyWindowCallback         ,+    onTerminalIconifyWindow                 ,+    wrap_TerminalIconifyWindowCallback      ,+++-- ** increaseFontSize #signal:increaseFontSize#++    C_TerminalIncreaseFontSizeCallback      ,+    TerminalIncreaseFontSizeCallback        ,+#if ENABLE_OVERLOADING+    TerminalIncreaseFontSizeSignalInfo      ,+#endif+    afterTerminalIncreaseFontSize           ,+    genClosure_TerminalIncreaseFontSize     ,+    mk_TerminalIncreaseFontSizeCallback     ,+    noTerminalIncreaseFontSizeCallback      ,+    onTerminalIncreaseFontSize              ,+    wrap_TerminalIncreaseFontSizeCallback   ,+++-- ** lowerWindow #signal:lowerWindow#++    C_TerminalLowerWindowCallback           ,+    TerminalLowerWindowCallback             ,+#if ENABLE_OVERLOADING+    TerminalLowerWindowSignalInfo           ,+#endif+    afterTerminalLowerWindow                ,+    genClosure_TerminalLowerWindow          ,+    mk_TerminalLowerWindowCallback          ,+    noTerminalLowerWindowCallback           ,+    onTerminalLowerWindow                   ,+    wrap_TerminalLowerWindowCallback        ,+++-- ** maximizeWindow #signal:maximizeWindow#++    C_TerminalMaximizeWindowCallback        ,+    TerminalMaximizeWindowCallback          ,+#if ENABLE_OVERLOADING+    TerminalMaximizeWindowSignalInfo        ,+#endif+    afterTerminalMaximizeWindow             ,+    genClosure_TerminalMaximizeWindow       ,+    mk_TerminalMaximizeWindowCallback       ,+    noTerminalMaximizeWindowCallback        ,+    onTerminalMaximizeWindow                ,+    wrap_TerminalMaximizeWindowCallback     ,+++-- ** moveWindow #signal:moveWindow#++    C_TerminalMoveWindowCallback            ,+    TerminalMoveWindowCallback              ,+#if ENABLE_OVERLOADING+    TerminalMoveWindowSignalInfo            ,+#endif+    afterTerminalMoveWindow                 ,+    genClosure_TerminalMoveWindow           ,+    mk_TerminalMoveWindowCallback           ,+    noTerminalMoveWindowCallback            ,+    onTerminalMoveWindow                    ,+    wrap_TerminalMoveWindowCallback         ,+++-- ** notificationReceived #signal:notificationReceived#++    C_TerminalNotificationReceivedCallback  ,+    TerminalNotificationReceivedCallback    ,+#if ENABLE_OVERLOADING+    TerminalNotificationReceivedSignalInfo  ,+#endif+    afterTerminalNotificationReceived       ,+    genClosure_TerminalNotificationReceived ,+    mk_TerminalNotificationReceivedCallback ,+    noTerminalNotificationReceivedCallback  ,+    onTerminalNotificationReceived          ,+    wrap_TerminalNotificationReceivedCallback,+++-- ** pasteClipboard #signal:pasteClipboard#++    C_TerminalPasteClipboardCallback        ,+    TerminalPasteClipboardCallback          ,+#if ENABLE_OVERLOADING+    TerminalPasteClipboardSignalInfo        ,+#endif+    afterTerminalPasteClipboard             ,+    genClosure_TerminalPasteClipboard       ,+    mk_TerminalPasteClipboardCallback       ,+    noTerminalPasteClipboardCallback        ,+    onTerminalPasteClipboard                ,+    wrap_TerminalPasteClipboardCallback     ,+++-- ** raiseWindow #signal:raiseWindow#++    C_TerminalRaiseWindowCallback           ,+    TerminalRaiseWindowCallback             ,+#if ENABLE_OVERLOADING+    TerminalRaiseWindowSignalInfo           ,+#endif+    afterTerminalRaiseWindow                ,+    genClosure_TerminalRaiseWindow          ,+    mk_TerminalRaiseWindowCallback          ,+    noTerminalRaiseWindowCallback           ,+    onTerminalRaiseWindow                   ,+    wrap_TerminalRaiseWindowCallback        ,+++-- ** refreshWindow #signal:refreshWindow#++    C_TerminalRefreshWindowCallback         ,+    TerminalRefreshWindowCallback           ,+#if ENABLE_OVERLOADING+    TerminalRefreshWindowSignalInfo         ,+#endif+    afterTerminalRefreshWindow              ,+    genClosure_TerminalRefreshWindow        ,+    mk_TerminalRefreshWindowCallback        ,+    noTerminalRefreshWindowCallback         ,+    onTerminalRefreshWindow                 ,+    wrap_TerminalRefreshWindowCallback      ,+++-- ** resizeWindow #signal:resizeWindow#++    C_TerminalResizeWindowCallback          ,+    TerminalResizeWindowCallback            ,+#if ENABLE_OVERLOADING+    TerminalResizeWindowSignalInfo          ,+#endif+    afterTerminalResizeWindow               ,+    genClosure_TerminalResizeWindow         ,+    mk_TerminalResizeWindowCallback         ,+    noTerminalResizeWindowCallback          ,+    onTerminalResizeWindow                  ,+    wrap_TerminalResizeWindowCallback       ,+++-- ** restoreWindow #signal:restoreWindow#++    C_TerminalRestoreWindowCallback         ,+    TerminalRestoreWindowCallback           ,+#if ENABLE_OVERLOADING+    TerminalRestoreWindowSignalInfo         ,+#endif+    afterTerminalRestoreWindow              ,+    genClosure_TerminalRestoreWindow        ,+    mk_TerminalRestoreWindowCallback        ,+    noTerminalRestoreWindowCallback         ,+    onTerminalRestoreWindow                 ,+    wrap_TerminalRestoreWindowCallback      ,+++-- ** selectionChanged #signal:selectionChanged#++    C_TerminalSelectionChangedCallback      ,+    TerminalSelectionChangedCallback        ,+#if ENABLE_OVERLOADING+    TerminalSelectionChangedSignalInfo      ,+#endif+    afterTerminalSelectionChanged           ,+    genClosure_TerminalSelectionChanged     ,+    mk_TerminalSelectionChangedCallback     ,+    noTerminalSelectionChangedCallback      ,+    onTerminalSelectionChanged              ,+    wrap_TerminalSelectionChangedCallback   ,+++-- ** textDeleted #signal:textDeleted#++    C_TerminalTextDeletedCallback           ,+    TerminalTextDeletedCallback             ,+#if ENABLE_OVERLOADING+    TerminalTextDeletedSignalInfo           ,+#endif+    afterTerminalTextDeleted                ,+    genClosure_TerminalTextDeleted          ,+    mk_TerminalTextDeletedCallback          ,+    noTerminalTextDeletedCallback           ,+    onTerminalTextDeleted                   ,+    wrap_TerminalTextDeletedCallback        ,+++-- ** textInserted #signal:textInserted#++    C_TerminalTextInsertedCallback          ,+    TerminalTextInsertedCallback            ,+#if ENABLE_OVERLOADING+    TerminalTextInsertedSignalInfo          ,+#endif+    afterTerminalTextInserted               ,+    genClosure_TerminalTextInserted         ,+    mk_TerminalTextInsertedCallback         ,+    noTerminalTextInsertedCallback          ,+    onTerminalTextInserted                  ,+    wrap_TerminalTextInsertedCallback       ,+++-- ** textModified #signal:textModified#++    C_TerminalTextModifiedCallback          ,+    TerminalTextModifiedCallback            ,+#if ENABLE_OVERLOADING+    TerminalTextModifiedSignalInfo          ,+#endif+    afterTerminalTextModified               ,+    genClosure_TerminalTextModified         ,+    mk_TerminalTextModifiedCallback         ,+    noTerminalTextModifiedCallback          ,+    onTerminalTextModified                  ,+    wrap_TerminalTextModifiedCallback       ,+++-- ** textScrolled #signal:textScrolled#++    C_TerminalTextScrolledCallback          ,+    TerminalTextScrolledCallback            ,+#if ENABLE_OVERLOADING+    TerminalTextScrolledSignalInfo          ,+#endif+    afterTerminalTextScrolled               ,+    genClosure_TerminalTextScrolled         ,+    mk_TerminalTextScrolledCallback         ,+    noTerminalTextScrolledCallback          ,+    onTerminalTextScrolled                  ,+    wrap_TerminalTextScrolledCallback       ,+++-- ** windowTitleChanged #signal:windowTitleChanged#++    C_TerminalWindowTitleChangedCallback    ,+    TerminalWindowTitleChangedCallback      ,+#if ENABLE_OVERLOADING+    TerminalWindowTitleChangedSignalInfo    ,+#endif+    afterTerminalWindowTitleChanged         ,+    genClosure_TerminalWindowTitleChanged   ,+    mk_TerminalWindowTitleChangedCallback   ,+    noTerminalWindowTitleChangedCallback    ,+    onTerminalWindowTitleChanged            ,+    wrap_TerminalWindowTitleChangedCallback ,+++++    ) 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++import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface+import qualified GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GLib.Flags as GLib.Flags+import qualified GI.GLib.Structs.Regex as GLib.Regex+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gdk.Enums as Gdk.Enums+import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor+import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry+import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA+import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle+import qualified GI.Gdk.Unions.Event as Gdk.Event+import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable+import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import qualified GI.Gtk.Objects.Window as Gtk.Window+import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription+import {-# SOURCE #-} qualified GI.Vte.Enums as Vte.Enums+import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags+import {-# SOURCE #-} qualified GI.Vte.Objects.Pty as Vte.Pty+import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex++-- | Memory-managed wrapper type.+newtype Terminal = Terminal (ManagedPtr Terminal)+foreign import ccall "vte_terminal_get_type"+    c_vte_terminal_get_type :: IO GType++instance GObject Terminal where+    gobjectType = c_vte_terminal_get_type+    ++-- | Type class for types which can be safely cast to `Terminal`, for instance with `toTerminal`.+class (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o+instance (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o++instance O.HasParentTypes Terminal+type instance O.ParentTypes Terminal = '[Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Scrollable.Scrollable]++-- | Cast to `Terminal`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toTerminal :: (MonadIO m, IsTerminal o) => o -> m Terminal+toTerminal = liftIO . unsafeCastTo Terminal++-- | A convenience alias for `Nothing` :: `Maybe` `Terminal`.+noTerminal :: Maybe Terminal+noTerminal = Nothing++#if ENABLE_OVERLOADING+type family ResolveTerminalMethod (t :: Symbol) (o :: *) :: * where+    ResolveTerminalMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveTerminalMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveTerminalMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveTerminalMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveTerminalMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveTerminalMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveTerminalMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveTerminalMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveTerminalMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveTerminalMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveTerminalMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveTerminalMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo+    ResolveTerminalMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveTerminalMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveTerminalMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveTerminalMethod "copyClipboard" o = TerminalCopyClipboardMethodInfo+    ResolveTerminalMethod "copyClipboardFormat" o = TerminalCopyClipboardFormatMethodInfo+    ResolveTerminalMethod "copyPrimary" o = TerminalCopyPrimaryMethodInfo+    ResolveTerminalMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveTerminalMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveTerminalMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveTerminalMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveTerminalMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveTerminalMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveTerminalMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveTerminalMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveTerminalMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveTerminalMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveTerminalMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveTerminalMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveTerminalMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveTerminalMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveTerminalMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveTerminalMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveTerminalMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveTerminalMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveTerminalMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveTerminalMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveTerminalMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveTerminalMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveTerminalMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveTerminalMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveTerminalMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveTerminalMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveTerminalMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveTerminalMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveTerminalMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveTerminalMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveTerminalMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveTerminalMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveTerminalMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveTerminalMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveTerminalMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveTerminalMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveTerminalMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveTerminalMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveTerminalMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveTerminalMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveTerminalMethod "feed" o = TerminalFeedMethodInfo+    ResolveTerminalMethod "feedChild" o = TerminalFeedChildMethodInfo+    ResolveTerminalMethod "feedChildBinary" o = TerminalFeedChildBinaryMethodInfo+    ResolveTerminalMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveTerminalMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveTerminalMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveTerminalMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveTerminalMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveTerminalMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveTerminalMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveTerminalMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveTerminalMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveTerminalMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveTerminalMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveTerminalMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveTerminalMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveTerminalMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveTerminalMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveTerminalMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveTerminalMethod "hyperlinkCheckEvent" o = TerminalHyperlinkCheckEventMethodInfo+    ResolveTerminalMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveTerminalMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveTerminalMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveTerminalMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveTerminalMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveTerminalMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveTerminalMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveTerminalMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveTerminalMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveTerminalMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveTerminalMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveTerminalMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveTerminalMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveTerminalMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveTerminalMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveTerminalMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveTerminalMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveTerminalMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveTerminalMethod "matchAddGregex" o = TerminalMatchAddGregexMethodInfo+    ResolveTerminalMethod "matchAddRegex" o = TerminalMatchAddRegexMethodInfo+    ResolveTerminalMethod "matchCheck" o = TerminalMatchCheckMethodInfo+    ResolveTerminalMethod "matchCheckEvent" o = TerminalMatchCheckEventMethodInfo+    ResolveTerminalMethod "matchRemove" o = TerminalMatchRemoveMethodInfo+    ResolveTerminalMethod "matchRemoveAll" o = TerminalMatchRemoveAllMethodInfo+    ResolveTerminalMethod "matchSetCursor" o = TerminalMatchSetCursorMethodInfo+    ResolveTerminalMethod "matchSetCursorName" o = TerminalMatchSetCursorNameMethodInfo+    ResolveTerminalMethod "matchSetCursorType" o = TerminalMatchSetCursorTypeMethodInfo+    ResolveTerminalMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveTerminalMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveTerminalMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveTerminalMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveTerminalMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveTerminalMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveTerminalMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveTerminalMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveTerminalMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveTerminalMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveTerminalMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveTerminalMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveTerminalMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveTerminalMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveTerminalMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveTerminalMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveTerminalMethod "pasteClipboard" o = TerminalPasteClipboardMethodInfo+    ResolveTerminalMethod "pastePrimary" o = TerminalPastePrimaryMethodInfo+    ResolveTerminalMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveTerminalMethod "ptyNewSync" o = TerminalPtyNewSyncMethodInfo+    ResolveTerminalMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveTerminalMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveTerminalMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveTerminalMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveTerminalMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveTerminalMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveTerminalMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveTerminalMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveTerminalMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveTerminalMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveTerminalMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveTerminalMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveTerminalMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveTerminalMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveTerminalMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveTerminalMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveTerminalMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveTerminalMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveTerminalMethod "reset" o = TerminalResetMethodInfo+    ResolveTerminalMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveTerminalMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveTerminalMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveTerminalMethod "searchFindNext" o = TerminalSearchFindNextMethodInfo+    ResolveTerminalMethod "searchFindPrevious" o = TerminalSearchFindPreviousMethodInfo+    ResolveTerminalMethod "searchGetGregex" o = TerminalSearchGetGregexMethodInfo+    ResolveTerminalMethod "searchGetRegex" o = TerminalSearchGetRegexMethodInfo+    ResolveTerminalMethod "searchGetWrapAround" o = TerminalSearchGetWrapAroundMethodInfo+    ResolveTerminalMethod "searchSetGregex" o = TerminalSearchSetGregexMethodInfo+    ResolveTerminalMethod "searchSetRegex" o = TerminalSearchSetRegexMethodInfo+    ResolveTerminalMethod "searchSetWrapAround" o = TerminalSearchSetWrapAroundMethodInfo+    ResolveTerminalMethod "selectAll" o = TerminalSelectAllMethodInfo+    ResolveTerminalMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveTerminalMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveTerminalMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveTerminalMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveTerminalMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveTerminalMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveTerminalMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveTerminalMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveTerminalMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveTerminalMethod "spawnSync" o = TerminalSpawnSyncMethodInfo+    ResolveTerminalMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveTerminalMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveTerminalMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveTerminalMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveTerminalMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveTerminalMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveTerminalMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveTerminalMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveTerminalMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveTerminalMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveTerminalMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveTerminalMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveTerminalMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveTerminalMethod "unselectAll" o = TerminalUnselectAllMethodInfo+    ResolveTerminalMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveTerminalMethod "watchChild" o = TerminalWatchChildMethodInfo+    ResolveTerminalMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveTerminalMethod "writeContentsSync" o = TerminalWriteContentsSyncMethodInfo+    ResolveTerminalMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveTerminalMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveTerminalMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveTerminalMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveTerminalMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveTerminalMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveTerminalMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveTerminalMethod "getAllowBold" o = TerminalGetAllowBoldMethodInfo+    ResolveTerminalMethod "getAllowHyperlink" o = TerminalGetAllowHyperlinkMethodInfo+    ResolveTerminalMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveTerminalMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveTerminalMethod "getAudibleBell" o = TerminalGetAudibleBellMethodInfo+    ResolveTerminalMethod "getBoldIsBright" o = TerminalGetBoldIsBrightMethodInfo+    ResolveTerminalMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo+    ResolveTerminalMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveTerminalMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveTerminalMethod "getCellHeightScale" o = TerminalGetCellHeightScaleMethodInfo+    ResolveTerminalMethod "getCellWidthScale" o = TerminalGetCellWidthScaleMethodInfo+    ResolveTerminalMethod "getCharHeight" o = TerminalGetCharHeightMethodInfo+    ResolveTerminalMethod "getCharWidth" o = TerminalGetCharWidthMethodInfo+    ResolveTerminalMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveTerminalMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveTerminalMethod "getCjkAmbiguousWidth" o = TerminalGetCjkAmbiguousWidthMethodInfo+    ResolveTerminalMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveTerminalMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveTerminalMethod "getColorBackgroundForDraw" o = TerminalGetColorBackgroundForDrawMethodInfo+    ResolveTerminalMethod "getColumnCount" o = TerminalGetColumnCountMethodInfo+    ResolveTerminalMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveTerminalMethod "getCurrentDirectoryUri" o = TerminalGetCurrentDirectoryUriMethodInfo+    ResolveTerminalMethod "getCurrentFileUri" o = TerminalGetCurrentFileUriMethodInfo+    ResolveTerminalMethod "getCursorBlinkMode" o = TerminalGetCursorBlinkModeMethodInfo+    ResolveTerminalMethod "getCursorPosition" o = TerminalGetCursorPositionMethodInfo+    ResolveTerminalMethod "getCursorShape" o = TerminalGetCursorShapeMethodInfo+    ResolveTerminalMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveTerminalMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveTerminalMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveTerminalMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveTerminalMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveTerminalMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveTerminalMethod "getEncoding" o = TerminalGetEncodingMethodInfo+    ResolveTerminalMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveTerminalMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveTerminalMethod "getFont" o = TerminalGetFontMethodInfo+    ResolveTerminalMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveTerminalMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveTerminalMethod "getFontScale" o = TerminalGetFontScaleMethodInfo+    ResolveTerminalMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveTerminalMethod "getGeometryHints" o = TerminalGetGeometryHintsMethodInfo+    ResolveTerminalMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo+    ResolveTerminalMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveTerminalMethod "getHasSelection" o = TerminalGetHasSelectionMethodInfo+    ResolveTerminalMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveTerminalMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveTerminalMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveTerminalMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveTerminalMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo+    ResolveTerminalMethod "getIconTitle" o = TerminalGetIconTitleMethodInfo+    ResolveTerminalMethod "getInputEnabled" o = TerminalGetInputEnabledMethodInfo+    ResolveTerminalMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveTerminalMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveTerminalMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveTerminalMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveTerminalMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveTerminalMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveTerminalMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveTerminalMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveTerminalMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveTerminalMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveTerminalMethod "getMouseAutohide" o = TerminalGetMouseAutohideMethodInfo+    ResolveTerminalMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveTerminalMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveTerminalMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveTerminalMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveTerminalMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveTerminalMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveTerminalMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveTerminalMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveTerminalMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveTerminalMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveTerminalMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveTerminalMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveTerminalMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveTerminalMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveTerminalMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveTerminalMethod "getPty" o = TerminalGetPtyMethodInfo+    ResolveTerminalMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveTerminalMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveTerminalMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveTerminalMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveTerminalMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveTerminalMethod "getRewrapOnResize" o = TerminalGetRewrapOnResizeMethodInfo+    ResolveTerminalMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveTerminalMethod "getRowCount" o = TerminalGetRowCountMethodInfo+    ResolveTerminalMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveTerminalMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveTerminalMethod "getScrollOnKeystroke" o = TerminalGetScrollOnKeystrokeMethodInfo+    ResolveTerminalMethod "getScrollOnOutput" o = TerminalGetScrollOnOutputMethodInfo+    ResolveTerminalMethod "getScrollbackLines" o = TerminalGetScrollbackLinesMethodInfo+    ResolveTerminalMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveTerminalMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveTerminalMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveTerminalMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveTerminalMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveTerminalMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveTerminalMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveTerminalMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveTerminalMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveTerminalMethod "getText" o = TerminalGetTextMethodInfo+    ResolveTerminalMethod "getTextBlinkMode" o = TerminalGetTextBlinkModeMethodInfo+    ResolveTerminalMethod "getTextIncludeTrailingSpaces" o = TerminalGetTextIncludeTrailingSpacesMethodInfo+    ResolveTerminalMethod "getTextRange" o = TerminalGetTextRangeMethodInfo+    ResolveTerminalMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveTerminalMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveTerminalMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveTerminalMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveTerminalMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo+    ResolveTerminalMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveTerminalMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveTerminalMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveTerminalMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveTerminalMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveTerminalMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveTerminalMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo+    ResolveTerminalMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveTerminalMethod "getWindowTitle" o = TerminalGetWindowTitleMethodInfo+    ResolveTerminalMethod "getWordCharExceptions" o = TerminalGetWordCharExceptionsMethodInfo+    ResolveTerminalMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveTerminalMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveTerminalMethod "setAllowBold" o = TerminalSetAllowBoldMethodInfo+    ResolveTerminalMethod "setAllowHyperlink" o = TerminalSetAllowHyperlinkMethodInfo+    ResolveTerminalMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveTerminalMethod "setAudibleBell" o = TerminalSetAudibleBellMethodInfo+    ResolveTerminalMethod "setBackspaceBinding" o = TerminalSetBackspaceBindingMethodInfo+    ResolveTerminalMethod "setBoldIsBright" o = TerminalSetBoldIsBrightMethodInfo+    ResolveTerminalMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveTerminalMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveTerminalMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveTerminalMethod "setCellHeightScale" o = TerminalSetCellHeightScaleMethodInfo+    ResolveTerminalMethod "setCellWidthScale" o = TerminalSetCellWidthScaleMethodInfo+    ResolveTerminalMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveTerminalMethod "setCjkAmbiguousWidth" o = TerminalSetCjkAmbiguousWidthMethodInfo+    ResolveTerminalMethod "setClearBackground" o = TerminalSetClearBackgroundMethodInfo+    ResolveTerminalMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveTerminalMethod "setColorBackground" o = TerminalSetColorBackgroundMethodInfo+    ResolveTerminalMethod "setColorBold" o = TerminalSetColorBoldMethodInfo+    ResolveTerminalMethod "setColorCursor" o = TerminalSetColorCursorMethodInfo+    ResolveTerminalMethod "setColorCursorForeground" o = TerminalSetColorCursorForegroundMethodInfo+    ResolveTerminalMethod "setColorForeground" o = TerminalSetColorForegroundMethodInfo+    ResolveTerminalMethod "setColorHighlight" o = TerminalSetColorHighlightMethodInfo+    ResolveTerminalMethod "setColorHighlightForeground" o = TerminalSetColorHighlightForegroundMethodInfo+    ResolveTerminalMethod "setColors" o = TerminalSetColorsMethodInfo+    ResolveTerminalMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveTerminalMethod "setCursorBlinkMode" o = TerminalSetCursorBlinkModeMethodInfo+    ResolveTerminalMethod "setCursorShape" o = TerminalSetCursorShapeMethodInfo+    ResolveTerminalMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveTerminalMethod "setDefaultColors" o = TerminalSetDefaultColorsMethodInfo+    ResolveTerminalMethod "setDeleteBinding" o = TerminalSetDeleteBindingMethodInfo+    ResolveTerminalMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveTerminalMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveTerminalMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveTerminalMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveTerminalMethod "setEncoding" o = TerminalSetEncodingMethodInfo+    ResolveTerminalMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveTerminalMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveTerminalMethod "setFont" o = TerminalSetFontMethodInfo+    ResolveTerminalMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveTerminalMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveTerminalMethod "setFontScale" o = TerminalSetFontScaleMethodInfo+    ResolveTerminalMethod "setGeometryHintsForWindow" o = TerminalSetGeometryHintsForWindowMethodInfo+    ResolveTerminalMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo+    ResolveTerminalMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveTerminalMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveTerminalMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveTerminalMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveTerminalMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveTerminalMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo+    ResolveTerminalMethod "setInputEnabled" o = TerminalSetInputEnabledMethodInfo+    ResolveTerminalMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveTerminalMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveTerminalMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveTerminalMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveTerminalMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveTerminalMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveTerminalMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveTerminalMethod "setMouseAutohide" o = TerminalSetMouseAutohideMethodInfo+    ResolveTerminalMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveTerminalMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveTerminalMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveTerminalMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveTerminalMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveTerminalMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveTerminalMethod "setPty" o = TerminalSetPtyMethodInfo+    ResolveTerminalMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveTerminalMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveTerminalMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveTerminalMethod "setRewrapOnResize" o = TerminalSetRewrapOnResizeMethodInfo+    ResolveTerminalMethod "setScrollOnKeystroke" o = TerminalSetScrollOnKeystrokeMethodInfo+    ResolveTerminalMethod "setScrollOnOutput" o = TerminalSetScrollOnOutputMethodInfo+    ResolveTerminalMethod "setScrollSpeed" o = TerminalSetScrollSpeedMethodInfo+    ResolveTerminalMethod "setScrollbackLines" o = TerminalSetScrollbackLinesMethodInfo+    ResolveTerminalMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveTerminalMethod "setSize" o = TerminalSetSizeMethodInfo+    ResolveTerminalMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveTerminalMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveTerminalMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveTerminalMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveTerminalMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveTerminalMethod "setTextBlinkMode" o = TerminalSetTextBlinkModeMethodInfo+    ResolveTerminalMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveTerminalMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveTerminalMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveTerminalMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo+    ResolveTerminalMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveTerminalMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveTerminalMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveTerminalMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveTerminalMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveTerminalMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo+    ResolveTerminalMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveTerminalMethod "setWordCharExceptions" o = TerminalSetWordCharExceptionsMethodInfo+    ResolveTerminalMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveTerminalMethod t Terminal, O.MethodInfo info Terminal p) => OL.IsLabel t (Terminal -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- signal Terminal::bell+{- |+This signal is emitted when the a child sends a bell request to the+terminal.+-}+type TerminalBellCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalBellCallback`@.+noTerminalBellCallback :: Maybe TerminalBellCallback+noTerminalBellCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalBellCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalBellCallback`.+foreign import ccall "wrapper"+    mk_TerminalBellCallback :: C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalBell :: MonadIO m => TerminalBellCallback -> m (GClosure C_TerminalBellCallback)+genClosure_TerminalBell cb = liftIO $ do+    let cb' = wrap_TerminalBellCallback cb+    mk_TerminalBellCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalBellCallback` into a `C_TerminalBellCallback`.+wrap_TerminalBellCallback ::+    TerminalBellCallback ->+    C_TerminalBellCallback+wrap_TerminalBellCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@bell@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #bell callback+@+-}+onTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId+onTerminalBell obj cb = liftIO $ do+    let cb' = wrap_TerminalBellCallback cb+    cb'' <- mk_TerminalBellCallback cb'+    connectSignalFunPtr obj "bell" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@bell@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #bell callback+@+-}+afterTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId+afterTerminalBell obj cb = liftIO $ do+    let cb' = wrap_TerminalBellCallback cb+    cb'' <- mk_TerminalBellCallback cb'+    connectSignalFunPtr obj "bell" cb'' SignalConnectAfter+++-- signal Terminal::char-size-changed+{- |+Emitted whenever the cell size changes, e.g. due to a change in+font, font-scale or cell-width\/height-scale.++Note that this signal should rather be called \"cell-size-changed\".+-}+type TerminalCharSizeChangedCallback =+    Word32+    {- ^ /@width@/: the new character cell width -}+    -> Word32+    {- ^ /@height@/: the new character cell height -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCharSizeChangedCallback`@.+noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback+noTerminalCharSizeChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCharSizeChangedCallback =+    Ptr () ->                               -- object+    Word32 ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCharSizeChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalCharSizeChangedCallback :: C_TerminalCharSizeChangedCallback -> IO (FunPtr C_TerminalCharSizeChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCharSizeChanged :: MonadIO m => TerminalCharSizeChangedCallback -> m (GClosure C_TerminalCharSizeChangedCallback)+genClosure_TerminalCharSizeChanged cb = liftIO $ do+    let cb' = wrap_TerminalCharSizeChangedCallback cb+    mk_TerminalCharSizeChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCharSizeChangedCallback` into a `C_TerminalCharSizeChangedCallback`.+wrap_TerminalCharSizeChangedCallback ::+    TerminalCharSizeChangedCallback ->+    C_TerminalCharSizeChangedCallback+wrap_TerminalCharSizeChangedCallback _cb _ width height _ = do+    _cb  width height+++{- |+Connect a signal handler for the “@char-size-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #charSizeChanged callback+@+-}+onTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId+onTerminalCharSizeChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCharSizeChangedCallback cb+    cb'' <- mk_TerminalCharSizeChangedCallback cb'+    connectSignalFunPtr obj "char-size-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@char-size-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #charSizeChanged callback+@+-}+afterTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId+afterTerminalCharSizeChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCharSizeChangedCallback cb+    cb'' <- mk_TerminalCharSizeChangedCallback cb'+    connectSignalFunPtr obj "char-size-changed" cb'' SignalConnectAfter+++-- signal Terminal::child-exited+{- |+This signal is emitted when the terminal detects that a child+watched using 'GI.Vte.Objects.Terminal.terminalWatchChild' has exited.+-}+type TerminalChildExitedCallback =+    Int32+    {- ^ /@status@/: the child\'s exit status -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalChildExitedCallback`@.+noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback+noTerminalChildExitedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalChildExitedCallback =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalChildExitedCallback`.+foreign import ccall "wrapper"+    mk_TerminalChildExitedCallback :: C_TerminalChildExitedCallback -> IO (FunPtr C_TerminalChildExitedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalChildExited :: MonadIO m => TerminalChildExitedCallback -> m (GClosure C_TerminalChildExitedCallback)+genClosure_TerminalChildExited cb = liftIO $ do+    let cb' = wrap_TerminalChildExitedCallback cb+    mk_TerminalChildExitedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalChildExitedCallback` into a `C_TerminalChildExitedCallback`.+wrap_TerminalChildExitedCallback ::+    TerminalChildExitedCallback ->+    C_TerminalChildExitedCallback+wrap_TerminalChildExitedCallback _cb _ status _ = do+    _cb  status+++{- |+Connect a signal handler for the “@child-exited@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #childExited callback+@+-}+onTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId+onTerminalChildExited obj cb = liftIO $ do+    let cb' = wrap_TerminalChildExitedCallback cb+    cb'' <- mk_TerminalChildExitedCallback cb'+    connectSignalFunPtr obj "child-exited" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@child-exited@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #childExited callback+@+-}+afterTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId+afterTerminalChildExited obj cb = liftIO $ do+    let cb' = wrap_TerminalChildExitedCallback cb+    cb'' <- mk_TerminalChildExitedCallback cb'+    connectSignalFunPtr obj "child-exited" cb'' SignalConnectAfter+++-- signal Terminal::commit+{- |+Emitted whenever the terminal receives input from the user and+prepares to send it to the child process.  The signal is emitted even+when there is no child process.+-}+type TerminalCommitCallback =+    T.Text+    {- ^ /@text@/: a string of text -}+    -> Word32+    {- ^ /@size@/: the length of that string of text -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCommitCallback`@.+noTerminalCommitCallback :: Maybe TerminalCommitCallback+noTerminalCommitCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCommitCallback =+    Ptr () ->                               -- object+    CString ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCommitCallback`.+foreign import ccall "wrapper"+    mk_TerminalCommitCallback :: C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCommit :: MonadIO m => TerminalCommitCallback -> m (GClosure C_TerminalCommitCallback)+genClosure_TerminalCommit cb = liftIO $ do+    let cb' = wrap_TerminalCommitCallback cb+    mk_TerminalCommitCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCommitCallback` into a `C_TerminalCommitCallback`.+wrap_TerminalCommitCallback ::+    TerminalCommitCallback ->+    C_TerminalCommitCallback+wrap_TerminalCommitCallback _cb _ text size _ = do+    text' <- cstringToText text+    _cb  text' size+++{- |+Connect a signal handler for the “@commit@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #commit callback+@+-}+onTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId+onTerminalCommit obj cb = liftIO $ do+    let cb' = wrap_TerminalCommitCallback cb+    cb'' <- mk_TerminalCommitCallback cb'+    connectSignalFunPtr obj "commit" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@commit@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #commit callback+@+-}+afterTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId+afterTerminalCommit obj cb = liftIO $ do+    let cb' = wrap_TerminalCommitCallback cb+    cb'' <- mk_TerminalCommitCallback cb'+    connectSignalFunPtr obj "commit" cb'' SignalConnectAfter+++-- signal Terminal::contents-changed+{- |+Emitted whenever the visible appearance of the terminal has changed.+Used primarily by @/VteTerminalAccessible/@.+-}+type TerminalContentsChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalContentsChangedCallback`@.+noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback+noTerminalContentsChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalContentsChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalContentsChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalContentsChangedCallback :: C_TerminalContentsChangedCallback -> IO (FunPtr C_TerminalContentsChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalContentsChanged :: MonadIO m => TerminalContentsChangedCallback -> m (GClosure C_TerminalContentsChangedCallback)+genClosure_TerminalContentsChanged cb = liftIO $ do+    let cb' = wrap_TerminalContentsChangedCallback cb+    mk_TerminalContentsChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalContentsChangedCallback` into a `C_TerminalContentsChangedCallback`.+wrap_TerminalContentsChangedCallback ::+    TerminalContentsChangedCallback ->+    C_TerminalContentsChangedCallback+wrap_TerminalContentsChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@contents-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #contentsChanged callback+@+-}+onTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId+onTerminalContentsChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalContentsChangedCallback cb+    cb'' <- mk_TerminalContentsChangedCallback cb'+    connectSignalFunPtr obj "contents-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@contents-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #contentsChanged callback+@+-}+afterTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId+afterTerminalContentsChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalContentsChangedCallback cb+    cb'' <- mk_TerminalContentsChangedCallback cb'+    connectSignalFunPtr obj "contents-changed" cb'' SignalConnectAfter+++-- signal Terminal::copy-clipboard+{- |+Emitted whenever 'GI.Vte.Objects.Terminal.terminalCopyClipboard' is called.+-}+type TerminalCopyClipboardCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCopyClipboardCallback`@.+noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback+noTerminalCopyClipboardCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCopyClipboardCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCopyClipboardCallback`.+foreign import ccall "wrapper"+    mk_TerminalCopyClipboardCallback :: C_TerminalCopyClipboardCallback -> IO (FunPtr C_TerminalCopyClipboardCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCopyClipboard :: MonadIO m => TerminalCopyClipboardCallback -> m (GClosure C_TerminalCopyClipboardCallback)+genClosure_TerminalCopyClipboard cb = liftIO $ do+    let cb' = wrap_TerminalCopyClipboardCallback cb+    mk_TerminalCopyClipboardCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCopyClipboardCallback` into a `C_TerminalCopyClipboardCallback`.+wrap_TerminalCopyClipboardCallback ::+    TerminalCopyClipboardCallback ->+    C_TerminalCopyClipboardCallback+wrap_TerminalCopyClipboardCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@copy-clipboard@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #copyClipboard callback+@+-}+onTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId+onTerminalCopyClipboard obj cb = liftIO $ do+    let cb' = wrap_TerminalCopyClipboardCallback cb+    cb'' <- mk_TerminalCopyClipboardCallback cb'+    connectSignalFunPtr obj "copy-clipboard" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@copy-clipboard@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #copyClipboard callback+@+-}+afterTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId+afterTerminalCopyClipboard obj cb = liftIO $ do+    let cb' = wrap_TerminalCopyClipboardCallback cb+    cb'' <- mk_TerminalCopyClipboardCallback cb'+    connectSignalFunPtr obj "copy-clipboard" cb'' SignalConnectAfter+++-- signal Terminal::current-directory-uri-changed+{- |+Emitted when the current directory URI is modified.+-}+type TerminalCurrentDirectoryUriChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentDirectoryUriChangedCallback`@.+noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback+noTerminalCurrentDirectoryUriChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCurrentDirectoryUriChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentDirectoryUriChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalCurrentDirectoryUriChangedCallback :: C_TerminalCurrentDirectoryUriChangedCallback -> IO (FunPtr C_TerminalCurrentDirectoryUriChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCurrentDirectoryUriChanged :: MonadIO m => TerminalCurrentDirectoryUriChangedCallback -> m (GClosure C_TerminalCurrentDirectoryUriChangedCallback)+genClosure_TerminalCurrentDirectoryUriChanged cb = liftIO $ do+    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb+    mk_TerminalCurrentDirectoryUriChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCurrentDirectoryUriChangedCallback` into a `C_TerminalCurrentDirectoryUriChangedCallback`.+wrap_TerminalCurrentDirectoryUriChangedCallback ::+    TerminalCurrentDirectoryUriChangedCallback ->+    C_TerminalCurrentDirectoryUriChangedCallback+wrap_TerminalCurrentDirectoryUriChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@current-directory-uri-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #currentDirectoryUriChanged callback+@+-}+onTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId+onTerminalCurrentDirectoryUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb+    cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'+    connectSignalFunPtr obj "current-directory-uri-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@current-directory-uri-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #currentDirectoryUriChanged callback+@+-}+afterTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId+afterTerminalCurrentDirectoryUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb+    cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'+    connectSignalFunPtr obj "current-directory-uri-changed" cb'' SignalConnectAfter+++-- signal Terminal::current-file-uri-changed+{- |+Emitted when the current file URI is modified.+-}+type TerminalCurrentFileUriChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentFileUriChangedCallback`@.+noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback+noTerminalCurrentFileUriChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCurrentFileUriChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentFileUriChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalCurrentFileUriChangedCallback :: C_TerminalCurrentFileUriChangedCallback -> IO (FunPtr C_TerminalCurrentFileUriChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCurrentFileUriChanged :: MonadIO m => TerminalCurrentFileUriChangedCallback -> m (GClosure C_TerminalCurrentFileUriChangedCallback)+genClosure_TerminalCurrentFileUriChanged cb = liftIO $ do+    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb+    mk_TerminalCurrentFileUriChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCurrentFileUriChangedCallback` into a `C_TerminalCurrentFileUriChangedCallback`.+wrap_TerminalCurrentFileUriChangedCallback ::+    TerminalCurrentFileUriChangedCallback ->+    C_TerminalCurrentFileUriChangedCallback+wrap_TerminalCurrentFileUriChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@current-file-uri-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #currentFileUriChanged callback+@+-}+onTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId+onTerminalCurrentFileUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb+    cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'+    connectSignalFunPtr obj "current-file-uri-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@current-file-uri-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #currentFileUriChanged callback+@+-}+afterTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId+afterTerminalCurrentFileUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb+    cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'+    connectSignalFunPtr obj "current-file-uri-changed" cb'' SignalConnectAfter+++-- signal Terminal::cursor-moved+{- |+Emitted whenever the cursor moves to a new character cell.  Used+primarily by @/VteTerminalAccessible/@.+-}+type TerminalCursorMovedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCursorMovedCallback`@.+noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback+noTerminalCursorMovedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalCursorMovedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalCursorMovedCallback`.+foreign import ccall "wrapper"+    mk_TerminalCursorMovedCallback :: C_TerminalCursorMovedCallback -> IO (FunPtr C_TerminalCursorMovedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalCursorMoved :: MonadIO m => TerminalCursorMovedCallback -> m (GClosure C_TerminalCursorMovedCallback)+genClosure_TerminalCursorMoved cb = liftIO $ do+    let cb' = wrap_TerminalCursorMovedCallback cb+    mk_TerminalCursorMovedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalCursorMovedCallback` into a `C_TerminalCursorMovedCallback`.+wrap_TerminalCursorMovedCallback ::+    TerminalCursorMovedCallback ->+    C_TerminalCursorMovedCallback+wrap_TerminalCursorMovedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@cursor-moved@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #cursorMoved callback+@+-}+onTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId+onTerminalCursorMoved obj cb = liftIO $ do+    let cb' = wrap_TerminalCursorMovedCallback cb+    cb'' <- mk_TerminalCursorMovedCallback cb'+    connectSignalFunPtr obj "cursor-moved" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@cursor-moved@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #cursorMoved callback+@+-}+afterTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId+afterTerminalCursorMoved obj cb = liftIO $ do+    let cb' = wrap_TerminalCursorMovedCallback cb+    cb'' <- mk_TerminalCursorMovedCallback cb'+    connectSignalFunPtr obj "cursor-moved" cb'' SignalConnectAfter+++-- signal Terminal::decrease-font-size+{- |+Emitted when the user hits the \'-\' key while holding the Control key.+-}+type TerminalDecreaseFontSizeCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDecreaseFontSizeCallback`@.+noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback+noTerminalDecreaseFontSizeCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalDecreaseFontSizeCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalDecreaseFontSizeCallback`.+foreign import ccall "wrapper"+    mk_TerminalDecreaseFontSizeCallback :: C_TerminalDecreaseFontSizeCallback -> IO (FunPtr C_TerminalDecreaseFontSizeCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalDecreaseFontSize :: MonadIO m => TerminalDecreaseFontSizeCallback -> m (GClosure C_TerminalDecreaseFontSizeCallback)+genClosure_TerminalDecreaseFontSize cb = liftIO $ do+    let cb' = wrap_TerminalDecreaseFontSizeCallback cb+    mk_TerminalDecreaseFontSizeCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalDecreaseFontSizeCallback` into a `C_TerminalDecreaseFontSizeCallback`.+wrap_TerminalDecreaseFontSizeCallback ::+    TerminalDecreaseFontSizeCallback ->+    C_TerminalDecreaseFontSizeCallback+wrap_TerminalDecreaseFontSizeCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@decrease-font-size@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #decreaseFontSize callback+@+-}+onTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId+onTerminalDecreaseFontSize obj cb = liftIO $ do+    let cb' = wrap_TerminalDecreaseFontSizeCallback cb+    cb'' <- mk_TerminalDecreaseFontSizeCallback cb'+    connectSignalFunPtr obj "decrease-font-size" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@decrease-font-size@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #decreaseFontSize callback+@+-}+afterTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId+afterTerminalDecreaseFontSize obj cb = liftIO $ do+    let cb' = wrap_TerminalDecreaseFontSizeCallback cb+    cb'' <- mk_TerminalDecreaseFontSizeCallback cb'+    connectSignalFunPtr obj "decrease-font-size" cb'' SignalConnectAfter+++-- signal Terminal::deiconify-window+{- |+Emitted at the child application\'s request.+-}+type TerminalDeiconifyWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDeiconifyWindowCallback`@.+noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback+noTerminalDeiconifyWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalDeiconifyWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalDeiconifyWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalDeiconifyWindowCallback :: C_TerminalDeiconifyWindowCallback -> IO (FunPtr C_TerminalDeiconifyWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalDeiconifyWindow :: MonadIO m => TerminalDeiconifyWindowCallback -> m (GClosure C_TerminalDeiconifyWindowCallback)+genClosure_TerminalDeiconifyWindow cb = liftIO $ do+    let cb' = wrap_TerminalDeiconifyWindowCallback cb+    mk_TerminalDeiconifyWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalDeiconifyWindowCallback` into a `C_TerminalDeiconifyWindowCallback`.+wrap_TerminalDeiconifyWindowCallback ::+    TerminalDeiconifyWindowCallback ->+    C_TerminalDeiconifyWindowCallback+wrap_TerminalDeiconifyWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@deiconify-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #deiconifyWindow callback+@+-}+onTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId+onTerminalDeiconifyWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalDeiconifyWindowCallback cb+    cb'' <- mk_TerminalDeiconifyWindowCallback cb'+    connectSignalFunPtr obj "deiconify-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@deiconify-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #deiconifyWindow callback+@+-}+afterTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId+afterTerminalDeiconifyWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalDeiconifyWindowCallback cb+    cb'' <- mk_TerminalDeiconifyWindowCallback cb'+    connectSignalFunPtr obj "deiconify-window" cb'' SignalConnectAfter+++-- signal Terminal::encoding-changed+{- |+Emitted whenever the terminal\'s current encoding has changed.++Note: support for non-UTF-8 is deprecated.+-}+type TerminalEncodingChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEncodingChangedCallback`@.+noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback+noTerminalEncodingChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalEncodingChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalEncodingChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalEncodingChangedCallback :: C_TerminalEncodingChangedCallback -> IO (FunPtr C_TerminalEncodingChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalEncodingChanged :: MonadIO m => TerminalEncodingChangedCallback -> m (GClosure C_TerminalEncodingChangedCallback)+genClosure_TerminalEncodingChanged cb = liftIO $ do+    let cb' = wrap_TerminalEncodingChangedCallback cb+    mk_TerminalEncodingChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalEncodingChangedCallback` into a `C_TerminalEncodingChangedCallback`.+wrap_TerminalEncodingChangedCallback ::+    TerminalEncodingChangedCallback ->+    C_TerminalEncodingChangedCallback+wrap_TerminalEncodingChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@encoding-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #encodingChanged callback+@+-}+onTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId+onTerminalEncodingChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalEncodingChangedCallback cb+    cb'' <- mk_TerminalEncodingChangedCallback cb'+    connectSignalFunPtr obj "encoding-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@encoding-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #encodingChanged callback+@+-}+afterTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId+afterTerminalEncodingChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalEncodingChangedCallback cb+    cb'' <- mk_TerminalEncodingChangedCallback cb'+    connectSignalFunPtr obj "encoding-changed" cb'' SignalConnectAfter+++-- signal Terminal::eof+{- |+Emitted when the terminal receives an end-of-file from a child which+is running in the terminal.  This signal is frequently (but not+always) emitted with a 'GI.Vte.Objects.Terminal.Terminal'::@/child-exited/@ signal.+-}+type TerminalEofCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEofCallback`@.+noTerminalEofCallback :: Maybe TerminalEofCallback+noTerminalEofCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalEofCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalEofCallback`.+foreign import ccall "wrapper"+    mk_TerminalEofCallback :: C_TerminalEofCallback -> IO (FunPtr C_TerminalEofCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalEof :: MonadIO m => TerminalEofCallback -> m (GClosure C_TerminalEofCallback)+genClosure_TerminalEof cb = liftIO $ do+    let cb' = wrap_TerminalEofCallback cb+    mk_TerminalEofCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalEofCallback` into a `C_TerminalEofCallback`.+wrap_TerminalEofCallback ::+    TerminalEofCallback ->+    C_TerminalEofCallback+wrap_TerminalEofCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@eof@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #eof callback+@+-}+onTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId+onTerminalEof obj cb = liftIO $ do+    let cb' = wrap_TerminalEofCallback cb+    cb'' <- mk_TerminalEofCallback cb'+    connectSignalFunPtr obj "eof" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@eof@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #eof callback+@+-}+afterTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId+afterTerminalEof obj cb = liftIO $ do+    let cb' = wrap_TerminalEofCallback cb+    cb'' <- mk_TerminalEofCallback cb'+    connectSignalFunPtr obj "eof" cb'' SignalConnectAfter+++-- signal Terminal::hyperlink-hover-uri-changed+{- |+Emitted when the hovered hyperlink changes.++/@uri@/ and /@bbox@/ are owned by VTE, must not be modified, and might+change after the signal handlers returns.++The signal is not re-emitted when the bounding box changes for the+same hyperlink. This might change in a future VTE version without notice.++/Since: 0.50/+-}+type TerminalHyperlinkHoverUriChangedCallback =+    T.Text+    {- ^ /@uri@/: the nonempty target URI under the mouse, or NULL -}+    -> Gdk.Rectangle.Rectangle+    {- ^ /@bbox@/: the bounding box of the hyperlink anchor text, or NULL -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalHyperlinkHoverUriChangedCallback`@.+noTerminalHyperlinkHoverUriChangedCallback :: Maybe TerminalHyperlinkHoverUriChangedCallback+noTerminalHyperlinkHoverUriChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalHyperlinkHoverUriChangedCallback =+    Ptr () ->                               -- object+    CString ->+    Ptr Gdk.Rectangle.Rectangle ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalHyperlinkHoverUriChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalHyperlinkHoverUriChangedCallback :: C_TerminalHyperlinkHoverUriChangedCallback -> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalHyperlinkHoverUriChanged :: MonadIO m => TerminalHyperlinkHoverUriChangedCallback -> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)+genClosure_TerminalHyperlinkHoverUriChanged cb = liftIO $ do+    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb+    mk_TerminalHyperlinkHoverUriChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalHyperlinkHoverUriChangedCallback` into a `C_TerminalHyperlinkHoverUriChangedCallback`.+wrap_TerminalHyperlinkHoverUriChangedCallback ::+    TerminalHyperlinkHoverUriChangedCallback ->+    C_TerminalHyperlinkHoverUriChangedCallback+wrap_TerminalHyperlinkHoverUriChangedCallback _cb _ uri bbox _ = do+    uri' <- cstringToText uri+    B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle bbox $ \bbox' -> do+        _cb  uri' bbox'+++{- |+Connect a signal handler for the “@hyperlink-hover-uri-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #hyperlinkHoverUriChanged callback+@+-}+onTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId+onTerminalHyperlinkHoverUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb+    cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'+    connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@hyperlink-hover-uri-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #hyperlinkHoverUriChanged callback+@+-}+afterTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId+afterTerminalHyperlinkHoverUriChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb+    cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'+    connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' SignalConnectAfter+++-- signal Terminal::icon-title-changed+{-# DEPRECATED TerminalIconTitleChangedCallback ["(Since version 0.54)","This signal is never emitted."] #-}+{- |+/No description available in the introspection data./+-}+type TerminalIconTitleChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconTitleChangedCallback`@.+noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback+noTerminalIconTitleChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalIconTitleChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalIconTitleChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalIconTitleChangedCallback :: C_TerminalIconTitleChangedCallback -> IO (FunPtr C_TerminalIconTitleChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalIconTitleChanged :: MonadIO m => TerminalIconTitleChangedCallback -> m (GClosure C_TerminalIconTitleChangedCallback)+genClosure_TerminalIconTitleChanged cb = liftIO $ do+    let cb' = wrap_TerminalIconTitleChangedCallback cb+    mk_TerminalIconTitleChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalIconTitleChangedCallback` into a `C_TerminalIconTitleChangedCallback`.+wrap_TerminalIconTitleChangedCallback ::+    TerminalIconTitleChangedCallback ->+    C_TerminalIconTitleChangedCallback+wrap_TerminalIconTitleChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@icon-title-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #iconTitleChanged callback+@+-}+onTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId+onTerminalIconTitleChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalIconTitleChangedCallback cb+    cb'' <- mk_TerminalIconTitleChangedCallback cb'+    connectSignalFunPtr obj "icon-title-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@icon-title-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #iconTitleChanged callback+@+-}+afterTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId+afterTerminalIconTitleChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalIconTitleChangedCallback cb+    cb'' <- mk_TerminalIconTitleChangedCallback cb'+    connectSignalFunPtr obj "icon-title-changed" cb'' SignalConnectAfter+++-- signal Terminal::iconify-window+{- |+Emitted at the child application\'s request.+-}+type TerminalIconifyWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconifyWindowCallback`@.+noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback+noTerminalIconifyWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalIconifyWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalIconifyWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalIconifyWindowCallback :: C_TerminalIconifyWindowCallback -> IO (FunPtr C_TerminalIconifyWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalIconifyWindow :: MonadIO m => TerminalIconifyWindowCallback -> m (GClosure C_TerminalIconifyWindowCallback)+genClosure_TerminalIconifyWindow cb = liftIO $ do+    let cb' = wrap_TerminalIconifyWindowCallback cb+    mk_TerminalIconifyWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalIconifyWindowCallback` into a `C_TerminalIconifyWindowCallback`.+wrap_TerminalIconifyWindowCallback ::+    TerminalIconifyWindowCallback ->+    C_TerminalIconifyWindowCallback+wrap_TerminalIconifyWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@iconify-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #iconifyWindow callback+@+-}+onTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId+onTerminalIconifyWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalIconifyWindowCallback cb+    cb'' <- mk_TerminalIconifyWindowCallback cb'+    connectSignalFunPtr obj "iconify-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@iconify-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #iconifyWindow callback+@+-}+afterTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId+afterTerminalIconifyWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalIconifyWindowCallback cb+    cb'' <- mk_TerminalIconifyWindowCallback cb'+    connectSignalFunPtr obj "iconify-window" cb'' SignalConnectAfter+++-- signal Terminal::increase-font-size+{- |+Emitted when the user hits the \'+\' key while holding the Control key.+-}+type TerminalIncreaseFontSizeCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIncreaseFontSizeCallback`@.+noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback+noTerminalIncreaseFontSizeCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalIncreaseFontSizeCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalIncreaseFontSizeCallback`.+foreign import ccall "wrapper"+    mk_TerminalIncreaseFontSizeCallback :: C_TerminalIncreaseFontSizeCallback -> IO (FunPtr C_TerminalIncreaseFontSizeCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalIncreaseFontSize :: MonadIO m => TerminalIncreaseFontSizeCallback -> m (GClosure C_TerminalIncreaseFontSizeCallback)+genClosure_TerminalIncreaseFontSize cb = liftIO $ do+    let cb' = wrap_TerminalIncreaseFontSizeCallback cb+    mk_TerminalIncreaseFontSizeCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalIncreaseFontSizeCallback` into a `C_TerminalIncreaseFontSizeCallback`.+wrap_TerminalIncreaseFontSizeCallback ::+    TerminalIncreaseFontSizeCallback ->+    C_TerminalIncreaseFontSizeCallback+wrap_TerminalIncreaseFontSizeCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@increase-font-size@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #increaseFontSize callback+@+-}+onTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId+onTerminalIncreaseFontSize obj cb = liftIO $ do+    let cb' = wrap_TerminalIncreaseFontSizeCallback cb+    cb'' <- mk_TerminalIncreaseFontSizeCallback cb'+    connectSignalFunPtr obj "increase-font-size" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@increase-font-size@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #increaseFontSize callback+@+-}+afterTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId+afterTerminalIncreaseFontSize obj cb = liftIO $ do+    let cb' = wrap_TerminalIncreaseFontSizeCallback cb+    cb'' <- mk_TerminalIncreaseFontSizeCallback cb'+    connectSignalFunPtr obj "increase-font-size" cb'' SignalConnectAfter+++-- signal Terminal::lower-window+{- |+Emitted at the child application\'s request.+-}+type TerminalLowerWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalLowerWindowCallback`@.+noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback+noTerminalLowerWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalLowerWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalLowerWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalLowerWindowCallback :: C_TerminalLowerWindowCallback -> IO (FunPtr C_TerminalLowerWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalLowerWindow :: MonadIO m => TerminalLowerWindowCallback -> m (GClosure C_TerminalLowerWindowCallback)+genClosure_TerminalLowerWindow cb = liftIO $ do+    let cb' = wrap_TerminalLowerWindowCallback cb+    mk_TerminalLowerWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalLowerWindowCallback` into a `C_TerminalLowerWindowCallback`.+wrap_TerminalLowerWindowCallback ::+    TerminalLowerWindowCallback ->+    C_TerminalLowerWindowCallback+wrap_TerminalLowerWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@lower-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #lowerWindow callback+@+-}+onTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId+onTerminalLowerWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalLowerWindowCallback cb+    cb'' <- mk_TerminalLowerWindowCallback cb'+    connectSignalFunPtr obj "lower-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@lower-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #lowerWindow callback+@+-}+afterTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId+afterTerminalLowerWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalLowerWindowCallback cb+    cb'' <- mk_TerminalLowerWindowCallback cb'+    connectSignalFunPtr obj "lower-window" cb'' SignalConnectAfter+++-- signal Terminal::maximize-window+{- |+Emitted at the child application\'s request.+-}+type TerminalMaximizeWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMaximizeWindowCallback`@.+noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback+noTerminalMaximizeWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalMaximizeWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalMaximizeWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalMaximizeWindowCallback :: C_TerminalMaximizeWindowCallback -> IO (FunPtr C_TerminalMaximizeWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalMaximizeWindow :: MonadIO m => TerminalMaximizeWindowCallback -> m (GClosure C_TerminalMaximizeWindowCallback)+genClosure_TerminalMaximizeWindow cb = liftIO $ do+    let cb' = wrap_TerminalMaximizeWindowCallback cb+    mk_TerminalMaximizeWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalMaximizeWindowCallback` into a `C_TerminalMaximizeWindowCallback`.+wrap_TerminalMaximizeWindowCallback ::+    TerminalMaximizeWindowCallback ->+    C_TerminalMaximizeWindowCallback+wrap_TerminalMaximizeWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@maximize-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #maximizeWindow callback+@+-}+onTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId+onTerminalMaximizeWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalMaximizeWindowCallback cb+    cb'' <- mk_TerminalMaximizeWindowCallback cb'+    connectSignalFunPtr obj "maximize-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@maximize-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #maximizeWindow callback+@+-}+afterTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId+afterTerminalMaximizeWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalMaximizeWindowCallback cb+    cb'' <- mk_TerminalMaximizeWindowCallback cb'+    connectSignalFunPtr obj "maximize-window" cb'' SignalConnectAfter+++-- signal Terminal::move-window+{- |+Emitted at the child application\'s request.+-}+type TerminalMoveWindowCallback =+    Word32+    {- ^ /@x@/: the terminal\'s desired location, X coordinate -}+    -> Word32+    {- ^ /@y@/: the terminal\'s desired location, Y coordinate -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMoveWindowCallback`@.+noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback+noTerminalMoveWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalMoveWindowCallback =+    Ptr () ->                               -- object+    Word32 ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalMoveWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalMoveWindowCallback :: C_TerminalMoveWindowCallback -> IO (FunPtr C_TerminalMoveWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalMoveWindow :: MonadIO m => TerminalMoveWindowCallback -> m (GClosure C_TerminalMoveWindowCallback)+genClosure_TerminalMoveWindow cb = liftIO $ do+    let cb' = wrap_TerminalMoveWindowCallback cb+    mk_TerminalMoveWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalMoveWindowCallback` into a `C_TerminalMoveWindowCallback`.+wrap_TerminalMoveWindowCallback ::+    TerminalMoveWindowCallback ->+    C_TerminalMoveWindowCallback+wrap_TerminalMoveWindowCallback _cb _ x y _ = do+    _cb  x y+++{- |+Connect a signal handler for the “@move-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #moveWindow callback+@+-}+onTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId+onTerminalMoveWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalMoveWindowCallback cb+    cb'' <- mk_TerminalMoveWindowCallback cb'+    connectSignalFunPtr obj "move-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@move-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #moveWindow callback+@+-}+afterTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId+afterTerminalMoveWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalMoveWindowCallback cb+    cb'' <- mk_TerminalMoveWindowCallback cb'+    connectSignalFunPtr obj "move-window" cb'' SignalConnectAfter+++-- signal Terminal::notification-received+{- |+Emitted when a process running in the terminal wants to+send a notification to the desktop environment.+-}+type TerminalNotificationReceivedCallback =+    T.Text+    {- ^ /@summary@/: The summary -}+    -> Maybe T.Text+    {- ^ /@body@/: Extra optional text -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalNotificationReceivedCallback`@.+noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback+noTerminalNotificationReceivedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalNotificationReceivedCallback =+    Ptr () ->                               -- object+    CString ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalNotificationReceivedCallback`.+foreign import ccall "wrapper"+    mk_TerminalNotificationReceivedCallback :: C_TerminalNotificationReceivedCallback -> IO (FunPtr C_TerminalNotificationReceivedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalNotificationReceived :: MonadIO m => TerminalNotificationReceivedCallback -> m (GClosure C_TerminalNotificationReceivedCallback)+genClosure_TerminalNotificationReceived cb = liftIO $ do+    let cb' = wrap_TerminalNotificationReceivedCallback cb+    mk_TerminalNotificationReceivedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalNotificationReceivedCallback` into a `C_TerminalNotificationReceivedCallback`.+wrap_TerminalNotificationReceivedCallback ::+    TerminalNotificationReceivedCallback ->+    C_TerminalNotificationReceivedCallback+wrap_TerminalNotificationReceivedCallback _cb _ summary body _ = do+    summary' <- cstringToText summary+    maybeBody <-+        if body == nullPtr+        then return Nothing+        else do+            body' <- cstringToText body+            return $ Just body'+    _cb  summary' maybeBody+++{- |+Connect a signal handler for the “@notification-received@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #notificationReceived callback+@+-}+onTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId+onTerminalNotificationReceived obj cb = liftIO $ do+    let cb' = wrap_TerminalNotificationReceivedCallback cb+    cb'' <- mk_TerminalNotificationReceivedCallback cb'+    connectSignalFunPtr obj "notification-received" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@notification-received@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #notificationReceived callback+@+-}+afterTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId+afterTerminalNotificationReceived obj cb = liftIO $ do+    let cb' = wrap_TerminalNotificationReceivedCallback cb+    cb'' <- mk_TerminalNotificationReceivedCallback cb'+    connectSignalFunPtr obj "notification-received" cb'' SignalConnectAfter+++-- signal Terminal::paste-clipboard+{- |+Emitted whenever 'GI.Vte.Objects.Terminal.terminalPasteClipboard' is called.+-}+type TerminalPasteClipboardCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalPasteClipboardCallback`@.+noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback+noTerminalPasteClipboardCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalPasteClipboardCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalPasteClipboardCallback`.+foreign import ccall "wrapper"+    mk_TerminalPasteClipboardCallback :: C_TerminalPasteClipboardCallback -> IO (FunPtr C_TerminalPasteClipboardCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalPasteClipboard :: MonadIO m => TerminalPasteClipboardCallback -> m (GClosure C_TerminalPasteClipboardCallback)+genClosure_TerminalPasteClipboard cb = liftIO $ do+    let cb' = wrap_TerminalPasteClipboardCallback cb+    mk_TerminalPasteClipboardCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalPasteClipboardCallback` into a `C_TerminalPasteClipboardCallback`.+wrap_TerminalPasteClipboardCallback ::+    TerminalPasteClipboardCallback ->+    C_TerminalPasteClipboardCallback+wrap_TerminalPasteClipboardCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@paste-clipboard@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #pasteClipboard callback+@+-}+onTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId+onTerminalPasteClipboard obj cb = liftIO $ do+    let cb' = wrap_TerminalPasteClipboardCallback cb+    cb'' <- mk_TerminalPasteClipboardCallback cb'+    connectSignalFunPtr obj "paste-clipboard" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@paste-clipboard@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #pasteClipboard callback+@+-}+afterTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId+afterTerminalPasteClipboard obj cb = liftIO $ do+    let cb' = wrap_TerminalPasteClipboardCallback cb+    cb'' <- mk_TerminalPasteClipboardCallback cb'+    connectSignalFunPtr obj "paste-clipboard" cb'' SignalConnectAfter+++-- signal Terminal::raise-window+{- |+Emitted at the child application\'s request.+-}+type TerminalRaiseWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRaiseWindowCallback`@.+noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback+noTerminalRaiseWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalRaiseWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalRaiseWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalRaiseWindowCallback :: C_TerminalRaiseWindowCallback -> IO (FunPtr C_TerminalRaiseWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalRaiseWindow :: MonadIO m => TerminalRaiseWindowCallback -> m (GClosure C_TerminalRaiseWindowCallback)+genClosure_TerminalRaiseWindow cb = liftIO $ do+    let cb' = wrap_TerminalRaiseWindowCallback cb+    mk_TerminalRaiseWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalRaiseWindowCallback` into a `C_TerminalRaiseWindowCallback`.+wrap_TerminalRaiseWindowCallback ::+    TerminalRaiseWindowCallback ->+    C_TerminalRaiseWindowCallback+wrap_TerminalRaiseWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@raise-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #raiseWindow callback+@+-}+onTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId+onTerminalRaiseWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRaiseWindowCallback cb+    cb'' <- mk_TerminalRaiseWindowCallback cb'+    connectSignalFunPtr obj "raise-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@raise-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #raiseWindow callback+@+-}+afterTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId+afterTerminalRaiseWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRaiseWindowCallback cb+    cb'' <- mk_TerminalRaiseWindowCallback cb'+    connectSignalFunPtr obj "raise-window" cb'' SignalConnectAfter+++-- signal Terminal::refresh-window+{- |+Emitted at the child application\'s request.+-}+type TerminalRefreshWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRefreshWindowCallback`@.+noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback+noTerminalRefreshWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalRefreshWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalRefreshWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalRefreshWindowCallback :: C_TerminalRefreshWindowCallback -> IO (FunPtr C_TerminalRefreshWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalRefreshWindow :: MonadIO m => TerminalRefreshWindowCallback -> m (GClosure C_TerminalRefreshWindowCallback)+genClosure_TerminalRefreshWindow cb = liftIO $ do+    let cb' = wrap_TerminalRefreshWindowCallback cb+    mk_TerminalRefreshWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalRefreshWindowCallback` into a `C_TerminalRefreshWindowCallback`.+wrap_TerminalRefreshWindowCallback ::+    TerminalRefreshWindowCallback ->+    C_TerminalRefreshWindowCallback+wrap_TerminalRefreshWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@refresh-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #refreshWindow callback+@+-}+onTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId+onTerminalRefreshWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRefreshWindowCallback cb+    cb'' <- mk_TerminalRefreshWindowCallback cb'+    connectSignalFunPtr obj "refresh-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@refresh-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #refreshWindow callback+@+-}+afterTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId+afterTerminalRefreshWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRefreshWindowCallback cb+    cb'' <- mk_TerminalRefreshWindowCallback cb'+    connectSignalFunPtr obj "refresh-window" cb'' SignalConnectAfter+++-- signal Terminal::resize-window+{- |+Emitted at the child application\'s request.+-}+type TerminalResizeWindowCallback =+    Word32+    {- ^ /@width@/: the desired number of columns -}+    -> Word32+    {- ^ /@height@/: the desired number of rows -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalResizeWindowCallback`@.+noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback+noTerminalResizeWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalResizeWindowCallback =+    Ptr () ->                               -- object+    Word32 ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalResizeWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalResizeWindowCallback :: C_TerminalResizeWindowCallback -> IO (FunPtr C_TerminalResizeWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalResizeWindow :: MonadIO m => TerminalResizeWindowCallback -> m (GClosure C_TerminalResizeWindowCallback)+genClosure_TerminalResizeWindow cb = liftIO $ do+    let cb' = wrap_TerminalResizeWindowCallback cb+    mk_TerminalResizeWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalResizeWindowCallback` into a `C_TerminalResizeWindowCallback`.+wrap_TerminalResizeWindowCallback ::+    TerminalResizeWindowCallback ->+    C_TerminalResizeWindowCallback+wrap_TerminalResizeWindowCallback _cb _ width height _ = do+    _cb  width height+++{- |+Connect a signal handler for the “@resize-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #resizeWindow callback+@+-}+onTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId+onTerminalResizeWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalResizeWindowCallback cb+    cb'' <- mk_TerminalResizeWindowCallback cb'+    connectSignalFunPtr obj "resize-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@resize-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #resizeWindow callback+@+-}+afterTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId+afterTerminalResizeWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalResizeWindowCallback cb+    cb'' <- mk_TerminalResizeWindowCallback cb'+    connectSignalFunPtr obj "resize-window" cb'' SignalConnectAfter+++-- signal Terminal::restore-window+{- |+Emitted at the child application\'s request.+-}+type TerminalRestoreWindowCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRestoreWindowCallback`@.+noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback+noTerminalRestoreWindowCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalRestoreWindowCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalRestoreWindowCallback`.+foreign import ccall "wrapper"+    mk_TerminalRestoreWindowCallback :: C_TerminalRestoreWindowCallback -> IO (FunPtr C_TerminalRestoreWindowCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalRestoreWindow :: MonadIO m => TerminalRestoreWindowCallback -> m (GClosure C_TerminalRestoreWindowCallback)+genClosure_TerminalRestoreWindow cb = liftIO $ do+    let cb' = wrap_TerminalRestoreWindowCallback cb+    mk_TerminalRestoreWindowCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalRestoreWindowCallback` into a `C_TerminalRestoreWindowCallback`.+wrap_TerminalRestoreWindowCallback ::+    TerminalRestoreWindowCallback ->+    C_TerminalRestoreWindowCallback+wrap_TerminalRestoreWindowCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@restore-window@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #restoreWindow callback+@+-}+onTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId+onTerminalRestoreWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRestoreWindowCallback cb+    cb'' <- mk_TerminalRestoreWindowCallback cb'+    connectSignalFunPtr obj "restore-window" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@restore-window@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #restoreWindow callback+@+-}+afterTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId+afterTerminalRestoreWindow obj cb = liftIO $ do+    let cb' = wrap_TerminalRestoreWindowCallback cb+    cb'' <- mk_TerminalRestoreWindowCallback cb'+    connectSignalFunPtr obj "restore-window" cb'' SignalConnectAfter+++-- signal Terminal::selection-changed+{- |+Emitted whenever the contents of terminal\'s selection changes.+-}+type TerminalSelectionChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalSelectionChangedCallback`@.+noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback+noTerminalSelectionChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalSelectionChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalSelectionChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalSelectionChangedCallback :: C_TerminalSelectionChangedCallback -> IO (FunPtr C_TerminalSelectionChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalSelectionChanged :: MonadIO m => TerminalSelectionChangedCallback -> m (GClosure C_TerminalSelectionChangedCallback)+genClosure_TerminalSelectionChanged cb = liftIO $ do+    let cb' = wrap_TerminalSelectionChangedCallback cb+    mk_TerminalSelectionChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalSelectionChangedCallback` into a `C_TerminalSelectionChangedCallback`.+wrap_TerminalSelectionChangedCallback ::+    TerminalSelectionChangedCallback ->+    C_TerminalSelectionChangedCallback+wrap_TerminalSelectionChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@selection-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #selectionChanged callback+@+-}+onTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId+onTerminalSelectionChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalSelectionChangedCallback cb+    cb'' <- mk_TerminalSelectionChangedCallback cb'+    connectSignalFunPtr obj "selection-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@selection-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #selectionChanged callback+@+-}+afterTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId+afterTerminalSelectionChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalSelectionChangedCallback cb+    cb'' <- mk_TerminalSelectionChangedCallback cb'+    connectSignalFunPtr obj "selection-changed" cb'' SignalConnectAfter+++-- signal Terminal::text-deleted+{- |+An internal signal used for communication between the terminal and+its accessibility peer. May not be emitted under certain+circumstances.+-}+type TerminalTextDeletedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextDeletedCallback`@.+noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback+noTerminalTextDeletedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalTextDeletedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalTextDeletedCallback`.+foreign import ccall "wrapper"+    mk_TerminalTextDeletedCallback :: C_TerminalTextDeletedCallback -> IO (FunPtr C_TerminalTextDeletedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalTextDeleted :: MonadIO m => TerminalTextDeletedCallback -> m (GClosure C_TerminalTextDeletedCallback)+genClosure_TerminalTextDeleted cb = liftIO $ do+    let cb' = wrap_TerminalTextDeletedCallback cb+    mk_TerminalTextDeletedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalTextDeletedCallback` into a `C_TerminalTextDeletedCallback`.+wrap_TerminalTextDeletedCallback ::+    TerminalTextDeletedCallback ->+    C_TerminalTextDeletedCallback+wrap_TerminalTextDeletedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@text-deleted@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #textDeleted callback+@+-}+onTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId+onTerminalTextDeleted obj cb = liftIO $ do+    let cb' = wrap_TerminalTextDeletedCallback cb+    cb'' <- mk_TerminalTextDeletedCallback cb'+    connectSignalFunPtr obj "text-deleted" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@text-deleted@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #textDeleted callback+@+-}+afterTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId+afterTerminalTextDeleted obj cb = liftIO $ do+    let cb' = wrap_TerminalTextDeletedCallback cb+    cb'' <- mk_TerminalTextDeletedCallback cb'+    connectSignalFunPtr obj "text-deleted" cb'' SignalConnectAfter+++-- signal Terminal::text-inserted+{- |+An internal signal used for communication between the terminal and+its accessibility peer. May not be emitted under certain+circumstances.+-}+type TerminalTextInsertedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextInsertedCallback`@.+noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback+noTerminalTextInsertedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalTextInsertedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalTextInsertedCallback`.+foreign import ccall "wrapper"+    mk_TerminalTextInsertedCallback :: C_TerminalTextInsertedCallback -> IO (FunPtr C_TerminalTextInsertedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalTextInserted :: MonadIO m => TerminalTextInsertedCallback -> m (GClosure C_TerminalTextInsertedCallback)+genClosure_TerminalTextInserted cb = liftIO $ do+    let cb' = wrap_TerminalTextInsertedCallback cb+    mk_TerminalTextInsertedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalTextInsertedCallback` into a `C_TerminalTextInsertedCallback`.+wrap_TerminalTextInsertedCallback ::+    TerminalTextInsertedCallback ->+    C_TerminalTextInsertedCallback+wrap_TerminalTextInsertedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@text-inserted@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #textInserted callback+@+-}+onTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId+onTerminalTextInserted obj cb = liftIO $ do+    let cb' = wrap_TerminalTextInsertedCallback cb+    cb'' <- mk_TerminalTextInsertedCallback cb'+    connectSignalFunPtr obj "text-inserted" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@text-inserted@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #textInserted callback+@+-}+afterTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId+afterTerminalTextInserted obj cb = liftIO $ do+    let cb' = wrap_TerminalTextInsertedCallback cb+    cb'' <- mk_TerminalTextInsertedCallback cb'+    connectSignalFunPtr obj "text-inserted" cb'' SignalConnectAfter+++-- signal Terminal::text-modified+{- |+An internal signal used for communication between the terminal and+its accessibility peer. May not be emitted under certain+circumstances.+-}+type TerminalTextModifiedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextModifiedCallback`@.+noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback+noTerminalTextModifiedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalTextModifiedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalTextModifiedCallback`.+foreign import ccall "wrapper"+    mk_TerminalTextModifiedCallback :: C_TerminalTextModifiedCallback -> IO (FunPtr C_TerminalTextModifiedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalTextModified :: MonadIO m => TerminalTextModifiedCallback -> m (GClosure C_TerminalTextModifiedCallback)+genClosure_TerminalTextModified cb = liftIO $ do+    let cb' = wrap_TerminalTextModifiedCallback cb+    mk_TerminalTextModifiedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalTextModifiedCallback` into a `C_TerminalTextModifiedCallback`.+wrap_TerminalTextModifiedCallback ::+    TerminalTextModifiedCallback ->+    C_TerminalTextModifiedCallback+wrap_TerminalTextModifiedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@text-modified@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #textModified callback+@+-}+onTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId+onTerminalTextModified obj cb = liftIO $ do+    let cb' = wrap_TerminalTextModifiedCallback cb+    cb'' <- mk_TerminalTextModifiedCallback cb'+    connectSignalFunPtr obj "text-modified" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@text-modified@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #textModified callback+@+-}+afterTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId+afterTerminalTextModified obj cb = liftIO $ do+    let cb' = wrap_TerminalTextModifiedCallback cb+    cb'' <- mk_TerminalTextModifiedCallback cb'+    connectSignalFunPtr obj "text-modified" cb'' SignalConnectAfter+++-- signal Terminal::text-scrolled+{- |+An internal signal used for communication between the terminal and+its accessibility peer. May not be emitted under certain+circumstances.+-}+type TerminalTextScrolledCallback =+    Int32+    {- ^ /@delta@/: the number of lines scrolled -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextScrolledCallback`@.+noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback+noTerminalTextScrolledCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalTextScrolledCallback =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalTextScrolledCallback`.+foreign import ccall "wrapper"+    mk_TerminalTextScrolledCallback :: C_TerminalTextScrolledCallback -> IO (FunPtr C_TerminalTextScrolledCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalTextScrolled :: MonadIO m => TerminalTextScrolledCallback -> m (GClosure C_TerminalTextScrolledCallback)+genClosure_TerminalTextScrolled cb = liftIO $ do+    let cb' = wrap_TerminalTextScrolledCallback cb+    mk_TerminalTextScrolledCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalTextScrolledCallback` into a `C_TerminalTextScrolledCallback`.+wrap_TerminalTextScrolledCallback ::+    TerminalTextScrolledCallback ->+    C_TerminalTextScrolledCallback+wrap_TerminalTextScrolledCallback _cb _ delta _ = do+    _cb  delta+++{- |+Connect a signal handler for the “@text-scrolled@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #textScrolled callback+@+-}+onTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId+onTerminalTextScrolled obj cb = liftIO $ do+    let cb' = wrap_TerminalTextScrolledCallback cb+    cb'' <- mk_TerminalTextScrolledCallback cb'+    connectSignalFunPtr obj "text-scrolled" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@text-scrolled@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #textScrolled callback+@+-}+afterTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId+afterTerminalTextScrolled obj cb = liftIO $ do+    let cb' = wrap_TerminalTextScrolledCallback cb+    cb'' <- mk_TerminalTextScrolledCallback cb'+    connectSignalFunPtr obj "text-scrolled" cb'' SignalConnectAfter+++-- signal Terminal::window-title-changed+{- |+Emitted when the terminal\'s @/window_title/@ field is modified.+-}+type TerminalWindowTitleChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalWindowTitleChangedCallback`@.+noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback+noTerminalWindowTitleChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_TerminalWindowTitleChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_TerminalWindowTitleChangedCallback`.+foreign import ccall "wrapper"+    mk_TerminalWindowTitleChangedCallback :: C_TerminalWindowTitleChangedCallback -> IO (FunPtr C_TerminalWindowTitleChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_TerminalWindowTitleChanged :: MonadIO m => TerminalWindowTitleChangedCallback -> m (GClosure C_TerminalWindowTitleChangedCallback)+genClosure_TerminalWindowTitleChanged cb = liftIO $ do+    let cb' = wrap_TerminalWindowTitleChangedCallback cb+    mk_TerminalWindowTitleChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `TerminalWindowTitleChangedCallback` into a `C_TerminalWindowTitleChangedCallback`.+wrap_TerminalWindowTitleChangedCallback ::+    TerminalWindowTitleChangedCallback ->+    C_TerminalWindowTitleChangedCallback+wrap_TerminalWindowTitleChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@window-title-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' terminal #windowTitleChanged callback+@+-}+onTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId+onTerminalWindowTitleChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalWindowTitleChangedCallback cb+    cb'' <- mk_TerminalWindowTitleChangedCallback cb'+    connectSignalFunPtr obj "window-title-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@window-title-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' terminal #windowTitleChanged callback+@+-}+afterTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId+afterTerminalWindowTitleChanged obj cb = liftIO $ do+    let cb' = wrap_TerminalWindowTitleChangedCallback cb+    cb'' <- mk_TerminalWindowTitleChangedCallback cb'+    connectSignalFunPtr obj "window-title-changed" cb'' SignalConnectAfter+++-- VVV Prop "allow-bold"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@allow-bold@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #allowBold+@+-}+getTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalAllowBold obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-bold"++{- |+Set the value of the “@allow-bold@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #allowBold 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalAllowBold obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-bold" val++{- |+Construct a `GValueConstruct` with valid value for the “@allow-bold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalAllowBold :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalAllowBold val = B.Properties.constructObjectPropertyBool "allow-bold" val++#if ENABLE_OVERLOADING+data TerminalAllowBoldPropertyInfo+instance AttrInfo TerminalAllowBoldPropertyInfo where+    type AttrAllowedOps TerminalAllowBoldPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalAllowBoldPropertyInfo = IsTerminal+    type AttrGetType TerminalAllowBoldPropertyInfo = Bool+    type AttrLabel TerminalAllowBoldPropertyInfo = "allow-bold"+    type AttrOrigin TerminalAllowBoldPropertyInfo = Terminal+    attrGet _ = getTerminalAllowBold+    attrSet _ = setTerminalAllowBold+    attrConstruct _ = constructTerminalAllowBold+    attrClear _ = undefined+#endif++-- VVV Prop "allow-hyperlink"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@allow-hyperlink@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #allowHyperlink+@+-}+getTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalAllowHyperlink obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-hyperlink"++{- |+Set the value of the “@allow-hyperlink@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #allowHyperlink 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalAllowHyperlink obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-hyperlink" val++{- |+Construct a `GValueConstruct` with valid value for the “@allow-hyperlink@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalAllowHyperlink :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalAllowHyperlink val = B.Properties.constructObjectPropertyBool "allow-hyperlink" val++#if ENABLE_OVERLOADING+data TerminalAllowHyperlinkPropertyInfo+instance AttrInfo TerminalAllowHyperlinkPropertyInfo where+    type AttrAllowedOps TerminalAllowHyperlinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalAllowHyperlinkPropertyInfo = IsTerminal+    type AttrGetType TerminalAllowHyperlinkPropertyInfo = Bool+    type AttrLabel TerminalAllowHyperlinkPropertyInfo = "allow-hyperlink"+    type AttrOrigin TerminalAllowHyperlinkPropertyInfo = Terminal+    attrGet _ = getTerminalAllowHyperlink+    attrSet _ = setTerminalAllowHyperlink+    attrConstruct _ = constructTerminalAllowHyperlink+    attrClear _ = undefined+#endif++-- VVV Prop "audible-bell"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@audible-bell@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #audibleBell+@+-}+getTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalAudibleBell obj = liftIO $ B.Properties.getObjectPropertyBool obj "audible-bell"++{- |+Set the value of the “@audible-bell@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #audibleBell 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalAudibleBell obj val = liftIO $ B.Properties.setObjectPropertyBool obj "audible-bell" val++{- |+Construct a `GValueConstruct` with valid value for the “@audible-bell@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalAudibleBell :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalAudibleBell val = B.Properties.constructObjectPropertyBool "audible-bell" val++#if ENABLE_OVERLOADING+data TerminalAudibleBellPropertyInfo+instance AttrInfo TerminalAudibleBellPropertyInfo where+    type AttrAllowedOps TerminalAudibleBellPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalAudibleBellPropertyInfo = IsTerminal+    type AttrGetType TerminalAudibleBellPropertyInfo = Bool+    type AttrLabel TerminalAudibleBellPropertyInfo = "audible-bell"+    type AttrOrigin TerminalAudibleBellPropertyInfo = Terminal+    attrGet _ = getTerminalAudibleBell+    attrSet _ = setTerminalAudibleBell+    attrConstruct _ = constructTerminalAudibleBell+    attrClear _ = undefined+#endif++-- VVV Prop "backspace-binding"+   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Just False)++{- |+Get the value of the “@backspace-binding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #backspaceBinding+@+-}+getTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding+getTerminalBackspaceBinding obj = liftIO $ B.Properties.getObjectPropertyEnum obj "backspace-binding"++{- |+Set the value of the “@backspace-binding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #backspaceBinding 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()+setTerminalBackspaceBinding obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "backspace-binding" val++{- |+Construct a `GValueConstruct` with valid value for the “@backspace-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalBackspaceBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)+constructTerminalBackspaceBinding val = B.Properties.constructObjectPropertyEnum "backspace-binding" val++#if ENABLE_OVERLOADING+data TerminalBackspaceBindingPropertyInfo+instance AttrInfo TerminalBackspaceBindingPropertyInfo where+    type AttrAllowedOps TerminalBackspaceBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding+    type AttrBaseTypeConstraint TerminalBackspaceBindingPropertyInfo = IsTerminal+    type AttrGetType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding+    type AttrLabel TerminalBackspaceBindingPropertyInfo = "backspace-binding"+    type AttrOrigin TerminalBackspaceBindingPropertyInfo = Terminal+    attrGet _ = getTerminalBackspaceBinding+    attrSet _ = setTerminalBackspaceBinding+    attrConstruct _ = constructTerminalBackspaceBinding+    attrClear _ = undefined+#endif++-- VVV Prop "bold-is-bright"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@bold-is-bright@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #boldIsBright+@+-}+getTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalBoldIsBright obj = liftIO $ B.Properties.getObjectPropertyBool obj "bold-is-bright"++{- |+Set the value of the “@bold-is-bright@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #boldIsBright 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalBoldIsBright obj val = liftIO $ B.Properties.setObjectPropertyBool obj "bold-is-bright" val++{- |+Construct a `GValueConstruct` with valid value for the “@bold-is-bright@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalBoldIsBright :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalBoldIsBright val = B.Properties.constructObjectPropertyBool "bold-is-bright" val++#if ENABLE_OVERLOADING+data TerminalBoldIsBrightPropertyInfo+instance AttrInfo TerminalBoldIsBrightPropertyInfo where+    type AttrAllowedOps TerminalBoldIsBrightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalBoldIsBrightPropertyInfo = IsTerminal+    type AttrGetType TerminalBoldIsBrightPropertyInfo = Bool+    type AttrLabel TerminalBoldIsBrightPropertyInfo = "bold-is-bright"+    type AttrOrigin TerminalBoldIsBrightPropertyInfo = Terminal+    attrGet _ = getTerminalBoldIsBright+    attrSet _ = setTerminalBoldIsBright+    attrConstruct _ = constructTerminalBoldIsBright+    attrClear _ = undefined+#endif++-- VVV Prop "cell-height-scale"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cell-height-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #cellHeightScale+@+-}+getTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> m Double+getTerminalCellHeightScale obj = liftIO $ B.Properties.getObjectPropertyDouble obj "cell-height-scale"++{- |+Set the value of the “@cell-height-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #cellHeightScale 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()+setTerminalCellHeightScale obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "cell-height-scale" val++{- |+Construct a `GValueConstruct` with valid value for the “@cell-height-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalCellHeightScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)+constructTerminalCellHeightScale val = B.Properties.constructObjectPropertyDouble "cell-height-scale" val++#if ENABLE_OVERLOADING+data TerminalCellHeightScalePropertyInfo+instance AttrInfo TerminalCellHeightScalePropertyInfo where+    type AttrAllowedOps TerminalCellHeightScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double+    type AttrBaseTypeConstraint TerminalCellHeightScalePropertyInfo = IsTerminal+    type AttrGetType TerminalCellHeightScalePropertyInfo = Double+    type AttrLabel TerminalCellHeightScalePropertyInfo = "cell-height-scale"+    type AttrOrigin TerminalCellHeightScalePropertyInfo = Terminal+    attrGet _ = getTerminalCellHeightScale+    attrSet _ = setTerminalCellHeightScale+    attrConstruct _ = constructTerminalCellHeightScale+    attrClear _ = undefined+#endif++-- VVV Prop "cell-width-scale"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cell-width-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #cellWidthScale+@+-}+getTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> m Double+getTerminalCellWidthScale obj = liftIO $ B.Properties.getObjectPropertyDouble obj "cell-width-scale"++{- |+Set the value of the “@cell-width-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #cellWidthScale 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()+setTerminalCellWidthScale obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "cell-width-scale" val++{- |+Construct a `GValueConstruct` with valid value for the “@cell-width-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalCellWidthScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)+constructTerminalCellWidthScale val = B.Properties.constructObjectPropertyDouble "cell-width-scale" val++#if ENABLE_OVERLOADING+data TerminalCellWidthScalePropertyInfo+instance AttrInfo TerminalCellWidthScalePropertyInfo where+    type AttrAllowedOps TerminalCellWidthScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double+    type AttrBaseTypeConstraint TerminalCellWidthScalePropertyInfo = IsTerminal+    type AttrGetType TerminalCellWidthScalePropertyInfo = Double+    type AttrLabel TerminalCellWidthScalePropertyInfo = "cell-width-scale"+    type AttrOrigin TerminalCellWidthScalePropertyInfo = Terminal+    attrGet _ = getTerminalCellWidthScale+    attrSet _ = setTerminalCellWidthScale+    attrConstruct _ = constructTerminalCellWidthScale+    attrClear _ = undefined+#endif++-- VVV Prop "cjk-ambiguous-width"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cjk-ambiguous-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #cjkAmbiguousWidth+@+-}+getTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> m Int32+getTerminalCjkAmbiguousWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "cjk-ambiguous-width"++{- |+Set the value of the “@cjk-ambiguous-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #cjkAmbiguousWidth 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> Int32 -> m ()+setTerminalCjkAmbiguousWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "cjk-ambiguous-width" val++{- |+Construct a `GValueConstruct` with valid value for the “@cjk-ambiguous-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalCjkAmbiguousWidth :: (IsTerminal o) => Int32 -> IO (GValueConstruct o)+constructTerminalCjkAmbiguousWidth val = B.Properties.constructObjectPropertyInt32 "cjk-ambiguous-width" val++#if ENABLE_OVERLOADING+data TerminalCjkAmbiguousWidthPropertyInfo+instance AttrInfo TerminalCjkAmbiguousWidthPropertyInfo where+    type AttrAllowedOps TerminalCjkAmbiguousWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = IsTerminal+    type AttrGetType TerminalCjkAmbiguousWidthPropertyInfo = Int32+    type AttrLabel TerminalCjkAmbiguousWidthPropertyInfo = "cjk-ambiguous-width"+    type AttrOrigin TerminalCjkAmbiguousWidthPropertyInfo = Terminal+    attrGet _ = getTerminalCjkAmbiguousWidth+    attrSet _ = setTerminalCjkAmbiguousWidth+    attrConstruct _ = constructTerminalCjkAmbiguousWidth+    attrClear _ = undefined+#endif++-- VVV Prop "current-directory-uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Just True,Nothing)++{- |+Get the value of the “@current-directory-uri@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #currentDirectoryUri+@+-}+getTerminalCurrentDirectoryUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalCurrentDirectoryUri obj = liftIO $ B.Properties.getObjectPropertyString obj "current-directory-uri"++#if ENABLE_OVERLOADING+data TerminalCurrentDirectoryUriPropertyInfo+instance AttrInfo TerminalCurrentDirectoryUriPropertyInfo where+    type AttrAllowedOps TerminalCurrentDirectoryUriPropertyInfo = '[ 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = IsTerminal+    type AttrGetType TerminalCurrentDirectoryUriPropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalCurrentDirectoryUriPropertyInfo = "current-directory-uri"+    type AttrOrigin TerminalCurrentDirectoryUriPropertyInfo = Terminal+    attrGet _ = getTerminalCurrentDirectoryUri+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "current-file-uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Just True,Nothing)++{- |+Get the value of the “@current-file-uri@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #currentFileUri+@+-}+getTerminalCurrentFileUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalCurrentFileUri obj = liftIO $ B.Properties.getObjectPropertyString obj "current-file-uri"++#if ENABLE_OVERLOADING+data TerminalCurrentFileUriPropertyInfo+instance AttrInfo TerminalCurrentFileUriPropertyInfo where+    type AttrAllowedOps TerminalCurrentFileUriPropertyInfo = '[ 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalCurrentFileUriPropertyInfo = IsTerminal+    type AttrGetType TerminalCurrentFileUriPropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalCurrentFileUriPropertyInfo = "current-file-uri"+    type AttrOrigin TerminalCurrentFileUriPropertyInfo = Terminal+    attrGet _ = getTerminalCurrentFileUri+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "cursor-blink-mode"+   -- Type: TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cursor-blink-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #cursorBlinkMode+@+-}+getTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorBlinkMode+getTerminalCursorBlinkMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "cursor-blink-mode"++{- |+Set the value of the “@cursor-blink-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #cursorBlinkMode 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorBlinkMode -> m ()+setTerminalCursorBlinkMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "cursor-blink-mode" val++{- |+Construct a `GValueConstruct` with valid value for the “@cursor-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalCursorBlinkMode :: (IsTerminal o) => Vte.Enums.CursorBlinkMode -> IO (GValueConstruct o)+constructTerminalCursorBlinkMode val = B.Properties.constructObjectPropertyEnum "cursor-blink-mode" val++#if ENABLE_OVERLOADING+data TerminalCursorBlinkModePropertyInfo+instance AttrInfo TerminalCursorBlinkModePropertyInfo where+    type AttrAllowedOps TerminalCursorBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode+    type AttrBaseTypeConstraint TerminalCursorBlinkModePropertyInfo = IsTerminal+    type AttrGetType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode+    type AttrLabel TerminalCursorBlinkModePropertyInfo = "cursor-blink-mode"+    type AttrOrigin TerminalCursorBlinkModePropertyInfo = Terminal+    attrGet _ = getTerminalCursorBlinkMode+    attrSet _ = setTerminalCursorBlinkMode+    attrConstruct _ = constructTerminalCursorBlinkMode+    attrClear _ = undefined+#endif++-- VVV Prop "cursor-shape"+   -- Type: TInterface (Name {namespace = "Vte", name = "CursorShape"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cursor-shape@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #cursorShape+@+-}+getTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorShape+getTerminalCursorShape obj = liftIO $ B.Properties.getObjectPropertyEnum obj "cursor-shape"++{- |+Set the value of the “@cursor-shape@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #cursorShape 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorShape -> m ()+setTerminalCursorShape obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "cursor-shape" val++{- |+Construct a `GValueConstruct` with valid value for the “@cursor-shape@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalCursorShape :: (IsTerminal o) => Vte.Enums.CursorShape -> IO (GValueConstruct o)+constructTerminalCursorShape val = B.Properties.constructObjectPropertyEnum "cursor-shape" val++#if ENABLE_OVERLOADING+data TerminalCursorShapePropertyInfo+instance AttrInfo TerminalCursorShapePropertyInfo where+    type AttrAllowedOps TerminalCursorShapePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape+    type AttrBaseTypeConstraint TerminalCursorShapePropertyInfo = IsTerminal+    type AttrGetType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape+    type AttrLabel TerminalCursorShapePropertyInfo = "cursor-shape"+    type AttrOrigin TerminalCursorShapePropertyInfo = Terminal+    attrGet _ = getTerminalCursorShape+    attrSet _ = setTerminalCursorShape+    attrConstruct _ = constructTerminalCursorShape+    attrClear _ = undefined+#endif++-- VVV Prop "delete-binding"+   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Just False)++{- |+Get the value of the “@delete-binding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #deleteBinding+@+-}+getTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding+getTerminalDeleteBinding obj = liftIO $ B.Properties.getObjectPropertyEnum obj "delete-binding"++{- |+Set the value of the “@delete-binding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #deleteBinding 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()+setTerminalDeleteBinding obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "delete-binding" val++{- |+Construct a `GValueConstruct` with valid value for the “@delete-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalDeleteBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)+constructTerminalDeleteBinding val = B.Properties.constructObjectPropertyEnum "delete-binding" val++#if ENABLE_OVERLOADING+data TerminalDeleteBindingPropertyInfo+instance AttrInfo TerminalDeleteBindingPropertyInfo where+    type AttrAllowedOps TerminalDeleteBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding+    type AttrBaseTypeConstraint TerminalDeleteBindingPropertyInfo = IsTerminal+    type AttrGetType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding+    type AttrLabel TerminalDeleteBindingPropertyInfo = "delete-binding"+    type AttrOrigin TerminalDeleteBindingPropertyInfo = Terminal+    attrGet _ = getTerminalDeleteBinding+    attrSet _ = setTerminalDeleteBinding+    attrConstruct _ = constructTerminalDeleteBinding+    attrClear _ = undefined+#endif++-- VVV Prop "encoding"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just True,Nothing)++{- |+Get the value of the “@encoding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #encoding+@+-}+getTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalEncoding obj = liftIO $ B.Properties.getObjectPropertyString obj "encoding"++{- |+Set the value of the “@encoding@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #encoding 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> T.Text -> m ()+setTerminalEncoding obj val = liftIO $ B.Properties.setObjectPropertyString obj "encoding" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@encoding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalEncoding :: (IsTerminal o) => T.Text -> IO (GValueConstruct o)+constructTerminalEncoding val = B.Properties.constructObjectPropertyString "encoding" (Just val)++{- |+Set the value of the “@encoding@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #encoding+@+-}+clearTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m ()+clearTerminalEncoding obj = liftIO $ B.Properties.setObjectPropertyString obj "encoding" (Nothing :: Maybe T.Text)++#if ENABLE_OVERLOADING+data TerminalEncodingPropertyInfo+instance AttrInfo TerminalEncodingPropertyInfo where+    type AttrAllowedOps TerminalEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TerminalEncodingPropertyInfo = IsTerminal+    type AttrGetType TerminalEncodingPropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalEncodingPropertyInfo = "encoding"+    type AttrOrigin TerminalEncodingPropertyInfo = Terminal+    attrGet _ = getTerminalEncoding+    attrSet _ = setTerminalEncoding+    attrConstruct _ = constructTerminalEncoding+    attrClear _ = clearTerminalEncoding+#endif++-- VVV Prop "font-desc"+   -- Type: TInterface (Name {namespace = "Pango", name = "FontDescription"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@font-desc@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #fontDesc+@+-}+getTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m (Maybe Pango.FontDescription.FontDescription)+getTerminalFontDesc obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "font-desc" Pango.FontDescription.FontDescription++{- |+Set the value of the “@font-desc@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #fontDesc 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> Pango.FontDescription.FontDescription -> m ()+setTerminalFontDesc obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "font-desc" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalFontDesc :: (IsTerminal o) => Pango.FontDescription.FontDescription -> IO (GValueConstruct o)+constructTerminalFontDesc val = B.Properties.constructObjectPropertyBoxed "font-desc" (Just val)++{- |+Set the value of the “@font-desc@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #fontDesc+@+-}+clearTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m ()+clearTerminalFontDesc obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "font-desc" (Nothing :: Maybe Pango.FontDescription.FontDescription)++#if ENABLE_OVERLOADING+data TerminalFontDescPropertyInfo+instance AttrInfo TerminalFontDescPropertyInfo where+    type AttrAllowedOps TerminalFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription+    type AttrBaseTypeConstraint TerminalFontDescPropertyInfo = IsTerminal+    type AttrGetType TerminalFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription)+    type AttrLabel TerminalFontDescPropertyInfo = "font-desc"+    type AttrOrigin TerminalFontDescPropertyInfo = Terminal+    attrGet _ = getTerminalFontDesc+    attrSet _ = setTerminalFontDesc+    attrConstruct _ = constructTerminalFontDesc+    attrClear _ = clearTerminalFontDesc+#endif++-- VVV Prop "font-scale"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@font-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #fontScale+@+-}+getTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> m Double+getTerminalFontScale obj = liftIO $ B.Properties.getObjectPropertyDouble obj "font-scale"++{- |+Set the value of the “@font-scale@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #fontScale 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()+setTerminalFontScale obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "font-scale" val++{- |+Construct a `GValueConstruct` with valid value for the “@font-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalFontScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)+constructTerminalFontScale val = B.Properties.constructObjectPropertyDouble "font-scale" val++#if ENABLE_OVERLOADING+data TerminalFontScalePropertyInfo+instance AttrInfo TerminalFontScalePropertyInfo where+    type AttrAllowedOps TerminalFontScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalFontScalePropertyInfo = (~) Double+    type AttrBaseTypeConstraint TerminalFontScalePropertyInfo = IsTerminal+    type AttrGetType TerminalFontScalePropertyInfo = Double+    type AttrLabel TerminalFontScalePropertyInfo = "font-scale"+    type AttrOrigin TerminalFontScalePropertyInfo = Terminal+    attrGet _ = getTerminalFontScale+    attrSet _ = setTerminalFontScale+    attrConstruct _ = constructTerminalFontScale+    attrClear _ = undefined+#endif++-- VVV Prop "hyperlink-hover-uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@hyperlink-hover-uri@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #hyperlinkHoverUri+@+-}+getTerminalHyperlinkHoverUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalHyperlinkHoverUri obj = liftIO $ B.Properties.getObjectPropertyString obj "hyperlink-hover-uri"++#if ENABLE_OVERLOADING+data TerminalHyperlinkHoverUriPropertyInfo+instance AttrInfo TerminalHyperlinkHoverUriPropertyInfo where+    type AttrAllowedOps TerminalHyperlinkHoverUriPropertyInfo = '[ 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = IsTerminal+    type AttrGetType TerminalHyperlinkHoverUriPropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalHyperlinkHoverUriPropertyInfo = "hyperlink-hover-uri"+    type AttrOrigin TerminalHyperlinkHoverUriPropertyInfo = Terminal+    attrGet _ = getTerminalHyperlinkHoverUri+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "icon-title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Just True,Nothing)++{- |+Get the value of the “@icon-title@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #iconTitle+@+-}+getTerminalIconTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalIconTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "icon-title"++#if ENABLE_OVERLOADING+data TerminalIconTitlePropertyInfo+instance AttrInfo TerminalIconTitlePropertyInfo where+    type AttrAllowedOps TerminalIconTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalIconTitlePropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalIconTitlePropertyInfo = IsTerminal+    type AttrGetType TerminalIconTitlePropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalIconTitlePropertyInfo = "icon-title"+    type AttrOrigin TerminalIconTitlePropertyInfo = Terminal+    attrGet _ = getTerminalIconTitle+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "input-enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@input-enabled@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #inputEnabled+@+-}+getTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalInputEnabled obj = liftIO $ B.Properties.getObjectPropertyBool obj "input-enabled"++{- |+Set the value of the “@input-enabled@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #inputEnabled 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalInputEnabled obj val = liftIO $ B.Properties.setObjectPropertyBool obj "input-enabled" val++{- |+Construct a `GValueConstruct` with valid value for the “@input-enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalInputEnabled :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalInputEnabled val = B.Properties.constructObjectPropertyBool "input-enabled" val++#if ENABLE_OVERLOADING+data TerminalInputEnabledPropertyInfo+instance AttrInfo TerminalInputEnabledPropertyInfo where+    type AttrAllowedOps TerminalInputEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalInputEnabledPropertyInfo = IsTerminal+    type AttrGetType TerminalInputEnabledPropertyInfo = Bool+    type AttrLabel TerminalInputEnabledPropertyInfo = "input-enabled"+    type AttrOrigin TerminalInputEnabledPropertyInfo = Terminal+    attrGet _ = getTerminalInputEnabled+    attrSet _ = setTerminalInputEnabled+    attrConstruct _ = constructTerminalInputEnabled+    attrClear _ = undefined+#endif++-- VVV Prop "pointer-autohide"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@pointer-autohide@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #pointerAutohide+@+-}+getTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalPointerAutohide obj = liftIO $ B.Properties.getObjectPropertyBool obj "pointer-autohide"++{- |+Set the value of the “@pointer-autohide@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #pointerAutohide 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalPointerAutohide obj val = liftIO $ B.Properties.setObjectPropertyBool obj "pointer-autohide" val++{- |+Construct a `GValueConstruct` with valid value for the “@pointer-autohide@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalPointerAutohide :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalPointerAutohide val = B.Properties.constructObjectPropertyBool "pointer-autohide" val++#if ENABLE_OVERLOADING+data TerminalPointerAutohidePropertyInfo+instance AttrInfo TerminalPointerAutohidePropertyInfo where+    type AttrAllowedOps TerminalPointerAutohidePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalPointerAutohidePropertyInfo = IsTerminal+    type AttrGetType TerminalPointerAutohidePropertyInfo = Bool+    type AttrLabel TerminalPointerAutohidePropertyInfo = "pointer-autohide"+    type AttrOrigin TerminalPointerAutohidePropertyInfo = Terminal+    attrGet _ = getTerminalPointerAutohide+    attrSet _ = setTerminalPointerAutohide+    attrConstruct _ = constructTerminalPointerAutohide+    attrClear _ = undefined+#endif++-- VVV Prop "pty"+   -- Type: TInterface (Name {namespace = "Vte", name = "Pty"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just True)++{- |+Get the value of the “@pty@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #pty+@+-}+getTerminalPty :: (MonadIO m, IsTerminal o) => o -> m Vte.Pty.Pty+getTerminalPty obj = liftIO $ checkUnexpectedNothing "getTerminalPty" $ B.Properties.getObjectPropertyObject obj "pty" Vte.Pty.Pty++{- |+Set the value of the “@pty@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #pty 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalPty :: (MonadIO m, IsTerminal o, Vte.Pty.IsPty a) => o -> a -> m ()+setTerminalPty obj val = liftIO $ B.Properties.setObjectPropertyObject obj "pty" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@pty@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalPty :: (IsTerminal o, Vte.Pty.IsPty a) => a -> IO (GValueConstruct o)+constructTerminalPty val = B.Properties.constructObjectPropertyObject "pty" (Just val)++{- |+Set the value of the “@pty@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #pty+@+-}+clearTerminalPty :: (MonadIO m, IsTerminal o) => o -> m ()+clearTerminalPty obj = liftIO $ B.Properties.setObjectPropertyObject obj "pty" (Nothing :: Maybe Vte.Pty.Pty)++#if ENABLE_OVERLOADING+data TerminalPtyPropertyInfo+instance AttrInfo TerminalPtyPropertyInfo where+    type AttrAllowedOps TerminalPtyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty+    type AttrBaseTypeConstraint TerminalPtyPropertyInfo = IsTerminal+    type AttrGetType TerminalPtyPropertyInfo = Vte.Pty.Pty+    type AttrLabel TerminalPtyPropertyInfo = "pty"+    type AttrOrigin TerminalPtyPropertyInfo = Terminal+    attrGet _ = getTerminalPty+    attrSet _ = setTerminalPty+    attrConstruct _ = constructTerminalPty+    attrClear _ = clearTerminalPty+#endif++-- VVV Prop "rewrap-on-resize"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@rewrap-on-resize@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #rewrapOnResize+@+-}+getTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalRewrapOnResize obj = liftIO $ B.Properties.getObjectPropertyBool obj "rewrap-on-resize"++{- |+Set the value of the “@rewrap-on-resize@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #rewrapOnResize 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalRewrapOnResize obj val = liftIO $ B.Properties.setObjectPropertyBool obj "rewrap-on-resize" val++{- |+Construct a `GValueConstruct` with valid value for the “@rewrap-on-resize@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalRewrapOnResize :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalRewrapOnResize val = B.Properties.constructObjectPropertyBool "rewrap-on-resize" val++#if ENABLE_OVERLOADING+data TerminalRewrapOnResizePropertyInfo+instance AttrInfo TerminalRewrapOnResizePropertyInfo where+    type AttrAllowedOps TerminalRewrapOnResizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalRewrapOnResizePropertyInfo = IsTerminal+    type AttrGetType TerminalRewrapOnResizePropertyInfo = Bool+    type AttrLabel TerminalRewrapOnResizePropertyInfo = "rewrap-on-resize"+    type AttrOrigin TerminalRewrapOnResizePropertyInfo = Terminal+    attrGet _ = getTerminalRewrapOnResize+    attrSet _ = setTerminalRewrapOnResize+    attrConstruct _ = constructTerminalRewrapOnResize+    attrClear _ = undefined+#endif++-- VVV Prop "scroll-on-keystroke"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@scroll-on-keystroke@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #scrollOnKeystroke+@+-}+getTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalScrollOnKeystroke obj = liftIO $ B.Properties.getObjectPropertyBool obj "scroll-on-keystroke"++{- |+Set the value of the “@scroll-on-keystroke@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #scrollOnKeystroke 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalScrollOnKeystroke obj val = liftIO $ B.Properties.setObjectPropertyBool obj "scroll-on-keystroke" val++{- |+Construct a `GValueConstruct` with valid value for the “@scroll-on-keystroke@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalScrollOnKeystroke :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalScrollOnKeystroke val = B.Properties.constructObjectPropertyBool "scroll-on-keystroke" val++#if ENABLE_OVERLOADING+data TerminalScrollOnKeystrokePropertyInfo+instance AttrInfo TerminalScrollOnKeystrokePropertyInfo where+    type AttrAllowedOps TerminalScrollOnKeystrokePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalScrollOnKeystrokePropertyInfo = IsTerminal+    type AttrGetType TerminalScrollOnKeystrokePropertyInfo = Bool+    type AttrLabel TerminalScrollOnKeystrokePropertyInfo = "scroll-on-keystroke"+    type AttrOrigin TerminalScrollOnKeystrokePropertyInfo = Terminal+    attrGet _ = getTerminalScrollOnKeystroke+    attrSet _ = setTerminalScrollOnKeystroke+    attrConstruct _ = constructTerminalScrollOnKeystroke+    attrClear _ = undefined+#endif++-- VVV Prop "scroll-on-output"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@scroll-on-output@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #scrollOnOutput+@+-}+getTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> m Bool+getTerminalScrollOnOutput obj = liftIO $ B.Properties.getObjectPropertyBool obj "scroll-on-output"++{- |+Set the value of the “@scroll-on-output@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #scrollOnOutput 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()+setTerminalScrollOnOutput obj val = liftIO $ B.Properties.setObjectPropertyBool obj "scroll-on-output" val++{- |+Construct a `GValueConstruct` with valid value for the “@scroll-on-output@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalScrollOnOutput :: (IsTerminal o) => Bool -> IO (GValueConstruct o)+constructTerminalScrollOnOutput val = B.Properties.constructObjectPropertyBool "scroll-on-output" val++#if ENABLE_OVERLOADING+data TerminalScrollOnOutputPropertyInfo+instance AttrInfo TerminalScrollOnOutputPropertyInfo where+    type AttrAllowedOps TerminalScrollOnOutputPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TerminalScrollOnOutputPropertyInfo = IsTerminal+    type AttrGetType TerminalScrollOnOutputPropertyInfo = Bool+    type AttrLabel TerminalScrollOnOutputPropertyInfo = "scroll-on-output"+    type AttrOrigin TerminalScrollOnOutputPropertyInfo = Terminal+    attrGet _ = getTerminalScrollOnOutput+    attrSet _ = setTerminalScrollOnOutput+    attrConstruct _ = constructTerminalScrollOnOutput+    attrClear _ = undefined+#endif++-- VVV Prop "scroll-speed"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Just False)++{- |+Get the value of the “@scroll-speed@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #scrollSpeed+@+-}+getTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> m Word32+getTerminalScrollSpeed obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "scroll-speed"++{- |+Set the value of the “@scroll-speed@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #scrollSpeed 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()+setTerminalScrollSpeed obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "scroll-speed" val++{- |+Construct a `GValueConstruct` with valid value for the “@scroll-speed@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalScrollSpeed :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)+constructTerminalScrollSpeed val = B.Properties.constructObjectPropertyUInt32 "scroll-speed" val++#if ENABLE_OVERLOADING+data TerminalScrollSpeedPropertyInfo+instance AttrInfo TerminalScrollSpeedPropertyInfo where+    type AttrAllowedOps TerminalScrollSpeedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalScrollSpeedPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint TerminalScrollSpeedPropertyInfo = IsTerminal+    type AttrGetType TerminalScrollSpeedPropertyInfo = Word32+    type AttrLabel TerminalScrollSpeedPropertyInfo = "scroll-speed"+    type AttrOrigin TerminalScrollSpeedPropertyInfo = Terminal+    attrGet _ = getTerminalScrollSpeed+    attrSet _ = setTerminalScrollSpeed+    attrConstruct _ = constructTerminalScrollSpeed+    attrClear _ = undefined+#endif++-- VVV Prop "scrollback-lines"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@scrollback-lines@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #scrollbackLines+@+-}+getTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> m Word32+getTerminalScrollbackLines obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "scrollback-lines"++{- |+Set the value of the “@scrollback-lines@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #scrollbackLines 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()+setTerminalScrollbackLines obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "scrollback-lines" val++{- |+Construct a `GValueConstruct` with valid value for the “@scrollback-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalScrollbackLines :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)+constructTerminalScrollbackLines val = B.Properties.constructObjectPropertyUInt32 "scrollback-lines" val++#if ENABLE_OVERLOADING+data TerminalScrollbackLinesPropertyInfo+instance AttrInfo TerminalScrollbackLinesPropertyInfo where+    type AttrAllowedOps TerminalScrollbackLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint TerminalScrollbackLinesPropertyInfo = IsTerminal+    type AttrGetType TerminalScrollbackLinesPropertyInfo = Word32+    type AttrLabel TerminalScrollbackLinesPropertyInfo = "scrollback-lines"+    type AttrOrigin TerminalScrollbackLinesPropertyInfo = Terminal+    attrGet _ = getTerminalScrollbackLines+    attrSet _ = setTerminalScrollbackLines+    attrConstruct _ = constructTerminalScrollbackLines+    attrClear _ = undefined+#endif++-- VVV Prop "text-blink-mode"+   -- Type: TInterface (Name {namespace = "Vte", name = "TextBlinkMode"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@text-blink-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #textBlinkMode+@+-}+getTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.TextBlinkMode+getTerminalTextBlinkMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "text-blink-mode"++{- |+Set the value of the “@text-blink-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' terminal [ #textBlinkMode 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.TextBlinkMode -> m ()+setTerminalTextBlinkMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "text-blink-mode" val++{- |+Construct a `GValueConstruct` with valid value for the “@text-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTerminalTextBlinkMode :: (IsTerminal o) => Vte.Enums.TextBlinkMode -> IO (GValueConstruct o)+constructTerminalTextBlinkMode val = B.Properties.constructObjectPropertyEnum "text-blink-mode" val++#if ENABLE_OVERLOADING+data TerminalTextBlinkModePropertyInfo+instance AttrInfo TerminalTextBlinkModePropertyInfo where+    type AttrAllowedOps TerminalTextBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode+    type AttrBaseTypeConstraint TerminalTextBlinkModePropertyInfo = IsTerminal+    type AttrGetType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode+    type AttrLabel TerminalTextBlinkModePropertyInfo = "text-blink-mode"+    type AttrOrigin TerminalTextBlinkModePropertyInfo = Terminal+    attrGet _ = getTerminalTextBlinkMode+    attrSet _ = setTerminalTextBlinkMode+    attrConstruct _ = constructTerminalTextBlinkMode+    attrClear _ = undefined+#endif++-- VVV Prop "window-title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Just True,Nothing)++{- |+Get the value of the “@window-title@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #windowTitle+@+-}+getTerminalWindowTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalWindowTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "window-title"++#if ENABLE_OVERLOADING+data TerminalWindowTitlePropertyInfo+instance AttrInfo TerminalWindowTitlePropertyInfo where+    type AttrAllowedOps TerminalWindowTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalWindowTitlePropertyInfo = IsTerminal+    type AttrGetType TerminalWindowTitlePropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalWindowTitlePropertyInfo = "window-title"+    type AttrOrigin TerminalWindowTitlePropertyInfo = Terminal+    attrGet _ = getTerminalWindowTitle+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "word-char-exceptions"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]+   -- Nullable: (Just True,Just False)++{- |+Get the value of the “@word-char-exceptions@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' terminal #wordCharExceptions+@+-}+getTerminalWordCharExceptions :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)+getTerminalWordCharExceptions obj = liftIO $ B.Properties.getObjectPropertyString obj "word-char-exceptions"++#if ENABLE_OVERLOADING+data TerminalWordCharExceptionsPropertyInfo+instance AttrInfo TerminalWordCharExceptionsPropertyInfo where+    type AttrAllowedOps TerminalWordCharExceptionsPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TerminalWordCharExceptionsPropertyInfo = IsTerminal+    type AttrGetType TerminalWordCharExceptionsPropertyInfo = (Maybe T.Text)+    type AttrLabel TerminalWordCharExceptionsPropertyInfo = "word-char-exceptions"+    type AttrOrigin TerminalWordCharExceptionsPropertyInfo = Terminal+    attrGet _ = getTerminalWordCharExceptions+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Terminal+type instance O.AttributeList Terminal = TerminalAttributeList+type TerminalAttributeList = ('[ '("allowBold", TerminalAllowBoldPropertyInfo), '("allowHyperlink", TerminalAllowHyperlinkPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("audibleBell", TerminalAudibleBellPropertyInfo), '("backspaceBinding", TerminalBackspaceBindingPropertyInfo), '("boldIsBright", TerminalBoldIsBrightPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("cellHeightScale", TerminalCellHeightScalePropertyInfo), '("cellWidthScale", TerminalCellWidthScalePropertyInfo), '("cjkAmbiguousWidth", TerminalCjkAmbiguousWidthPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("currentDirectoryUri", TerminalCurrentDirectoryUriPropertyInfo), '("currentFileUri", TerminalCurrentFileUriPropertyInfo), '("cursorBlinkMode", TerminalCursorBlinkModePropertyInfo), '("cursorShape", TerminalCursorShapePropertyInfo), '("deleteBinding", TerminalDeleteBindingPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("encoding", TerminalEncodingPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("fontDesc", TerminalFontDescPropertyInfo), '("fontScale", TerminalFontScalePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("hyperlinkHoverUri", TerminalHyperlinkHoverUriPropertyInfo), '("iconTitle", TerminalIconTitlePropertyInfo), '("inputEnabled", TerminalInputEnabledPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pointerAutohide", TerminalPointerAutohidePropertyInfo), '("pty", TerminalPtyPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rewrapOnResize", TerminalRewrapOnResizePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("scrollOnKeystroke", TerminalScrollOnKeystrokePropertyInfo), '("scrollOnOutput", TerminalScrollOnOutputPropertyInfo), '("scrollSpeed", TerminalScrollSpeedPropertyInfo), '("scrollbackLines", TerminalScrollbackLinesPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("textBlinkMode", TerminalTextBlinkModePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowTitle", TerminalWindowTitlePropertyInfo), '("wordCharExceptions", TerminalWordCharExceptionsPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+terminalAllowBold :: AttrLabelProxy "allowBold"+terminalAllowBold = AttrLabelProxy++terminalAllowHyperlink :: AttrLabelProxy "allowHyperlink"+terminalAllowHyperlink = AttrLabelProxy++terminalAudibleBell :: AttrLabelProxy "audibleBell"+terminalAudibleBell = AttrLabelProxy++terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"+terminalBackspaceBinding = AttrLabelProxy++terminalBoldIsBright :: AttrLabelProxy "boldIsBright"+terminalBoldIsBright = AttrLabelProxy++terminalCellHeightScale :: AttrLabelProxy "cellHeightScale"+terminalCellHeightScale = AttrLabelProxy++terminalCellWidthScale :: AttrLabelProxy "cellWidthScale"+terminalCellWidthScale = AttrLabelProxy++terminalCjkAmbiguousWidth :: AttrLabelProxy "cjkAmbiguousWidth"+terminalCjkAmbiguousWidth = AttrLabelProxy++terminalCurrentDirectoryUri :: AttrLabelProxy "currentDirectoryUri"+terminalCurrentDirectoryUri = AttrLabelProxy++terminalCurrentFileUri :: AttrLabelProxy "currentFileUri"+terminalCurrentFileUri = AttrLabelProxy++terminalCursorBlinkMode :: AttrLabelProxy "cursorBlinkMode"+terminalCursorBlinkMode = AttrLabelProxy++terminalCursorShape :: AttrLabelProxy "cursorShape"+terminalCursorShape = AttrLabelProxy++terminalDeleteBinding :: AttrLabelProxy "deleteBinding"+terminalDeleteBinding = AttrLabelProxy++terminalEncoding :: AttrLabelProxy "encoding"+terminalEncoding = AttrLabelProxy++terminalFontDesc :: AttrLabelProxy "fontDesc"+terminalFontDesc = AttrLabelProxy++terminalFontScale :: AttrLabelProxy "fontScale"+terminalFontScale = AttrLabelProxy++terminalHyperlinkHoverUri :: AttrLabelProxy "hyperlinkHoverUri"+terminalHyperlinkHoverUri = AttrLabelProxy++terminalIconTitle :: AttrLabelProxy "iconTitle"+terminalIconTitle = AttrLabelProxy++terminalInputEnabled :: AttrLabelProxy "inputEnabled"+terminalInputEnabled = AttrLabelProxy++terminalPointerAutohide :: AttrLabelProxy "pointerAutohide"+terminalPointerAutohide = AttrLabelProxy++terminalPty :: AttrLabelProxy "pty"+terminalPty = AttrLabelProxy++terminalRewrapOnResize :: AttrLabelProxy "rewrapOnResize"+terminalRewrapOnResize = AttrLabelProxy++terminalScrollOnKeystroke :: AttrLabelProxy "scrollOnKeystroke"+terminalScrollOnKeystroke = AttrLabelProxy++terminalScrollOnOutput :: AttrLabelProxy "scrollOnOutput"+terminalScrollOnOutput = AttrLabelProxy++terminalScrollSpeed :: AttrLabelProxy "scrollSpeed"+terminalScrollSpeed = AttrLabelProxy++terminalScrollbackLines :: AttrLabelProxy "scrollbackLines"+terminalScrollbackLines = AttrLabelProxy++terminalTextBlinkMode :: AttrLabelProxy "textBlinkMode"+terminalTextBlinkMode = AttrLabelProxy++terminalWindowTitle :: AttrLabelProxy "windowTitle"+terminalWindowTitle = AttrLabelProxy++terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"+terminalWordCharExceptions = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+data TerminalBellSignalInfo+instance SignalInfo TerminalBellSignalInfo where+    type HaskellCallbackType TerminalBellSignalInfo = TerminalBellCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalBellCallback cb+        cb'' <- mk_TerminalBellCallback cb'+        connectSignalFunPtr obj "bell" cb'' connectMode++data TerminalCharSizeChangedSignalInfo+instance SignalInfo TerminalCharSizeChangedSignalInfo where+    type HaskellCallbackType TerminalCharSizeChangedSignalInfo = TerminalCharSizeChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCharSizeChangedCallback cb+        cb'' <- mk_TerminalCharSizeChangedCallback cb'+        connectSignalFunPtr obj "char-size-changed" cb'' connectMode++data TerminalChildExitedSignalInfo+instance SignalInfo TerminalChildExitedSignalInfo where+    type HaskellCallbackType TerminalChildExitedSignalInfo = TerminalChildExitedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalChildExitedCallback cb+        cb'' <- mk_TerminalChildExitedCallback cb'+        connectSignalFunPtr obj "child-exited" cb'' connectMode++data TerminalCommitSignalInfo+instance SignalInfo TerminalCommitSignalInfo where+    type HaskellCallbackType TerminalCommitSignalInfo = TerminalCommitCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCommitCallback cb+        cb'' <- mk_TerminalCommitCallback cb'+        connectSignalFunPtr obj "commit" cb'' connectMode++data TerminalContentsChangedSignalInfo+instance SignalInfo TerminalContentsChangedSignalInfo where+    type HaskellCallbackType TerminalContentsChangedSignalInfo = TerminalContentsChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalContentsChangedCallback cb+        cb'' <- mk_TerminalContentsChangedCallback cb'+        connectSignalFunPtr obj "contents-changed" cb'' connectMode++data TerminalCopyClipboardSignalInfo+instance SignalInfo TerminalCopyClipboardSignalInfo where+    type HaskellCallbackType TerminalCopyClipboardSignalInfo = TerminalCopyClipboardCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCopyClipboardCallback cb+        cb'' <- mk_TerminalCopyClipboardCallback cb'+        connectSignalFunPtr obj "copy-clipboard" cb'' connectMode++data TerminalCurrentDirectoryUriChangedSignalInfo+instance SignalInfo TerminalCurrentDirectoryUriChangedSignalInfo where+    type HaskellCallbackType TerminalCurrentDirectoryUriChangedSignalInfo = TerminalCurrentDirectoryUriChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb+        cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'+        connectSignalFunPtr obj "current-directory-uri-changed" cb'' connectMode++data TerminalCurrentFileUriChangedSignalInfo+instance SignalInfo TerminalCurrentFileUriChangedSignalInfo where+    type HaskellCallbackType TerminalCurrentFileUriChangedSignalInfo = TerminalCurrentFileUriChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCurrentFileUriChangedCallback cb+        cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'+        connectSignalFunPtr obj "current-file-uri-changed" cb'' connectMode++data TerminalCursorMovedSignalInfo+instance SignalInfo TerminalCursorMovedSignalInfo where+    type HaskellCallbackType TerminalCursorMovedSignalInfo = TerminalCursorMovedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalCursorMovedCallback cb+        cb'' <- mk_TerminalCursorMovedCallback cb'+        connectSignalFunPtr obj "cursor-moved" cb'' connectMode++data TerminalDecreaseFontSizeSignalInfo+instance SignalInfo TerminalDecreaseFontSizeSignalInfo where+    type HaskellCallbackType TerminalDecreaseFontSizeSignalInfo = TerminalDecreaseFontSizeCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalDecreaseFontSizeCallback cb+        cb'' <- mk_TerminalDecreaseFontSizeCallback cb'+        connectSignalFunPtr obj "decrease-font-size" cb'' connectMode++data TerminalDeiconifyWindowSignalInfo+instance SignalInfo TerminalDeiconifyWindowSignalInfo where+    type HaskellCallbackType TerminalDeiconifyWindowSignalInfo = TerminalDeiconifyWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalDeiconifyWindowCallback cb+        cb'' <- mk_TerminalDeiconifyWindowCallback cb'+        connectSignalFunPtr obj "deiconify-window" cb'' connectMode++data TerminalEncodingChangedSignalInfo+instance SignalInfo TerminalEncodingChangedSignalInfo where+    type HaskellCallbackType TerminalEncodingChangedSignalInfo = TerminalEncodingChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalEncodingChangedCallback cb+        cb'' <- mk_TerminalEncodingChangedCallback cb'+        connectSignalFunPtr obj "encoding-changed" cb'' connectMode++data TerminalEofSignalInfo+instance SignalInfo TerminalEofSignalInfo where+    type HaskellCallbackType TerminalEofSignalInfo = TerminalEofCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalEofCallback cb+        cb'' <- mk_TerminalEofCallback cb'+        connectSignalFunPtr obj "eof" cb'' connectMode++data TerminalHyperlinkHoverUriChangedSignalInfo+instance SignalInfo TerminalHyperlinkHoverUriChangedSignalInfo where+    type HaskellCallbackType TerminalHyperlinkHoverUriChangedSignalInfo = TerminalHyperlinkHoverUriChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb+        cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'+        connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' connectMode++data TerminalIconTitleChangedSignalInfo+instance SignalInfo TerminalIconTitleChangedSignalInfo where+    type HaskellCallbackType TerminalIconTitleChangedSignalInfo = TerminalIconTitleChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalIconTitleChangedCallback cb+        cb'' <- mk_TerminalIconTitleChangedCallback cb'+        connectSignalFunPtr obj "icon-title-changed" cb'' connectMode++data TerminalIconifyWindowSignalInfo+instance SignalInfo TerminalIconifyWindowSignalInfo where+    type HaskellCallbackType TerminalIconifyWindowSignalInfo = TerminalIconifyWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalIconifyWindowCallback cb+        cb'' <- mk_TerminalIconifyWindowCallback cb'+        connectSignalFunPtr obj "iconify-window" cb'' connectMode++data TerminalIncreaseFontSizeSignalInfo+instance SignalInfo TerminalIncreaseFontSizeSignalInfo where+    type HaskellCallbackType TerminalIncreaseFontSizeSignalInfo = TerminalIncreaseFontSizeCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalIncreaseFontSizeCallback cb+        cb'' <- mk_TerminalIncreaseFontSizeCallback cb'+        connectSignalFunPtr obj "increase-font-size" cb'' connectMode++data TerminalLowerWindowSignalInfo+instance SignalInfo TerminalLowerWindowSignalInfo where+    type HaskellCallbackType TerminalLowerWindowSignalInfo = TerminalLowerWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalLowerWindowCallback cb+        cb'' <- mk_TerminalLowerWindowCallback cb'+        connectSignalFunPtr obj "lower-window" cb'' connectMode++data TerminalMaximizeWindowSignalInfo+instance SignalInfo TerminalMaximizeWindowSignalInfo where+    type HaskellCallbackType TerminalMaximizeWindowSignalInfo = TerminalMaximizeWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalMaximizeWindowCallback cb+        cb'' <- mk_TerminalMaximizeWindowCallback cb'+        connectSignalFunPtr obj "maximize-window" cb'' connectMode++data TerminalMoveWindowSignalInfo+instance SignalInfo TerminalMoveWindowSignalInfo where+    type HaskellCallbackType TerminalMoveWindowSignalInfo = TerminalMoveWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalMoveWindowCallback cb+        cb'' <- mk_TerminalMoveWindowCallback cb'+        connectSignalFunPtr obj "move-window" cb'' connectMode++data TerminalNotificationReceivedSignalInfo+instance SignalInfo TerminalNotificationReceivedSignalInfo where+    type HaskellCallbackType TerminalNotificationReceivedSignalInfo = TerminalNotificationReceivedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalNotificationReceivedCallback cb+        cb'' <- mk_TerminalNotificationReceivedCallback cb'+        connectSignalFunPtr obj "notification-received" cb'' connectMode++data TerminalPasteClipboardSignalInfo+instance SignalInfo TerminalPasteClipboardSignalInfo where+    type HaskellCallbackType TerminalPasteClipboardSignalInfo = TerminalPasteClipboardCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalPasteClipboardCallback cb+        cb'' <- mk_TerminalPasteClipboardCallback cb'+        connectSignalFunPtr obj "paste-clipboard" cb'' connectMode++data TerminalRaiseWindowSignalInfo+instance SignalInfo TerminalRaiseWindowSignalInfo where+    type HaskellCallbackType TerminalRaiseWindowSignalInfo = TerminalRaiseWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalRaiseWindowCallback cb+        cb'' <- mk_TerminalRaiseWindowCallback cb'+        connectSignalFunPtr obj "raise-window" cb'' connectMode++data TerminalRefreshWindowSignalInfo+instance SignalInfo TerminalRefreshWindowSignalInfo where+    type HaskellCallbackType TerminalRefreshWindowSignalInfo = TerminalRefreshWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalRefreshWindowCallback cb+        cb'' <- mk_TerminalRefreshWindowCallback cb'+        connectSignalFunPtr obj "refresh-window" cb'' connectMode++data TerminalResizeWindowSignalInfo+instance SignalInfo TerminalResizeWindowSignalInfo where+    type HaskellCallbackType TerminalResizeWindowSignalInfo = TerminalResizeWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalResizeWindowCallback cb+        cb'' <- mk_TerminalResizeWindowCallback cb'+        connectSignalFunPtr obj "resize-window" cb'' connectMode++data TerminalRestoreWindowSignalInfo+instance SignalInfo TerminalRestoreWindowSignalInfo where+    type HaskellCallbackType TerminalRestoreWindowSignalInfo = TerminalRestoreWindowCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalRestoreWindowCallback cb+        cb'' <- mk_TerminalRestoreWindowCallback cb'+        connectSignalFunPtr obj "restore-window" cb'' connectMode++data TerminalSelectionChangedSignalInfo+instance SignalInfo TerminalSelectionChangedSignalInfo where+    type HaskellCallbackType TerminalSelectionChangedSignalInfo = TerminalSelectionChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalSelectionChangedCallback cb+        cb'' <- mk_TerminalSelectionChangedCallback cb'+        connectSignalFunPtr obj "selection-changed" cb'' connectMode++data TerminalTextDeletedSignalInfo+instance SignalInfo TerminalTextDeletedSignalInfo where+    type HaskellCallbackType TerminalTextDeletedSignalInfo = TerminalTextDeletedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalTextDeletedCallback cb+        cb'' <- mk_TerminalTextDeletedCallback cb'+        connectSignalFunPtr obj "text-deleted" cb'' connectMode++data TerminalTextInsertedSignalInfo+instance SignalInfo TerminalTextInsertedSignalInfo where+    type HaskellCallbackType TerminalTextInsertedSignalInfo = TerminalTextInsertedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalTextInsertedCallback cb+        cb'' <- mk_TerminalTextInsertedCallback cb'+        connectSignalFunPtr obj "text-inserted" cb'' connectMode++data TerminalTextModifiedSignalInfo+instance SignalInfo TerminalTextModifiedSignalInfo where+    type HaskellCallbackType TerminalTextModifiedSignalInfo = TerminalTextModifiedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalTextModifiedCallback cb+        cb'' <- mk_TerminalTextModifiedCallback cb'+        connectSignalFunPtr obj "text-modified" cb'' connectMode++data TerminalTextScrolledSignalInfo+instance SignalInfo TerminalTextScrolledSignalInfo where+    type HaskellCallbackType TerminalTextScrolledSignalInfo = TerminalTextScrolledCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalTextScrolledCallback cb+        cb'' <- mk_TerminalTextScrolledCallback cb'+        connectSignalFunPtr obj "text-scrolled" cb'' connectMode++data TerminalWindowTitleChangedSignalInfo+instance SignalInfo TerminalWindowTitleChangedSignalInfo where+    type HaskellCallbackType TerminalWindowTitleChangedSignalInfo = TerminalWindowTitleChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_TerminalWindowTitleChangedCallback cb+        cb'' <- mk_TerminalWindowTitleChangedCallback cb'+        connectSignalFunPtr obj "window-title-changed" cb'' connectMode++type instance O.SignalList Terminal = TerminalSignalList+type TerminalSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("bell", TerminalBellSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("charSizeChanged", TerminalCharSizeChangedSignalInfo), '("childExited", TerminalChildExitedSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("commit", TerminalCommitSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("contentsChanged", TerminalContentsChangedSignalInfo), '("copyClipboard", TerminalCopyClipboardSignalInfo), '("currentDirectoryUriChanged", TerminalCurrentDirectoryUriChangedSignalInfo), '("currentFileUriChanged", TerminalCurrentFileUriChangedSignalInfo), '("cursorMoved", TerminalCursorMovedSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("decreaseFontSize", TerminalDecreaseFontSizeSignalInfo), '("deiconifyWindow", TerminalDeiconifyWindowSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("encodingChanged", TerminalEncodingChangedSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("eof", TerminalEofSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("hyperlinkHoverUriChanged", TerminalHyperlinkHoverUriChangedSignalInfo), '("iconTitleChanged", TerminalIconTitleChangedSignalInfo), '("iconifyWindow", TerminalIconifyWindowSignalInfo), '("increaseFontSize", TerminalIncreaseFontSizeSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("lowerWindow", TerminalLowerWindowSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("maximizeWindow", TerminalMaximizeWindowSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveWindow", TerminalMoveWindowSignalInfo), '("notificationReceived", TerminalNotificationReceivedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", TerminalPasteClipboardSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("raiseWindow", TerminalRaiseWindowSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("refreshWindow", TerminalRefreshWindowSignalInfo), '("resizeWindow", TerminalResizeWindowSignalInfo), '("restoreWindow", TerminalRestoreWindowSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionChanged", TerminalSelectionChangedSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("textDeleted", TerminalTextDeletedSignalInfo), '("textInserted", TerminalTextInsertedSignalInfo), '("textModified", TerminalTextModifiedSignalInfo), '("textScrolled", TerminalTextScrolledSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo), '("windowTitleChanged", TerminalWindowTitleChangedSignalInfo)] :: [(Symbol, *)])++#endif++-- method Terminal::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Terminal"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_new" vte_terminal_new :: +    IO (Ptr Terminal)++{- |+Creates a new terminal widget.+-}+terminalNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Terminal+    {- ^ __Returns:__ a new 'GI.Vte.Objects.Terminal.Terminal' object -}+terminalNew  = liftIO $ do+    result <- vte_terminal_new+    checkUnexpectedReturnNULL "terminalNew" result+    result' <- (newObject Terminal) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Terminal::copy_clipboard+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_copy_clipboard" vte_terminal_copy_clipboard :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{-# DEPRECATED terminalCopyClipboard ["(Since version 0.50)","Use 'GI.Vte.Objects.Terminal.terminalCopyClipboardFormat' with 'GI.Vte.Enums.FormatText'","  instead."] #-}+{- |+Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@+selection.+-}+terminalCopyClipboard ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalCopyClipboard terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_copy_clipboard terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalCopyClipboardMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardMethodInfo a signature where+    overloadedMethod _ = terminalCopyClipboard++#endif++-- method Terminal::copy_clipboard_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Vte", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_copy_clipboard_format" vte_terminal_copy_clipboard_format :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- format : TInterface (Name {namespace = "Vte", name = "Format"})+    IO ()++{- |+Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@+selection in the form specified by /@format@/.++For all formats, the selection data (see 'GI.Gtk.Structs.SelectionData.SelectionData') will include the+text targets (see 'GI.Gtk.Structs.TargetList.targetListAddTextTargets' and+@/gtk_selection_data_targets_includes_text()/@). For 'GI.Vte.Enums.FormatHtml',+the selection will also include the \"text\/html\" target, which when requested,+returns the HTML data in UTF-16 with a U+FEFF BYTE ORDER MARK character at+the start.++/Since: 0.50/+-}+terminalCopyClipboardFormat ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.Format+    {- ^ /@format@/: a 'GI.Vte.Enums.Format' -}+    -> m ()+terminalCopyClipboardFormat terminal format = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let format' = (fromIntegral . fromEnum) format+    vte_terminal_copy_clipboard_format terminal' format'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalCopyClipboardFormatMethodInfo+instance (signature ~ (Vte.Enums.Format -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardFormatMethodInfo a signature where+    overloadedMethod _ = terminalCopyClipboardFormat++#endif++-- method Terminal::copy_primary+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_copy_primary" vte_terminal_copy_primary :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Places the selected text in the terminal in the @/GDK_SELECTION_PRIMARY/@+selection.+-}+terminalCopyPrimary ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalCopyPrimary terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_copy_primary terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalCopyPrimaryMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyPrimaryMethodInfo a signature where+    overloadedMethod _ = terminalCopyPrimary++#endif++-- method Terminal::feed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a string in the terminal's current encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the string, or -1 to use the full length or a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the string, or -1 to use the full length or a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_feed" vte_terminal_feed :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    Int64 ->                                -- length : TBasicType TInt64+    IO ()++{- |+Interprets /@data@/ as if it were data received from a child process.  This+can either be used to drive the terminal without a child process, or just+to mess with your users.+-}+terminalFeed ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (ByteString)+    {- ^ /@data@/: a string in the terminal\'s current encoding -}+    -> m ()+terminalFeed terminal data_ = liftIO $ do+    let length_ = case data_ of+            Nothing -> 0+            Just jData_ -> fromIntegral $ B.length jData_+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeData_ <- case data_ of+        Nothing -> return nullPtr+        Just jData_ -> do+            jData_' <- packByteString jData_+            return jData_'+    vte_terminal_feed terminal' maybeData_ length_+    touchManagedPtr terminal+    freeMem maybeData_+    return ()++#if ENABLE_OVERLOADING+data TerminalFeedMethodInfo+instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedMethodInfo a signature where+    overloadedMethod _ = terminalFeed++#endif++-- method Terminal::feed_child+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TCArray False (-1) 2 (TBasicType TInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the child", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @text in bytes, or -1 if @text is NUL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @text in bytes, or -1 if @text is NUL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_feed_child" vte_terminal_feed_child :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Int8 ->                             -- text : TCArray False (-1) 2 (TBasicType TInt8)+    Int64 ->                                -- length : TBasicType TInt64+    IO ()++{- |+Sends a block of UTF-8 text to the child as if it were entered by the user+at the keyboard.+-}+terminalFeedChild ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe ([Int8])+    {- ^ /@text@/: data to send to the child -}+    -> m ()+terminalFeedChild terminal text = liftIO $ do+    let length_ = case text of+            Nothing -> 0+            Just jText -> fromIntegral $ length jText+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeText <- case text of+        Nothing -> return nullPtr+        Just jText -> do+            jText' <- packStorableArray jText+            return jText'+    vte_terminal_feed_child terminal' maybeText length_+    touchManagedPtr terminal+    freeMem maybeText+    return ()++#if ENABLE_OVERLOADING+data TerminalFeedChildMethodInfo+instance (signature ~ (Maybe ([Int8]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildMethodInfo a signature where+    overloadedMethod _ = terminalFeedChild++#endif++-- method Terminal::feed_child_binary+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the child", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_feed_child_binary" vte_terminal_feed_child_binary :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- length : TBasicType TUInt64+    IO ()++{- |+Sends a block of binary data to the child.+-}+terminalFeedChildBinary ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (ByteString)+    {- ^ /@data@/: data to send to the child -}+    -> m ()+terminalFeedChildBinary terminal data_ = liftIO $ do+    let length_ = case data_ of+            Nothing -> 0+            Just jData_ -> fromIntegral $ B.length jData_+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeData_ <- case data_ of+        Nothing -> return nullPtr+        Just jData_ -> do+            jData_' <- packByteString jData_+            return jData_'+    vte_terminal_feed_child_binary terminal' maybeData_ length_+    touchManagedPtr terminal+    freeMem maybeData_+    return ()++#if ENABLE_OVERLOADING+data TerminalFeedChildBinaryMethodInfo+instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildBinaryMethodInfo a signature where+    overloadedMethod _ = terminalFeedChildBinary++#endif++-- method Terminal::get_allow_bold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_allow_bold" vte_terminal_get_allow_bold :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks whether or not the terminal will attempt to draw bold text,+either by using a bold font variant or by repainting text with a different+offset.+-}+terminalGetAllowBold ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if bolding is enabled, 'False' if not -}+terminalGetAllowBold terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_allow_bold terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetAllowBoldMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowBoldMethodInfo a signature where+    overloadedMethod _ = terminalGetAllowBold++#endif++-- method Terminal::get_allow_hyperlink+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_allow_hyperlink" vte_terminal_get_allow_hyperlink :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks whether or not hyperlinks (OSC 8 escape sequence) are allowed.++/Since: 0.50/+-}+terminalGetAllowHyperlink ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if hyperlinks are enabled, 'False' if not -}+terminalGetAllowHyperlink terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_allow_hyperlink terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetAllowHyperlinkMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowHyperlinkMethodInfo a signature where+    overloadedMethod _ = terminalGetAllowHyperlink++#endif++-- method Terminal::get_audible_bell+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_audible_bell" vte_terminal_get_audible_bell :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks whether or not the terminal will beep when the child outputs the+\"bl\" sequence.+-}+terminalGetAudibleBell ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if audible bell is enabled, 'False' if not -}+terminalGetAudibleBell terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_audible_bell terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetAudibleBellMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAudibleBellMethodInfo a signature where+    overloadedMethod _ = terminalGetAudibleBell++#endif++-- method Terminal::get_bold_is_bright+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_bold_is_bright" vte_terminal_get_bold_is_bright :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks whether the SGR 1 attribute also switches to the bright counterpart+of the first 8 palette colors, in addition to making them bold (legacy behavior)+or if SGR 1 only enables bold and leaves the color intact.++/Since: 0.52/+-}+terminalGetBoldIsBright ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if bold also enables bright, 'False' if not -}+terminalGetBoldIsBright terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_bold_is_bright terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetBoldIsBrightMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetBoldIsBrightMethodInfo a signature where+    overloadedMethod _ = terminalGetBoldIsBright++#endif++-- method Terminal::get_cell_height_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cell_height_scale" vte_terminal_get_cell_height_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CDouble++{- |+/No description available in the introspection data./++/Since: 0.52/+-}+terminalGetCellHeightScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Double+    {- ^ __Returns:__ the terminal\'s cell height scale -}+terminalGetCellHeightScale terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_cell_height_scale terminal'+    let result' = realToFrac result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetCellHeightScaleMethodInfo+instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellHeightScaleMethodInfo a signature where+    overloadedMethod _ = terminalGetCellHeightScale++#endif++-- method Terminal::get_cell_width_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cell_width_scale" vte_terminal_get_cell_width_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CDouble++{- |+/No description available in the introspection data./++/Since: 0.52/+-}+terminalGetCellWidthScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Double+    {- ^ __Returns:__ the terminal\'s cell width scale -}+terminalGetCellWidthScale terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_cell_width_scale terminal'+    let result' = realToFrac result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetCellWidthScaleMethodInfo+instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellWidthScaleMethodInfo a signature where+    overloadedMethod _ = terminalGetCellWidthScale++#endif++-- method Terminal::get_char_height+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_char_height" vte_terminal_get_char_height :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CLong++{- |+/No description available in the introspection data./+-}+terminalGetCharHeight ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m CLong+    {- ^ __Returns:__ the height of a character cell++Note that this method should rather be called vte_terminal_get_cell_height,+because the return value takes cell-height-scale into account. -}+terminalGetCharHeight terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_char_height terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetCharHeightMethodInfo+instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharHeightMethodInfo a signature where+    overloadedMethod _ = terminalGetCharHeight++#endif++-- method Terminal::get_char_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_char_width" vte_terminal_get_char_width :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CLong++{- |+/No description available in the introspection data./+-}+terminalGetCharWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m CLong+    {- ^ __Returns:__ the width of a character cell++Note that this method should rather be called vte_terminal_get_cell_width,+because the return value takes cell-width-scale into account. -}+terminalGetCharWidth terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_char_width terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetCharWidthMethodInfo+instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharWidthMethodInfo a signature where+    overloadedMethod _ = terminalGetCharWidth++#endif++-- method Terminal::get_cjk_ambiguous_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cjk_ambiguous_width" vte_terminal_get_cjk_ambiguous_width :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO Int32++{- |+Returns whether ambiguous-width characters are narrow or wide.+(Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',+the width of ambiguous-width characters is fixed and determined by the encoding+itself.)+-}+terminalGetCjkAmbiguousWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Int32+    {- ^ __Returns:__ 1 if ambiguous-width characters are narrow, or 2 if they are wide -}+terminalGetCjkAmbiguousWidth terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_cjk_ambiguous_width terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetCjkAmbiguousWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCjkAmbiguousWidthMethodInfo a signature where+    overloadedMethod _ = terminalGetCjkAmbiguousWidth++#endif++-- method Terminal::get_color_background_for_draw+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store a #GdbRGBA color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_color_background_for_draw" vte_terminal_get_color_background_for_draw :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Returns the background colour, as used by /@terminal@/ when+drawing the background, which may be different from+the color set by 'GI.Vte.Objects.Terminal.terminalSetColorBackground'.++Note: you must only call this function while handling the+GtkWidget::draw signal.++This function is rarely useful. One use for it is if you disable+drawing the background (see 'GI.Vte.Objects.Terminal.terminalSetClearBackground')+and then need to draw the background yourself.++/Since: 0.54/+-}+terminalGetColorBackgroundForDraw ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Gdk.RGBA.RGBA)+terminalGetColorBackgroundForDraw terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)+    vte_terminal_get_color_background_for_draw terminal' color+    color' <- (wrapBoxed Gdk.RGBA.RGBA) color+    touchManagedPtr terminal+    return color'++#if ENABLE_OVERLOADING+data TerminalGetColorBackgroundForDrawMethodInfo+instance (signature ~ (m (Gdk.RGBA.RGBA)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetColorBackgroundForDrawMethodInfo a signature where+    overloadedMethod _ = terminalGetColorBackgroundForDraw++#endif++-- method Terminal::get_column_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_column_count" vte_terminal_get_column_count :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CLong++{- |+/No description available in the introspection data./+-}+terminalGetColumnCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m CLong+    {- ^ __Returns:__ the number of columns -}+terminalGetColumnCount terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_column_count terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetColumnCountMethodInfo+instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetColumnCountMethodInfo a signature where+    overloadedMethod _ = terminalGetColumnCount++#endif++-- method Terminal::get_current_directory_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_current_directory_uri" vte_terminal_get_current_directory_uri :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{- |+/No description available in the introspection data./+-}+terminalGetCurrentDirectoryUri ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the URI of the current directory of the+  process running in the terminal, or 'Nothing' -}+terminalGetCurrentDirectoryUri terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_current_directory_uri terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetCurrentDirectoryUriMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentDirectoryUriMethodInfo a signature where+    overloadedMethod _ = terminalGetCurrentDirectoryUri++#endif++-- method Terminal::get_current_file_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_current_file_uri" vte_terminal_get_current_file_uri :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{- |+/No description available in the introspection data./+-}+terminalGetCurrentFileUri ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the URI of the current file the+  process running in the terminal is operating on, or 'Nothing' if+  not set -}+terminalGetCurrentFileUri terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_current_file_uri terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetCurrentFileUriMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentFileUriMethodInfo a signature where+    overloadedMethod _ = terminalGetCurrentFileUri++#endif++-- method Terminal::get_cursor_blink_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cursor_blink_mode" vte_terminal_get_cursor_blink_mode :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CUInt++{- |+Returns the currently set cursor blink mode.+-}+terminalGetCursorBlinkMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Vte.Enums.CursorBlinkMode+    {- ^ __Returns:__ cursor blink mode. -}+terminalGetCursorBlinkMode terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_cursor_blink_mode terminal'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetCursorBlinkModeMethodInfo+instance (signature ~ (m Vte.Enums.CursorBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorBlinkModeMethodInfo a signature where+    overloadedMethod _ = terminalGetCursorBlinkMode++#endif++-- method Terminal::get_cursor_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the column, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the row, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cursor_position" vte_terminal_get_cursor_position :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr CLong ->                            -- column : TBasicType TLong+    Ptr CLong ->                            -- row : TBasicType TLong+    IO ()++{- |+Reads the location of the insertion cursor and returns it.  The row+coordinate is absolute.+-}+terminalGetCursorPosition ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ((CLong, CLong))+terminalGetCursorPosition terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    column <- allocMem :: IO (Ptr CLong)+    row <- allocMem :: IO (Ptr CLong)+    vte_terminal_get_cursor_position terminal' column row+    column' <- peek column+    row' <- peek row+    touchManagedPtr terminal+    freeMem column+    freeMem row+    return (column', row')++#if ENABLE_OVERLOADING+data TerminalGetCursorPositionMethodInfo+instance (signature ~ (m ((CLong, CLong))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorPositionMethodInfo a signature where+    overloadedMethod _ = terminalGetCursorPosition++#endif++-- method Terminal::get_cursor_shape+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "CursorShape"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_cursor_shape" vte_terminal_get_cursor_shape :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CUInt++{- |+Returns the currently set cursor shape.+-}+terminalGetCursorShape ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Vte.Enums.CursorShape+    {- ^ __Returns:__ cursor shape. -}+terminalGetCursorShape terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_cursor_shape terminal'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetCursorShapeMethodInfo+instance (signature ~ (m Vte.Enums.CursorShape), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorShapeMethodInfo a signature where+    overloadedMethod _ = terminalGetCursorShape++#endif++-- method Terminal::get_encoding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_encoding" vte_terminal_get_encoding :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{-# DEPRECATED terminalGetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}+{- |+Determines the name of the encoding in which the terminal expects data to be+encoded, or 'Nothing' if UTF-8 is in use.+-}+terminalGetEncoding ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the current encoding for the terminal -}+terminalGetEncoding terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_encoding terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetEncodingMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetEncodingMethodInfo a signature where+    overloadedMethod _ = terminalGetEncoding++#endif++-- method Terminal::get_font+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Pango", name = "FontDescription"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_font" vte_terminal_get_font :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO (Ptr Pango.FontDescription.FontDescription)++{- |+Queries the terminal for information about the fonts which will be+used to draw text in the terminal.  The actual font takes the font scale+into account, this is not reflected in the return value, the unscaled+font is returned.+-}+terminalGetFont ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Pango.FontDescription.FontDescription+    {- ^ __Returns:__ a 'GI.Pango.Structs.FontDescription.FontDescription' describing the font the+terminal uses to render text at the default font scale of 1.0. -}+terminalGetFont terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_font terminal'+    checkUnexpectedReturnNULL "terminalGetFont" result+    result' <- (newBoxed Pango.FontDescription.FontDescription) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetFontMethodInfo+instance (signature ~ (m Pango.FontDescription.FontDescription), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontMethodInfo a signature where+    overloadedMethod _ = terminalGetFont++#endif++-- method Terminal::get_font_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_font_scale" vte_terminal_get_font_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CDouble++{- |+/No description available in the introspection data./+-}+terminalGetFontScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Double+    {- ^ __Returns:__ the terminal\'s font scale -}+terminalGetFontScale terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_font_scale terminal'+    let result' = realToFrac result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetFontScaleMethodInfo+instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontScaleMethodInfo a signature where+    overloadedMethod _ = terminalGetFontScale++#endif++-- method Terminal::get_geometry_hints+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hints", argType = TInterface (Name {namespace = "Gdk", name = "Geometry"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkGeometry to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "min_rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of rows to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_columns", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of columns to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_geometry_hints" vte_terminal_get_geometry_hints :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.Geometry.Geometry ->            -- hints : TInterface (Name {namespace = "Gdk", name = "Geometry"})+    Int32 ->                                -- min_rows : TBasicType TInt+    Int32 ->                                -- min_columns : TBasicType TInt+    IO ()++{-# DEPRECATED terminalGetGeometryHints ["(Since version 0.52)"] #-}+{- |+Fills in some /@hints@/ from /@terminal@/\'s geometry. The hints+filled are those covered by the 'GI.Gdk.Flags.WindowHintsResizeInc',+'GI.Gdk.Flags.WindowHintsMinSize' and 'GI.Gdk.Flags.WindowHintsBaseSize' flags.++See 'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.++/@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').+-}+terminalGetGeometryHints ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@minRows@/: the minimum number of rows to request -}+    -> Int32+    {- ^ /@minColumns@/: the minimum number of columns to request -}+    -> m (Gdk.Geometry.Geometry)+terminalGetGeometryHints terminal minRows minColumns = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    hints <- callocBytes 56 :: IO (Ptr Gdk.Geometry.Geometry)+    vte_terminal_get_geometry_hints terminal' hints minRows minColumns+    hints' <- (wrapPtr Gdk.Geometry.Geometry) hints+    touchManagedPtr terminal+    return hints'++#if ENABLE_OVERLOADING+data TerminalGetGeometryHintsMethodInfo+instance (signature ~ (Int32 -> Int32 -> m (Gdk.Geometry.Geometry)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetGeometryHintsMethodInfo a signature where+    overloadedMethod _ = terminalGetGeometryHints++#endif++-- method Terminal::get_has_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_has_selection" vte_terminal_get_has_selection :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks if the terminal currently contains selected text.  Note that this+is different from determining if the terminal is the owner of any+'GI.Gtk.Objects.Clipboard.Clipboard' items.+-}+terminalGetHasSelection ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if part of the text in the terminal is selected. -}+terminalGetHasSelection terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_has_selection terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetHasSelectionMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetHasSelectionMethodInfo a signature where+    overloadedMethod _ = terminalGetHasSelection++#endif++-- method Terminal::get_icon_title+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_icon_title" vte_terminal_get_icon_title :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{-# DEPRECATED terminalGetIconTitle ["(Since version 0.54)"] #-}+{- |+/No description available in the introspection data./+-}+terminalGetIconTitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ 'Nothing' -}+terminalGetIconTitle terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_icon_title terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetIconTitleMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetIconTitleMethodInfo a signature where+    overloadedMethod _ = terminalGetIconTitle++#endif++-- method Terminal::get_input_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_input_enabled" vte_terminal_get_input_enabled :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Returns whether the terminal allow user input.+-}+terminalGetInputEnabled ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+terminalGetInputEnabled terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_input_enabled terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetInputEnabledMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetInputEnabledMethodInfo a signature where+    overloadedMethod _ = terminalGetInputEnabled++#endif++-- method Terminal::get_mouse_autohide+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_mouse_autohide" vte_terminal_get_mouse_autohide :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Determines the value of the terminal\'s mouse autohide setting.  When+autohiding is enabled, the mouse cursor will be hidden when the user presses+a key and shown when the user moves the mouse.  This setting can be changed+using 'GI.Vte.Objects.Terminal.terminalSetMouseAutohide'.+-}+terminalGetMouseAutohide ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if autohiding is enabled, 'False' if not -}+terminalGetMouseAutohide terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_mouse_autohide terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetMouseAutohideMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetMouseAutohideMethodInfo a signature where+    overloadedMethod _ = terminalGetMouseAutohide++#endif++-- method Terminal::get_pty+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Pty"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_pty" vte_terminal_get_pty :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO (Ptr Vte.Pty.Pty)++{- |+Returns the 'GI.Vte.Objects.Pty.Pty' of /@terminal@/.+-}+terminalGetPty ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Vte.Pty.Pty+    {- ^ __Returns:__ a 'GI.Vte.Objects.Pty.Pty', or 'Nothing' -}+terminalGetPty terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_pty terminal'+    checkUnexpectedReturnNULL "terminalGetPty" result+    result' <- (newObject Vte.Pty.Pty) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetPtyMethodInfo+instance (signature ~ (m Vte.Pty.Pty), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetPtyMethodInfo a signature where+    overloadedMethod _ = terminalGetPty++#endif++-- method Terminal::get_rewrap_on_resize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_rewrap_on_resize" vte_terminal_get_rewrap_on_resize :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Checks whether or not the terminal will rewrap its contents upon resize.+-}+terminalGetRewrapOnResize ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if rewrapping is enabled, 'False' if not -}+terminalGetRewrapOnResize terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_rewrap_on_resize terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetRewrapOnResizeMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRewrapOnResizeMethodInfo a signature where+    overloadedMethod _ = terminalGetRewrapOnResize++#endif++-- method Terminal::get_row_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_row_count" vte_terminal_get_row_count :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CLong++{- |+/No description available in the introspection data./+-}+terminalGetRowCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m CLong+    {- ^ __Returns:__ the number of rows -}+terminalGetRowCount terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_row_count terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetRowCountMethodInfo+instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRowCountMethodInfo a signature where+    overloadedMethod _ = terminalGetRowCount++#endif++-- method Terminal::get_scroll_on_keystroke+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_scroll_on_keystroke" vte_terminal_get_scroll_on_keystroke :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+/No description available in the introspection data./++/Since: 0.52/+-}+terminalGetScrollOnKeystroke ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the user presses a key.  Modifier keys do not+trigger this behavior. -}+terminalGetScrollOnKeystroke terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_scroll_on_keystroke terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetScrollOnKeystrokeMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnKeystrokeMethodInfo a signature where+    overloadedMethod _ = terminalGetScrollOnKeystroke++#endif++-- method Terminal::get_scroll_on_output+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_scroll_on_output" vte_terminal_get_scroll_on_output :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+/No description available in the introspection data./++/Since: 0.52/+-}+terminalGetScrollOnOutput ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the new data is received from the child. -}+terminalGetScrollOnOutput terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_scroll_on_output terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetScrollOnOutputMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnOutputMethodInfo a signature where+    overloadedMethod _ = terminalGetScrollOnOutput++#endif++-- method Terminal::get_scrollback_lines+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_scrollback_lines" vte_terminal_get_scrollback_lines :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CLong++{- |+/No description available in the introspection data./++/Since: 0.52/+-}+terminalGetScrollbackLines ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m CLong+    {- ^ __Returns:__ length of the scrollback buffer used by the terminal.+A negative value means \"infinite scrollback\". -}+terminalGetScrollbackLines terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_scrollback_lines terminal'+    touchManagedPtr terminal+    return result++#if ENABLE_OVERLOADING+data TerminalGetScrollbackLinesMethodInfo+instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollbackLinesMethodInfo a signature where+    overloadedMethod _ = terminalGetScrollbackLines++#endif++-- XXX Could not generate method Terminal::get_text+-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"+#if ENABLE_OVERLOADING+-- XXX: Dummy instance, since code generation failed.+-- Please file a bug at http://github.com/haskell-gi/haskell-gi.+data TerminalGetTextMethodInfo+instance (p ~ (), o ~ O.MethodResolutionFailed "getText" Terminal) => O.MethodInfo TerminalGetTextMethodInfo o p where+    overloadedMethod _ = undefined+#endif++-- method Terminal::get_text_blink_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "TextBlinkMode"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_text_blink_mode" vte_terminal_get_text_blink_mode :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CUInt++{- |+Checks whether or not the terminal will allow blinking text.++/Since: 0.52/+-}+terminalGetTextBlinkMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Vte.Enums.TextBlinkMode+    {- ^ __Returns:__ the blinking setting -}+terminalGetTextBlinkMode terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_text_blink_mode terminal'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalGetTextBlinkModeMethodInfo+instance (signature ~ (m Vte.Enums.TextBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetTextBlinkModeMethodInfo a signature where+    overloadedMethod _ = terminalGetTextBlinkMode++#endif++-- XXX Could not generate method Terminal::get_text_include_trailing_spaces+-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"+#if ENABLE_OVERLOADING+-- XXX: Dummy instance, since code generation failed.+-- Please file a bug at http://github.com/haskell-gi/haskell-gi.+data TerminalGetTextIncludeTrailingSpacesMethodInfo+instance (p ~ (), o ~ O.MethodResolutionFailed "getTextIncludeTrailingSpaces" Terminal) => O.MethodInfo TerminalGetTextIncludeTrailingSpacesMethodInfo o p where+    overloadedMethod _ = undefined+#endif++-- XXX Could not generate method Terminal::get_text_range+-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"+#if ENABLE_OVERLOADING+-- XXX: Dummy instance, since code generation failed.+-- Please file a bug at http://github.com/haskell-gi/haskell-gi.+data TerminalGetTextRangeMethodInfo+instance (p ~ (), o ~ O.MethodResolutionFailed "getTextRange" Terminal) => O.MethodInfo TerminalGetTextRangeMethodInfo o p where+    overloadedMethod _ = undefined+#endif++-- method Terminal::get_window_title+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_window_title" vte_terminal_get_window_title :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{- |+/No description available in the introspection data./+-}+terminalGetWindowTitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the window title, or 'Nothing' -}+terminalGetWindowTitle terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_window_title terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetWindowTitleMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWindowTitleMethodInfo a signature where+    overloadedMethod _ = terminalGetWindowTitle++#endif++-- method Terminal::get_word_char_exceptions+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_get_word_char_exceptions" vte_terminal_get_word_char_exceptions :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CString++{- |+Returns the set of characters which will be considered parts of a word+when doing word-wise selection, in addition to the default which only+considers alphanumeric characters part of a word.++If 'Nothing', a built-in set is used.++/Since: 0.40/+-}+terminalGetWordCharExceptions ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a string, or 'Nothing' -}+terminalGetWordCharExceptions terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_get_word_char_exceptions terminal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr terminal+    return maybeResult++#if ENABLE_OVERLOADING+data TerminalGetWordCharExceptionsMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWordCharExceptionsMethodInfo a signature where+    overloadedMethod _ = terminalGetWordCharExceptions++#endif++-- method Terminal::hyperlink_check_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_hyperlink_check_event" vte_terminal_hyperlink_check_event :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})+    IO CString++{- |+Returns a nonempty string: the target of the explicit hyperlink (printed using the OSC 8+escape sequence) at the position of the event, or 'Nothing'.++Proper use of the escape sequence should result in URI-encoded URIs with a proper scheme+like \"http:\/\/\", \"https:\/\/\", \"file:\/\/\", \"mailto:\" etc. This is, however, not enforced by VTE.+The caller must tolerate the returned string potentially not being a valid URI.++/Since: 0.50/+-}+terminalHyperlinkCheckEvent ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Gdk.Event.Event+    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -}+    -> m T.Text+    {- ^ __Returns:__ a newly allocated string containing the target of the hyperlink -}+terminalHyperlinkCheckEvent terminal event = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    event' <- unsafeManagedPtrGetPtr event+    result <- vte_terminal_hyperlink_check_event terminal' event'+    checkUnexpectedReturnNULL "terminalHyperlinkCheckEvent" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr terminal+    touchManagedPtr event+    return result'++#if ENABLE_OVERLOADING+data TerminalHyperlinkCheckEventMethodInfo+instance (signature ~ (Gdk.Event.Event -> m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalHyperlinkCheckEventMethodInfo a signature where+    overloadedMethod _ = terminalHyperlinkCheckEvent++#endif++-- method Terminal::match_add_gregex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gregex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GRegex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gflags", argType = TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GRegexMatchFlags to use when matching the regex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_add_gregex" vte_terminal_match_add_gregex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})+    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})+    IO Int32++{-# DEPRECATED terminalMatchAddGregex ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' or @/vte_terminal_match_add_regex_full()/@ instead."] #-}+{- |+Adds the regular expression /@regex@/ to the list of matching expressions.  When the+user moves the mouse cursor over a section of displayed text which matches+this expression, the text will be highlighted.+-}+terminalMatchAddGregex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> GLib.Regex.Regex+    {- ^ /@gregex@/: a 'GI.GLib.Structs.Regex.Regex' -}+    -> [GLib.Flags.RegexMatchFlags]+    {- ^ /@gflags@/: the 'GI.GLib.Flags.RegexMatchFlags' to use when matching the regex -}+    -> m Int32+    {- ^ __Returns:__ an integer associated with this expression, or -1 if /@gregex@/ could not be+  transformed into a 'GI.Vte.Structs.Regex.Regex' or /@gflags@/ were incompatible -}+terminalMatchAddGregex terminal gregex gflags = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    gregex' <- unsafeManagedPtrGetPtr gregex+    let gflags' = gflagsToWord gflags+    result <- vte_terminal_match_add_gregex terminal' gregex' gflags'+    touchManagedPtr terminal+    touchManagedPtr gregex+    return result++#if ENABLE_OVERLOADING+data TerminalMatchAddGregexMethodInfo+instance (signature ~ (GLib.Regex.Regex -> [GLib.Flags.RegexMatchFlags] -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddGregexMethodInfo a signature where+    overloadedMethod _ = terminalMatchAddGregex++#endif++-- method Terminal::match_add_regex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteRegex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "PCRE2 match flags, or 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_add_regex" vte_terminal_match_add_regex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})+    Word32 ->                               -- flags : TBasicType TUInt32+    IO Int32++{- |+Adds the regular expression /@regex@/ to the list of matching expressions.  When the+user moves the mouse cursor over a section of displayed text which matches+this expression, the text will be highlighted.++/Since: 0.46/+-}+terminalMatchAddRegex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Regex.Regex+    {- ^ /@regex@/: a 'GI.Vte.Structs.Regex.Regex' -}+    -> Word32+    {- ^ /@flags@/: PCRE2 match flags, or 0 -}+    -> m Int32+    {- ^ __Returns:__ an integer associated with this expression -}+terminalMatchAddRegex terminal regex flags = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    regex' <- unsafeManagedPtrGetPtr regex+    result <- vte_terminal_match_add_regex terminal' regex' flags+    touchManagedPtr terminal+    touchManagedPtr regex+    return result++#if ENABLE_OVERLOADING+data TerminalMatchAddRegexMethodInfo+instance (signature ~ (Vte.Regex.Regex -> Word32 -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddRegexMethodInfo a signature where+    overloadedMethod _ = terminalMatchAddRegex++#endif++-- method Terminal::match_check+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text column", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text row", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the tag, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_check" vte_terminal_match_check :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CLong ->                                -- column : TBasicType TLong+    CLong ->                                -- row : TBasicType TLong+    Ptr Int32 ->                            -- tag : TBasicType TInt+    IO CString++{-# DEPRECATED terminalMatchCheck ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchCheckEvent' instead."] #-}+{- |+Checks if the text in and around the specified position matches any of the+regular expressions previously set using @/vte_terminal_match_add()/@.  If a+match exists, the text string is returned and if /@tag@/ is not 'Nothing', the number+associated with the matched regular expression will be stored in /@tag@/.++If more than one regular expression has been set with+@/vte_terminal_match_add()/@, then expressions are checked in the order in+which they were added.+-}+terminalMatchCheck ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> CLong+    {- ^ /@column@/: the text column -}+    -> CLong+    {- ^ /@row@/: the text row -}+    -> m ((T.Text, Int32))+    {- ^ __Returns:__ a newly allocated string which matches one of the previously+  set regular expressions -}+terminalMatchCheck terminal column row = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    tag <- allocMem :: IO (Ptr Int32)+    result <- vte_terminal_match_check terminal' column row tag+    checkUnexpectedReturnNULL "terminalMatchCheck" result+    result' <- cstringToText result+    freeMem result+    tag' <- peek tag+    touchManagedPtr terminal+    freeMem tag+    return (result', tag')++#if ENABLE_OVERLOADING+data TerminalMatchCheckMethodInfo+instance (signature ~ (CLong -> CLong -> m ((T.Text, Int32))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckMethodInfo a signature where+    overloadedMethod _ = terminalMatchCheck++#endif++-- method Terminal::match_check_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the tag, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_check_event" vte_terminal_match_check_event :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})+    Ptr Int32 ->                            -- tag : TBasicType TInt+    IO CString++{- |+Checks if the text in and around the position of the event matches any of the+regular expressions previously set using @/vte_terminal_match_add()/@.  If a+match exists, the text string is returned and if /@tag@/ is not 'Nothing', the number+associated with the matched regular expression will be stored in /@tag@/.++If more than one regular expression has been set with+@/vte_terminal_match_add()/@, then expressions are checked in the order in+which they were added.+-}+terminalMatchCheckEvent ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Gdk.Event.Event+    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -}+    -> m ((T.Text, Int32))+    {- ^ __Returns:__ a newly allocated string which matches one of the previously+  set regular expressions -}+terminalMatchCheckEvent terminal event = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    event' <- unsafeManagedPtrGetPtr event+    tag <- allocMem :: IO (Ptr Int32)+    result <- vte_terminal_match_check_event terminal' event' tag+    checkUnexpectedReturnNULL "terminalMatchCheckEvent" result+    result' <- cstringToText result+    freeMem result+    tag' <- peek tag+    touchManagedPtr terminal+    touchManagedPtr event+    freeMem tag+    return (result', tag')++#if ENABLE_OVERLOADING+data TerminalMatchCheckEventMethodInfo+instance (signature ~ (Gdk.Event.Event -> m ((T.Text, Int32))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckEventMethodInfo a signature where+    overloadedMethod _ = terminalMatchCheckEvent++#endif++-- method Terminal::match_remove+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_remove" vte_terminal_match_remove :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- tag : TBasicType TInt+    IO ()++{- |+Removes the regular expression which is associated with the given /@tag@/ from+the list of expressions which the terminal will highlight when the user+moves the mouse cursor over matching text.+-}+terminalMatchRemove ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@tag@/: the tag of the regex to remove -}+    -> m ()+terminalMatchRemove terminal tag = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_match_remove terminal' tag+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalMatchRemoveMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveMethodInfo a signature where+    overloadedMethod _ = terminalMatchRemove++#endif++-- method Terminal::match_remove_all+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_remove_all" vte_terminal_match_remove_all :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Clears the list of regular expressions the terminal uses to highlight text+when the user moves the mouse cursor.+-}+terminalMatchRemoveAll ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalMatchRemoveAll terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_match_remove_all terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalMatchRemoveAllMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveAllMethodInfo a signature where+    overloadedMethod _ = terminalMatchRemoveAll++#endif++-- method Terminal::match_set_cursor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor", argType = TInterface (Name {namespace = "Gdk", name = "Cursor"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GdkCursor which the terminal should use when the pattern is\n  highlighted, or %NULL to use the standard cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_set_cursor" vte_terminal_match_set_cursor :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- tag : TBasicType TInt+    Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})+    IO ()++{-# DEPRECATED terminalMatchSetCursor ["(Since version 0.40)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}+{- |+Sets which cursor the terminal will use if the pointer is over the pattern+specified by /@tag@/.  The terminal keeps a reference to /@cursor@/.+-}+terminalMatchSetCursor ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}+    -> Maybe (b)+    {- ^ /@cursor@/: the 'GI.Gdk.Objects.Cursor.Cursor' which the terminal should use when the pattern is+  highlighted, or 'Nothing' to use the standard cursor -}+    -> m ()+terminalMatchSetCursor terminal tag cursor = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeCursor <- case cursor of+        Nothing -> return nullPtr+        Just jCursor -> do+            jCursor' <- unsafeManagedPtrCastPtr jCursor+            return jCursor'+    vte_terminal_match_set_cursor terminal' tag maybeCursor+    touchManagedPtr terminal+    whenJust cursor touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalMatchSetCursorMethodInfo+instance (signature ~ (Int32 -> Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) => O.MethodInfo TerminalMatchSetCursorMethodInfo a signature where+    overloadedMethod _ = terminalMatchSetCursor++#endif++-- method Terminal::match_set_cursor_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_set_cursor_name" vte_terminal_match_set_cursor_name :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- tag : TBasicType TInt+    CString ->                              -- cursor_name : TBasicType TUTF8+    IO ()++{- |+Sets which cursor the terminal will use if the pointer is over the pattern+specified by /@tag@/.+-}+terminalMatchSetCursorName ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}+    -> T.Text+    {- ^ /@cursorName@/: the name of the cursor -}+    -> m ()+terminalMatchSetCursorName terminal tag cursorName = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    cursorName' <- textToCString cursorName+    vte_terminal_match_set_cursor_name terminal' tag cursorName'+    touchManagedPtr terminal+    freeMem cursorName'+    return ()++#if ENABLE_OVERLOADING+data TerminalMatchSetCursorNameMethodInfo+instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorNameMethodInfo a signature where+    overloadedMethod _ = terminalMatchSetCursorName++#endif++-- method Terminal::match_set_cursor_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_type", argType = TInterface (Name {namespace = "Gdk", name = "CursorType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkCursorType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_match_set_cursor_type" vte_terminal_match_set_cursor_type :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- tag : TBasicType TInt+    CInt ->                                 -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})+    IO ()++{-# DEPRECATED terminalMatchSetCursorType ["(Since version 0.54)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}+{- |+Sets which cursor the terminal will use if the pointer is over the pattern+specified by /@tag@/.+-}+terminalMatchSetCursorType ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}+    -> Gdk.Enums.CursorType+    {- ^ /@cursorType@/: a 'GI.Gdk.Enums.CursorType' -}+    -> m ()+terminalMatchSetCursorType terminal tag cursorType = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let cursorType' = (fromIntegral . fromEnum) cursorType+    vte_terminal_match_set_cursor_type terminal' tag cursorType'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalMatchSetCursorTypeMethodInfo+instance (signature ~ (Int32 -> Gdk.Enums.CursorType -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorTypeMethodInfo a signature where+    overloadedMethod _ = terminalMatchSetCursorType++#endif++-- method Terminal::paste_clipboard+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_paste_clipboard" vte_terminal_paste_clipboard :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Sends the contents of the @/GDK_SELECTION_CLIPBOARD/@ selection to the+terminal\'s child. It\'s called on paste menu item, or when+user presses Shift+Insert.+-}+terminalPasteClipboard ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalPasteClipboard terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_paste_clipboard terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalPasteClipboardMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPasteClipboardMethodInfo a signature where+    overloadedMethod _ = terminalPasteClipboard++#endif++-- method Terminal::paste_primary+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_paste_primary" vte_terminal_paste_primary :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Sends the contents of the @/GDK_SELECTION_PRIMARY/@ selection to the terminal\'s+child. The terminal will call also paste the+@/GDK_SELECTION_PRIMARY/@ selection when the user clicks with the the second+mouse button.+-}+terminalPastePrimary ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalPastePrimary terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_paste_primary terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalPastePrimaryMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPastePrimaryMethodInfo a signature where+    overloadedMethod _ = terminalPastePrimary++#endif++-- method Terminal::pty_new_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Vte", name = "PtyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #VtePtyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Pty"}))+-- throws : True+-- Skip return : False++foreign import ccall "vte_terminal_pty_new_sync" vte_terminal_pty_new_sync :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Vte.Pty.Pty)++{- |+Creates a new 'GI.Vte.Objects.Pty.Pty', and sets the emulation property+from 'GI.Vte.Objects.Terminal.Terminal':@/emulation/@.++See @/vte_pty_new()/@ for more information.+-}+terminalPtyNewSync ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> [Vte.Flags.PtyFlags]+    {- ^ /@flags@/: flags from 'GI.Vte.Flags.PtyFlags' -}+    -> Maybe (b)+    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}+    -> m Vte.Pty.Pty+    {- ^ __Returns:__ a new 'GI.Vte.Objects.Pty.Pty' /(Can throw 'Data.GI.Base.GError.GError')/ -}+terminalPtyNewSync terminal flags cancellable = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ vte_terminal_pty_new_sync terminal' flags' maybeCancellable+        checkUnexpectedReturnNULL "terminalPtyNewSync" result+        result' <- (wrapObject Vte.Pty.Pty) result+        touchManagedPtr terminal+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data TerminalPtyNewSyncMethodInfo+instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (b) -> m Vte.Pty.Pty), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalPtyNewSyncMethodInfo a signature where+    overloadedMethod _ = terminalPtyNewSync++#endif++-- method Terminal::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clear_tabstops", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to reset tabstops", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clear_history", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to empty the terminal's scrollback buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_reset" vte_terminal_reset :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- clear_tabstops : TBasicType TBoolean+    CInt ->                                 -- clear_history : TBasicType TBoolean+    IO ()++{- |+Resets as much of the terminal\'s internal state as possible, discarding any+unprocessed input data, resetting character attributes, cursor state,+national character set state, status line, terminal modes (insert\/delete),+selection state, and encoding.+-}+terminalReset ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@clearTabstops@/: whether to reset tabstops -}+    -> Bool+    {- ^ /@clearHistory@/: whether to empty the terminal\'s scrollback buffer -}+    -> m ()+terminalReset terminal clearTabstops clearHistory = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let clearTabstops' = (fromIntegral . fromEnum) clearTabstops+    let clearHistory' = (fromIntegral . fromEnum) clearHistory+    vte_terminal_reset terminal' clearTabstops' clearHistory'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalResetMethodInfo+instance (signature ~ (Bool -> Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalResetMethodInfo a signature where+    overloadedMethod _ = terminalReset++#endif++-- method Terminal::search_find_next+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_find_next" vte_terminal_search_find_next :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Searches the next string matching the search regex set with+'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.+-}+terminalSearchFindNext ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if a match was found -}+terminalSearchFindNext terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_search_find_next terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalSearchFindNextMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindNextMethodInfo a signature where+    overloadedMethod _ = terminalSearchFindNext++#endif++-- method Terminal::search_find_previous+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_find_previous" vte_terminal_search_find_previous :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+Searches the previous string matching the search regex set with+'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.+-}+terminalSearchFindPrevious ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if a match was found -}+terminalSearchFindPrevious terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_search_find_previous terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalSearchFindPreviousMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindPreviousMethodInfo a signature where+    overloadedMethod _ = terminalSearchFindPrevious++#endif++-- method Terminal::search_get_gregex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Regex"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_get_gregex" vte_terminal_search_get_gregex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO (Ptr GLib.Regex.Regex)++{-# DEPRECATED terminalSearchGetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchGetRegex' instead."] #-}+{- |+/No description available in the introspection data./+-}+terminalSearchGetGregex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m GLib.Regex.Regex+    {- ^ __Returns:__ 'Nothing' -}+terminalSearchGetGregex terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_search_get_gregex terminal'+    checkUnexpectedReturnNULL "terminalSearchGetGregex" result+    result' <- (newBoxed GLib.Regex.Regex) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalSearchGetGregexMethodInfo+instance (signature ~ (m GLib.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetGregexMethodInfo a signature where+    overloadedMethod _ = terminalSearchGetGregex++#endif++-- method Terminal::search_get_regex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Regex"}))+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_get_regex" vte_terminal_search_get_regex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO (Ptr Vte.Regex.Regex)++{- |+/No description available in the introspection data./++/Since: 0.46/+-}+terminalSearchGetRegex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Vte.Regex.Regex+    {- ^ __Returns:__ the search 'GI.Vte.Structs.Regex.Regex' regex set in /@terminal@/, or 'Nothing' -}+terminalSearchGetRegex terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_search_get_regex terminal'+    checkUnexpectedReturnNULL "terminalSearchGetRegex" result+    result' <- (newBoxed Vte.Regex.Regex) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalSearchGetRegexMethodInfo+instance (signature ~ (m Vte.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetRegexMethodInfo a signature where+    overloadedMethod _ = terminalSearchGetRegex++#endif++-- method Terminal::search_get_wrap_around+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_get_wrap_around" vte_terminal_search_get_wrap_around :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO CInt++{- |+/No description available in the introspection data./+-}+terminalSearchGetWrapAround ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m Bool+    {- ^ __Returns:__ whether searching will wrap around -}+terminalSearchGetWrapAround terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    result <- vte_terminal_search_get_wrap_around terminal'+    let result' = (/= 0) result+    touchManagedPtr terminal+    return result'++#if ENABLE_OVERLOADING+data TerminalSearchGetWrapAroundMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetWrapAroundMethodInfo a signature where+    overloadedMethod _ = terminalSearchGetWrapAround++#endif++-- method Terminal::search_set_gregex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gregex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GRegex, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gflags", argType = TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #GRegexMatchFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_set_gregex" vte_terminal_search_set_gregex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})+    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})+    IO ()++{-# DEPRECATED terminalSearchSetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchSetRegex' instead."] #-}+{- |+Sets the 'GI.GLib.Structs.Regex.Regex' regex to search for. Unsets the search regex when passed 'Nothing'.+-}+terminalSearchSetGregex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (GLib.Regex.Regex)+    {- ^ /@gregex@/: a 'GI.GLib.Structs.Regex.Regex', or 'Nothing' -}+    -> [GLib.Flags.RegexMatchFlags]+    {- ^ /@gflags@/: flags from 'GI.GLib.Flags.RegexMatchFlags' -}+    -> m ()+terminalSearchSetGregex terminal gregex gflags = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeGregex <- case gregex of+        Nothing -> return nullPtr+        Just jGregex -> do+            jGregex' <- unsafeManagedPtrGetPtr jGregex+            return jGregex'+    let gflags' = gflagsToWord gflags+    vte_terminal_search_set_gregex terminal' maybeGregex gflags'+    touchManagedPtr terminal+    whenJust gregex touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSearchSetGregexMethodInfo+instance (signature ~ (Maybe (GLib.Regex.Regex) -> [GLib.Flags.RegexMatchFlags] -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetGregexMethodInfo a signature where+    overloadedMethod _ = terminalSearchSetGregex++#endif++-- method Terminal::search_set_regex+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #VteRegex, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "PCRE2 match flags, or 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_set_regex" vte_terminal_search_set_regex :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})+    Word32 ->                               -- flags : TBasicType TUInt32+    IO ()++{- |+Sets the regex to search for. Unsets the search regex when passed 'Nothing'.++/Since: 0.46/+-}+terminalSearchSetRegex ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Vte.Regex.Regex)+    {- ^ /@regex@/: a 'GI.Vte.Structs.Regex.Regex', or 'Nothing' -}+    -> Word32+    {- ^ /@flags@/: PCRE2 match flags, or 0 -}+    -> m ()+terminalSearchSetRegex terminal regex flags = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeRegex <- case regex of+        Nothing -> return nullPtr+        Just jRegex -> do+            jRegex' <- unsafeManagedPtrGetPtr jRegex+            return jRegex'+    vte_terminal_search_set_regex terminal' maybeRegex flags+    touchManagedPtr terminal+    whenJust regex touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSearchSetRegexMethodInfo+instance (signature ~ (Maybe (Vte.Regex.Regex) -> Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetRegexMethodInfo a signature where+    overloadedMethod _ = terminalSearchSetRegex++#endif++-- method Terminal::search_set_wrap_around+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_around", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether search should wrap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_search_set_wrap_around" vte_terminal_search_set_wrap_around :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- wrap_around : TBasicType TBoolean+    IO ()++{- |+Sets whether search should wrap around to the beginning of the+terminal content when reaching its end.+-}+terminalSearchSetWrapAround ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@wrapAround@/: whether search should wrap -}+    -> m ()+terminalSearchSetWrapAround terminal wrapAround = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let wrapAround' = (fromIntegral . fromEnum) wrapAround+    vte_terminal_search_set_wrap_around terminal' wrapAround'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSearchSetWrapAroundMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetWrapAroundMethodInfo a signature where+    overloadedMethod _ = terminalSearchSetWrapAround++#endif++-- method Terminal::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_select_all" vte_terminal_select_all :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Selects all text within the terminal (including the scrollback buffer).+-}+terminalSelectAll ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalSelectAll terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_select_all terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSelectAllMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSelectAllMethodInfo a signature where+    overloadedMethod _ = terminalSelectAll++#endif++-- method Terminal::set_allow_bold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_bold", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should attempt to draw bold text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_allow_bold" vte_terminal_set_allow_bold :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- allow_bold : TBasicType TBoolean+    IO ()++{- |+Controls whether or not the terminal will attempt to draw bold text,+either by using a bold font variant or by repainting text with a different+offset.+-}+terminalSetAllowBold ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@allowBold@/: 'True' if the terminal should attempt to draw bold text -}+    -> m ()+terminalSetAllowBold terminal allowBold = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let allowBold' = (fromIntegral . fromEnum) allowBold+    vte_terminal_set_allow_bold terminal' allowBold'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetAllowBoldMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowBoldMethodInfo a signature where+    overloadedMethod _ = terminalSetAllowBold++#endif++-- method Terminal::set_allow_hyperlink+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_hyperlink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should allow hyperlinks", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_allow_hyperlink" vte_terminal_set_allow_hyperlink :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- allow_hyperlink : TBasicType TBoolean+    IO ()++{- |+Controls whether or not hyperlinks (OSC 8 escape sequence) are allowed.++/Since: 0.50/+-}+terminalSetAllowHyperlink ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@allowHyperlink@/: 'True' if the terminal should allow hyperlinks -}+    -> m ()+terminalSetAllowHyperlink terminal allowHyperlink = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let allowHyperlink' = (fromIntegral . fromEnum) allowHyperlink+    vte_terminal_set_allow_hyperlink terminal' allowHyperlink'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetAllowHyperlinkMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowHyperlinkMethodInfo a signature where+    overloadedMethod _ = terminalSetAllowHyperlink++#endif++-- method Terminal::set_audible_bell+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_audible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should beep", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_audible_bell" vte_terminal_set_audible_bell :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- is_audible : TBasicType TBoolean+    IO ()++{- |+Controls whether or not the terminal will beep when the child outputs the+\"bl\" sequence.+-}+terminalSetAudibleBell ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@isAudible@/: 'True' if the terminal should beep -}+    -> m ()+terminalSetAudibleBell terminal isAudible = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let isAudible' = (fromIntegral . fromEnum) isAudible+    vte_terminal_set_audible_bell terminal' isAudible'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetAudibleBellMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAudibleBellMethodInfo a signature where+    overloadedMethod _ = terminalSetAudibleBell++#endif++-- method Terminal::set_backspace_binding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Vte", name = "EraseBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteEraseBinding for the backspace key", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_backspace_binding" vte_terminal_set_backspace_binding :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})+    IO ()++{- |+Modifies the terminal\'s backspace key binding, which controls what+string or control sequence the terminal sends to its child when the user+presses the backspace key.+-}+terminalSetBackspaceBinding ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.EraseBinding+    {- ^ /@binding@/: a 'GI.Vte.Enums.EraseBinding' for the backspace key -}+    -> m ()+terminalSetBackspaceBinding terminal binding = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let binding' = (fromIntegral . fromEnum) binding+    vte_terminal_set_backspace_binding terminal' binding'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetBackspaceBindingMethodInfo+instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBackspaceBindingMethodInfo a signature where+    overloadedMethod _ = terminalSetBackspaceBinding++#endif++-- method Terminal::set_bold_is_bright+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bold_is_bright", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if bold should also enable bright", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_bold_is_bright" vte_terminal_set_bold_is_bright :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- bold_is_bright : TBasicType TBoolean+    IO ()++{- |+Sets whether the SGR 1 attribute also switches to the bright counterpart+of the first 8 palette colors, in addition to making them bold (legacy behavior)+or if SGR 1 only enables bold and leaves the color intact.++/Since: 0.52/+-}+terminalSetBoldIsBright ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@boldIsBright@/: 'True' if bold should also enable bright -}+    -> m ()+terminalSetBoldIsBright terminal boldIsBright = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let boldIsBright' = (fromIntegral . fromEnum) boldIsBright+    vte_terminal_set_bold_is_bright terminal' boldIsBright'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetBoldIsBrightMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBoldIsBrightMethodInfo a signature where+    overloadedMethod _ = terminalSetBoldIsBright++#endif++-- method Terminal::set_cell_height_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the cell height scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_cell_height_scale" vte_terminal_set_cell_height_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CDouble ->                              -- scale : TBasicType TDouble+    IO ()++{- |+Sets the terminal\'s cell height scale to /@scale@/.++This can be used to increase the line spacing. (The font\'s height is not affected.)+Valid values go from 1.0 (default) to 2.0 (\"double spacing\").++/Since: 0.52/+-}+terminalSetCellHeightScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Double+    {- ^ /@scale@/: the cell height scale -}+    -> m ()+terminalSetCellHeightScale terminal scale = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let scale' = realToFrac scale+    vte_terminal_set_cell_height_scale terminal' scale'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetCellHeightScaleMethodInfo+instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellHeightScaleMethodInfo a signature where+    overloadedMethod _ = terminalSetCellHeightScale++#endif++-- method Terminal::set_cell_width_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the cell width scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_cell_width_scale" vte_terminal_set_cell_width_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CDouble ->                              -- scale : TBasicType TDouble+    IO ()++{- |+Sets the terminal\'s cell width scale to /@scale@/.++This can be used to increase the letter spacing. (The font\'s width is not affected.)+Valid values go from 1.0 (default) to 2.0.++/Since: 0.52/+-}+terminalSetCellWidthScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Double+    {- ^ /@scale@/: the cell width scale -}+    -> m ()+terminalSetCellWidthScale terminal scale = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let scale' = realToFrac scale+    vte_terminal_set_cell_width_scale terminal' scale'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetCellWidthScaleMethodInfo+instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellWidthScaleMethodInfo a signature where+    overloadedMethod _ = terminalSetCellWidthScale++#endif++-- method Terminal::set_cjk_ambiguous_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "either 1 (narrow) or 2 (wide)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_cjk_ambiguous_width" vte_terminal_set_cjk_ambiguous_width :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- width : TBasicType TInt+    IO ()++{- |+This setting controls whether ambiguous-width characters are narrow or wide.+(Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',+the width of ambiguous-width characters is fixed and determined by the encoding+itself.)+-}+terminalSetCjkAmbiguousWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@width@/: either 1 (narrow) or 2 (wide) -}+    -> m ()+terminalSetCjkAmbiguousWidth terminal width = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_set_cjk_ambiguous_width terminal' width+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetCjkAmbiguousWidthMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCjkAmbiguousWidthMethodInfo a signature where+    overloadedMethod _ = terminalSetCjkAmbiguousWidth++#endif++-- method Terminal::set_clear_background+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_clear_background" vte_terminal_set_clear_background :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()++{- |+Sets whether to paint the background with the background colour.+The default is 'True'.++This function is rarely useful. One use for it is to add a background+image to the terminal.++/Since: 0.52/+-}+terminalSetClearBackground ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    -> m ()+terminalSetClearBackground terminal setting = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let setting' = (fromIntegral . fromEnum) setting+    vte_terminal_set_clear_background terminal' setting'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetClearBackgroundMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetClearBackgroundMethodInfo a signature where+    overloadedMethod _ = terminalSetClearBackground++#endif++-- method Terminal::set_color_background+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_background" vte_terminal_set_color_background :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the background color for text which does not have a specific background+color assigned.  Only has effect when no background image is set and when+the terminal is not transparent.+-}+terminalSetColorBackground ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Gdk.RGBA.RGBA+    {- ^ /@background@/: the new background color -}+    -> m ()+terminalSetColorBackground terminal background = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    background' <- unsafeManagedPtrGetPtr background+    vte_terminal_set_color_background terminal' background'+    touchManagedPtr terminal+    touchManagedPtr background+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorBackgroundMethodInfo+instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBackgroundMethodInfo a signature where+    overloadedMethod _ = terminalSetColorBackground++#endif++-- method Terminal::set_color_bold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bold", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new bold color or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_bold" vte_terminal_set_color_bold :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- bold : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the color used to draw bold text in the default foreground color.+If /@bold@/ is 'Nothing' then the default color is used.+-}+terminalSetColorBold ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@bold@/: the new bold color or 'Nothing' -}+    -> m ()+terminalSetColorBold terminal bold = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeBold <- case bold of+        Nothing -> return nullPtr+        Just jBold -> do+            jBold' <- unsafeManagedPtrGetPtr jBold+            return jBold'+    vte_terminal_set_color_bold terminal' maybeBold+    touchManagedPtr terminal+    whenJust bold touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorBoldMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBoldMethodInfo a signature where+    overloadedMethod _ = terminalSetColorBold++#endif++-- method Terminal::set_color_cursor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for the text cursor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_cursor" vte_terminal_set_color_cursor :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- cursor_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the background color for text which is under the cursor.  If 'Nothing', text+under the cursor will be drawn with foreground and background colors+reversed.+-}+terminalSetColorCursor ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@cursorBackground@/: the new color to use for the text cursor, or 'Nothing' -}+    -> m ()+terminalSetColorCursor terminal cursorBackground = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeCursorBackground <- case cursorBackground of+        Nothing -> return nullPtr+        Just jCursorBackground -> do+            jCursorBackground' <- unsafeManagedPtrGetPtr jCursorBackground+            return jCursorBackground'+    vte_terminal_set_color_cursor terminal' maybeCursorBackground+    touchManagedPtr terminal+    whenJust cursorBackground touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorCursorMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorMethodInfo a signature where+    overloadedMethod _ = terminalSetColorCursor++#endif++-- method Terminal::set_color_cursor_foreground+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for the text cursor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_cursor_foreground" vte_terminal_set_color_cursor_foreground :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- cursor_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the foreground color for text which is under the cursor.  If 'Nothing', text+under the cursor will be drawn with foreground and background colors+reversed.++/Since: 0.44/+-}+terminalSetColorCursorForeground ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@cursorForeground@/: the new color to use for the text cursor, or 'Nothing' -}+    -> m ()+terminalSetColorCursorForeground terminal cursorForeground = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeCursorForeground <- case cursorForeground of+        Nothing -> return nullPtr+        Just jCursorForeground -> do+            jCursorForeground' <- unsafeManagedPtrGetPtr jCursorForeground+            return jCursorForeground'+    vte_terminal_set_color_cursor_foreground terminal' maybeCursorForeground+    touchManagedPtr terminal+    whenJust cursorForeground touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorCursorForegroundMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorForegroundMethodInfo a signature where+    overloadedMethod _ = terminalSetColorCursorForeground++#endif++-- method Terminal::set_color_foreground+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new foreground color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_foreground" vte_terminal_set_color_foreground :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the foreground color used to draw normal text.+-}+terminalSetColorForeground ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Gdk.RGBA.RGBA+    {- ^ /@foreground@/: the new foreground color -}+    -> m ()+terminalSetColorForeground terminal foreground = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    foreground' <- unsafeManagedPtrGetPtr foreground+    vte_terminal_set_color_foreground terminal' foreground'+    touchManagedPtr terminal+    touchManagedPtr foreground+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorForegroundMethodInfo+instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorForegroundMethodInfo a signature where+    overloadedMethod _ = terminalSetColorForeground++#endif++-- method Terminal::set_color_highlight+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight_background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for highlighted text, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_highlight" vte_terminal_set_color_highlight :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- highlight_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the background color for text which is highlighted.  If 'Nothing',+it is unset.  If neither highlight background nor highlight foreground are set,+highlighted text (which is usually highlighted because it is selected) will+be drawn with foreground and background colors reversed.+-}+terminalSetColorHighlight ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@highlightBackground@/: the new color to use for highlighted text, or 'Nothing' -}+    -> m ()+terminalSetColorHighlight terminal highlightBackground = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeHighlightBackground <- case highlightBackground of+        Nothing -> return nullPtr+        Just jHighlightBackground -> do+            jHighlightBackground' <- unsafeManagedPtrGetPtr jHighlightBackground+            return jHighlightBackground'+    vte_terminal_set_color_highlight terminal' maybeHighlightBackground+    touchManagedPtr terminal+    whenJust highlightBackground touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorHighlightMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightMethodInfo a signature where+    overloadedMethod _ = terminalSetColorHighlight++#endif++-- method Terminal::set_color_highlight_foreground+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight_foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for highlighted text, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_color_highlight_foreground" vte_terminal_set_color_highlight_foreground :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- highlight_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    IO ()++{- |+Sets the foreground color for text which is highlighted.  If 'Nothing',+it is unset.  If neither highlight background nor highlight foreground are set,+highlighted text (which is usually highlighted because it is selected) will+be drawn with foreground and background colors reversed.+-}+terminalSetColorHighlightForeground ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@highlightForeground@/: the new color to use for highlighted text, or 'Nothing' -}+    -> m ()+terminalSetColorHighlightForeground terminal highlightForeground = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeHighlightForeground <- case highlightForeground of+        Nothing -> return nullPtr+        Just jHighlightForeground -> do+            jHighlightForeground' <- unsafeManagedPtrGetPtr jHighlightForeground+            return jHighlightForeground'+    vte_terminal_set_color_highlight_foreground terminal' maybeHighlightForeground+    touchManagedPtr terminal+    whenJust highlightForeground touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorHighlightForegroundMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightForegroundMethodInfo a signature where+    overloadedMethod _ = terminalSetColorHighlightForeground++#endif++-- method Terminal::set_colors+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new foreground color, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new background color, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "palette", argType = TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_colors" vte_terminal_set_colors :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})+    Ptr Gdk.RGBA.RGBA ->                    -- palette : TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"}))+    Word64 ->                               -- palette_size : TBasicType TUInt64+    IO ()++{- |+/@palette@/ specifies the new values for the 256 palette colors: 8 standard colors,+their 8 bright counterparts, 6x6x6 color cube, and 24 grayscale colors.+Omitted entries will default to a hardcoded value.++/@paletteSize@/ must be 0, 8, 16, 232 or 256.++If /@foreground@/ is 'Nothing' and /@paletteSize@/ is greater than 0, the new foreground+color is taken from /@palette@/[7].  If /@background@/ is 'Nothing' and /@paletteSize@/ is+greater than 0, the new background color is taken from /@palette@/[0].+-}+terminalSetColors ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@foreground@/: the new foreground color, or 'Nothing' -}+    -> Maybe (Gdk.RGBA.RGBA)+    {- ^ /@background@/: the new background color, or 'Nothing' -}+    -> Maybe ([Gdk.RGBA.RGBA])+    {- ^ /@palette@/: the color palette -}+    -> m ()+terminalSetColors terminal foreground background palette = liftIO $ do+    let paletteSize = case palette of+            Nothing -> 0+            Just jPalette -> fromIntegral $ length jPalette+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeForeground <- case foreground of+        Nothing -> return nullPtr+        Just jForeground -> do+            jForeground' <- unsafeManagedPtrGetPtr jForeground+            return jForeground'+    maybeBackground <- case background of+        Nothing -> return nullPtr+        Just jBackground -> do+            jBackground' <- unsafeManagedPtrGetPtr jBackground+            return jBackground'+    maybePalette <- case palette of+        Nothing -> return nullPtr+        Just jPalette -> do+            jPalette' <- mapM unsafeManagedPtrGetPtr jPalette+            jPalette'' <- packBlockArray 32 jPalette'+            return jPalette''+    vte_terminal_set_colors terminal' maybeForeground maybeBackground maybePalette paletteSize+    touchManagedPtr terminal+    whenJust foreground touchManagedPtr+    whenJust background touchManagedPtr+    whenJust palette (mapM_ touchManagedPtr)+    freeMem maybePalette+    return ()++#if ENABLE_OVERLOADING+data TerminalSetColorsMethodInfo+instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> Maybe (Gdk.RGBA.RGBA) -> Maybe ([Gdk.RGBA.RGBA]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorsMethodInfo a signature where+    overloadedMethod _ = terminalSetColors++#endif++-- method Terminal::set_cursor_blink_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteCursorBlinkMode to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_cursor_blink_mode" vte_terminal_set_cursor_blink_mode :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- mode : TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})+    IO ()++{- |+Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'+will use the 'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.+-}+terminalSetCursorBlinkMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.CursorBlinkMode+    {- ^ /@mode@/: the 'GI.Vte.Enums.CursorBlinkMode' to use -}+    -> m ()+terminalSetCursorBlinkMode terminal mode = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let mode' = (fromIntegral . fromEnum) mode+    vte_terminal_set_cursor_blink_mode terminal' mode'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetCursorBlinkModeMethodInfo+instance (signature ~ (Vte.Enums.CursorBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorBlinkModeMethodInfo a signature where+    overloadedMethod _ = terminalSetCursorBlinkMode++#endif++-- method Terminal::set_cursor_shape+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shape", argType = TInterface (Name {namespace = "Vte", name = "CursorShape"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteCursorShape to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_cursor_shape" vte_terminal_set_cursor_shape :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- shape : TInterface (Name {namespace = "Vte", name = "CursorShape"})+    IO ()++{- |+Sets the shape of the cursor drawn.+-}+terminalSetCursorShape ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.CursorShape+    {- ^ /@shape@/: the 'GI.Vte.Enums.CursorShape' to use -}+    -> m ()+terminalSetCursorShape terminal shape = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let shape' = (fromIntegral . fromEnum) shape+    vte_terminal_set_cursor_shape terminal' shape'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetCursorShapeMethodInfo+instance (signature ~ (Vte.Enums.CursorShape -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorShapeMethodInfo a signature where+    overloadedMethod _ = terminalSetCursorShape++#endif++-- method Terminal::set_default_colors+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_default_colors" vte_terminal_set_default_colors :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Reset the terminal palette to reasonable compiled-in default color.+-}+terminalSetDefaultColors ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalSetDefaultColors terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_set_default_colors terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetDefaultColorsMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDefaultColorsMethodInfo a signature where+    overloadedMethod _ = terminalSetDefaultColors++#endif++-- method Terminal::set_delete_binding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Vte", name = "EraseBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteEraseBinding for the delete key", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_delete_binding" vte_terminal_set_delete_binding :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})+    IO ()++{- |+Modifies the terminal\'s delete key binding, which controls what+string or control sequence the terminal sends to its child when the user+presses the delete key.+-}+terminalSetDeleteBinding ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.EraseBinding+    {- ^ /@binding@/: a 'GI.Vte.Enums.EraseBinding' for the delete key -}+    -> m ()+terminalSetDeleteBinding terminal binding = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let binding' = (fromIntegral . fromEnum) binding+    vte_terminal_set_delete_binding terminal' binding'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetDeleteBindingMethodInfo+instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDeleteBindingMethodInfo a signature where+    overloadedMethod _ = terminalSetDeleteBinding++#endif++-- method Terminal::set_encoding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "codeset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a valid #GIConv target, or %NULL to use UTF-8", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_terminal_set_encoding" vte_terminal_set_encoding :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CString ->                              -- codeset : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED terminalSetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}+{- |+Changes the encoding the terminal will expect data from the child to+be encoded with.  For certain terminal types, applications executing in the+terminal can change the encoding. If /@codeset@/ is 'Nothing', it uses \"UTF-8\".++Note: Support for non-UTF-8 is deprecated and may get removed altogether.+Instead of this function, you should use a wrapper like luit(1) when+spawning the child process.+-}+terminalSetEncoding ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (T.Text)+    {- ^ /@codeset@/: a valid @/GIConv/@ target, or 'Nothing' to use UTF-8 -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+terminalSetEncoding terminal codeset = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeCodeset <- case codeset of+        Nothing -> return nullPtr+        Just jCodeset -> do+            jCodeset' <- textToCString jCodeset+            return jCodeset'+    onException (do+        _ <- propagateGError $ vte_terminal_set_encoding terminal' maybeCodeset+        touchManagedPtr terminal+        freeMem maybeCodeset+        return ()+     ) (do+        freeMem maybeCodeset+     )++#if ENABLE_OVERLOADING+data TerminalSetEncodingMethodInfo+instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetEncodingMethodInfo a signature where+    overloadedMethod _ = terminalSetEncoding++#endif++-- method Terminal::set_font+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_desc", argType = TInterface (Name {namespace = "Pango", name = "FontDescription"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PangoFontDescription for the desired font, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_font" vte_terminal_set_font :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})+    IO ()++{- |+Sets the font used for rendering all text displayed by the terminal,+overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal+will immediately attempt to load the desired font, retrieve its+metrics, and attempt to resize itself to keep the same number of rows+and columns.  The font scale is applied to the specified font.+-}+terminalSetFont ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (Pango.FontDescription.FontDescription)+    {- ^ /@fontDesc@/: a 'GI.Pango.Structs.FontDescription.FontDescription' for the desired font, or 'Nothing' -}+    -> m ()+terminalSetFont terminal fontDesc = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybeFontDesc <- case fontDesc of+        Nothing -> return nullPtr+        Just jFontDesc -> do+            jFontDesc' <- unsafeManagedPtrGetPtr jFontDesc+            return jFontDesc'+    vte_terminal_set_font terminal' maybeFontDesc+    touchManagedPtr terminal+    whenJust fontDesc touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetFontMethodInfo+instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontMethodInfo a signature where+    overloadedMethod _ = terminalSetFont++#endif++-- method Terminal::set_font_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the font scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_font_scale" vte_terminal_set_font_scale :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CDouble ->                              -- scale : TBasicType TDouble+    IO ()++{- |+Sets the terminal\'s font scale to /@scale@/.+-}+terminalSetFontScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Double+    {- ^ /@scale@/: the font scale -}+    -> m ()+terminalSetFontScale terminal scale = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let scale' = realToFrac scale+    vte_terminal_set_font_scale terminal' scale'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetFontScaleMethodInfo+instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontScaleMethodInfo a signature where+    overloadedMethod _ = terminalSetFontScale++#endif++-- method Terminal::set_geometry_hints_for_window+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gtk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_geometry_hints_for_window" vte_terminal_set_geometry_hints_for_window :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gtk.Window.Window ->                -- window : TInterface (Name {namespace = "Gtk", name = "Window"})+    IO ()++{-# DEPRECATED terminalSetGeometryHintsForWindow ["(Since version 0.52)"] #-}+{- |+Sets /@terminal@/ as /@window@/\'s geometry widget. See+'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.++/@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').+-}+terminalSetGeometryHintsForWindow ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> b+    {- ^ /@window@/: a 'GI.Gtk.Objects.Window.Window' -}+    -> m ()+terminalSetGeometryHintsForWindow terminal window = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    window' <- unsafeManagedPtrCastPtr window+    vte_terminal_set_geometry_hints_for_window terminal' window'+    touchManagedPtr terminal+    touchManagedPtr window+    return ()++#if ENABLE_OVERLOADING+data TerminalSetGeometryHintsForWindowMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) => O.MethodInfo TerminalSetGeometryHintsForWindowMethodInfo a signature where+    overloadedMethod _ = terminalSetGeometryHintsForWindow++#endif++-- method Terminal::set_input_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable user input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_input_enabled" vte_terminal_set_input_enabled :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()++{- |+Enables or disables user input. When user input is disabled,+the terminal\'s child will not receive any key press, or mouse button+press or motion events sent to it.+-}+terminalSetInputEnabled ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@enabled@/: whether to enable user input -}+    -> m ()+terminalSetInputEnabled terminal enabled = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let enabled' = (fromIntegral . fromEnum) enabled+    vte_terminal_set_input_enabled terminal' enabled'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetInputEnabledMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetInputEnabledMethodInfo a signature where+    overloadedMethod _ = terminalSetInputEnabled++#endif++-- method Terminal::set_mouse_autohide+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the mouse pointer should autohide", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_mouse_autohide" vte_terminal_set_mouse_autohide :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()++{- |+Changes the value of the terminal\'s mouse autohide setting.  When autohiding+is enabled, the mouse cursor will be hidden when the user presses a key and+shown when the user moves the mouse.  This setting can be read using+'GI.Vte.Objects.Terminal.terminalGetMouseAutohide'.+-}+terminalSetMouseAutohide ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@setting@/: whether the mouse pointer should autohide -}+    -> m ()+terminalSetMouseAutohide terminal setting = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let setting' = (fromIntegral . fromEnum) setting+    vte_terminal_set_mouse_autohide terminal' setting'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetMouseAutohideMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetMouseAutohideMethodInfo a signature where+    overloadedMethod _ = terminalSetMouseAutohide++#endif++-- method Terminal::set_pty+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #VtePty, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_pty" vte_terminal_set_pty :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Vte.Pty.Pty ->                      -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})+    IO ()++{- |+Sets /@pty@/ as the PTY to use in /@terminal@/.+Use 'Nothing' to unset the PTY.+-}+terminalSetPty ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Vte.Pty.IsPty b) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Maybe (b)+    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty', or 'Nothing' -}+    -> m ()+terminalSetPty terminal pty = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    maybePty <- case pty of+        Nothing -> return nullPtr+        Just jPty -> do+            jPty' <- unsafeManagedPtrCastPtr jPty+            return jPty'+    vte_terminal_set_pty terminal' maybePty+    touchManagedPtr terminal+    whenJust pty touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data TerminalSetPtyMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Vte.Pty.IsPty b) => O.MethodInfo TerminalSetPtyMethodInfo a signature where+    overloadedMethod _ = terminalSetPty++#endif++-- method Terminal::set_rewrap_on_resize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rewrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should rewrap on resize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_rewrap_on_resize" vte_terminal_set_rewrap_on_resize :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- rewrap : TBasicType TBoolean+    IO ()++{- |+Controls whether or not the terminal will rewrap its contents, including+the scrollback history, whenever the terminal\'s width changes.+-}+terminalSetRewrapOnResize ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@rewrap@/: 'True' if the terminal should rewrap on resize -}+    -> m ()+terminalSetRewrapOnResize terminal rewrap = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let rewrap' = (fromIntegral . fromEnum) rewrap+    vte_terminal_set_rewrap_on_resize terminal' rewrap'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetRewrapOnResizeMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetRewrapOnResizeMethodInfo a signature where+    overloadedMethod _ = terminalSetRewrapOnResize++#endif++-- method Terminal::set_scroll_on_keystroke+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the terminal should scroll on keystrokes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_scroll_on_keystroke" vte_terminal_set_scroll_on_keystroke :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- scroll : TBasicType TBoolean+    IO ()++{- |+Controls whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the user presses a key.  Modifier keys do not+trigger this behavior.+-}+terminalSetScrollOnKeystroke ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@scroll@/: whether the terminal should scroll on keystrokes -}+    -> m ()+terminalSetScrollOnKeystroke terminal scroll = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let scroll' = (fromIntegral . fromEnum) scroll+    vte_terminal_set_scroll_on_keystroke terminal' scroll'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetScrollOnKeystrokeMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnKeystrokeMethodInfo a signature where+    overloadedMethod _ = terminalSetScrollOnKeystroke++#endif++-- method Terminal::set_scroll_on_output+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the terminal should scroll on output", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_scroll_on_output" vte_terminal_set_scroll_on_output :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CInt ->                                 -- scroll : TBasicType TBoolean+    IO ()++{- |+Controls whether or not the terminal will forcibly scroll to the bottom of+the viewable history when the new data is received from the child.+-}+terminalSetScrollOnOutput ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Bool+    {- ^ /@scroll@/: whether the terminal should scroll on output -}+    -> m ()+terminalSetScrollOnOutput terminal scroll = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let scroll' = (fromIntegral . fromEnum) scroll+    vte_terminal_set_scroll_on_output terminal' scroll'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetScrollOnOutputMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnOutputMethodInfo a signature where+    overloadedMethod _ = terminalSetScrollOnOutput++#endif++-- method Terminal::set_scroll_speed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll_speed", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "move the buffer by this number of lines while scrolling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_scroll_speed" vte_terminal_set_scroll_speed :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Word32 ->                               -- scroll_speed : TBasicType TUInt+    IO ()++{- |+Sets the number of lines by which the buffer is moved when+scrolling with a mouse wheel. Setting it to zero will cause the+buffer to be moved by an amount depending on the number of visible+rows the widget can display.+-}+terminalSetScrollSpeed ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Word32+    {- ^ /@scrollSpeed@/: move the buffer by this number of lines while scrolling -}+    -> m ()+terminalSetScrollSpeed terminal scrollSpeed = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_set_scroll_speed terminal' scrollSpeed+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetScrollSpeedMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollSpeedMethodInfo a signature where+    overloadedMethod _ = terminalSetScrollSpeed++#endif++-- method Terminal::set_scrollback_lines+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the history buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_scrollback_lines" vte_terminal_set_scrollback_lines :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CLong ->                                -- lines : TBasicType TLong+    IO ()++{- |+Sets the length of the scrollback buffer used by the terminal.  The size of+the scrollback buffer will be set to the larger of this value and the number+of visible rows the widget can display, so 0 can safely be used to disable+scrollback.++A negative value means \"infinite scrollback\".++Note that this setting only affects the normal screen buffer.+No scrollback is allowed on the alternate screen buffer.+-}+terminalSetScrollbackLines ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> CLong+    {- ^ /@lines@/: the length of the history buffer -}+    -> m ()+terminalSetScrollbackLines terminal lines = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_set_scrollback_lines terminal' lines+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetScrollbackLinesMethodInfo+instance (signature ~ (CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollbackLinesMethodInfo a signature where+    overloadedMethod _ = terminalSetScrollbackLines++#endif++-- method Terminal::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "columns", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of columns", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_size" vte_terminal_set_size :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CLong ->                                -- columns : TBasicType TLong+    CLong ->                                -- rows : TBasicType TLong+    IO ()++{- |+Attempts to change the terminal\'s size in terms of rows and columns.  If+the attempt succeeds, the widget will resize itself to the proper size.+-}+terminalSetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> CLong+    {- ^ /@columns@/: the desired number of columns -}+    -> CLong+    {- ^ /@rows@/: the desired number of rows -}+    -> m ()+terminalSetSize terminal columns rows = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_set_size terminal' columns rows+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetSizeMethodInfo+instance (signature ~ (CLong -> CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetSizeMethodInfo a signature where+    overloadedMethod _ = terminalSetSize++#endif++-- method Terminal::set_text_blink_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text_blink_mode", argType = TInterface (Name {namespace = "Vte", name = "TextBlinkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteTextBlinkMode to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_text_blink_mode" vte_terminal_set_text_blink_mode :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- text_blink_mode : TInterface (Name {namespace = "Vte", name = "TextBlinkMode"})+    IO ()++{- |+Controls whether or not the terminal will allow blinking text.++/Since: 0.52/+-}+terminalSetTextBlinkMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Vte.Enums.TextBlinkMode+    {- ^ /@textBlinkMode@/: the 'GI.Vte.Enums.TextBlinkMode' to use -}+    -> m ()+terminalSetTextBlinkMode terminal textBlinkMode = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let textBlinkMode' = (fromIntegral . fromEnum) textBlinkMode+    vte_terminal_set_text_blink_mode terminal' textBlinkMode'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalSetTextBlinkModeMethodInfo+instance (signature ~ (Vte.Enums.TextBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetTextBlinkModeMethodInfo a signature where+    overloadedMethod _ = terminalSetTextBlinkMode++#endif++-- method Terminal::set_word_char_exceptions+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exceptions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string of ASCII punctuation characters, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_set_word_char_exceptions" vte_terminal_set_word_char_exceptions :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CString ->                              -- exceptions : TBasicType TUTF8+    IO ()++{- |+With this function you can provide a set of characters which will+be considered parts of a word when doing word-wise selection, in+addition to the default which only considers alphanumeric characters+part of a word.++The characters in /@exceptions@/ must be non-alphanumeric, each character+must occur only once, and if /@exceptions@/ contains the character+U+002D HYPHEN-MINUS, it must be at the start of the string.++Use 'Nothing' to reset the set of exception characters to the default.++/Since: 0.40/+-}+terminalSetWordCharExceptions ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> T.Text+    {- ^ /@exceptions@/: a string of ASCII punctuation characters, or 'Nothing' -}+    -> m ()+terminalSetWordCharExceptions terminal exceptions = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    exceptions' <- textToCString exceptions+    vte_terminal_set_word_char_exceptions terminal' exceptions'+    touchManagedPtr terminal+    freeMem exceptions'+    return ()++#if ENABLE_OVERLOADING+data TerminalSetWordCharExceptionsMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetWordCharExceptionsMethodInfo a signature where+    overloadedMethod _ = terminalSetWordCharExceptions++#endif++-- method Terminal::spawn_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pty_flags", argType = TInterface (Name {namespace = "Vte", name = "PtyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #VtePtyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "working_directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of a directory the command should start\n  in, or %NULL to use the current working directory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "child's argument vector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "envv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of environment\n  variables to be added to the environment before starting the process, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "spawn_flags", argType = TInterface (Name {namespace = "GLib", name = "SpawnFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #GSpawnFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_setup", argType = TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an extra child setup function to run in the child just before exec(), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_setup_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for @child_setup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_pid", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the child PID, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_terminal_spawn_sync" vte_terminal_spawn_sync :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})+    CString ->                              -- working_directory : TBasicType TUTF8+    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)+    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)+    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})+    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})+    Ptr () ->                               -- child_setup_data : TBasicType TPtr+    Ptr Int32 ->                            -- child_pid : TBasicType TInt+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED terminalSpawnSync ["(Since version 0.48)","Use @/vte_terminal_spawn_async()/@ instead."] #-}+{- |+Starts the specified command under a newly-allocated controlling+pseudo-terminal.  The /@argv@/ and /@envv@/ lists should be 'Nothing'-terminated.+The \"TERM\" environment variable is automatically set to a default value,+but can be overridden from /@envv@/.+/@ptyFlags@/ controls logging the session to the specified system log files.++Note that 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' will always be added to /@spawnFlags@/.++Note that all open file descriptors will be closed in the child. If you want+to keep some file descriptor open for use in the child process, you need to+use a child setup function that unsets the FD_CLOEXEC flag on that file+descriptor.++See @/vte_pty_new()/@, 'GI.GLib.Functions.spawnAsync' and 'GI.Vte.Objects.Terminal.terminalWatchChild' for more information.++Beginning with 0.52, sets PWD to /@workingDirectory@/ in order to preserve symlink components.+The caller should also make sure that symlinks were preserved while constructing the value of /@workingDirectory@/,+e.g. by using 'GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri', 'GI.GLib.Functions.getCurrentDir' or @/get_current_dir_name()/@.+-}+terminalSpawnSync ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> [Vte.Flags.PtyFlags]+    {- ^ /@ptyFlags@/: flags from 'GI.Vte.Flags.PtyFlags' -}+    -> Maybe (T.Text)+    {- ^ /@workingDirectory@/: the name of a directory the command should start+  in, or 'Nothing' to use the current working directory -}+    -> [[Char]]+    {- ^ /@argv@/: child\'s argument vector -}+    -> Maybe ([[Char]])+    {- ^ /@envv@/: a list of environment+  variables to be added to the environment before starting the process, or 'Nothing' -}+    -> [GLib.Flags.SpawnFlags]+    {- ^ /@spawnFlags@/: flags from 'GI.GLib.Flags.SpawnFlags' -}+    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)+    {- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'Nothing' -}+    -> Maybe (b)+    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}+    -> m (Int32)+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+terminalSpawnSync terminal ptyFlags workingDirectory argv envv spawnFlags childSetup cancellable = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    let ptyFlags' = gflagsToWord ptyFlags+    maybeWorkingDirectory <- case workingDirectory of+        Nothing -> return nullPtr+        Just jWorkingDirectory -> do+            jWorkingDirectory' <- textToCString jWorkingDirectory+            return jWorkingDirectory'+    argv' <- packZeroTerminatedFileNameArray argv+    maybeEnvv <- case envv of+        Nothing -> return nullPtr+        Just jEnvv -> do+            jEnvv' <- packZeroTerminatedFileNameArray jEnvv+            return jEnvv'+    let spawnFlags' = gflagsToWord spawnFlags+    maybeChildSetup <- case childSetup of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jChildSetup -> do+            jChildSetup' <- GLib.Callbacks.mk_SpawnChildSetupFunc (GLib.Callbacks.wrap_SpawnChildSetupFunc Nothing (GLib.Callbacks.drop_closures_SpawnChildSetupFunc jChildSetup))+            return jChildSetup'+    childPid <- allocMem :: IO (Ptr Int32)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    let childSetupData = nullPtr+    onException (do+        _ <- propagateGError $ vte_terminal_spawn_sync terminal' ptyFlags' maybeWorkingDirectory argv' maybeEnvv spawnFlags' maybeChildSetup childSetupData childPid maybeCancellable+        childPid' <- peek childPid+        safeFreeFunPtr $ castFunPtrToPtr maybeChildSetup+        touchManagedPtr terminal+        whenJust cancellable touchManagedPtr+        freeMem maybeWorkingDirectory+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        mapZeroTerminatedCArray freeMem maybeEnvv+        freeMem maybeEnvv+        freeMem childPid+        return childPid'+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr maybeChildSetup+        freeMem maybeWorkingDirectory+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        mapZeroTerminatedCArray freeMem maybeEnvv+        freeMem maybeEnvv+        freeMem childPid+     )++#if ENABLE_OVERLOADING+data TerminalSpawnSyncMethodInfo+instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (T.Text) -> [[Char]] -> Maybe ([[Char]]) -> [GLib.Flags.SpawnFlags] -> Maybe (GLib.Callbacks.SpawnChildSetupFunc) -> Maybe (b) -> m (Int32)), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalSpawnSyncMethodInfo a signature where+    overloadedMethod _ = terminalSpawnSync++#endif++-- method Terminal::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_unselect_all" vte_terminal_unselect_all :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    IO ()++{- |+Clears the current selection.+-}+terminalUnselectAll ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> m ()+terminalUnselectAll terminal = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_unselect_all terminal'+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalUnselectAllMethodInfo+instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalUnselectAllMethodInfo a signature where+    overloadedMethod _ = terminalUnselectAll++#endif++-- method Terminal::watch_child+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_pid", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "vte_terminal_watch_child" vte_terminal_watch_child :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Int32 ->                                -- child_pid : TBasicType TInt+    IO ()++{- |+Watches /@childPid@/. When the process exists, the 'GI.Vte.Objects.Terminal.Terminal'::@/child-exited/@+signal will be called with the child\'s exit status.++Prior to calling this function, a 'GI.Vte.Objects.Pty.Pty' must have been set in /@terminal@/+using 'GI.Vte.Objects.Terminal.terminalSetPty'.+When the child exits, the terminal\'s 'GI.Vte.Objects.Pty.Pty' will be set to 'Nothing'.++Note: @/g_child_watch_add()/@ or 'GI.GLib.Functions.childWatchAdd' must not have+been called for /@childPid@/, nor a 'GI.GLib.Structs.Source.Source' for it been created with+'GI.GLib.Functions.childWatchSourceNew'.++Note: when using the 'GI.GLib.Functions.spawnAsync' family of functions,+the 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' flag MUST have been passed.+-}+terminalWatchChild ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> Int32+    {- ^ /@childPid@/: a @/GPid/@ -}+    -> m ()+terminalWatchChild terminal childPid = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    vte_terminal_watch_child terminal' childPid+    touchManagedPtr terminal+    return ()++#if ENABLE_OVERLOADING+data TerminalWatchChildMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalWatchChildMethodInfo a signature where+    overloadedMethod _ = terminalWatchChild++#endif++-- method Terminal::write_contents_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream to write to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Vte", name = "WriteFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #VteWriteFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "vte_terminal_write_contents_sync" vte_terminal_write_contents_sync :: +    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})+    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "WriteFlags"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Write contents of the current contents of /@terminal@/ (including any+scrollback history) to /@stream@/ according to /@flags@/.++If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by triggering+the cancellable object from another thread. If the operation was cancelled,+the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned in /@error@/.++This is a synchronous operation and will make the widget (and input+processing) during the write operation, which may take a long time+depending on scrollback history and /@stream@/ availability for writing.+-}+terminalWriteContentsSync ::+    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>+    a+    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}+    -> b+    {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' to write to -}+    -> Vte.Enums.WriteFlags+    {- ^ /@flags@/: a set of 'GI.Vte.Enums.WriteFlags' -}+    -> Maybe (c)+    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+terminalWriteContentsSync terminal stream flags cancellable = liftIO $ do+    terminal' <- unsafeManagedPtrCastPtr terminal+    stream' <- unsafeManagedPtrCastPtr stream+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ vte_terminal_write_contents_sync terminal' stream' flags' maybeCancellable+        touchManagedPtr terminal+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data TerminalWriteContentsSyncMethodInfo+instance (signature ~ (b -> Vte.Enums.WriteFlags -> Maybe (c) -> m ()), MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TerminalWriteContentsSyncMethodInfo a signature where+    overloadedMethod _ = terminalWriteContentsSync++#endif++