-- Generated code.

{-# OPTIONS_GHC -fno-warn-unused-imports #-}

{-# LANGUAGE ForeignFunctionInterface, ConstraintKinds,
    TypeFamilies, MultiParamTypeClasses, KindSignatures,
    FlexibleInstances, UndecidableInstances, DataKinds,
    OverloadedStrings, NegativeLiterals, FlexibleContexts #-}

module GI.Vte where

import Prelude ()
import Data.GI.Base.ShortPrelude
import Data.Char
import Data.Int
import Data.Word
import qualified Data.ByteString.Char8 as B
import Data.ByteString.Char8 (ByteString)
import qualified Data.Map as Map
import Foreign.C
import Foreign.Ptr
import Foreign.ForeignPtr
import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
import Foreign.Storable (peek, poke, sizeOf)
import Control.Applicative ((<$>))
import Control.Exception (onException)
import Control.Monad.IO.Class
import qualified Data.Text as T

import Data.GI.Base.Attributes hiding (get, set)
import Data.GI.Base.BasicTypes
import Data.GI.Base.BasicConversions
import Data.GI.Base.Closure
import Data.GI.Base.GError
import Data.GI.Base.GHashTable
import Data.GI.Base.GParamSpec
import Data.GI.Base.GVariant
import Data.GI.Base.GValue
import Data.GI.Base.ManagedPtr
import Data.GI.Base.Overloading
import Data.GI.Base.Properties hiding (new)
import Data.GI.Base.Signals (SignalConnectMode(..), connectSignalFunPtr, SignalHandlerId)
import Data.GI.Base.Utils

import qualified GI.Atk as Atk
import qualified GI.AtkAttributes as AtkA
import qualified GI.GLib as GLib
import qualified GI.GLibAttributes as GLibA
import qualified GI.GObject as GObject
import qualified GI.GObjectAttributes as GObjectA
import qualified GI.Gdk as Gdk
import qualified GI.GdkAttributes as GdkA
import qualified GI.Gio as Gio
import qualified GI.GioAttributes as GioA
import qualified GI.Gtk as Gtk
import qualified GI.GtkAttributes as GtkA
import qualified GI.Pango as Pango
import qualified GI.PangoAttributes as PangoA

-- struct CharAttributes
newtype CharAttributes = CharAttributes (ForeignPtr CharAttributes)
noCharAttributes :: Maybe CharAttributes
noCharAttributes = Nothing

-- Enum CursorBlinkMode

data CursorBlinkMode = 
      CursorBlinkModeSystem
    | CursorBlinkModeOn
    | CursorBlinkModeOff
    | AnotherCursorBlinkMode Int
    deriving (Show, Eq)

instance 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

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

-- Enum CursorShape

data CursorShape = 
      CursorShapeBlock
    | CursorShapeIbeam
    | CursorShapeUnderline
    | AnotherCursorShape Int
    deriving (Show, Eq)

instance 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

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 EraseBinding

data EraseBinding = 
      EraseBindingAuto
    | EraseBindingAsciiBackspace
    | EraseBindingAsciiDelete
    | EraseBindingDeleteSequence
    | EraseBindingTty
    | AnotherEraseBinding Int
    deriving (Show, Eq)

instance 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

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

-- object Pty 
newtype Pty = Pty (ForeignPtr Pty)
noPty :: Maybe Pty
noPty = Nothing

foreign import ccall "vte_pty_get_type"
    c_vte_pty_get_type :: IO GType

type instance ParentTypes Pty = '[GObject.Object, Gio.Initable]

instance GObject Pty where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_vte_pty_get_type
    

class GObject o => PtyK o
instance (GObject o, IsDescendantOf Pty o) => PtyK o

toPty :: PtyK o => o -> IO Pty
toPty = unsafeCastTo Pty

-- method Pty::new_foreign_sync
-- method type : Constructor
-- Args : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "Pty"
-- throws : True
-- Skip return : False

foreign import ccall "vte_pty_new_foreign_sync" vte_pty_new_foreign_sync :: 
    Int32 ->                                -- fd : TBasicType TInt32
    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Pty)


ptyNewForeignSync ::
    (MonadIO m, Gio.CancellableK a) =>
    Int32 ->                                -- fd
    Maybe (a) ->                            -- cancellable
    m Pty
ptyNewForeignSync fd cancellable = liftIO $ do
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            let jCancellable' = unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ vte_pty_new_foreign_sync fd maybeCancellable
        checkUnexpectedReturnNULL "vte_pty_new_foreign_sync" result
        result' <- (wrapObject Pty) result
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

-- method Pty::new_sync
-- method type : Constructor
-- Args : [Arg {argName = "flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "Pty"
-- throws : True
-- Skip return : False

foreign import ccall "vte_pty_new_sync" vte_pty_new_sync :: 
    CUInt ->                                -- flags : TInterface "Vte" "PtyFlags"
    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Pty)


ptyNewSync ::
    (MonadIO m, Gio.CancellableK a) =>
    [PtyFlags] ->                           -- flags
    Maybe (a) ->                            -- cancellable
    m Pty
ptyNewSync flags cancellable = liftIO $ do
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            let jCancellable' = unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ vte_pty_new_sync flags' maybeCancellable
        checkUnexpectedReturnNULL "vte_pty_new_sync" result
        result' <- (wrapObject Pty) result
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

-- method Pty::child_setup
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_pty_child_setup" vte_pty_child_setup :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    IO ()


ptyChildSetup ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    m ()
ptyChildSetup _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_pty_child_setup _obj'
    touchManagedPtr _obj
    return ()

-- method Pty::close
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_pty_close" vte_pty_close :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    IO ()


ptyClose ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    m ()
ptyClose _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_pty_close _obj'
    touchManagedPtr _obj
    return ()

-- method Pty::get_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_pty_get_fd" vte_pty_get_fd :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    IO Int32


ptyGetFd ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    m Int32
ptyGetFd _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_pty_get_fd _obj'
    touchManagedPtr _obj
    return result

-- method Pty::get_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "columns", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_pty_get_size" vte_pty_get_size :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    Ptr Int32 ->                            -- rows : TBasicType TInt32
    Ptr Int32 ->                            -- columns : TBasicType TInt32
    Ptr (Ptr GError) ->                     -- error
    IO CInt


ptyGetSize ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    m (Int32,Int32)
ptyGetSize _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    rows <- allocMem :: IO (Ptr Int32)
    columns <- allocMem :: IO (Ptr Int32)
    onException (do
        _ <- propagateGError $ vte_pty_get_size _obj' rows columns
        rows' <- peek rows
        columns' <- peek columns
        touchManagedPtr _obj
        freeMem rows
        freeMem columns
        return (rows', columns')
     ) (do
        freeMem rows
        freeMem columns
     )

-- method Pty::set_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_pty_set_size" vte_pty_set_size :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    Int32 ->                                -- rows : TBasicType TInt32
    Int32 ->                                -- columns : TBasicType TInt32
    Ptr (Ptr GError) ->                     -- error
    IO CInt


ptySetSize ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- rows
    Int32 ->                                -- columns
    m ()
ptySetSize _obj rows columns = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    onException (do
        _ <- propagateGError $ vte_pty_set_size _obj' rows columns
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- method Pty::set_utf8
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "utf8", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "utf8", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_pty_set_utf8" vte_pty_set_utf8 :: 
    Ptr Pty ->                              -- _obj : TInterface "Vte" "Pty"
    CInt ->                                 -- utf8 : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt


ptySetUtf8 ::
    (MonadIO m, PtyK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- utf8
    m ()
ptySetUtf8 _obj utf8 = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let utf8' = (fromIntegral . fromEnum) utf8
    onException (do
        _ <- propagateGError $ vte_pty_set_utf8 _obj' utf8'
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- Enum PtyError

data PtyError = 
      PtyErrorPtyHelperFailed
    | PtyErrorPty98Failed
    | AnotherPtyError Int
    deriving (Show, Eq)

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

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

instance GErrorClass PtyError where
    gerrorClassDomain _ = "vte-pty-error"

catchPtyError ::
    IO a ->
    (PtyError -> GErrorMessage -> IO a) ->
    IO a
catchPtyError = catchGErrorJustDomain

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

-- Flags PtyFlags

data PtyFlags = 
      PtyFlagsNoLastlog
    | PtyFlagsNoUtmp
    | PtyFlagsNoWtmp
    | PtyFlagsNoHelper
    | PtyFlagsNoFallback
    | PtyFlagsDefault
    | AnotherPtyFlags Int
    deriving (Show, Eq)

instance 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 0 = PtyFlagsDefault
    toEnum 1 = PtyFlagsNoLastlog
    toEnum 2 = PtyFlagsNoUtmp
    toEnum 4 = PtyFlagsNoWtmp
    toEnum 8 = PtyFlagsNoHelper
    toEnum 16 = PtyFlagsNoFallback
    toEnum k = AnotherPtyFlags k

foreign import ccall "vte_pty_flags_get_type" c_vte_pty_flags_get_type :: 
    IO GType

instance BoxedEnum PtyFlags where
    boxedEnumType _ = c_vte_pty_flags_get_type

instance IsGFlag PtyFlags

-- callback SelectionFunc
selectionFuncClosure :: SelectionFunc -> IO Closure
selectionFuncClosure cb = newCClosure =<< mkSelectionFunc wrapped
    where wrapped = selectionFuncWrapper Nothing cb

type SelectionFuncC =
    Ptr Terminal ->
    Int64 ->
    Int64 ->
    Ptr () ->
    IO CInt

foreign import ccall "wrapper"
    mkSelectionFunc :: SelectionFuncC -> IO (FunPtr SelectionFuncC)

type SelectionFunc =
    Terminal ->
    Int64 ->
    Int64 ->
    IO Bool

noSelectionFunc :: Maybe SelectionFunc
noSelectionFunc = Nothing

selectionFuncWrapper ::
    Maybe (Ptr (FunPtr (SelectionFuncC))) ->
    SelectionFunc ->
    Ptr Terminal ->
    Int64 ->
    Int64 ->
    Ptr () ->
    IO CInt
selectionFuncWrapper funptrptr _cb terminal column row _ = do
    terminal' <- (newObject Terminal) terminal
    result <- _cb  terminal' column row
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'

-- object Terminal 
newtype Terminal = Terminal (ForeignPtr Terminal)
noTerminal :: Maybe Terminal
noTerminal = Nothing

foreign import ccall "vte_terminal_get_type"
    c_vte_terminal_get_type :: IO GType

type instance ParentTypes Terminal = '[Gtk.Widget, GObject.Object, Atk.ImplementorIface, Gtk.Buildable, Gtk.Scrollable]

instance GObject Terminal where
    gobjectIsInitiallyUnowned _ = True
    gobjectType _ = c_vte_terminal_get_type
    

class GObject o => TerminalK o
instance (GObject o, IsDescendantOf Terminal o) => TerminalK o

toTerminal :: TerminalK o => o -> IO Terminal
toTerminal = unsafeCastTo Terminal

-- method Terminal::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TInterface "Vte" "Terminal"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_new" vte_terminal_new :: 
    IO (Ptr Terminal)


terminalNew ::
    (MonadIO m) =>
    m Terminal
terminalNew  = liftIO $ do
    result <- vte_terminal_new
    checkUnexpectedReturnNULL "vte_terminal_new" result
    result' <- (newObject Terminal) result
    return result'

-- method Terminal::copy_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_copy_clipboard" vte_terminal_copy_clipboard :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalCopyClipboard ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalCopyClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_copy_clipboard _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::copy_primary
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_copy_primary" vte_terminal_copy_primary :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalCopyPrimary ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalCopyPrimary _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_copy_primary _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::feed
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : [Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed" vte_terminal_feed :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Int64 ->                                -- length : TBasicType TInt64
    IO ()


terminalFeed ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    ByteString ->                           -- data
    m ()
terminalFeed _obj data_ = liftIO $ do
    let length_ = fromIntegral $ B.length data_
    let _obj' = unsafeManagedPtrCastPtr _obj
    data_' <- packByteString data_
    vte_terminal_feed _obj' data_' length_
    touchManagedPtr _obj
    freeMem data_'
    return ()

-- method Terminal::feed_child
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child" vte_terminal_feed_child :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CString ->                              -- text : TBasicType TUTF8
    Int64 ->                                -- length : TBasicType TInt64
    IO ()


terminalFeedChild ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- text
    Int64 ->                                -- length
    m ()
terminalFeedChild _obj text length_ = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    text' <- textToCString text
    vte_terminal_feed_child _obj' text' length_
    touchManagedPtr _obj
    freeMem text'
    return ()

-- method Terminal::feed_child_binary
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child_binary" vte_terminal_feed_child_binary :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Word8 ->                                -- data : TBasicType TUInt8
    Word64 ->                               -- length : TBasicType TUInt64
    IO ()


terminalFeedChildBinary ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Word8 ->                                -- data
    Word64 ->                               -- length
    m ()
terminalFeedChildBinary _obj data_ length_ = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_feed_child_binary _obj' data_ length_
    touchManagedPtr _obj
    return ()

-- method Terminal::get_allow_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_allow_bold" vte_terminal_get_allow_bold :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetAllowBold ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetAllowBold _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_allow_bold _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_audible_bell
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_audible_bell" vte_terminal_get_audible_bell :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetAudibleBell ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetAudibleBell _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_audible_bell _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_char_height
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt64
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_char_height" vte_terminal_get_char_height :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO Int64


terminalGetCharHeight ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Int64
terminalGetCharHeight _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_char_height _obj'
    touchManagedPtr _obj
    return result

-- method Terminal::get_char_width
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt64
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_char_width" vte_terminal_get_char_width :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO Int64


terminalGetCharWidth ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Int64
terminalGetCharWidth _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_char_width _obj'
    touchManagedPtr _obj
    return result

-- method Terminal::get_cjk_ambiguous_width
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cjk_ambiguous_width" vte_terminal_get_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO Int32


terminalGetCjkAmbiguousWidth ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Int32
terminalGetCjkAmbiguousWidth _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_cjk_ambiguous_width _obj'
    touchManagedPtr _obj
    return result

-- method Terminal::get_column_count
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt64
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_column_count" vte_terminal_get_column_count :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO Int64


terminalGetColumnCount ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Int64
terminalGetColumnCount _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_column_count _obj'
    touchManagedPtr _obj
    return result

-- method Terminal::get_current_directory_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_directory_uri" vte_terminal_get_current_directory_uri :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetCurrentDirectoryUri ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetCurrentDirectoryUri _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_current_directory_uri _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_current_directory_uri" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_current_file_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_file_uri" vte_terminal_get_current_file_uri :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetCurrentFileUri ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetCurrentFileUri _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_current_file_uri _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_current_file_uri" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_cursor_blink_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "CursorBlinkMode"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_blink_mode" vte_terminal_get_cursor_blink_mode :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CUInt


terminalGetCursorBlinkMode ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m CursorBlinkMode
terminalGetCursorBlinkMode _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_cursor_blink_mode _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_cursor_position
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "row", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_position" vte_terminal_get_cursor_position :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Int64 ->                            -- column : TBasicType TInt64
    Ptr Int64 ->                            -- row : TBasicType TInt64
    IO ()


terminalGetCursorPosition ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m (Int64,Int64)
terminalGetCursorPosition _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    column <- allocMem :: IO (Ptr Int64)
    row <- allocMem :: IO (Ptr Int64)
    vte_terminal_get_cursor_position _obj' column row
    column' <- peek column
    row' <- peek row
    touchManagedPtr _obj
    freeMem column
    freeMem row
    return (column', row')

-- method Terminal::get_cursor_shape
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "CursorShape"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_shape" vte_terminal_get_cursor_shape :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CUInt


terminalGetCursorShape ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m CursorShape
terminalGetCursorShape _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_cursor_shape _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_encoding" vte_terminal_get_encoding :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetEncoding ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetEncoding _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_encoding _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_encoding" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_font
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Pango" "FontDescription"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_font" vte_terminal_get_font :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO (Ptr Pango.FontDescription)


terminalGetFont ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Pango.FontDescription
terminalGetFont _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_font _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_font" result
    result' <- (newBoxed Pango.FontDescription) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_font_scale
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_font_scale" vte_terminal_get_font_scale :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CDouble


terminalGetFontScale ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Double
terminalGetFontScale _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_font_scale _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_geometry_hints
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hints", argType = TInterface "Gdk" "Geometry", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_geometry_hints" vte_terminal_get_geometry_hints :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.Geometry ->                     -- hints : TInterface "Gdk" "Geometry"
    Int32 ->                                -- min_rows : TBasicType TInt32
    Int32 ->                                -- min_columns : TBasicType TInt32
    IO ()


terminalGetGeometryHints ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- min_rows
    Int32 ->                                -- min_columns
    m (Gdk.Geometry)
terminalGetGeometryHints _obj min_rows min_columns = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    hints <- callocBytes 56 :: IO (Ptr Gdk.Geometry)
    vte_terminal_get_geometry_hints _obj' hints min_rows min_columns
    hints' <- (wrapPtr Gdk.Geometry) hints
    touchManagedPtr _obj
    return hints'

-- method Terminal::get_has_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_has_selection" vte_terminal_get_has_selection :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetHasSelection ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetHasSelection _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_has_selection _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_icon_title
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_icon_title" vte_terminal_get_icon_title :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetIconTitle ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetIconTitle _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_icon_title _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_icon_title" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_input_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_input_enabled" vte_terminal_get_input_enabled :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetInputEnabled ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetInputEnabled _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_input_enabled _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_mouse_autohide
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_mouse_autohide" vte_terminal_get_mouse_autohide :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetMouseAutohide ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetMouseAutohide _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_mouse_autohide _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_pty
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "Pty"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_pty" vte_terminal_get_pty :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO (Ptr Pty)


terminalGetPty ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Pty
terminalGetPty _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_pty _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_pty" result
    result' <- (newObject Pty) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_rewrap_on_resize" vte_terminal_get_rewrap_on_resize :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalGetRewrapOnResize ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalGetRewrapOnResize _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_rewrap_on_resize _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_row_count
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt64
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_row_count" vte_terminal_get_row_count :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO Int64


terminalGetRowCount ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Int64
terminalGetRowCount _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_row_count _obj'
    touchManagedPtr _obj
    return result

-- method Terminal::get_text
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TGArray (TInterface "Vte" "CharAttributes"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text" vte_terminal_get_text :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    FunPtr SelectionFuncC ->                -- is_selected : TInterface "Vte" "SelectionFunc"
    Ptr () ->                               -- user_data : TBasicType TVoid
    Ptr (Ptr (GArray (Ptr CharAttributes))) -> -- attributes : TGArray (TInterface "Vte" "CharAttributes")
    IO CString


terminalGetText ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (SelectionFunc) ->                -- is_selected
    m (T.Text,[CharAttributes])
terminalGetText _obj is_selected = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeIs_selected <- case is_selected of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jIs_selected -> do
            jIs_selected' <- mkSelectionFunc (selectionFuncWrapper Nothing jIs_selected)
            return jIs_selected'
    attributes <- allocMem :: IO (Ptr (Ptr (GArray (Ptr CharAttributes))))
    let user_data = nullPtr
    result <- vte_terminal_get_text _obj' maybeIs_selected user_data attributes
    checkUnexpectedReturnNULL "vte_terminal_get_text" result
    result' <- cstringToText result
    freeMem result
    attributes' <- peek attributes
    attributes'' <- unpackGArray attributes'
    attributes''' <- mapM (wrapPtr CharAttributes) attributes''
    unrefGArray attributes'
    safeFreeFunPtr $ castFunPtrToPtr maybeIs_selected
    touchManagedPtr _obj
    freeMem attributes
    return (result', attributes''')

-- method Terminal::get_text_include_trailing_spaces
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TGArray (TInterface "Vte" "CharAttributes"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_include_trailing_spaces" vte_terminal_get_text_include_trailing_spaces :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    FunPtr SelectionFuncC ->                -- is_selected : TInterface "Vte" "SelectionFunc"
    Ptr () ->                               -- user_data : TBasicType TVoid
    Ptr (Ptr (GArray (Ptr CharAttributes))) -> -- attributes : TGArray (TInterface "Vte" "CharAttributes")
    IO CString


terminalGetTextIncludeTrailingSpaces ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (SelectionFunc) ->                -- is_selected
    m (T.Text,[CharAttributes])
terminalGetTextIncludeTrailingSpaces _obj is_selected = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeIs_selected <- case is_selected of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jIs_selected -> do
            jIs_selected' <- mkSelectionFunc (selectionFuncWrapper Nothing jIs_selected)
            return jIs_selected'
    attributes <- allocMem :: IO (Ptr (Ptr (GArray (Ptr CharAttributes))))
    let user_data = nullPtr
    result <- vte_terminal_get_text_include_trailing_spaces _obj' maybeIs_selected user_data attributes
    checkUnexpectedReturnNULL "vte_terminal_get_text_include_trailing_spaces" result
    result' <- cstringToText result
    freeMem result
    attributes' <- peek attributes
    attributes'' <- unpackGArray attributes'
    attributes''' <- mapM (wrapPtr CharAttributes) attributes''
    unrefGArray attributes'
    safeFreeFunPtr $ castFunPtrToPtr maybeIs_selected
    touchManagedPtr _obj
    freeMem attributes
    return (result', attributes''')

-- method Terminal::get_text_range
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_col", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_col", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TGArray (TInterface "Vte" "CharAttributes"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_col", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_col", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_selected", argType = TInterface "Vte" "SelectionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_range" vte_terminal_get_text_range :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int64 ->                                -- start_row : TBasicType TInt64
    Int64 ->                                -- start_col : TBasicType TInt64
    Int64 ->                                -- end_row : TBasicType TInt64
    Int64 ->                                -- end_col : TBasicType TInt64
    FunPtr SelectionFuncC ->                -- is_selected : TInterface "Vte" "SelectionFunc"
    Ptr () ->                               -- user_data : TBasicType TVoid
    Ptr (Ptr (GArray (Ptr CharAttributes))) -> -- attributes : TGArray (TInterface "Vte" "CharAttributes")
    IO CString


terminalGetTextRange ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int64 ->                                -- start_row
    Int64 ->                                -- start_col
    Int64 ->                                -- end_row
    Int64 ->                                -- end_col
    Maybe (SelectionFunc) ->                -- is_selected
    m (T.Text,[CharAttributes])
terminalGetTextRange _obj start_row start_col end_row end_col is_selected = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeIs_selected <- case is_selected of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jIs_selected -> do
            jIs_selected' <- mkSelectionFunc (selectionFuncWrapper Nothing jIs_selected)
            return jIs_selected'
    attributes <- allocMem :: IO (Ptr (Ptr (GArray (Ptr CharAttributes))))
    let user_data = nullPtr
    result <- vte_terminal_get_text_range _obj' start_row start_col end_row end_col maybeIs_selected user_data attributes
    checkUnexpectedReturnNULL "vte_terminal_get_text_range" result
    result' <- cstringToText result
    freeMem result
    attributes' <- peek attributes
    attributes'' <- unpackGArray attributes'
    attributes''' <- mapM (wrapPtr CharAttributes) attributes''
    unrefGArray attributes'
    safeFreeFunPtr $ castFunPtrToPtr maybeIs_selected
    touchManagedPtr _obj
    freeMem attributes
    return (result', attributes''')

-- method Terminal::get_window_title
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_window_title" vte_terminal_get_window_title :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetWindowTitle ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetWindowTitle _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_window_title _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_window_title" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::get_word_char_exceptions
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_word_char_exceptions" vte_terminal_get_word_char_exceptions :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CString


terminalGetWordCharExceptions ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m T.Text
terminalGetWordCharExceptions _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_get_word_char_exceptions _obj'
    checkUnexpectedReturnNULL "vte_terminal_get_word_char_exceptions" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method Terminal::match_add_gregex
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "regex", argType = TInterface "GLib" "Regex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "RegexMatchFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "regex", argType = TInterface "GLib" "Regex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "RegexMatchFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_gregex" vte_terminal_match_add_gregex :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr GLib.Regex ->                       -- regex : TInterface "GLib" "Regex"
    CUInt ->                                -- flags : TInterface "GLib" "RegexMatchFlags"
    IO Int32


terminalMatchAddGregex ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    GLib.Regex ->                           -- regex
    [GLib.RegexMatchFlags] ->               -- flags
    m Int32
terminalMatchAddGregex _obj regex flags = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let regex' = unsafeManagedPtrGetPtr regex
    let flags' = gflagsToWord flags
    result <- vte_terminal_match_add_gregex _obj' regex' flags'
    touchManagedPtr _obj
    touchManagedPtr regex
    return result

-- method Terminal::match_check
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check" vte_terminal_match_check :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int64 ->                                -- column : TBasicType TInt64
    Int64 ->                                -- row : TBasicType TInt64
    Ptr Int32 ->                            -- tag : TBasicType TInt32
    IO CString


terminalMatchCheck ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int64 ->                                -- column
    Int64 ->                                -- row
    m (T.Text,Int32)
terminalMatchCheck _obj column row = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    tag <- allocMem :: IO (Ptr Int32)
    result <- vte_terminal_match_check _obj' column row tag
    checkUnexpectedReturnNULL "vte_terminal_match_check" result
    result' <- cstringToText result
    freeMem result
    tag' <- peek tag
    touchManagedPtr _obj
    freeMem tag
    return (result', tag')

-- method Terminal::match_check_event
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check_event" vte_terminal_match_check_event :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"
    Ptr Int32 ->                            -- tag : TBasicType TInt32
    IO CString


terminalMatchCheckEvent ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Gdk.Event ->                            -- event
    m (T.Text,Int32)
terminalMatchCheckEvent _obj event = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let event' = unsafeManagedPtrGetPtr event
    tag <- allocMem :: IO (Ptr Int32)
    result <- vte_terminal_match_check_event _obj' event' tag
    checkUnexpectedReturnNULL "vte_terminal_match_check_event" result
    result' <- cstringToText result
    freeMem result
    tag' <- peek tag
    touchManagedPtr _obj
    touchManagedPtr event
    freeMem tag
    return (result', tag')

-- method Terminal::match_remove
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_remove" vte_terminal_match_remove :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- tag : TBasicType TInt32
    IO ()


terminalMatchRemove ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- tag
    m ()
terminalMatchRemove _obj tag = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_match_remove _obj' tag
    touchManagedPtr _obj
    return ()

-- method Terminal::match_remove_all
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_remove_all" vte_terminal_match_remove_all :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalMatchRemoveAll ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalMatchRemoveAll _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_match_remove_all _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::match_set_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor", argType = TInterface "Gdk" "Cursor", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor", argType = TInterface "Gdk" "Cursor", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor" vte_terminal_match_set_cursor :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- tag : TBasicType TInt32
    Ptr Gdk.Cursor ->                       -- cursor : TInterface "Gdk" "Cursor"
    IO ()

{-# DEPRECATED terminalMatchSetCursor ["(Since version 0.40)","Use vte_terminal_match_set_cursor_type() or vte_terminal_match_set_cursor_named() instead."]#-}
terminalMatchSetCursor ::
    (MonadIO m, TerminalK a, Gdk.CursorK b) =>
    a ->                                    -- _obj
    Int32 ->                                -- tag
    Maybe (b) ->                            -- cursor
    m ()
terminalMatchSetCursor _obj tag cursor = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeCursor <- case cursor of
        Nothing -> return nullPtr
        Just jCursor -> do
            let jCursor' = unsafeManagedPtrCastPtr jCursor
            return jCursor'
    vte_terminal_match_set_cursor _obj' tag maybeCursor
    touchManagedPtr _obj
    whenJust cursor touchManagedPtr
    return ()

-- method Terminal::match_set_cursor_name
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_name" vte_terminal_match_set_cursor_name :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- tag : TBasicType TInt32
    CString ->                              -- cursor_name : TBasicType TUTF8
    IO ()


terminalMatchSetCursorName ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- tag
    T.Text ->                               -- cursor_name
    m ()
terminalMatchSetCursorName _obj tag cursor_name = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    cursor_name' <- textToCString cursor_name
    vte_terminal_match_set_cursor_name _obj' tag cursor_name'
    touchManagedPtr _obj
    freeMem cursor_name'
    return ()

-- method Terminal::match_set_cursor_type
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_type", argType = TInterface "Gdk" "CursorType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tag", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_type", argType = TInterface "Gdk" "CursorType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_type" vte_terminal_match_set_cursor_type :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- tag : TBasicType TInt32
    CUInt ->                                -- cursor_type : TInterface "Gdk" "CursorType"
    IO ()


terminalMatchSetCursorType ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- tag
    Gdk.CursorType ->                       -- cursor_type
    m ()
terminalMatchSetCursorType _obj tag cursor_type = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let cursor_type' = (fromIntegral . fromEnum) cursor_type
    vte_terminal_match_set_cursor_type _obj' tag cursor_type'
    touchManagedPtr _obj
    return ()

-- method Terminal::paste_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_paste_clipboard" vte_terminal_paste_clipboard :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalPasteClipboard ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalPasteClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_paste_clipboard _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::paste_primary
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_paste_primary" vte_terminal_paste_primary :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalPastePrimary ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalPastePrimary _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_paste_primary _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::pty_new_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Vte" "Pty"
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_pty_new_sync" vte_terminal_pty_new_sync :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- flags : TInterface "Vte" "PtyFlags"
    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Pty)


terminalPtyNewSync ::
    (MonadIO m, TerminalK a, Gio.CancellableK b) =>
    a ->                                    -- _obj
    [PtyFlags] ->                           -- flags
    Maybe (b) ->                            -- cancellable
    m Pty
terminalPtyNewSync _obj flags cancellable = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            let jCancellable' = unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ vte_terminal_pty_new_sync _obj' flags' maybeCancellable
        checkUnexpectedReturnNULL "vte_terminal_pty_new_sync" result
        result' <- (wrapObject Pty) result
        touchManagedPtr _obj
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

-- method Terminal::reset
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "clear_tabstops", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "clear_history", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "clear_tabstops", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "clear_history", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_reset" vte_terminal_reset :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- clear_tabstops : TBasicType TBoolean
    CInt ->                                 -- clear_history : TBasicType TBoolean
    IO ()


terminalReset ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- clear_tabstops
    Bool ->                                 -- clear_history
    m ()
terminalReset _obj clear_tabstops clear_history = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let clear_tabstops' = (fromIntegral . fromEnum) clear_tabstops
    let clear_history' = (fromIntegral . fromEnum) clear_history
    vte_terminal_reset _obj' clear_tabstops' clear_history'
    touchManagedPtr _obj
    return ()

-- method Terminal::search_find_next
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_find_next" vte_terminal_search_find_next :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalSearchFindNext ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalSearchFindNext _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_search_find_next _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::search_find_previous
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_find_previous" vte_terminal_search_find_previous :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalSearchFindPrevious ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalSearchFindPrevious _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_search_find_previous _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::search_get_gregex
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GLib" "Regex"
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_get_gregex" vte_terminal_search_get_gregex :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO (Ptr GLib.Regex)


terminalSearchGetGregex ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m GLib.Regex
terminalSearchGetGregex _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_search_get_gregex _obj'
    checkUnexpectedReturnNULL "vte_terminal_search_get_gregex" result
    result' <- (newBoxed GLib.Regex) result
    touchManagedPtr _obj
    return result'

-- method Terminal::search_get_wrap_around
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_get_wrap_around" vte_terminal_search_get_wrap_around :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO CInt


terminalSearchGetWrapAround ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m Bool
terminalSearchGetWrapAround _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- vte_terminal_search_get_wrap_around _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Terminal::search_set_gregex
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "regex", argType = TInterface "GLib" "Regex", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "RegexMatchFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "regex", argType = TInterface "GLib" "Regex", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "RegexMatchFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_gregex" vte_terminal_search_set_gregex :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr GLib.Regex ->                       -- regex : TInterface "GLib" "Regex"
    CUInt ->                                -- flags : TInterface "GLib" "RegexMatchFlags"
    IO ()


terminalSearchSetGregex ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (GLib.Regex) ->                   -- regex
    [GLib.RegexMatchFlags] ->               -- flags
    m ()
terminalSearchSetGregex _obj regex flags = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeRegex <- case regex of
        Nothing -> return nullPtr
        Just jRegex -> do
            let jRegex' = unsafeManagedPtrGetPtr jRegex
            return jRegex'
    let flags' = gflagsToWord flags
    vte_terminal_search_set_gregex _obj' maybeRegex flags'
    touchManagedPtr _obj
    whenJust regex touchManagedPtr
    return ()

-- method Terminal::search_set_wrap_around
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_around", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_around", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_wrap_around" vte_terminal_search_set_wrap_around :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- wrap_around : TBasicType TBoolean
    IO ()


terminalSearchSetWrapAround ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- wrap_around
    m ()
terminalSearchSetWrapAround _obj wrap_around = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let wrap_around' = (fromIntegral . fromEnum) wrap_around
    vte_terminal_search_set_wrap_around _obj' wrap_around'
    touchManagedPtr _obj
    return ()

-- method Terminal::select_all
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_select_all" vte_terminal_select_all :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalSelectAll ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalSelectAll _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_select_all _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_allow_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_bold", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_bold", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_allow_bold" vte_terminal_set_allow_bold :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- allow_bold : TBasicType TBoolean
    IO ()


terminalSetAllowBold ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- allow_bold
    m ()
terminalSetAllowBold _obj allow_bold = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let allow_bold' = (fromIntegral . fromEnum) allow_bold
    vte_terminal_set_allow_bold _obj' allow_bold'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_audible_bell
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_audible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_audible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_audible_bell" vte_terminal_set_audible_bell :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- is_audible : TBasicType TBoolean
    IO ()


terminalSetAudibleBell ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- is_audible
    m ()
terminalSetAudibleBell _obj is_audible = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let is_audible' = (fromIntegral . fromEnum) is_audible
    vte_terminal_set_audible_bell _obj' is_audible'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_backspace_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "binding", argType = TInterface "Vte" "EraseBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "binding", argType = TInterface "Vte" "EraseBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_backspace_binding" vte_terminal_set_backspace_binding :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- binding : TInterface "Vte" "EraseBinding"
    IO ()


terminalSetBackspaceBinding ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    EraseBinding ->                         -- binding
    m ()
terminalSetBackspaceBinding _obj binding = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let binding' = (fromIntegral . fromEnum) binding
    vte_terminal_set_backspace_binding _obj' binding'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_cjk_ambiguous_width
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cjk_ambiguous_width" vte_terminal_set_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- width : TBasicType TInt32
    IO ()


terminalSetCjkAmbiguousWidth ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- width
    m ()
terminalSetCjkAmbiguousWidth _obj width = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_set_cjk_ambiguous_width _obj' width
    touchManagedPtr _obj
    return ()

-- method Terminal::set_color_background
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_background" vte_terminal_set_color_background :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- background : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorBackground ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Gdk.RGBA ->                             -- background
    m ()
terminalSetColorBackground _obj background = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let background' = unsafeManagedPtrGetPtr background
    vte_terminal_set_color_background _obj' background'
    touchManagedPtr _obj
    touchManagedPtr background
    return ()

-- method Terminal::set_color_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bold", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bold", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_bold" vte_terminal_set_color_bold :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- bold : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorBold ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Gdk.RGBA) ->                     -- bold
    m ()
terminalSetColorBold _obj bold = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeBold <- case bold of
        Nothing -> return nullPtr
        Just jBold -> do
            let jBold' = unsafeManagedPtrGetPtr jBold
            return jBold'
    vte_terminal_set_color_bold _obj' maybeBold
    touchManagedPtr _obj
    whenJust bold touchManagedPtr
    return ()

-- method Terminal::set_color_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cursor_background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_cursor" vte_terminal_set_color_cursor :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- cursor_background : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorCursor ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Gdk.RGBA) ->                     -- cursor_background
    m ()
terminalSetColorCursor _obj cursor_background = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeCursor_background <- case cursor_background of
        Nothing -> return nullPtr
        Just jCursor_background -> do
            let jCursor_background' = unsafeManagedPtrGetPtr jCursor_background
            return jCursor_background'
    vte_terminal_set_color_cursor _obj' maybeCursor_background
    touchManagedPtr _obj
    whenJust cursor_background touchManagedPtr
    return ()

-- method Terminal::set_color_foreground
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_foreground" vte_terminal_set_color_foreground :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- foreground : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorForeground ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Gdk.RGBA ->                             -- foreground
    m ()
terminalSetColorForeground _obj foreground = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let foreground' = unsafeManagedPtrGetPtr foreground
    vte_terminal_set_color_foreground _obj' foreground'
    touchManagedPtr _obj
    touchManagedPtr foreground
    return ()

-- method Terminal::set_color_highlight
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight_background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight_background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight" vte_terminal_set_color_highlight :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- highlight_background : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorHighlight ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Gdk.RGBA) ->                     -- highlight_background
    m ()
terminalSetColorHighlight _obj highlight_background = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeHighlight_background <- case highlight_background of
        Nothing -> return nullPtr
        Just jHighlight_background -> do
            let jHighlight_background' = unsafeManagedPtrGetPtr jHighlight_background
            return jHighlight_background'
    vte_terminal_set_color_highlight _obj' maybeHighlight_background
    touchManagedPtr _obj
    whenJust highlight_background touchManagedPtr
    return ()

-- method Terminal::set_color_highlight_foreground
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight_foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight_foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight_foreground" vte_terminal_set_color_highlight_foreground :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- highlight_foreground : TInterface "Gdk" "RGBA"
    IO ()


terminalSetColorHighlightForeground ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Gdk.RGBA) ->                     -- highlight_foreground
    m ()
terminalSetColorHighlightForeground _obj highlight_foreground = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeHighlight_foreground <- case highlight_foreground of
        Nothing -> return nullPtr
        Just jHighlight_foreground -> do
            let jHighlight_foreground' = unsafeManagedPtrGetPtr jHighlight_foreground
            return jHighlight_foreground'
    vte_terminal_set_color_highlight_foreground _obj' maybeHighlight_foreground
    touchManagedPtr _obj
    whenJust highlight_foreground touchManagedPtr
    return ()

-- method Terminal::set_colors
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "palette", argType = TCArray False (-1) 4 (TInterface "Gdk" "RGBA"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : [Arg {argName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreground", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "palette", argType = TCArray False (-1) 4 (TInterface "Gdk" "RGBA"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_colors" vte_terminal_set_colors :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gdk.RGBA ->                         -- foreground : TInterface "Gdk" "RGBA"
    Ptr Gdk.RGBA ->                         -- background : TInterface "Gdk" "RGBA"
    Ptr Gdk.RGBA ->                         -- palette : TCArray False (-1) 4 (TInterface "Gdk" "RGBA")
    Word64 ->                               -- palette_size : TBasicType TUInt64
    IO ()


terminalSetColors ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Gdk.RGBA) ->                     -- foreground
    Maybe (Gdk.RGBA) ->                     -- background
    Maybe ([Gdk.RGBA]) ->                   -- palette
    m ()
terminalSetColors _obj foreground background palette = liftIO $ do
    let palette_size = case palette of
            Nothing -> 0
            Just jPalette -> fromIntegral $ length jPalette
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeForeground <- case foreground of
        Nothing -> return nullPtr
        Just jForeground -> do
            let jForeground' = unsafeManagedPtrGetPtr jForeground
            return jForeground'
    maybeBackground <- case background of
        Nothing -> return nullPtr
        Just jBackground -> do
            let jBackground' = unsafeManagedPtrGetPtr jBackground
            return jBackground'
    maybePalette <- case palette of
        Nothing -> return nullPtr
        Just jPalette -> do
            let jPalette' = map unsafeManagedPtrGetPtr jPalette
            jPalette'' <- packBlockArray 32 jPalette'
            return jPalette''
    vte_terminal_set_colors _obj' maybeForeground maybeBackground maybePalette palette_size
    touchManagedPtr _obj
    whenJust foreground touchManagedPtr
    whenJust background touchManagedPtr
    whenJust palette (mapM_ touchManagedPtr)
    freeMem maybePalette
    return ()

-- method Terminal::set_cursor_blink_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Vte" "CursorBlinkMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Vte" "CursorBlinkMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_blink_mode" vte_terminal_set_cursor_blink_mode :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- mode : TInterface "Vte" "CursorBlinkMode"
    IO ()


terminalSetCursorBlinkMode ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    CursorBlinkMode ->                      -- mode
    m ()
terminalSetCursorBlinkMode _obj mode = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let mode' = (fromIntegral . fromEnum) mode
    vte_terminal_set_cursor_blink_mode _obj' mode'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_cursor_shape
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shape", argType = TInterface "Vte" "CursorShape", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shape", argType = TInterface "Vte" "CursorShape", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_shape" vte_terminal_set_cursor_shape :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- shape : TInterface "Vte" "CursorShape"
    IO ()


terminalSetCursorShape ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    CursorShape ->                          -- shape
    m ()
terminalSetCursorShape _obj shape = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let shape' = (fromIntegral . fromEnum) shape
    vte_terminal_set_cursor_shape _obj' shape'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_default_colors
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_default_colors" vte_terminal_set_default_colors :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalSetDefaultColors ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalSetDefaultColors _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_set_default_colors _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_delete_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "binding", argType = TInterface "Vte" "EraseBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "binding", argType = TInterface "Vte" "EraseBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_delete_binding" vte_terminal_set_delete_binding :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- binding : TInterface "Vte" "EraseBinding"
    IO ()


terminalSetDeleteBinding ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    EraseBinding ->                         -- binding
    m ()
terminalSetDeleteBinding _obj binding = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let binding' = (fromIntegral . fromEnum) binding
    vte_terminal_set_delete_binding _obj' binding'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "codeset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "codeset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_set_encoding" vte_terminal_set_encoding :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CString ->                              -- codeset : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt


terminalSetEncoding ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (T.Text) ->                       -- codeset
    m ()
terminalSetEncoding _obj codeset = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeCodeset <- case codeset of
        Nothing -> return nullPtr
        Just jCodeset -> do
            jCodeset' <- textToCString jCodeset
            return jCodeset'
    onException (do
        _ <- propagateGError $ vte_terminal_set_encoding _obj' maybeCodeset
        touchManagedPtr _obj
        freeMem maybeCodeset
        return ()
     ) (do
        freeMem maybeCodeset
     )

-- method Terminal::set_font
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "font_desc", argType = TInterface "Pango" "FontDescription", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "font_desc", argType = TInterface "Pango" "FontDescription", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font" vte_terminal_set_font :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Pango.FontDescription ->            -- font_desc : TInterface "Pango" "FontDescription"
    IO ()


terminalSetFont ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Maybe (Pango.FontDescription) ->        -- font_desc
    m ()
terminalSetFont _obj font_desc = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeFont_desc <- case font_desc of
        Nothing -> return nullPtr
        Just jFont_desc -> do
            let jFont_desc' = unsafeManagedPtrGetPtr jFont_desc
            return jFont_desc'
    vte_terminal_set_font _obj' maybeFont_desc
    touchManagedPtr _obj
    whenJust font_desc touchManagedPtr
    return ()

-- method Terminal::set_font_scale
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font_scale" vte_terminal_set_font_scale :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()


terminalSetFontScale ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Double ->                               -- scale
    m ()
terminalSetFontScale _obj scale = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let scale' = realToFrac scale
    vte_terminal_set_font_scale _obj' scale'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_geometry_hints_for_window
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_geometry_hints_for_window" vte_terminal_set_geometry_hints_for_window :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gtk.Window ->                       -- window : TInterface "Gtk" "Window"
    IO ()


terminalSetGeometryHintsForWindow ::
    (MonadIO m, TerminalK a, Gtk.WindowK b) =>
    a ->                                    -- _obj
    b ->                                    -- window
    m ()
terminalSetGeometryHintsForWindow _obj window = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let window' = unsafeManagedPtrCastPtr window
    vte_terminal_set_geometry_hints_for_window _obj' window'
    touchManagedPtr _obj
    touchManagedPtr window
    return ()

-- method Terminal::set_input_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_input_enabled" vte_terminal_set_input_enabled :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()


terminalSetInputEnabled ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- enabled
    m ()
terminalSetInputEnabled _obj enabled = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let enabled' = (fromIntegral . fromEnum) enabled
    vte_terminal_set_input_enabled _obj' enabled'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_mouse_autohide
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_mouse_autohide" vte_terminal_set_mouse_autohide :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()


terminalSetMouseAutohide ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- setting
    m ()
terminalSetMouseAutohide _obj setting = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let setting' = (fromIntegral . fromEnum) setting
    vte_terminal_set_mouse_autohide _obj' setting'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_pty
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pty", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pty", argType = TInterface "Vte" "Pty", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_pty" vte_terminal_set_pty :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Pty ->                              -- pty : TInterface "Vte" "Pty"
    IO ()


terminalSetPty ::
    (MonadIO m, TerminalK a, PtyK b) =>
    a ->                                    -- _obj
    Maybe (b) ->                            -- pty
    m ()
terminalSetPty _obj pty = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybePty <- case pty of
        Nothing -> return nullPtr
        Just jPty -> do
            let jPty' = unsafeManagedPtrCastPtr jPty
            return jPty'
    vte_terminal_set_pty _obj' maybePty
    touchManagedPtr _obj
    whenJust pty touchManagedPtr
    return ()

-- method Terminal::set_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rewrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rewrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_rewrap_on_resize" vte_terminal_set_rewrap_on_resize :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- rewrap : TBasicType TBoolean
    IO ()


terminalSetRewrapOnResize ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- rewrap
    m ()
terminalSetRewrapOnResize _obj rewrap = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let rewrap' = (fromIntegral . fromEnum) rewrap
    vte_terminal_set_rewrap_on_resize _obj' rewrap'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_scroll_on_keystroke
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_keystroke" vte_terminal_set_scroll_on_keystroke :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()


terminalSetScrollOnKeystroke ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- scroll
    m ()
terminalSetScrollOnKeystroke _obj scroll = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let scroll' = (fromIntegral . fromEnum) scroll
    vte_terminal_set_scroll_on_keystroke _obj' scroll'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_scroll_on_output
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_output" vte_terminal_set_scroll_on_output :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()


terminalSetScrollOnOutput ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- scroll
    m ()
terminalSetScrollOnOutput _obj scroll = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let scroll' = (fromIntegral . fromEnum) scroll
    vte_terminal_set_scroll_on_output _obj' scroll'
    touchManagedPtr _obj
    return ()

-- method Terminal::set_scrollback_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lines", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lines", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scrollback_lines" vte_terminal_set_scrollback_lines :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int64 ->                                -- lines : TBasicType TInt64
    IO ()


terminalSetScrollbackLines ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int64 ->                                -- lines
    m ()
terminalSetScrollbackLines _obj lines = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_set_scrollback_lines _obj' lines
    touchManagedPtr _obj
    return ()

-- method Terminal::set_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_size" vte_terminal_set_size :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int64 ->                                -- columns : TBasicType TInt64
    Int64 ->                                -- rows : TBasicType TInt64
    IO ()


terminalSetSize ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int64 ->                                -- columns
    Int64 ->                                -- rows
    m ()
terminalSetSize _obj columns rows = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_set_size _obj' columns rows
    touchManagedPtr _obj
    return ()

-- method Terminal::set_word_char_exceptions
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exceptions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exceptions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_word_char_exceptions" vte_terminal_set_word_char_exceptions :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CString ->                              -- exceptions : TBasicType TUTF8
    IO ()


terminalSetWordCharExceptions ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- exceptions
    m ()
terminalSetWordCharExceptions _obj exceptions = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    exceptions' <- textToCString exceptions
    vte_terminal_set_word_char_exceptions _obj' exceptions'
    touchManagedPtr _obj
    freeMem exceptions'
    return ()

-- method Terminal::spawn_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pty_flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "working_directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "envv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spawn_flags", argType = TInterface "GLib" "SpawnFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_setup", argType = TInterface "GLib" "SpawnChildSetupFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_setup_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_pid", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pty_flags", argType = TInterface "Vte" "PtyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "working_directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "envv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spawn_flags", argType = TInterface "GLib" "SpawnFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_setup", argType = TInterface "GLib" "SpawnChildSetupFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_spawn_sync" vte_terminal_spawn_sync :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    CUInt ->                                -- pty_flags : TInterface "Vte" "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 "GLib" "SpawnFlags"
    FunPtr GLib.SpawnChildSetupFuncC ->     -- child_setup : TInterface "GLib" "SpawnChildSetupFunc"
    Ptr () ->                               -- child_setup_data : TBasicType TVoid
    Ptr Int32 ->                            -- child_pid : TBasicType TInt32
    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


terminalSpawnSync ::
    (MonadIO m, TerminalK a, Gio.CancellableK b) =>
    a ->                                    -- _obj
    [PtyFlags] ->                           -- pty_flags
    Maybe (T.Text) ->                       -- working_directory
    [[Char]] ->                             -- argv
    Maybe ([[Char]]) ->                     -- envv
    [GLib.SpawnFlags] ->                    -- spawn_flags
    Maybe (GLib.SpawnChildSetupFunc) ->     -- child_setup
    Maybe (b) ->                            -- cancellable
    m (Int32)
terminalSpawnSync _obj pty_flags working_directory argv envv spawn_flags child_setup cancellable = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let pty_flags' = gflagsToWord pty_flags
    maybeWorking_directory <- case working_directory of
        Nothing -> return nullPtr
        Just jWorking_directory -> do
            jWorking_directory' <- textToCString jWorking_directory
            return jWorking_directory'
    argv' <- packZeroTerminatedFileNameArray argv
    maybeEnvv <- case envv of
        Nothing -> return nullPtr
        Just jEnvv -> do
            jEnvv' <- packZeroTerminatedFileNameArray jEnvv
            return jEnvv'
    let spawn_flags' = gflagsToWord spawn_flags
    maybeChild_setup <- case child_setup of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jChild_setup -> do
            jChild_setup' <- GLib.mkSpawnChildSetupFunc (GLib.spawnChildSetupFuncWrapper Nothing jChild_setup)
            return jChild_setup'
    child_pid <- allocMem :: IO (Ptr Int32)
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            let jCancellable' = unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    let child_setup_data = nullPtr
    onException (do
        _ <- propagateGError $ vte_terminal_spawn_sync _obj' pty_flags' maybeWorking_directory argv' maybeEnvv spawn_flags' maybeChild_setup child_setup_data child_pid maybeCancellable
        child_pid' <- peek child_pid
        safeFreeFunPtr $ castFunPtrToPtr maybeChild_setup
        touchManagedPtr _obj
        whenJust cancellable touchManagedPtr
        freeMem maybeWorking_directory
        mapZeroTerminatedCArray freeMem argv'
        freeMem argv'
        mapZeroTerminatedCArray freeMem maybeEnvv
        freeMem maybeEnvv
        freeMem child_pid
        return child_pid'
     ) (do
        safeFreeFunPtr $ castFunPtrToPtr maybeChild_setup
        freeMem maybeWorking_directory
        mapZeroTerminatedCArray freeMem argv'
        freeMem argv'
        mapZeroTerminatedCArray freeMem maybeEnvv
        freeMem maybeEnvv
        freeMem child_pid
     )

-- method Terminal::unselect_all
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_unselect_all" vte_terminal_unselect_all :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    IO ()


terminalUnselectAll ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    m ()
terminalUnselectAll _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_unselect_all _obj'
    touchManagedPtr _obj
    return ()

-- method Terminal::watch_child
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_pid", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_pid", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_watch_child" vte_terminal_watch_child :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Int32 ->                                -- child_pid : TBasicType TInt32
    IO ()


terminalWatchChild ::
    (MonadIO m, TerminalK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- child_pid
    m ()
terminalWatchChild _obj child_pid = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    vte_terminal_watch_child _obj' child_pid
    touchManagedPtr _obj
    return ()

-- method Terminal::write_contents_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Vte" "WriteFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Vte" "Terminal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Vte" "WriteFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_write_contents_sync" vte_terminal_write_contents_sync :: 
    Ptr Terminal ->                         -- _obj : TInterface "Vte" "Terminal"
    Ptr Gio.OutputStream ->                 -- stream : TInterface "Gio" "OutputStream"
    CUInt ->                                -- flags : TInterface "Vte" "WriteFlags"
    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


terminalWriteContentsSync ::
    (MonadIO m, TerminalK a, Gio.OutputStreamK b, Gio.CancellableK c) =>
    a ->                                    -- _obj
    b ->                                    -- stream
    WriteFlags ->                           -- flags
    Maybe (c) ->                            -- cancellable
    m ()
terminalWriteContentsSync _obj stream flags cancellable = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let stream' = unsafeManagedPtrCastPtr stream
    let flags' = (fromIntegral . fromEnum) flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            let jCancellable' = unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ vte_terminal_write_contents_sync _obj' stream' flags' maybeCancellable
        touchManagedPtr _obj
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

-- signal Terminal::bell
type TerminalBellCallback =
    IO ()

noTerminalBellCallback :: Maybe TerminalBellCallback
noTerminalBellCallback = Nothing

type TerminalBellCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalBellCallback :: TerminalBellCallbackC -> IO (FunPtr TerminalBellCallbackC)

terminalBellClosure :: TerminalBellCallback -> IO Closure
terminalBellClosure cb = newCClosure =<< mkTerminalBellCallback wrapped
    where wrapped = terminalBellCallbackWrapper cb

terminalBellCallbackWrapper ::
    TerminalBellCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalBellCallbackWrapper _cb _ _ = do
    _cb 

onTerminalBell :: (GObject a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
onTerminalBell obj cb = liftIO $ connectTerminalBell obj cb SignalConnectBefore
afterTerminalBell :: (GObject a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
afterTerminalBell obj cb = connectTerminalBell obj cb SignalConnectAfter

connectTerminalBell :: (GObject a, MonadIO m) =>
                       a -> TerminalBellCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalBell obj cb after = liftIO $ do
    cb' <- mkTerminalBellCallback (terminalBellCallbackWrapper cb)
    connectSignalFunPtr obj "bell" cb' after

-- signal Terminal::char-size-changed
type TerminalCharSizeChangedCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalCharSizeChangedCallback = Nothing

type TerminalCharSizeChangedCallbackC =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCharSizeChangedCallback :: TerminalCharSizeChangedCallbackC -> IO (FunPtr TerminalCharSizeChangedCallbackC)

terminalCharSizeChangedClosure :: TerminalCharSizeChangedCallback -> IO Closure
terminalCharSizeChangedClosure cb = newCClosure =<< mkTerminalCharSizeChangedCallback wrapped
    where wrapped = terminalCharSizeChangedCallbackWrapper cb

terminalCharSizeChangedCallbackWrapper ::
    TerminalCharSizeChangedCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
terminalCharSizeChangedCallbackWrapper _cb _ width height _ = do
    _cb  width height

onTerminalCharSizeChanged :: (GObject a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalCharSizeChanged obj cb = liftIO $ connectTerminalCharSizeChanged obj cb SignalConnectBefore
afterTerminalCharSizeChanged :: (GObject a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalCharSizeChanged obj cb = connectTerminalCharSizeChanged obj cb SignalConnectAfter

connectTerminalCharSizeChanged :: (GObject a, MonadIO m) =>
                                  a -> TerminalCharSizeChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCharSizeChanged obj cb after = liftIO $ do
    cb' <- mkTerminalCharSizeChangedCallback (terminalCharSizeChangedCallbackWrapper cb)
    connectSignalFunPtr obj "char-size-changed" cb' after

-- signal Terminal::child-exited
type TerminalChildExitedCallback =
    Int32 ->
    IO ()

noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback
noTerminalChildExitedCallback = Nothing

type TerminalChildExitedCallbackC =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalChildExitedCallback :: TerminalChildExitedCallbackC -> IO (FunPtr TerminalChildExitedCallbackC)

terminalChildExitedClosure :: TerminalChildExitedCallback -> IO Closure
terminalChildExitedClosure cb = newCClosure =<< mkTerminalChildExitedCallback wrapped
    where wrapped = terminalChildExitedCallbackWrapper cb

terminalChildExitedCallbackWrapper ::
    TerminalChildExitedCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
terminalChildExitedCallbackWrapper _cb _ status _ = do
    _cb  status

onTerminalChildExited :: (GObject a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalChildExited obj cb = liftIO $ connectTerminalChildExited obj cb SignalConnectBefore
afterTerminalChildExited :: (GObject a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalChildExited obj cb = connectTerminalChildExited obj cb SignalConnectAfter

connectTerminalChildExited :: (GObject a, MonadIO m) =>
                              a -> TerminalChildExitedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalChildExited obj cb after = liftIO $ do
    cb' <- mkTerminalChildExitedCallback (terminalChildExitedCallbackWrapper cb)
    connectSignalFunPtr obj "child-exited" cb' after

-- signal Terminal::commit
type TerminalCommitCallback =
    T.Text ->
    Word32 ->
    IO ()

noTerminalCommitCallback :: Maybe TerminalCommitCallback
noTerminalCommitCallback = Nothing

type TerminalCommitCallbackC =
    Ptr () ->                               -- object
    CString ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCommitCallback :: TerminalCommitCallbackC -> IO (FunPtr TerminalCommitCallbackC)

terminalCommitClosure :: TerminalCommitCallback -> IO Closure
terminalCommitClosure cb = newCClosure =<< mkTerminalCommitCallback wrapped
    where wrapped = terminalCommitCallbackWrapper cb

terminalCommitCallbackWrapper ::
    TerminalCommitCallback ->
    Ptr () ->
    CString ->
    Word32 ->
    Ptr () ->
    IO ()
terminalCommitCallbackWrapper _cb _ text size _ = do
    text' <- cstringToText text
    _cb  text' size

onTerminalCommit :: (GObject a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
onTerminalCommit obj cb = liftIO $ connectTerminalCommit obj cb SignalConnectBefore
afterTerminalCommit :: (GObject a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
afterTerminalCommit obj cb = connectTerminalCommit obj cb SignalConnectAfter

connectTerminalCommit :: (GObject a, MonadIO m) =>
                         a -> TerminalCommitCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCommit obj cb after = liftIO $ do
    cb' <- mkTerminalCommitCallback (terminalCommitCallbackWrapper cb)
    connectSignalFunPtr obj "commit" cb' after

-- signal Terminal::contents-changed
type TerminalContentsChangedCallback =
    IO ()

noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback
noTerminalContentsChangedCallback = Nothing

type TerminalContentsChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalContentsChangedCallback :: TerminalContentsChangedCallbackC -> IO (FunPtr TerminalContentsChangedCallbackC)

terminalContentsChangedClosure :: TerminalContentsChangedCallback -> IO Closure
terminalContentsChangedClosure cb = newCClosure =<< mkTerminalContentsChangedCallback wrapped
    where wrapped = terminalContentsChangedCallbackWrapper cb

terminalContentsChangedCallbackWrapper ::
    TerminalContentsChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalContentsChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalContentsChanged :: (GObject a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
onTerminalContentsChanged obj cb = liftIO $ connectTerminalContentsChanged obj cb SignalConnectBefore
afterTerminalContentsChanged :: (GObject a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
afterTerminalContentsChanged obj cb = connectTerminalContentsChanged obj cb SignalConnectAfter

connectTerminalContentsChanged :: (GObject a, MonadIO m) =>
                                  a -> TerminalContentsChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalContentsChanged obj cb after = liftIO $ do
    cb' <- mkTerminalContentsChangedCallback (terminalContentsChangedCallbackWrapper cb)
    connectSignalFunPtr obj "contents-changed" cb' after

-- signal Terminal::copy-clipboard
type TerminalCopyClipboardCallback =
    IO ()

noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback
noTerminalCopyClipboardCallback = Nothing

type TerminalCopyClipboardCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCopyClipboardCallback :: TerminalCopyClipboardCallbackC -> IO (FunPtr TerminalCopyClipboardCallbackC)

terminalCopyClipboardClosure :: TerminalCopyClipboardCallback -> IO Closure
terminalCopyClipboardClosure cb = newCClosure =<< mkTerminalCopyClipboardCallback wrapped
    where wrapped = terminalCopyClipboardCallbackWrapper cb

terminalCopyClipboardCallbackWrapper ::
    TerminalCopyClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalCopyClipboardCallbackWrapper _cb _ _ = do
    _cb 

onTerminalCopyClipboard :: (GObject a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
onTerminalCopyClipboard obj cb = liftIO $ connectTerminalCopyClipboard obj cb SignalConnectBefore
afterTerminalCopyClipboard :: (GObject a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
afterTerminalCopyClipboard obj cb = connectTerminalCopyClipboard obj cb SignalConnectAfter

connectTerminalCopyClipboard :: (GObject a, MonadIO m) =>
                                a -> TerminalCopyClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCopyClipboard obj cb after = liftIO $ do
    cb' <- mkTerminalCopyClipboardCallback (terminalCopyClipboardCallbackWrapper cb)
    connectSignalFunPtr obj "copy-clipboard" cb' after

-- signal Terminal::current-directory-uri-changed
type TerminalCurrentDirectoryUriChangedCallback =
    IO ()

noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback
noTerminalCurrentDirectoryUriChangedCallback = Nothing

type TerminalCurrentDirectoryUriChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCurrentDirectoryUriChangedCallback :: TerminalCurrentDirectoryUriChangedCallbackC -> IO (FunPtr TerminalCurrentDirectoryUriChangedCallbackC)

terminalCurrentDirectoryUriChangedClosure :: TerminalCurrentDirectoryUriChangedCallback -> IO Closure
terminalCurrentDirectoryUriChangedClosure cb = newCClosure =<< mkTerminalCurrentDirectoryUriChangedCallback wrapped
    where wrapped = terminalCurrentDirectoryUriChangedCallbackWrapper cb

terminalCurrentDirectoryUriChangedCallbackWrapper ::
    TerminalCurrentDirectoryUriChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalCurrentDirectoryUriChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalCurrentDirectoryUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged obj cb = liftIO $ connectTerminalCurrentDirectoryUriChanged obj cb SignalConnectBefore
afterTerminalCurrentDirectoryUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged obj cb = connectTerminalCurrentDirectoryUriChanged obj cb SignalConnectAfter

connectTerminalCurrentDirectoryUriChanged :: (GObject a, MonadIO m) =>
                                             a -> TerminalCurrentDirectoryUriChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCurrentDirectoryUriChanged obj cb after = liftIO $ do
    cb' <- mkTerminalCurrentDirectoryUriChangedCallback (terminalCurrentDirectoryUriChangedCallbackWrapper cb)
    connectSignalFunPtr obj "current-directory-uri-changed" cb' after

-- signal Terminal::current-file-uri-changed
type TerminalCurrentFileUriChangedCallback =
    IO ()

noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback
noTerminalCurrentFileUriChangedCallback = Nothing

type TerminalCurrentFileUriChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCurrentFileUriChangedCallback :: TerminalCurrentFileUriChangedCallbackC -> IO (FunPtr TerminalCurrentFileUriChangedCallbackC)

terminalCurrentFileUriChangedClosure :: TerminalCurrentFileUriChangedCallback -> IO Closure
terminalCurrentFileUriChangedClosure cb = newCClosure =<< mkTerminalCurrentFileUriChangedCallback wrapped
    where wrapped = terminalCurrentFileUriChangedCallbackWrapper cb

terminalCurrentFileUriChangedCallbackWrapper ::
    TerminalCurrentFileUriChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalCurrentFileUriChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalCurrentFileUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
onTerminalCurrentFileUriChanged obj cb = liftIO $ connectTerminalCurrentFileUriChanged obj cb SignalConnectBefore
afterTerminalCurrentFileUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentFileUriChanged obj cb = connectTerminalCurrentFileUriChanged obj cb SignalConnectAfter

connectTerminalCurrentFileUriChanged :: (GObject a, MonadIO m) =>
                                        a -> TerminalCurrentFileUriChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCurrentFileUriChanged obj cb after = liftIO $ do
    cb' <- mkTerminalCurrentFileUriChangedCallback (terminalCurrentFileUriChangedCallbackWrapper cb)
    connectSignalFunPtr obj "current-file-uri-changed" cb' after

-- signal Terminal::cursor-moved
type TerminalCursorMovedCallback =
    IO ()

noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback
noTerminalCursorMovedCallback = Nothing

type TerminalCursorMovedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalCursorMovedCallback :: TerminalCursorMovedCallbackC -> IO (FunPtr TerminalCursorMovedCallbackC)

terminalCursorMovedClosure :: TerminalCursorMovedCallback -> IO Closure
terminalCursorMovedClosure cb = newCClosure =<< mkTerminalCursorMovedCallback wrapped
    where wrapped = terminalCursorMovedCallbackWrapper cb

terminalCursorMovedCallbackWrapper ::
    TerminalCursorMovedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalCursorMovedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalCursorMoved :: (GObject a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
onTerminalCursorMoved obj cb = liftIO $ connectTerminalCursorMoved obj cb SignalConnectBefore
afterTerminalCursorMoved :: (GObject a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
afterTerminalCursorMoved obj cb = connectTerminalCursorMoved obj cb SignalConnectAfter

connectTerminalCursorMoved :: (GObject a, MonadIO m) =>
                              a -> TerminalCursorMovedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalCursorMoved obj cb after = liftIO $ do
    cb' <- mkTerminalCursorMovedCallback (terminalCursorMovedCallbackWrapper cb)
    connectSignalFunPtr obj "cursor-moved" cb' after

-- signal Terminal::decrease-font-size
type TerminalDecreaseFontSizeCallback =
    IO ()

noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback
noTerminalDecreaseFontSizeCallback = Nothing

type TerminalDecreaseFontSizeCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalDecreaseFontSizeCallback :: TerminalDecreaseFontSizeCallbackC -> IO (FunPtr TerminalDecreaseFontSizeCallbackC)

terminalDecreaseFontSizeClosure :: TerminalDecreaseFontSizeCallback -> IO Closure
terminalDecreaseFontSizeClosure cb = newCClosure =<< mkTerminalDecreaseFontSizeCallback wrapped
    where wrapped = terminalDecreaseFontSizeCallbackWrapper cb

terminalDecreaseFontSizeCallbackWrapper ::
    TerminalDecreaseFontSizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalDecreaseFontSizeCallbackWrapper _cb _ _ = do
    _cb 

onTerminalDecreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
onTerminalDecreaseFontSize obj cb = liftIO $ connectTerminalDecreaseFontSize obj cb SignalConnectBefore
afterTerminalDecreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
afterTerminalDecreaseFontSize obj cb = connectTerminalDecreaseFontSize obj cb SignalConnectAfter

connectTerminalDecreaseFontSize :: (GObject a, MonadIO m) =>
                                   a -> TerminalDecreaseFontSizeCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalDecreaseFontSize obj cb after = liftIO $ do
    cb' <- mkTerminalDecreaseFontSizeCallback (terminalDecreaseFontSizeCallbackWrapper cb)
    connectSignalFunPtr obj "decrease-font-size" cb' after

-- signal Terminal::deiconify-window
type TerminalDeiconifyWindowCallback =
    IO ()

noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback
noTerminalDeiconifyWindowCallback = Nothing

type TerminalDeiconifyWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalDeiconifyWindowCallback :: TerminalDeiconifyWindowCallbackC -> IO (FunPtr TerminalDeiconifyWindowCallbackC)

terminalDeiconifyWindowClosure :: TerminalDeiconifyWindowCallback -> IO Closure
terminalDeiconifyWindowClosure cb = newCClosure =<< mkTerminalDeiconifyWindowCallback wrapped
    where wrapped = terminalDeiconifyWindowCallbackWrapper cb

terminalDeiconifyWindowCallbackWrapper ::
    TerminalDeiconifyWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalDeiconifyWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalDeiconifyWindow :: (GObject a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
onTerminalDeiconifyWindow obj cb = liftIO $ connectTerminalDeiconifyWindow obj cb SignalConnectBefore
afterTerminalDeiconifyWindow :: (GObject a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
afterTerminalDeiconifyWindow obj cb = connectTerminalDeiconifyWindow obj cb SignalConnectAfter

connectTerminalDeiconifyWindow :: (GObject a, MonadIO m) =>
                                  a -> TerminalDeiconifyWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalDeiconifyWindow obj cb after = liftIO $ do
    cb' <- mkTerminalDeiconifyWindowCallback (terminalDeiconifyWindowCallbackWrapper cb)
    connectSignalFunPtr obj "deiconify-window" cb' after

-- signal Terminal::encoding-changed
type TerminalEncodingChangedCallback =
    IO ()

noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback
noTerminalEncodingChangedCallback = Nothing

type TerminalEncodingChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalEncodingChangedCallback :: TerminalEncodingChangedCallbackC -> IO (FunPtr TerminalEncodingChangedCallbackC)

terminalEncodingChangedClosure :: TerminalEncodingChangedCallback -> IO Closure
terminalEncodingChangedClosure cb = newCClosure =<< mkTerminalEncodingChangedCallback wrapped
    where wrapped = terminalEncodingChangedCallbackWrapper cb

terminalEncodingChangedCallbackWrapper ::
    TerminalEncodingChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalEncodingChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalEncodingChanged :: (GObject a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
onTerminalEncodingChanged obj cb = liftIO $ connectTerminalEncodingChanged obj cb SignalConnectBefore
afterTerminalEncodingChanged :: (GObject a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
afterTerminalEncodingChanged obj cb = connectTerminalEncodingChanged obj cb SignalConnectAfter

connectTerminalEncodingChanged :: (GObject a, MonadIO m) =>
                                  a -> TerminalEncodingChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalEncodingChanged obj cb after = liftIO $ do
    cb' <- mkTerminalEncodingChangedCallback (terminalEncodingChangedCallbackWrapper cb)
    connectSignalFunPtr obj "encoding-changed" cb' after

-- signal Terminal::eof
type TerminalEofCallback =
    IO ()

noTerminalEofCallback :: Maybe TerminalEofCallback
noTerminalEofCallback = Nothing

type TerminalEofCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalEofCallback :: TerminalEofCallbackC -> IO (FunPtr TerminalEofCallbackC)

terminalEofClosure :: TerminalEofCallback -> IO Closure
terminalEofClosure cb = newCClosure =<< mkTerminalEofCallback wrapped
    where wrapped = terminalEofCallbackWrapper cb

terminalEofCallbackWrapper ::
    TerminalEofCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalEofCallbackWrapper _cb _ _ = do
    _cb 

onTerminalEof :: (GObject a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
onTerminalEof obj cb = liftIO $ connectTerminalEof obj cb SignalConnectBefore
afterTerminalEof :: (GObject a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
afterTerminalEof obj cb = connectTerminalEof obj cb SignalConnectAfter

connectTerminalEof :: (GObject a, MonadIO m) =>
                      a -> TerminalEofCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalEof obj cb after = liftIO $ do
    cb' <- mkTerminalEofCallback (terminalEofCallbackWrapper cb)
    connectSignalFunPtr obj "eof" cb' after

-- signal Terminal::icon-title-changed
type TerminalIconTitleChangedCallback =
    IO ()

noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback
noTerminalIconTitleChangedCallback = Nothing

type TerminalIconTitleChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalIconTitleChangedCallback :: TerminalIconTitleChangedCallbackC -> IO (FunPtr TerminalIconTitleChangedCallbackC)

terminalIconTitleChangedClosure :: TerminalIconTitleChangedCallback -> IO Closure
terminalIconTitleChangedClosure cb = newCClosure =<< mkTerminalIconTitleChangedCallback wrapped
    where wrapped = terminalIconTitleChangedCallbackWrapper cb

terminalIconTitleChangedCallbackWrapper ::
    TerminalIconTitleChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalIconTitleChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalIconTitleChanged :: (GObject a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
onTerminalIconTitleChanged obj cb = liftIO $ connectTerminalIconTitleChanged obj cb SignalConnectBefore
afterTerminalIconTitleChanged :: (GObject a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
afterTerminalIconTitleChanged obj cb = connectTerminalIconTitleChanged obj cb SignalConnectAfter

connectTerminalIconTitleChanged :: (GObject a, MonadIO m) =>
                                   a -> TerminalIconTitleChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalIconTitleChanged obj cb after = liftIO $ do
    cb' <- mkTerminalIconTitleChangedCallback (terminalIconTitleChangedCallbackWrapper cb)
    connectSignalFunPtr obj "icon-title-changed" cb' after

-- signal Terminal::iconify-window
type TerminalIconifyWindowCallback =
    IO ()

noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback
noTerminalIconifyWindowCallback = Nothing

type TerminalIconifyWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalIconifyWindowCallback :: TerminalIconifyWindowCallbackC -> IO (FunPtr TerminalIconifyWindowCallbackC)

terminalIconifyWindowClosure :: TerminalIconifyWindowCallback -> IO Closure
terminalIconifyWindowClosure cb = newCClosure =<< mkTerminalIconifyWindowCallback wrapped
    where wrapped = terminalIconifyWindowCallbackWrapper cb

terminalIconifyWindowCallbackWrapper ::
    TerminalIconifyWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalIconifyWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalIconifyWindow :: (GObject a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
onTerminalIconifyWindow obj cb = liftIO $ connectTerminalIconifyWindow obj cb SignalConnectBefore
afterTerminalIconifyWindow :: (GObject a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
afterTerminalIconifyWindow obj cb = connectTerminalIconifyWindow obj cb SignalConnectAfter

connectTerminalIconifyWindow :: (GObject a, MonadIO m) =>
                                a -> TerminalIconifyWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalIconifyWindow obj cb after = liftIO $ do
    cb' <- mkTerminalIconifyWindowCallback (terminalIconifyWindowCallbackWrapper cb)
    connectSignalFunPtr obj "iconify-window" cb' after

-- signal Terminal::increase-font-size
type TerminalIncreaseFontSizeCallback =
    IO ()

noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback
noTerminalIncreaseFontSizeCallback = Nothing

type TerminalIncreaseFontSizeCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalIncreaseFontSizeCallback :: TerminalIncreaseFontSizeCallbackC -> IO (FunPtr TerminalIncreaseFontSizeCallbackC)

terminalIncreaseFontSizeClosure :: TerminalIncreaseFontSizeCallback -> IO Closure
terminalIncreaseFontSizeClosure cb = newCClosure =<< mkTerminalIncreaseFontSizeCallback wrapped
    where wrapped = terminalIncreaseFontSizeCallbackWrapper cb

terminalIncreaseFontSizeCallbackWrapper ::
    TerminalIncreaseFontSizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalIncreaseFontSizeCallbackWrapper _cb _ _ = do
    _cb 

onTerminalIncreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
onTerminalIncreaseFontSize obj cb = liftIO $ connectTerminalIncreaseFontSize obj cb SignalConnectBefore
afterTerminalIncreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
afterTerminalIncreaseFontSize obj cb = connectTerminalIncreaseFontSize obj cb SignalConnectAfter

connectTerminalIncreaseFontSize :: (GObject a, MonadIO m) =>
                                   a -> TerminalIncreaseFontSizeCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalIncreaseFontSize obj cb after = liftIO $ do
    cb' <- mkTerminalIncreaseFontSizeCallback (terminalIncreaseFontSizeCallbackWrapper cb)
    connectSignalFunPtr obj "increase-font-size" cb' after

-- signal Terminal::lower-window
type TerminalLowerWindowCallback =
    IO ()

noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback
noTerminalLowerWindowCallback = Nothing

type TerminalLowerWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalLowerWindowCallback :: TerminalLowerWindowCallbackC -> IO (FunPtr TerminalLowerWindowCallbackC)

terminalLowerWindowClosure :: TerminalLowerWindowCallback -> IO Closure
terminalLowerWindowClosure cb = newCClosure =<< mkTerminalLowerWindowCallback wrapped
    where wrapped = terminalLowerWindowCallbackWrapper cb

terminalLowerWindowCallbackWrapper ::
    TerminalLowerWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalLowerWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalLowerWindow :: (GObject a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
onTerminalLowerWindow obj cb = liftIO $ connectTerminalLowerWindow obj cb SignalConnectBefore
afterTerminalLowerWindow :: (GObject a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
afterTerminalLowerWindow obj cb = connectTerminalLowerWindow obj cb SignalConnectAfter

connectTerminalLowerWindow :: (GObject a, MonadIO m) =>
                              a -> TerminalLowerWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalLowerWindow obj cb after = liftIO $ do
    cb' <- mkTerminalLowerWindowCallback (terminalLowerWindowCallbackWrapper cb)
    connectSignalFunPtr obj "lower-window" cb' after

-- signal Terminal::maximize-window
type TerminalMaximizeWindowCallback =
    IO ()

noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback
noTerminalMaximizeWindowCallback = Nothing

type TerminalMaximizeWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalMaximizeWindowCallback :: TerminalMaximizeWindowCallbackC -> IO (FunPtr TerminalMaximizeWindowCallbackC)

terminalMaximizeWindowClosure :: TerminalMaximizeWindowCallback -> IO Closure
terminalMaximizeWindowClosure cb = newCClosure =<< mkTerminalMaximizeWindowCallback wrapped
    where wrapped = terminalMaximizeWindowCallbackWrapper cb

terminalMaximizeWindowCallbackWrapper ::
    TerminalMaximizeWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalMaximizeWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalMaximizeWindow :: (GObject a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
onTerminalMaximizeWindow obj cb = liftIO $ connectTerminalMaximizeWindow obj cb SignalConnectBefore
afterTerminalMaximizeWindow :: (GObject a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
afterTerminalMaximizeWindow obj cb = connectTerminalMaximizeWindow obj cb SignalConnectAfter

connectTerminalMaximizeWindow :: (GObject a, MonadIO m) =>
                                 a -> TerminalMaximizeWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalMaximizeWindow obj cb after = liftIO $ do
    cb' <- mkTerminalMaximizeWindowCallback (terminalMaximizeWindowCallbackWrapper cb)
    connectSignalFunPtr obj "maximize-window" cb' after

-- signal Terminal::move-window
type TerminalMoveWindowCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback
noTerminalMoveWindowCallback = Nothing

type TerminalMoveWindowCallbackC =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalMoveWindowCallback :: TerminalMoveWindowCallbackC -> IO (FunPtr TerminalMoveWindowCallbackC)

terminalMoveWindowClosure :: TerminalMoveWindowCallback -> IO Closure
terminalMoveWindowClosure cb = newCClosure =<< mkTerminalMoveWindowCallback wrapped
    where wrapped = terminalMoveWindowCallbackWrapper cb

terminalMoveWindowCallbackWrapper ::
    TerminalMoveWindowCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
terminalMoveWindowCallbackWrapper _cb _ x y _ = do
    _cb  x y

onTerminalMoveWindow :: (GObject a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
onTerminalMoveWindow obj cb = liftIO $ connectTerminalMoveWindow obj cb SignalConnectBefore
afterTerminalMoveWindow :: (GObject a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
afterTerminalMoveWindow obj cb = connectTerminalMoveWindow obj cb SignalConnectAfter

connectTerminalMoveWindow :: (GObject a, MonadIO m) =>
                             a -> TerminalMoveWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalMoveWindow obj cb after = liftIO $ do
    cb' <- mkTerminalMoveWindowCallback (terminalMoveWindowCallbackWrapper cb)
    connectSignalFunPtr obj "move-window" cb' after

-- signal Terminal::notification-received
type TerminalNotificationReceivedCallback =
    T.Text ->
    Maybe T.Text ->
    IO ()

noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback
noTerminalNotificationReceivedCallback = Nothing

type TerminalNotificationReceivedCallbackC =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalNotificationReceivedCallback :: TerminalNotificationReceivedCallbackC -> IO (FunPtr TerminalNotificationReceivedCallbackC)

terminalNotificationReceivedClosure :: TerminalNotificationReceivedCallback -> IO Closure
terminalNotificationReceivedClosure cb = newCClosure =<< mkTerminalNotificationReceivedCallback wrapped
    where wrapped = terminalNotificationReceivedCallbackWrapper cb

terminalNotificationReceivedCallbackWrapper ::
    TerminalNotificationReceivedCallback ->
    Ptr () ->
    CString ->
    CString ->
    Ptr () ->
    IO ()
terminalNotificationReceivedCallbackWrapper _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

onTerminalNotificationReceived :: (GObject a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
onTerminalNotificationReceived obj cb = liftIO $ connectTerminalNotificationReceived obj cb SignalConnectBefore
afterTerminalNotificationReceived :: (GObject a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
afterTerminalNotificationReceived obj cb = connectTerminalNotificationReceived obj cb SignalConnectAfter

connectTerminalNotificationReceived :: (GObject a, MonadIO m) =>
                                       a -> TerminalNotificationReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalNotificationReceived obj cb after = liftIO $ do
    cb' <- mkTerminalNotificationReceivedCallback (terminalNotificationReceivedCallbackWrapper cb)
    connectSignalFunPtr obj "notification-received" cb' after

-- signal Terminal::paste-clipboard
type TerminalPasteClipboardCallback =
    IO ()

noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback
noTerminalPasteClipboardCallback = Nothing

type TerminalPasteClipboardCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalPasteClipboardCallback :: TerminalPasteClipboardCallbackC -> IO (FunPtr TerminalPasteClipboardCallbackC)

terminalPasteClipboardClosure :: TerminalPasteClipboardCallback -> IO Closure
terminalPasteClipboardClosure cb = newCClosure =<< mkTerminalPasteClipboardCallback wrapped
    where wrapped = terminalPasteClipboardCallbackWrapper cb

terminalPasteClipboardCallbackWrapper ::
    TerminalPasteClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalPasteClipboardCallbackWrapper _cb _ _ = do
    _cb 

onTerminalPasteClipboard :: (GObject a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
onTerminalPasteClipboard obj cb = liftIO $ connectTerminalPasteClipboard obj cb SignalConnectBefore
afterTerminalPasteClipboard :: (GObject a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
afterTerminalPasteClipboard obj cb = connectTerminalPasteClipboard obj cb SignalConnectAfter

connectTerminalPasteClipboard :: (GObject a, MonadIO m) =>
                                 a -> TerminalPasteClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalPasteClipboard obj cb after = liftIO $ do
    cb' <- mkTerminalPasteClipboardCallback (terminalPasteClipboardCallbackWrapper cb)
    connectSignalFunPtr obj "paste-clipboard" cb' after

-- signal Terminal::raise-window
type TerminalRaiseWindowCallback =
    IO ()

noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback
noTerminalRaiseWindowCallback = Nothing

type TerminalRaiseWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalRaiseWindowCallback :: TerminalRaiseWindowCallbackC -> IO (FunPtr TerminalRaiseWindowCallbackC)

terminalRaiseWindowClosure :: TerminalRaiseWindowCallback -> IO Closure
terminalRaiseWindowClosure cb = newCClosure =<< mkTerminalRaiseWindowCallback wrapped
    where wrapped = terminalRaiseWindowCallbackWrapper cb

terminalRaiseWindowCallbackWrapper ::
    TerminalRaiseWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalRaiseWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalRaiseWindow :: (GObject a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
onTerminalRaiseWindow obj cb = liftIO $ connectTerminalRaiseWindow obj cb SignalConnectBefore
afterTerminalRaiseWindow :: (GObject a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
afterTerminalRaiseWindow obj cb = connectTerminalRaiseWindow obj cb SignalConnectAfter

connectTerminalRaiseWindow :: (GObject a, MonadIO m) =>
                              a -> TerminalRaiseWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalRaiseWindow obj cb after = liftIO $ do
    cb' <- mkTerminalRaiseWindowCallback (terminalRaiseWindowCallbackWrapper cb)
    connectSignalFunPtr obj "raise-window" cb' after

-- signal Terminal::refresh-window
type TerminalRefreshWindowCallback =
    IO ()

noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback
noTerminalRefreshWindowCallback = Nothing

type TerminalRefreshWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalRefreshWindowCallback :: TerminalRefreshWindowCallbackC -> IO (FunPtr TerminalRefreshWindowCallbackC)

terminalRefreshWindowClosure :: TerminalRefreshWindowCallback -> IO Closure
terminalRefreshWindowClosure cb = newCClosure =<< mkTerminalRefreshWindowCallback wrapped
    where wrapped = terminalRefreshWindowCallbackWrapper cb

terminalRefreshWindowCallbackWrapper ::
    TerminalRefreshWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalRefreshWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalRefreshWindow :: (GObject a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
onTerminalRefreshWindow obj cb = liftIO $ connectTerminalRefreshWindow obj cb SignalConnectBefore
afterTerminalRefreshWindow :: (GObject a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
afterTerminalRefreshWindow obj cb = connectTerminalRefreshWindow obj cb SignalConnectAfter

connectTerminalRefreshWindow :: (GObject a, MonadIO m) =>
                                a -> TerminalRefreshWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalRefreshWindow obj cb after = liftIO $ do
    cb' <- mkTerminalRefreshWindowCallback (terminalRefreshWindowCallbackWrapper cb)
    connectSignalFunPtr obj "refresh-window" cb' after

-- signal Terminal::resize-window
type TerminalResizeWindowCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback
noTerminalResizeWindowCallback = Nothing

type TerminalResizeWindowCallbackC =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalResizeWindowCallback :: TerminalResizeWindowCallbackC -> IO (FunPtr TerminalResizeWindowCallbackC)

terminalResizeWindowClosure :: TerminalResizeWindowCallback -> IO Closure
terminalResizeWindowClosure cb = newCClosure =<< mkTerminalResizeWindowCallback wrapped
    where wrapped = terminalResizeWindowCallbackWrapper cb

terminalResizeWindowCallbackWrapper ::
    TerminalResizeWindowCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
terminalResizeWindowCallbackWrapper _cb _ width height _ = do
    _cb  width height

onTerminalResizeWindow :: (GObject a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
onTerminalResizeWindow obj cb = liftIO $ connectTerminalResizeWindow obj cb SignalConnectBefore
afterTerminalResizeWindow :: (GObject a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
afterTerminalResizeWindow obj cb = connectTerminalResizeWindow obj cb SignalConnectAfter

connectTerminalResizeWindow :: (GObject a, MonadIO m) =>
                               a -> TerminalResizeWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalResizeWindow obj cb after = liftIO $ do
    cb' <- mkTerminalResizeWindowCallback (terminalResizeWindowCallbackWrapper cb)
    connectSignalFunPtr obj "resize-window" cb' after

-- signal Terminal::restore-window
type TerminalRestoreWindowCallback =
    IO ()

noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback
noTerminalRestoreWindowCallback = Nothing

type TerminalRestoreWindowCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalRestoreWindowCallback :: TerminalRestoreWindowCallbackC -> IO (FunPtr TerminalRestoreWindowCallbackC)

terminalRestoreWindowClosure :: TerminalRestoreWindowCallback -> IO Closure
terminalRestoreWindowClosure cb = newCClosure =<< mkTerminalRestoreWindowCallback wrapped
    where wrapped = terminalRestoreWindowCallbackWrapper cb

terminalRestoreWindowCallbackWrapper ::
    TerminalRestoreWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalRestoreWindowCallbackWrapper _cb _ _ = do
    _cb 

onTerminalRestoreWindow :: (GObject a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
onTerminalRestoreWindow obj cb = liftIO $ connectTerminalRestoreWindow obj cb SignalConnectBefore
afterTerminalRestoreWindow :: (GObject a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
afterTerminalRestoreWindow obj cb = connectTerminalRestoreWindow obj cb SignalConnectAfter

connectTerminalRestoreWindow :: (GObject a, MonadIO m) =>
                                a -> TerminalRestoreWindowCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalRestoreWindow obj cb after = liftIO $ do
    cb' <- mkTerminalRestoreWindowCallback (terminalRestoreWindowCallbackWrapper cb)
    connectSignalFunPtr obj "restore-window" cb' after

-- signal Terminal::selection-changed
type TerminalSelectionChangedCallback =
    IO ()

noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback
noTerminalSelectionChangedCallback = Nothing

type TerminalSelectionChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalSelectionChangedCallback :: TerminalSelectionChangedCallbackC -> IO (FunPtr TerminalSelectionChangedCallbackC)

terminalSelectionChangedClosure :: TerminalSelectionChangedCallback -> IO Closure
terminalSelectionChangedClosure cb = newCClosure =<< mkTerminalSelectionChangedCallback wrapped
    where wrapped = terminalSelectionChangedCallbackWrapper cb

terminalSelectionChangedCallbackWrapper ::
    TerminalSelectionChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalSelectionChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalSelectionChanged :: (GObject a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
onTerminalSelectionChanged obj cb = liftIO $ connectTerminalSelectionChanged obj cb SignalConnectBefore
afterTerminalSelectionChanged :: (GObject a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
afterTerminalSelectionChanged obj cb = connectTerminalSelectionChanged obj cb SignalConnectAfter

connectTerminalSelectionChanged :: (GObject a, MonadIO m) =>
                                   a -> TerminalSelectionChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalSelectionChanged obj cb after = liftIO $ do
    cb' <- mkTerminalSelectionChangedCallback (terminalSelectionChangedCallbackWrapper cb)
    connectSignalFunPtr obj "selection-changed" cb' after

-- signal Terminal::text-deleted
type TerminalTextDeletedCallback =
    IO ()

noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback
noTerminalTextDeletedCallback = Nothing

type TerminalTextDeletedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalTextDeletedCallback :: TerminalTextDeletedCallbackC -> IO (FunPtr TerminalTextDeletedCallbackC)

terminalTextDeletedClosure :: TerminalTextDeletedCallback -> IO Closure
terminalTextDeletedClosure cb = newCClosure =<< mkTerminalTextDeletedCallback wrapped
    where wrapped = terminalTextDeletedCallbackWrapper cb

terminalTextDeletedCallbackWrapper ::
    TerminalTextDeletedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalTextDeletedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalTextDeleted :: (GObject a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
onTerminalTextDeleted obj cb = liftIO $ connectTerminalTextDeleted obj cb SignalConnectBefore
afterTerminalTextDeleted :: (GObject a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
afterTerminalTextDeleted obj cb = connectTerminalTextDeleted obj cb SignalConnectAfter

connectTerminalTextDeleted :: (GObject a, MonadIO m) =>
                              a -> TerminalTextDeletedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalTextDeleted obj cb after = liftIO $ do
    cb' <- mkTerminalTextDeletedCallback (terminalTextDeletedCallbackWrapper cb)
    connectSignalFunPtr obj "text-deleted" cb' after

-- signal Terminal::text-inserted
type TerminalTextInsertedCallback =
    IO ()

noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback
noTerminalTextInsertedCallback = Nothing

type TerminalTextInsertedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalTextInsertedCallback :: TerminalTextInsertedCallbackC -> IO (FunPtr TerminalTextInsertedCallbackC)

terminalTextInsertedClosure :: TerminalTextInsertedCallback -> IO Closure
terminalTextInsertedClosure cb = newCClosure =<< mkTerminalTextInsertedCallback wrapped
    where wrapped = terminalTextInsertedCallbackWrapper cb

terminalTextInsertedCallbackWrapper ::
    TerminalTextInsertedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalTextInsertedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalTextInserted :: (GObject a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
onTerminalTextInserted obj cb = liftIO $ connectTerminalTextInserted obj cb SignalConnectBefore
afterTerminalTextInserted :: (GObject a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
afterTerminalTextInserted obj cb = connectTerminalTextInserted obj cb SignalConnectAfter

connectTerminalTextInserted :: (GObject a, MonadIO m) =>
                               a -> TerminalTextInsertedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalTextInserted obj cb after = liftIO $ do
    cb' <- mkTerminalTextInsertedCallback (terminalTextInsertedCallbackWrapper cb)
    connectSignalFunPtr obj "text-inserted" cb' after

-- signal Terminal::text-modified
type TerminalTextModifiedCallback =
    IO ()

noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback
noTerminalTextModifiedCallback = Nothing

type TerminalTextModifiedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalTextModifiedCallback :: TerminalTextModifiedCallbackC -> IO (FunPtr TerminalTextModifiedCallbackC)

terminalTextModifiedClosure :: TerminalTextModifiedCallback -> IO Closure
terminalTextModifiedClosure cb = newCClosure =<< mkTerminalTextModifiedCallback wrapped
    where wrapped = terminalTextModifiedCallbackWrapper cb

terminalTextModifiedCallbackWrapper ::
    TerminalTextModifiedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalTextModifiedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalTextModified :: (GObject a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
onTerminalTextModified obj cb = liftIO $ connectTerminalTextModified obj cb SignalConnectBefore
afterTerminalTextModified :: (GObject a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
afterTerminalTextModified obj cb = connectTerminalTextModified obj cb SignalConnectAfter

connectTerminalTextModified :: (GObject a, MonadIO m) =>
                               a -> TerminalTextModifiedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalTextModified obj cb after = liftIO $ do
    cb' <- mkTerminalTextModifiedCallback (terminalTextModifiedCallbackWrapper cb)
    connectSignalFunPtr obj "text-modified" cb' after

-- signal Terminal::text-scrolled
type TerminalTextScrolledCallback =
    Int32 ->
    IO ()

noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback
noTerminalTextScrolledCallback = Nothing

type TerminalTextScrolledCallbackC =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalTextScrolledCallback :: TerminalTextScrolledCallbackC -> IO (FunPtr TerminalTextScrolledCallbackC)

terminalTextScrolledClosure :: TerminalTextScrolledCallback -> IO Closure
terminalTextScrolledClosure cb = newCClosure =<< mkTerminalTextScrolledCallback wrapped
    where wrapped = terminalTextScrolledCallbackWrapper cb

terminalTextScrolledCallbackWrapper ::
    TerminalTextScrolledCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
terminalTextScrolledCallbackWrapper _cb _ delta _ = do
    _cb  delta

onTerminalTextScrolled :: (GObject a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
onTerminalTextScrolled obj cb = liftIO $ connectTerminalTextScrolled obj cb SignalConnectBefore
afterTerminalTextScrolled :: (GObject a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
afterTerminalTextScrolled obj cb = connectTerminalTextScrolled obj cb SignalConnectAfter

connectTerminalTextScrolled :: (GObject a, MonadIO m) =>
                               a -> TerminalTextScrolledCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalTextScrolled obj cb after = liftIO $ do
    cb' <- mkTerminalTextScrolledCallback (terminalTextScrolledCallbackWrapper cb)
    connectSignalFunPtr obj "text-scrolled" cb' after

-- signal Terminal::window-title-changed
type TerminalWindowTitleChangedCallback =
    IO ()

noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback
noTerminalWindowTitleChangedCallback = Nothing

type TerminalWindowTitleChangedCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkTerminalWindowTitleChangedCallback :: TerminalWindowTitleChangedCallbackC -> IO (FunPtr TerminalWindowTitleChangedCallbackC)

terminalWindowTitleChangedClosure :: TerminalWindowTitleChangedCallback -> IO Closure
terminalWindowTitleChangedClosure cb = newCClosure =<< mkTerminalWindowTitleChangedCallback wrapped
    where wrapped = terminalWindowTitleChangedCallbackWrapper cb

terminalWindowTitleChangedCallbackWrapper ::
    TerminalWindowTitleChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
terminalWindowTitleChangedCallbackWrapper _cb _ _ = do
    _cb 

onTerminalWindowTitleChanged :: (GObject a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
onTerminalWindowTitleChanged obj cb = liftIO $ connectTerminalWindowTitleChanged obj cb SignalConnectBefore
afterTerminalWindowTitleChanged :: (GObject a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
afterTerminalWindowTitleChanged obj cb = connectTerminalWindowTitleChanged obj cb SignalConnectAfter

connectTerminalWindowTitleChanged :: (GObject a, MonadIO m) =>
                                     a -> TerminalWindowTitleChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTerminalWindowTitleChanged obj cb after = liftIO $ do
    cb' <- mkTerminalWindowTitleChangedCallback (terminalWindowTitleChangedCallbackWrapper cb)
    connectSignalFunPtr obj "window-title-changed" cb' after

-- Enum WriteFlags

data WriteFlags = 
      WriteFlagsDefault
    | AnotherWriteFlags Int
    deriving (Show, Eq)

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

    toEnum 0 = WriteFlagsDefault
    toEnum k = AnotherWriteFlags k

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

-- constant _MAJOR_VERSION

_MAJOR_VERSION :: Int32
_MAJOR_VERSION = 0
-- constant _MICRO_VERSION

_MICRO_VERSION :: Int32
_MICRO_VERSION = 2
-- constant _MINOR_VERSION

_MINOR_VERSION :: Int32
_MINOR_VERSION = 40
-- constant _SPAWN_NO_PARENT_ENVV

_SPAWN_NO_PARENT_ENVV :: Int32
_SPAWN_NO_PARENT_ENVV = 33554432
-- function vte_get_features
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "vte_get_features" vte_get_features :: 
    IO CString


getFeatures ::
    (MonadIO m) =>
    m T.Text
getFeatures  = liftIO $ do
    result <- vte_get_features
    checkUnexpectedReturnNULL "vte_get_features" result
    result' <- cstringToText result
    return result'

-- function vte_get_major_version
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_get_major_version" vte_get_major_version :: 
    IO Word32


getMajorVersion ::
    (MonadIO m) =>
    m Word32
getMajorVersion  = liftIO $ do
    result <- vte_get_major_version
    return result

-- function vte_get_micro_version
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_get_micro_version" vte_get_micro_version :: 
    IO Word32


getMicroVersion ::
    (MonadIO m) =>
    m Word32
getMicroVersion  = liftIO $ do
    result <- vte_get_micro_version
    return result

-- function vte_get_minor_version
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_get_minor_version" vte_get_minor_version :: 
    IO Word32


getMinorVersion ::
    (MonadIO m) =>
    m Word32
getMinorVersion  = liftIO $ do
    result <- vte_get_minor_version
    return result

-- function vte_get_user_shell
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TFileName
-- throws : False
-- Skip return : False

foreign import ccall "vte_get_user_shell" vte_get_user_shell :: 
    IO CString


getUserShell ::
    (MonadIO m) =>
    m [Char]
getUserShell  = liftIO $ do
    result <- vte_get_user_shell
    checkUnexpectedReturnNULL "vte_get_user_shell" result
    result' <- cstringToString result
    freeMem result
    return result'

-- function vte_pty_error_quark
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "vte_pty_error_quark" vte_pty_error_quark :: 
    IO Word32


ptyErrorQuark ::
    (MonadIO m) =>
    m Word32
ptyErrorQuark  = liftIO $ do
    result <- vte_pty_error_quark
    return result