diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -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. diff --git a/GI/Vte.hs b/GI/Vte.hs new file mode 100644 --- /dev/null +++ b/GI/Vte.hs @@ -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 + diff --git a/GI/Vte/Callbacks.hs b/GI/Vte/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Callbacks.hs @@ -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' + + + diff --git a/GI/Vte/Constants.hs b/GI/Vte/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Constants.hs @@ -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 + + diff --git a/GI/Vte/Enums.hs b/GI/Vte/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Enums.hs @@ -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 + + diff --git a/GI/Vte/Enums.hs-boot b/GI/Vte/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Enums.hs-boot @@ -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 diff --git a/GI/Vte/Flags.hs b/GI/Vte/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Flags.hs @@ -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 + + diff --git a/GI/Vte/Flags.hs-boot b/GI/Vte/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Flags.hs-boot @@ -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 diff --git a/GI/Vte/Functions.hs b/GI/Vte/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Functions.hs @@ -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' + + + diff --git a/GI/Vte/Objects.hs b/GI/Vte/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Objects.hs @@ -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 + + + diff --git a/GI/Vte/Objects/Pty.hs b/GI/Vte/Objects/Pty.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Objects/Pty.hs @@ -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 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 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 + + diff --git a/GI/Vte/Objects/Pty.hs-boot b/GI/Vte/Objects/Pty.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Objects/Pty.hs-boot @@ -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 diff --git a/GI/Vte/Objects/Terminal.hs b/GI/Vte/Objects/Terminal.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Objects/Terminal.hs @@ -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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 + + diff --git a/GI/Vte/Objects/Terminal.hs-boot b/GI/Vte/Objects/Terminal.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Objects/Terminal.hs-boot @@ -0,0 +1,527 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Vte.Objects.Terminal 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 Terminal = Terminal (ManagedPtr Terminal) +instance GObject Terminal where +class (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o +instance (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o +instance O.HasParentTypes Terminal +#if ENABLE_OVERLOADING +data TerminalAllowBoldPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalAllowHyperlinkPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalAudibleBellPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalBackspaceBindingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalBoldIsBrightPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCellHeightScalePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCellWidthScalePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCjkAmbiguousWidthPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCurrentDirectoryUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCurrentFileUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCursorBlinkModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCursorShapePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalDeleteBindingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalEncodingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalFontDescPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalFontScalePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalHyperlinkHoverUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalIconTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalInputEnabledPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPointerAutohidePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPtyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalRewrapOnResizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalScrollOnKeystrokePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalScrollOnOutputPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalScrollSpeedPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalScrollbackLinesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalTextBlinkModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalWindowTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalWordCharExceptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TerminalBellSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCharSizeChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalChildExitedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCommitSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalContentsChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCopyClipboardSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCurrentDirectoryUriChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCurrentFileUriChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCursorMovedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalDecreaseFontSizeSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalDeiconifyWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalEncodingChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalEofSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalHyperlinkHoverUriChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalIconTitleChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalIconifyWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalIncreaseFontSizeSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalLowerWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMaximizeWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMoveWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalNotificationReceivedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPasteClipboardSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalRaiseWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalRefreshWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalResizeWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalRestoreWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSelectionChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalTextDeletedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalTextInsertedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalTextModifiedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalTextScrolledSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalWindowTitleChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCopyClipboardMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCopyClipboardFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalCopyPrimaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalFeedMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalFeedChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalFeedChildBinaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetAllowBoldMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetAllowHyperlinkMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetAudibleBellMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetBoldIsBrightMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCellHeightScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCellWidthScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCharHeightMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCharWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCjkAmbiguousWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetColorBackgroundForDrawMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetColumnCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCurrentDirectoryUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCurrentFileUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCursorBlinkModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCursorPositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetCursorShapeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetFontMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetFontScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetGeometryHintsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetHasSelectionMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetIconTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetInputEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetMouseAutohideMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetPtyMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetRewrapOnResizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetRowCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetScrollOnKeystrokeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetScrollOnOutputMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetScrollbackLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetTextBlinkModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetTextIncludeTrailingSpacesMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetTextRangeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetWindowTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalGetWordCharExceptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalHyperlinkCheckEventMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchAddGregexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchAddRegexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchCheckMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchCheckEventMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchRemoveAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchSetCursorMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchSetCursorNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalMatchSetCursorTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPasteClipboardMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPastePrimaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalPtyNewSyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalResetMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchFindNextMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchFindPreviousMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchGetGregexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchGetRegexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchGetWrapAroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchSetGregexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchSetRegexMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSearchSetWrapAroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSelectAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetAllowBoldMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetAllowHyperlinkMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetAudibleBellMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetBackspaceBindingMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetBoldIsBrightMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetCellHeightScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetCellWidthScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetCjkAmbiguousWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetClearBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorBoldMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorCursorMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorCursorForegroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorForegroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorHighlightMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorHighlightForegroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetColorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetCursorBlinkModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetCursorShapeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetDefaultColorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetDeleteBindingMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetFontMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetFontScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetGeometryHintsForWindowMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetInputEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetMouseAutohideMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetPtyMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetRewrapOnResizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetScrollOnKeystrokeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetScrollOnOutputMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetScrollSpeedMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetScrollbackLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetTextBlinkModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSetWordCharExceptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalSpawnSyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalUnselectAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalWatchChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data TerminalWriteContentsSyncMethodInfo +#endif diff --git a/GI/Vte/Structs.hs b/GI/Vte/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Structs.hs @@ -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.Structs + ( module GI.Vte.Structs.CharAttributes , + module GI.Vte.Structs.Regex , + + + ) where + +import GI.Vte.Structs.CharAttributes +import GI.Vte.Structs.Regex + +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 + + + diff --git a/GI/Vte/Structs/CharAttributes.hs b/GI/Vte/Structs/CharAttributes.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Structs/CharAttributes.hs @@ -0,0 +1,88 @@ + + +{- | +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.Structs.CharAttributes + ( + +-- * Exported types + CharAttributes(..) , + newZeroCharAttributes , + noCharAttributes , + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype CharAttributes = CharAttributes (ManagedPtr CharAttributes) +instance WrappedPtr CharAttributes where + wrappedPtrCalloc = callocBytes 40 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr CharAttributes) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `CharAttributes` struct initialized to zero. +newZeroCharAttributes :: MonadIO m => m CharAttributes +newZeroCharAttributes = liftIO $ wrappedPtrCalloc >>= wrapPtr CharAttributes + +instance tag ~ 'AttrSet => Constructible CharAttributes tag where + new _ attrs = do + o <- newZeroCharAttributes + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `CharAttributes`. +noCharAttributes :: Maybe CharAttributes +noCharAttributes = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CharAttributes +type instance O.AttributeList CharAttributes = CharAttributesAttributeList +type CharAttributesAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveCharAttributesMethod (t :: Symbol) (o :: *) :: * where + ResolveCharAttributesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCharAttributesMethod t CharAttributes, O.MethodInfo info CharAttributes p) => OL.IsLabel t (CharAttributes -> 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 + + diff --git a/GI/Vte/Structs/CharAttributes.hs-boot b/GI/Vte/Structs/CharAttributes.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Structs/CharAttributes.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Vte.Structs.CharAttributes 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 CharAttributes = CharAttributes (ManagedPtr CharAttributes) +instance WrappedPtr CharAttributes where diff --git a/GI/Vte/Structs/Regex.hs b/GI/Vte/Structs/Regex.hs new file mode 100644 --- /dev/null +++ b/GI/Vte/Structs/Regex.hs @@ -0,0 +1,366 @@ + + +{- | +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.Structs.Regex + ( + +-- * Exported types + Regex(..) , + noRegex , + + + -- * Methods +-- ** jit #method:jit# + +#if ENABLE_OVERLOADING + RegexJitMethodInfo , +#endif + regexJit , + + +-- ** newForMatch #method:newForMatch# + + regexNewForMatch , + + +-- ** newForSearch #method:newForSearch# + + regexNewForSearch , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RegexRefMethodInfo , +#endif + regexRef , + + +-- ** substitute #method:substitute# + +#if ENABLE_OVERLOADING + RegexSubstituteMethodInfo , +#endif + regexSubstitute , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RegexUnrefMethodInfo , +#endif + regexUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype Regex = Regex (ManagedPtr Regex) +foreign import ccall "vte_regex_get_type" c_vte_regex_get_type :: + IO GType + +instance BoxedObject Regex where + boxedType _ = c_vte_regex_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Regex`. +noRegex :: Maybe Regex +noRegex = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Regex +type instance O.AttributeList Regex = RegexAttributeList +type RegexAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Regex::new_for_match +-- method type : Constructor +-- Args : [Arg {argCName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Regex"})) +-- throws : True +-- Skip return : False + +foreign import ccall "vte_regex_new_for_match" vte_regex_new_for_match :: + CString -> -- pattern : TBasicType TUTF8 + Int64 -> -- pattern_length : TBasicType TInt64 + Word32 -> -- flags : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO (Ptr Regex) + +{- | +/No description available in the introspection data./ +-} +regexNewForMatch :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> Int64 + -> Word32 + -> m Regex + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +regexNewForMatch pattern patternLength flags = liftIO $ do + pattern' <- textToCString pattern + onException (do + result <- propagateGError $ vte_regex_new_for_match pattern' patternLength flags + checkUnexpectedReturnNULL "regexNewForMatch" result + result' <- (wrapBoxed Regex) result + freeMem pattern' + return result' + ) (do + freeMem pattern' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Regex::new_for_search +-- method type : Constructor +-- Args : [Arg {argCName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Regex"})) +-- throws : True +-- Skip return : False + +foreign import ccall "vte_regex_new_for_search" vte_regex_new_for_search :: + CString -> -- pattern : TBasicType TUTF8 + Int64 -> -- pattern_length : TBasicType TInt64 + Word32 -> -- flags : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO (Ptr Regex) + +{- | +/No description available in the introspection data./ +-} +regexNewForSearch :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> Int64 + -> Word32 + -> m Regex + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +regexNewForSearch pattern patternLength flags = liftIO $ do + pattern' <- textToCString pattern + onException (do + result <- propagateGError $ vte_regex_new_for_search pattern' patternLength flags + checkUnexpectedReturnNULL "regexNewForSearch" result + result' <- (wrapBoxed Regex) result + freeMem pattern' + return result' + ) (do + freeMem pattern' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Regex::jit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 = Nothing, 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_regex_jit" vte_regex_jit :: + Ptr Regex -> -- regex : TInterface (Name {namespace = "Vte", name = "Regex"}) + Word32 -> -- flags : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +regexJit :: + (B.CallStack.HasCallStack, MonadIO m) => + Regex + -> Word32 + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +regexJit regex flags = liftIO $ do + regex' <- unsafeManagedPtrGetPtr regex + onException (do + _ <- propagateGError $ vte_regex_jit regex' flags + touchManagedPtr regex + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RegexJitMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo RegexJitMethodInfo Regex signature where + overloadedMethod _ = regexJit + +#endif + +-- method Regex::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_regex_ref" vte_regex_ref :: + Ptr Regex -> -- regex : TInterface (Name {namespace = "Vte", name = "Regex"}) + IO (Ptr Regex) + +{- | +/No description available in the introspection data./ +-} +regexRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Regex + -> m Regex +regexRef regex = liftIO $ do + regex' <- unsafeManagedPtrGetPtr regex + result <- vte_regex_ref regex' + checkUnexpectedReturnNULL "regexRef" result + result' <- (wrapBoxed Regex) result + touchManagedPtr regex + return result' + +#if ENABLE_OVERLOADING +data RegexRefMethodInfo +instance (signature ~ (m Regex), MonadIO m) => O.MethodInfo RegexRefMethodInfo Regex signature where + overloadedMethod _ = regexRef + +#endif + +-- method Regex::substitute +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subject", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replacement", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "vte_regex_substitute" vte_regex_substitute :: + Ptr Regex -> -- regex : TInterface (Name {namespace = "Vte", name = "Regex"}) + CString -> -- subject : TBasicType TUTF8 + CString -> -- replacement : TBasicType TUTF8 + Word32 -> -- flags : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO CString + +{- | +/No description available in the introspection data./ +-} +regexSubstitute :: + (B.CallStack.HasCallStack, MonadIO m) => + Regex + -> T.Text + -> T.Text + -> Word32 + -> m T.Text + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +regexSubstitute regex subject replacement flags = liftIO $ do + regex' <- unsafeManagedPtrGetPtr regex + subject' <- textToCString subject + replacement' <- textToCString replacement + onException (do + result <- propagateGError $ vte_regex_substitute regex' subject' replacement' flags + checkUnexpectedReturnNULL "regexSubstitute" result + result' <- cstringToText result + freeMem result + touchManagedPtr regex + freeMem subject' + freeMem replacement' + return result' + ) (do + freeMem subject' + freeMem replacement' + ) + +#if ENABLE_OVERLOADING +data RegexSubstituteMethodInfo +instance (signature ~ (T.Text -> T.Text -> Word32 -> m T.Text), MonadIO m) => O.MethodInfo RegexSubstituteMethodInfo Regex signature where + overloadedMethod _ = regexSubstitute + +#endif + +-- method Regex::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_regex_unref" vte_regex_unref :: + Ptr Regex -> -- regex : TInterface (Name {namespace = "Vte", name = "Regex"}) + IO (Ptr Regex) + +{- | +/No description available in the introspection data./ +-} +regexUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Regex + -> m Regex +regexUnref regex = liftIO $ do + regex' <- unsafeManagedPtrGetPtr regex + result <- vte_regex_unref regex' + checkUnexpectedReturnNULL "regexUnref" result + result' <- (wrapBoxed Regex) result + touchManagedPtr regex + return result' + +#if ENABLE_OVERLOADING +data RegexUnrefMethodInfo +instance (signature ~ (m Regex), MonadIO m) => O.MethodInfo RegexUnrefMethodInfo Regex signature where + overloadedMethod _ = regexUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRegexMethod (t :: Symbol) (o :: *) :: * where + ResolveRegexMethod "jit" o = RegexJitMethodInfo + ResolveRegexMethod "ref" o = RegexRefMethodInfo + ResolveRegexMethod "substitute" o = RegexSubstituteMethodInfo + ResolveRegexMethod "unref" o = RegexUnrefMethodInfo + ResolveRegexMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRegexMethod t Regex, O.MethodInfo info Regex p) => OL.IsLabel t (Regex -> 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 + + diff --git a/GI/Vte/Structs/Regex.hs-boot b/GI/Vte/Structs/Regex.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Vte/Structs/Regex.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Vte.Structs.Regex 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 Regex = Regex (ManagedPtr Regex) +instance BoxedObject Regex where +#if ENABLE_OVERLOADING +data RegexJitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegexRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegexSubstituteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegexUnrefMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-vte library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-vte library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-vte libraries, or to link their applications against a +user-supplied version of gi-vte. If you link applications to a modified +version of gi-vte, then the changes to gi-vte must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-vte-2.91.19/docs/GI-Vte.html](https://hackage.haskell.org/package/gi-vte-2.91.19/docs/GI-Vte.html) +[https://hackage.haskell.org/package/gi-vte-2.91.21/docs/GI-Vte.html](https://hackage.haskell.org/package/gi-vte-2.91.21/docs/GI-Vte.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-vte.cabal b/gi-vte.cabal --- a/gi-vte.cabal +++ b/gi-vte.cabal @@ -1,12 +1,12 @@ name: gi-vte -version: 2.91.19 +version: 2.91.21 synopsis: Vte bindings description: Bindings for Vte, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom cabal-version: 1.24 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml Vte.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: vte-2.91 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-pango == 1.0.*, gi-gtk == 3.0.*, @@ -45,3 +45,16 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.Vte, + GI.Vte.Callbacks, + GI.Vte.Constants, + GI.Vte.Enums, + GI.Vte.Flags, + GI.Vte.Functions, + GI.Vte.Objects, + GI.Vte.Objects.Pty, + GI.Vte.Objects.Terminal, + GI.Vte.Structs, + GI.Vte.Structs.CharAttributes, + GI.Vte.Structs.Regex diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7