GI.Vte.Objects.Terminal

Exported types

newtype Terminal

Constructors

Terminal (ForeignPtr Terminal)

Instances

GObject Terminal

((~) * info (ResolveTerminalMethod t Terminal), MethodInfo * info Terminal p) => IsLabelProxy t (Terminal -> p)

type ParentTypes Terminal

type AttributeList Terminal

type SignalList Terminal

class GObject o => TerminalK o

Instances

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

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

noTerminal :: Maybe Terminal

Methods

terminalCopyClipboard

data TerminalCopyClipboardMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalCopyClipboardMethodInfo a signature

terminalCopyClipboard :: (MonadIO m, TerminalK a) => a -> m ()

terminalCopyPrimary

data TerminalCopyPrimaryMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalCopyPrimaryMethodInfo a signature

terminalCopyPrimary :: (MonadIO m, TerminalK a) => a -> m ()

terminalFeed

data TerminalFeedMethodInfo

Instances

((~) * signature (ByteString -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalFeedMethodInfo a signature

terminalFeed :: (MonadIO m, TerminalK a) => a -> ByteString -> m ()

terminalFeedChild

data TerminalFeedChildMethodInfo

Instances

((~) * signature (Text -> Int64 -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalFeedChildMethodInfo a signature

terminalFeedChild :: (MonadIO m, TerminalK a) => a -> Text -> Int64 -> m ()

terminalFeedChildBinary

data TerminalFeedChildBinaryMethodInfo

Instances

((~) * signature (Word8 -> Word64 -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalFeedChildBinaryMethodInfo a signature

terminalFeedChildBinary :: (MonadIO m, TerminalK a) => a -> Word8 -> Word64 -> m ()

terminalGetAllowBold

data TerminalGetAllowBoldMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetAllowBoldMethodInfo a signature

terminalGetAllowBold :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetAudibleBell

data TerminalGetAudibleBellMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetAudibleBellMethodInfo a signature

terminalGetAudibleBell :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetCharHeight

data TerminalGetCharHeightMethodInfo

Instances

((~) * signature (m CLong), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCharHeightMethodInfo a signature

terminalGetCharHeight :: (MonadIO m, TerminalK a) => a -> m CLong

terminalGetCharWidth

data TerminalGetCharWidthMethodInfo

Instances

((~) * signature (m CLong), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCharWidthMethodInfo a signature

terminalGetCharWidth :: (MonadIO m, TerminalK a) => a -> m CLong

terminalGetCjkAmbiguousWidth

data TerminalGetCjkAmbiguousWidthMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCjkAmbiguousWidthMethodInfo a signature

terminalGetCjkAmbiguousWidth :: (MonadIO m, TerminalK a) => a -> m Int32

terminalGetColumnCount

data TerminalGetColumnCountMethodInfo

Instances

((~) * signature (m CLong), MonadIO m, TerminalK a) => MethodInfo * TerminalGetColumnCountMethodInfo a signature

terminalGetColumnCount :: (MonadIO m, TerminalK a) => a -> m CLong

terminalGetCurrentDirectoryUri

data TerminalGetCurrentDirectoryUriMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCurrentDirectoryUriMethodInfo a signature

terminalGetCurrentDirectoryUri :: (MonadIO m, TerminalK a) => a -> m Text

terminalGetCurrentFileUri

data TerminalGetCurrentFileUriMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCurrentFileUriMethodInfo a signature

terminalGetCurrentFileUri :: (MonadIO m, TerminalK a) => a -> m Text

terminalGetCursorBlinkMode

data TerminalGetCursorBlinkModeMethodInfo

Instances

((~) * signature (m CursorBlinkMode), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCursorBlinkModeMethodInfo a signature

terminalGetCursorBlinkMode :: (MonadIO m, TerminalK a) => a -> m CursorBlinkMode

terminalGetCursorPosition

data TerminalGetCursorPositionMethodInfo

Instances

((~) * signature (m (CLong, CLong)), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCursorPositionMethodInfo a signature

terminalGetCursorPosition :: (MonadIO m, TerminalK a) => a -> m (CLong, CLong)

terminalGetCursorShape

data TerminalGetCursorShapeMethodInfo

Instances

((~) * signature (m CursorShape), MonadIO m, TerminalK a) => MethodInfo * TerminalGetCursorShapeMethodInfo a signature

terminalGetCursorShape :: (MonadIO m, TerminalK a) => a -> m CursorShape

terminalGetEncoding

data TerminalGetEncodingMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetEncodingMethodInfo a signature

terminalGetEncoding :: (MonadIO m, TerminalK a) => a -> m Text

terminalGetFont

data TerminalGetFontMethodInfo

Instances

((~) * signature (m FontDescription), MonadIO m, TerminalK a) => MethodInfo * TerminalGetFontMethodInfo a signature

terminalGetFont :: (MonadIO m, TerminalK a) => a -> m FontDescription

terminalGetFontScale

data TerminalGetFontScaleMethodInfo

Instances

((~) * signature (m Double), MonadIO m, TerminalK a) => MethodInfo * TerminalGetFontScaleMethodInfo a signature

terminalGetFontScale :: (MonadIO m, TerminalK a) => a -> m Double

terminalGetGeometryHints

data TerminalGetGeometryHintsMethodInfo

Instances

((~) * signature (Int32 -> Int32 -> m Geometry), MonadIO m, TerminalK a) => MethodInfo * TerminalGetGeometryHintsMethodInfo a signature

terminalGetGeometryHints :: (MonadIO m, TerminalK a) => a -> Int32 -> Int32 -> m Geometry

terminalGetHasSelection

data TerminalGetHasSelectionMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetHasSelectionMethodInfo a signature

terminalGetHasSelection :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetIconTitle

data TerminalGetIconTitleMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetIconTitleMethodInfo a signature

terminalGetIconTitle :: (MonadIO m, TerminalK a) => a -> m Text

terminalGetInputEnabled

data TerminalGetInputEnabledMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetInputEnabledMethodInfo a signature

terminalGetInputEnabled :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetMouseAutohide

data TerminalGetMouseAutohideMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetMouseAutohideMethodInfo a signature

terminalGetMouseAutohide :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetPty

data TerminalGetPtyMethodInfo

Instances

((~) * signature (m Pty), MonadIO m, TerminalK a) => MethodInfo * TerminalGetPtyMethodInfo a signature

terminalGetPty :: (MonadIO m, TerminalK a) => a -> m Pty

terminalGetRewrapOnResize

data TerminalGetRewrapOnResizeMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalGetRewrapOnResizeMethodInfo a signature

terminalGetRewrapOnResize :: (MonadIO m, TerminalK a) => a -> m Bool

terminalGetRowCount

data TerminalGetRowCountMethodInfo

Instances

((~) * signature (m CLong), MonadIO m, TerminalK a) => MethodInfo * TerminalGetRowCountMethodInfo a signature

terminalGetRowCount :: (MonadIO m, TerminalK a) => a -> m CLong

terminalGetText

data TerminalGetTextMethodInfo

Instances

((~) * signature (Maybe SelectionFunc -> m (Text, [CharAttributes])), MonadIO m, TerminalK a) => MethodInfo * TerminalGetTextMethodInfo a signature

terminalGetText :: (MonadIO m, TerminalK a) => a -> Maybe SelectionFunc -> m (Text, [CharAttributes])

terminalGetTextIncludeTrailingSpaces

data TerminalGetTextIncludeTrailingSpacesMethodInfo

Instances

((~) * signature (Maybe SelectionFunc -> m (Text, [CharAttributes])), MonadIO m, TerminalK a) => MethodInfo * TerminalGetTextIncludeTrailingSpacesMethodInfo a signature

terminalGetTextIncludeTrailingSpaces :: (MonadIO m, TerminalK a) => a -> Maybe SelectionFunc -> m (Text, [CharAttributes])

terminalGetTextRange

data TerminalGetTextRangeMethodInfo

Instances

((~) * signature (CLong -> CLong -> CLong -> CLong -> Maybe SelectionFunc -> m (Text, [CharAttributes])), MonadIO m, TerminalK a) => MethodInfo * TerminalGetTextRangeMethodInfo a signature

terminalGetTextRange :: (MonadIO m, TerminalK a) => a -> CLong -> CLong -> CLong -> CLong -> Maybe SelectionFunc -> m (Text, [CharAttributes])

terminalGetWindowTitle

data TerminalGetWindowTitleMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetWindowTitleMethodInfo a signature

terminalGetWindowTitle :: (MonadIO m, TerminalK a) => a -> m Text

terminalGetWordCharExceptions

data TerminalGetWordCharExceptionsMethodInfo

Instances

((~) * signature (m Text), MonadIO m, TerminalK a) => MethodInfo * TerminalGetWordCharExceptionsMethodInfo a signature

terminalGetWordCharExceptions :: (MonadIO m, TerminalK a) => a -> m Text

terminalMatchAddGregex

data TerminalMatchAddGregexMethodInfo

Instances

((~) * signature (Regex -> [RegexMatchFlags] -> m Int32), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchAddGregexMethodInfo a signature

terminalMatchAddGregex :: (MonadIO m, TerminalK a) => a -> Regex -> [RegexMatchFlags] -> m Int32

terminalMatchCheck

data TerminalMatchCheckMethodInfo

Instances

((~) * signature (CLong -> CLong -> m (Text, Int32)), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchCheckMethodInfo a signature

terminalMatchCheck :: (MonadIO m, TerminalK a) => a -> CLong -> CLong -> m (Text, Int32)

terminalMatchCheckEvent

data TerminalMatchCheckEventMethodInfo

Instances

((~) * signature (Event -> m (Text, Int32)), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchCheckEventMethodInfo a signature

terminalMatchCheckEvent :: (MonadIO m, TerminalK a) => a -> Event -> m (Text, Int32)

terminalMatchRemove

data TerminalMatchRemoveMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchRemoveMethodInfo a signature

terminalMatchRemove :: (MonadIO m, TerminalK a) => a -> Int32 -> m ()

terminalMatchRemoveAll

data TerminalMatchRemoveAllMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchRemoveAllMethodInfo a signature

terminalMatchRemoveAll :: (MonadIO m, TerminalK a) => a -> m ()

terminalMatchSetCursorName

data TerminalMatchSetCursorNameMethodInfo

Instances

((~) * signature (Int32 -> Text -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchSetCursorNameMethodInfo a signature

terminalMatchSetCursorName :: (MonadIO m, TerminalK a) => a -> Int32 -> Text -> m ()

terminalMatchSetCursorType

data TerminalMatchSetCursorTypeMethodInfo

Instances

((~) * signature (Int32 -> CursorType -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalMatchSetCursorTypeMethodInfo a signature

terminalMatchSetCursorType :: (MonadIO m, TerminalK a) => a -> Int32 -> CursorType -> m ()

terminalNew

terminalNew :: MonadIO m => m Terminal

terminalPasteClipboard

data TerminalPasteClipboardMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalPasteClipboardMethodInfo a signature

terminalPasteClipboard :: (MonadIO m, TerminalK a) => a -> m ()

terminalPastePrimary

data TerminalPastePrimaryMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalPastePrimaryMethodInfo a signature

terminalPastePrimary :: (MonadIO m, TerminalK a) => a -> m ()

terminalPtyNewSync

data TerminalPtyNewSyncMethodInfo

Instances

((~) * signature ([PtyFlags] -> Maybe b -> m Pty), MonadIO m, TerminalK a, CancellableK b) => MethodInfo * TerminalPtyNewSyncMethodInfo a signature

terminalPtyNewSync :: (MonadIO m, TerminalK a, CancellableK b) => a -> [PtyFlags] -> Maybe b -> m Pty

terminalReset

data TerminalResetMethodInfo

Instances

((~) * signature (Bool -> Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalResetMethodInfo a signature

terminalReset :: (MonadIO m, TerminalK a) => a -> Bool -> Bool -> m ()

terminalSearchFindNext

data TerminalSearchFindNextMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchFindNextMethodInfo a signature

terminalSearchFindNext :: (MonadIO m, TerminalK a) => a -> m Bool

terminalSearchFindPrevious

data TerminalSearchFindPreviousMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchFindPreviousMethodInfo a signature

terminalSearchFindPrevious :: (MonadIO m, TerminalK a) => a -> m Bool

terminalSearchGetGregex

data TerminalSearchGetGregexMethodInfo

Instances

((~) * signature (m Regex), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchGetGregexMethodInfo a signature

terminalSearchGetGregex :: (MonadIO m, TerminalK a) => a -> m Regex

terminalSearchGetWrapAround

data TerminalSearchGetWrapAroundMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchGetWrapAroundMethodInfo a signature

terminalSearchGetWrapAround :: (MonadIO m, TerminalK a) => a -> m Bool

terminalSearchSetGregex

data TerminalSearchSetGregexMethodInfo

Instances

((~) * signature (Maybe Regex -> [RegexMatchFlags] -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchSetGregexMethodInfo a signature

terminalSearchSetGregex :: (MonadIO m, TerminalK a) => a -> Maybe Regex -> [RegexMatchFlags] -> m ()

terminalSearchSetWrapAround

data TerminalSearchSetWrapAroundMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSearchSetWrapAroundMethodInfo a signature

terminalSearchSetWrapAround :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSelectAll

data TerminalSelectAllMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSelectAllMethodInfo a signature

terminalSelectAll :: (MonadIO m, TerminalK a) => a -> m ()

terminalSetAllowBold

data TerminalSetAllowBoldMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetAllowBoldMethodInfo a signature

terminalSetAllowBold :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetAudibleBell

data TerminalSetAudibleBellMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetAudibleBellMethodInfo a signature

terminalSetAudibleBell :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetBackspaceBinding

data TerminalSetBackspaceBindingMethodInfo

Instances

((~) * signature (EraseBinding -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetBackspaceBindingMethodInfo a signature

terminalSetBackspaceBinding :: (MonadIO m, TerminalK a) => a -> EraseBinding -> m ()

terminalSetCjkAmbiguousWidth

data TerminalSetCjkAmbiguousWidthMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetCjkAmbiguousWidthMethodInfo a signature

terminalSetCjkAmbiguousWidth :: (MonadIO m, TerminalK a) => a -> Int32 -> m ()

terminalSetColorBackground

data TerminalSetColorBackgroundMethodInfo

Instances

((~) * signature (RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorBackgroundMethodInfo a signature

terminalSetColorBackground :: (MonadIO m, TerminalK a) => a -> RGBA -> m ()

terminalSetColorBold

data TerminalSetColorBoldMethodInfo

Instances

((~) * signature (Maybe RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorBoldMethodInfo a signature

terminalSetColorBold :: (MonadIO m, TerminalK a) => a -> Maybe RGBA -> m ()

terminalSetColorCursor

data TerminalSetColorCursorMethodInfo

Instances

((~) * signature (Maybe RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorCursorMethodInfo a signature

terminalSetColorCursor :: (MonadIO m, TerminalK a) => a -> Maybe RGBA -> m ()

terminalSetColorForeground

data TerminalSetColorForegroundMethodInfo

Instances

((~) * signature (RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorForegroundMethodInfo a signature

terminalSetColorForeground :: (MonadIO m, TerminalK a) => a -> RGBA -> m ()

terminalSetColorHighlight

data TerminalSetColorHighlightMethodInfo

Instances

((~) * signature (Maybe RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorHighlightMethodInfo a signature

terminalSetColorHighlight :: (MonadIO m, TerminalK a) => a -> Maybe RGBA -> m ()

terminalSetColorHighlightForeground

data TerminalSetColorHighlightForegroundMethodInfo

Instances

((~) * signature (Maybe RGBA -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorHighlightForegroundMethodInfo a signature

terminalSetColorHighlightForeground :: (MonadIO m, TerminalK a) => a -> Maybe RGBA -> m ()

terminalSetColors

data TerminalSetColorsMethodInfo

Instances

((~) * signature (Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetColorsMethodInfo a signature

terminalSetColors :: (MonadIO m, TerminalK a) => a -> Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()

terminalSetCursorBlinkMode

data TerminalSetCursorBlinkModeMethodInfo

Instances

((~) * signature (CursorBlinkMode -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetCursorBlinkModeMethodInfo a signature

terminalSetCursorBlinkMode :: (MonadIO m, TerminalK a) => a -> CursorBlinkMode -> m ()

terminalSetCursorShape

data TerminalSetCursorShapeMethodInfo

Instances

((~) * signature (CursorShape -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetCursorShapeMethodInfo a signature

terminalSetCursorShape :: (MonadIO m, TerminalK a) => a -> CursorShape -> m ()

terminalSetDefaultColors

data TerminalSetDefaultColorsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetDefaultColorsMethodInfo a signature

terminalSetDefaultColors :: (MonadIO m, TerminalK a) => a -> m ()

terminalSetDeleteBinding

data TerminalSetDeleteBindingMethodInfo

Instances

((~) * signature (EraseBinding -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetDeleteBindingMethodInfo a signature

terminalSetDeleteBinding :: (MonadIO m, TerminalK a) => a -> EraseBinding -> m ()

terminalSetEncoding

data TerminalSetEncodingMethodInfo

Instances

((~) * signature (Maybe Text -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetEncodingMethodInfo a signature

terminalSetEncoding :: (MonadIO m, TerminalK a) => a -> Maybe Text -> m ()

terminalSetFont

data TerminalSetFontMethodInfo

Instances

((~) * signature (Maybe FontDescription -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetFontMethodInfo a signature

terminalSetFont :: (MonadIO m, TerminalK a) => a -> Maybe FontDescription -> m ()

terminalSetFontScale

data TerminalSetFontScaleMethodInfo

Instances

((~) * signature (Double -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetFontScaleMethodInfo a signature

terminalSetFontScale :: (MonadIO m, TerminalK a) => a -> Double -> m ()

terminalSetGeometryHintsForWindow

data TerminalSetGeometryHintsForWindowMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, TerminalK a, WindowK b) => MethodInfo * TerminalSetGeometryHintsForWindowMethodInfo a signature

terminalSetGeometryHintsForWindow :: (MonadIO m, TerminalK a, WindowK b) => a -> b -> m ()

terminalSetInputEnabled

data TerminalSetInputEnabledMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetInputEnabledMethodInfo a signature

terminalSetInputEnabled :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetMouseAutohide

data TerminalSetMouseAutohideMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetMouseAutohideMethodInfo a signature

terminalSetMouseAutohide :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetPty

data TerminalSetPtyMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, TerminalK a, PtyK b) => MethodInfo * TerminalSetPtyMethodInfo a signature

terminalSetPty :: (MonadIO m, TerminalK a, PtyK b) => a -> Maybe b -> m ()

terminalSetRewrapOnResize

data TerminalSetRewrapOnResizeMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetRewrapOnResizeMethodInfo a signature

terminalSetRewrapOnResize :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetScrollOnKeystroke

data TerminalSetScrollOnKeystrokeMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetScrollOnKeystrokeMethodInfo a signature

terminalSetScrollOnKeystroke :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetScrollOnOutput

data TerminalSetScrollOnOutputMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetScrollOnOutputMethodInfo a signature

terminalSetScrollOnOutput :: (MonadIO m, TerminalK a) => a -> Bool -> m ()

terminalSetScrollbackLines

data TerminalSetScrollbackLinesMethodInfo

Instances

((~) * signature (CLong -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetScrollbackLinesMethodInfo a signature

terminalSetScrollbackLines :: (MonadIO m, TerminalK a) => a -> CLong -> m ()

terminalSetSize

data TerminalSetSizeMethodInfo

Instances

((~) * signature (CLong -> CLong -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetSizeMethodInfo a signature

terminalSetSize :: (MonadIO m, TerminalK a) => a -> CLong -> CLong -> m ()

terminalSetWordCharExceptions

data TerminalSetWordCharExceptionsMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalSetWordCharExceptionsMethodInfo a signature

terminalSetWordCharExceptions :: (MonadIO m, TerminalK a) => a -> Text -> m ()

terminalSpawnSync

data TerminalSpawnSyncMethodInfo

Instances

((~) * signature ([PtyFlags] -> Maybe Text -> [[Char]] -> Maybe [[Char]] -> [SpawnFlags] -> Maybe SpawnChildSetupFunc -> Maybe b -> m Int32), MonadIO m, TerminalK a, CancellableK b) => MethodInfo * TerminalSpawnSyncMethodInfo a signature

terminalSpawnSync :: (MonadIO m, TerminalK a, CancellableK b) => a -> [PtyFlags] -> Maybe Text -> [[Char]] -> Maybe [[Char]] -> [SpawnFlags] -> Maybe SpawnChildSetupFunc -> Maybe b -> m Int32

terminalUnselectAll

data TerminalUnselectAllMethodInfo

Instances

((~) * signature (m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalUnselectAllMethodInfo a signature

terminalUnselectAll :: (MonadIO m, TerminalK a) => a -> m ()

terminalWatchChild

data TerminalWatchChildMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, TerminalK a) => MethodInfo * TerminalWatchChildMethodInfo a signature

terminalWatchChild :: (MonadIO m, TerminalK a) => a -> Int32 -> m ()

terminalWriteContentsSync

data TerminalWriteContentsSyncMethodInfo

Instances

((~) * signature (b -> WriteFlags -> Maybe c -> m ()), MonadIO m, TerminalK a, OutputStreamK b, CancellableK c) => MethodInfo * TerminalWriteContentsSyncMethodInfo a signature

terminalWriteContentsSync :: (MonadIO m, TerminalK a, OutputStreamK b, CancellableK c) => a -> b -> WriteFlags -> Maybe c -> m ()

Properties

AllowBold

data TerminalAllowBoldPropertyInfo

Instances

AttrInfo TerminalAllowBoldPropertyInfo

type AttrLabel TerminalAllowBoldPropertyInfo = "allow-bold"

type AttrGetType TerminalAllowBoldPropertyInfo = Bool

type AttrBaseTypeConstraint TerminalAllowBoldPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalAllowBoldPropertyInfo = * ~ Bool

type AttrAllowedOps TerminalAllowBoldPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalAllowBold :: Bool -> IO ([Char], GValue)

getTerminalAllowBold :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalAllowBold :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalAllowBold :: AttrLabelProxy "allowBold"

AudibleBell

data TerminalAudibleBellPropertyInfo

Instances

AttrInfo TerminalAudibleBellPropertyInfo

type AttrLabel TerminalAudibleBellPropertyInfo = "audible-bell"

type AttrGetType TerminalAudibleBellPropertyInfo = Bool

type AttrBaseTypeConstraint TerminalAudibleBellPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalAudibleBellPropertyInfo = * ~ Bool

type AttrAllowedOps TerminalAudibleBellPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalAudibleBell :: Bool -> IO ([Char], GValue)

getTerminalAudibleBell :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalAudibleBell :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalAudibleBell :: AttrLabelProxy "audibleBell"

BackspaceBinding

data TerminalBackspaceBindingPropertyInfo

Instances

AttrInfo TerminalBackspaceBindingPropertyInfo

type AttrLabel TerminalBackspaceBindingPropertyInfo = "backspace-binding"

type AttrGetType TerminalBackspaceBindingPropertyInfo = EraseBinding

type AttrBaseTypeConstraint TerminalBackspaceBindingPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalBackspaceBindingPropertyInfo = * ~ EraseBinding

type AttrAllowedOps TerminalBackspaceBindingPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalBackspaceBinding :: EraseBinding -> IO ([Char], GValue)

getTerminalBackspaceBinding :: (MonadIO m, TerminalK o) => o -> m EraseBinding

setTerminalBackspaceBinding :: (MonadIO m, TerminalK o) => o -> EraseBinding -> m ()

terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"

CjkAmbiguousWidth

data TerminalCjkAmbiguousWidthPropertyInfo

Instances

AttrInfo TerminalCjkAmbiguousWidthPropertyInfo

type AttrLabel TerminalCjkAmbiguousWidthPropertyInfo = "cjk-ambiguous-width"

type AttrGetType TerminalCjkAmbiguousWidthPropertyInfo = Int32

type AttrBaseTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = * ~ Int32

type AttrAllowedOps TerminalCjkAmbiguousWidthPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalCjkAmbiguousWidth :: Int32 -> IO ([Char], GValue)

getTerminalCjkAmbiguousWidth :: (MonadIO m, TerminalK o) => o -> m Int32

setTerminalCjkAmbiguousWidth :: (MonadIO m, TerminalK o) => o -> Int32 -> m ()

terminalCjkAmbiguousWidth :: AttrLabelProxy "cjkAmbiguousWidth"

CurrentDirectoryUri

data TerminalCurrentDirectoryUriPropertyInfo

Instances

AttrInfo TerminalCurrentDirectoryUriPropertyInfo

type AttrLabel TerminalCurrentDirectoryUriPropertyInfo = "current-directory-uri"

type AttrGetType TerminalCurrentDirectoryUriPropertyInfo = Text

type AttrBaseTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = * ~ ()

type AttrAllowedOps TerminalCurrentDirectoryUriPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getTerminalCurrentDirectoryUri :: (MonadIO m, TerminalK o) => o -> m Text

terminalCurrentDirectoryUri :: AttrLabelProxy "currentDirectoryUri"

CurrentFileUri

data TerminalCurrentFileUriPropertyInfo

Instances

AttrInfo TerminalCurrentFileUriPropertyInfo

type AttrLabel TerminalCurrentFileUriPropertyInfo = "current-file-uri"

type AttrGetType TerminalCurrentFileUriPropertyInfo = Text

type AttrBaseTypeConstraint TerminalCurrentFileUriPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalCurrentFileUriPropertyInfo = * ~ ()

type AttrAllowedOps TerminalCurrentFileUriPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getTerminalCurrentFileUri :: (MonadIO m, TerminalK o) => o -> m Text

terminalCurrentFileUri :: AttrLabelProxy "currentFileUri"

CursorBlinkMode

data TerminalCursorBlinkModePropertyInfo

Instances

AttrInfo TerminalCursorBlinkModePropertyInfo

type AttrLabel TerminalCursorBlinkModePropertyInfo = "cursor-blink-mode"

type AttrGetType TerminalCursorBlinkModePropertyInfo = CursorBlinkMode

type AttrBaseTypeConstraint TerminalCursorBlinkModePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalCursorBlinkModePropertyInfo = * ~ CursorBlinkMode

type AttrAllowedOps TerminalCursorBlinkModePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalCursorBlinkMode :: CursorBlinkMode -> IO ([Char], GValue)

getTerminalCursorBlinkMode :: (MonadIO m, TerminalK o) => o -> m CursorBlinkMode

setTerminalCursorBlinkMode :: (MonadIO m, TerminalK o) => o -> CursorBlinkMode -> m ()

terminalCursorBlinkMode :: AttrLabelProxy "cursorBlinkMode"

CursorShape

data TerminalCursorShapePropertyInfo

Instances

AttrInfo TerminalCursorShapePropertyInfo

type AttrLabel TerminalCursorShapePropertyInfo = "cursor-shape"

type AttrGetType TerminalCursorShapePropertyInfo = CursorShape

type AttrBaseTypeConstraint TerminalCursorShapePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalCursorShapePropertyInfo = * ~ CursorShape

type AttrAllowedOps TerminalCursorShapePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalCursorShape :: CursorShape -> IO ([Char], GValue)

getTerminalCursorShape :: (MonadIO m, TerminalK o) => o -> m CursorShape

setTerminalCursorShape :: (MonadIO m, TerminalK o) => o -> CursorShape -> m ()

terminalCursorShape :: AttrLabelProxy "cursorShape"

DeleteBinding

data TerminalDeleteBindingPropertyInfo

Instances

AttrInfo TerminalDeleteBindingPropertyInfo

type AttrLabel TerminalDeleteBindingPropertyInfo = "delete-binding"

type AttrGetType TerminalDeleteBindingPropertyInfo = EraseBinding

type AttrBaseTypeConstraint TerminalDeleteBindingPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalDeleteBindingPropertyInfo = * ~ EraseBinding

type AttrAllowedOps TerminalDeleteBindingPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalDeleteBinding :: EraseBinding -> IO ([Char], GValue)

getTerminalDeleteBinding :: (MonadIO m, TerminalK o) => o -> m EraseBinding

setTerminalDeleteBinding :: (MonadIO m, TerminalK o) => o -> EraseBinding -> m ()

terminalDeleteBinding :: AttrLabelProxy "deleteBinding"

Encoding

data TerminalEncodingPropertyInfo

Instances

AttrInfo TerminalEncodingPropertyInfo

type AttrLabel TerminalEncodingPropertyInfo = "encoding"

type AttrGetType TerminalEncodingPropertyInfo = Text

type AttrBaseTypeConstraint TerminalEncodingPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalEncodingPropertyInfo = * ~ Text

type AttrAllowedOps TerminalEncodingPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearTerminalEncoding :: (MonadIO m, TerminalK o) => o -> m ()

constructTerminalEncoding :: Text -> IO ([Char], GValue)

getTerminalEncoding :: (MonadIO m, TerminalK o) => o -> m Text

setTerminalEncoding :: (MonadIO m, TerminalK o) => o -> Text -> m ()

terminalEncoding :: AttrLabelProxy "encoding"

FontDesc

data TerminalFontDescPropertyInfo

Instances

AttrInfo TerminalFontDescPropertyInfo

type AttrLabel TerminalFontDescPropertyInfo = "font-desc"

type AttrGetType TerminalFontDescPropertyInfo = Maybe FontDescription

type AttrBaseTypeConstraint TerminalFontDescPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalFontDescPropertyInfo = * ~ FontDescription

type AttrAllowedOps TerminalFontDescPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearTerminalFontDesc :: (MonadIO m, TerminalK o) => o -> m ()

constructTerminalFontDesc :: FontDescription -> IO ([Char], GValue)

getTerminalFontDesc :: (MonadIO m, TerminalK o) => o -> m (Maybe FontDescription)

setTerminalFontDesc :: (MonadIO m, TerminalK o) => o -> FontDescription -> m ()

terminalFontDesc :: AttrLabelProxy "fontDesc"

FontScale

data TerminalFontScalePropertyInfo

Instances

AttrInfo TerminalFontScalePropertyInfo

type AttrLabel TerminalFontScalePropertyInfo = "font-scale"

type AttrGetType TerminalFontScalePropertyInfo = Double

type AttrBaseTypeConstraint TerminalFontScalePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalFontScalePropertyInfo = * ~ Double

type AttrAllowedOps TerminalFontScalePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalFontScale :: Double -> IO ([Char], GValue)

getTerminalFontScale :: (MonadIO m, TerminalK o) => o -> m Double

setTerminalFontScale :: (MonadIO m, TerminalK o) => o -> Double -> m ()

terminalFontScale :: AttrLabelProxy "fontScale"

IconTitle

data TerminalIconTitlePropertyInfo

Instances

AttrInfo TerminalIconTitlePropertyInfo

type AttrLabel TerminalIconTitlePropertyInfo = "icon-title"

type AttrGetType TerminalIconTitlePropertyInfo = Text

type AttrBaseTypeConstraint TerminalIconTitlePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalIconTitlePropertyInfo = * ~ ()

type AttrAllowedOps TerminalIconTitlePropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getTerminalIconTitle :: (MonadIO m, TerminalK o) => o -> m Text

terminalIconTitle :: AttrLabelProxy "iconTitle"

InputEnabled

data TerminalInputEnabledPropertyInfo

Instances

AttrInfo TerminalInputEnabledPropertyInfo

type AttrLabel TerminalInputEnabledPropertyInfo = "input-enabled"

type AttrGetType TerminalInputEnabledPropertyInfo = Bool

type AttrBaseTypeConstraint TerminalInputEnabledPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalInputEnabledPropertyInfo = * ~ Bool

type AttrAllowedOps TerminalInputEnabledPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalInputEnabled :: Bool -> IO ([Char], GValue)

getTerminalInputEnabled :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalInputEnabled :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalInputEnabled :: AttrLabelProxy "inputEnabled"

PointerAutohide

data TerminalPointerAutohidePropertyInfo

Instances

AttrInfo TerminalPointerAutohidePropertyInfo

type AttrLabel TerminalPointerAutohidePropertyInfo = "pointer-autohide"

type AttrGetType TerminalPointerAutohidePropertyInfo = Bool

type AttrBaseTypeConstraint TerminalPointerAutohidePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalPointerAutohidePropertyInfo = * ~ Bool

type AttrAllowedOps TerminalPointerAutohidePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalPointerAutohide :: Bool -> IO ([Char], GValue)

getTerminalPointerAutohide :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalPointerAutohide :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalPointerAutohide :: AttrLabelProxy "pointerAutohide"

Pty

data TerminalPtyPropertyInfo

Instances

AttrInfo TerminalPtyPropertyInfo

type AttrLabel TerminalPtyPropertyInfo = "pty"

type AttrGetType TerminalPtyPropertyInfo = Pty

type AttrBaseTypeConstraint TerminalPtyPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalPtyPropertyInfo = PtyK

type AttrAllowedOps TerminalPtyPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearTerminalPty :: (MonadIO m, TerminalK o) => o -> m ()

constructTerminalPty :: PtyK a => a -> IO ([Char], GValue)

getTerminalPty :: (MonadIO m, TerminalK o) => o -> m Pty

setTerminalPty :: (MonadIO m, TerminalK o, PtyK a) => o -> a -> m ()

terminalPty :: AttrLabelProxy "pty"

RewrapOnResize

data TerminalRewrapOnResizePropertyInfo

Instances

AttrInfo TerminalRewrapOnResizePropertyInfo

type AttrLabel TerminalRewrapOnResizePropertyInfo = "rewrap-on-resize"

type AttrGetType TerminalRewrapOnResizePropertyInfo = Bool

type AttrBaseTypeConstraint TerminalRewrapOnResizePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalRewrapOnResizePropertyInfo = * ~ Bool

type AttrAllowedOps TerminalRewrapOnResizePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalRewrapOnResize :: Bool -> IO ([Char], GValue)

getTerminalRewrapOnResize :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalRewrapOnResize :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalRewrapOnResize :: AttrLabelProxy "rewrapOnResize"

ScrollOnKeystroke

data TerminalScrollOnKeystrokePropertyInfo

Instances

AttrInfo TerminalScrollOnKeystrokePropertyInfo

type AttrLabel TerminalScrollOnKeystrokePropertyInfo = "scroll-on-keystroke"

type AttrGetType TerminalScrollOnKeystrokePropertyInfo = Bool

type AttrBaseTypeConstraint TerminalScrollOnKeystrokePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalScrollOnKeystrokePropertyInfo = * ~ Bool

type AttrAllowedOps TerminalScrollOnKeystrokePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalScrollOnKeystroke :: Bool -> IO ([Char], GValue)

getTerminalScrollOnKeystroke :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalScrollOnKeystroke :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalScrollOnKeystroke :: AttrLabelProxy "scrollOnKeystroke"

ScrollOnOutput

data TerminalScrollOnOutputPropertyInfo

Instances

AttrInfo TerminalScrollOnOutputPropertyInfo

type AttrLabel TerminalScrollOnOutputPropertyInfo = "scroll-on-output"

type AttrGetType TerminalScrollOnOutputPropertyInfo = Bool

type AttrBaseTypeConstraint TerminalScrollOnOutputPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalScrollOnOutputPropertyInfo = * ~ Bool

type AttrAllowedOps TerminalScrollOnOutputPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalScrollOnOutput :: Bool -> IO ([Char], GValue)

getTerminalScrollOnOutput :: (MonadIO m, TerminalK o) => o -> m Bool

setTerminalScrollOnOutput :: (MonadIO m, TerminalK o) => o -> Bool -> m ()

terminalScrollOnOutput :: AttrLabelProxy "scrollOnOutput"

ScrollbackLines

data TerminalScrollbackLinesPropertyInfo

Instances

AttrInfo TerminalScrollbackLinesPropertyInfo

type AttrLabel TerminalScrollbackLinesPropertyInfo = "scrollback-lines"

type AttrGetType TerminalScrollbackLinesPropertyInfo = Word32

type AttrBaseTypeConstraint TerminalScrollbackLinesPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalScrollbackLinesPropertyInfo = * ~ Word32

type AttrAllowedOps TerminalScrollbackLinesPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructTerminalScrollbackLines :: Word32 -> IO ([Char], GValue)

getTerminalScrollbackLines :: (MonadIO m, TerminalK o) => o -> m Word32

setTerminalScrollbackLines :: (MonadIO m, TerminalK o) => o -> Word32 -> m ()

terminalScrollbackLines :: AttrLabelProxy "scrollbackLines"

WindowTitle

data TerminalWindowTitlePropertyInfo

Instances

AttrInfo TerminalWindowTitlePropertyInfo

type AttrLabel TerminalWindowTitlePropertyInfo = "window-title"

type AttrGetType TerminalWindowTitlePropertyInfo = Text

type AttrBaseTypeConstraint TerminalWindowTitlePropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalWindowTitlePropertyInfo = * ~ ()

type AttrAllowedOps TerminalWindowTitlePropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getTerminalWindowTitle :: (MonadIO m, TerminalK o) => o -> m Text

terminalWindowTitle :: AttrLabelProxy "windowTitle"

WordCharExceptions

data TerminalWordCharExceptionsPropertyInfo

Instances

AttrInfo TerminalWordCharExceptionsPropertyInfo

type AttrLabel TerminalWordCharExceptionsPropertyInfo = "word-char-exceptions"

type AttrGetType TerminalWordCharExceptionsPropertyInfo = Text

type AttrBaseTypeConstraint TerminalWordCharExceptionsPropertyInfo = TerminalK

type AttrSetTypeConstraint TerminalWordCharExceptionsPropertyInfo = * ~ ()

type AttrAllowedOps TerminalWordCharExceptionsPropertyInfo = (:) AttrOpTag AttrGet ([] AttrOpTag)

getTerminalWordCharExceptions :: (MonadIO m, TerminalK o) => o -> m Text

terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"

Signals

Bell

type TerminalBellCallback = IO ()

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

data TerminalBellSignalInfo

Instances

SignalInfo TerminalBellSignalInfo

type HaskellCallbackType TerminalBellSignalInfo = TerminalBellCallback

afterTerminalBell :: (GObject a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId

mkTerminalBellCallback :: TerminalBellCallbackC -> IO (FunPtr TerminalBellCallbackC)

noTerminalBellCallback :: Maybe TerminalBellCallback

onTerminalBell :: (GObject a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId

terminalBellCallbackWrapper :: TerminalBellCallback -> Ptr () -> Ptr () -> IO ()

terminalBellClosure :: TerminalBellCallback -> IO Closure

CharSizeChanged

type TerminalCharSizeChangedCallback = Word32 -> Word32 -> IO ()

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

data TerminalCharSizeChangedSignalInfo

Instances

SignalInfo TerminalCharSizeChangedSignalInfo

type HaskellCallbackType TerminalCharSizeChangedSignalInfo = TerminalCharSizeChangedCallback

afterTerminalCharSizeChanged :: (GObject a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId

mkTerminalCharSizeChangedCallback :: TerminalCharSizeChangedCallbackC -> IO (FunPtr TerminalCharSizeChangedCallbackC)

noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback

onTerminalCharSizeChanged :: (GObject a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId

terminalCharSizeChangedCallbackWrapper :: TerminalCharSizeChangedCallback -> Ptr () -> Word32 -> Word32 -> Ptr () -> IO ()

terminalCharSizeChangedClosure :: TerminalCharSizeChangedCallback -> IO Closure

ChildExited

type TerminalChildExitedCallback = Int32 -> IO ()

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

data TerminalChildExitedSignalInfo

Instances

SignalInfo TerminalChildExitedSignalInfo

type HaskellCallbackType TerminalChildExitedSignalInfo = TerminalChildExitedCallback

afterTerminalChildExited :: (GObject a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId

mkTerminalChildExitedCallback :: TerminalChildExitedCallbackC -> IO (FunPtr TerminalChildExitedCallbackC)

noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback

onTerminalChildExited :: (GObject a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId

terminalChildExitedCallbackWrapper :: TerminalChildExitedCallback -> Ptr () -> Int32 -> Ptr () -> IO ()

terminalChildExitedClosure :: TerminalChildExitedCallback -> IO Closure

Commit

type TerminalCommitCallback = Text -> Word32 -> IO ()

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

data TerminalCommitSignalInfo

Instances

SignalInfo TerminalCommitSignalInfo

type HaskellCallbackType TerminalCommitSignalInfo = TerminalCommitCallback

afterTerminalCommit :: (GObject a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId

mkTerminalCommitCallback :: TerminalCommitCallbackC -> IO (FunPtr TerminalCommitCallbackC)

noTerminalCommitCallback :: Maybe TerminalCommitCallback

onTerminalCommit :: (GObject a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId

terminalCommitCallbackWrapper :: TerminalCommitCallback -> Ptr () -> CString -> Word32 -> Ptr () -> IO ()

terminalCommitClosure :: TerminalCommitCallback -> IO Closure

ContentsChanged

type TerminalContentsChangedCallback = IO ()

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

data TerminalContentsChangedSignalInfo

Instances

SignalInfo TerminalContentsChangedSignalInfo

type HaskellCallbackType TerminalContentsChangedSignalInfo = TerminalContentsChangedCallback

afterTerminalContentsChanged :: (GObject a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId

mkTerminalContentsChangedCallback :: TerminalContentsChangedCallbackC -> IO (FunPtr TerminalContentsChangedCallbackC)

noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback

onTerminalContentsChanged :: (GObject a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId

terminalContentsChangedCallbackWrapper :: TerminalContentsChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalContentsChangedClosure :: TerminalContentsChangedCallback -> IO Closure

CopyClipboard

type TerminalCopyClipboardCallback = IO ()

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

data TerminalCopyClipboardSignalInfo

Instances

SignalInfo TerminalCopyClipboardSignalInfo

type HaskellCallbackType TerminalCopyClipboardSignalInfo = TerminalCopyClipboardCallback

afterTerminalCopyClipboard :: (GObject a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId

mkTerminalCopyClipboardCallback :: TerminalCopyClipboardCallbackC -> IO (FunPtr TerminalCopyClipboardCallbackC)

noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback

onTerminalCopyClipboard :: (GObject a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId

terminalCopyClipboardCallbackWrapper :: TerminalCopyClipboardCallback -> Ptr () -> Ptr () -> IO ()

terminalCopyClipboardClosure :: TerminalCopyClipboardCallback -> IO Closure

CurrentDirectoryUriChanged

type TerminalCurrentDirectoryUriChangedCallback = IO ()

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

data TerminalCurrentDirectoryUriChangedSignalInfo

Instances

SignalInfo TerminalCurrentDirectoryUriChangedSignalInfo

type HaskellCallbackType TerminalCurrentDirectoryUriChangedSignalInfo = TerminalCurrentDirectoryUriChangedCallback

afterTerminalCurrentDirectoryUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId

mkTerminalCurrentDirectoryUriChangedCallback :: TerminalCurrentDirectoryUriChangedCallbackC -> IO (FunPtr TerminalCurrentDirectoryUriChangedCallbackC)

noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback

onTerminalCurrentDirectoryUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId

terminalCurrentDirectoryUriChangedCallbackWrapper :: TerminalCurrentDirectoryUriChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalCurrentDirectoryUriChangedClosure :: TerminalCurrentDirectoryUriChangedCallback -> IO Closure

CurrentFileUriChanged

type TerminalCurrentFileUriChangedCallback = IO ()

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

data TerminalCurrentFileUriChangedSignalInfo

Instances

SignalInfo TerminalCurrentFileUriChangedSignalInfo

type HaskellCallbackType TerminalCurrentFileUriChangedSignalInfo = TerminalCurrentFileUriChangedCallback

afterTerminalCurrentFileUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId

mkTerminalCurrentFileUriChangedCallback :: TerminalCurrentFileUriChangedCallbackC -> IO (FunPtr TerminalCurrentFileUriChangedCallbackC)

noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback

onTerminalCurrentFileUriChanged :: (GObject a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId

terminalCurrentFileUriChangedCallbackWrapper :: TerminalCurrentFileUriChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalCurrentFileUriChangedClosure :: TerminalCurrentFileUriChangedCallback -> IO Closure

CursorMoved

type TerminalCursorMovedCallback = IO ()

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

data TerminalCursorMovedSignalInfo

Instances

SignalInfo TerminalCursorMovedSignalInfo

type HaskellCallbackType TerminalCursorMovedSignalInfo = TerminalCursorMovedCallback

afterTerminalCursorMoved :: (GObject a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId

mkTerminalCursorMovedCallback :: TerminalCursorMovedCallbackC -> IO (FunPtr TerminalCursorMovedCallbackC)

noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback

onTerminalCursorMoved :: (GObject a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId

terminalCursorMovedCallbackWrapper :: TerminalCursorMovedCallback -> Ptr () -> Ptr () -> IO ()

terminalCursorMovedClosure :: TerminalCursorMovedCallback -> IO Closure

DecreaseFontSize

type TerminalDecreaseFontSizeCallback = IO ()

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

data TerminalDecreaseFontSizeSignalInfo

Instances

SignalInfo TerminalDecreaseFontSizeSignalInfo

type HaskellCallbackType TerminalDecreaseFontSizeSignalInfo = TerminalDecreaseFontSizeCallback

afterTerminalDecreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId

mkTerminalDecreaseFontSizeCallback :: TerminalDecreaseFontSizeCallbackC -> IO (FunPtr TerminalDecreaseFontSizeCallbackC)

noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback

onTerminalDecreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId

terminalDecreaseFontSizeCallbackWrapper :: TerminalDecreaseFontSizeCallback -> Ptr () -> Ptr () -> IO ()

terminalDecreaseFontSizeClosure :: TerminalDecreaseFontSizeCallback -> IO Closure

DeiconifyWindow

type TerminalDeiconifyWindowCallback = IO ()

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

data TerminalDeiconifyWindowSignalInfo

Instances

SignalInfo TerminalDeiconifyWindowSignalInfo

type HaskellCallbackType TerminalDeiconifyWindowSignalInfo = TerminalDeiconifyWindowCallback

afterTerminalDeiconifyWindow :: (GObject a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId

mkTerminalDeiconifyWindowCallback :: TerminalDeiconifyWindowCallbackC -> IO (FunPtr TerminalDeiconifyWindowCallbackC)

noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback

onTerminalDeiconifyWindow :: (GObject a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId

terminalDeiconifyWindowCallbackWrapper :: TerminalDeiconifyWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalDeiconifyWindowClosure :: TerminalDeiconifyWindowCallback -> IO Closure

EncodingChanged

type TerminalEncodingChangedCallback = IO ()

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

data TerminalEncodingChangedSignalInfo

Instances

SignalInfo TerminalEncodingChangedSignalInfo

type HaskellCallbackType TerminalEncodingChangedSignalInfo = TerminalEncodingChangedCallback

afterTerminalEncodingChanged :: (GObject a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId

mkTerminalEncodingChangedCallback :: TerminalEncodingChangedCallbackC -> IO (FunPtr TerminalEncodingChangedCallbackC)

noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback

onTerminalEncodingChanged :: (GObject a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId

terminalEncodingChangedCallbackWrapper :: TerminalEncodingChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalEncodingChangedClosure :: TerminalEncodingChangedCallback -> IO Closure

Eof

type TerminalEofCallback = IO ()

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

data TerminalEofSignalInfo

Instances

SignalInfo TerminalEofSignalInfo

type HaskellCallbackType TerminalEofSignalInfo = TerminalEofCallback

afterTerminalEof :: (GObject a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId

mkTerminalEofCallback :: TerminalEofCallbackC -> IO (FunPtr TerminalEofCallbackC)

noTerminalEofCallback :: Maybe TerminalEofCallback

onTerminalEof :: (GObject a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId

terminalEofCallbackWrapper :: TerminalEofCallback -> Ptr () -> Ptr () -> IO ()

terminalEofClosure :: TerminalEofCallback -> IO Closure

IconTitleChanged

type TerminalIconTitleChangedCallback = IO ()

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

data TerminalIconTitleChangedSignalInfo

Instances

SignalInfo TerminalIconTitleChangedSignalInfo

type HaskellCallbackType TerminalIconTitleChangedSignalInfo = TerminalIconTitleChangedCallback

afterTerminalIconTitleChanged :: (GObject a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId

mkTerminalIconTitleChangedCallback :: TerminalIconTitleChangedCallbackC -> IO (FunPtr TerminalIconTitleChangedCallbackC)

noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback

onTerminalIconTitleChanged :: (GObject a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId

terminalIconTitleChangedCallbackWrapper :: TerminalIconTitleChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalIconTitleChangedClosure :: TerminalIconTitleChangedCallback -> IO Closure

IconifyWindow

type TerminalIconifyWindowCallback = IO ()

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

data TerminalIconifyWindowSignalInfo

Instances

SignalInfo TerminalIconifyWindowSignalInfo

type HaskellCallbackType TerminalIconifyWindowSignalInfo = TerminalIconifyWindowCallback

afterTerminalIconifyWindow :: (GObject a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId

mkTerminalIconifyWindowCallback :: TerminalIconifyWindowCallbackC -> IO (FunPtr TerminalIconifyWindowCallbackC)

noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback

onTerminalIconifyWindow :: (GObject a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId

terminalIconifyWindowCallbackWrapper :: TerminalIconifyWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalIconifyWindowClosure :: TerminalIconifyWindowCallback -> IO Closure

IncreaseFontSize

type TerminalIncreaseFontSizeCallback = IO ()

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

data TerminalIncreaseFontSizeSignalInfo

Instances

SignalInfo TerminalIncreaseFontSizeSignalInfo

type HaskellCallbackType TerminalIncreaseFontSizeSignalInfo = TerminalIncreaseFontSizeCallback

afterTerminalIncreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId

mkTerminalIncreaseFontSizeCallback :: TerminalIncreaseFontSizeCallbackC -> IO (FunPtr TerminalIncreaseFontSizeCallbackC)

noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback

onTerminalIncreaseFontSize :: (GObject a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId

terminalIncreaseFontSizeCallbackWrapper :: TerminalIncreaseFontSizeCallback -> Ptr () -> Ptr () -> IO ()

terminalIncreaseFontSizeClosure :: TerminalIncreaseFontSizeCallback -> IO Closure

LowerWindow

type TerminalLowerWindowCallback = IO ()

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

data TerminalLowerWindowSignalInfo

Instances

SignalInfo TerminalLowerWindowSignalInfo

type HaskellCallbackType TerminalLowerWindowSignalInfo = TerminalLowerWindowCallback

afterTerminalLowerWindow :: (GObject a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId

mkTerminalLowerWindowCallback :: TerminalLowerWindowCallbackC -> IO (FunPtr TerminalLowerWindowCallbackC)

noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback

onTerminalLowerWindow :: (GObject a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId

terminalLowerWindowCallbackWrapper :: TerminalLowerWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalLowerWindowClosure :: TerminalLowerWindowCallback -> IO Closure

MaximizeWindow

type TerminalMaximizeWindowCallback = IO ()

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

data TerminalMaximizeWindowSignalInfo

Instances

SignalInfo TerminalMaximizeWindowSignalInfo

type HaskellCallbackType TerminalMaximizeWindowSignalInfo = TerminalMaximizeWindowCallback

afterTerminalMaximizeWindow :: (GObject a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId

mkTerminalMaximizeWindowCallback :: TerminalMaximizeWindowCallbackC -> IO (FunPtr TerminalMaximizeWindowCallbackC)

noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback

onTerminalMaximizeWindow :: (GObject a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId

terminalMaximizeWindowCallbackWrapper :: TerminalMaximizeWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalMaximizeWindowClosure :: TerminalMaximizeWindowCallback -> IO Closure

MoveWindow

type TerminalMoveWindowCallback = Word32 -> Word32 -> IO ()

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

data TerminalMoveWindowSignalInfo

Instances

SignalInfo TerminalMoveWindowSignalInfo

type HaskellCallbackType TerminalMoveWindowSignalInfo = TerminalMoveWindowCallback

afterTerminalMoveWindow :: (GObject a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId

mkTerminalMoveWindowCallback :: TerminalMoveWindowCallbackC -> IO (FunPtr TerminalMoveWindowCallbackC)

noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback

onTerminalMoveWindow :: (GObject a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId

terminalMoveWindowCallbackWrapper :: TerminalMoveWindowCallback -> Ptr () -> Word32 -> Word32 -> Ptr () -> IO ()

terminalMoveWindowClosure :: TerminalMoveWindowCallback -> IO Closure

NotificationReceived

type TerminalNotificationReceivedCallback = Text -> Maybe Text -> IO ()

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

data TerminalNotificationReceivedSignalInfo

Instances

SignalInfo TerminalNotificationReceivedSignalInfo

type HaskellCallbackType TerminalNotificationReceivedSignalInfo = TerminalNotificationReceivedCallback

afterTerminalNotificationReceived :: (GObject a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId

mkTerminalNotificationReceivedCallback :: TerminalNotificationReceivedCallbackC -> IO (FunPtr TerminalNotificationReceivedCallbackC)

noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback

onTerminalNotificationReceived :: (GObject a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId

terminalNotificationReceivedCallbackWrapper :: TerminalNotificationReceivedCallback -> Ptr () -> CString -> CString -> Ptr () -> IO ()

terminalNotificationReceivedClosure :: TerminalNotificationReceivedCallback -> IO Closure

PasteClipboard

type TerminalPasteClipboardCallback = IO ()

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

data TerminalPasteClipboardSignalInfo

Instances

SignalInfo TerminalPasteClipboardSignalInfo

type HaskellCallbackType TerminalPasteClipboardSignalInfo = TerminalPasteClipboardCallback

afterTerminalPasteClipboard :: (GObject a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId

mkTerminalPasteClipboardCallback :: TerminalPasteClipboardCallbackC -> IO (FunPtr TerminalPasteClipboardCallbackC)

noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback

onTerminalPasteClipboard :: (GObject a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId

terminalPasteClipboardCallbackWrapper :: TerminalPasteClipboardCallback -> Ptr () -> Ptr () -> IO ()

terminalPasteClipboardClosure :: TerminalPasteClipboardCallback -> IO Closure

RaiseWindow

type TerminalRaiseWindowCallback = IO ()

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

data TerminalRaiseWindowSignalInfo

Instances

SignalInfo TerminalRaiseWindowSignalInfo

type HaskellCallbackType TerminalRaiseWindowSignalInfo = TerminalRaiseWindowCallback

afterTerminalRaiseWindow :: (GObject a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId

mkTerminalRaiseWindowCallback :: TerminalRaiseWindowCallbackC -> IO (FunPtr TerminalRaiseWindowCallbackC)

noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback

onTerminalRaiseWindow :: (GObject a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId

terminalRaiseWindowCallbackWrapper :: TerminalRaiseWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalRaiseWindowClosure :: TerminalRaiseWindowCallback -> IO Closure

RefreshWindow

type TerminalRefreshWindowCallback = IO ()

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

data TerminalRefreshWindowSignalInfo

Instances

SignalInfo TerminalRefreshWindowSignalInfo

type HaskellCallbackType TerminalRefreshWindowSignalInfo = TerminalRefreshWindowCallback

afterTerminalRefreshWindow :: (GObject a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId

mkTerminalRefreshWindowCallback :: TerminalRefreshWindowCallbackC -> IO (FunPtr TerminalRefreshWindowCallbackC)

noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback

onTerminalRefreshWindow :: (GObject a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId

terminalRefreshWindowCallbackWrapper :: TerminalRefreshWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalRefreshWindowClosure :: TerminalRefreshWindowCallback -> IO Closure

ResizeWindow

type TerminalResizeWindowCallback = Word32 -> Word32 -> IO ()

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

data TerminalResizeWindowSignalInfo

Instances

SignalInfo TerminalResizeWindowSignalInfo

type HaskellCallbackType TerminalResizeWindowSignalInfo = TerminalResizeWindowCallback

afterTerminalResizeWindow :: (GObject a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId

mkTerminalResizeWindowCallback :: TerminalResizeWindowCallbackC -> IO (FunPtr TerminalResizeWindowCallbackC)

noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback

onTerminalResizeWindow :: (GObject a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId

terminalResizeWindowCallbackWrapper :: TerminalResizeWindowCallback -> Ptr () -> Word32 -> Word32 -> Ptr () -> IO ()

terminalResizeWindowClosure :: TerminalResizeWindowCallback -> IO Closure

RestoreWindow

type TerminalRestoreWindowCallback = IO ()

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

data TerminalRestoreWindowSignalInfo

Instances

SignalInfo TerminalRestoreWindowSignalInfo

type HaskellCallbackType TerminalRestoreWindowSignalInfo = TerminalRestoreWindowCallback

afterTerminalRestoreWindow :: (GObject a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId

mkTerminalRestoreWindowCallback :: TerminalRestoreWindowCallbackC -> IO (FunPtr TerminalRestoreWindowCallbackC)

noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback

onTerminalRestoreWindow :: (GObject a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId

terminalRestoreWindowCallbackWrapper :: TerminalRestoreWindowCallback -> Ptr () -> Ptr () -> IO ()

terminalRestoreWindowClosure :: TerminalRestoreWindowCallback -> IO Closure

SelectionChanged

type TerminalSelectionChangedCallback = IO ()

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

data TerminalSelectionChangedSignalInfo

Instances

SignalInfo TerminalSelectionChangedSignalInfo

type HaskellCallbackType TerminalSelectionChangedSignalInfo = TerminalSelectionChangedCallback

afterTerminalSelectionChanged :: (GObject a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId

mkTerminalSelectionChangedCallback :: TerminalSelectionChangedCallbackC -> IO (FunPtr TerminalSelectionChangedCallbackC)

noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback

onTerminalSelectionChanged :: (GObject a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId

terminalSelectionChangedCallbackWrapper :: TerminalSelectionChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalSelectionChangedClosure :: TerminalSelectionChangedCallback -> IO Closure

TextDeleted

type TerminalTextDeletedCallback = IO ()

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

data TerminalTextDeletedSignalInfo

Instances

SignalInfo TerminalTextDeletedSignalInfo

type HaskellCallbackType TerminalTextDeletedSignalInfo = TerminalTextDeletedCallback

afterTerminalTextDeleted :: (GObject a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId

mkTerminalTextDeletedCallback :: TerminalTextDeletedCallbackC -> IO (FunPtr TerminalTextDeletedCallbackC)

noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback

onTerminalTextDeleted :: (GObject a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId

terminalTextDeletedCallbackWrapper :: TerminalTextDeletedCallback -> Ptr () -> Ptr () -> IO ()

terminalTextDeletedClosure :: TerminalTextDeletedCallback -> IO Closure

TextInserted

type TerminalTextInsertedCallback = IO ()

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

data TerminalTextInsertedSignalInfo

Instances

SignalInfo TerminalTextInsertedSignalInfo

type HaskellCallbackType TerminalTextInsertedSignalInfo = TerminalTextInsertedCallback

afterTerminalTextInserted :: (GObject a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId

mkTerminalTextInsertedCallback :: TerminalTextInsertedCallbackC -> IO (FunPtr TerminalTextInsertedCallbackC)

noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback

onTerminalTextInserted :: (GObject a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId

terminalTextInsertedCallbackWrapper :: TerminalTextInsertedCallback -> Ptr () -> Ptr () -> IO ()

terminalTextInsertedClosure :: TerminalTextInsertedCallback -> IO Closure

TextModified

type TerminalTextModifiedCallback = IO ()

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

data TerminalTextModifiedSignalInfo

Instances

SignalInfo TerminalTextModifiedSignalInfo

type HaskellCallbackType TerminalTextModifiedSignalInfo = TerminalTextModifiedCallback

afterTerminalTextModified :: (GObject a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId

mkTerminalTextModifiedCallback :: TerminalTextModifiedCallbackC -> IO (FunPtr TerminalTextModifiedCallbackC)

noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback

onTerminalTextModified :: (GObject a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId

terminalTextModifiedCallbackWrapper :: TerminalTextModifiedCallback -> Ptr () -> Ptr () -> IO ()

terminalTextModifiedClosure :: TerminalTextModifiedCallback -> IO Closure

TextScrolled

type TerminalTextScrolledCallback = Int32 -> IO ()

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

data TerminalTextScrolledSignalInfo

Instances

SignalInfo TerminalTextScrolledSignalInfo

type HaskellCallbackType TerminalTextScrolledSignalInfo = TerminalTextScrolledCallback

afterTerminalTextScrolled :: (GObject a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId

mkTerminalTextScrolledCallback :: TerminalTextScrolledCallbackC -> IO (FunPtr TerminalTextScrolledCallbackC)

noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback

onTerminalTextScrolled :: (GObject a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId

terminalTextScrolledCallbackWrapper :: TerminalTextScrolledCallback -> Ptr () -> Int32 -> Ptr () -> IO ()

terminalTextScrolledClosure :: TerminalTextScrolledCallback -> IO Closure

WindowTitleChanged

type TerminalWindowTitleChangedCallback = IO ()

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

data TerminalWindowTitleChangedSignalInfo

Instances

SignalInfo TerminalWindowTitleChangedSignalInfo

type HaskellCallbackType TerminalWindowTitleChangedSignalInfo = TerminalWindowTitleChangedCallback

afterTerminalWindowTitleChanged :: (GObject a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId

mkTerminalWindowTitleChangedCallback :: TerminalWindowTitleChangedCallbackC -> IO (FunPtr TerminalWindowTitleChangedCallbackC)

noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback

onTerminalWindowTitleChanged :: (GObject a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId

terminalWindowTitleChangedCallbackWrapper :: TerminalWindowTitleChangedCallback -> Ptr () -> Ptr () -> IO ()

terminalWindowTitleChangedClosure :: TerminalWindowTitleChangedCallback -> IO Closure