{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Vte.Objects.Terminal
    ( 
#if defined(ENABLE_OVERLOADING)
    TerminalGetTextMethodInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    TerminalGetTextIncludeTrailingSpacesMethodInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    TerminalGetTextRangeMethodInfo          ,
#endif

-- * Exported types
    Terminal(..)                            ,
    IsTerminal                              ,
    toTerminal                              ,
    noTerminal                              ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveTerminalMethod                   ,
#endif


-- ** copyClipboard #method:copyClipboard#

#if defined(ENABLE_OVERLOADING)
    TerminalCopyClipboardMethodInfo         ,
#endif
    terminalCopyClipboard                   ,


-- ** copyClipboardFormat #method:copyClipboardFormat#

#if defined(ENABLE_OVERLOADING)
    TerminalCopyClipboardFormatMethodInfo   ,
#endif
    terminalCopyClipboardFormat             ,


-- ** copyPrimary #method:copyPrimary#

#if defined(ENABLE_OVERLOADING)
    TerminalCopyPrimaryMethodInfo           ,
#endif
    terminalCopyPrimary                     ,


-- ** feed #method:feed#

#if defined(ENABLE_OVERLOADING)
    TerminalFeedMethodInfo                  ,
#endif
    terminalFeed                            ,


-- ** feedChild #method:feedChild#

#if defined(ENABLE_OVERLOADING)
    TerminalFeedChildMethodInfo             ,
#endif
    terminalFeedChild                       ,


-- ** feedChildBinary #method:feedChildBinary#

#if defined(ENABLE_OVERLOADING)
    TerminalFeedChildBinaryMethodInfo       ,
#endif
    terminalFeedChildBinary                 ,


-- ** getAllowBold #method:getAllowBold#

#if defined(ENABLE_OVERLOADING)
    TerminalGetAllowBoldMethodInfo          ,
#endif
    terminalGetAllowBold                    ,


-- ** getAllowHyperlink #method:getAllowHyperlink#

#if defined(ENABLE_OVERLOADING)
    TerminalGetAllowHyperlinkMethodInfo     ,
#endif
    terminalGetAllowHyperlink               ,


-- ** getAudibleBell #method:getAudibleBell#

#if defined(ENABLE_OVERLOADING)
    TerminalGetAudibleBellMethodInfo        ,
#endif
    terminalGetAudibleBell                  ,


-- ** getBoldIsBright #method:getBoldIsBright#

#if defined(ENABLE_OVERLOADING)
    TerminalGetBoldIsBrightMethodInfo       ,
#endif
    terminalGetBoldIsBright                 ,


-- ** getCellHeightScale #method:getCellHeightScale#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCellHeightScaleMethodInfo    ,
#endif
    terminalGetCellHeightScale              ,


-- ** getCellWidthScale #method:getCellWidthScale#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCellWidthScaleMethodInfo     ,
#endif
    terminalGetCellWidthScale               ,


-- ** getCharHeight #method:getCharHeight#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCharHeightMethodInfo         ,
#endif
    terminalGetCharHeight                   ,


-- ** getCharWidth #method:getCharWidth#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCharWidthMethodInfo          ,
#endif
    terminalGetCharWidth                    ,


-- ** getCjkAmbiguousWidth #method:getCjkAmbiguousWidth#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCjkAmbiguousWidthMethodInfo  ,
#endif
    terminalGetCjkAmbiguousWidth            ,


-- ** getColorBackgroundForDraw #method:getColorBackgroundForDraw#

#if defined(ENABLE_OVERLOADING)
    TerminalGetColorBackgroundForDrawMethodInfo,
#endif
    terminalGetColorBackgroundForDraw       ,


-- ** getColumnCount #method:getColumnCount#

#if defined(ENABLE_OVERLOADING)
    TerminalGetColumnCountMethodInfo        ,
#endif
    terminalGetColumnCount                  ,


-- ** getCurrentContainerName #method:getCurrentContainerName#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCurrentContainerNameMethodInfo,
#endif
    terminalGetCurrentContainerName         ,


-- ** getCurrentContainerRuntime #method:getCurrentContainerRuntime#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCurrentContainerRuntimeMethodInfo,
#endif
    terminalGetCurrentContainerRuntime      ,


-- ** getCurrentDirectoryUri #method:getCurrentDirectoryUri#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCurrentDirectoryUriMethodInfo,
#endif
    terminalGetCurrentDirectoryUri          ,


-- ** getCurrentFileUri #method:getCurrentFileUri#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCurrentFileUriMethodInfo     ,
#endif
    terminalGetCurrentFileUri               ,


-- ** getCursorBlinkMode #method:getCursorBlinkMode#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCursorBlinkModeMethodInfo    ,
#endif
    terminalGetCursorBlinkMode              ,


-- ** getCursorPosition #method:getCursorPosition#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCursorPositionMethodInfo     ,
#endif
    terminalGetCursorPosition               ,


-- ** getCursorShape #method:getCursorShape#

#if defined(ENABLE_OVERLOADING)
    TerminalGetCursorShapeMethodInfo        ,
#endif
    terminalGetCursorShape                  ,


-- ** getEncoding #method:getEncoding#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEncodingMethodInfo           ,
#endif
    terminalGetEncoding                     ,


-- ** getFont #method:getFont#

#if defined(ENABLE_OVERLOADING)
    TerminalGetFontMethodInfo               ,
#endif
    terminalGetFont                         ,


-- ** getFontScale #method:getFontScale#

#if defined(ENABLE_OVERLOADING)
    TerminalGetFontScaleMethodInfo          ,
#endif
    terminalGetFontScale                    ,


-- ** getGeometryHints #method:getGeometryHints#

#if defined(ENABLE_OVERLOADING)
    TerminalGetGeometryHintsMethodInfo      ,
#endif
    terminalGetGeometryHints                ,


-- ** getHasSelection #method:getHasSelection#

#if defined(ENABLE_OVERLOADING)
    TerminalGetHasSelectionMethodInfo       ,
#endif
    terminalGetHasSelection                 ,


-- ** getIconTitle #method:getIconTitle#

#if defined(ENABLE_OVERLOADING)
    TerminalGetIconTitleMethodInfo          ,
#endif
    terminalGetIconTitle                    ,


-- ** getInputEnabled #method:getInputEnabled#

#if defined(ENABLE_OVERLOADING)
    TerminalGetInputEnabledMethodInfo       ,
#endif
    terminalGetInputEnabled                 ,


-- ** getMouseAutohide #method:getMouseAutohide#

#if defined(ENABLE_OVERLOADING)
    TerminalGetMouseAutohideMethodInfo      ,
#endif
    terminalGetMouseAutohide                ,


-- ** getPty #method:getPty#

#if defined(ENABLE_OVERLOADING)
    TerminalGetPtyMethodInfo                ,
#endif
    terminalGetPty                          ,


-- ** getRewrapOnResize #method:getRewrapOnResize#

#if defined(ENABLE_OVERLOADING)
    TerminalGetRewrapOnResizeMethodInfo     ,
#endif
    terminalGetRewrapOnResize               ,


-- ** getRowCount #method:getRowCount#

#if defined(ENABLE_OVERLOADING)
    TerminalGetRowCountMethodInfo           ,
#endif
    terminalGetRowCount                     ,


-- ** getScrollOnKeystroke #method:getScrollOnKeystroke#

#if defined(ENABLE_OVERLOADING)
    TerminalGetScrollOnKeystrokeMethodInfo  ,
#endif
    terminalGetScrollOnKeystroke            ,


-- ** getScrollOnOutput #method:getScrollOnOutput#

#if defined(ENABLE_OVERLOADING)
    TerminalGetScrollOnOutputMethodInfo     ,
#endif
    terminalGetScrollOnOutput               ,


-- ** getScrollbackLines #method:getScrollbackLines#

#if defined(ENABLE_OVERLOADING)
    TerminalGetScrollbackLinesMethodInfo    ,
#endif
    terminalGetScrollbackLines              ,


-- ** getTextBlinkMode #method:getTextBlinkMode#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextBlinkModeMethodInfo      ,
#endif
    terminalGetTextBlinkMode                ,


-- ** getWindowTitle #method:getWindowTitle#

#if defined(ENABLE_OVERLOADING)
    TerminalGetWindowTitleMethodInfo        ,
#endif
    terminalGetWindowTitle                  ,


-- ** getWordCharExceptions #method:getWordCharExceptions#

#if defined(ENABLE_OVERLOADING)
    TerminalGetWordCharExceptionsMethodInfo ,
#endif
    terminalGetWordCharExceptions           ,


-- ** hyperlinkCheckEvent #method:hyperlinkCheckEvent#

#if defined(ENABLE_OVERLOADING)
    TerminalHyperlinkCheckEventMethodInfo   ,
#endif
    terminalHyperlinkCheckEvent             ,


-- ** matchAddGregex #method:matchAddGregex#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchAddGregexMethodInfo        ,
#endif
    terminalMatchAddGregex                  ,


-- ** matchAddRegex #method:matchAddRegex#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchAddRegexMethodInfo         ,
#endif
    terminalMatchAddRegex                   ,


-- ** matchCheck #method:matchCheck#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchCheckMethodInfo            ,
#endif
    terminalMatchCheck                      ,


-- ** matchCheckEvent #method:matchCheckEvent#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchCheckEventMethodInfo       ,
#endif
    terminalMatchCheckEvent                 ,


-- ** matchRemove #method:matchRemove#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchRemoveMethodInfo           ,
#endif
    terminalMatchRemove                     ,


-- ** matchRemoveAll #method:matchRemoveAll#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchRemoveAllMethodInfo        ,
#endif
    terminalMatchRemoveAll                  ,


-- ** matchSetCursor #method:matchSetCursor#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchSetCursorMethodInfo        ,
#endif
    terminalMatchSetCursor                  ,


-- ** matchSetCursorName #method:matchSetCursorName#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchSetCursorNameMethodInfo    ,
#endif
    terminalMatchSetCursorName              ,


-- ** matchSetCursorType #method:matchSetCursorType#

#if defined(ENABLE_OVERLOADING)
    TerminalMatchSetCursorTypeMethodInfo    ,
#endif
    terminalMatchSetCursorType              ,


-- ** new #method:new#

    terminalNew                             ,


-- ** pasteClipboard #method:pasteClipboard#

#if defined(ENABLE_OVERLOADING)
    TerminalPasteClipboardMethodInfo        ,
#endif
    terminalPasteClipboard                  ,


-- ** pastePrimary #method:pastePrimary#

#if defined(ENABLE_OVERLOADING)
    TerminalPastePrimaryMethodInfo          ,
#endif
    terminalPastePrimary                    ,


-- ** ptyNewSync #method:ptyNewSync#

#if defined(ENABLE_OVERLOADING)
    TerminalPtyNewSyncMethodInfo            ,
#endif
    terminalPtyNewSync                      ,


-- ** reset #method:reset#

#if defined(ENABLE_OVERLOADING)
    TerminalResetMethodInfo                 ,
#endif
    terminalReset                           ,


-- ** searchFindNext #method:searchFindNext#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchFindNextMethodInfo        ,
#endif
    terminalSearchFindNext                  ,


-- ** searchFindPrevious #method:searchFindPrevious#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchFindPreviousMethodInfo    ,
#endif
    terminalSearchFindPrevious              ,


-- ** searchGetGregex #method:searchGetGregex#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchGetGregexMethodInfo       ,
#endif
    terminalSearchGetGregex                 ,


-- ** searchGetRegex #method:searchGetRegex#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchGetRegexMethodInfo        ,
#endif
    terminalSearchGetRegex                  ,


-- ** searchGetWrapAround #method:searchGetWrapAround#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchGetWrapAroundMethodInfo   ,
#endif
    terminalSearchGetWrapAround             ,


-- ** searchSetGregex #method:searchSetGregex#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchSetGregexMethodInfo       ,
#endif
    terminalSearchSetGregex                 ,


-- ** searchSetRegex #method:searchSetRegex#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchSetRegexMethodInfo        ,
#endif
    terminalSearchSetRegex                  ,


-- ** searchSetWrapAround #method:searchSetWrapAround#

#if defined(ENABLE_OVERLOADING)
    TerminalSearchSetWrapAroundMethodInfo   ,
#endif
    terminalSearchSetWrapAround             ,


-- ** selectAll #method:selectAll#

#if defined(ENABLE_OVERLOADING)
    TerminalSelectAllMethodInfo             ,
#endif
    terminalSelectAll                       ,


-- ** setAllowBold #method:setAllowBold#

#if defined(ENABLE_OVERLOADING)
    TerminalSetAllowBoldMethodInfo          ,
#endif
    terminalSetAllowBold                    ,


-- ** setAllowHyperlink #method:setAllowHyperlink#

#if defined(ENABLE_OVERLOADING)
    TerminalSetAllowHyperlinkMethodInfo     ,
#endif
    terminalSetAllowHyperlink               ,


-- ** setAudibleBell #method:setAudibleBell#

#if defined(ENABLE_OVERLOADING)
    TerminalSetAudibleBellMethodInfo        ,
#endif
    terminalSetAudibleBell                  ,


-- ** setBackspaceBinding #method:setBackspaceBinding#

#if defined(ENABLE_OVERLOADING)
    TerminalSetBackspaceBindingMethodInfo   ,
#endif
    terminalSetBackspaceBinding             ,


-- ** setBoldIsBright #method:setBoldIsBright#

#if defined(ENABLE_OVERLOADING)
    TerminalSetBoldIsBrightMethodInfo       ,
#endif
    terminalSetBoldIsBright                 ,


-- ** setCellHeightScale #method:setCellHeightScale#

#if defined(ENABLE_OVERLOADING)
    TerminalSetCellHeightScaleMethodInfo    ,
#endif
    terminalSetCellHeightScale              ,


-- ** setCellWidthScale #method:setCellWidthScale#

#if defined(ENABLE_OVERLOADING)
    TerminalSetCellWidthScaleMethodInfo     ,
#endif
    terminalSetCellWidthScale               ,


-- ** setCjkAmbiguousWidth #method:setCjkAmbiguousWidth#

#if defined(ENABLE_OVERLOADING)
    TerminalSetCjkAmbiguousWidthMethodInfo  ,
#endif
    terminalSetCjkAmbiguousWidth            ,


-- ** setClearBackground #method:setClearBackground#

#if defined(ENABLE_OVERLOADING)
    TerminalSetClearBackgroundMethodInfo    ,
#endif
    terminalSetClearBackground              ,


-- ** setColorBackground #method:setColorBackground#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorBackgroundMethodInfo    ,
#endif
    terminalSetColorBackground              ,


-- ** setColorBold #method:setColorBold#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorBoldMethodInfo          ,
#endif
    terminalSetColorBold                    ,


-- ** setColorCursor #method:setColorCursor#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorCursorMethodInfo        ,
#endif
    terminalSetColorCursor                  ,


-- ** setColorCursorForeground #method:setColorCursorForeground#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorCursorForegroundMethodInfo,
#endif
    terminalSetColorCursorForeground        ,


-- ** setColorForeground #method:setColorForeground#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorForegroundMethodInfo    ,
#endif
    terminalSetColorForeground              ,


-- ** setColorHighlight #method:setColorHighlight#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorHighlightMethodInfo     ,
#endif
    terminalSetColorHighlight               ,


-- ** setColorHighlightForeground #method:setColorHighlightForeground#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorHighlightForegroundMethodInfo,
#endif
    terminalSetColorHighlightForeground     ,


-- ** setColors #method:setColors#

#if defined(ENABLE_OVERLOADING)
    TerminalSetColorsMethodInfo             ,
#endif
    terminalSetColors                       ,


-- ** setCursorBlinkMode #method:setCursorBlinkMode#

#if defined(ENABLE_OVERLOADING)
    TerminalSetCursorBlinkModeMethodInfo    ,
#endif
    terminalSetCursorBlinkMode              ,


-- ** setCursorShape #method:setCursorShape#

#if defined(ENABLE_OVERLOADING)
    TerminalSetCursorShapeMethodInfo        ,
#endif
    terminalSetCursorShape                  ,


-- ** setDefaultColors #method:setDefaultColors#

#if defined(ENABLE_OVERLOADING)
    TerminalSetDefaultColorsMethodInfo      ,
#endif
    terminalSetDefaultColors                ,


-- ** setDeleteBinding #method:setDeleteBinding#

#if defined(ENABLE_OVERLOADING)
    TerminalSetDeleteBindingMethodInfo      ,
#endif
    terminalSetDeleteBinding                ,


-- ** setEncoding #method:setEncoding#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEncodingMethodInfo           ,
#endif
    terminalSetEncoding                     ,


-- ** setFont #method:setFont#

#if defined(ENABLE_OVERLOADING)
    TerminalSetFontMethodInfo               ,
#endif
    terminalSetFont                         ,


-- ** setFontScale #method:setFontScale#

#if defined(ENABLE_OVERLOADING)
    TerminalSetFontScaleMethodInfo          ,
#endif
    terminalSetFontScale                    ,


-- ** setGeometryHintsForWindow #method:setGeometryHintsForWindow#

#if defined(ENABLE_OVERLOADING)
    TerminalSetGeometryHintsForWindowMethodInfo,
#endif
    terminalSetGeometryHintsForWindow       ,


-- ** setInputEnabled #method:setInputEnabled#

#if defined(ENABLE_OVERLOADING)
    TerminalSetInputEnabledMethodInfo       ,
#endif
    terminalSetInputEnabled                 ,


-- ** setMouseAutohide #method:setMouseAutohide#

#if defined(ENABLE_OVERLOADING)
    TerminalSetMouseAutohideMethodInfo      ,
#endif
    terminalSetMouseAutohide                ,


-- ** setPty #method:setPty#

#if defined(ENABLE_OVERLOADING)
    TerminalSetPtyMethodInfo                ,
#endif
    terminalSetPty                          ,


-- ** setRewrapOnResize #method:setRewrapOnResize#

#if defined(ENABLE_OVERLOADING)
    TerminalSetRewrapOnResizeMethodInfo     ,
#endif
    terminalSetRewrapOnResize               ,


-- ** setScrollOnKeystroke #method:setScrollOnKeystroke#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollOnKeystrokeMethodInfo  ,
#endif
    terminalSetScrollOnKeystroke            ,


-- ** setScrollOnOutput #method:setScrollOnOutput#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollOnOutputMethodInfo     ,
#endif
    terminalSetScrollOnOutput               ,


-- ** setScrollSpeed #method:setScrollSpeed#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollSpeedMethodInfo        ,
#endif
    terminalSetScrollSpeed                  ,


-- ** setScrollbackLines #method:setScrollbackLines#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollbackLinesMethodInfo    ,
#endif
    terminalSetScrollbackLines              ,


-- ** setSize #method:setSize#

#if defined(ENABLE_OVERLOADING)
    TerminalSetSizeMethodInfo               ,
#endif
    terminalSetSize                         ,


-- ** setTextBlinkMode #method:setTextBlinkMode#

#if defined(ENABLE_OVERLOADING)
    TerminalSetTextBlinkModeMethodInfo      ,
#endif
    terminalSetTextBlinkMode                ,


-- ** setWordCharExceptions #method:setWordCharExceptions#

#if defined(ENABLE_OVERLOADING)
    TerminalSetWordCharExceptionsMethodInfo ,
#endif
    terminalSetWordCharExceptions           ,


-- ** spawnSync #method:spawnSync#

#if defined(ENABLE_OVERLOADING)
    TerminalSpawnSyncMethodInfo             ,
#endif
    terminalSpawnSync                       ,


-- ** unselectAll #method:unselectAll#

#if defined(ENABLE_OVERLOADING)
    TerminalUnselectAllMethodInfo           ,
#endif
    terminalUnselectAll                     ,


-- ** watchChild #method:watchChild#

#if defined(ENABLE_OVERLOADING)
    TerminalWatchChildMethodInfo            ,
#endif
    terminalWatchChild                      ,


-- ** writeContentsSync #method:writeContentsSync#

#if defined(ENABLE_OVERLOADING)
    TerminalWriteContentsSyncMethodInfo     ,
#endif
    terminalWriteContentsSync               ,




 -- * Properties
-- ** allowBold #attr:allowBold#
-- | Controls whether or not the terminal will attempt to draw bold text.
-- This may happen either by using a bold font variant, or by
-- repainting text with a different offset.

#if defined(ENABLE_OVERLOADING)
    TerminalAllowBoldPropertyInfo           ,
#endif
    constructTerminalAllowBold              ,
    getTerminalAllowBold                    ,
    setTerminalAllowBold                    ,
#if defined(ENABLE_OVERLOADING)
    terminalAllowBold                       ,
#endif


-- ** allowHyperlink #attr:allowHyperlink#
-- | Controls whether or not hyperlinks (OSC 8 escape sequence) are recognized and displayed.
-- 
-- /Since: 0.50/

#if defined(ENABLE_OVERLOADING)
    TerminalAllowHyperlinkPropertyInfo      ,
#endif
    constructTerminalAllowHyperlink         ,
    getTerminalAllowHyperlink               ,
    setTerminalAllowHyperlink               ,
#if defined(ENABLE_OVERLOADING)
    terminalAllowHyperlink                  ,
#endif


-- ** audibleBell #attr:audibleBell#
-- | Controls whether or not the terminal will beep when the child outputs the
-- \"bl\" sequence.

#if defined(ENABLE_OVERLOADING)
    TerminalAudibleBellPropertyInfo         ,
#endif
    constructTerminalAudibleBell            ,
    getTerminalAudibleBell                  ,
    setTerminalAudibleBell                  ,
#if defined(ENABLE_OVERLOADING)
    terminalAudibleBell                     ,
#endif


-- ** backspaceBinding #attr:backspaceBinding#
-- | Controls what string or control sequence the terminal sends to its child
-- when the user presses the backspace key.

#if defined(ENABLE_OVERLOADING)
    TerminalBackspaceBindingPropertyInfo    ,
#endif
    constructTerminalBackspaceBinding       ,
    getTerminalBackspaceBinding             ,
    setTerminalBackspaceBinding             ,
#if defined(ENABLE_OVERLOADING)
    terminalBackspaceBinding                ,
#endif


-- ** boldIsBright #attr:boldIsBright#
-- | Whether the SGR 1 attribute also switches to the bright counterpart
-- of the first 8 palette colors, in addition to making them bold (legacy behavior)
-- or if SGR 1 only enables bold and leaves the color intact.
-- 
-- /Since: 0.52/

#if defined(ENABLE_OVERLOADING)
    TerminalBoldIsBrightPropertyInfo        ,
#endif
    constructTerminalBoldIsBright           ,
    getTerminalBoldIsBright                 ,
    setTerminalBoldIsBright                 ,
#if defined(ENABLE_OVERLOADING)
    terminalBoldIsBright                    ,
#endif


-- ** cellHeightScale #attr:cellHeightScale#
-- | Scale factor for the cell height, to increase line spacing. (The font\'s height is not affected.)
-- 
-- /Since: 0.52/

#if defined(ENABLE_OVERLOADING)
    TerminalCellHeightScalePropertyInfo     ,
#endif
    constructTerminalCellHeightScale        ,
    getTerminalCellHeightScale              ,
    setTerminalCellHeightScale              ,
#if defined(ENABLE_OVERLOADING)
    terminalCellHeightScale                 ,
#endif


-- ** cellWidthScale #attr:cellWidthScale#
-- | Scale factor for the cell width, to increase letter spacing. (The font\'s width is not affected.)
-- 
-- /Since: 0.52/

#if defined(ENABLE_OVERLOADING)
    TerminalCellWidthScalePropertyInfo      ,
#endif
    constructTerminalCellWidthScale         ,
    getTerminalCellWidthScale               ,
    setTerminalCellWidthScale               ,
#if defined(ENABLE_OVERLOADING)
    terminalCellWidthScale                  ,
#endif


-- ** cjkAmbiguousWidth #attr:cjkAmbiguousWidth#
-- | This setting controls whether ambiguous-width characters are narrow or wide.
-- (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
-- the width of ambiguous-width characters is fixed and determined by the encoding
-- itself.)
-- 
-- This setting only takes effect the next time the terminal is reset, either
-- via escape sequence or with 'GI.Vte.Objects.Terminal.terminalReset'.

#if defined(ENABLE_OVERLOADING)
    TerminalCjkAmbiguousWidthPropertyInfo   ,
#endif
    constructTerminalCjkAmbiguousWidth      ,
    getTerminalCjkAmbiguousWidth            ,
    setTerminalCjkAmbiguousWidth            ,
#if defined(ENABLE_OVERLOADING)
    terminalCjkAmbiguousWidth               ,
#endif


-- ** currentContainerName #attr:currentContainerName#
-- | The name of the current container, or 'P.Nothing' if unset.

#if defined(ENABLE_OVERLOADING)
    TerminalCurrentContainerNamePropertyInfo,
#endif
    getTerminalCurrentContainerName         ,
#if defined(ENABLE_OVERLOADING)
    terminalCurrentContainerName            ,
#endif


-- ** currentContainerRuntime #attr:currentContainerRuntime#
-- | The name of the runtime toolset used to set up the current
-- container, or 'P.Nothing' if unset.

#if defined(ENABLE_OVERLOADING)
    TerminalCurrentContainerRuntimePropertyInfo,
#endif
    getTerminalCurrentContainerRuntime      ,
#if defined(ENABLE_OVERLOADING)
    terminalCurrentContainerRuntime         ,
#endif


-- ** currentDirectoryUri #attr:currentDirectoryUri#
-- | The current directory URI, or 'P.Nothing' if unset.

#if defined(ENABLE_OVERLOADING)
    TerminalCurrentDirectoryUriPropertyInfo ,
#endif
    getTerminalCurrentDirectoryUri          ,
#if defined(ENABLE_OVERLOADING)
    terminalCurrentDirectoryUri             ,
#endif


-- ** currentFileUri #attr:currentFileUri#
-- | The current file URI, or 'P.Nothing' if unset.

#if defined(ENABLE_OVERLOADING)
    TerminalCurrentFileUriPropertyInfo      ,
#endif
    getTerminalCurrentFileUri               ,
#if defined(ENABLE_OVERLOADING)
    terminalCurrentFileUri                  ,
#endif


-- ** cursorBlinkMode #attr:cursorBlinkMode#
-- | Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'
-- will use the t'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.

#if defined(ENABLE_OVERLOADING)
    TerminalCursorBlinkModePropertyInfo     ,
#endif
    constructTerminalCursorBlinkMode        ,
    getTerminalCursorBlinkMode              ,
    setTerminalCursorBlinkMode              ,
#if defined(ENABLE_OVERLOADING)
    terminalCursorBlinkMode                 ,
#endif


-- ** cursorShape #attr:cursorShape#
-- | Controls the shape of the cursor.

#if defined(ENABLE_OVERLOADING)
    TerminalCursorShapePropertyInfo         ,
#endif
    constructTerminalCursorShape            ,
    getTerminalCursorShape                  ,
    setTerminalCursorShape                  ,
#if defined(ENABLE_OVERLOADING)
    terminalCursorShape                     ,
#endif


-- ** deleteBinding #attr:deleteBinding#
-- | Controls what string or control sequence the terminal sends to its child
-- when the user presses the delete key.

#if defined(ENABLE_OVERLOADING)
    TerminalDeleteBindingPropertyInfo       ,
#endif
    constructTerminalDeleteBinding          ,
    getTerminalDeleteBinding                ,
    setTerminalDeleteBinding                ,
#if defined(ENABLE_OVERLOADING)
    terminalDeleteBinding                   ,
#endif


-- ** encoding #attr:encoding#
-- | Controls the encoding the terminal will expect data from the child to
-- be encoded with.  For certain terminal types, applications executing in the
-- terminal can change the encoding.  The default is defined by the
-- application\'s locale settings.

#if defined(ENABLE_OVERLOADING)
    TerminalEncodingPropertyInfo            ,
#endif
    clearTerminalEncoding                   ,
    constructTerminalEncoding               ,
    getTerminalEncoding                     ,
    setTerminalEncoding                     ,
#if defined(ENABLE_OVERLOADING)
    terminalEncoding                        ,
#endif


-- ** fontDesc #attr:fontDesc#
-- | Specifies the font used for rendering all text displayed by the terminal,
-- overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal
-- will immediately attempt to load the desired font, retrieve its
-- metrics, and attempt to resize itself to keep the same number of rows
-- and columns.

#if defined(ENABLE_OVERLOADING)
    TerminalFontDescPropertyInfo            ,
#endif
    clearTerminalFontDesc                   ,
    constructTerminalFontDesc               ,
    getTerminalFontDesc                     ,
    setTerminalFontDesc                     ,
#if defined(ENABLE_OVERLOADING)
    terminalFontDesc                        ,
#endif


-- ** fontScale #attr:fontScale#
-- | The terminal\'s font scale.

#if defined(ENABLE_OVERLOADING)
    TerminalFontScalePropertyInfo           ,
#endif
    constructTerminalFontScale              ,
    getTerminalFontScale                    ,
    setTerminalFontScale                    ,
#if defined(ENABLE_OVERLOADING)
    terminalFontScale                       ,
#endif


-- ** hyperlinkHoverUri #attr:hyperlinkHoverUri#
-- | The currently hovered hyperlink URI, or 'P.Nothing' if unset.
-- 
-- /Since: 0.50/

#if defined(ENABLE_OVERLOADING)
    TerminalHyperlinkHoverUriPropertyInfo   ,
#endif
    getTerminalHyperlinkHoverUri            ,
#if defined(ENABLE_OVERLOADING)
    terminalHyperlinkHoverUri               ,
#endif


-- ** iconTitle #attr:iconTitle#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TerminalIconTitlePropertyInfo           ,
#endif
    getTerminalIconTitle                    ,
#if defined(ENABLE_OVERLOADING)
    terminalIconTitle                       ,
#endif


-- ** inputEnabled #attr:inputEnabled#
-- | Controls whether the terminal allows user input. When user input is disabled,
-- key press and mouse button press and motion events are not sent to the
-- terminal\'s child.

#if defined(ENABLE_OVERLOADING)
    TerminalInputEnabledPropertyInfo        ,
#endif
    constructTerminalInputEnabled           ,
    getTerminalInputEnabled                 ,
    setTerminalInputEnabled                 ,
#if defined(ENABLE_OVERLOADING)
    terminalInputEnabled                    ,
#endif


-- ** pointerAutohide #attr:pointerAutohide#
-- | Controls the value of the terminal\'s mouse autohide setting.  When autohiding
-- is enabled, the mouse cursor will be hidden when the user presses a key and
-- shown when the user moves the mouse.

#if defined(ENABLE_OVERLOADING)
    TerminalPointerAutohidePropertyInfo     ,
#endif
    constructTerminalPointerAutohide        ,
    getTerminalPointerAutohide              ,
    setTerminalPointerAutohide              ,
#if defined(ENABLE_OVERLOADING)
    terminalPointerAutohide                 ,
#endif


-- ** pty #attr:pty#
-- | The PTY object for the terminal.

#if defined(ENABLE_OVERLOADING)
    TerminalPtyPropertyInfo                 ,
#endif
    clearTerminalPty                        ,
    constructTerminalPty                    ,
    getTerminalPty                          ,
    setTerminalPty                          ,
#if defined(ENABLE_OVERLOADING)
    terminalPty                             ,
#endif


-- ** rewrapOnResize #attr:rewrapOnResize#
-- | Controls whether or not the terminal will rewrap its contents, including
-- the scrollback buffer, whenever the terminal\'s width changes.

#if defined(ENABLE_OVERLOADING)
    TerminalRewrapOnResizePropertyInfo      ,
#endif
    constructTerminalRewrapOnResize         ,
    getTerminalRewrapOnResize               ,
    setTerminalRewrapOnResize               ,
#if defined(ENABLE_OVERLOADING)
    terminalRewrapOnResize                  ,
#endif


-- ** scrollOnKeystroke #attr:scrollOnKeystroke#
-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the user presses a key.  Modifier keys do not
-- trigger this behavior.

#if defined(ENABLE_OVERLOADING)
    TerminalScrollOnKeystrokePropertyInfo   ,
#endif
    constructTerminalScrollOnKeystroke      ,
    getTerminalScrollOnKeystroke            ,
    setTerminalScrollOnKeystroke            ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollOnKeystroke               ,
#endif


-- ** scrollOnOutput #attr:scrollOnOutput#
-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the new data is received from the child.

#if defined(ENABLE_OVERLOADING)
    TerminalScrollOnOutputPropertyInfo      ,
#endif
    constructTerminalScrollOnOutput         ,
    getTerminalScrollOnOutput               ,
    setTerminalScrollOnOutput               ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollOnOutput                  ,
#endif


-- ** scrollSpeed #attr:scrollSpeed#
-- | The number of lines by which the buffer is moved when
-- scrolling with a mouse wheel on top of the terminal
-- Setting it to zero will cause the buffer to be moved by an
-- amount depending on the number of visible rows the widget
-- can display.

#if defined(ENABLE_OVERLOADING)
    TerminalScrollSpeedPropertyInfo         ,
#endif
    constructTerminalScrollSpeed            ,
    getTerminalScrollSpeed                  ,
    setTerminalScrollSpeed                  ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollSpeed                     ,
#endif


-- ** scrollbackLines #attr:scrollbackLines#
-- | The length of the scrollback buffer used by the terminal.  The size of
-- the scrollback buffer will be set to the larger of this value and the number
-- of visible rows the widget can display, so 0 can safely be used to disable
-- scrollback.  Note that this setting only affects the normal screen buffer.
-- For terminal types which have an alternate screen buffer, no scrollback is
-- allowed on the alternate screen buffer.

#if defined(ENABLE_OVERLOADING)
    TerminalScrollbackLinesPropertyInfo     ,
#endif
    constructTerminalScrollbackLines        ,
    getTerminalScrollbackLines              ,
    setTerminalScrollbackLines              ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollbackLines                 ,
#endif


-- ** textBlinkMode #attr:textBlinkMode#
-- | Controls whether or not the terminal will allow blinking text.
-- 
-- /Since: 0.52/

#if defined(ENABLE_OVERLOADING)
    TerminalTextBlinkModePropertyInfo       ,
#endif
    constructTerminalTextBlinkMode          ,
    getTerminalTextBlinkMode                ,
    setTerminalTextBlinkMode                ,
#if defined(ENABLE_OVERLOADING)
    terminalTextBlinkMode                   ,
#endif


-- ** windowTitle #attr:windowTitle#
-- | The terminal\'s title.

#if defined(ENABLE_OVERLOADING)
    TerminalWindowTitlePropertyInfo         ,
#endif
    getTerminalWindowTitle                  ,
#if defined(ENABLE_OVERLOADING)
    terminalWindowTitle                     ,
#endif


-- ** wordCharExceptions #attr:wordCharExceptions#
-- | The set of characters which will be considered parts of a word
-- when doing word-wise selection, in addition to the default which only
-- considers alphanumeric characters part of a word.
-- 
-- If 'P.Nothing', a built-in set is used.
-- 
-- /Since: 0.40/

#if defined(ENABLE_OVERLOADING)
    TerminalWordCharExceptionsPropertyInfo  ,
#endif
    getTerminalWordCharExceptions           ,
#if defined(ENABLE_OVERLOADING)
    terminalWordCharExceptions              ,
#endif




 -- * Signals
-- ** bell #signal:bell#

    C_TerminalBellCallback                  ,
    TerminalBellCallback                    ,
#if defined(ENABLE_OVERLOADING)
    TerminalBellSignalInfo                  ,
#endif
    afterTerminalBell                       ,
    genClosure_TerminalBell                 ,
    mk_TerminalBellCallback                 ,
    noTerminalBellCallback                  ,
    onTerminalBell                          ,
    wrap_TerminalBellCallback               ,


-- ** charSizeChanged #signal:charSizeChanged#

    C_TerminalCharSizeChangedCallback       ,
    TerminalCharSizeChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalCharSizeChangedSignalInfo       ,
#endif
    afterTerminalCharSizeChanged            ,
    genClosure_TerminalCharSizeChanged      ,
    mk_TerminalCharSizeChangedCallback      ,
    noTerminalCharSizeChangedCallback       ,
    onTerminalCharSizeChanged               ,
    wrap_TerminalCharSizeChangedCallback    ,


-- ** childExited #signal:childExited#

    C_TerminalChildExitedCallback           ,
    TerminalChildExitedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalChildExitedSignalInfo           ,
#endif
    afterTerminalChildExited                ,
    genClosure_TerminalChildExited          ,
    mk_TerminalChildExitedCallback          ,
    noTerminalChildExitedCallback           ,
    onTerminalChildExited                   ,
    wrap_TerminalChildExitedCallback        ,


-- ** commit #signal:commit#

    C_TerminalCommitCallback                ,
    TerminalCommitCallback                  ,
#if defined(ENABLE_OVERLOADING)
    TerminalCommitSignalInfo                ,
#endif
    afterTerminalCommit                     ,
    genClosure_TerminalCommit               ,
    mk_TerminalCommitCallback               ,
    noTerminalCommitCallback                ,
    onTerminalCommit                        ,
    wrap_TerminalCommitCallback             ,


-- ** contentsChanged #signal:contentsChanged#

    C_TerminalContentsChangedCallback       ,
    TerminalContentsChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalContentsChangedSignalInfo       ,
#endif
    afterTerminalContentsChanged            ,
    genClosure_TerminalContentsChanged      ,
    mk_TerminalContentsChangedCallback      ,
    noTerminalContentsChangedCallback       ,
    onTerminalContentsChanged               ,
    wrap_TerminalContentsChangedCallback    ,


-- ** copyClipboard #signal:copyClipboard#

    C_TerminalCopyClipboardCallback         ,
    TerminalCopyClipboardCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalCopyClipboardSignalInfo         ,
#endif
    afterTerminalCopyClipboard              ,
    genClosure_TerminalCopyClipboard        ,
    mk_TerminalCopyClipboardCallback        ,
    noTerminalCopyClipboardCallback         ,
    onTerminalCopyClipboard                 ,
    wrap_TerminalCopyClipboardCallback      ,


-- ** currentDirectoryUriChanged #signal:currentDirectoryUriChanged#

    C_TerminalCurrentDirectoryUriChangedCallback,
    TerminalCurrentDirectoryUriChangedCallback,
#if defined(ENABLE_OVERLOADING)
    TerminalCurrentDirectoryUriChangedSignalInfo,
#endif
    afterTerminalCurrentDirectoryUriChanged ,
    genClosure_TerminalCurrentDirectoryUriChanged,
    mk_TerminalCurrentDirectoryUriChangedCallback,
    noTerminalCurrentDirectoryUriChangedCallback,
    onTerminalCurrentDirectoryUriChanged    ,
    wrap_TerminalCurrentDirectoryUriChangedCallback,


-- ** currentFileUriChanged #signal:currentFileUriChanged#

    C_TerminalCurrentFileUriChangedCallback ,
    TerminalCurrentFileUriChangedCallback   ,
#if defined(ENABLE_OVERLOADING)
    TerminalCurrentFileUriChangedSignalInfo ,
#endif
    afterTerminalCurrentFileUriChanged      ,
    genClosure_TerminalCurrentFileUriChanged,
    mk_TerminalCurrentFileUriChangedCallback,
    noTerminalCurrentFileUriChangedCallback ,
    onTerminalCurrentFileUriChanged         ,
    wrap_TerminalCurrentFileUriChangedCallback,


-- ** cursorMoved #signal:cursorMoved#

    C_TerminalCursorMovedCallback           ,
    TerminalCursorMovedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalCursorMovedSignalInfo           ,
#endif
    afterTerminalCursorMoved                ,
    genClosure_TerminalCursorMoved          ,
    mk_TerminalCursorMovedCallback          ,
    noTerminalCursorMovedCallback           ,
    onTerminalCursorMoved                   ,
    wrap_TerminalCursorMovedCallback        ,


-- ** decreaseFontSize #signal:decreaseFontSize#

    C_TerminalDecreaseFontSizeCallback      ,
    TerminalDecreaseFontSizeCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalDecreaseFontSizeSignalInfo      ,
#endif
    afterTerminalDecreaseFontSize           ,
    genClosure_TerminalDecreaseFontSize     ,
    mk_TerminalDecreaseFontSizeCallback     ,
    noTerminalDecreaseFontSizeCallback      ,
    onTerminalDecreaseFontSize              ,
    wrap_TerminalDecreaseFontSizeCallback   ,


-- ** deiconifyWindow #signal:deiconifyWindow#

    C_TerminalDeiconifyWindowCallback       ,
    TerminalDeiconifyWindowCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalDeiconifyWindowSignalInfo       ,
#endif
    afterTerminalDeiconifyWindow            ,
    genClosure_TerminalDeiconifyWindow      ,
    mk_TerminalDeiconifyWindowCallback      ,
    noTerminalDeiconifyWindowCallback       ,
    onTerminalDeiconifyWindow               ,
    wrap_TerminalDeiconifyWindowCallback    ,


-- ** encodingChanged #signal:encodingChanged#

    C_TerminalEncodingChangedCallback       ,
    TerminalEncodingChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalEncodingChangedSignalInfo       ,
#endif
    afterTerminalEncodingChanged            ,
    genClosure_TerminalEncodingChanged      ,
    mk_TerminalEncodingChangedCallback      ,
    noTerminalEncodingChangedCallback       ,
    onTerminalEncodingChanged               ,
    wrap_TerminalEncodingChangedCallback    ,


-- ** eof #signal:eof#

    C_TerminalEofCallback                   ,
    TerminalEofCallback                     ,
#if defined(ENABLE_OVERLOADING)
    TerminalEofSignalInfo                   ,
#endif
    afterTerminalEof                        ,
    genClosure_TerminalEof                  ,
    mk_TerminalEofCallback                  ,
    noTerminalEofCallback                   ,
    onTerminalEof                           ,
    wrap_TerminalEofCallback                ,


-- ** hyperlinkHoverUriChanged #signal:hyperlinkHoverUriChanged#

    C_TerminalHyperlinkHoverUriChangedCallback,
    TerminalHyperlinkHoverUriChangedCallback,
#if defined(ENABLE_OVERLOADING)
    TerminalHyperlinkHoverUriChangedSignalInfo,
#endif
    afterTerminalHyperlinkHoverUriChanged   ,
    genClosure_TerminalHyperlinkHoverUriChanged,
    mk_TerminalHyperlinkHoverUriChangedCallback,
    noTerminalHyperlinkHoverUriChangedCallback,
    onTerminalHyperlinkHoverUriChanged      ,
    wrap_TerminalHyperlinkHoverUriChangedCallback,


-- ** iconTitleChanged #signal:iconTitleChanged#

    C_TerminalIconTitleChangedCallback      ,
    TerminalIconTitleChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalIconTitleChangedSignalInfo      ,
#endif
    afterTerminalIconTitleChanged           ,
    genClosure_TerminalIconTitleChanged     ,
    mk_TerminalIconTitleChangedCallback     ,
    noTerminalIconTitleChangedCallback      ,
    onTerminalIconTitleChanged              ,
    wrap_TerminalIconTitleChangedCallback   ,


-- ** iconifyWindow #signal:iconifyWindow#

    C_TerminalIconifyWindowCallback         ,
    TerminalIconifyWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalIconifyWindowSignalInfo         ,
#endif
    afterTerminalIconifyWindow              ,
    genClosure_TerminalIconifyWindow        ,
    mk_TerminalIconifyWindowCallback        ,
    noTerminalIconifyWindowCallback         ,
    onTerminalIconifyWindow                 ,
    wrap_TerminalIconifyWindowCallback      ,


-- ** increaseFontSize #signal:increaseFontSize#

    C_TerminalIncreaseFontSizeCallback      ,
    TerminalIncreaseFontSizeCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalIncreaseFontSizeSignalInfo      ,
#endif
    afterTerminalIncreaseFontSize           ,
    genClosure_TerminalIncreaseFontSize     ,
    mk_TerminalIncreaseFontSizeCallback     ,
    noTerminalIncreaseFontSizeCallback      ,
    onTerminalIncreaseFontSize              ,
    wrap_TerminalIncreaseFontSizeCallback   ,


-- ** lowerWindow #signal:lowerWindow#

    C_TerminalLowerWindowCallback           ,
    TerminalLowerWindowCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalLowerWindowSignalInfo           ,
#endif
    afterTerminalLowerWindow                ,
    genClosure_TerminalLowerWindow          ,
    mk_TerminalLowerWindowCallback          ,
    noTerminalLowerWindowCallback           ,
    onTerminalLowerWindow                   ,
    wrap_TerminalLowerWindowCallback        ,


-- ** maximizeWindow #signal:maximizeWindow#

    C_TerminalMaximizeWindowCallback        ,
    TerminalMaximizeWindowCallback          ,
#if defined(ENABLE_OVERLOADING)
    TerminalMaximizeWindowSignalInfo        ,
#endif
    afterTerminalMaximizeWindow             ,
    genClosure_TerminalMaximizeWindow       ,
    mk_TerminalMaximizeWindowCallback       ,
    noTerminalMaximizeWindowCallback        ,
    onTerminalMaximizeWindow                ,
    wrap_TerminalMaximizeWindowCallback     ,


-- ** moveWindow #signal:moveWindow#

    C_TerminalMoveWindowCallback            ,
    TerminalMoveWindowCallback              ,
#if defined(ENABLE_OVERLOADING)
    TerminalMoveWindowSignalInfo            ,
#endif
    afterTerminalMoveWindow                 ,
    genClosure_TerminalMoveWindow           ,
    mk_TerminalMoveWindowCallback           ,
    noTerminalMoveWindowCallback            ,
    onTerminalMoveWindow                    ,
    wrap_TerminalMoveWindowCallback         ,


-- ** notificationReceived #signal:notificationReceived#

    C_TerminalNotificationReceivedCallback  ,
    TerminalNotificationReceivedCallback    ,
#if defined(ENABLE_OVERLOADING)
    TerminalNotificationReceivedSignalInfo  ,
#endif
    afterTerminalNotificationReceived       ,
    genClosure_TerminalNotificationReceived ,
    mk_TerminalNotificationReceivedCallback ,
    noTerminalNotificationReceivedCallback  ,
    onTerminalNotificationReceived          ,
    wrap_TerminalNotificationReceivedCallback,


-- ** pasteClipboard #signal:pasteClipboard#

    C_TerminalPasteClipboardCallback        ,
    TerminalPasteClipboardCallback          ,
#if defined(ENABLE_OVERLOADING)
    TerminalPasteClipboardSignalInfo        ,
#endif
    afterTerminalPasteClipboard             ,
    genClosure_TerminalPasteClipboard       ,
    mk_TerminalPasteClipboardCallback       ,
    noTerminalPasteClipboardCallback        ,
    onTerminalPasteClipboard                ,
    wrap_TerminalPasteClipboardCallback     ,


-- ** raiseWindow #signal:raiseWindow#

    C_TerminalRaiseWindowCallback           ,
    TerminalRaiseWindowCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalRaiseWindowSignalInfo           ,
#endif
    afterTerminalRaiseWindow                ,
    genClosure_TerminalRaiseWindow          ,
    mk_TerminalRaiseWindowCallback          ,
    noTerminalRaiseWindowCallback           ,
    onTerminalRaiseWindow                   ,
    wrap_TerminalRaiseWindowCallback        ,


-- ** refreshWindow #signal:refreshWindow#

    C_TerminalRefreshWindowCallback         ,
    TerminalRefreshWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalRefreshWindowSignalInfo         ,
#endif
    afterTerminalRefreshWindow              ,
    genClosure_TerminalRefreshWindow        ,
    mk_TerminalRefreshWindowCallback        ,
    noTerminalRefreshWindowCallback         ,
    onTerminalRefreshWindow                 ,
    wrap_TerminalRefreshWindowCallback      ,


-- ** resizeWindow #signal:resizeWindow#

    C_TerminalResizeWindowCallback          ,
    TerminalResizeWindowCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalResizeWindowSignalInfo          ,
#endif
    afterTerminalResizeWindow               ,
    genClosure_TerminalResizeWindow         ,
    mk_TerminalResizeWindowCallback         ,
    noTerminalResizeWindowCallback          ,
    onTerminalResizeWindow                  ,
    wrap_TerminalResizeWindowCallback       ,


-- ** restoreWindow #signal:restoreWindow#

    C_TerminalRestoreWindowCallback         ,
    TerminalRestoreWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalRestoreWindowSignalInfo         ,
#endif
    afterTerminalRestoreWindow              ,
    genClosure_TerminalRestoreWindow        ,
    mk_TerminalRestoreWindowCallback        ,
    noTerminalRestoreWindowCallback         ,
    onTerminalRestoreWindow                 ,
    wrap_TerminalRestoreWindowCallback      ,


-- ** selectionChanged #signal:selectionChanged#

    C_TerminalSelectionChangedCallback      ,
    TerminalSelectionChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalSelectionChangedSignalInfo      ,
#endif
    afterTerminalSelectionChanged           ,
    genClosure_TerminalSelectionChanged     ,
    mk_TerminalSelectionChangedCallback     ,
    noTerminalSelectionChangedCallback      ,
    onTerminalSelectionChanged              ,
    wrap_TerminalSelectionChangedCallback   ,


-- ** textDeleted #signal:textDeleted#

    C_TerminalTextDeletedCallback           ,
    TerminalTextDeletedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextDeletedSignalInfo           ,
#endif
    afterTerminalTextDeleted                ,
    genClosure_TerminalTextDeleted          ,
    mk_TerminalTextDeletedCallback          ,
    noTerminalTextDeletedCallback           ,
    onTerminalTextDeleted                   ,
    wrap_TerminalTextDeletedCallback        ,


-- ** textInserted #signal:textInserted#

    C_TerminalTextInsertedCallback          ,
    TerminalTextInsertedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextInsertedSignalInfo          ,
#endif
    afterTerminalTextInserted               ,
    genClosure_TerminalTextInserted         ,
    mk_TerminalTextInsertedCallback         ,
    noTerminalTextInsertedCallback          ,
    onTerminalTextInserted                  ,
    wrap_TerminalTextInsertedCallback       ,


-- ** textModified #signal:textModified#

    C_TerminalTextModifiedCallback          ,
    TerminalTextModifiedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextModifiedSignalInfo          ,
#endif
    afterTerminalTextModified               ,
    genClosure_TerminalTextModified         ,
    mk_TerminalTextModifiedCallback         ,
    noTerminalTextModifiedCallback          ,
    onTerminalTextModified                  ,
    wrap_TerminalTextModifiedCallback       ,


-- ** textScrolled #signal:textScrolled#

    C_TerminalTextScrolledCallback          ,
    TerminalTextScrolledCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextScrolledSignalInfo          ,
#endif
    afterTerminalTextScrolled               ,
    genClosure_TerminalTextScrolled         ,
    mk_TerminalTextScrolledCallback         ,
    noTerminalTextScrolledCallback          ,
    onTerminalTextScrolled                  ,
    wrap_TerminalTextScrolledCallback       ,


-- ** windowTitleChanged #signal:windowTitleChanged#

    C_TerminalWindowTitleChangedCallback    ,
    TerminalWindowTitleChangedCallback      ,
#if defined(ENABLE_OVERLOADING)
    TerminalWindowTitleChangedSignalInfo    ,
#endif
    afterTerminalWindowTitleChanged         ,
    genClosure_TerminalWindowTitleChanged   ,
    mk_TerminalWindowTitleChangedCallback   ,
    noTerminalWindowTitleChangedCallback    ,
    onTerminalWindowTitleChanged            ,
    wrap_TerminalWindowTitleChangedCallback ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Regex as GLib.Regex
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Objects.Window as Gtk.Window
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
import {-# SOURCE #-} qualified GI.Vte.Enums as Vte.Enums
import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags
import {-# SOURCE #-} qualified GI.Vte.Objects.Pty as Vte.Pty
import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex

-- | Memory-managed wrapper type.
newtype Terminal = Terminal (ManagedPtr Terminal)
    deriving (Terminal -> Terminal -> Bool
(Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Bool) -> Eq Terminal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Terminal -> Terminal -> Bool
$c/= :: Terminal -> Terminal -> Bool
== :: Terminal -> Terminal -> Bool
$c== :: Terminal -> Terminal -> Bool
Eq)
foreign import ccall "vte_terminal_get_type"
    c_vte_terminal_get_type :: IO GType

instance GObject Terminal where
    gobjectType :: IO GType
gobjectType = IO GType
c_vte_terminal_get_type
    

-- | Convert 'Terminal' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Terminal where
    toGValue :: Terminal -> IO GValue
toGValue o :: Terminal
o = do
        GType
gtype <- IO GType
c_vte_terminal_get_type
        Terminal -> (Ptr Terminal -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Terminal
o (GType
-> (GValue -> Ptr Terminal -> IO ()) -> Ptr Terminal -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Terminal -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Terminal
fromGValue gv :: GValue
gv = do
        Ptr Terminal
ptr <- GValue -> IO (Ptr Terminal)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Terminal)
        (ManagedPtr Terminal -> Terminal) -> Ptr Terminal -> IO Terminal
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Terminal -> Terminal
Terminal Ptr Terminal
ptr
        
    

-- | Type class for types which can be safely cast to `Terminal`, for instance with `toTerminal`.
class (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o
instance (GObject o, O.IsDescendantOf Terminal o) => IsTerminal o

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

-- | Cast to `Terminal`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTerminal :: (MonadIO m, IsTerminal o) => o -> m Terminal
toTerminal :: o -> m Terminal
toTerminal = IO Terminal -> m Terminal
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Terminal -> m Terminal)
-> (o -> IO Terminal) -> o -> m Terminal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Terminal -> Terminal) -> o -> IO Terminal
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Terminal -> Terminal
Terminal

-- | A convenience alias for `Nothing` :: `Maybe` `Terminal`.
noTerminal :: Maybe Terminal
noTerminal :: Maybe Terminal
noTerminal = Maybe Terminal
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveTerminalMethod (t :: Symbol) (o :: *) :: * where
    ResolveTerminalMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTerminalMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTerminalMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTerminalMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTerminalMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTerminalMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTerminalMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTerminalMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTerminalMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTerminalMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTerminalMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTerminalMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo
    ResolveTerminalMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTerminalMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTerminalMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTerminalMethod "copyClipboard" o = TerminalCopyClipboardMethodInfo
    ResolveTerminalMethod "copyClipboardFormat" o = TerminalCopyClipboardFormatMethodInfo
    ResolveTerminalMethod "copyPrimary" o = TerminalCopyPrimaryMethodInfo
    ResolveTerminalMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTerminalMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTerminalMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTerminalMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTerminalMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTerminalMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTerminalMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTerminalMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTerminalMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTerminalMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTerminalMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTerminalMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTerminalMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTerminalMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTerminalMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTerminalMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTerminalMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTerminalMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTerminalMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTerminalMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTerminalMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTerminalMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTerminalMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTerminalMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTerminalMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTerminalMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTerminalMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTerminalMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTerminalMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTerminalMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTerminalMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTerminalMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTerminalMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTerminalMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTerminalMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTerminalMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTerminalMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTerminalMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTerminalMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTerminalMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTerminalMethod "feed" o = TerminalFeedMethodInfo
    ResolveTerminalMethod "feedChild" o = TerminalFeedChildMethodInfo
    ResolveTerminalMethod "feedChildBinary" o = TerminalFeedChildBinaryMethodInfo
    ResolveTerminalMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTerminalMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTerminalMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTerminalMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTerminalMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTerminalMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTerminalMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTerminalMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTerminalMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTerminalMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTerminalMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTerminalMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTerminalMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTerminalMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTerminalMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTerminalMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTerminalMethod "hyperlinkCheckEvent" o = TerminalHyperlinkCheckEventMethodInfo
    ResolveTerminalMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTerminalMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTerminalMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTerminalMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTerminalMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTerminalMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTerminalMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveTerminalMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTerminalMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTerminalMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTerminalMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTerminalMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTerminalMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTerminalMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTerminalMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTerminalMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTerminalMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTerminalMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTerminalMethod "matchAddGregex" o = TerminalMatchAddGregexMethodInfo
    ResolveTerminalMethod "matchAddRegex" o = TerminalMatchAddRegexMethodInfo
    ResolveTerminalMethod "matchCheck" o = TerminalMatchCheckMethodInfo
    ResolveTerminalMethod "matchCheckEvent" o = TerminalMatchCheckEventMethodInfo
    ResolveTerminalMethod "matchRemove" o = TerminalMatchRemoveMethodInfo
    ResolveTerminalMethod "matchRemoveAll" o = TerminalMatchRemoveAllMethodInfo
    ResolveTerminalMethod "matchSetCursor" o = TerminalMatchSetCursorMethodInfo
    ResolveTerminalMethod "matchSetCursorName" o = TerminalMatchSetCursorNameMethodInfo
    ResolveTerminalMethod "matchSetCursorType" o = TerminalMatchSetCursorTypeMethodInfo
    ResolveTerminalMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTerminalMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTerminalMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTerminalMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTerminalMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTerminalMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTerminalMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTerminalMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTerminalMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTerminalMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTerminalMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTerminalMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTerminalMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTerminalMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTerminalMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTerminalMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTerminalMethod "pasteClipboard" o = TerminalPasteClipboardMethodInfo
    ResolveTerminalMethod "pastePrimary" o = TerminalPastePrimaryMethodInfo
    ResolveTerminalMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTerminalMethod "ptyNewSync" o = TerminalPtyNewSyncMethodInfo
    ResolveTerminalMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTerminalMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTerminalMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTerminalMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTerminalMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTerminalMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTerminalMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTerminalMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTerminalMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTerminalMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTerminalMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTerminalMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTerminalMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTerminalMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTerminalMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTerminalMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTerminalMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTerminalMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTerminalMethod "reset" o = TerminalResetMethodInfo
    ResolveTerminalMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTerminalMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTerminalMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTerminalMethod "searchFindNext" o = TerminalSearchFindNextMethodInfo
    ResolveTerminalMethod "searchFindPrevious" o = TerminalSearchFindPreviousMethodInfo
    ResolveTerminalMethod "searchGetGregex" o = TerminalSearchGetGregexMethodInfo
    ResolveTerminalMethod "searchGetRegex" o = TerminalSearchGetRegexMethodInfo
    ResolveTerminalMethod "searchGetWrapAround" o = TerminalSearchGetWrapAroundMethodInfo
    ResolveTerminalMethod "searchSetGregex" o = TerminalSearchSetGregexMethodInfo
    ResolveTerminalMethod "searchSetRegex" o = TerminalSearchSetRegexMethodInfo
    ResolveTerminalMethod "searchSetWrapAround" o = TerminalSearchSetWrapAroundMethodInfo
    ResolveTerminalMethod "selectAll" o = TerminalSelectAllMethodInfo
    ResolveTerminalMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTerminalMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTerminalMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTerminalMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTerminalMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTerminalMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTerminalMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTerminalMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTerminalMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTerminalMethod "spawnSync" o = TerminalSpawnSyncMethodInfo
    ResolveTerminalMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTerminalMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTerminalMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTerminalMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTerminalMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveTerminalMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTerminalMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTerminalMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTerminalMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTerminalMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTerminalMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTerminalMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTerminalMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTerminalMethod "unselectAll" o = TerminalUnselectAllMethodInfo
    ResolveTerminalMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTerminalMethod "watchChild" o = TerminalWatchChildMethodInfo
    ResolveTerminalMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTerminalMethod "writeContentsSync" o = TerminalWriteContentsSyncMethodInfo
    ResolveTerminalMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTerminalMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTerminalMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTerminalMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTerminalMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTerminalMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTerminalMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTerminalMethod "getAllowBold" o = TerminalGetAllowBoldMethodInfo
    ResolveTerminalMethod "getAllowHyperlink" o = TerminalGetAllowHyperlinkMethodInfo
    ResolveTerminalMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTerminalMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTerminalMethod "getAudibleBell" o = TerminalGetAudibleBellMethodInfo
    ResolveTerminalMethod "getBoldIsBright" o = TerminalGetBoldIsBrightMethodInfo
    ResolveTerminalMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveTerminalMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTerminalMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTerminalMethod "getCellHeightScale" o = TerminalGetCellHeightScaleMethodInfo
    ResolveTerminalMethod "getCellWidthScale" o = TerminalGetCellWidthScaleMethodInfo
    ResolveTerminalMethod "getCharHeight" o = TerminalGetCharHeightMethodInfo
    ResolveTerminalMethod "getCharWidth" o = TerminalGetCharWidthMethodInfo
    ResolveTerminalMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTerminalMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTerminalMethod "getCjkAmbiguousWidth" o = TerminalGetCjkAmbiguousWidthMethodInfo
    ResolveTerminalMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTerminalMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTerminalMethod "getColorBackgroundForDraw" o = TerminalGetColorBackgroundForDrawMethodInfo
    ResolveTerminalMethod "getColumnCount" o = TerminalGetColumnCountMethodInfo
    ResolveTerminalMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTerminalMethod "getCurrentContainerName" o = TerminalGetCurrentContainerNameMethodInfo
    ResolveTerminalMethod "getCurrentContainerRuntime" o = TerminalGetCurrentContainerRuntimeMethodInfo
    ResolveTerminalMethod "getCurrentDirectoryUri" o = TerminalGetCurrentDirectoryUriMethodInfo
    ResolveTerminalMethod "getCurrentFileUri" o = TerminalGetCurrentFileUriMethodInfo
    ResolveTerminalMethod "getCursorBlinkMode" o = TerminalGetCursorBlinkModeMethodInfo
    ResolveTerminalMethod "getCursorPosition" o = TerminalGetCursorPositionMethodInfo
    ResolveTerminalMethod "getCursorShape" o = TerminalGetCursorShapeMethodInfo
    ResolveTerminalMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTerminalMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTerminalMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTerminalMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTerminalMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTerminalMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTerminalMethod "getEncoding" o = TerminalGetEncodingMethodInfo
    ResolveTerminalMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTerminalMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTerminalMethod "getFont" o = TerminalGetFontMethodInfo
    ResolveTerminalMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTerminalMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTerminalMethod "getFontScale" o = TerminalGetFontScaleMethodInfo
    ResolveTerminalMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTerminalMethod "getGeometryHints" o = TerminalGetGeometryHintsMethodInfo
    ResolveTerminalMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
    ResolveTerminalMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTerminalMethod "getHasSelection" o = TerminalGetHasSelectionMethodInfo
    ResolveTerminalMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTerminalMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTerminalMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTerminalMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTerminalMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveTerminalMethod "getIconTitle" o = TerminalGetIconTitleMethodInfo
    ResolveTerminalMethod "getInputEnabled" o = TerminalGetInputEnabledMethodInfo
    ResolveTerminalMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTerminalMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTerminalMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTerminalMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTerminalMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTerminalMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTerminalMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTerminalMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTerminalMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTerminalMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTerminalMethod "getMouseAutohide" o = TerminalGetMouseAutohideMethodInfo
    ResolveTerminalMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTerminalMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTerminalMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTerminalMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTerminalMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTerminalMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTerminalMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTerminalMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTerminalMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTerminalMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTerminalMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTerminalMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTerminalMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTerminalMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveTerminalMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTerminalMethod "getPty" o = TerminalGetPtyMethodInfo
    ResolveTerminalMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTerminalMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTerminalMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTerminalMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTerminalMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTerminalMethod "getRewrapOnResize" o = TerminalGetRewrapOnResizeMethodInfo
    ResolveTerminalMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTerminalMethod "getRowCount" o = TerminalGetRowCountMethodInfo
    ResolveTerminalMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTerminalMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTerminalMethod "getScrollOnKeystroke" o = TerminalGetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "getScrollOnOutput" o = TerminalGetScrollOnOutputMethodInfo
    ResolveTerminalMethod "getScrollbackLines" o = TerminalGetScrollbackLinesMethodInfo
    ResolveTerminalMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTerminalMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTerminalMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTerminalMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTerminalMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTerminalMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTerminalMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTerminalMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTerminalMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTerminalMethod "getText" o = TerminalGetTextMethodInfo
    ResolveTerminalMethod "getTextBlinkMode" o = TerminalGetTextBlinkModeMethodInfo
    ResolveTerminalMethod "getTextIncludeTrailingSpaces" o = TerminalGetTextIncludeTrailingSpacesMethodInfo
    ResolveTerminalMethod "getTextRange" o = TerminalGetTextRangeMethodInfo
    ResolveTerminalMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTerminalMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTerminalMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTerminalMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTerminalMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
    ResolveTerminalMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTerminalMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTerminalMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTerminalMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTerminalMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTerminalMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTerminalMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveTerminalMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTerminalMethod "getWindowTitle" o = TerminalGetWindowTitleMethodInfo
    ResolveTerminalMethod "getWordCharExceptions" o = TerminalGetWordCharExceptionsMethodInfo
    ResolveTerminalMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTerminalMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTerminalMethod "setAllowBold" o = TerminalSetAllowBoldMethodInfo
    ResolveTerminalMethod "setAllowHyperlink" o = TerminalSetAllowHyperlinkMethodInfo
    ResolveTerminalMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTerminalMethod "setAudibleBell" o = TerminalSetAudibleBellMethodInfo
    ResolveTerminalMethod "setBackspaceBinding" o = TerminalSetBackspaceBindingMethodInfo
    ResolveTerminalMethod "setBoldIsBright" o = TerminalSetBoldIsBrightMethodInfo
    ResolveTerminalMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTerminalMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTerminalMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTerminalMethod "setCellHeightScale" o = TerminalSetCellHeightScaleMethodInfo
    ResolveTerminalMethod "setCellWidthScale" o = TerminalSetCellWidthScaleMethodInfo
    ResolveTerminalMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTerminalMethod "setCjkAmbiguousWidth" o = TerminalSetCjkAmbiguousWidthMethodInfo
    ResolveTerminalMethod "setClearBackground" o = TerminalSetClearBackgroundMethodInfo
    ResolveTerminalMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTerminalMethod "setColorBackground" o = TerminalSetColorBackgroundMethodInfo
    ResolveTerminalMethod "setColorBold" o = TerminalSetColorBoldMethodInfo
    ResolveTerminalMethod "setColorCursor" o = TerminalSetColorCursorMethodInfo
    ResolveTerminalMethod "setColorCursorForeground" o = TerminalSetColorCursorForegroundMethodInfo
    ResolveTerminalMethod "setColorForeground" o = TerminalSetColorForegroundMethodInfo
    ResolveTerminalMethod "setColorHighlight" o = TerminalSetColorHighlightMethodInfo
    ResolveTerminalMethod "setColorHighlightForeground" o = TerminalSetColorHighlightForegroundMethodInfo
    ResolveTerminalMethod "setColors" o = TerminalSetColorsMethodInfo
    ResolveTerminalMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTerminalMethod "setCursorBlinkMode" o = TerminalSetCursorBlinkModeMethodInfo
    ResolveTerminalMethod "setCursorShape" o = TerminalSetCursorShapeMethodInfo
    ResolveTerminalMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTerminalMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTerminalMethod "setDefaultColors" o = TerminalSetDefaultColorsMethodInfo
    ResolveTerminalMethod "setDeleteBinding" o = TerminalSetDeleteBindingMethodInfo
    ResolveTerminalMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTerminalMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTerminalMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTerminalMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTerminalMethod "setEncoding" o = TerminalSetEncodingMethodInfo
    ResolveTerminalMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTerminalMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTerminalMethod "setFont" o = TerminalSetFontMethodInfo
    ResolveTerminalMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTerminalMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTerminalMethod "setFontScale" o = TerminalSetFontScaleMethodInfo
    ResolveTerminalMethod "setGeometryHintsForWindow" o = TerminalSetGeometryHintsForWindowMethodInfo
    ResolveTerminalMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
    ResolveTerminalMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTerminalMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTerminalMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTerminalMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTerminalMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTerminalMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveTerminalMethod "setInputEnabled" o = TerminalSetInputEnabledMethodInfo
    ResolveTerminalMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTerminalMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTerminalMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTerminalMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTerminalMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTerminalMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTerminalMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTerminalMethod "setMouseAutohide" o = TerminalSetMouseAutohideMethodInfo
    ResolveTerminalMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTerminalMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTerminalMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTerminalMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTerminalMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTerminalMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTerminalMethod "setPty" o = TerminalSetPtyMethodInfo
    ResolveTerminalMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTerminalMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTerminalMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTerminalMethod "setRewrapOnResize" o = TerminalSetRewrapOnResizeMethodInfo
    ResolveTerminalMethod "setScrollOnKeystroke" o = TerminalSetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "setScrollOnOutput" o = TerminalSetScrollOnOutputMethodInfo
    ResolveTerminalMethod "setScrollSpeed" o = TerminalSetScrollSpeedMethodInfo
    ResolveTerminalMethod "setScrollbackLines" o = TerminalSetScrollbackLinesMethodInfo
    ResolveTerminalMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTerminalMethod "setSize" o = TerminalSetSizeMethodInfo
    ResolveTerminalMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTerminalMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTerminalMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTerminalMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTerminalMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTerminalMethod "setTextBlinkMode" o = TerminalSetTextBlinkModeMethodInfo
    ResolveTerminalMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTerminalMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTerminalMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveTerminalMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
    ResolveTerminalMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTerminalMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTerminalMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTerminalMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTerminalMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTerminalMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveTerminalMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveTerminalMethod "setWordCharExceptions" o = TerminalSetWordCharExceptionsMethodInfo
    ResolveTerminalMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTerminalMethod t Terminal, O.MethodInfo info Terminal p) => OL.IsLabel t (Terminal -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- signal Terminal::bell
-- | This signal is emitted when the a child sends a bell request to the
-- terminal.
type TerminalBellCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalBellCallback`@.
noTerminalBellCallback :: Maybe TerminalBellCallback
noTerminalBellCallback :: Maybe (IO ())
noTerminalBellCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalBellCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalBellCallback`.
foreign import ccall "wrapper"
    mk_TerminalBellCallback :: C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalBell :: MonadIO m => TerminalBellCallback -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalBell :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalBell cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalBellCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalBellCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalBellCallback` into a `C_TerminalBellCallback`.
wrap_TerminalBellCallback ::
    TerminalBellCallback ->
    C_TerminalBellCallback
wrap_TerminalBellCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalBellCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [bell](#signal:bell) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #bell callback
-- @
-- 
-- 
onTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
onTerminalBell :: a -> IO () -> m SignalHandlerId
onTerminalBell obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalBellCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalBellCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bell" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [bell](#signal:bell) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #bell callback
-- @
-- 
-- 
afterTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
afterTerminalBell :: a -> IO () -> m SignalHandlerId
afterTerminalBell obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalBellCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalBellCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bell" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalBellSignalInfo
instance SignalInfo TerminalBellSignalInfo where
    type HaskellCallbackType TerminalBellSignalInfo = TerminalBellCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalBellCallback cb
        cb'' <- mk_TerminalBellCallback cb'
        connectSignalFunPtr obj "bell" cb'' connectMode detail

#endif

-- signal Terminal::char-size-changed
-- | Emitted whenever the cell size changes, e.g. due to a change in
-- font, font-scale or cell-width\/height-scale.
-- 
-- Note that this signal should rather be called \"cell-size-changed\".
type TerminalCharSizeChangedCallback =
    Word32
    -- ^ /@width@/: the new character cell width
    -> Word32
    -- ^ /@height@/: the new character cell height
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCharSizeChangedCallback`@.
noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalCharSizeChangedCallback = Maybe TerminalCharSizeChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCharSizeChangedCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCharSizeChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCharSizeChangedCallback :: C_TerminalCharSizeChangedCallback -> IO (FunPtr C_TerminalCharSizeChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCharSizeChanged :: MonadIO m => TerminalCharSizeChangedCallback -> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalCharSizeChanged :: TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalCharSizeChanged cb :: TerminalCharSizeChangedCallback
cb = IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalCharSizeChangedCallback)
 -> m (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback TerminalCharSizeChangedCallback
cb
    C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalCharSizeChangedCallback C_TerminalCharSizeChangedCallback
cb' IO (FunPtr C_TerminalCharSizeChangedCallback)
-> (FunPtr C_TerminalCharSizeChangedCallback
    -> IO (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalCharSizeChangedCallback
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCharSizeChangedCallback` into a `C_TerminalCharSizeChangedCallback`.
wrap_TerminalCharSizeChangedCallback ::
    TerminalCharSizeChangedCallback ->
    C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback :: TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback _cb :: TerminalCharSizeChangedCallback
_cb _ width :: Word32
width height :: Word32
height _ = do
    TerminalCharSizeChangedCallback
_cb  Word32
width Word32
height


-- | Connect a signal handler for the [charSizeChanged](#signal:charSizeChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #charSizeChanged callback
-- @
-- 
-- 
onTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalCharSizeChanged :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalCharSizeChanged obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalCharSizeChangedCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "char-size-changed" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [charSizeChanged](#signal:charSizeChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #charSizeChanged callback
-- @
-- 
-- 
afterTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalCharSizeChanged :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalCharSizeChanged obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalCharSizeChangedCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "char-size-changed" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCharSizeChangedSignalInfo
instance SignalInfo TerminalCharSizeChangedSignalInfo where
    type HaskellCallbackType TerminalCharSizeChangedSignalInfo = TerminalCharSizeChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCharSizeChangedCallback cb
        cb'' <- mk_TerminalCharSizeChangedCallback cb'
        connectSignalFunPtr obj "char-size-changed" cb'' connectMode detail

#endif

-- signal Terminal::child-exited
-- | This signal is emitted when the terminal detects that a child
-- watched using 'GI.Vte.Objects.Terminal.terminalWatchChild' has exited.
type TerminalChildExitedCallback =
    Int32
    -- ^ /@status@/: the child\'s exit status
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalChildExitedCallback`@.
noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback
noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback
noTerminalChildExitedCallback = Maybe TerminalChildExitedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalChildExitedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalChildExitedCallback`.
foreign import ccall "wrapper"
    mk_TerminalChildExitedCallback :: C_TerminalChildExitedCallback -> IO (FunPtr C_TerminalChildExitedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalChildExited :: MonadIO m => TerminalChildExitedCallback -> m (GClosure C_TerminalChildExitedCallback)
genClosure_TerminalChildExited :: TerminalChildExitedCallback
-> m (GClosure C_TerminalChildExitedCallback)
genClosure_TerminalChildExited cb :: TerminalChildExitedCallback
cb = IO (GClosure C_TerminalChildExitedCallback)
-> m (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalChildExitedCallback)
 -> m (GClosure C_TerminalChildExitedCallback))
-> IO (GClosure C_TerminalChildExitedCallback)
-> m (GClosure C_TerminalChildExitedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback TerminalChildExitedCallback
cb
    C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalChildExitedCallback C_TerminalChildExitedCallback
cb' IO (FunPtr C_TerminalChildExitedCallback)
-> (FunPtr C_TerminalChildExitedCallback
    -> IO (GClosure C_TerminalChildExitedCallback))
-> IO (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalChildExitedCallback
-> IO (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalChildExitedCallback` into a `C_TerminalChildExitedCallback`.
wrap_TerminalChildExitedCallback ::
    TerminalChildExitedCallback ->
    C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback :: TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback _cb :: TerminalChildExitedCallback
_cb _ status :: Int32
status _ = do
    TerminalChildExitedCallback
_cb  Int32
status


-- | Connect a signal handler for the [childExited](#signal:childExited) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #childExited callback
-- @
-- 
-- 
onTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalChildExited :: a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalChildExited obj :: a
obj cb :: TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback TerminalChildExitedCallback
cb
    FunPtr C_TerminalChildExitedCallback
cb'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalChildExitedCallback C_TerminalChildExitedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalChildExitedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-exited" FunPtr C_TerminalChildExitedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [childExited](#signal:childExited) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #childExited callback
-- @
-- 
-- 
afterTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalChildExited :: a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalChildExited obj :: a
obj cb :: TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback TerminalChildExitedCallback
cb
    FunPtr C_TerminalChildExitedCallback
cb'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalChildExitedCallback C_TerminalChildExitedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalChildExitedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-exited" FunPtr C_TerminalChildExitedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalChildExitedSignalInfo
instance SignalInfo TerminalChildExitedSignalInfo where
    type HaskellCallbackType TerminalChildExitedSignalInfo = TerminalChildExitedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalChildExitedCallback cb
        cb'' <- mk_TerminalChildExitedCallback cb'
        connectSignalFunPtr obj "child-exited" cb'' connectMode detail

#endif

-- signal Terminal::commit
-- | Emitted whenever the terminal receives input from the user and
-- prepares to send it to the child process.  The signal is emitted even
-- when there is no child process.
type TerminalCommitCallback =
    T.Text
    -- ^ /@text@/: a string of text
    -> Word32
    -- ^ /@size@/: the length of that string of text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCommitCallback`@.
noTerminalCommitCallback :: Maybe TerminalCommitCallback
noTerminalCommitCallback :: Maybe TerminalCommitCallback
noTerminalCommitCallback = Maybe TerminalCommitCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCommitCallback =
    Ptr () ->                               -- object
    CString ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCommitCallback`.
foreign import ccall "wrapper"
    mk_TerminalCommitCallback :: C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCommit :: MonadIO m => TerminalCommitCallback -> m (GClosure C_TerminalCommitCallback)
genClosure_TerminalCommit :: TerminalCommitCallback -> m (GClosure C_TerminalCommitCallback)
genClosure_TerminalCommit cb :: TerminalCommitCallback
cb = IO (GClosure C_TerminalCommitCallback)
-> m (GClosure C_TerminalCommitCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalCommitCallback)
 -> m (GClosure C_TerminalCommitCallback))
-> IO (GClosure C_TerminalCommitCallback)
-> m (GClosure C_TerminalCommitCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCommitCallback
cb' = TerminalCommitCallback -> C_TerminalCommitCallback
wrap_TerminalCommitCallback TerminalCommitCallback
cb
    C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)
mk_TerminalCommitCallback C_TerminalCommitCallback
cb' IO (FunPtr C_TerminalCommitCallback)
-> (FunPtr C_TerminalCommitCallback
    -> IO (GClosure C_TerminalCommitCallback))
-> IO (GClosure C_TerminalCommitCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalCommitCallback
-> IO (GClosure C_TerminalCommitCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCommitCallback` into a `C_TerminalCommitCallback`.
wrap_TerminalCommitCallback ::
    TerminalCommitCallback ->
    C_TerminalCommitCallback
wrap_TerminalCommitCallback :: TerminalCommitCallback -> C_TerminalCommitCallback
wrap_TerminalCommitCallback _cb :: TerminalCommitCallback
_cb _ text :: CString
text size :: Word32
size _ = do
    Text
text' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
text
    TerminalCommitCallback
_cb  Text
text' Word32
size


-- | Connect a signal handler for the [commit](#signal:commit) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #commit callback
-- @
-- 
-- 
onTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
onTerminalCommit :: a -> TerminalCommitCallback -> m SignalHandlerId
onTerminalCommit obj :: a
obj cb :: TerminalCommitCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCommitCallback
cb' = TerminalCommitCallback -> C_TerminalCommitCallback
wrap_TerminalCommitCallback TerminalCommitCallback
cb
    FunPtr C_TerminalCommitCallback
cb'' <- C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)
mk_TerminalCommitCallback C_TerminalCommitCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCommitCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "commit" FunPtr C_TerminalCommitCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [commit](#signal:commit) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #commit callback
-- @
-- 
-- 
afterTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
afterTerminalCommit :: a -> TerminalCommitCallback -> m SignalHandlerId
afterTerminalCommit obj :: a
obj cb :: TerminalCommitCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCommitCallback
cb' = TerminalCommitCallback -> C_TerminalCommitCallback
wrap_TerminalCommitCallback TerminalCommitCallback
cb
    FunPtr C_TerminalCommitCallback
cb'' <- C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)
mk_TerminalCommitCallback C_TerminalCommitCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCommitCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "commit" FunPtr C_TerminalCommitCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCommitSignalInfo
instance SignalInfo TerminalCommitSignalInfo where
    type HaskellCallbackType TerminalCommitSignalInfo = TerminalCommitCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCommitCallback cb
        cb'' <- mk_TerminalCommitCallback cb'
        connectSignalFunPtr obj "commit" cb'' connectMode detail

#endif

-- signal Terminal::contents-changed
-- | Emitted whenever the visible appearance of the terminal has changed.
-- Used primarily by @/VteTerminalAccessible/@.
type TerminalContentsChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalContentsChangedCallback`@.
noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback
noTerminalContentsChangedCallback :: Maybe (IO ())
noTerminalContentsChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalContentsChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalContentsChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalContentsChangedCallback :: C_TerminalContentsChangedCallback -> IO (FunPtr C_TerminalContentsChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalContentsChanged :: MonadIO m => TerminalContentsChangedCallback -> m (GClosure C_TerminalContentsChangedCallback)
genClosure_TerminalContentsChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalContentsChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalContentsChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalContentsChangedCallback` into a `C_TerminalContentsChangedCallback`.
wrap_TerminalContentsChangedCallback ::
    TerminalContentsChangedCallback ->
    C_TerminalContentsChangedCallback
wrap_TerminalContentsChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [contentsChanged](#signal:contentsChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #contentsChanged callback
-- @
-- 
-- 
onTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
onTerminalContentsChanged :: a -> IO () -> m SignalHandlerId
onTerminalContentsChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalContentsChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "contents-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [contentsChanged](#signal:contentsChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #contentsChanged callback
-- @
-- 
-- 
afterTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
afterTerminalContentsChanged :: a -> IO () -> m SignalHandlerId
afterTerminalContentsChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalContentsChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "contents-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalContentsChangedSignalInfo
instance SignalInfo TerminalContentsChangedSignalInfo where
    type HaskellCallbackType TerminalContentsChangedSignalInfo = TerminalContentsChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalContentsChangedCallback cb
        cb'' <- mk_TerminalContentsChangedCallback cb'
        connectSignalFunPtr obj "contents-changed" cb'' connectMode detail

#endif

-- signal Terminal::copy-clipboard
-- | Emitted whenever 'GI.Vte.Objects.Terminal.terminalCopyClipboard' is called.
type TerminalCopyClipboardCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCopyClipboardCallback`@.
noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback
noTerminalCopyClipboardCallback :: Maybe (IO ())
noTerminalCopyClipboardCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCopyClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCopyClipboardCallback`.
foreign import ccall "wrapper"
    mk_TerminalCopyClipboardCallback :: C_TerminalCopyClipboardCallback -> IO (FunPtr C_TerminalCopyClipboardCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCopyClipboard :: MonadIO m => TerminalCopyClipboardCallback -> m (GClosure C_TerminalCopyClipboardCallback)
genClosure_TerminalCopyClipboard :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCopyClipboard cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCopyClipboardCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCopyClipboardCallback` into a `C_TerminalCopyClipboardCallback`.
wrap_TerminalCopyClipboardCallback ::
    TerminalCopyClipboardCallback ->
    C_TerminalCopyClipboardCallback
wrap_TerminalCopyClipboardCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [copyClipboard](#signal:copyClipboard) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #copyClipboard callback
-- @
-- 
-- 
onTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
onTerminalCopyClipboard :: a -> IO () -> m SignalHandlerId
onTerminalCopyClipboard obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCopyClipboardCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "copy-clipboard" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [copyClipboard](#signal:copyClipboard) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #copyClipboard callback
-- @
-- 
-- 
afterTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
afterTerminalCopyClipboard :: a -> IO () -> m SignalHandlerId
afterTerminalCopyClipboard obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCopyClipboardCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "copy-clipboard" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCopyClipboardSignalInfo
instance SignalInfo TerminalCopyClipboardSignalInfo where
    type HaskellCallbackType TerminalCopyClipboardSignalInfo = TerminalCopyClipboardCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCopyClipboardCallback cb
        cb'' <- mk_TerminalCopyClipboardCallback cb'
        connectSignalFunPtr obj "copy-clipboard" cb'' connectMode detail

#endif

-- signal Terminal::current-directory-uri-changed
-- | Emitted when the current directory URI is modified.
type TerminalCurrentDirectoryUriChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentDirectoryUriChangedCallback`@.
noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback
noTerminalCurrentDirectoryUriChangedCallback :: Maybe (IO ())
noTerminalCurrentDirectoryUriChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCurrentDirectoryUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentDirectoryUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCurrentDirectoryUriChangedCallback :: C_TerminalCurrentDirectoryUriChangedCallback -> IO (FunPtr C_TerminalCurrentDirectoryUriChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCurrentDirectoryUriChanged :: MonadIO m => TerminalCurrentDirectoryUriChangedCallback -> m (GClosure C_TerminalCurrentDirectoryUriChangedCallback)
genClosure_TerminalCurrentDirectoryUriChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCurrentDirectoryUriChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentDirectoryUriChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCurrentDirectoryUriChangedCallback` into a `C_TerminalCurrentDirectoryUriChangedCallback`.
wrap_TerminalCurrentDirectoryUriChangedCallback ::
    TerminalCurrentDirectoryUriChangedCallback ->
    C_TerminalCurrentDirectoryUriChangedCallback
wrap_TerminalCurrentDirectoryUriChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [currentDirectoryUriChanged](#signal:currentDirectoryUriChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #currentDirectoryUriChanged callback
-- @
-- 
-- 
onTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged :: a -> IO () -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentDirectoryUriChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "current-directory-uri-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [currentDirectoryUriChanged](#signal:currentDirectoryUriChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #currentDirectoryUriChanged callback
-- @
-- 
-- 
afterTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged :: a -> IO () -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentDirectoryUriChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "current-directory-uri-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCurrentDirectoryUriChangedSignalInfo
instance SignalInfo TerminalCurrentDirectoryUriChangedSignalInfo where
    type HaskellCallbackType TerminalCurrentDirectoryUriChangedSignalInfo = TerminalCurrentDirectoryUriChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
        cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'
        connectSignalFunPtr obj "current-directory-uri-changed" cb'' connectMode detail

#endif

-- signal Terminal::current-file-uri-changed
-- | Emitted when the current file URI is modified.
type TerminalCurrentFileUriChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentFileUriChangedCallback`@.
noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback
noTerminalCurrentFileUriChangedCallback :: Maybe (IO ())
noTerminalCurrentFileUriChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCurrentFileUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentFileUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCurrentFileUriChangedCallback :: C_TerminalCurrentFileUriChangedCallback -> IO (FunPtr C_TerminalCurrentFileUriChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCurrentFileUriChanged :: MonadIO m => TerminalCurrentFileUriChangedCallback -> m (GClosure C_TerminalCurrentFileUriChangedCallback)
genClosure_TerminalCurrentFileUriChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCurrentFileUriChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentFileUriChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCurrentFileUriChangedCallback` into a `C_TerminalCurrentFileUriChangedCallback`.
wrap_TerminalCurrentFileUriChangedCallback ::
    TerminalCurrentFileUriChangedCallback ->
    C_TerminalCurrentFileUriChangedCallback
wrap_TerminalCurrentFileUriChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [currentFileUriChanged](#signal:currentFileUriChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #currentFileUriChanged callback
-- @
-- 
-- 
onTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
onTerminalCurrentFileUriChanged :: a -> IO () -> m SignalHandlerId
onTerminalCurrentFileUriChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentFileUriChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "current-file-uri-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [currentFileUriChanged](#signal:currentFileUriChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #currentFileUriChanged callback
-- @
-- 
-- 
afterTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentFileUriChanged :: a -> IO () -> m SignalHandlerId
afterTerminalCurrentFileUriChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentFileUriChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "current-file-uri-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCurrentFileUriChangedSignalInfo
instance SignalInfo TerminalCurrentFileUriChangedSignalInfo where
    type HaskellCallbackType TerminalCurrentFileUriChangedSignalInfo = TerminalCurrentFileUriChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
        cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'
        connectSignalFunPtr obj "current-file-uri-changed" cb'' connectMode detail

#endif

-- signal Terminal::cursor-moved
-- | Emitted whenever the cursor moves to a new character cell.  Used
-- primarily by @/VteTerminalAccessible/@.
type TerminalCursorMovedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCursorMovedCallback`@.
noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback
noTerminalCursorMovedCallback :: Maybe (IO ())
noTerminalCursorMovedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCursorMovedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCursorMovedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCursorMovedCallback :: C_TerminalCursorMovedCallback -> IO (FunPtr C_TerminalCursorMovedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalCursorMoved :: MonadIO m => TerminalCursorMovedCallback -> m (GClosure C_TerminalCursorMovedCallback)
genClosure_TerminalCursorMoved :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCursorMoved cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCursorMovedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalCursorMovedCallback` into a `C_TerminalCursorMovedCallback`.
wrap_TerminalCursorMovedCallback ::
    TerminalCursorMovedCallback ->
    C_TerminalCursorMovedCallback
wrap_TerminalCursorMovedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cursorMoved](#signal:cursorMoved) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #cursorMoved callback
-- @
-- 
-- 
onTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
onTerminalCursorMoved :: a -> IO () -> m SignalHandlerId
onTerminalCursorMoved obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCursorMovedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "cursor-moved" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorMoved](#signal:cursorMoved) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #cursorMoved callback
-- @
-- 
-- 
afterTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
afterTerminalCursorMoved :: a -> IO () -> m SignalHandlerId
afterTerminalCursorMoved obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCursorMovedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "cursor-moved" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalCursorMovedSignalInfo
instance SignalInfo TerminalCursorMovedSignalInfo where
    type HaskellCallbackType TerminalCursorMovedSignalInfo = TerminalCursorMovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalCursorMovedCallback cb
        cb'' <- mk_TerminalCursorMovedCallback cb'
        connectSignalFunPtr obj "cursor-moved" cb'' connectMode detail

#endif

-- signal Terminal::decrease-font-size
-- | Emitted when the user hits the \'-\' key while holding the Control key.
type TerminalDecreaseFontSizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDecreaseFontSizeCallback`@.
noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback
noTerminalDecreaseFontSizeCallback :: Maybe (IO ())
noTerminalDecreaseFontSizeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalDecreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalDecreaseFontSizeCallback`.
foreign import ccall "wrapper"
    mk_TerminalDecreaseFontSizeCallback :: C_TerminalDecreaseFontSizeCallback -> IO (FunPtr C_TerminalDecreaseFontSizeCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalDecreaseFontSize :: MonadIO m => TerminalDecreaseFontSizeCallback -> m (GClosure C_TerminalDecreaseFontSizeCallback)
genClosure_TerminalDecreaseFontSize :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalDecreaseFontSize cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDecreaseFontSizeCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalDecreaseFontSizeCallback` into a `C_TerminalDecreaseFontSizeCallback`.
wrap_TerminalDecreaseFontSizeCallback ::
    TerminalDecreaseFontSizeCallback ->
    C_TerminalDecreaseFontSizeCallback
wrap_TerminalDecreaseFontSizeCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [decreaseFontSize](#signal:decreaseFontSize) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #decreaseFontSize callback
-- @
-- 
-- 
onTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
onTerminalDecreaseFontSize :: a -> IO () -> m SignalHandlerId
onTerminalDecreaseFontSize obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDecreaseFontSizeCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "decrease-font-size" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [decreaseFontSize](#signal:decreaseFontSize) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #decreaseFontSize callback
-- @
-- 
-- 
afterTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
afterTerminalDecreaseFontSize :: a -> IO () -> m SignalHandlerId
afterTerminalDecreaseFontSize obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDecreaseFontSizeCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "decrease-font-size" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalDecreaseFontSizeSignalInfo
instance SignalInfo TerminalDecreaseFontSizeSignalInfo where
    type HaskellCallbackType TerminalDecreaseFontSizeSignalInfo = TerminalDecreaseFontSizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalDecreaseFontSizeCallback cb
        cb'' <- mk_TerminalDecreaseFontSizeCallback cb'
        connectSignalFunPtr obj "decrease-font-size" cb'' connectMode detail

#endif

-- signal Terminal::deiconify-window
-- | Emitted at the child application\'s request.
type TerminalDeiconifyWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDeiconifyWindowCallback`@.
noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback
noTerminalDeiconifyWindowCallback :: Maybe (IO ())
noTerminalDeiconifyWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalDeiconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalDeiconifyWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalDeiconifyWindowCallback :: C_TerminalDeiconifyWindowCallback -> IO (FunPtr C_TerminalDeiconifyWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalDeiconifyWindow :: MonadIO m => TerminalDeiconifyWindowCallback -> m (GClosure C_TerminalDeiconifyWindowCallback)
genClosure_TerminalDeiconifyWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalDeiconifyWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDeiconifyWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalDeiconifyWindowCallback` into a `C_TerminalDeiconifyWindowCallback`.
wrap_TerminalDeiconifyWindowCallback ::
    TerminalDeiconifyWindowCallback ->
    C_TerminalDeiconifyWindowCallback
wrap_TerminalDeiconifyWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [deiconifyWindow](#signal:deiconifyWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #deiconifyWindow callback
-- @
-- 
-- 
onTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
onTerminalDeiconifyWindow :: a -> IO () -> m SignalHandlerId
onTerminalDeiconifyWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDeiconifyWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "deiconify-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [deiconifyWindow](#signal:deiconifyWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #deiconifyWindow callback
-- @
-- 
-- 
afterTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
afterTerminalDeiconifyWindow :: a -> IO () -> m SignalHandlerId
afterTerminalDeiconifyWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDeiconifyWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "deiconify-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalDeiconifyWindowSignalInfo
instance SignalInfo TerminalDeiconifyWindowSignalInfo where
    type HaskellCallbackType TerminalDeiconifyWindowSignalInfo = TerminalDeiconifyWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalDeiconifyWindowCallback cb
        cb'' <- mk_TerminalDeiconifyWindowCallback cb'
        connectSignalFunPtr obj "deiconify-window" cb'' connectMode detail

#endif

-- signal Terminal::encoding-changed
-- | Emitted whenever the terminal\'s current encoding has changed.
-- 
-- Note: support for non-UTF-8 is deprecated.
type TerminalEncodingChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEncodingChangedCallback`@.
noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback
noTerminalEncodingChangedCallback :: Maybe (IO ())
noTerminalEncodingChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalEncodingChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalEncodingChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalEncodingChangedCallback :: C_TerminalEncodingChangedCallback -> IO (FunPtr C_TerminalEncodingChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalEncodingChanged :: MonadIO m => TerminalEncodingChangedCallback -> m (GClosure C_TerminalEncodingChangedCallback)
genClosure_TerminalEncodingChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalEncodingChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEncodingChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalEncodingChangedCallback` into a `C_TerminalEncodingChangedCallback`.
wrap_TerminalEncodingChangedCallback ::
    TerminalEncodingChangedCallback ->
    C_TerminalEncodingChangedCallback
wrap_TerminalEncodingChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [encodingChanged](#signal:encodingChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #encodingChanged callback
-- @
-- 
-- 
onTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
onTerminalEncodingChanged :: a -> IO () -> m SignalHandlerId
onTerminalEncodingChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEncodingChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "encoding-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [encodingChanged](#signal:encodingChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #encodingChanged callback
-- @
-- 
-- 
afterTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
afterTerminalEncodingChanged :: a -> IO () -> m SignalHandlerId
afterTerminalEncodingChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEncodingChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "encoding-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalEncodingChangedSignalInfo
instance SignalInfo TerminalEncodingChangedSignalInfo where
    type HaskellCallbackType TerminalEncodingChangedSignalInfo = TerminalEncodingChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalEncodingChangedCallback cb
        cb'' <- mk_TerminalEncodingChangedCallback cb'
        connectSignalFunPtr obj "encoding-changed" cb'' connectMode detail

#endif

-- signal Terminal::eof
-- | Emitted when the terminal receives an end-of-file from a child which
-- is running in the terminal.  This signal is frequently (but not
-- always) emitted with a [childExited]("GI.Vte.Objects.Terminal#signal:childExited") signal.
type TerminalEofCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEofCallback`@.
noTerminalEofCallback :: Maybe TerminalEofCallback
noTerminalEofCallback :: Maybe (IO ())
noTerminalEofCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalEofCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalEofCallback`.
foreign import ccall "wrapper"
    mk_TerminalEofCallback :: C_TerminalEofCallback -> IO (FunPtr C_TerminalEofCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalEof :: MonadIO m => TerminalEofCallback -> m (GClosure C_TerminalEofCallback)
genClosure_TerminalEof :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalEof cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEofCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEofCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalEofCallback` into a `C_TerminalEofCallback`.
wrap_TerminalEofCallback ::
    TerminalEofCallback ->
    C_TerminalEofCallback
wrap_TerminalEofCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalEofCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [eof](#signal:eof) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #eof callback
-- @
-- 
-- 
onTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
onTerminalEof :: a -> IO () -> m SignalHandlerId
onTerminalEof obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEofCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEofCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "eof" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [eof](#signal:eof) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #eof callback
-- @
-- 
-- 
afterTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
afterTerminalEof :: a -> IO () -> m SignalHandlerId
afterTerminalEof obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalEofCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEofCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "eof" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalEofSignalInfo
instance SignalInfo TerminalEofSignalInfo where
    type HaskellCallbackType TerminalEofSignalInfo = TerminalEofCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalEofCallback cb
        cb'' <- mk_TerminalEofCallback cb'
        connectSignalFunPtr obj "eof" cb'' connectMode detail

#endif

-- signal Terminal::hyperlink-hover-uri-changed
-- | Emitted when the hovered hyperlink changes.
-- 
-- /@uri@/ and /@bbox@/ are owned by VTE, must not be modified, and might
-- change after the signal handlers returns.
-- 
-- The signal is not re-emitted when the bounding box changes for the
-- same hyperlink. This might change in a future VTE version without notice.
-- 
-- /Since: 0.50/
type TerminalHyperlinkHoverUriChangedCallback =
    T.Text
    -- ^ /@uri@/: the nonempty target URI under the mouse, or NULL
    -> Gdk.Rectangle.Rectangle
    -- ^ /@bbox@/: the bounding box of the hyperlink anchor text, or NULL
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalHyperlinkHoverUriChangedCallback`@.
noTerminalHyperlinkHoverUriChangedCallback :: Maybe TerminalHyperlinkHoverUriChangedCallback
noTerminalHyperlinkHoverUriChangedCallback :: Maybe TerminalHyperlinkHoverUriChangedCallback
noTerminalHyperlinkHoverUriChangedCallback = Maybe TerminalHyperlinkHoverUriChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalHyperlinkHoverUriChangedCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalHyperlinkHoverUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalHyperlinkHoverUriChangedCallback :: C_TerminalHyperlinkHoverUriChangedCallback -> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalHyperlinkHoverUriChanged :: MonadIO m => TerminalHyperlinkHoverUriChangedCallback -> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
genClosure_TerminalHyperlinkHoverUriChanged :: TerminalHyperlinkHoverUriChangedCallback
-> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
genClosure_TerminalHyperlinkHoverUriChanged cb :: TerminalHyperlinkHoverUriChangedCallback
cb = IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
-> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
 -> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback))
-> IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
-> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalHyperlinkHoverUriChangedCallback
cb' = TerminalHyperlinkHoverUriChangedCallback
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback TerminalHyperlinkHoverUriChangedCallback
cb
    C_TerminalHyperlinkHoverUriChangedCallback
-> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
mk_TerminalHyperlinkHoverUriChangedCallback C_TerminalHyperlinkHoverUriChangedCallback
cb' IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
-> (FunPtr C_TerminalHyperlinkHoverUriChangedCallback
    -> IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback))
-> IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalHyperlinkHoverUriChangedCallback
-> IO (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalHyperlinkHoverUriChangedCallback` into a `C_TerminalHyperlinkHoverUriChangedCallback`.
wrap_TerminalHyperlinkHoverUriChangedCallback ::
    TerminalHyperlinkHoverUriChangedCallback ->
    C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback :: TerminalHyperlinkHoverUriChangedCallback
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback _cb :: TerminalHyperlinkHoverUriChangedCallback
_cb _ uri :: CString
uri bbox :: Ptr Rectangle
bbox _ = do
    Text
uri' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
uri
    (ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> (Rectangle -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle Ptr Rectangle
bbox ((Rectangle -> IO ()) -> IO ()) -> (Rectangle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \bbox' :: Rectangle
bbox' -> do
        TerminalHyperlinkHoverUriChangedCallback
_cb  Text
uri' Rectangle
bbox'


-- | Connect a signal handler for the [hyperlinkHoverUriChanged](#signal:hyperlinkHoverUriChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #hyperlinkHoverUriChanged callback
-- @
-- 
-- 
onTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged :: a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged obj :: a
obj cb :: TerminalHyperlinkHoverUriChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalHyperlinkHoverUriChangedCallback
cb' = TerminalHyperlinkHoverUriChangedCallback
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback TerminalHyperlinkHoverUriChangedCallback
cb
    FunPtr C_TerminalHyperlinkHoverUriChangedCallback
cb'' <- C_TerminalHyperlinkHoverUriChangedCallback
-> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
mk_TerminalHyperlinkHoverUriChangedCallback C_TerminalHyperlinkHoverUriChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalHyperlinkHoverUriChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "hyperlink-hover-uri-changed" FunPtr C_TerminalHyperlinkHoverUriChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hyperlinkHoverUriChanged](#signal:hyperlinkHoverUriChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #hyperlinkHoverUriChanged callback
-- @
-- 
-- 
afterTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged :: a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged obj :: a
obj cb :: TerminalHyperlinkHoverUriChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalHyperlinkHoverUriChangedCallback
cb' = TerminalHyperlinkHoverUriChangedCallback
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback TerminalHyperlinkHoverUriChangedCallback
cb
    FunPtr C_TerminalHyperlinkHoverUriChangedCallback
cb'' <- C_TerminalHyperlinkHoverUriChangedCallback
-> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
mk_TerminalHyperlinkHoverUriChangedCallback C_TerminalHyperlinkHoverUriChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalHyperlinkHoverUriChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "hyperlink-hover-uri-changed" FunPtr C_TerminalHyperlinkHoverUriChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalHyperlinkHoverUriChangedSignalInfo
instance SignalInfo TerminalHyperlinkHoverUriChangedSignalInfo where
    type HaskellCallbackType TerminalHyperlinkHoverUriChangedSignalInfo = TerminalHyperlinkHoverUriChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb
        cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'
        connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' connectMode detail

#endif

-- signal Terminal::icon-title-changed
{-# DEPRECATED TerminalIconTitleChangedCallback ["(Since version 0.54)","This signal is never emitted."] #-}
-- | /No description available in the introspection data./
type TerminalIconTitleChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconTitleChangedCallback`@.
noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback
noTerminalIconTitleChangedCallback :: Maybe (IO ())
noTerminalIconTitleChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIconTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIconTitleChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalIconTitleChangedCallback :: C_TerminalIconTitleChangedCallback -> IO (FunPtr C_TerminalIconTitleChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalIconTitleChanged :: MonadIO m => TerminalIconTitleChangedCallback -> m (GClosure C_TerminalIconTitleChangedCallback)
genClosure_TerminalIconTitleChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIconTitleChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconTitleChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalIconTitleChangedCallback` into a `C_TerminalIconTitleChangedCallback`.
wrap_TerminalIconTitleChangedCallback ::
    TerminalIconTitleChangedCallback ->
    C_TerminalIconTitleChangedCallback
wrap_TerminalIconTitleChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [iconTitleChanged](#signal:iconTitleChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #iconTitleChanged callback
-- @
-- 
-- 
onTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
onTerminalIconTitleChanged :: a -> IO () -> m SignalHandlerId
onTerminalIconTitleChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconTitleChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "icon-title-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [iconTitleChanged](#signal:iconTitleChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #iconTitleChanged callback
-- @
-- 
-- 
afterTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
afterTerminalIconTitleChanged :: a -> IO () -> m SignalHandlerId
afterTerminalIconTitleChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconTitleChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "icon-title-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalIconTitleChangedSignalInfo
instance SignalInfo TerminalIconTitleChangedSignalInfo where
    type HaskellCallbackType TerminalIconTitleChangedSignalInfo = TerminalIconTitleChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalIconTitleChangedCallback cb
        cb'' <- mk_TerminalIconTitleChangedCallback cb'
        connectSignalFunPtr obj "icon-title-changed" cb'' connectMode detail

#endif

-- signal Terminal::iconify-window
-- | Emitted at the child application\'s request.
type TerminalIconifyWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconifyWindowCallback`@.
noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback
noTerminalIconifyWindowCallback :: Maybe (IO ())
noTerminalIconifyWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIconifyWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalIconifyWindowCallback :: C_TerminalIconifyWindowCallback -> IO (FunPtr C_TerminalIconifyWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalIconifyWindow :: MonadIO m => TerminalIconifyWindowCallback -> m (GClosure C_TerminalIconifyWindowCallback)
genClosure_TerminalIconifyWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIconifyWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconifyWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalIconifyWindowCallback` into a `C_TerminalIconifyWindowCallback`.
wrap_TerminalIconifyWindowCallback ::
    TerminalIconifyWindowCallback ->
    C_TerminalIconifyWindowCallback
wrap_TerminalIconifyWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [iconifyWindow](#signal:iconifyWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #iconifyWindow callback
-- @
-- 
-- 
onTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
onTerminalIconifyWindow :: a -> IO () -> m SignalHandlerId
onTerminalIconifyWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconifyWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "iconify-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [iconifyWindow](#signal:iconifyWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #iconifyWindow callback
-- @
-- 
-- 
afterTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
afterTerminalIconifyWindow :: a -> IO () -> m SignalHandlerId
afterTerminalIconifyWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconifyWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "iconify-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalIconifyWindowSignalInfo
instance SignalInfo TerminalIconifyWindowSignalInfo where
    type HaskellCallbackType TerminalIconifyWindowSignalInfo = TerminalIconifyWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalIconifyWindowCallback cb
        cb'' <- mk_TerminalIconifyWindowCallback cb'
        connectSignalFunPtr obj "iconify-window" cb'' connectMode detail

#endif

-- signal Terminal::increase-font-size
-- | Emitted when the user hits the \'+\' key while holding the Control key.
type TerminalIncreaseFontSizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIncreaseFontSizeCallback`@.
noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback
noTerminalIncreaseFontSizeCallback :: Maybe (IO ())
noTerminalIncreaseFontSizeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIncreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIncreaseFontSizeCallback`.
foreign import ccall "wrapper"
    mk_TerminalIncreaseFontSizeCallback :: C_TerminalIncreaseFontSizeCallback -> IO (FunPtr C_TerminalIncreaseFontSizeCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalIncreaseFontSize :: MonadIO m => TerminalIncreaseFontSizeCallback -> m (GClosure C_TerminalIncreaseFontSizeCallback)
genClosure_TerminalIncreaseFontSize :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIncreaseFontSize cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIncreaseFontSizeCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalIncreaseFontSizeCallback` into a `C_TerminalIncreaseFontSizeCallback`.
wrap_TerminalIncreaseFontSizeCallback ::
    TerminalIncreaseFontSizeCallback ->
    C_TerminalIncreaseFontSizeCallback
wrap_TerminalIncreaseFontSizeCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [increaseFontSize](#signal:increaseFontSize) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #increaseFontSize callback
-- @
-- 
-- 
onTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
onTerminalIncreaseFontSize :: a -> IO () -> m SignalHandlerId
onTerminalIncreaseFontSize obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIncreaseFontSizeCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "increase-font-size" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [increaseFontSize](#signal:increaseFontSize) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #increaseFontSize callback
-- @
-- 
-- 
afterTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
afterTerminalIncreaseFontSize :: a -> IO () -> m SignalHandlerId
afterTerminalIncreaseFontSize obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIncreaseFontSizeCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "increase-font-size" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalIncreaseFontSizeSignalInfo
instance SignalInfo TerminalIncreaseFontSizeSignalInfo where
    type HaskellCallbackType TerminalIncreaseFontSizeSignalInfo = TerminalIncreaseFontSizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalIncreaseFontSizeCallback cb
        cb'' <- mk_TerminalIncreaseFontSizeCallback cb'
        connectSignalFunPtr obj "increase-font-size" cb'' connectMode detail

#endif

-- signal Terminal::lower-window
-- | Emitted at the child application\'s request.
type TerminalLowerWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalLowerWindowCallback`@.
noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback
noTerminalLowerWindowCallback :: Maybe (IO ())
noTerminalLowerWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalLowerWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalLowerWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalLowerWindowCallback :: C_TerminalLowerWindowCallback -> IO (FunPtr C_TerminalLowerWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalLowerWindow :: MonadIO m => TerminalLowerWindowCallback -> m (GClosure C_TerminalLowerWindowCallback)
genClosure_TerminalLowerWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalLowerWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalLowerWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalLowerWindowCallback` into a `C_TerminalLowerWindowCallback`.
wrap_TerminalLowerWindowCallback ::
    TerminalLowerWindowCallback ->
    C_TerminalLowerWindowCallback
wrap_TerminalLowerWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [lowerWindow](#signal:lowerWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #lowerWindow callback
-- @
-- 
-- 
onTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
onTerminalLowerWindow :: a -> IO () -> m SignalHandlerId
onTerminalLowerWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalLowerWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "lower-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [lowerWindow](#signal:lowerWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #lowerWindow callback
-- @
-- 
-- 
afterTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
afterTerminalLowerWindow :: a -> IO () -> m SignalHandlerId
afterTerminalLowerWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalLowerWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "lower-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalLowerWindowSignalInfo
instance SignalInfo TerminalLowerWindowSignalInfo where
    type HaskellCallbackType TerminalLowerWindowSignalInfo = TerminalLowerWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalLowerWindowCallback cb
        cb'' <- mk_TerminalLowerWindowCallback cb'
        connectSignalFunPtr obj "lower-window" cb'' connectMode detail

#endif

-- signal Terminal::maximize-window
-- | Emitted at the child application\'s request.
type TerminalMaximizeWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMaximizeWindowCallback`@.
noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback
noTerminalMaximizeWindowCallback :: Maybe (IO ())
noTerminalMaximizeWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalMaximizeWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalMaximizeWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalMaximizeWindowCallback :: C_TerminalMaximizeWindowCallback -> IO (FunPtr C_TerminalMaximizeWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalMaximizeWindow :: MonadIO m => TerminalMaximizeWindowCallback -> m (GClosure C_TerminalMaximizeWindowCallback)
genClosure_TerminalMaximizeWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalMaximizeWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalMaximizeWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalMaximizeWindowCallback` into a `C_TerminalMaximizeWindowCallback`.
wrap_TerminalMaximizeWindowCallback ::
    TerminalMaximizeWindowCallback ->
    C_TerminalMaximizeWindowCallback
wrap_TerminalMaximizeWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [maximizeWindow](#signal:maximizeWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #maximizeWindow callback
-- @
-- 
-- 
onTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
onTerminalMaximizeWindow :: a -> IO () -> m SignalHandlerId
onTerminalMaximizeWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalMaximizeWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "maximize-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [maximizeWindow](#signal:maximizeWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #maximizeWindow callback
-- @
-- 
-- 
afterTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
afterTerminalMaximizeWindow :: a -> IO () -> m SignalHandlerId
afterTerminalMaximizeWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalMaximizeWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "maximize-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalMaximizeWindowSignalInfo
instance SignalInfo TerminalMaximizeWindowSignalInfo where
    type HaskellCallbackType TerminalMaximizeWindowSignalInfo = TerminalMaximizeWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalMaximizeWindowCallback cb
        cb'' <- mk_TerminalMaximizeWindowCallback cb'
        connectSignalFunPtr obj "maximize-window" cb'' connectMode detail

#endif

-- signal Terminal::move-window
-- | Emitted at the child application\'s request.
type TerminalMoveWindowCallback =
    Word32
    -- ^ /@x@/: the terminal\'s desired location, X coordinate
    -> Word32
    -- ^ /@y@/: the terminal\'s desired location, Y coordinate
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMoveWindowCallback`@.
noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback
noTerminalMoveWindowCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalMoveWindowCallback = Maybe TerminalCharSizeChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalMoveWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalMoveWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalMoveWindowCallback :: C_TerminalMoveWindowCallback -> IO (FunPtr C_TerminalMoveWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalMoveWindow :: MonadIO m => TerminalMoveWindowCallback -> m (GClosure C_TerminalMoveWindowCallback)
genClosure_TerminalMoveWindow :: TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalMoveWindow cb :: TerminalCharSizeChangedCallback
cb = IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalCharSizeChangedCallback)
 -> m (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback TerminalCharSizeChangedCallback
cb
    C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalMoveWindowCallback C_TerminalCharSizeChangedCallback
cb' IO (FunPtr C_TerminalCharSizeChangedCallback)
-> (FunPtr C_TerminalCharSizeChangedCallback
    -> IO (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalCharSizeChangedCallback
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalMoveWindowCallback` into a `C_TerminalMoveWindowCallback`.
wrap_TerminalMoveWindowCallback ::
    TerminalMoveWindowCallback ->
    C_TerminalMoveWindowCallback
wrap_TerminalMoveWindowCallback :: TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback _cb :: TerminalCharSizeChangedCallback
_cb _ x :: Word32
x y :: Word32
y _ = do
    TerminalCharSizeChangedCallback
_cb  Word32
x Word32
y


-- | Connect a signal handler for the [moveWindow](#signal:moveWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #moveWindow callback
-- @
-- 
-- 
onTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
onTerminalMoveWindow :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalMoveWindow obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalMoveWindowCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "move-window" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [moveWindow](#signal:moveWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #moveWindow callback
-- @
-- 
-- 
afterTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
afterTerminalMoveWindow :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalMoveWindow obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalMoveWindowCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "move-window" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalMoveWindowSignalInfo
instance SignalInfo TerminalMoveWindowSignalInfo where
    type HaskellCallbackType TerminalMoveWindowSignalInfo = TerminalMoveWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalMoveWindowCallback cb
        cb'' <- mk_TerminalMoveWindowCallback cb'
        connectSignalFunPtr obj "move-window" cb'' connectMode detail

#endif

-- signal Terminal::notification-received
-- | Emitted when a process running in the terminal wants to
-- send a notification to the desktop environment.
type TerminalNotificationReceivedCallback =
    T.Text
    -- ^ /@summary@/: The summary
    -> Maybe T.Text
    -- ^ /@body@/: Extra optional text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalNotificationReceivedCallback`@.
noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback
noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback
noTerminalNotificationReceivedCallback = Maybe TerminalNotificationReceivedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalNotificationReceivedCallback =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalNotificationReceivedCallback`.
foreign import ccall "wrapper"
    mk_TerminalNotificationReceivedCallback :: C_TerminalNotificationReceivedCallback -> IO (FunPtr C_TerminalNotificationReceivedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalNotificationReceived :: MonadIO m => TerminalNotificationReceivedCallback -> m (GClosure C_TerminalNotificationReceivedCallback)
genClosure_TerminalNotificationReceived :: TerminalNotificationReceivedCallback
-> m (GClosure C_TerminalNotificationReceivedCallback)
genClosure_TerminalNotificationReceived cb :: TerminalNotificationReceivedCallback
cb = IO (GClosure C_TerminalNotificationReceivedCallback)
-> m (GClosure C_TerminalNotificationReceivedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalNotificationReceivedCallback)
 -> m (GClosure C_TerminalNotificationReceivedCallback))
-> IO (GClosure C_TerminalNotificationReceivedCallback)
-> m (GClosure C_TerminalNotificationReceivedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalNotificationReceivedCallback
cb' = TerminalNotificationReceivedCallback
-> C_TerminalNotificationReceivedCallback
wrap_TerminalNotificationReceivedCallback TerminalNotificationReceivedCallback
cb
    C_TerminalNotificationReceivedCallback
-> IO (FunPtr C_TerminalNotificationReceivedCallback)
mk_TerminalNotificationReceivedCallback C_TerminalNotificationReceivedCallback
cb' IO (FunPtr C_TerminalNotificationReceivedCallback)
-> (FunPtr C_TerminalNotificationReceivedCallback
    -> IO (GClosure C_TerminalNotificationReceivedCallback))
-> IO (GClosure C_TerminalNotificationReceivedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalNotificationReceivedCallback
-> IO (GClosure C_TerminalNotificationReceivedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalNotificationReceivedCallback` into a `C_TerminalNotificationReceivedCallback`.
wrap_TerminalNotificationReceivedCallback ::
    TerminalNotificationReceivedCallback ->
    C_TerminalNotificationReceivedCallback
wrap_TerminalNotificationReceivedCallback :: TerminalNotificationReceivedCallback
-> C_TerminalNotificationReceivedCallback
wrap_TerminalNotificationReceivedCallback _cb :: TerminalNotificationReceivedCallback
_cb _ summary :: CString
summary body :: CString
body _ = do
    Text
summary' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
summary
    Maybe Text
maybeBody <-
        if CString
body CString -> CString -> Bool
forall a. Eq a => a -> a -> Bool
== CString
forall a. Ptr a
nullPtr
        then Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
        else do
            Text
body' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
body
            Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text -> IO (Maybe Text)) -> Maybe Text -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
body'
    TerminalNotificationReceivedCallback
_cb  Text
summary' Maybe Text
maybeBody


-- | Connect a signal handler for the [notificationReceived](#signal:notificationReceived) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #notificationReceived callback
-- @
-- 
-- 
onTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
onTerminalNotificationReceived :: a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
onTerminalNotificationReceived obj :: a
obj cb :: TerminalNotificationReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalNotificationReceivedCallback
cb' = TerminalNotificationReceivedCallback
-> C_TerminalNotificationReceivedCallback
wrap_TerminalNotificationReceivedCallback TerminalNotificationReceivedCallback
cb
    FunPtr C_TerminalNotificationReceivedCallback
cb'' <- C_TerminalNotificationReceivedCallback
-> IO (FunPtr C_TerminalNotificationReceivedCallback)
mk_TerminalNotificationReceivedCallback C_TerminalNotificationReceivedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalNotificationReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "notification-received" FunPtr C_TerminalNotificationReceivedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [notificationReceived](#signal:notificationReceived) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #notificationReceived callback
-- @
-- 
-- 
afterTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
afterTerminalNotificationReceived :: a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
afterTerminalNotificationReceived obj :: a
obj cb :: TerminalNotificationReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalNotificationReceivedCallback
cb' = TerminalNotificationReceivedCallback
-> C_TerminalNotificationReceivedCallback
wrap_TerminalNotificationReceivedCallback TerminalNotificationReceivedCallback
cb
    FunPtr C_TerminalNotificationReceivedCallback
cb'' <- C_TerminalNotificationReceivedCallback
-> IO (FunPtr C_TerminalNotificationReceivedCallback)
mk_TerminalNotificationReceivedCallback C_TerminalNotificationReceivedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalNotificationReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "notification-received" FunPtr C_TerminalNotificationReceivedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalNotificationReceivedSignalInfo
instance SignalInfo TerminalNotificationReceivedSignalInfo where
    type HaskellCallbackType TerminalNotificationReceivedSignalInfo = TerminalNotificationReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalNotificationReceivedCallback cb
        cb'' <- mk_TerminalNotificationReceivedCallback cb'
        connectSignalFunPtr obj "notification-received" cb'' connectMode detail

#endif

-- signal Terminal::paste-clipboard
-- | Emitted whenever 'GI.Vte.Objects.Terminal.terminalPasteClipboard' is called.
type TerminalPasteClipboardCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalPasteClipboardCallback`@.
noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback
noTerminalPasteClipboardCallback :: Maybe (IO ())
noTerminalPasteClipboardCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalPasteClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalPasteClipboardCallback`.
foreign import ccall "wrapper"
    mk_TerminalPasteClipboardCallback :: C_TerminalPasteClipboardCallback -> IO (FunPtr C_TerminalPasteClipboardCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalPasteClipboard :: MonadIO m => TerminalPasteClipboardCallback -> m (GClosure C_TerminalPasteClipboardCallback)
genClosure_TerminalPasteClipboard :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalPasteClipboard cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalPasteClipboardCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalPasteClipboardCallback` into a `C_TerminalPasteClipboardCallback`.
wrap_TerminalPasteClipboardCallback ::
    TerminalPasteClipboardCallback ->
    C_TerminalPasteClipboardCallback
wrap_TerminalPasteClipboardCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [pasteClipboard](#signal:pasteClipboard) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #pasteClipboard callback
-- @
-- 
-- 
onTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
onTerminalPasteClipboard :: a -> IO () -> m SignalHandlerId
onTerminalPasteClipboard obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalPasteClipboardCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "paste-clipboard" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pasteClipboard](#signal:pasteClipboard) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #pasteClipboard callback
-- @
-- 
-- 
afterTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
afterTerminalPasteClipboard :: a -> IO () -> m SignalHandlerId
afterTerminalPasteClipboard obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalPasteClipboardCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "paste-clipboard" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalPasteClipboardSignalInfo
instance SignalInfo TerminalPasteClipboardSignalInfo where
    type HaskellCallbackType TerminalPasteClipboardSignalInfo = TerminalPasteClipboardCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalPasteClipboardCallback cb
        cb'' <- mk_TerminalPasteClipboardCallback cb'
        connectSignalFunPtr obj "paste-clipboard" cb'' connectMode detail

#endif

-- signal Terminal::raise-window
-- | Emitted at the child application\'s request.
type TerminalRaiseWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRaiseWindowCallback`@.
noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback
noTerminalRaiseWindowCallback :: Maybe (IO ())
noTerminalRaiseWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRaiseWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRaiseWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRaiseWindowCallback :: C_TerminalRaiseWindowCallback -> IO (FunPtr C_TerminalRaiseWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalRaiseWindow :: MonadIO m => TerminalRaiseWindowCallback -> m (GClosure C_TerminalRaiseWindowCallback)
genClosure_TerminalRaiseWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRaiseWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRaiseWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalRaiseWindowCallback` into a `C_TerminalRaiseWindowCallback`.
wrap_TerminalRaiseWindowCallback ::
    TerminalRaiseWindowCallback ->
    C_TerminalRaiseWindowCallback
wrap_TerminalRaiseWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [raiseWindow](#signal:raiseWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #raiseWindow callback
-- @
-- 
-- 
onTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
onTerminalRaiseWindow :: a -> IO () -> m SignalHandlerId
onTerminalRaiseWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRaiseWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "raise-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [raiseWindow](#signal:raiseWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #raiseWindow callback
-- @
-- 
-- 
afterTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
afterTerminalRaiseWindow :: a -> IO () -> m SignalHandlerId
afterTerminalRaiseWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRaiseWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "raise-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRaiseWindowSignalInfo
instance SignalInfo TerminalRaiseWindowSignalInfo where
    type HaskellCallbackType TerminalRaiseWindowSignalInfo = TerminalRaiseWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRaiseWindowCallback cb
        cb'' <- mk_TerminalRaiseWindowCallback cb'
        connectSignalFunPtr obj "raise-window" cb'' connectMode detail

#endif

-- signal Terminal::refresh-window
-- | Emitted at the child application\'s request.
type TerminalRefreshWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRefreshWindowCallback`@.
noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback
noTerminalRefreshWindowCallback :: Maybe (IO ())
noTerminalRefreshWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRefreshWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRefreshWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRefreshWindowCallback :: C_TerminalRefreshWindowCallback -> IO (FunPtr C_TerminalRefreshWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalRefreshWindow :: MonadIO m => TerminalRefreshWindowCallback -> m (GClosure C_TerminalRefreshWindowCallback)
genClosure_TerminalRefreshWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRefreshWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRefreshWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalRefreshWindowCallback` into a `C_TerminalRefreshWindowCallback`.
wrap_TerminalRefreshWindowCallback ::
    TerminalRefreshWindowCallback ->
    C_TerminalRefreshWindowCallback
wrap_TerminalRefreshWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [refreshWindow](#signal:refreshWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #refreshWindow callback
-- @
-- 
-- 
onTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
onTerminalRefreshWindow :: a -> IO () -> m SignalHandlerId
onTerminalRefreshWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRefreshWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "refresh-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [refreshWindow](#signal:refreshWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #refreshWindow callback
-- @
-- 
-- 
afterTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
afterTerminalRefreshWindow :: a -> IO () -> m SignalHandlerId
afterTerminalRefreshWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRefreshWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "refresh-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRefreshWindowSignalInfo
instance SignalInfo TerminalRefreshWindowSignalInfo where
    type HaskellCallbackType TerminalRefreshWindowSignalInfo = TerminalRefreshWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRefreshWindowCallback cb
        cb'' <- mk_TerminalRefreshWindowCallback cb'
        connectSignalFunPtr obj "refresh-window" cb'' connectMode detail

#endif

-- signal Terminal::resize-window
-- | Emitted at the child application\'s request.
type TerminalResizeWindowCallback =
    Word32
    -- ^ /@width@/: the desired number of columns
    -> Word32
    -- ^ /@height@/: the desired number of rows
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalResizeWindowCallback`@.
noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback
noTerminalResizeWindowCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalResizeWindowCallback = Maybe TerminalCharSizeChangedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalResizeWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalResizeWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalResizeWindowCallback :: C_TerminalResizeWindowCallback -> IO (FunPtr C_TerminalResizeWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalResizeWindow :: MonadIO m => TerminalResizeWindowCallback -> m (GClosure C_TerminalResizeWindowCallback)
genClosure_TerminalResizeWindow :: TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalResizeWindow cb :: TerminalCharSizeChangedCallback
cb = IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalCharSizeChangedCallback)
 -> m (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
-> m (GClosure C_TerminalCharSizeChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback TerminalCharSizeChangedCallback
cb
    C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalResizeWindowCallback C_TerminalCharSizeChangedCallback
cb' IO (FunPtr C_TerminalCharSizeChangedCallback)
-> (FunPtr C_TerminalCharSizeChangedCallback
    -> IO (GClosure C_TerminalCharSizeChangedCallback))
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalCharSizeChangedCallback
-> IO (GClosure C_TerminalCharSizeChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalResizeWindowCallback` into a `C_TerminalResizeWindowCallback`.
wrap_TerminalResizeWindowCallback ::
    TerminalResizeWindowCallback ->
    C_TerminalResizeWindowCallback
wrap_TerminalResizeWindowCallback :: TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback _cb :: TerminalCharSizeChangedCallback
_cb _ width :: Word32
width height :: Word32
height _ = do
    TerminalCharSizeChangedCallback
_cb  Word32
width Word32
height


-- | Connect a signal handler for the [resizeWindow](#signal:resizeWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #resizeWindow callback
-- @
-- 
-- 
onTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
onTerminalResizeWindow :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalResizeWindow obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalResizeWindowCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "resize-window" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [resizeWindow](#signal:resizeWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #resizeWindow callback
-- @
-- 
-- 
afterTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
afterTerminalResizeWindow :: a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalResizeWindow obj :: a
obj cb :: TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalCharSizeChangedCallback
cb' = TerminalCharSizeChangedCallback
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback TerminalCharSizeChangedCallback
cb
    FunPtr C_TerminalCharSizeChangedCallback
cb'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalResizeWindowCallback C_TerminalCharSizeChangedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "resize-window" FunPtr C_TerminalCharSizeChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalResizeWindowSignalInfo
instance SignalInfo TerminalResizeWindowSignalInfo where
    type HaskellCallbackType TerminalResizeWindowSignalInfo = TerminalResizeWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalResizeWindowCallback cb
        cb'' <- mk_TerminalResizeWindowCallback cb'
        connectSignalFunPtr obj "resize-window" cb'' connectMode detail

#endif

-- signal Terminal::restore-window
-- | Emitted at the child application\'s request.
type TerminalRestoreWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRestoreWindowCallback`@.
noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback
noTerminalRestoreWindowCallback :: Maybe (IO ())
noTerminalRestoreWindowCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRestoreWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRestoreWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRestoreWindowCallback :: C_TerminalRestoreWindowCallback -> IO (FunPtr C_TerminalRestoreWindowCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalRestoreWindow :: MonadIO m => TerminalRestoreWindowCallback -> m (GClosure C_TerminalRestoreWindowCallback)
genClosure_TerminalRestoreWindow :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRestoreWindow cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRestoreWindowCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalRestoreWindowCallback` into a `C_TerminalRestoreWindowCallback`.
wrap_TerminalRestoreWindowCallback ::
    TerminalRestoreWindowCallback ->
    C_TerminalRestoreWindowCallback
wrap_TerminalRestoreWindowCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [restoreWindow](#signal:restoreWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #restoreWindow callback
-- @
-- 
-- 
onTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
onTerminalRestoreWindow :: a -> IO () -> m SignalHandlerId
onTerminalRestoreWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRestoreWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "restore-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [restoreWindow](#signal:restoreWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #restoreWindow callback
-- @
-- 
-- 
afterTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
afterTerminalRestoreWindow :: a -> IO () -> m SignalHandlerId
afterTerminalRestoreWindow obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRestoreWindowCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "restore-window" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRestoreWindowSignalInfo
instance SignalInfo TerminalRestoreWindowSignalInfo where
    type HaskellCallbackType TerminalRestoreWindowSignalInfo = TerminalRestoreWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRestoreWindowCallback cb
        cb'' <- mk_TerminalRestoreWindowCallback cb'
        connectSignalFunPtr obj "restore-window" cb'' connectMode detail

#endif

-- signal Terminal::selection-changed
-- | Emitted whenever the contents of terminal\'s selection changes.
type TerminalSelectionChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalSelectionChangedCallback`@.
noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback
noTerminalSelectionChangedCallback :: Maybe (IO ())
noTerminalSelectionChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalSelectionChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalSelectionChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalSelectionChangedCallback :: C_TerminalSelectionChangedCallback -> IO (FunPtr C_TerminalSelectionChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalSelectionChanged :: MonadIO m => TerminalSelectionChangedCallback -> m (GClosure C_TerminalSelectionChangedCallback)
genClosure_TerminalSelectionChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalSelectionChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalSelectionChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalSelectionChangedCallback` into a `C_TerminalSelectionChangedCallback`.
wrap_TerminalSelectionChangedCallback ::
    TerminalSelectionChangedCallback ->
    C_TerminalSelectionChangedCallback
wrap_TerminalSelectionChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [selectionChanged](#signal:selectionChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #selectionChanged callback
-- @
-- 
-- 
onTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
onTerminalSelectionChanged :: a -> IO () -> m SignalHandlerId
onTerminalSelectionChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalSelectionChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "selection-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [selectionChanged](#signal:selectionChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #selectionChanged callback
-- @
-- 
-- 
afterTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
afterTerminalSelectionChanged :: a -> IO () -> m SignalHandlerId
afterTerminalSelectionChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalSelectionChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "selection-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalSelectionChangedSignalInfo
instance SignalInfo TerminalSelectionChangedSignalInfo where
    type HaskellCallbackType TerminalSelectionChangedSignalInfo = TerminalSelectionChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalSelectionChangedCallback cb
        cb'' <- mk_TerminalSelectionChangedCallback cb'
        connectSignalFunPtr obj "selection-changed" cb'' connectMode detail

#endif

-- signal Terminal::text-deleted
-- | An internal signal used for communication between the terminal and
-- its accessibility peer. May not be emitted under certain
-- circumstances.
type TerminalTextDeletedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextDeletedCallback`@.
noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback
noTerminalTextDeletedCallback :: Maybe (IO ())
noTerminalTextDeletedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextDeletedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextDeletedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextDeletedCallback :: C_TerminalTextDeletedCallback -> IO (FunPtr C_TerminalTextDeletedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalTextDeleted :: MonadIO m => TerminalTextDeletedCallback -> m (GClosure C_TerminalTextDeletedCallback)
genClosure_TerminalTextDeleted :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextDeleted cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextDeletedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalTextDeletedCallback` into a `C_TerminalTextDeletedCallback`.
wrap_TerminalTextDeletedCallback ::
    TerminalTextDeletedCallback ->
    C_TerminalTextDeletedCallback
wrap_TerminalTextDeletedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [textDeleted](#signal:textDeleted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #textDeleted callback
-- @
-- 
-- 
onTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
onTerminalTextDeleted :: a -> IO () -> m SignalHandlerId
onTerminalTextDeleted obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextDeletedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-deleted" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [textDeleted](#signal:textDeleted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textDeleted callback
-- @
-- 
-- 
afterTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
afterTerminalTextDeleted :: a -> IO () -> m SignalHandlerId
afterTerminalTextDeleted obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextDeletedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-deleted" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextDeletedSignalInfo
instance SignalInfo TerminalTextDeletedSignalInfo where
    type HaskellCallbackType TerminalTextDeletedSignalInfo = TerminalTextDeletedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextDeletedCallback cb
        cb'' <- mk_TerminalTextDeletedCallback cb'
        connectSignalFunPtr obj "text-deleted" cb'' connectMode detail

#endif

-- signal Terminal::text-inserted
-- | An internal signal used for communication between the terminal and
-- its accessibility peer. May not be emitted under certain
-- circumstances.
type TerminalTextInsertedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextInsertedCallback`@.
noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback
noTerminalTextInsertedCallback :: Maybe (IO ())
noTerminalTextInsertedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextInsertedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextInsertedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextInsertedCallback :: C_TerminalTextInsertedCallback -> IO (FunPtr C_TerminalTextInsertedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalTextInserted :: MonadIO m => TerminalTextInsertedCallback -> m (GClosure C_TerminalTextInsertedCallback)
genClosure_TerminalTextInserted :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextInserted cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextInsertedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalTextInsertedCallback` into a `C_TerminalTextInsertedCallback`.
wrap_TerminalTextInsertedCallback ::
    TerminalTextInsertedCallback ->
    C_TerminalTextInsertedCallback
wrap_TerminalTextInsertedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [textInserted](#signal:textInserted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #textInserted callback
-- @
-- 
-- 
onTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
onTerminalTextInserted :: a -> IO () -> m SignalHandlerId
onTerminalTextInserted obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextInsertedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-inserted" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [textInserted](#signal:textInserted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textInserted callback
-- @
-- 
-- 
afterTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
afterTerminalTextInserted :: a -> IO () -> m SignalHandlerId
afterTerminalTextInserted obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextInsertedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-inserted" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextInsertedSignalInfo
instance SignalInfo TerminalTextInsertedSignalInfo where
    type HaskellCallbackType TerminalTextInsertedSignalInfo = TerminalTextInsertedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextInsertedCallback cb
        cb'' <- mk_TerminalTextInsertedCallback cb'
        connectSignalFunPtr obj "text-inserted" cb'' connectMode detail

#endif

-- signal Terminal::text-modified
-- | An internal signal used for communication between the terminal and
-- its accessibility peer. May not be emitted under certain
-- circumstances.
type TerminalTextModifiedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextModifiedCallback`@.
noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback
noTerminalTextModifiedCallback :: Maybe (IO ())
noTerminalTextModifiedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextModifiedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextModifiedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextModifiedCallback :: C_TerminalTextModifiedCallback -> IO (FunPtr C_TerminalTextModifiedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalTextModified :: MonadIO m => TerminalTextModifiedCallback -> m (GClosure C_TerminalTextModifiedCallback)
genClosure_TerminalTextModified :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextModified cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextModifiedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalTextModifiedCallback` into a `C_TerminalTextModifiedCallback`.
wrap_TerminalTextModifiedCallback ::
    TerminalTextModifiedCallback ->
    C_TerminalTextModifiedCallback
wrap_TerminalTextModifiedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [textModified](#signal:textModified) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #textModified callback
-- @
-- 
-- 
onTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
onTerminalTextModified :: a -> IO () -> m SignalHandlerId
onTerminalTextModified obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextModifiedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-modified" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [textModified](#signal:textModified) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textModified callback
-- @
-- 
-- 
afterTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
afterTerminalTextModified :: a -> IO () -> m SignalHandlerId
afterTerminalTextModified obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextModifiedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-modified" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextModifiedSignalInfo
instance SignalInfo TerminalTextModifiedSignalInfo where
    type HaskellCallbackType TerminalTextModifiedSignalInfo = TerminalTextModifiedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextModifiedCallback cb
        cb'' <- mk_TerminalTextModifiedCallback cb'
        connectSignalFunPtr obj "text-modified" cb'' connectMode detail

#endif

-- signal Terminal::text-scrolled
-- | An internal signal used for communication between the terminal and
-- its accessibility peer. May not be emitted under certain
-- circumstances.
type TerminalTextScrolledCallback =
    Int32
    -- ^ /@delta@/: the number of lines scrolled
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextScrolledCallback`@.
noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback
noTerminalTextScrolledCallback :: Maybe TerminalChildExitedCallback
noTerminalTextScrolledCallback = Maybe TerminalChildExitedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextScrolledCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextScrolledCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextScrolledCallback :: C_TerminalTextScrolledCallback -> IO (FunPtr C_TerminalTextScrolledCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalTextScrolled :: MonadIO m => TerminalTextScrolledCallback -> m (GClosure C_TerminalTextScrolledCallback)
genClosure_TerminalTextScrolled :: TerminalChildExitedCallback
-> m (GClosure C_TerminalChildExitedCallback)
genClosure_TerminalTextScrolled cb :: TerminalChildExitedCallback
cb = IO (GClosure C_TerminalChildExitedCallback)
-> m (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalChildExitedCallback)
 -> m (GClosure C_TerminalChildExitedCallback))
-> IO (GClosure C_TerminalChildExitedCallback)
-> m (GClosure C_TerminalChildExitedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback TerminalChildExitedCallback
cb
    C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalTextScrolledCallback C_TerminalChildExitedCallback
cb' IO (FunPtr C_TerminalChildExitedCallback)
-> (FunPtr C_TerminalChildExitedCallback
    -> IO (GClosure C_TerminalChildExitedCallback))
-> IO (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalChildExitedCallback
-> IO (GClosure C_TerminalChildExitedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalTextScrolledCallback` into a `C_TerminalTextScrolledCallback`.
wrap_TerminalTextScrolledCallback ::
    TerminalTextScrolledCallback ->
    C_TerminalTextScrolledCallback
wrap_TerminalTextScrolledCallback :: TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback _cb :: TerminalChildExitedCallback
_cb _ delta :: Int32
delta _ = do
    TerminalChildExitedCallback
_cb  Int32
delta


-- | Connect a signal handler for the [textScrolled](#signal:textScrolled) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #textScrolled callback
-- @
-- 
-- 
onTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
onTerminalTextScrolled :: a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalTextScrolled obj :: a
obj cb :: TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback TerminalChildExitedCallback
cb
    FunPtr C_TerminalChildExitedCallback
cb'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalTextScrolledCallback C_TerminalChildExitedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalChildExitedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-scrolled" FunPtr C_TerminalChildExitedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [textScrolled](#signal:textScrolled) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textScrolled callback
-- @
-- 
-- 
afterTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
afterTerminalTextScrolled :: a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalTextScrolled obj :: a
obj cb :: TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalChildExitedCallback
cb' = TerminalChildExitedCallback -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback TerminalChildExitedCallback
cb
    FunPtr C_TerminalChildExitedCallback
cb'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalTextScrolledCallback C_TerminalChildExitedCallback
cb'
    a
-> Text
-> FunPtr C_TerminalChildExitedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "text-scrolled" FunPtr C_TerminalChildExitedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextScrolledSignalInfo
instance SignalInfo TerminalTextScrolledSignalInfo where
    type HaskellCallbackType TerminalTextScrolledSignalInfo = TerminalTextScrolledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextScrolledCallback cb
        cb'' <- mk_TerminalTextScrolledCallback cb'
        connectSignalFunPtr obj "text-scrolled" cb'' connectMode detail

#endif

-- signal Terminal::window-title-changed
-- | Emitted when the terminal\'s @/window_title/@ field is modified.
type TerminalWindowTitleChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalWindowTitleChangedCallback`@.
noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback
noTerminalWindowTitleChangedCallback :: Maybe (IO ())
noTerminalWindowTitleChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalWindowTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalWindowTitleChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalWindowTitleChangedCallback :: C_TerminalWindowTitleChangedCallback -> IO (FunPtr C_TerminalWindowTitleChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalWindowTitleChanged :: MonadIO m => TerminalWindowTitleChangedCallback -> m (GClosure C_TerminalWindowTitleChangedCallback)
genClosure_TerminalWindowTitleChanged :: IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalWindowTitleChanged cb :: IO ()
cb = IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TerminalBellCallback)
 -> m (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
-> m (GClosure C_TerminalBellCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalWindowTitleChangedCallback C_TerminalBellCallback
cb' IO (FunPtr C_TerminalBellCallback)
-> (FunPtr C_TerminalBellCallback
    -> IO (GClosure C_TerminalBellCallback))
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TerminalBellCallback
-> IO (GClosure C_TerminalBellCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TerminalWindowTitleChangedCallback` into a `C_TerminalWindowTitleChangedCallback`.
wrap_TerminalWindowTitleChangedCallback ::
    TerminalWindowTitleChangedCallback ->
    C_TerminalWindowTitleChangedCallback
wrap_TerminalWindowTitleChangedCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [windowTitleChanged](#signal:windowTitleChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' terminal #windowTitleChanged callback
-- @
-- 
-- 
onTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
onTerminalWindowTitleChanged :: a -> IO () -> m SignalHandlerId
onTerminalWindowTitleChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalWindowTitleChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "window-title-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [windowTitleChanged](#signal:windowTitleChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #windowTitleChanged callback
-- @
-- 
-- 
afterTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
afterTerminalWindowTitleChanged :: a -> IO () -> m SignalHandlerId
afterTerminalWindowTitleChanged obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TerminalBellCallback
cb' = IO () -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalWindowTitleChangedCallback C_TerminalBellCallback
cb'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "window-title-changed" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalWindowTitleChangedSignalInfo
instance SignalInfo TerminalWindowTitleChangedSignalInfo where
    type HaskellCallbackType TerminalWindowTitleChangedSignalInfo = TerminalWindowTitleChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalWindowTitleChangedCallback cb
        cb'' <- mk_TerminalWindowTitleChangedCallback cb'
        connectSignalFunPtr obj "window-title-changed" cb'' connectMode detail

#endif

-- VVV Prop "allow-bold"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@allow-bold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #allowBold
-- @
getTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowBold :: o -> m Bool
getTerminalAllowBold obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "allow-bold"

-- | Set the value of the “@allow-bold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #allowBold 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAllowBold :: o -> Bool -> m ()
setTerminalAllowBold obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "allow-bold" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-bold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalAllowBold :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAllowBold :: Bool -> IO (GValueConstruct o)
constructTerminalAllowBold val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "allow-bold" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalAllowBoldPropertyInfo
instance AttrInfo TerminalAllowBoldPropertyInfo where
    type AttrAllowedOps TerminalAllowBoldPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAllowBoldPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool
    type AttrTransferType TerminalAllowBoldPropertyInfo = Bool
    type AttrGetType TerminalAllowBoldPropertyInfo = Bool
    type AttrLabel TerminalAllowBoldPropertyInfo = "allow-bold"
    type AttrOrigin TerminalAllowBoldPropertyInfo = Terminal
    attrGet = getTerminalAllowBold
    attrSet = setTerminalAllowBold
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAllowBold
    attrClear = undefined
#endif

-- VVV Prop "allow-hyperlink"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@allow-hyperlink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #allowHyperlink
-- @
getTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowHyperlink :: o -> m Bool
getTerminalAllowHyperlink obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "allow-hyperlink"

-- | Set the value of the “@allow-hyperlink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #allowHyperlink 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAllowHyperlink :: o -> Bool -> m ()
setTerminalAllowHyperlink obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "allow-hyperlink" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-hyperlink@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalAllowHyperlink :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAllowHyperlink :: Bool -> IO (GValueConstruct o)
constructTerminalAllowHyperlink val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "allow-hyperlink" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalAllowHyperlinkPropertyInfo
instance AttrInfo TerminalAllowHyperlinkPropertyInfo where
    type AttrAllowedOps TerminalAllowHyperlinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAllowHyperlinkPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool
    type AttrTransferType TerminalAllowHyperlinkPropertyInfo = Bool
    type AttrGetType TerminalAllowHyperlinkPropertyInfo = Bool
    type AttrLabel TerminalAllowHyperlinkPropertyInfo = "allow-hyperlink"
    type AttrOrigin TerminalAllowHyperlinkPropertyInfo = Terminal
    attrGet = getTerminalAllowHyperlink
    attrSet = setTerminalAllowHyperlink
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAllowHyperlink
    attrClear = undefined
#endif

-- VVV Prop "audible-bell"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@audible-bell@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #audibleBell
-- @
getTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAudibleBell :: o -> m Bool
getTerminalAudibleBell obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "audible-bell"

-- | Set the value of the “@audible-bell@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #audibleBell 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAudibleBell :: o -> Bool -> m ()
setTerminalAudibleBell obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "audible-bell" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@audible-bell@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalAudibleBell :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAudibleBell :: Bool -> IO (GValueConstruct o)
constructTerminalAudibleBell val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "audible-bell" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalAudibleBellPropertyInfo
instance AttrInfo TerminalAudibleBellPropertyInfo where
    type AttrAllowedOps TerminalAudibleBellPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAudibleBellPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool
    type AttrTransferType TerminalAudibleBellPropertyInfo = Bool
    type AttrGetType TerminalAudibleBellPropertyInfo = Bool
    type AttrLabel TerminalAudibleBellPropertyInfo = "audible-bell"
    type AttrOrigin TerminalAudibleBellPropertyInfo = Terminal
    attrGet = getTerminalAudibleBell
    attrSet = setTerminalAudibleBell
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAudibleBell
    attrClear = undefined
#endif

-- VVV Prop "backspace-binding"
   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@backspace-binding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #backspaceBinding
-- @
getTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalBackspaceBinding :: o -> m EraseBinding
getTerminalBackspaceBinding obj :: o
obj = IO EraseBinding -> m EraseBinding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EraseBinding -> m EraseBinding)
-> IO EraseBinding -> m EraseBinding
forall a b. (a -> b) -> a -> b
$ o -> String -> IO EraseBinding
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "backspace-binding"

-- | Set the value of the “@backspace-binding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #backspaceBinding 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalBackspaceBinding :: o -> EraseBinding -> m ()
setTerminalBackspaceBinding obj :: o
obj val :: EraseBinding
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> EraseBinding -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "backspace-binding" EraseBinding
val

-- | Construct a `GValueConstruct` with valid value for the “@backspace-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalBackspaceBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalBackspaceBinding :: EraseBinding -> IO (GValueConstruct o)
constructTerminalBackspaceBinding val :: EraseBinding
val = String -> EraseBinding -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "backspace-binding" EraseBinding
val

#if defined(ENABLE_OVERLOADING)
data TerminalBackspaceBindingPropertyInfo
instance AttrInfo TerminalBackspaceBindingPropertyInfo where
    type AttrAllowedOps TerminalBackspaceBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalBackspaceBindingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrGetType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalBackspaceBindingPropertyInfo = "backspace-binding"
    type AttrOrigin TerminalBackspaceBindingPropertyInfo = Terminal
    attrGet = getTerminalBackspaceBinding
    attrSet = setTerminalBackspaceBinding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalBackspaceBinding
    attrClear = undefined
#endif

-- VVV Prop "bold-is-bright"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@bold-is-bright@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #boldIsBright
-- @
getTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalBoldIsBright :: o -> m Bool
getTerminalBoldIsBright obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "bold-is-bright"

-- | Set the value of the “@bold-is-bright@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #boldIsBright 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalBoldIsBright :: o -> Bool -> m ()
setTerminalBoldIsBright obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "bold-is-bright" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@bold-is-bright@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalBoldIsBright :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalBoldIsBright :: Bool -> IO (GValueConstruct o)
constructTerminalBoldIsBright val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "bold-is-bright" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalBoldIsBrightPropertyInfo
instance AttrInfo TerminalBoldIsBrightPropertyInfo where
    type AttrAllowedOps TerminalBoldIsBrightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalBoldIsBrightPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool
    type AttrTransferType TerminalBoldIsBrightPropertyInfo = Bool
    type AttrGetType TerminalBoldIsBrightPropertyInfo = Bool
    type AttrLabel TerminalBoldIsBrightPropertyInfo = "bold-is-bright"
    type AttrOrigin TerminalBoldIsBrightPropertyInfo = Terminal
    attrGet = getTerminalBoldIsBright
    attrSet = setTerminalBoldIsBright
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalBoldIsBright
    attrClear = undefined
#endif

-- VVV Prop "cell-height-scale"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cell-height-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #cellHeightScale
-- @
getTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellHeightScale :: o -> m Double
getTerminalCellHeightScale obj :: o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj "cell-height-scale"

-- | Set the value of the “@cell-height-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #cellHeightScale 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalCellHeightScale :: o -> Double -> m ()
setTerminalCellHeightScale obj :: o
obj val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj "cell-height-scale" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@cell-height-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalCellHeightScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalCellHeightScale :: Double -> IO (GValueConstruct o)
constructTerminalCellHeightScale val :: Double
val = String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble "cell-height-scale" Double
val

#if defined(ENABLE_OVERLOADING)
data TerminalCellHeightScalePropertyInfo
instance AttrInfo TerminalCellHeightScalePropertyInfo where
    type AttrAllowedOps TerminalCellHeightScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCellHeightScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double
    type AttrTransferType TerminalCellHeightScalePropertyInfo = Double
    type AttrGetType TerminalCellHeightScalePropertyInfo = Double
    type AttrLabel TerminalCellHeightScalePropertyInfo = "cell-height-scale"
    type AttrOrigin TerminalCellHeightScalePropertyInfo = Terminal
    attrGet = getTerminalCellHeightScale
    attrSet = setTerminalCellHeightScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCellHeightScale
    attrClear = undefined
#endif

-- VVV Prop "cell-width-scale"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cell-width-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #cellWidthScale
-- @
getTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellWidthScale :: o -> m Double
getTerminalCellWidthScale obj :: o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj "cell-width-scale"

-- | Set the value of the “@cell-width-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #cellWidthScale 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalCellWidthScale :: o -> Double -> m ()
setTerminalCellWidthScale obj :: o
obj val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj "cell-width-scale" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@cell-width-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalCellWidthScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalCellWidthScale :: Double -> IO (GValueConstruct o)
constructTerminalCellWidthScale val :: Double
val = String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble "cell-width-scale" Double
val

#if defined(ENABLE_OVERLOADING)
data TerminalCellWidthScalePropertyInfo
instance AttrInfo TerminalCellWidthScalePropertyInfo where
    type AttrAllowedOps TerminalCellWidthScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCellWidthScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double
    type AttrTransferType TerminalCellWidthScalePropertyInfo = Double
    type AttrGetType TerminalCellWidthScalePropertyInfo = Double
    type AttrLabel TerminalCellWidthScalePropertyInfo = "cell-width-scale"
    type AttrOrigin TerminalCellWidthScalePropertyInfo = Terminal
    attrGet = getTerminalCellWidthScale
    attrSet = setTerminalCellWidthScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCellWidthScale
    attrClear = undefined
#endif

-- VVV Prop "cjk-ambiguous-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cjk-ambiguous-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #cjkAmbiguousWidth
-- @
getTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> m Int32
getTerminalCjkAmbiguousWidth :: o -> m Int32
getTerminalCjkAmbiguousWidth obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj "cjk-ambiguous-width"

-- | Set the value of the “@cjk-ambiguous-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #cjkAmbiguousWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> Int32 -> m ()
setTerminalCjkAmbiguousWidth :: o -> Int32 -> m ()
setTerminalCjkAmbiguousWidth obj :: o
obj val :: Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> TerminalChildExitedCallback
forall a. GObject a => a -> String -> TerminalChildExitedCallback
B.Properties.setObjectPropertyInt32 o
obj "cjk-ambiguous-width" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@cjk-ambiguous-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalCjkAmbiguousWidth :: (IsTerminal o) => Int32 -> IO (GValueConstruct o)
constructTerminalCjkAmbiguousWidth :: Int32 -> IO (GValueConstruct o)
constructTerminalCjkAmbiguousWidth val :: Int32
val = String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 "cjk-ambiguous-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data TerminalCjkAmbiguousWidthPropertyInfo
instance AttrInfo TerminalCjkAmbiguousWidthPropertyInfo where
    type AttrAllowedOps TerminalCjkAmbiguousWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32
    type AttrTransferType TerminalCjkAmbiguousWidthPropertyInfo = Int32
    type AttrGetType TerminalCjkAmbiguousWidthPropertyInfo = Int32
    type AttrLabel TerminalCjkAmbiguousWidthPropertyInfo = "cjk-ambiguous-width"
    type AttrOrigin TerminalCjkAmbiguousWidthPropertyInfo = Terminal
    attrGet = getTerminalCjkAmbiguousWidth
    attrSet = setTerminalCjkAmbiguousWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCjkAmbiguousWidth
    attrClear = undefined
#endif

-- VVV Prop "current-container-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@current-container-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #currentContainerName
-- @
getTerminalCurrentContainerName :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalCurrentContainerName :: o -> m (Maybe Text)
getTerminalCurrentContainerName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "current-container-name"

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentContainerNamePropertyInfo
instance AttrInfo TerminalCurrentContainerNamePropertyInfo where
    type AttrAllowedOps TerminalCurrentContainerNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentContainerNamePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentContainerNamePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentContainerNamePropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentContainerNamePropertyInfo = ()
    type AttrGetType TerminalCurrentContainerNamePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentContainerNamePropertyInfo = "current-container-name"
    type AttrOrigin TerminalCurrentContainerNamePropertyInfo = Terminal
    attrGet = getTerminalCurrentContainerName
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "current-container-runtime"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@current-container-runtime@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #currentContainerRuntime
-- @
getTerminalCurrentContainerRuntime :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalCurrentContainerRuntime :: o -> m (Maybe Text)
getTerminalCurrentContainerRuntime obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "current-container-runtime"

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentContainerRuntimePropertyInfo
instance AttrInfo TerminalCurrentContainerRuntimePropertyInfo where
    type AttrAllowedOps TerminalCurrentContainerRuntimePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentContainerRuntimePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentContainerRuntimePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentContainerRuntimePropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentContainerRuntimePropertyInfo = ()
    type AttrGetType TerminalCurrentContainerRuntimePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentContainerRuntimePropertyInfo = "current-container-runtime"
    type AttrOrigin TerminalCurrentContainerRuntimePropertyInfo = Terminal
    attrGet = getTerminalCurrentContainerRuntime
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "current-directory-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@current-directory-uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #currentDirectoryUri
-- @
getTerminalCurrentDirectoryUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalCurrentDirectoryUri :: o -> m (Maybe Text)
getTerminalCurrentDirectoryUri obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "current-directory-uri"

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentDirectoryUriPropertyInfo
instance AttrInfo TerminalCurrentDirectoryUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentDirectoryUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentDirectoryUriPropertyInfo = ()
    type AttrGetType TerminalCurrentDirectoryUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentDirectoryUriPropertyInfo = "current-directory-uri"
    type AttrOrigin TerminalCurrentDirectoryUriPropertyInfo = Terminal
    attrGet = getTerminalCurrentDirectoryUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "current-file-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@current-file-uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #currentFileUri
-- @
getTerminalCurrentFileUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalCurrentFileUri :: o -> m (Maybe Text)
getTerminalCurrentFileUri obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "current-file-uri"

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentFileUriPropertyInfo
instance AttrInfo TerminalCurrentFileUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentFileUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentFileUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentFileUriPropertyInfo = ()
    type AttrGetType TerminalCurrentFileUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentFileUriPropertyInfo = "current-file-uri"
    type AttrOrigin TerminalCurrentFileUriPropertyInfo = Terminal
    attrGet = getTerminalCurrentFileUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "cursor-blink-mode"
   -- Type: TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cursor-blink-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #cursorBlinkMode
-- @
getTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorBlinkMode
getTerminalCursorBlinkMode :: o -> m CursorBlinkMode
getTerminalCursorBlinkMode obj :: o
obj = IO CursorBlinkMode -> m CursorBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CursorBlinkMode -> m CursorBlinkMode)
-> IO CursorBlinkMode -> m CursorBlinkMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CursorBlinkMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "cursor-blink-mode"

-- | Set the value of the “@cursor-blink-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #cursorBlinkMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorBlinkMode -> m ()
setTerminalCursorBlinkMode :: o -> CursorBlinkMode -> m ()
setTerminalCursorBlinkMode obj :: o
obj val :: CursorBlinkMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> CursorBlinkMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "cursor-blink-mode" CursorBlinkMode
val

-- | Construct a `GValueConstruct` with valid value for the “@cursor-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalCursorBlinkMode :: (IsTerminal o) => Vte.Enums.CursorBlinkMode -> IO (GValueConstruct o)
constructTerminalCursorBlinkMode :: CursorBlinkMode -> IO (GValueConstruct o)
constructTerminalCursorBlinkMode val :: CursorBlinkMode
val = String -> CursorBlinkMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "cursor-blink-mode" CursorBlinkMode
val

#if defined(ENABLE_OVERLOADING)
data TerminalCursorBlinkModePropertyInfo
instance AttrInfo TerminalCursorBlinkModePropertyInfo where
    type AttrAllowedOps TerminalCursorBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCursorBlinkModePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode
    type AttrTransferTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode
    type AttrTransferType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode
    type AttrGetType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode
    type AttrLabel TerminalCursorBlinkModePropertyInfo = "cursor-blink-mode"
    type AttrOrigin TerminalCursorBlinkModePropertyInfo = Terminal
    attrGet = getTerminalCursorBlinkMode
    attrSet = setTerminalCursorBlinkMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCursorBlinkMode
    attrClear = undefined
#endif

-- VVV Prop "cursor-shape"
   -- Type: TInterface (Name {namespace = "Vte", name = "CursorShape"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cursor-shape@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #cursorShape
-- @
getTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorShape
getTerminalCursorShape :: o -> m CursorShape
getTerminalCursorShape obj :: o
obj = IO CursorShape -> m CursorShape
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CursorShape -> m CursorShape)
-> IO CursorShape -> m CursorShape
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CursorShape
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "cursor-shape"

-- | Set the value of the “@cursor-shape@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #cursorShape 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorShape -> m ()
setTerminalCursorShape :: o -> CursorShape -> m ()
setTerminalCursorShape obj :: o
obj val :: CursorShape
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> CursorShape -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "cursor-shape" CursorShape
val

-- | Construct a `GValueConstruct` with valid value for the “@cursor-shape@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalCursorShape :: (IsTerminal o) => Vte.Enums.CursorShape -> IO (GValueConstruct o)
constructTerminalCursorShape :: CursorShape -> IO (GValueConstruct o)
constructTerminalCursorShape val :: CursorShape
val = String -> CursorShape -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "cursor-shape" CursorShape
val

#if defined(ENABLE_OVERLOADING)
data TerminalCursorShapePropertyInfo
instance AttrInfo TerminalCursorShapePropertyInfo where
    type AttrAllowedOps TerminalCursorShapePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCursorShapePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape
    type AttrTransferTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape
    type AttrTransferType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape
    type AttrGetType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape
    type AttrLabel TerminalCursorShapePropertyInfo = "cursor-shape"
    type AttrOrigin TerminalCursorShapePropertyInfo = Terminal
    attrGet = getTerminalCursorShape
    attrSet = setTerminalCursorShape
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCursorShape
    attrClear = undefined
#endif

-- VVV Prop "delete-binding"
   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@delete-binding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #deleteBinding
-- @
getTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalDeleteBinding :: o -> m EraseBinding
getTerminalDeleteBinding obj :: o
obj = IO EraseBinding -> m EraseBinding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EraseBinding -> m EraseBinding)
-> IO EraseBinding -> m EraseBinding
forall a b. (a -> b) -> a -> b
$ o -> String -> IO EraseBinding
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "delete-binding"

-- | Set the value of the “@delete-binding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #deleteBinding 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalDeleteBinding :: o -> EraseBinding -> m ()
setTerminalDeleteBinding obj :: o
obj val :: EraseBinding
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> EraseBinding -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "delete-binding" EraseBinding
val

-- | Construct a `GValueConstruct` with valid value for the “@delete-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalDeleteBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalDeleteBinding :: EraseBinding -> IO (GValueConstruct o)
constructTerminalDeleteBinding val :: EraseBinding
val = String -> EraseBinding -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "delete-binding" EraseBinding
val

#if defined(ENABLE_OVERLOADING)
data TerminalDeleteBindingPropertyInfo
instance AttrInfo TerminalDeleteBindingPropertyInfo where
    type AttrAllowedOps TerminalDeleteBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalDeleteBindingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrGetType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalDeleteBindingPropertyInfo = "delete-binding"
    type AttrOrigin TerminalDeleteBindingPropertyInfo = Terminal
    attrGet = getTerminalDeleteBinding
    attrSet = setTerminalDeleteBinding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalDeleteBinding
    attrClear = undefined
#endif

-- VVV Prop "encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@encoding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #encoding
-- @
getTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalEncoding :: o -> m (Maybe Text)
getTerminalEncoding obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "encoding"

-- | Set the value of the “@encoding@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #encoding 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> T.Text -> m ()
setTerminalEncoding :: o -> Text -> m ()
setTerminalEncoding obj :: o
obj val :: Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj "encoding" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@encoding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalEncoding :: (IsTerminal o) => T.Text -> IO (GValueConstruct o)
constructTerminalEncoding :: Text -> IO (GValueConstruct o)
constructTerminalEncoding val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString "encoding" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Set the value of the “@encoding@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #encoding
-- @
clearTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalEncoding :: o -> m ()
clearTerminalEncoding obj :: o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj "encoding" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data TerminalEncodingPropertyInfo
instance AttrInfo TerminalEncodingPropertyInfo where
    type AttrAllowedOps TerminalEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalEncodingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text
    type AttrTransferType TerminalEncodingPropertyInfo = T.Text
    type AttrGetType TerminalEncodingPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalEncodingPropertyInfo = "encoding"
    type AttrOrigin TerminalEncodingPropertyInfo = Terminal
    attrGet = getTerminalEncoding
    attrSet = setTerminalEncoding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEncoding
    attrClear = clearTerminalEncoding
#endif

-- VVV Prop "font-desc"
   -- Type: TInterface (Name {namespace = "Pango", name = "FontDescription"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@font-desc@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #fontDesc
-- @
getTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m (Maybe Pango.FontDescription.FontDescription)
getTerminalFontDesc :: o -> m (Maybe FontDescription)
getTerminalFontDesc obj :: o
obj = IO (Maybe FontDescription) -> m (Maybe FontDescription)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FontDescription) -> m (Maybe FontDescription))
-> IO (Maybe FontDescription) -> m (Maybe FontDescription)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr FontDescription -> FontDescription)
-> IO (Maybe FontDescription)
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj "font-desc" ManagedPtr FontDescription -> FontDescription
Pango.FontDescription.FontDescription

-- | Set the value of the “@font-desc@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #fontDesc 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> Pango.FontDescription.FontDescription -> m ()
setTerminalFontDesc :: o -> FontDescription -> m ()
setTerminalFontDesc obj :: o
obj val :: FontDescription
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe FontDescription -> IO ()
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj "font-desc" (FontDescription -> Maybe FontDescription
forall a. a -> Maybe a
Just FontDescription
val)

-- | Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalFontDesc :: (IsTerminal o) => Pango.FontDescription.FontDescription -> IO (GValueConstruct o)
constructTerminalFontDesc :: FontDescription -> IO (GValueConstruct o)
constructTerminalFontDesc val :: FontDescription
val = String -> Maybe FontDescription -> IO (GValueConstruct o)
forall a o.
BoxedObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed "font-desc" (FontDescription -> Maybe FontDescription
forall a. a -> Maybe a
Just FontDescription
val)

-- | Set the value of the “@font-desc@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #fontDesc
-- @
clearTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalFontDesc :: o -> m ()
clearTerminalFontDesc obj :: o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe FontDescription -> IO ()
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj "font-desc" (Maybe FontDescription
forall a. Maybe a
Nothing :: Maybe Pango.FontDescription.FontDescription)

#if defined(ENABLE_OVERLOADING)
data TerminalFontDescPropertyInfo
instance AttrInfo TerminalFontDescPropertyInfo where
    type AttrAllowedOps TerminalFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalFontDescPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferType TerminalFontDescPropertyInfo = Pango.FontDescription.FontDescription
    type AttrGetType TerminalFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription)
    type AttrLabel TerminalFontDescPropertyInfo = "font-desc"
    type AttrOrigin TerminalFontDescPropertyInfo = Terminal
    attrGet = getTerminalFontDesc
    attrSet = setTerminalFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalFontDesc
    attrClear = clearTerminalFontDesc
#endif

-- VVV Prop "font-scale"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@font-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #fontScale
-- @
getTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalFontScale :: o -> m Double
getTerminalFontScale obj :: o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj "font-scale"

-- | Set the value of the “@font-scale@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #fontScale 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalFontScale :: o -> Double -> m ()
setTerminalFontScale obj :: o
obj val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj "font-scale" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@font-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalFontScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalFontScale :: Double -> IO (GValueConstruct o)
constructTerminalFontScale val :: Double
val = String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble "font-scale" Double
val

#if defined(ENABLE_OVERLOADING)
data TerminalFontScalePropertyInfo
instance AttrInfo TerminalFontScalePropertyInfo where
    type AttrAllowedOps TerminalFontScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalFontScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalFontScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalFontScalePropertyInfo = (~) Double
    type AttrTransferType TerminalFontScalePropertyInfo = Double
    type AttrGetType TerminalFontScalePropertyInfo = Double
    type AttrLabel TerminalFontScalePropertyInfo = "font-scale"
    type AttrOrigin TerminalFontScalePropertyInfo = Terminal
    attrGet = getTerminalFontScale
    attrSet = setTerminalFontScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalFontScale
    attrClear = undefined
#endif

-- VVV Prop "hyperlink-hover-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@hyperlink-hover-uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #hyperlinkHoverUri
-- @
getTerminalHyperlinkHoverUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalHyperlinkHoverUri :: o -> m (Maybe Text)
getTerminalHyperlinkHoverUri obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "hyperlink-hover-uri"

#if defined(ENABLE_OVERLOADING)
data TerminalHyperlinkHoverUriPropertyInfo
instance AttrInfo TerminalHyperlinkHoverUriPropertyInfo where
    type AttrAllowedOps TerminalHyperlinkHoverUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()
    type AttrTransferType TerminalHyperlinkHoverUriPropertyInfo = ()
    type AttrGetType TerminalHyperlinkHoverUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalHyperlinkHoverUriPropertyInfo = "hyperlink-hover-uri"
    type AttrOrigin TerminalHyperlinkHoverUriPropertyInfo = Terminal
    attrGet = getTerminalHyperlinkHoverUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "icon-title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@icon-title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #iconTitle
-- @
getTerminalIconTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalIconTitle :: o -> m (Maybe Text)
getTerminalIconTitle obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "icon-title"

#if defined(ENABLE_OVERLOADING)
data TerminalIconTitlePropertyInfo
instance AttrInfo TerminalIconTitlePropertyInfo where
    type AttrAllowedOps TerminalIconTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalIconTitlePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalIconTitlePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalIconTitlePropertyInfo = (~) ()
    type AttrTransferType TerminalIconTitlePropertyInfo = ()
    type AttrGetType TerminalIconTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalIconTitlePropertyInfo = "icon-title"
    type AttrOrigin TerminalIconTitlePropertyInfo = Terminal
    attrGet = getTerminalIconTitle
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "input-enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@input-enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #inputEnabled
-- @
getTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalInputEnabled :: o -> m Bool
getTerminalInputEnabled obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "input-enabled"

-- | Set the value of the “@input-enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #inputEnabled 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalInputEnabled :: o -> Bool -> m ()
setTerminalInputEnabled obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "input-enabled" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@input-enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalInputEnabled :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalInputEnabled :: Bool -> IO (GValueConstruct o)
constructTerminalInputEnabled val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "input-enabled" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalInputEnabledPropertyInfo
instance AttrInfo TerminalInputEnabledPropertyInfo where
    type AttrAllowedOps TerminalInputEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalInputEnabledPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool
    type AttrTransferType TerminalInputEnabledPropertyInfo = Bool
    type AttrGetType TerminalInputEnabledPropertyInfo = Bool
    type AttrLabel TerminalInputEnabledPropertyInfo = "input-enabled"
    type AttrOrigin TerminalInputEnabledPropertyInfo = Terminal
    attrGet = getTerminalInputEnabled
    attrSet = setTerminalInputEnabled
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalInputEnabled
    attrClear = undefined
#endif

-- VVV Prop "pointer-autohide"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@pointer-autohide@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #pointerAutohide
-- @
getTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalPointerAutohide :: o -> m Bool
getTerminalPointerAutohide obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "pointer-autohide"

-- | Set the value of the “@pointer-autohide@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #pointerAutohide 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalPointerAutohide :: o -> Bool -> m ()
setTerminalPointerAutohide obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "pointer-autohide" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@pointer-autohide@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalPointerAutohide :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalPointerAutohide :: Bool -> IO (GValueConstruct o)
constructTerminalPointerAutohide val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "pointer-autohide" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalPointerAutohidePropertyInfo
instance AttrInfo TerminalPointerAutohidePropertyInfo where
    type AttrAllowedOps TerminalPointerAutohidePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalPointerAutohidePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool
    type AttrTransferType TerminalPointerAutohidePropertyInfo = Bool
    type AttrGetType TerminalPointerAutohidePropertyInfo = Bool
    type AttrLabel TerminalPointerAutohidePropertyInfo = "pointer-autohide"
    type AttrOrigin TerminalPointerAutohidePropertyInfo = Terminal
    attrGet = getTerminalPointerAutohide
    attrSet = setTerminalPointerAutohide
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalPointerAutohide
    attrClear = undefined
#endif

-- VVV Prop "pty"
   -- Type: TInterface (Name {namespace = "Vte", name = "Pty"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@pty@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #pty
-- @
getTerminalPty :: (MonadIO m, IsTerminal o) => o -> m Vte.Pty.Pty
getTerminalPty :: o -> m Pty
getTerminalPty obj :: o
obj = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Pty) -> IO Pty
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getTerminalPty" (IO (Maybe Pty) -> IO Pty) -> IO (Maybe Pty) -> IO Pty
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Pty -> Pty) -> IO (Maybe Pty)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "pty" ManagedPtr Pty -> Pty
Vte.Pty.Pty

-- | Set the value of the “@pty@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #pty 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalPty :: (MonadIO m, IsTerminal o, Vte.Pty.IsPty a) => o -> a -> m ()
setTerminalPty :: o -> a -> m ()
setTerminalPty obj :: o
obj val :: a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "pty" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@pty@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalPty :: (IsTerminal o, Vte.Pty.IsPty a) => a -> IO (GValueConstruct o)
constructTerminalPty :: a -> IO (GValueConstruct o)
constructTerminalPty val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "pty" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Set the value of the “@pty@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #pty
-- @
clearTerminalPty :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalPty :: o -> m ()
clearTerminalPty obj :: o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Pty -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "pty" (Maybe Pty
forall a. Maybe a
Nothing :: Maybe Vte.Pty.Pty)

#if defined(ENABLE_OVERLOADING)
data TerminalPtyPropertyInfo
instance AttrInfo TerminalPtyPropertyInfo where
    type AttrAllowedOps TerminalPtyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalPtyPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty
    type AttrTransferTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty
    type AttrTransferType TerminalPtyPropertyInfo = Vte.Pty.Pty
    type AttrGetType TerminalPtyPropertyInfo = Vte.Pty.Pty
    type AttrLabel TerminalPtyPropertyInfo = "pty"
    type AttrOrigin TerminalPtyPropertyInfo = Terminal
    attrGet = getTerminalPty
    attrSet = setTerminalPty
    attrTransfer _ v = do
        unsafeCastTo Vte.Pty.Pty v
    attrConstruct = constructTerminalPty
    attrClear = clearTerminalPty
#endif

-- VVV Prop "rewrap-on-resize"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@rewrap-on-resize@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #rewrapOnResize
-- @
getTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalRewrapOnResize :: o -> m Bool
getTerminalRewrapOnResize obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "rewrap-on-resize"

-- | Set the value of the “@rewrap-on-resize@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #rewrapOnResize 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalRewrapOnResize :: o -> Bool -> m ()
setTerminalRewrapOnResize obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "rewrap-on-resize" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@rewrap-on-resize@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalRewrapOnResize :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalRewrapOnResize :: Bool -> IO (GValueConstruct o)
constructTerminalRewrapOnResize val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "rewrap-on-resize" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalRewrapOnResizePropertyInfo
instance AttrInfo TerminalRewrapOnResizePropertyInfo where
    type AttrAllowedOps TerminalRewrapOnResizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalRewrapOnResizePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool
    type AttrTransferType TerminalRewrapOnResizePropertyInfo = Bool
    type AttrGetType TerminalRewrapOnResizePropertyInfo = Bool
    type AttrLabel TerminalRewrapOnResizePropertyInfo = "rewrap-on-resize"
    type AttrOrigin TerminalRewrapOnResizePropertyInfo = Terminal
    attrGet = getTerminalRewrapOnResize
    attrSet = setTerminalRewrapOnResize
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalRewrapOnResize
    attrClear = undefined
#endif

-- VVV Prop "scroll-on-keystroke"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@scroll-on-keystroke@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #scrollOnKeystroke
-- @
getTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnKeystroke :: o -> m Bool
getTerminalScrollOnKeystroke obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "scroll-on-keystroke"

-- | Set the value of the “@scroll-on-keystroke@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #scrollOnKeystroke 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnKeystroke :: o -> Bool -> m ()
setTerminalScrollOnKeystroke obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "scroll-on-keystroke" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@scroll-on-keystroke@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalScrollOnKeystroke :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnKeystroke :: Bool -> IO (GValueConstruct o)
constructTerminalScrollOnKeystroke val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "scroll-on-keystroke" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalScrollOnKeystrokePropertyInfo
instance AttrInfo TerminalScrollOnKeystrokePropertyInfo where
    type AttrAllowedOps TerminalScrollOnKeystrokePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollOnKeystrokePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollOnKeystrokePropertyInfo = Bool
    type AttrGetType TerminalScrollOnKeystrokePropertyInfo = Bool
    type AttrLabel TerminalScrollOnKeystrokePropertyInfo = "scroll-on-keystroke"
    type AttrOrigin TerminalScrollOnKeystrokePropertyInfo = Terminal
    attrGet = getTerminalScrollOnKeystroke
    attrSet = setTerminalScrollOnKeystroke
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollOnKeystroke
    attrClear = undefined
#endif

-- VVV Prop "scroll-on-output"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@scroll-on-output@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #scrollOnOutput
-- @
getTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnOutput :: o -> m Bool
getTerminalScrollOnOutput obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "scroll-on-output"

-- | Set the value of the “@scroll-on-output@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #scrollOnOutput 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnOutput :: o -> Bool -> m ()
setTerminalScrollOnOutput obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "scroll-on-output" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@scroll-on-output@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalScrollOnOutput :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnOutput :: Bool -> IO (GValueConstruct o)
constructTerminalScrollOnOutput val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "scroll-on-output" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalScrollOnOutputPropertyInfo
instance AttrInfo TerminalScrollOnOutputPropertyInfo where
    type AttrAllowedOps TerminalScrollOnOutputPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollOnOutputPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollOnOutputPropertyInfo = Bool
    type AttrGetType TerminalScrollOnOutputPropertyInfo = Bool
    type AttrLabel TerminalScrollOnOutputPropertyInfo = "scroll-on-output"
    type AttrOrigin TerminalScrollOnOutputPropertyInfo = Terminal
    attrGet = getTerminalScrollOnOutput
    attrSet = setTerminalScrollOnOutput
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollOnOutput
    attrClear = undefined
#endif

-- VVV Prop "scroll-speed"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@scroll-speed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #scrollSpeed
-- @
getTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollSpeed :: o -> m Word32
getTerminalScrollSpeed obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj "scroll-speed"

-- | Set the value of the “@scroll-speed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #scrollSpeed 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollSpeed :: o -> Word32 -> m ()
setTerminalScrollSpeed obj :: o
obj val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj "scroll-speed" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@scroll-speed@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalScrollSpeed :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollSpeed :: Word32 -> IO (GValueConstruct o)
constructTerminalScrollSpeed val :: Word32
val = String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 "scroll-speed" Word32
val

#if defined(ENABLE_OVERLOADING)
data TerminalScrollSpeedPropertyInfo
instance AttrInfo TerminalScrollSpeedPropertyInfo where
    type AttrAllowedOps TerminalScrollSpeedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollSpeedPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollSpeedPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint TerminalScrollSpeedPropertyInfo = (~) Word32
    type AttrTransferType TerminalScrollSpeedPropertyInfo = Word32
    type AttrGetType TerminalScrollSpeedPropertyInfo = Word32
    type AttrLabel TerminalScrollSpeedPropertyInfo = "scroll-speed"
    type AttrOrigin TerminalScrollSpeedPropertyInfo = Terminal
    attrGet = getTerminalScrollSpeed
    attrSet = setTerminalScrollSpeed
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollSpeed
    attrClear = undefined
#endif

-- VVV Prop "scrollback-lines"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scrollback-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #scrollbackLines
-- @
getTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollbackLines :: o -> m Word32
getTerminalScrollbackLines obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj "scrollback-lines"

-- | Set the value of the “@scrollback-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #scrollbackLines 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollbackLines :: o -> Word32 -> m ()
setTerminalScrollbackLines obj :: o
obj val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj "scrollback-lines" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@scrollback-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalScrollbackLines :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollbackLines :: Word32 -> IO (GValueConstruct o)
constructTerminalScrollbackLines val :: Word32
val = String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 "scrollback-lines" Word32
val

#if defined(ENABLE_OVERLOADING)
data TerminalScrollbackLinesPropertyInfo
instance AttrInfo TerminalScrollbackLinesPropertyInfo where
    type AttrAllowedOps TerminalScrollbackLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollbackLinesPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32
    type AttrTransferType TerminalScrollbackLinesPropertyInfo = Word32
    type AttrGetType TerminalScrollbackLinesPropertyInfo = Word32
    type AttrLabel TerminalScrollbackLinesPropertyInfo = "scrollback-lines"
    type AttrOrigin TerminalScrollbackLinesPropertyInfo = Terminal
    attrGet = getTerminalScrollbackLines
    attrSet = setTerminalScrollbackLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollbackLines
    attrClear = undefined
#endif

-- VVV Prop "text-blink-mode"
   -- Type: TInterface (Name {namespace = "Vte", name = "TextBlinkMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@text-blink-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #textBlinkMode
-- @
getTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.TextBlinkMode
getTerminalTextBlinkMode :: o -> m TextBlinkMode
getTerminalTextBlinkMode obj :: o
obj = IO TextBlinkMode -> m TextBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextBlinkMode -> m TextBlinkMode)
-> IO TextBlinkMode -> m TextBlinkMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextBlinkMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "text-blink-mode"

-- | Set the value of the “@text-blink-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' terminal [ #textBlinkMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.TextBlinkMode -> m ()
setTerminalTextBlinkMode :: o -> TextBlinkMode -> m ()
setTerminalTextBlinkMode obj :: o
obj val :: TextBlinkMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> TextBlinkMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "text-blink-mode" TextBlinkMode
val

-- | Construct a `GValueConstruct` with valid value for the “@text-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalTextBlinkMode :: (IsTerminal o) => Vte.Enums.TextBlinkMode -> IO (GValueConstruct o)
constructTerminalTextBlinkMode :: TextBlinkMode -> IO (GValueConstruct o)
constructTerminalTextBlinkMode val :: TextBlinkMode
val = String -> TextBlinkMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "text-blink-mode" TextBlinkMode
val

#if defined(ENABLE_OVERLOADING)
data TerminalTextBlinkModePropertyInfo
instance AttrInfo TerminalTextBlinkModePropertyInfo where
    type AttrAllowedOps TerminalTextBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalTextBlinkModePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode
    type AttrTransferTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode
    type AttrTransferType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode
    type AttrGetType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode
    type AttrLabel TerminalTextBlinkModePropertyInfo = "text-blink-mode"
    type AttrOrigin TerminalTextBlinkModePropertyInfo = Terminal
    attrGet = getTerminalTextBlinkMode
    attrSet = setTerminalTextBlinkMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalTextBlinkMode
    attrClear = undefined
#endif

-- VVV Prop "window-title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@window-title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #windowTitle
-- @
getTerminalWindowTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalWindowTitle :: o -> m (Maybe Text)
getTerminalWindowTitle obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "window-title"

#if defined(ENABLE_OVERLOADING)
data TerminalWindowTitlePropertyInfo
instance AttrInfo TerminalWindowTitlePropertyInfo where
    type AttrAllowedOps TerminalWindowTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalWindowTitlePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()
    type AttrTransferType TerminalWindowTitlePropertyInfo = ()
    type AttrGetType TerminalWindowTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalWindowTitlePropertyInfo = "window-title"
    type AttrOrigin TerminalWindowTitlePropertyInfo = Terminal
    attrGet = getTerminalWindowTitle
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "word-char-exceptions"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Just False)

-- | Get the value of the “@word-char-exceptions@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #wordCharExceptions
-- @
getTerminalWordCharExceptions :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalWordCharExceptions :: o -> m (Maybe Text)
getTerminalWordCharExceptions obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj "word-char-exceptions"

#if defined(ENABLE_OVERLOADING)
data TerminalWordCharExceptionsPropertyInfo
instance AttrInfo TerminalWordCharExceptionsPropertyInfo where
    type AttrAllowedOps TerminalWordCharExceptionsPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TerminalWordCharExceptionsPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()
    type AttrTransferType TerminalWordCharExceptionsPropertyInfo = ()
    type AttrGetType TerminalWordCharExceptionsPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalWordCharExceptionsPropertyInfo = "word-char-exceptions"
    type AttrOrigin TerminalWordCharExceptionsPropertyInfo = Terminal
    attrGet = getTerminalWordCharExceptions
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Terminal
type instance O.AttributeList Terminal = TerminalAttributeList
type TerminalAttributeList = ('[ '("allowBold", TerminalAllowBoldPropertyInfo), '("allowHyperlink", TerminalAllowHyperlinkPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("audibleBell", TerminalAudibleBellPropertyInfo), '("backspaceBinding", TerminalBackspaceBindingPropertyInfo), '("boldIsBright", TerminalBoldIsBrightPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("cellHeightScale", TerminalCellHeightScalePropertyInfo), '("cellWidthScale", TerminalCellWidthScalePropertyInfo), '("cjkAmbiguousWidth", TerminalCjkAmbiguousWidthPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("currentContainerName", TerminalCurrentContainerNamePropertyInfo), '("currentContainerRuntime", TerminalCurrentContainerRuntimePropertyInfo), '("currentDirectoryUri", TerminalCurrentDirectoryUriPropertyInfo), '("currentFileUri", TerminalCurrentFileUriPropertyInfo), '("cursorBlinkMode", TerminalCursorBlinkModePropertyInfo), '("cursorShape", TerminalCursorShapePropertyInfo), '("deleteBinding", TerminalDeleteBindingPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("encoding", TerminalEncodingPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("fontDesc", TerminalFontDescPropertyInfo), '("fontScale", TerminalFontScalePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("hyperlinkHoverUri", TerminalHyperlinkHoverUriPropertyInfo), '("iconTitle", TerminalIconTitlePropertyInfo), '("inputEnabled", TerminalInputEnabledPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pointerAutohide", TerminalPointerAutohidePropertyInfo), '("pty", TerminalPtyPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rewrapOnResize", TerminalRewrapOnResizePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("scrollOnKeystroke", TerminalScrollOnKeystrokePropertyInfo), '("scrollOnOutput", TerminalScrollOnOutputPropertyInfo), '("scrollSpeed", TerminalScrollSpeedPropertyInfo), '("scrollbackLines", TerminalScrollbackLinesPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("textBlinkMode", TerminalTextBlinkModePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowTitle", TerminalWindowTitlePropertyInfo), '("wordCharExceptions", TerminalWordCharExceptionsPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
terminalAllowBold :: AttrLabelProxy "allowBold"
terminalAllowBold = AttrLabelProxy

terminalAllowHyperlink :: AttrLabelProxy "allowHyperlink"
terminalAllowHyperlink = AttrLabelProxy

terminalAudibleBell :: AttrLabelProxy "audibleBell"
terminalAudibleBell = AttrLabelProxy

terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"
terminalBackspaceBinding = AttrLabelProxy

terminalBoldIsBright :: AttrLabelProxy "boldIsBright"
terminalBoldIsBright = AttrLabelProxy

terminalCellHeightScale :: AttrLabelProxy "cellHeightScale"
terminalCellHeightScale = AttrLabelProxy

terminalCellWidthScale :: AttrLabelProxy "cellWidthScale"
terminalCellWidthScale = AttrLabelProxy

terminalCjkAmbiguousWidth :: AttrLabelProxy "cjkAmbiguousWidth"
terminalCjkAmbiguousWidth = AttrLabelProxy

terminalCurrentContainerName :: AttrLabelProxy "currentContainerName"
terminalCurrentContainerName = AttrLabelProxy

terminalCurrentContainerRuntime :: AttrLabelProxy "currentContainerRuntime"
terminalCurrentContainerRuntime = AttrLabelProxy

terminalCurrentDirectoryUri :: AttrLabelProxy "currentDirectoryUri"
terminalCurrentDirectoryUri = AttrLabelProxy

terminalCurrentFileUri :: AttrLabelProxy "currentFileUri"
terminalCurrentFileUri = AttrLabelProxy

terminalCursorBlinkMode :: AttrLabelProxy "cursorBlinkMode"
terminalCursorBlinkMode = AttrLabelProxy

terminalCursorShape :: AttrLabelProxy "cursorShape"
terminalCursorShape = AttrLabelProxy

terminalDeleteBinding :: AttrLabelProxy "deleteBinding"
terminalDeleteBinding = AttrLabelProxy

terminalEncoding :: AttrLabelProxy "encoding"
terminalEncoding = AttrLabelProxy

terminalFontDesc :: AttrLabelProxy "fontDesc"
terminalFontDesc = AttrLabelProxy

terminalFontScale :: AttrLabelProxy "fontScale"
terminalFontScale = AttrLabelProxy

terminalHyperlinkHoverUri :: AttrLabelProxy "hyperlinkHoverUri"
terminalHyperlinkHoverUri = AttrLabelProxy

terminalIconTitle :: AttrLabelProxy "iconTitle"
terminalIconTitle = AttrLabelProxy

terminalInputEnabled :: AttrLabelProxy "inputEnabled"
terminalInputEnabled = AttrLabelProxy

terminalPointerAutohide :: AttrLabelProxy "pointerAutohide"
terminalPointerAutohide = AttrLabelProxy

terminalPty :: AttrLabelProxy "pty"
terminalPty = AttrLabelProxy

terminalRewrapOnResize :: AttrLabelProxy "rewrapOnResize"
terminalRewrapOnResize = AttrLabelProxy

terminalScrollOnKeystroke :: AttrLabelProxy "scrollOnKeystroke"
terminalScrollOnKeystroke = AttrLabelProxy

terminalScrollOnOutput :: AttrLabelProxy "scrollOnOutput"
terminalScrollOnOutput = AttrLabelProxy

terminalScrollSpeed :: AttrLabelProxy "scrollSpeed"
terminalScrollSpeed = AttrLabelProxy

terminalScrollbackLines :: AttrLabelProxy "scrollbackLines"
terminalScrollbackLines = AttrLabelProxy

terminalTextBlinkMode :: AttrLabelProxy "textBlinkMode"
terminalTextBlinkMode = AttrLabelProxy

terminalWindowTitle :: AttrLabelProxy "windowTitle"
terminalWindowTitle = AttrLabelProxy

terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"
terminalWordCharExceptions = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Terminal = TerminalSignalList
type TerminalSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("bell", TerminalBellSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("charSizeChanged", TerminalCharSizeChangedSignalInfo), '("childExited", TerminalChildExitedSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("commit", TerminalCommitSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("contentsChanged", TerminalContentsChangedSignalInfo), '("copyClipboard", TerminalCopyClipboardSignalInfo), '("currentDirectoryUriChanged", TerminalCurrentDirectoryUriChangedSignalInfo), '("currentFileUriChanged", TerminalCurrentFileUriChangedSignalInfo), '("cursorMoved", TerminalCursorMovedSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("decreaseFontSize", TerminalDecreaseFontSizeSignalInfo), '("deiconifyWindow", TerminalDeiconifyWindowSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("encodingChanged", TerminalEncodingChangedSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("eof", TerminalEofSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("hyperlinkHoverUriChanged", TerminalHyperlinkHoverUriChangedSignalInfo), '("iconTitleChanged", TerminalIconTitleChangedSignalInfo), '("iconifyWindow", TerminalIconifyWindowSignalInfo), '("increaseFontSize", TerminalIncreaseFontSizeSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("lowerWindow", TerminalLowerWindowSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("maximizeWindow", TerminalMaximizeWindowSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveWindow", TerminalMoveWindowSignalInfo), '("notificationReceived", TerminalNotificationReceivedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", TerminalPasteClipboardSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("raiseWindow", TerminalRaiseWindowSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("refreshWindow", TerminalRefreshWindowSignalInfo), '("resizeWindow", TerminalResizeWindowSignalInfo), '("restoreWindow", TerminalRestoreWindowSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionChanged", TerminalSelectionChangedSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("textDeleted", TerminalTextDeletedSignalInfo), '("textInserted", TerminalTextInsertedSignalInfo), '("textModified", TerminalTextModifiedSignalInfo), '("textScrolled", TerminalTextScrolledSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo), '("windowTitleChanged", TerminalWindowTitleChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Terminal::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "Terminal" })
-- throws : False
-- Skip return : False

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

-- | Creates a new terminal widget.
terminalNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Terminal
    -- ^ __Returns:__ a new t'GI.Vte.Objects.Terminal.Terminal' object
terminalNew :: m Terminal
terminalNew  = IO Terminal -> m Terminal
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Terminal -> m Terminal) -> IO Terminal -> m Terminal
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
result <- IO (Ptr Terminal)
vte_terminal_new
    Text -> Ptr Terminal -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalNew" Ptr Terminal
result
    Terminal
result' <- ((ManagedPtr Terminal -> Terminal) -> Ptr Terminal -> IO Terminal
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Terminal -> Terminal
Terminal) Ptr Terminal
result
    Terminal -> IO Terminal
forall (m :: * -> *) a. Monad m => a -> m a
return Terminal
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Terminal::copy_clipboard
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_copy_clipboard" vte_terminal_copy_clipboard :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{-# DEPRECATED terminalCopyClipboard ["(Since version 0.50)","Use 'GI.Vte.Objects.Terminal.terminalCopyClipboardFormat' with 'GI.Vte.Enums.FormatText'","  instead."] #-}
-- | Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@
-- selection.
terminalCopyClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalCopyClipboard :: a -> m ()
terminalCopyClipboard terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_copy_clipboard Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalCopyClipboardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardMethodInfo a signature where
    overloadedMethod = terminalCopyClipboard

#endif

-- method Terminal::copy_clipboard_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType = TInterface Name { namespace = "Vte" , name = "Format" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteFormat" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_copy_clipboard_format" vte_terminal_copy_clipboard_format :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Vte", name = "Format"})
    IO ()

-- | Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@
-- selection in the form specified by /@format@/.
-- 
-- For all formats, the selection data (see t'GI.Gtk.Structs.SelectionData.SelectionData') will include the
-- text targets (see 'GI.Gtk.Structs.TargetList.targetListAddTextTargets' and
-- @/gtk_selection_data_targets_includes_text()/@). For 'GI.Vte.Enums.FormatHtml',
-- the selection will also include the \"text\/html\" target, which when requested,
-- returns the HTML data in UTF-16 with a U+FEFF BYTE ORDER MARK character at
-- the start.
-- 
-- /Since: 0.50/
terminalCopyClipboardFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Format
    -- ^ /@format@/: a t'GI.Vte.Enums.Format'
    -> m ()
terminalCopyClipboardFormat :: a -> Format -> m ()
terminalCopyClipboardFormat terminal :: a
terminal format :: Format
format = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_copy_clipboard_format Ptr Terminal
terminal' CUInt
format'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalCopyClipboardFormatMethodInfo
instance (signature ~ (Vte.Enums.Format -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardFormatMethodInfo a signature where
    overloadedMethod = terminalCopyClipboardFormat

#endif

-- method Terminal::copy_primary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_copy_primary" vte_terminal_copy_primary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Places the selected text in the terminal in the @/GDK_SELECTION_PRIMARY/@
-- selection.
terminalCopyPrimary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalCopyPrimary :: a -> m ()
terminalCopyPrimary terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_copy_primary Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalCopyPrimaryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyPrimaryMethodInfo a signature where
    overloadedMethod = terminalCopyPrimary

#endif

-- method Terminal::feed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string in the terminal's current encoding"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the length of the string, or -1 to use the full length or a nul-terminated string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "the length of the string, or -1 to use the full length or a nul-terminated string"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed" vte_terminal_feed :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

-- | Interprets /@data@/ as if it were data received from a child process.  This
-- can either be used to drive the terminal without a child process, or just
-- to mess with your users.
terminalFeed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (ByteString)
    -- ^ /@data@/: a string in the terminal\'s current encoding
    -> m ()
terminalFeed :: a -> Maybe ByteString -> m ()
terminalFeed terminal :: a
terminal data_ :: Maybe ByteString
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let length_ :: Int64
length_ = case Maybe ByteString
data_ of
            Nothing -> 0
            Just jData_ :: ByteString
jData_ -> Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64) -> Int -> Int64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jData_
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Word8
maybeData_ <- case Maybe ByteString
data_ of
        Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just jData_ :: ByteString
jData_ -> do
            Ptr Word8
jData_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jData_
            Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jData_'
    Ptr Terminal -> Ptr Word8 -> Int64 -> IO ()
vte_terminal_feed Ptr Terminal
terminal' Ptr Word8
maybeData_ Int64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeData_
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalFeedMethodInfo
instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedMethodInfo a signature where
    overloadedMethod = terminalFeed

#endif

-- method Terminal::feed_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TCArray False (-1) 2 (TBasicType TInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to send to the child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "length of @text in bytes, or -1 if @text is NUL-terminated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "length of @text in bytes, or -1 if @text is NUL-terminated"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child" vte_terminal_feed_child :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Int8 ->                             -- text : TCArray False (-1) 2 (TBasicType TInt8)
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

-- | Sends a block of UTF-8 text to the child as if it were entered by the user
-- at the keyboard.
terminalFeedChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe ([Int8])
    -- ^ /@text@/: data to send to the child
    -> m ()
terminalFeedChild :: a -> Maybe [Int8] -> m ()
terminalFeedChild terminal :: a
terminal text :: Maybe [Int8]
text = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let length_ :: Int64
length_ = case Maybe [Int8]
text of
            Nothing -> 0
            Just jText :: [Int8]
jText -> Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64) -> Int -> Int64
forall a b. (a -> b) -> a -> b
$ [Int8] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int8]
jText
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Int8
maybeText <- case Maybe [Int8]
text of
        Nothing -> Ptr Int8 -> IO (Ptr Int8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int8
forall a. Ptr a
nullPtr
        Just jText :: [Int8]
jText -> do
            Ptr Int8
jText' <- [Int8] -> IO (Ptr Int8)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [Int8]
jText
            Ptr Int8 -> IO (Ptr Int8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int8
jText'
    Ptr Terminal -> Ptr Int8 -> Int64 -> IO ()
vte_terminal_feed_child Ptr Terminal
terminal' Ptr Int8
maybeText Int64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Int8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int8
maybeText
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalFeedChildMethodInfo
instance (signature ~ (Maybe ([Int8]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildMethodInfo a signature where
    overloadedMethod = terminalFeedChild

#endif

-- method Terminal::feed_child_binary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to send to the child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of @data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "length of @data" , sinceVersion = Nothing }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child_binary" vte_terminal_feed_child_binary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    IO ()

-- | Sends a block of binary data to the child.
terminalFeedChildBinary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (ByteString)
    -- ^ /@data@/: data to send to the child
    -> m ()
terminalFeedChildBinary :: a -> Maybe ByteString -> m ()
terminalFeedChildBinary terminal :: a
terminal data_ :: Maybe ByteString
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let length_ :: Word64
length_ = case Maybe ByteString
data_ of
            Nothing -> 0
            Just jData_ :: ByteString
jData_ -> Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jData_
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Word8
maybeData_ <- case Maybe ByteString
data_ of
        Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just jData_ :: ByteString
jData_ -> do
            Ptr Word8
jData_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jData_
            Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jData_'
    Ptr Terminal -> Ptr Word8 -> Word64 -> IO ()
vte_terminal_feed_child_binary Ptr Terminal
terminal' Ptr Word8
maybeData_ Word64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeData_
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalFeedChildBinaryMethodInfo
instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildBinaryMethodInfo a signature where
    overloadedMethod = terminalFeedChildBinary

#endif

-- method Terminal::get_allow_bold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_allow_bold" vte_terminal_get_allow_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether or not the terminal will attempt to draw bold text,
-- either by using a bold font variant or by repainting text with a different
-- offset.
terminalGetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if bolding is enabled, 'P.False' if not
terminalGetAllowBold :: a -> m Bool
terminalGetAllowBold terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_allow_bold Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetAllowBoldMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowBoldMethodInfo a signature where
    overloadedMethod = terminalGetAllowBold

#endif

-- method Terminal::get_allow_hyperlink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_allow_hyperlink" vte_terminal_get_allow_hyperlink :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether or not hyperlinks (OSC 8 escape sequence) are allowed.
-- 
-- /Since: 0.50/
terminalGetAllowHyperlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if hyperlinks are enabled, 'P.False' if not
terminalGetAllowHyperlink :: a -> m Bool
terminalGetAllowHyperlink terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_allow_hyperlink Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetAllowHyperlinkMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowHyperlinkMethodInfo a signature where
    overloadedMethod = terminalGetAllowHyperlink

#endif

-- method Terminal::get_audible_bell
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_audible_bell" vte_terminal_get_audible_bell :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether or not the terminal will beep when the child outputs the
-- \"bl\" sequence.
terminalGetAudibleBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if audible bell is enabled, 'P.False' if not
terminalGetAudibleBell :: a -> m Bool
terminalGetAudibleBell terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_audible_bell Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetAudibleBellMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAudibleBellMethodInfo a signature where
    overloadedMethod = terminalGetAudibleBell

#endif

-- method Terminal::get_bold_is_bright
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_bold_is_bright" vte_terminal_get_bold_is_bright :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether the SGR 1 attribute also switches to the bright counterpart
-- of the first 8 palette colors, in addition to making them bold (legacy behavior)
-- or if SGR 1 only enables bold and leaves the color intact.
-- 
-- /Since: 0.52/
terminalGetBoldIsBright ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if bold also enables bright, 'P.False' if not
terminalGetBoldIsBright :: a -> m Bool
terminalGetBoldIsBright terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_bold_is_bright Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetBoldIsBrightMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetBoldIsBrightMethodInfo a signature where
    overloadedMethod = terminalGetBoldIsBright

#endif

-- method Terminal::get_cell_height_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cell_height_scale" vte_terminal_get_cell_height_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetCellHeightScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Double
    -- ^ __Returns:__ the terminal\'s cell height scale
terminalGetCellHeightScale :: a -> m Double
terminalGetCellHeightScale terminal :: a
terminal = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CDouble
result <- Ptr Terminal -> IO CDouble
vte_terminal_get_cell_height_scale Ptr Terminal
terminal'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetCellHeightScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellHeightScaleMethodInfo a signature where
    overloadedMethod = terminalGetCellHeightScale

#endif

-- method Terminal::get_cell_width_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cell_width_scale" vte_terminal_get_cell_width_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetCellWidthScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Double
    -- ^ __Returns:__ the terminal\'s cell width scale
terminalGetCellWidthScale :: a -> m Double
terminalGetCellWidthScale terminal :: a
terminal = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CDouble
result <- Ptr Terminal -> IO CDouble
vte_terminal_get_cell_width_scale Ptr Terminal
terminal'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetCellWidthScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellWidthScaleMethodInfo a signature where
    overloadedMethod = terminalGetCellWidthScale

#endif

-- method Terminal::get_char_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_char_height" vte_terminal_get_char_height :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

-- | /No description available in the introspection data./
terminalGetCharHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m CLong
    -- ^ __Returns:__ the height of a character cell
    -- 
    -- Note that this method should rather be called vte_terminal_get_cell_height,
    -- because the return value takes cell-height-scale into account.
terminalGetCharHeight :: a -> m CLong
terminalGetCharHeight terminal :: a
terminal = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_char_height Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetCharHeightMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharHeightMethodInfo a signature where
    overloadedMethod = terminalGetCharHeight

#endif

-- method Terminal::get_char_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_char_width" vte_terminal_get_char_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

-- | /No description available in the introspection data./
terminalGetCharWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m CLong
    -- ^ __Returns:__ the width of a character cell
    -- 
    -- Note that this method should rather be called vte_terminal_get_cell_width,
    -- because the return value takes cell-width-scale into account.
terminalGetCharWidth :: a -> m CLong
terminalGetCharWidth terminal :: a
terminal = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_char_width Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetCharWidthMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharWidthMethodInfo a signature where
    overloadedMethod = terminalGetCharWidth

#endif

-- method Terminal::get_cjk_ambiguous_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cjk_ambiguous_width" vte_terminal_get_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO Int32

-- | Returns whether ambiguous-width characters are narrow or wide.
-- (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
-- the width of ambiguous-width characters is fixed and determined by the encoding
-- itself.)
terminalGetCjkAmbiguousWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Int32
    -- ^ __Returns:__ 1 if ambiguous-width characters are narrow, or 2 if they are wide
terminalGetCjkAmbiguousWidth :: a -> m Int32
terminalGetCjkAmbiguousWidth terminal :: a
terminal = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Int32
result <- Ptr Terminal -> IO Int32
vte_terminal_get_cjk_ambiguous_width Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetCjkAmbiguousWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod = terminalGetCjkAmbiguousWidth

#endif

-- method Terminal::get_color_background_for_draw
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store a #GdbRGBA color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_color_background_for_draw" vte_terminal_get_color_background_for_draw :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Returns the background colour, as used by /@terminal@/ when
-- drawing the background, which may be different from
-- the color set by 'GI.Vte.Objects.Terminal.terminalSetColorBackground'.
-- 
-- Note: you must only call this function while handling the
-- GtkWidget[draw](#signal:draw) signal.
-- 
-- This function is rarely useful. One use for it is if you disable
-- drawing the background (see 'GI.Vte.Objects.Terminal.terminalSetClearBackground')
-- and then need to draw the background yourself.
-- 
-- /Since: 0.54/
terminalGetColorBackgroundForDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Gdk.RGBA.RGBA)
terminalGetColorBackgroundForDraw :: a -> m RGBA
terminalGetColorBackgroundForDraw terminal :: a
terminal = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_get_color_background_for_draw Ptr Terminal
terminal' Ptr RGBA
color
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
color'

#if defined(ENABLE_OVERLOADING)
data TerminalGetColorBackgroundForDrawMethodInfo
instance (signature ~ (m (Gdk.RGBA.RGBA)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetColorBackgroundForDrawMethodInfo a signature where
    overloadedMethod = terminalGetColorBackgroundForDraw

#endif

-- method Terminal::get_column_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_column_count" vte_terminal_get_column_count :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

-- | /No description available in the introspection data./
terminalGetColumnCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m CLong
    -- ^ __Returns:__ the number of columns
terminalGetColumnCount :: a -> m CLong
terminalGetColumnCount terminal :: a
terminal = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_column_count Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetColumnCountMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetColumnCountMethodInfo a signature where
    overloadedMethod = terminalGetColumnCount

#endif

-- method Terminal::get_current_container_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_container_name" vte_terminal_get_current_container_name :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | /No description available in the introspection data./
terminalGetCurrentContainerName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the current
    --   container, or 'P.Nothing'
terminalGetCurrentContainerName :: a -> m (Maybe Text)
terminalGetCurrentContainerName terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_current_container_name Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetCurrentContainerNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentContainerNameMethodInfo a signature where
    overloadedMethod = terminalGetCurrentContainerName

#endif

-- method Terminal::get_current_container_runtime
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_container_runtime" vte_terminal_get_current_container_runtime :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | /No description available in the introspection data./
terminalGetCurrentContainerRuntime ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the runtime
    --   toolset used to set up the current container, or 'P.Nothing'
terminalGetCurrentContainerRuntime :: a -> m (Maybe Text)
terminalGetCurrentContainerRuntime terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_current_container_runtime Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetCurrentContainerRuntimeMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentContainerRuntimeMethodInfo a signature where
    overloadedMethod = terminalGetCurrentContainerRuntime

#endif

-- method Terminal::get_current_directory_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_directory_uri" vte_terminal_get_current_directory_uri :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | /No description available in the introspection data./
terminalGetCurrentDirectoryUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the URI of the current directory of the
    --   process running in the terminal, or 'P.Nothing'
terminalGetCurrentDirectoryUri :: a -> m (Maybe Text)
terminalGetCurrentDirectoryUri terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_current_directory_uri Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetCurrentDirectoryUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentDirectoryUriMethodInfo a signature where
    overloadedMethod = terminalGetCurrentDirectoryUri

#endif

-- method Terminal::get_current_file_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_current_file_uri" vte_terminal_get_current_file_uri :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | /No description available in the introspection data./
terminalGetCurrentFileUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the URI of the current file the
    --   process running in the terminal is operating on, or 'P.Nothing' if
    --   not set
terminalGetCurrentFileUri :: a -> m (Maybe Text)
terminalGetCurrentFileUri terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_current_file_uri Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetCurrentFileUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentFileUriMethodInfo a signature where
    overloadedMethod = terminalGetCurrentFileUri

#endif

-- method Terminal::get_cursor_blink_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Vte" , name = "CursorBlinkMode" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_blink_mode" vte_terminal_get_cursor_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CUInt

-- | Returns the currently set cursor blink mode.
terminalGetCursorBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.CursorBlinkMode
    -- ^ __Returns:__ cursor blink mode.
terminalGetCursorBlinkMode :: a -> m CursorBlinkMode
terminalGetCursorBlinkMode terminal :: a
terminal = IO CursorBlinkMode -> m CursorBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CursorBlinkMode -> m CursorBlinkMode)
-> IO CursorBlinkMode -> m CursorBlinkMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_cursor_blink_mode Ptr Terminal
terminal'
    let result' :: CursorBlinkMode
result' = (Int -> CursorBlinkMode
forall a. Enum a => Int -> a
toEnum (Int -> CursorBlinkMode)
-> (CUInt -> Int) -> CUInt -> CursorBlinkMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CursorBlinkMode -> IO CursorBlinkMode
forall (m :: * -> *) a. Monad m => a -> m a
return CursorBlinkMode
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetCursorBlinkModeMethodInfo
instance (signature ~ (m Vte.Enums.CursorBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorBlinkModeMethodInfo a signature where
    overloadedMethod = terminalGetCursorBlinkMode

#endif

-- method Terminal::get_cursor_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType = TBasicType TLong
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the column, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "row"
--           , argType = TBasicType TLong
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the row, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_position" vte_terminal_get_cursor_position :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr CLong ->                            -- column : TBasicType TLong
    Ptr CLong ->                            -- row : TBasicType TLong
    IO ()

-- | Reads the location of the insertion cursor and returns it.  The row
-- coordinate is absolute.
terminalGetCursorPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ((CLong, CLong))
terminalGetCursorPosition :: a -> m (CLong, CLong)
terminalGetCursorPosition terminal :: a
terminal = IO (CLong, CLong) -> m (CLong, CLong)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (CLong, CLong) -> m (CLong, CLong))
-> IO (CLong, CLong) -> m (CLong, CLong)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CLong
column <- IO (Ptr CLong)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CLong)
    Ptr CLong
row <- IO (Ptr CLong)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CLong)
    Ptr Terminal -> Ptr CLong -> Ptr CLong -> IO ()
vte_terminal_get_cursor_position Ptr Terminal
terminal' Ptr CLong
column Ptr CLong
row
    CLong
column' <- Ptr CLong -> IO CLong
forall a. Storable a => Ptr a -> IO a
peek Ptr CLong
column
    CLong
row' <- Ptr CLong -> IO CLong
forall a. Storable a => Ptr a -> IO a
peek Ptr CLong
row
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CLong -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CLong
column
    Ptr CLong -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CLong
row
    (CLong, CLong) -> IO (CLong, CLong)
forall (m :: * -> *) a. Monad m => a -> m a
return (CLong
column', CLong
row')

#if defined(ENABLE_OVERLOADING)
data TerminalGetCursorPositionMethodInfo
instance (signature ~ (m ((CLong, CLong))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorPositionMethodInfo a signature where
    overloadedMethod = terminalGetCursorPosition

#endif

-- method Terminal::get_cursor_shape
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "CursorShape" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_shape" vte_terminal_get_cursor_shape :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CUInt

-- | Returns the currently set cursor shape.
terminalGetCursorShape ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.CursorShape
    -- ^ __Returns:__ cursor shape.
terminalGetCursorShape :: a -> m CursorShape
terminalGetCursorShape terminal :: a
terminal = IO CursorShape -> m CursorShape
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CursorShape -> m CursorShape)
-> IO CursorShape -> m CursorShape
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_cursor_shape Ptr Terminal
terminal'
    let result' :: CursorShape
result' = (Int -> CursorShape
forall a. Enum a => Int -> a
toEnum (Int -> CursorShape) -> (CUInt -> Int) -> CUInt -> CursorShape
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CursorShape -> IO CursorShape
forall (m :: * -> *) a. Monad m => a -> m a
return CursorShape
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetCursorShapeMethodInfo
instance (signature ~ (m Vte.Enums.CursorShape), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorShapeMethodInfo a signature where
    overloadedMethod = terminalGetCursorShape

#endif

-- method Terminal::get_encoding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_encoding" vte_terminal_get_encoding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{-# DEPRECATED terminalGetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}
-- | Determines the name of the encoding in which the terminal expects data to be
-- encoded, or 'P.Nothing' if UTF-8 is in use.
terminalGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the current encoding for the terminal
terminalGetEncoding :: a -> m (Maybe Text)
terminalGetEncoding terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_encoding Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetEncodingMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetEncodingMethodInfo a signature where
    overloadedMethod = terminalGetEncoding

#endif

-- method Terminal::get_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Pango" , name = "FontDescription" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_font" vte_terminal_get_font :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Pango.FontDescription.FontDescription)

-- | Queries the terminal for information about the fonts which will be
-- used to draw text in the terminal.  The actual font takes the font scale
-- into account, this is not reflected in the return value, the unscaled
-- font is returned.
terminalGetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Pango.FontDescription.FontDescription
    -- ^ __Returns:__ a t'GI.Pango.Structs.FontDescription.FontDescription' describing the font the
    -- terminal uses to render text at the default font scale of 1.0.
terminalGetFont :: a -> m FontDescription
terminalGetFont terminal :: a
terminal = IO FontDescription -> m FontDescription
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontDescription -> m FontDescription)
-> IO FontDescription -> m FontDescription
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr FontDescription
result <- Ptr Terminal -> IO (Ptr FontDescription)
vte_terminal_get_font Ptr Terminal
terminal'
    Text -> Ptr FontDescription -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalGetFont" Ptr FontDescription
result
    FontDescription
result' <- ((ManagedPtr FontDescription -> FontDescription)
-> Ptr FontDescription -> IO FontDescription
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr FontDescription -> FontDescription
Pango.FontDescription.FontDescription) Ptr FontDescription
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    FontDescription -> IO FontDescription
forall (m :: * -> *) a. Monad m => a -> m a
return FontDescription
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetFontMethodInfo
instance (signature ~ (m Pango.FontDescription.FontDescription), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontMethodInfo a signature where
    overloadedMethod = terminalGetFont

#endif

-- method Terminal::get_font_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_font_scale" vte_terminal_get_font_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

-- | /No description available in the introspection data./
terminalGetFontScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Double
    -- ^ __Returns:__ the terminal\'s font scale
terminalGetFontScale :: a -> m Double
terminalGetFontScale terminal :: a
terminal = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CDouble
result <- Ptr Terminal -> IO CDouble
vte_terminal_get_font_scale Ptr Terminal
terminal'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetFontScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontScaleMethodInfo a signature where
    overloadedMethod = terminalGetFontScale

#endif

-- method Terminal::get_geometry_hints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hints"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Geometry" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkGeometry to fill in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_rows"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minimum number of rows to request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_columns"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minimum number of columns to request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_geometry_hints" vte_terminal_get_geometry_hints :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Geometry.Geometry ->            -- hints : TInterface (Name {namespace = "Gdk", name = "Geometry"})
    Int32 ->                                -- min_rows : TBasicType TInt
    Int32 ->                                -- min_columns : TBasicType TInt
    IO ()

{-# DEPRECATED terminalGetGeometryHints ["(Since version 0.52)"] #-}
-- | Fills in some /@hints@/ from /@terminal@/\'s geometry. The hints
-- filled are those covered by the 'GI.Gdk.Flags.WindowHintsResizeInc',
-- 'GI.Gdk.Flags.WindowHintsMinSize' and 'GI.Gdk.Flags.WindowHintsBaseSize' flags.
-- 
-- See 'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.
-- 
-- /@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').
terminalGetGeometryHints ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@minRows@/: the minimum number of rows to request
    -> Int32
    -- ^ /@minColumns@/: the minimum number of columns to request
    -> m (Gdk.Geometry.Geometry)
terminalGetGeometryHints :: a -> Int32 -> Int32 -> m Geometry
terminalGetGeometryHints terminal :: a
terminal minRows :: Int32
minRows minColumns :: Int32
minColumns = IO Geometry -> m Geometry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Geometry -> m Geometry) -> IO Geometry -> m Geometry
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Geometry
hints <- Int -> IO (Ptr Geometry)
forall a. Int -> IO (Ptr a)
callocBytes 56 :: IO (Ptr Gdk.Geometry.Geometry)
    Ptr Terminal
-> Ptr Geometry -> Int32 -> TerminalChildExitedCallback
vte_terminal_get_geometry_hints Ptr Terminal
terminal' Ptr Geometry
hints Int32
minRows Int32
minColumns
    Geometry
hints' <- ((ManagedPtr Geometry -> Geometry) -> Ptr Geometry -> IO Geometry
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Geometry -> Geometry
Gdk.Geometry.Geometry) Ptr Geometry
hints
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Geometry -> IO Geometry
forall (m :: * -> *) a. Monad m => a -> m a
return Geometry
hints'

#if defined(ENABLE_OVERLOADING)
data TerminalGetGeometryHintsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Gdk.Geometry.Geometry)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetGeometryHintsMethodInfo a signature where
    overloadedMethod = terminalGetGeometryHints

#endif

-- method Terminal::get_has_selection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_has_selection" vte_terminal_get_has_selection :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks if the terminal currently contains selected text.  Note that this
-- is different from determining if the terminal is the owner of any
-- t'GI.Gtk.Objects.Clipboard.Clipboard' items.
terminalGetHasSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if part of the text in the terminal is selected.
terminalGetHasSelection :: a -> m Bool
terminalGetHasSelection terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_has_selection Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetHasSelectionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetHasSelectionMethodInfo a signature where
    overloadedMethod = terminalGetHasSelection

#endif

-- method Terminal::get_icon_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_icon_title" vte_terminal_get_icon_title :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{-# DEPRECATED terminalGetIconTitle ["(Since version 0.54)"] #-}
-- | /No description available in the introspection data./
terminalGetIconTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ 'P.Nothing'
terminalGetIconTitle :: a -> m (Maybe Text)
terminalGetIconTitle terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_icon_title Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetIconTitleMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetIconTitleMethodInfo a signature where
    overloadedMethod = terminalGetIconTitle

#endif

-- method Terminal::get_input_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_input_enabled" vte_terminal_get_input_enabled :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Returns whether the terminal allow user input.
terminalGetInputEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
terminalGetInputEnabled :: a -> m Bool
terminalGetInputEnabled terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_input_enabled Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetInputEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetInputEnabledMethodInfo a signature where
    overloadedMethod = terminalGetInputEnabled

#endif

-- method Terminal::get_mouse_autohide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_mouse_autohide" vte_terminal_get_mouse_autohide :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Determines the value of the terminal\'s mouse autohide setting.  When
-- autohiding is enabled, the mouse cursor will be hidden when the user presses
-- a key and shown when the user moves the mouse.  This setting can be changed
-- using 'GI.Vte.Objects.Terminal.terminalSetMouseAutohide'.
terminalGetMouseAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if autohiding is enabled, 'P.False' if not
terminalGetMouseAutohide :: a -> m Bool
terminalGetMouseAutohide terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_mouse_autohide Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetMouseAutohideMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetMouseAutohideMethodInfo a signature where
    overloadedMethod = terminalGetMouseAutohide

#endif

-- method Terminal::get_pty
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "Pty" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_pty" vte_terminal_get_pty :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Vte.Pty.Pty)

-- | Returns the t'GI.Vte.Objects.Pty.Pty' of /@terminal@/.
terminalGetPty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Pty.Pty
    -- ^ __Returns:__ a t'GI.Vte.Objects.Pty.Pty', or 'P.Nothing'
terminalGetPty :: a -> m Pty
terminalGetPty terminal :: a
terminal = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Pty
result <- Ptr Terminal -> IO (Ptr Pty)
vte_terminal_get_pty Ptr Terminal
terminal'
    Text -> Ptr Pty -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalGetPty" Ptr Pty
result
    Pty
result' <- ((ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pty -> Pty
Vte.Pty.Pty) Ptr Pty
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Pty -> IO Pty
forall (m :: * -> *) a. Monad m => a -> m a
return Pty
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetPtyMethodInfo
instance (signature ~ (m Vte.Pty.Pty), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetPtyMethodInfo a signature where
    overloadedMethod = terminalGetPty

#endif

-- method Terminal::get_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_rewrap_on_resize" vte_terminal_get_rewrap_on_resize :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether or not the terminal will rewrap its contents upon resize.
terminalGetRewrapOnResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if rewrapping is enabled, 'P.False' if not
terminalGetRewrapOnResize :: a -> m Bool
terminalGetRewrapOnResize terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_rewrap_on_resize Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetRewrapOnResizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRewrapOnResizeMethodInfo a signature where
    overloadedMethod = terminalGetRewrapOnResize

#endif

-- method Terminal::get_row_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_row_count" vte_terminal_get_row_count :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

-- | /No description available in the introspection data./
terminalGetRowCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m CLong
    -- ^ __Returns:__ the number of rows
terminalGetRowCount :: a -> m CLong
terminalGetRowCount terminal :: a
terminal = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_row_count Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetRowCountMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRowCountMethodInfo a signature where
    overloadedMethod = terminalGetRowCount

#endif

-- method Terminal::get_scroll_on_keystroke
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_scroll_on_keystroke" vte_terminal_get_scroll_on_keystroke :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetScrollOnKeystroke ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ whether or not the terminal will forcibly scroll to the bottom of
    -- the viewable history when the user presses a key.  Modifier keys do not
    -- trigger this behavior.
terminalGetScrollOnKeystroke :: a -> m Bool
terminalGetScrollOnKeystroke terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_scroll_on_keystroke Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollOnKeystrokeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod = terminalGetScrollOnKeystroke

#endif

-- method Terminal::get_scroll_on_output
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_scroll_on_output" vte_terminal_get_scroll_on_output :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetScrollOnOutput ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ whether or not the terminal will forcibly scroll to the bottom of
    -- the viewable history when the new data is received from the child.
terminalGetScrollOnOutput :: a -> m Bool
terminalGetScrollOnOutput terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_scroll_on_output Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollOnOutputMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnOutputMethodInfo a signature where
    overloadedMethod = terminalGetScrollOnOutput

#endif

-- method Terminal::get_scrollback_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TLong)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_scrollback_lines" vte_terminal_get_scrollback_lines :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m CLong
    -- ^ __Returns:__ length of the scrollback buffer used by the terminal.
    -- A negative value means \"infinite scrollback\".
terminalGetScrollbackLines :: a -> m CLong
terminalGetScrollbackLines terminal :: a
terminal = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_scrollback_lines Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollbackLinesMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalGetScrollbackLines

#endif

-- XXX Could not generate method Terminal::get_text
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getText" Terminal) => O.MethodInfo TerminalGetTextMethodInfo o p where
    overloadedMethod = undefined
#endif

-- method Terminal::get_text_blink_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Vte" , name = "TextBlinkMode" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_blink_mode" vte_terminal_get_text_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CUInt

-- | Checks whether or not the terminal will allow blinking text.
-- 
-- /Since: 0.52/
terminalGetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.TextBlinkMode
    -- ^ __Returns:__ the blinking setting
terminalGetTextBlinkMode :: a -> m TextBlinkMode
terminalGetTextBlinkMode terminal :: a
terminal = IO TextBlinkMode -> m TextBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextBlinkMode -> m TextBlinkMode)
-> IO TextBlinkMode -> m TextBlinkMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_text_blink_mode Ptr Terminal
terminal'
    let result' :: TextBlinkMode
result' = (Int -> TextBlinkMode
forall a. Enum a => Int -> a
toEnum (Int -> TextBlinkMode) -> (CUInt -> Int) -> CUInt -> TextBlinkMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    TextBlinkMode -> IO TextBlinkMode
forall (m :: * -> *) a. Monad m => a -> m a
return TextBlinkMode
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextBlinkModeMethodInfo
instance (signature ~ (m Vte.Enums.TextBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalGetTextBlinkMode

#endif

-- XXX Could not generate method Terminal::get_text_include_trailing_spaces
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextIncludeTrailingSpacesMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getTextIncludeTrailingSpaces" Terminal) => O.MethodInfo TerminalGetTextIncludeTrailingSpacesMethodInfo o p where
    overloadedMethod = undefined
#endif

-- XXX Could not generate method Terminal::get_text_range
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextRangeMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getTextRange" Terminal) => O.MethodInfo TerminalGetTextRangeMethodInfo o p where
    overloadedMethod = undefined
#endif

-- method Terminal::get_window_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_window_title" vte_terminal_get_window_title :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | /No description available in the introspection data./
terminalGetWindowTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the window title, or 'P.Nothing'
terminalGetWindowTitle :: a -> m (Maybe Text)
terminalGetWindowTitle terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_window_title Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetWindowTitleMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWindowTitleMethodInfo a signature where
    overloadedMethod = terminalGetWindowTitle

#endif

-- method Terminal::get_word_char_exceptions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_word_char_exceptions" vte_terminal_get_word_char_exceptions :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

-- | Returns the set of characters which will be considered parts of a word
-- when doing word-wise selection, in addition to the default which only
-- considers alphanumeric characters part of a word.
-- 
-- If 'P.Nothing', a built-in set is used.
-- 
-- /Since: 0.40/
terminalGetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a string, or 'P.Nothing'
terminalGetWordCharExceptions :: a -> m (Maybe Text)
terminalGetWordCharExceptions terminal :: a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_word_char_exceptions Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetWordCharExceptionsMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWordCharExceptionsMethodInfo a signature where
    overloadedMethod = terminalGetWordCharExceptions

#endif

-- method Terminal::hyperlink_check_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_hyperlink_check_event" vte_terminal_hyperlink_check_event :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CString

-- | Returns a nonempty string: the target of the explicit hyperlink (printed using the OSC 8
-- escape sequence) at the position of the event, or 'P.Nothing'.
-- 
-- Proper use of the escape sequence should result in URI-encoded URIs with a proper scheme
-- like \"http:\/\/\", \"https:\/\/\", \"file:\/\/\", \"mailto:\" etc. This is, however, not enforced by VTE.
-- The caller must tolerate the returned string potentially not being a valid URI.
-- 
-- /Since: 0.50/
terminalHyperlinkCheckEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.Event.Event
    -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string containing the target of the hyperlink
terminalHyperlinkCheckEvent :: a -> Event -> m Text
terminalHyperlinkCheckEvent terminal :: a
terminal event :: Event
event = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    CString
result <- Ptr Terminal -> Ptr Event -> IO CString
vte_terminal_hyperlink_check_event Ptr Terminal
terminal' Ptr Event
event'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalHyperlinkCheckEvent" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TerminalHyperlinkCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalHyperlinkCheckEventMethodInfo a signature where
    overloadedMethod = terminalHyperlinkCheckEvent

#endif

-- method Terminal::match_add_gregex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gregex"
--           , argType = TInterface Name { namespace = "GLib" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GRegex" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gflags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "RegexMatchFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GRegexMatchFlags to use when matching the regex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_gregex" vte_terminal_match_add_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO Int32

{-# DEPRECATED terminalMatchAddGregex ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' or @/vte_terminal_match_add_regex_full()/@ instead."] #-}
-- | Adds the regular expression /@regex@/ to the list of matching expressions.  When the
-- user moves the mouse cursor over a section of displayed text which matches
-- this expression, the text will be highlighted.
terminalMatchAddGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> GLib.Regex.Regex
    -- ^ /@gregex@/: a t'GI.GLib.Structs.Regex.Regex'
    -> [GLib.Flags.RegexMatchFlags]
    -- ^ /@gflags@/: the t'GI.GLib.Flags.RegexMatchFlags' to use when matching the regex
    -> m Int32
    -- ^ __Returns:__ an integer associated with this expression, or -1 if /@gregex@/ could not be
    --   transformed into a t'GI.Vte.Structs.Regex.Regex' or /@gflags@/ were incompatible
terminalMatchAddGregex :: a -> Regex -> [RegexMatchFlags] -> m Int32
terminalMatchAddGregex terminal :: a
terminal gregex :: Regex
gregex gflags :: [RegexMatchFlags]
gflags = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
gregex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
gregex
    let gflags' :: CUInt
gflags' = [RegexMatchFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RegexMatchFlags]
gflags
    Int32
result <- Ptr Terminal -> Ptr Regex -> CUInt -> IO Int32
vte_terminal_match_add_gregex Ptr Terminal
terminal' Ptr Regex
gregex' CUInt
gflags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Regex
gregex
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TerminalMatchAddGregexMethodInfo
instance (signature ~ (GLib.Regex.Regex -> [GLib.Flags.RegexMatchFlags] -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddGregexMethodInfo a signature where
    overloadedMethod = terminalMatchAddGregex

#endif

-- method Terminal::match_add_regex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "regex"
--           , argType = TInterface Name { namespace = "Vte" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteRegex" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "PCRE2 match flags, or 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_regex" vte_terminal_match_add_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO Int32

-- | Adds the regular expression /@regex@/ to the list of matching expressions.  When the
-- user moves the mouse cursor over a section of displayed text which matches
-- this expression, the text will be highlighted.
-- 
-- /Since: 0.46/
terminalMatchAddRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Regex.Regex
    -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
    -> Word32
    -- ^ /@flags@/: PCRE2 match flags, or 0
    -> m Int32
    -- ^ __Returns:__ an integer associated with this expression
terminalMatchAddRegex :: a -> Regex -> Word32 -> m Int32
terminalMatchAddRegex terminal :: a
terminal regex :: Regex
regex flags :: Word32
flags = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
regex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
regex
    Int32
result <- Ptr Terminal -> Ptr Regex -> Word32 -> IO Int32
vte_terminal_match_add_regex Ptr Terminal
terminal' Ptr Regex
regex' Word32
flags
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Regex
regex
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TerminalMatchAddRegexMethodInfo
instance (signature ~ (Vte.Regex.Regex -> Word32 -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddRegexMethodInfo a signature where
    overloadedMethod = terminalMatchAddRegex

#endif

-- method Terminal::match_check
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the text column" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "row"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the text row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the tag, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check" vte_terminal_match_check :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- column : TBasicType TLong
    CLong ->                                -- row : TBasicType TLong
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

{-# DEPRECATED terminalMatchCheck ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchCheckEvent' instead."] #-}
-- | Checks if the text in and around the specified position matches any of the
-- regular expressions previously set using @/vte_terminal_match_add()/@.  If a
-- match exists, the text string is returned and if /@tag@/ is not 'P.Nothing', the number
-- associated with the matched regular expression will be stored in /@tag@/.
-- 
-- If more than one regular expression has been set with
-- @/vte_terminal_match_add()/@, then expressions are checked in the order in
-- which they were added.
terminalMatchCheck ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> CLong
    -- ^ /@column@/: the text column
    -> CLong
    -- ^ /@row@/: the text row
    -> m ((T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions
terminalMatchCheck :: a -> CLong -> CLong -> m (Text, Int32)
terminalMatchCheck terminal :: a
terminal column :: CLong
column row :: CLong
row = IO (Text, Int32) -> m (Text, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32) -> m (Text, Int32))
-> IO (Text, Int32) -> m (Text, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Int32
tag <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CString
result <- Ptr Terminal -> CLong -> CLong -> Ptr Int32 -> IO CString
vte_terminal_match_check Ptr Terminal
terminal' CLong
column CLong
row Ptr Int32
tag
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalMatchCheck" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    Int32
tag' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
tag
    (Text, Int32) -> IO (Text, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
tag')

#if defined(ENABLE_OVERLOADING)
data TerminalMatchCheckMethodInfo
instance (signature ~ (CLong -> CLong -> m ((T.Text, Int32))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckMethodInfo a signature where
    overloadedMethod = terminalMatchCheck

#endif

-- method Terminal::match_check_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the tag, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check_event" vte_terminal_match_check_event :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

-- | Checks if the text in and around the position of the event matches any of the
-- regular expressions previously set using @/vte_terminal_match_add()/@.  If a
-- match exists, the text string is returned and if /@tag@/ is not 'P.Nothing', the number
-- associated with the matched regular expression will be stored in /@tag@/.
-- 
-- If more than one regular expression has been set with
-- @/vte_terminal_match_add()/@, then expressions are checked in the order in
-- which they were added.
terminalMatchCheckEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.Event.Event
    -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
    -> m ((T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions
terminalMatchCheckEvent :: a -> Event -> m (Text, Int32)
terminalMatchCheckEvent terminal :: a
terminal event :: Event
event = IO (Text, Int32) -> m (Text, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Int32) -> m (Text, Int32))
-> IO (Text, Int32) -> m (Text, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    Ptr Int32
tag <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CString
result <- Ptr Terminal -> Ptr Event -> Ptr Int32 -> IO CString
vte_terminal_match_check_event Ptr Terminal
terminal' Ptr Event
event' Ptr Int32
tag
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalMatchCheckEvent" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    Int32
tag' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
tag
    (Text, Int32) -> IO (Text, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Int32
tag')

#if defined(ENABLE_OVERLOADING)
data TerminalMatchCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m ((T.Text, Int32))), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckEventMethodInfo a signature where
    overloadedMethod = terminalMatchCheckEvent

#endif

-- method Terminal::match_remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the tag of the regex to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_remove" vte_terminal_match_remove :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    IO ()

-- | Removes the regular expression which is associated with the given /@tag@/ from
-- the list of expressions which the terminal will highlight when the user
-- moves the mouse cursor over matching text.
terminalMatchRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex to remove
    -> m ()
terminalMatchRemove :: a -> Int32 -> m ()
terminalMatchRemove terminal :: a
terminal tag :: Int32
tag = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> TerminalChildExitedCallback
vte_terminal_match_remove Ptr Terminal
terminal' Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchRemoveMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveMethodInfo a signature where
    overloadedMethod = terminalMatchRemove

#endif

-- method Terminal::match_remove_all
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_remove_all" vte_terminal_match_remove_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Clears the list of regular expressions the terminal uses to highlight text
-- when the user moves the mouse cursor.
terminalMatchRemoveAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalMatchRemoveAll :: a -> m ()
terminalMatchRemoveAll terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_match_remove_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveAllMethodInfo a signature where
    overloadedMethod = terminalMatchRemoveAll

#endif

-- method Terminal::match_set_cursor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Cursor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GdkCursor which the terminal should use when the pattern is\n  highlighted, or %NULL to use the standard cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor" vte_terminal_match_set_cursor :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
    IO ()

{-# DEPRECATED terminalMatchSetCursor ["(Since version 0.40)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}
-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.  The terminal keeps a reference to /@cursor@/.
terminalMatchSetCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> Maybe (b)
    -- ^ /@cursor@/: the t'GI.Gdk.Objects.Cursor.Cursor' which the terminal should use when the pattern is
    --   highlighted, or 'P.Nothing' to use the standard cursor
    -> m ()
terminalMatchSetCursor :: a -> Int32 -> Maybe b -> m ()
terminalMatchSetCursor terminal :: a
terminal tag :: Int32
tag cursor :: Maybe b
cursor = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Cursor
maybeCursor <- case Maybe b
cursor of
        Nothing -> Ptr Cursor -> IO (Ptr Cursor)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cursor
forall a. Ptr a
nullPtr
        Just jCursor :: b
jCursor -> do
            Ptr Cursor
jCursor' <- b -> IO (Ptr Cursor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCursor
            Ptr Cursor -> IO (Ptr Cursor)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cursor
jCursor'
    Ptr Terminal -> Int32 -> Ptr Cursor -> IO ()
vte_terminal_match_set_cursor Ptr Terminal
terminal' Int32
tag Ptr Cursor
maybeCursor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cursor b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchSetCursorMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) => O.MethodInfo TerminalMatchSetCursorMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursor

#endif

-- method Terminal::match_set_cursor_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_name" vte_terminal_match_set_cursor_name :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CString ->                              -- cursor_name : TBasicType TUTF8
    IO ()

-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.
terminalMatchSetCursorName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> T.Text
    -- ^ /@cursorName@/: the name of the cursor
    -> m ()
terminalMatchSetCursorName :: a -> Int32 -> Text -> m ()
terminalMatchSetCursorName terminal :: a
terminal tag :: Int32
tag cursorName :: Text
cursorName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
cursorName' <- Text -> IO CString
textToCString Text
cursorName
    Ptr Terminal -> Int32 -> CString -> IO ()
vte_terminal_match_set_cursor_name Ptr Terminal
terminal' Int32
tag CString
cursorName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
cursorName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchSetCursorNameMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorNameMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursorName

#endif

-- method Terminal::match_set_cursor_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_type"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "CursorType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkCursorType" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_type" vte_terminal_match_set_cursor_type :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CInt ->                                 -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})
    IO ()

{-# DEPRECATED terminalMatchSetCursorType ["(Since version 0.54)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}
-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.
terminalMatchSetCursorType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> Gdk.Enums.CursorType
    -- ^ /@cursorType@/: a t'GI.Gdk.Enums.CursorType'
    -> m ()
terminalMatchSetCursorType :: a -> Int32 -> CursorType -> m ()
terminalMatchSetCursorType terminal :: a
terminal tag :: Int32
tag cursorType :: CursorType
cursorType = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let cursorType' :: CInt
cursorType' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (CursorType -> Int) -> CursorType -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorType -> Int
forall a. Enum a => a -> Int
fromEnum) CursorType
cursorType
    Ptr Terminal -> Int32 -> CInt -> IO ()
vte_terminal_match_set_cursor_type Ptr Terminal
terminal' Int32
tag CInt
cursorType'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchSetCursorTypeMethodInfo
instance (signature ~ (Int32 -> Gdk.Enums.CursorType -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorTypeMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursorType

#endif

-- method Terminal::paste_clipboard
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_paste_clipboard" vte_terminal_paste_clipboard :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Sends the contents of the @/GDK_SELECTION_CLIPBOARD/@ selection to the
-- terminal\'s child. It\'s called on paste menu item, or when
-- user presses Shift+Insert.
terminalPasteClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalPasteClipboard :: a -> m ()
terminalPasteClipboard terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_paste_clipboard Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalPasteClipboardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPasteClipboardMethodInfo a signature where
    overloadedMethod = terminalPasteClipboard

#endif

-- method Terminal::paste_primary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_paste_primary" vte_terminal_paste_primary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Sends the contents of the @/GDK_SELECTION_PRIMARY/@ selection to the terminal\'s
-- child. The terminal will call also paste the
-- @/GDK_SELECTION_PRIMARY/@ selection when the user clicks with the the second
-- mouse button.
terminalPastePrimary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalPastePrimary :: a -> m ()
terminalPastePrimary terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_paste_primary Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalPastePrimaryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPastePrimaryMethodInfo a signature where
    overloadedMethod = terminalPastePrimary

#endif

-- method Terminal::pty_new_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "Pty" })
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_pty_new_sync" vte_terminal_pty_new_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Vte.Pty.Pty)

-- | Creates a new t'GI.Vte.Objects.Pty.Pty', and sets the emulation property
-- from t'GI.Vte.Objects.Terminal.Terminal':@/emulation/@.
-- 
-- See @/vte_pty_new()/@ for more information.
terminalPtyNewSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@flags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m Vte.Pty.Pty
    -- ^ __Returns:__ a new t'GI.Vte.Objects.Pty.Pty' /(Can throw 'Data.GI.Base.GError.GError')/
terminalPtyNewSync :: a -> [PtyFlags] -> Maybe b -> m Pty
terminalPtyNewSync terminal :: a
terminal flags :: [PtyFlags]
flags cancellable :: Maybe b
cancellable = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let flags' :: CUInt
flags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
flags
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO Pty -> IO () -> IO Pty
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Pty
result <- (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty))
-> (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Pty)
vte_terminal_pty_new_sync Ptr Terminal
terminal' CUInt
flags' Ptr Cancellable
maybeCancellable
        Text -> Ptr Pty -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalPtyNewSync" Ptr Pty
result
        Pty
result' <- ((ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pty -> Pty
Vte.Pty.Pty) Ptr Pty
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Pty -> IO Pty
forall (m :: * -> *) a. Monad m => a -> m a
return Pty
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TerminalPtyNewSyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (b) -> m Vte.Pty.Pty), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalPtyNewSyncMethodInfo a signature where
    overloadedMethod = terminalPtyNewSync

#endif

-- method Terminal::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clear_tabstops"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to reset tabstops"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clear_history"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to empty the terminal's scrollback buffer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_reset" vte_terminal_reset :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- clear_tabstops : TBasicType TBoolean
    CInt ->                                 -- clear_history : TBasicType TBoolean
    IO ()

-- | Resets as much of the terminal\'s internal state as possible, discarding any
-- unprocessed input data, resetting character attributes, cursor state,
-- national character set state, status line, terminal modes (insert\/delete),
-- selection state, and encoding.
terminalReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@clearTabstops@/: whether to reset tabstops
    -> Bool
    -- ^ /@clearHistory@/: whether to empty the terminal\'s scrollback buffer
    -> m ()
terminalReset :: a -> Bool -> Bool -> m ()
terminalReset terminal :: a
terminal clearTabstops :: Bool
clearTabstops clearHistory :: Bool
clearHistory = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let clearTabstops' :: CInt
clearTabstops' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
clearTabstops
    let clearHistory' :: CInt
clearHistory' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
clearHistory
    Ptr Terminal -> CInt -> CInt -> IO ()
vte_terminal_reset Ptr Terminal
terminal' CInt
clearTabstops' CInt
clearHistory'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalResetMethodInfo
instance (signature ~ (Bool -> Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalResetMethodInfo a signature where
    overloadedMethod = terminalReset

#endif

-- method Terminal::search_find_next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_find_next" vte_terminal_search_find_next :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Searches the next string matching the search regex set with
-- 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
terminalSearchFindNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a match was found
terminalSearchFindNext :: a -> m Bool
terminalSearchFindNext terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_find_next Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchFindNextMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindNextMethodInfo a signature where
    overloadedMethod = terminalSearchFindNext

#endif

-- method Terminal::search_find_previous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_find_previous" vte_terminal_search_find_previous :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Searches the previous string matching the search regex set with
-- 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
terminalSearchFindPrevious ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a match was found
terminalSearchFindPrevious :: a -> m Bool
terminalSearchFindPrevious terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_find_previous Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchFindPreviousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindPreviousMethodInfo a signature where
    overloadedMethod = terminalSearchFindPrevious

#endif

-- method Terminal::search_get_gregex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Regex" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_get_gregex" vte_terminal_search_get_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr GLib.Regex.Regex)

{-# DEPRECATED terminalSearchGetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchGetRegex' instead."] #-}
-- | /No description available in the introspection data./
terminalSearchGetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m GLib.Regex.Regex
    -- ^ __Returns:__ 'P.Nothing'
terminalSearchGetGregex :: a -> m Regex
terminalSearchGetGregex terminal :: a
terminal = IO Regex -> m Regex
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
result <- Ptr Terminal -> IO (Ptr Regex)
vte_terminal_search_get_gregex Ptr Terminal
terminal'
    Text -> Ptr Regex -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalSearchGetGregex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Regex -> Regex
GLib.Regex.Regex) Ptr Regex
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO Regex
forall (m :: * -> *) a. Monad m => a -> m a
return Regex
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetGregexMethodInfo
instance (signature ~ (m GLib.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchGetGregex

#endif

-- method Terminal::search_get_regex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "Regex" })
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_get_regex" vte_terminal_search_get_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Vte.Regex.Regex)

-- | /No description available in the introspection data./
-- 
-- /Since: 0.46/
terminalSearchGetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Regex.Regex
    -- ^ __Returns:__ the search t'GI.Vte.Structs.Regex.Regex' regex set in /@terminal@/, or 'P.Nothing'
terminalSearchGetRegex :: a -> m Regex
terminalSearchGetRegex terminal :: a
terminal = IO Regex -> m Regex
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
result <- Ptr Terminal -> IO (Ptr Regex)
vte_terminal_search_get_regex Ptr Terminal
terminal'
    Text -> Ptr Regex -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "terminalSearchGetRegex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Regex -> Regex
Vte.Regex.Regex) Ptr Regex
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO Regex
forall (m :: * -> *) a. Monad m => a -> m a
return Regex
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetRegexMethodInfo
instance (signature ~ (m Vte.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchGetRegex

#endif

-- method Terminal::search_get_wrap_around
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_get_wrap_around" vte_terminal_search_get_wrap_around :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | /No description available in the introspection data./
terminalSearchGetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ whether searching will wrap around
terminalSearchGetWrapAround :: a -> m Bool
terminalSearchGetWrapAround terminal :: a
terminal = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_get_wrap_around Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetWrapAroundMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchGetWrapAround

#endif

-- method Terminal::search_set_gregex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gregex"
--           , argType = TInterface Name { namespace = "GLib" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GRegex, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gflags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "RegexMatchFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GRegexMatchFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_gregex" vte_terminal_search_set_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO ()

{-# DEPRECATED terminalSearchSetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchSetRegex' instead."] #-}
-- | Sets the t'GI.GLib.Structs.Regex.Regex' regex to search for. Unsets the search regex when passed 'P.Nothing'.
terminalSearchSetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (GLib.Regex.Regex)
    -- ^ /@gregex@/: a t'GI.GLib.Structs.Regex.Regex', or 'P.Nothing'
    -> [GLib.Flags.RegexMatchFlags]
    -- ^ /@gflags@/: flags from t'GI.GLib.Flags.RegexMatchFlags'
    -> m ()
terminalSearchSetGregex :: a -> Maybe Regex -> [RegexMatchFlags] -> m ()
terminalSearchSetGregex terminal :: a
terminal gregex :: Maybe Regex
gregex gflags :: [RegexMatchFlags]
gflags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
maybeGregex <- case Maybe Regex
gregex of
        Nothing -> Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
nullPtr
        Just jGregex :: Regex
jGregex -> do
            Ptr Regex
jGregex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
jGregex
            Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
jGregex'
    let gflags' :: CUInt
gflags' = [RegexMatchFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RegexMatchFlags]
gflags
    Ptr Terminal -> Ptr Regex -> CUInt -> IO ()
vte_terminal_search_set_gregex Ptr Terminal
terminal' Ptr Regex
maybeGregex CUInt
gflags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Regex -> (Regex -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Regex
gregex Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetGregexMethodInfo
instance (signature ~ (Maybe (GLib.Regex.Regex) -> [GLib.Flags.RegexMatchFlags] -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchSetGregex

#endif

-- method Terminal::search_set_regex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "regex"
--           , argType = TInterface Name { namespace = "Vte" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteRegex, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "PCRE2 match flags, or 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_regex" vte_terminal_search_set_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO ()

-- | Sets the regex to search for. Unsets the search regex when passed 'P.Nothing'.
-- 
-- /Since: 0.46/
terminalSearchSetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Regex.Regex)
    -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing'
    -> Word32
    -- ^ /@flags@/: PCRE2 match flags, or 0
    -> m ()
terminalSearchSetRegex :: a -> Maybe Regex -> Word32 -> m ()
terminalSearchSetRegex terminal :: a
terminal regex :: Maybe Regex
regex flags :: Word32
flags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
maybeRegex <- case Maybe Regex
regex of
        Nothing -> Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
nullPtr
        Just jRegex :: Regex
jRegex -> do
            Ptr Regex
jRegex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
jRegex
            Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
jRegex'
    Ptr Terminal -> Ptr Regex -> Word32 -> IO ()
vte_terminal_search_set_regex Ptr Terminal
terminal' Ptr Regex
maybeRegex Word32
flags
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Regex -> (Regex -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Regex
regex Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetRegexMethodInfo
instance (signature ~ (Maybe (Vte.Regex.Regex) -> Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchSetRegex

#endif

-- method Terminal::search_set_wrap_around
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wrap_around"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether search should wrap"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_wrap_around" vte_terminal_search_set_wrap_around :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- wrap_around : TBasicType TBoolean
    IO ()

-- | Sets whether search should wrap around to the beginning of the
-- terminal content when reaching its end.
terminalSearchSetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@wrapAround@/: whether search should wrap
    -> m ()
terminalSearchSetWrapAround :: a -> Bool -> m ()
terminalSearchSetWrapAround terminal :: a
terminal wrapAround :: Bool
wrapAround = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let wrapAround' :: CInt
wrapAround' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
wrapAround
    Ptr Terminal -> CInt -> IO ()
vte_terminal_search_set_wrap_around Ptr Terminal
terminal' CInt
wrapAround'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetWrapAroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchSetWrapAround

#endif

-- method Terminal::select_all
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_select_all" vte_terminal_select_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Selects all text within the terminal (including the scrollback buffer).
terminalSelectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalSelectAll :: a -> m ()
terminalSelectAll terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_select_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSelectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSelectAllMethodInfo a signature where
    overloadedMethod = terminalSelectAll

#endif

-- method Terminal::set_allow_bold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_bold"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if the terminal should attempt to draw bold text"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_allow_bold" vte_terminal_set_allow_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- allow_bold : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will attempt to draw bold text,
-- either by using a bold font variant or by repainting text with a different
-- offset.
terminalSetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@allowBold@/: 'P.True' if the terminal should attempt to draw bold text
    -> m ()
terminalSetAllowBold :: a -> Bool -> m ()
terminalSetAllowBold terminal :: a
terminal allowBold :: Bool
allowBold = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let allowBold' :: CInt
allowBold' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
allowBold
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_allow_bold Ptr Terminal
terminal' CInt
allowBold'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAllowBoldMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowBoldMethodInfo a signature where
    overloadedMethod = terminalSetAllowBold

#endif

-- method Terminal::set_allow_hyperlink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_hyperlink"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the terminal should allow hyperlinks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_allow_hyperlink" vte_terminal_set_allow_hyperlink :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- allow_hyperlink : TBasicType TBoolean
    IO ()

-- | Controls whether or not hyperlinks (OSC 8 escape sequence) are allowed.
-- 
-- /Since: 0.50/
terminalSetAllowHyperlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@allowHyperlink@/: 'P.True' if the terminal should allow hyperlinks
    -> m ()
terminalSetAllowHyperlink :: a -> Bool -> m ()
terminalSetAllowHyperlink terminal :: a
terminal allowHyperlink :: Bool
allowHyperlink = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let allowHyperlink' :: CInt
allowHyperlink' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
allowHyperlink
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_allow_hyperlink Ptr Terminal
terminal' CInt
allowHyperlink'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAllowHyperlinkMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowHyperlinkMethodInfo a signature where
    overloadedMethod = terminalSetAllowHyperlink

#endif

-- method Terminal::set_audible_bell
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_audible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the terminal should beep"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_audible_bell" vte_terminal_set_audible_bell :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- is_audible : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will beep when the child outputs the
-- \"bl\" sequence.
terminalSetAudibleBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@isAudible@/: 'P.True' if the terminal should beep
    -> m ()
terminalSetAudibleBell :: a -> Bool -> m ()
terminalSetAudibleBell terminal :: a
terminal isAudible :: Bool
isAudible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let isAudible' :: CInt
isAudible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isAudible
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_audible_bell Ptr Terminal
terminal' CInt
isAudible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAudibleBellMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAudibleBellMethodInfo a signature where
    overloadedMethod = terminalSetAudibleBell

#endif

-- method Terminal::set_backspace_binding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "binding"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "EraseBinding" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteEraseBinding for the backspace key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_backspace_binding" vte_terminal_set_backspace_binding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})
    IO ()

-- | Modifies the terminal\'s backspace key binding, which controls what
-- string or control sequence the terminal sends to its child when the user
-- presses the backspace key.
terminalSetBackspaceBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.EraseBinding
    -- ^ /@binding@/: a t'GI.Vte.Enums.EraseBinding' for the backspace key
    -> m ()
terminalSetBackspaceBinding :: a -> EraseBinding -> m ()
terminalSetBackspaceBinding terminal :: a
terminal binding :: EraseBinding
binding = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let binding' :: CUInt
binding' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EraseBinding -> Int) -> EraseBinding -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EraseBinding -> Int
forall a. Enum a => a -> Int
fromEnum) EraseBinding
binding
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_backspace_binding Ptr Terminal
terminal' CUInt
binding'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetBackspaceBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBackspaceBindingMethodInfo a signature where
    overloadedMethod = terminalSetBackspaceBinding

#endif

-- method Terminal::set_bold_is_bright
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bold_is_bright"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if bold should also enable bright"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_bold_is_bright" vte_terminal_set_bold_is_bright :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- bold_is_bright : TBasicType TBoolean
    IO ()

-- | Sets whether the SGR 1 attribute also switches to the bright counterpart
-- of the first 8 palette colors, in addition to making them bold (legacy behavior)
-- or if SGR 1 only enables bold and leaves the color intact.
-- 
-- /Since: 0.52/
terminalSetBoldIsBright ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@boldIsBright@/: 'P.True' if bold should also enable bright
    -> m ()
terminalSetBoldIsBright :: a -> Bool -> m ()
terminalSetBoldIsBright terminal :: a
terminal boldIsBright :: Bool
boldIsBright = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let boldIsBright' :: CInt
boldIsBright' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
boldIsBright
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_bold_is_bright Ptr Terminal
terminal' CInt
boldIsBright'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetBoldIsBrightMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBoldIsBrightMethodInfo a signature where
    overloadedMethod = terminalSetBoldIsBright

#endif

-- method Terminal::set_cell_height_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the cell height scale"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cell_height_scale" vte_terminal_set_cell_height_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

-- | Sets the terminal\'s cell height scale to /@scale@/.
-- 
-- This can be used to increase the line spacing. (The font\'s height is not affected.)
-- Valid values go from 1.0 (default) to 2.0 (\"double spacing\").
-- 
-- /Since: 0.52/
terminalSetCellHeightScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the cell height scale
    -> m ()
terminalSetCellHeightScale :: a -> Double -> m ()
terminalSetCellHeightScale terminal :: a
terminal scale :: Double
scale = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_cell_height_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCellHeightScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellHeightScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellHeightScale

#endif

-- method Terminal::set_cell_width_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the cell width scale"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cell_width_scale" vte_terminal_set_cell_width_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

-- | Sets the terminal\'s cell width scale to /@scale@/.
-- 
-- This can be used to increase the letter spacing. (The font\'s width is not affected.)
-- Valid values go from 1.0 (default) to 2.0.
-- 
-- /Since: 0.52/
terminalSetCellWidthScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the cell width scale
    -> m ()
terminalSetCellWidthScale :: a -> Double -> m ()
terminalSetCellWidthScale terminal :: a
terminal scale :: Double
scale = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_cell_width_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCellWidthScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellWidthScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellWidthScale

#endif

-- method Terminal::set_cjk_ambiguous_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "either 1 (narrow) or 2 (wide)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cjk_ambiguous_width" vte_terminal_set_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- width : TBasicType TInt
    IO ()

-- | This setting controls whether ambiguous-width characters are narrow or wide.
-- (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
-- the width of ambiguous-width characters is fixed and determined by the encoding
-- itself.)
terminalSetCjkAmbiguousWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@width@/: either 1 (narrow) or 2 (wide)
    -> m ()
terminalSetCjkAmbiguousWidth :: a -> Int32 -> m ()
terminalSetCjkAmbiguousWidth terminal :: a
terminal width :: Int32
width = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> TerminalChildExitedCallback
vte_terminal_set_cjk_ambiguous_width Ptr Terminal
terminal' Int32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCjkAmbiguousWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod = terminalSetCjkAmbiguousWidth

#endif

-- method Terminal::set_clear_background
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_clear_background" vte_terminal_set_clear_background :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether to paint the background with the background colour.
-- The default is 'P.True'.
-- 
-- This function is rarely useful. One use for it is to add a background
-- image to the terminal.
-- 
-- /Since: 0.52/
terminalSetClearBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -> m ()
terminalSetClearBackground :: a -> Bool -> m ()
terminalSetClearBackground terminal :: a
terminal setting :: Bool
setting = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_clear_background Ptr Terminal
terminal' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetClearBackgroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetClearBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetClearBackground

#endif

-- method Terminal::set_color_background
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new background color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_background" vte_terminal_set_color_background :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the background color for text which does not have a specific background
-- color assigned.  Only has effect when no background image is set and when
-- the terminal is not transparent.
terminalSetColorBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.RGBA.RGBA
    -- ^ /@background@/: the new background color
    -> m ()
terminalSetColorBackground :: a -> RGBA -> m ()
terminalSetColorBackground terminal :: a
terminal background :: RGBA
background = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
background' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
background
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_background Ptr Terminal
terminal' Ptr RGBA
background'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
background
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorBackgroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetColorBackground

#endif

-- method Terminal::set_color_bold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bold"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new bold color or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_bold" vte_terminal_set_color_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- bold : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the color used to draw bold text in the default foreground color.
-- If /@bold@/ is 'P.Nothing' then the default color is used.
terminalSetColorBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@bold@/: the new bold color or 'P.Nothing'
    -> m ()
terminalSetColorBold :: a -> Maybe RGBA -> m ()
terminalSetColorBold terminal :: a
terminal bold :: Maybe RGBA
bold = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeBold <- case Maybe RGBA
bold of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jBold :: RGBA
jBold -> do
            Ptr RGBA
jBold' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jBold
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jBold'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_bold Ptr Terminal
terminal' Ptr RGBA
maybeBold
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
bold RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorBoldMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBoldMethodInfo a signature where
    overloadedMethod = terminalSetColorBold

#endif

-- method Terminal::set_color_cursor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for the text cursor, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_cursor" vte_terminal_set_color_cursor :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- cursor_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the background color for text which is under the cursor.  If 'P.Nothing', text
-- under the cursor will be drawn with foreground and background colors
-- reversed.
terminalSetColorCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@cursorBackground@/: the new color to use for the text cursor, or 'P.Nothing'
    -> m ()
terminalSetColorCursor :: a -> Maybe RGBA -> m ()
terminalSetColorCursor terminal :: a
terminal cursorBackground :: Maybe RGBA
cursorBackground = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeCursorBackground <- case Maybe RGBA
cursorBackground of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jCursorBackground :: RGBA
jCursorBackground -> do
            Ptr RGBA
jCursorBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jCursorBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jCursorBackground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_cursor Ptr Terminal
terminal' Ptr RGBA
maybeCursorBackground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
cursorBackground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorCursorMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorMethodInfo a signature where
    overloadedMethod = terminalSetColorCursor

#endif

-- method Terminal::set_color_cursor_foreground
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for the text cursor, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_cursor_foreground" vte_terminal_set_color_cursor_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- cursor_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the foreground color for text which is under the cursor.  If 'P.Nothing', text
-- under the cursor will be drawn with foreground and background colors
-- reversed.
-- 
-- /Since: 0.44/
terminalSetColorCursorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@cursorForeground@/: the new color to use for the text cursor, or 'P.Nothing'
    -> m ()
terminalSetColorCursorForeground :: a -> Maybe RGBA -> m ()
terminalSetColorCursorForeground terminal :: a
terminal cursorForeground :: Maybe RGBA
cursorForeground = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeCursorForeground <- case Maybe RGBA
cursorForeground of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jCursorForeground :: RGBA
jCursorForeground -> do
            Ptr RGBA
jCursorForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jCursorForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jCursorForeground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_cursor_foreground Ptr Terminal
terminal' Ptr RGBA
maybeCursorForeground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
cursorForeground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorCursorForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorCursorForeground

#endif

-- method Terminal::set_color_foreground
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new foreground color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_foreground" vte_terminal_set_color_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the foreground color used to draw normal text.
terminalSetColorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.RGBA.RGBA
    -- ^ /@foreground@/: the new foreground color
    -> m ()
terminalSetColorForeground :: a -> RGBA -> m ()
terminalSetColorForeground terminal :: a
terminal foreground :: RGBA
foreground = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
foreground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
foreground
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_foreground Ptr Terminal
terminal' Ptr RGBA
foreground'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
foreground
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorForegroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorForeground

#endif

-- method Terminal::set_color_highlight
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight_background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for highlighted text, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight" vte_terminal_set_color_highlight :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- highlight_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the background color for text which is highlighted.  If 'P.Nothing',
-- it is unset.  If neither highlight background nor highlight foreground are set,
-- highlighted text (which is usually highlighted because it is selected) will
-- be drawn with foreground and background colors reversed.
terminalSetColorHighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@highlightBackground@/: the new color to use for highlighted text, or 'P.Nothing'
    -> m ()
terminalSetColorHighlight :: a -> Maybe RGBA -> m ()
terminalSetColorHighlight terminal :: a
terminal highlightBackground :: Maybe RGBA
highlightBackground = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeHighlightBackground <- case Maybe RGBA
highlightBackground of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jHighlightBackground :: RGBA
jHighlightBackground -> do
            Ptr RGBA
jHighlightBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jHighlightBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jHighlightBackground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_highlight Ptr Terminal
terminal' Ptr RGBA
maybeHighlightBackground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
highlightBackground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorHighlightMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlight

#endif

-- method Terminal::set_color_highlight_foreground
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight_foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for highlighted text, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight_foreground" vte_terminal_set_color_highlight_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- highlight_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

-- | Sets the foreground color for text which is highlighted.  If 'P.Nothing',
-- it is unset.  If neither highlight background nor highlight foreground are set,
-- highlighted text (which is usually highlighted because it is selected) will
-- be drawn with foreground and background colors reversed.
terminalSetColorHighlightForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@highlightForeground@/: the new color to use for highlighted text, or 'P.Nothing'
    -> m ()
terminalSetColorHighlightForeground :: a -> Maybe RGBA -> m ()
terminalSetColorHighlightForeground terminal :: a
terminal highlightForeground :: Maybe RGBA
highlightForeground = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeHighlightForeground <- case Maybe RGBA
highlightForeground of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jHighlightForeground :: RGBA
jHighlightForeground -> do
            Ptr RGBA
jHighlightForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jHighlightForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jHighlightForeground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_highlight_foreground Ptr Terminal
terminal' Ptr RGBA
maybeHighlightForeground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
highlightForeground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorHighlightForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlightForeground

#endif

-- method Terminal::set_colors
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new foreground color, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new background color, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "palette"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 4
--                 (TInterface Name { namespace = "Gdk" , name = "RGBA" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color palette" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "palette_size"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of entries in @palette"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "palette_size"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of entries in @palette"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_colors" vte_terminal_set_colors :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- palette : TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"}))
    Word64 ->                               -- palette_size : TBasicType TUInt64
    IO ()

-- | /@palette@/ specifies the new values for the 256 palette colors: 8 standard colors,
-- their 8 bright counterparts, 6x6x6 color cube, and 24 grayscale colors.
-- Omitted entries will default to a hardcoded value.
-- 
-- /@paletteSize@/ must be 0, 8, 16, 232 or 256.
-- 
-- If /@foreground@/ is 'P.Nothing' and /@paletteSize@/ is greater than 0, the new foreground
-- color is taken from /@palette@/[7].  If /@background@/ is 'P.Nothing' and /@paletteSize@/ is
-- greater than 0, the new background color is taken from /@palette@/[0].
terminalSetColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@foreground@/: the new foreground color, or 'P.Nothing'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@background@/: the new background color, or 'P.Nothing'
    -> Maybe ([Gdk.RGBA.RGBA])
    -- ^ /@palette@/: the color palette
    -> m ()
terminalSetColors :: a -> Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()
terminalSetColors terminal :: a
terminal foreground :: Maybe RGBA
foreground background :: Maybe RGBA
background palette :: Maybe [RGBA]
palette = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let paletteSize :: Word64
paletteSize = case Maybe [RGBA]
palette of
            Nothing -> 0
            Just jPalette :: [RGBA]
jPalette -> Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ [RGBA] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [RGBA]
jPalette
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeForeground <- case Maybe RGBA
foreground of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jForeground :: RGBA
jForeground -> do
            Ptr RGBA
jForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jForeground'
    Ptr RGBA
maybeBackground <- case Maybe RGBA
background of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jBackground :: RGBA
jBackground -> do
            Ptr RGBA
jBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jBackground'
    Ptr RGBA
maybePalette <- case Maybe [RGBA]
palette of
        Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just jPalette :: [RGBA]
jPalette -> do
            [Ptr RGBA]
jPalette' <- (RGBA -> IO (Ptr RGBA)) -> [RGBA] -> IO [Ptr RGBA]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [RGBA]
jPalette
            Ptr RGBA
jPalette'' <- Int -> [Ptr RGBA] -> IO (Ptr RGBA)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 32 [Ptr RGBA]
jPalette'
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jPalette''
    Ptr Terminal -> Ptr RGBA -> Ptr RGBA -> Ptr RGBA -> Word64 -> IO ()
vte_terminal_set_colors Ptr Terminal
terminal' Ptr RGBA
maybeForeground Ptr RGBA
maybeBackground Ptr RGBA
maybePalette Word64
paletteSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
foreground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
background RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe [RGBA] -> ([RGBA] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [RGBA]
palette ((RGBA -> IO ()) -> [RGBA] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
    Ptr RGBA -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr RGBA
maybePalette
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorsMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> Maybe (Gdk.RGBA.RGBA) -> Maybe ([Gdk.RGBA.RGBA]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorsMethodInfo a signature where
    overloadedMethod = terminalSetColors

#endif

-- method Terminal::set_cursor_blink_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "CursorBlinkMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VteCursorBlinkMode to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_blink_mode" vte_terminal_set_cursor_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})
    IO ()

-- | Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'
-- will use the t'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.
terminalSetCursorBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.CursorBlinkMode
    -- ^ /@mode@/: the t'GI.Vte.Enums.CursorBlinkMode' to use
    -> m ()
terminalSetCursorBlinkMode :: a -> CursorBlinkMode -> m ()
terminalSetCursorBlinkMode terminal :: a
terminal mode :: CursorBlinkMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (CursorBlinkMode -> Int) -> CursorBlinkMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorBlinkMode -> Int
forall a. Enum a => a -> Int
fromEnum) CursorBlinkMode
mode
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_cursor_blink_mode Ptr Terminal
terminal' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCursorBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.CursorBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetCursorBlinkMode

#endif

-- method Terminal::set_cursor_shape
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shape"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "CursorShape" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VteCursorShape to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_shape" vte_terminal_set_cursor_shape :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- shape : TInterface (Name {namespace = "Vte", name = "CursorShape"})
    IO ()

-- | Sets the shape of the cursor drawn.
terminalSetCursorShape ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.CursorShape
    -- ^ /@shape@/: the t'GI.Vte.Enums.CursorShape' to use
    -> m ()
terminalSetCursorShape :: a -> CursorShape -> m ()
terminalSetCursorShape terminal :: a
terminal shape :: CursorShape
shape = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let shape' :: CUInt
shape' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CursorShape -> Int) -> CursorShape -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorShape -> Int
forall a. Enum a => a -> Int
fromEnum) CursorShape
shape
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_cursor_shape Ptr Terminal
terminal' CUInt
shape'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCursorShapeMethodInfo
instance (signature ~ (Vte.Enums.CursorShape -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorShapeMethodInfo a signature where
    overloadedMethod = terminalSetCursorShape

#endif

-- method Terminal::set_default_colors
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_default_colors" vte_terminal_set_default_colors :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Reset the terminal palette to reasonable compiled-in default color.
terminalSetDefaultColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalSetDefaultColors :: a -> m ()
terminalSetDefaultColors terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_set_default_colors Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetDefaultColorsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDefaultColorsMethodInfo a signature where
    overloadedMethod = terminalSetDefaultColors

#endif

-- method Terminal::set_delete_binding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "binding"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "EraseBinding" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteEraseBinding for the delete key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_delete_binding" vte_terminal_set_delete_binding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})
    IO ()

-- | Modifies the terminal\'s delete key binding, which controls what
-- string or control sequence the terminal sends to its child when the user
-- presses the delete key.
terminalSetDeleteBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.EraseBinding
    -- ^ /@binding@/: a t'GI.Vte.Enums.EraseBinding' for the delete key
    -> m ()
terminalSetDeleteBinding :: a -> EraseBinding -> m ()
terminalSetDeleteBinding terminal :: a
terminal binding :: EraseBinding
binding = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let binding' :: CUInt
binding' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EraseBinding -> Int) -> EraseBinding -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EraseBinding -> Int
forall a. Enum a => a -> Int
fromEnum) EraseBinding
binding
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_delete_binding Ptr Terminal
terminal' CUInt
binding'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetDeleteBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDeleteBindingMethodInfo a signature where
    overloadedMethod = terminalSetDeleteBinding

#endif

-- method Terminal::set_encoding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "codeset"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GIConv target, or %NULL to use UTF-8"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_set_encoding" vte_terminal_set_encoding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- codeset : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED terminalSetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}
-- | Changes the encoding the terminal will expect data from the child to
-- be encoded with.  For certain terminal types, applications executing in the
-- terminal can change the encoding. If /@codeset@/ is 'P.Nothing', it uses \"UTF-8\".
-- 
-- Note: Support for non-UTF-8 is deprecated and may get removed altogether.
-- Instead of this function, you should use a wrapper like luit(1) when
-- spawning the child process.
terminalSetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (T.Text)
    -- ^ /@codeset@/: a valid @/GIConv/@ target, or 'P.Nothing' to use UTF-8
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalSetEncoding :: a -> Maybe Text -> m ()
terminalSetEncoding terminal :: a
terminal codeset :: Maybe Text
codeset = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
maybeCodeset <- case Maybe Text
codeset of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jCodeset :: Text
jCodeset -> do
            CString
jCodeset' <- Text -> IO CString
textToCString Text
jCodeset
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCodeset'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal -> CString -> Ptr (Ptr GError) -> IO CInt
vte_terminal_set_encoding Ptr Terminal
terminal' CString
maybeCodeset
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCodeset
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCodeset
     )

#if defined(ENABLE_OVERLOADING)
data TerminalSetEncodingMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetEncodingMethodInfo a signature where
    overloadedMethod = terminalSetEncoding

#endif

-- method Terminal::set_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_desc"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "FontDescription" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #PangoFontDescription for the desired font, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font" vte_terminal_set_font :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

-- | Sets the font used for rendering all text displayed by the terminal,
-- overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal
-- will immediately attempt to load the desired font, retrieve its
-- metrics, and attempt to resize itself to keep the same number of rows
-- and columns.  The font scale is applied to the specified font.
terminalSetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Pango.FontDescription.FontDescription)
    -- ^ /@fontDesc@/: a t'GI.Pango.Structs.FontDescription.FontDescription' for the desired font, or 'P.Nothing'
    -> m ()
terminalSetFont :: a -> Maybe FontDescription -> m ()
terminalSetFont terminal :: a
terminal fontDesc :: Maybe FontDescription
fontDesc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr FontDescription
maybeFontDesc <- case Maybe FontDescription
fontDesc of
        Nothing -> Ptr FontDescription -> IO (Ptr FontDescription)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDescription
forall a. Ptr a
nullPtr
        Just jFontDesc :: FontDescription
jFontDesc -> do
            Ptr FontDescription
jFontDesc' <- FontDescription -> IO (Ptr FontDescription)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontDescription
jFontDesc
            Ptr FontDescription -> IO (Ptr FontDescription)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDescription
jFontDesc'
    Ptr Terminal -> Ptr FontDescription -> IO ()
vte_terminal_set_font Ptr Terminal
terminal' Ptr FontDescription
maybeFontDesc
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe FontDescription -> (FontDescription -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe FontDescription
fontDesc FontDescription -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetFontMethodInfo
instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontMethodInfo a signature where
    overloadedMethod = terminalSetFont

#endif

-- method Terminal::set_font_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the font scale" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font_scale" vte_terminal_set_font_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

-- | Sets the terminal\'s font scale to /@scale@/.
terminalSetFontScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the font scale
    -> m ()
terminalSetFontScale :: a -> Double -> m ()
terminalSetFontScale terminal :: a
terminal scale :: Double
scale = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_font_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetFontScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontScaleMethodInfo a signature where
    overloadedMethod = terminalSetFontScale

#endif

-- method Terminal::set_geometry_hints_for_window
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWindow" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_geometry_hints_for_window" vte_terminal_set_geometry_hints_for_window :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gtk.Window.Window ->                -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

{-# DEPRECATED terminalSetGeometryHintsForWindow ["(Since version 0.52)"] #-}
-- | Sets /@terminal@/ as /@window@/\'s geometry widget. See
-- 'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.
-- 
-- /@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').
terminalSetGeometryHintsForWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> b
    -- ^ /@window@/: a t'GI.Gtk.Objects.Window.Window'
    -> m ()
terminalSetGeometryHintsForWindow :: a -> b -> m ()
terminalSetGeometryHintsForWindow terminal :: a
terminal window :: b
window = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Window
window' <- b -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
window
    Ptr Terminal -> Ptr Window -> IO ()
vte_terminal_set_geometry_hints_for_window Ptr Terminal
terminal' Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
window
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetGeometryHintsForWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) => O.MethodInfo TerminalSetGeometryHintsForWindowMethodInfo a signature where
    overloadedMethod = terminalSetGeometryHintsForWindow

#endif

-- method Terminal::set_input_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable user input"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_input_enabled" vte_terminal_set_input_enabled :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Enables or disables user input. When user input is disabled,
-- the terminal\'s child will not receive any key press, or mouse button
-- press or motion events sent to it.
terminalSetInputEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enabled@/: whether to enable user input
    -> m ()
terminalSetInputEnabled :: a -> Bool -> m ()
terminalSetInputEnabled terminal :: a
terminal enabled :: Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_input_enabled Ptr Terminal
terminal' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetInputEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetInputEnabledMethodInfo a signature where
    overloadedMethod = terminalSetInputEnabled

#endif

-- method Terminal::set_mouse_autohide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the mouse pointer should autohide"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_mouse_autohide" vte_terminal_set_mouse_autohide :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Changes the value of the terminal\'s mouse autohide setting.  When autohiding
-- is enabled, the mouse cursor will be hidden when the user presses a key and
-- shown when the user moves the mouse.  This setting can be read using
-- 'GI.Vte.Objects.Terminal.terminalGetMouseAutohide'.
terminalSetMouseAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@setting@/: whether the mouse pointer should autohide
    -> m ()
terminalSetMouseAutohide :: a -> Bool -> m ()
terminalSetMouseAutohide terminal :: a
terminal setting :: Bool
setting = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_mouse_autohide Ptr Terminal
terminal' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetMouseAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetMouseAutohideMethodInfo a signature where
    overloadedMethod = terminalSetMouseAutohide

#endif

-- method Terminal::set_pty
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pty"
--           , argType = TInterface Name { namespace = "Vte" , name = "Pty" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VtePty, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_pty" vte_terminal_set_pty :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Pty.Pty ->                      -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})
    IO ()

-- | Sets /@pty@/ as the PTY to use in /@terminal@/.
-- Use 'P.Nothing' to unset the PTY.
terminalSetPty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Vte.Pty.IsPty b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (b)
    -- ^ /@pty@/: a t'GI.Vte.Objects.Pty.Pty', or 'P.Nothing'
    -> m ()
terminalSetPty :: a -> Maybe b -> m ()
terminalSetPty terminal :: a
terminal pty :: Maybe b
pty = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Pty
maybePty <- case Maybe b
pty of
        Nothing -> Ptr Pty -> IO (Ptr Pty)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pty
forall a. Ptr a
nullPtr
        Just jPty :: b
jPty -> do
            Ptr Pty
jPty' <- b -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jPty
            Ptr Pty -> IO (Ptr Pty)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pty
jPty'
    Ptr Terminal -> Ptr Pty -> IO ()
vte_terminal_set_pty Ptr Terminal
terminal' Ptr Pty
maybePty
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
pty b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetPtyMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Vte.Pty.IsPty b) => O.MethodInfo TerminalSetPtyMethodInfo a signature where
    overloadedMethod = terminalSetPty

#endif

-- method Terminal::set_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rewrap"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the terminal should rewrap on resize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_rewrap_on_resize" vte_terminal_set_rewrap_on_resize :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- rewrap : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will rewrap its contents, including
-- the scrollback history, whenever the terminal\'s width changes.
terminalSetRewrapOnResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@rewrap@/: 'P.True' if the terminal should rewrap on resize
    -> m ()
terminalSetRewrapOnResize :: a -> Bool -> m ()
terminalSetRewrapOnResize terminal :: a
terminal rewrap :: Bool
rewrap = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let rewrap' :: CInt
rewrap' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
rewrap
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_rewrap_on_resize Ptr Terminal
terminal' CInt
rewrap'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetRewrapOnResizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetRewrapOnResizeMethodInfo a signature where
    overloadedMethod = terminalSetRewrapOnResize

#endif

-- method Terminal::set_scroll_on_keystroke
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scroll"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether the terminal should scroll on keystrokes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_keystroke" vte_terminal_set_scroll_on_keystroke :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the user presses a key.  Modifier keys do not
-- trigger this behavior.
terminalSetScrollOnKeystroke ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@scroll@/: whether the terminal should scroll on keystrokes
    -> m ()
terminalSetScrollOnKeystroke :: a -> Bool -> m ()
terminalSetScrollOnKeystroke terminal :: a
terminal scroll :: Bool
scroll = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scroll' :: CInt
scroll' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
scroll
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_on_keystroke Ptr Terminal
terminal' CInt
scroll'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollOnKeystrokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnKeystroke

#endif

-- method Terminal::set_scroll_on_output
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scroll"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the terminal should scroll on output"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_output" vte_terminal_set_scroll_on_output :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the new data is received from the child.
terminalSetScrollOnOutput ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@scroll@/: whether the terminal should scroll on output
    -> m ()
terminalSetScrollOnOutput :: a -> Bool -> m ()
terminalSetScrollOnOutput terminal :: a
terminal scroll :: Bool
scroll = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scroll' :: CInt
scroll' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
scroll
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_on_output Ptr Terminal
terminal' CInt
scroll'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollOnOutputMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnOutputMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnOutput

#endif

-- method Terminal::set_scroll_speed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scroll_speed"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "move the buffer by this number of lines while scrolling"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_speed" vte_terminal_set_scroll_speed :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Word32 ->                               -- scroll_speed : TBasicType TUInt
    IO ()

-- | Sets the number of lines by which the buffer is moved when
-- scrolling with a mouse wheel. Setting it to zero will cause the
-- buffer to be moved by an amount depending on the number of visible
-- rows the widget can display.
terminalSetScrollSpeed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Word32
    -- ^ /@scrollSpeed@/: move the buffer by this number of lines while scrolling
    -> m ()
terminalSetScrollSpeed :: a -> Word32 -> m ()
terminalSetScrollSpeed terminal :: a
terminal scrollSpeed :: Word32
scrollSpeed = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> Word32 -> IO ()
vte_terminal_set_scroll_speed Ptr Terminal
terminal' Word32
scrollSpeed
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollSpeedMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollSpeedMethodInfo a signature where
    overloadedMethod = terminalSetScrollSpeed

#endif

-- method Terminal::set_scrollback_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "lines"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of the history buffer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scrollback_lines" vte_terminal_set_scrollback_lines :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- lines : TBasicType TLong
    IO ()

-- | Sets the length of the scrollback buffer used by the terminal.  The size of
-- the scrollback buffer will be set to the larger of this value and the number
-- of visible rows the widget can display, so 0 can safely be used to disable
-- scrollback.
-- 
-- A negative value means \"infinite scrollback\".
-- 
-- Note that this setting only affects the normal screen buffer.
-- No scrollback is allowed on the alternate screen buffer.
terminalSetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> CLong
    -- ^ /@lines@/: the length of the history buffer
    -> m ()
terminalSetScrollbackLines :: a -> CLong -> m ()
terminalSetScrollbackLines terminal :: a
terminal lines :: CLong
lines = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> CLong -> IO ()
vte_terminal_set_scrollback_lines Ptr Terminal
terminal' CLong
lines
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollbackLinesMethodInfo
instance (signature ~ (CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalSetScrollbackLines

#endif

-- method Terminal::set_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "columns"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the desired number of columns"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rows"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the desired number of rows"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_size" vte_terminal_set_size :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- columns : TBasicType TLong
    CLong ->                                -- rows : TBasicType TLong
    IO ()

-- | Attempts to change the terminal\'s size in terms of rows and columns.  If
-- the attempt succeeds, the widget will resize itself to the proper size.
terminalSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> CLong
    -- ^ /@columns@/: the desired number of columns
    -> CLong
    -- ^ /@rows@/: the desired number of rows
    -> m ()
terminalSetSize :: a -> CLong -> CLong -> m ()
terminalSetSize terminal :: a
terminal columns :: CLong
columns rows :: CLong
rows = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> CLong -> CLong -> IO ()
vte_terminal_set_size Ptr Terminal
terminal' CLong
columns CLong
rows
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetSizeMethodInfo
instance (signature ~ (CLong -> CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetSizeMethodInfo a signature where
    overloadedMethod = terminalSetSize

#endif

-- method Terminal::set_text_blink_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text_blink_mode"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "TextBlinkMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VteTextBlinkMode to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_text_blink_mode" vte_terminal_set_text_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- text_blink_mode : TInterface (Name {namespace = "Vte", name = "TextBlinkMode"})
    IO ()

-- | Controls whether or not the terminal will allow blinking text.
-- 
-- /Since: 0.52/
terminalSetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.TextBlinkMode
    -- ^ /@textBlinkMode@/: the t'GI.Vte.Enums.TextBlinkMode' to use
    -> m ()
terminalSetTextBlinkMode :: a -> TextBlinkMode -> m ()
terminalSetTextBlinkMode terminal :: a
terminal textBlinkMode :: TextBlinkMode
textBlinkMode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let textBlinkMode' :: CUInt
textBlinkMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextBlinkMode -> Int) -> TextBlinkMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBlinkMode -> Int
forall a. Enum a => a -> Int
fromEnum) TextBlinkMode
textBlinkMode
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_text_blink_mode Ptr Terminal
terminal' CUInt
textBlinkMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetTextBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.TextBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetTextBlinkMode

#endif

-- method Terminal::set_word_char_exceptions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exceptions"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a string of ASCII punctuation characters, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_word_char_exceptions" vte_terminal_set_word_char_exceptions :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- exceptions : TBasicType TUTF8
    IO ()

-- | With this function you can provide a set of characters which will
-- be considered parts of a word when doing word-wise selection, in
-- addition to the default which only considers alphanumeric characters
-- part of a word.
-- 
-- The characters in /@exceptions@/ must be non-alphanumeric, each character
-- must occur only once, and if /@exceptions@/ contains the character
-- U+002D HYPHEN-MINUS, it must be at the start of the string.
-- 
-- Use 'P.Nothing' to reset the set of exception characters to the default.
-- 
-- /Since: 0.40/
terminalSetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@exceptions@/: a string of ASCII punctuation characters, or 'P.Nothing'
    -> m ()
terminalSetWordCharExceptions :: a -> Text -> m ()
terminalSetWordCharExceptions terminal :: a
terminal exceptions :: Text
exceptions = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
exceptions' <- Text -> IO CString
textToCString Text
exceptions
    Ptr Terminal -> CString -> IO ()
vte_terminal_set_word_char_exceptions Ptr Terminal
terminal' CString
exceptions'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
exceptions'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetWordCharExceptionsMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetWordCharExceptionsMethodInfo a signature where
    overloadedMethod = terminalSetWordCharExceptions

#endif

-- method Terminal::spawn_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pty_flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "working_directory"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of a directory the command should start\n  in, or %NULL to use the current working directory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "child's argument vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "envv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a list of environment\n  variables to be added to the environment before starting the process, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spawn_flags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "SpawnFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GSpawnFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup"
--           , argType =
--               TInterface
--                 Name { namespace = "GLib" , name = "SpawnChildSetupFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an extra child setup function to run in the child just before exec(), or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 7
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @child_setup"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_pid"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the child PID, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_spawn_sync" vte_terminal_spawn_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    CString ->                              -- working_directory : TBasicType TUTF8
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)
    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})
    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})
    Ptr () ->                               -- child_setup_data : TBasicType TPtr
    Ptr Int32 ->                            -- child_pid : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED terminalSpawnSync ["(Since version 0.48)","Use @/vte_terminal_spawn_async()/@ instead."] #-}
-- | Starts the specified command under a newly-allocated controlling
-- pseudo-terminal.  The /@argv@/ and /@envv@/ lists should be 'P.Nothing'-terminated.
-- The \"TERM\" environment variable is automatically set to a default value,
-- but can be overridden from /@envv@/.
-- /@ptyFlags@/ controls logging the session to the specified system log files.
-- 
-- Note that 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' will always be added to /@spawnFlags@/.
-- 
-- Note that all open file descriptors will be closed in the child. If you want
-- to keep some file descriptor open for use in the child process, you need to
-- use a child setup function that unsets the FD_CLOEXEC flag on that file
-- descriptor.
-- 
-- See @/vte_pty_new()/@, 'GI.GLib.Functions.spawnAsync' and 'GI.Vte.Objects.Terminal.terminalWatchChild' for more information.
-- 
-- Beginning with 0.52, sets PWD to /@workingDirectory@/ in order to preserve symlink components.
-- The caller should also make sure that symlinks were preserved while constructing the value of /@workingDirectory@/,
-- e.g. by using 'GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri', 'GI.GLib.Functions.getCurrentDir' or @/get_current_dir_name()/@.
terminalSpawnSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@ptyFlags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (T.Text)
    -- ^ /@workingDirectory@/: the name of a directory the command should start
    --   in, or 'P.Nothing' to use the current working directory
    -> [[Char]]
    -- ^ /@argv@/: child\'s argument vector
    -> Maybe ([[Char]])
    -- ^ /@envv@/: a list of environment
    --   variables to be added to the environment before starting the process, or 'P.Nothing'
    -> [GLib.Flags.SpawnFlags]
    -- ^ /@spawnFlags@/: flags from t'GI.GLib.Flags.SpawnFlags'
    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
    -- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m (Int32)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalSpawnSync :: a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe (IO ())
-> Maybe b
-> m Int32
terminalSpawnSync terminal :: a
terminal ptyFlags :: [PtyFlags]
ptyFlags workingDirectory :: Maybe Text
workingDirectory argv :: [String]
argv envv :: Maybe [String]
envv spawnFlags :: [SpawnFlags]
spawnFlags childSetup :: Maybe (IO ())
childSetup cancellable :: Maybe b
cancellable = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let ptyFlags' :: CUInt
ptyFlags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
ptyFlags
    CString
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jWorkingDirectory :: Text
jWorkingDirectory -> do
            CString
jWorkingDirectory' <- Text -> IO CString
textToCString Text
jWorkingDirectory
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jWorkingDirectory'
    Ptr CString
argv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
argv
    Ptr CString
maybeEnvv <- case Maybe [String]
envv of
        Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
        Just jEnvv :: [String]
jEnvv -> do
            Ptr CString
jEnvv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
jEnvv
            Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jEnvv'
    let spawnFlags' :: CUInt
spawnFlags' = [SpawnFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SpawnFlags]
spawnFlags
    FunPtr C_SpawnChildSetupFunc
maybeChildSetup <- case Maybe (IO ())
childSetup of
        Nothing -> FunPtr C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SpawnChildSetupFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jChildSetup :: IO ()
jChildSetup -> do
            FunPtr C_SpawnChildSetupFunc
jChildSetup' <- C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
GLib.Callbacks.mk_SpawnChildSetupFunc (Maybe (Ptr (FunPtr C_SpawnChildSetupFunc))
-> C_SpawnChildSetupFunc -> C_SpawnChildSetupFunc
GLib.Callbacks.wrap_SpawnChildSetupFunc Maybe (Ptr (FunPtr C_SpawnChildSetupFunc))
forall a. Maybe a
Nothing (IO () -> C_SpawnChildSetupFunc
GLib.Callbacks.drop_closures_SpawnChildSetupFunc IO ()
jChildSetup))
            FunPtr C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SpawnChildSetupFunc
jChildSetup'
    Ptr Int32
childPid <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    let childSetupData :: Ptr a
childSetupData = Ptr a
forall a. Ptr a
nullPtr
    IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> CUInt
-> CString
-> Ptr CString
-> Ptr CString
-> CUInt
-> FunPtr C_SpawnChildSetupFunc
-> Ptr ()
-> Ptr Int32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
vte_terminal_spawn_sync Ptr Terminal
terminal' CUInt
ptyFlags' CString
maybeWorkingDirectory Ptr CString
argv' Ptr CString
maybeEnvv CUInt
spawnFlags' FunPtr C_SpawnChildSetupFunc
maybeChildSetup Ptr ()
forall a. Ptr a
childSetupData Ptr Int32
childPid Ptr Cancellable
maybeCancellable
        Int32
childPid' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
childPid
        Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SpawnChildSetupFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SpawnChildSetupFunc
maybeChildSetup
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
        Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
childPid'
     ) (do
        Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SpawnChildSetupFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SpawnChildSetupFunc
maybeChildSetup
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
     )

#if defined(ENABLE_OVERLOADING)
data TerminalSpawnSyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (T.Text) -> [[Char]] -> Maybe ([[Char]]) -> [GLib.Flags.SpawnFlags] -> Maybe (GLib.Callbacks.SpawnChildSetupFunc) -> Maybe (b) -> m (Int32)), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalSpawnSyncMethodInfo a signature where
    overloadedMethod = terminalSpawnSync

#endif

-- method Terminal::unselect_all
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_unselect_all" vte_terminal_unselect_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

-- | Clears the current selection.
terminalUnselectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalUnselectAll :: a -> m ()
terminalUnselectAll terminal :: a
terminal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_unselect_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalUnselectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalUnselectAllMethodInfo a signature where
    overloadedMethod = terminalUnselectAll

#endif

-- method Terminal::watch_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_pid"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GPid" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_watch_child" vte_terminal_watch_child :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- child_pid : TBasicType TInt
    IO ()

-- | Watches /@childPid@/. When the process exists, the [childExited]("GI.Vte.Objects.Terminal#signal:childExited")
-- signal will be called with the child\'s exit status.
-- 
-- Prior to calling this function, a t'GI.Vte.Objects.Pty.Pty' must have been set in /@terminal@/
-- using 'GI.Vte.Objects.Terminal.terminalSetPty'.
-- When the child exits, the terminal\'s t'GI.Vte.Objects.Pty.Pty' will be set to 'P.Nothing'.
-- 
-- Note: @/g_child_watch_add()/@ or 'GI.GLib.Functions.childWatchAdd' must not have
-- been called for /@childPid@/, nor a t'GI.GLib.Structs.Source.Source' for it been created with
-- 'GI.GLib.Functions.childWatchSourceNew'.
-- 
-- Note: when using the 'GI.GLib.Functions.spawnAsync' family of functions,
-- the 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' flag MUST have been passed.
terminalWatchChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@childPid@/: a @/GPid/@
    -> m ()
terminalWatchChild :: a -> Int32 -> m ()
terminalWatchChild terminal :: a
terminal childPid :: Int32
childPid = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> TerminalChildExitedCallback
vte_terminal_watch_child Ptr Terminal
terminal' Int32
childPid
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalWatchChildMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalWatchChildMethodInfo a signature where
    overloadedMethod = terminalWatchChild

#endif

-- method Terminal::write_contents_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "OutputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOutputStream to write to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "WriteFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #VteWriteFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable object, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_write_contents_sync" vte_terminal_write_contents_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "WriteFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Write contents of the current contents of /@terminal@/ (including any
-- scrollback history) to /@stream@/ according to /@flags@/.
-- 
-- If /@cancellable@/ is not 'P.Nothing', then the operation can be cancelled by triggering
-- the cancellable object from another thread. If the operation was cancelled,
-- the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned in /@error@/.
-- 
-- This is a synchronous operation and will make the widget (and input
-- processing) during the write operation, which may take a long time
-- depending on scrollback history and /@stream@/ availability for writing.
terminalWriteContentsSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> b
    -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream' to write to
    -> Vte.Enums.WriteFlags
    -- ^ /@flags@/: a set of t'GI.Vte.Enums.WriteFlags'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' object, or 'P.Nothing'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalWriteContentsSync :: a -> b -> WriteFlags -> Maybe c -> m ()
terminalWriteContentsSync terminal :: a
terminal stream :: b
stream flags :: WriteFlags
flags cancellable :: Maybe c
cancellable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr OutputStream
stream' <- b -> IO (Ptr OutputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
stream
    let flags' :: CUInt
flags' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WriteFlags -> Int) -> WriteFlags -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriteFlags -> Int
forall a. Enum a => a -> Int
fromEnum) WriteFlags
flags
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> Ptr OutputStream
-> CUInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
vte_terminal_write_contents_sync Ptr Terminal
terminal' Ptr OutputStream
stream' CUInt
flags' Ptr Cancellable
maybeCancellable
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
stream
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TerminalWriteContentsSyncMethodInfo
instance (signature ~ (b -> Vte.Enums.WriteFlags -> Maybe (c) -> m ()), MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TerminalWriteContentsSyncMethodInfo a signature where
    overloadedMethod = terminalWriteContentsSync

#endif