{-# 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)
    TerminalSpawnWithFdsAsyncMethodInfo     ,
#endif

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [addAccelerator]("GI.Gtk.Objects.Widget#g:method:addAccelerator"), [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addDeviceEvents]("GI.Gtk.Objects.Widget#g:method:addDeviceEvents"), [addEvents]("GI.Gtk.Objects.Widget#g:method:addEvents"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childNotify]("GI.Gtk.Objects.Widget#g:method:childNotify"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [copyClipboard]("GI.Vte.Objects.Terminal#g:method:copyClipboard"), [copyClipboardFormat]("GI.Vte.Objects.Terminal#g:method:copyClipboardFormat"), [copyPrimary]("GI.Vte.Objects.Terminal#g:method:copyPrimary"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [dragBegin]("GI.Gtk.Objects.Widget#g:method:dragBegin"), [dragBeginWithCoordinates]("GI.Gtk.Objects.Widget#g:method:dragBeginWithCoordinates"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [dragDestAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddImageTargets"), [dragDestAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddTextTargets"), [dragDestAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddUriTargets"), [dragDestFindTarget]("GI.Gtk.Objects.Widget#g:method:dragDestFindTarget"), [dragDestGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestGetTargetList"), [dragDestGetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestGetTrackMotion"), [dragDestSet]("GI.Gtk.Objects.Widget#g:method:dragDestSet"), [dragDestSetProxy]("GI.Gtk.Objects.Widget#g:method:dragDestSetProxy"), [dragDestSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestSetTargetList"), [dragDestSetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestSetTrackMotion"), [dragDestUnset]("GI.Gtk.Objects.Widget#g:method:dragDestUnset"), [dragGetData]("GI.Gtk.Objects.Widget#g:method:dragGetData"), [dragHighlight]("GI.Gtk.Objects.Widget#g:method:dragHighlight"), [dragSourceAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddImageTargets"), [dragSourceAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddTextTargets"), [dragSourceAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddUriTargets"), [dragSourceGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceGetTargetList"), [dragSourceSet]("GI.Gtk.Objects.Widget#g:method:dragSourceSet"), [dragSourceSetIconGicon]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconGicon"), [dragSourceSetIconName]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconName"), [dragSourceSetIconPixbuf]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconPixbuf"), [dragSourceSetIconStock]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconStock"), [dragSourceSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceSetTargetList"), [dragSourceUnset]("GI.Gtk.Objects.Widget#g:method:dragSourceUnset"), [dragUnhighlight]("GI.Gtk.Objects.Widget#g:method:dragUnhighlight"), [draw]("GI.Gtk.Objects.Widget#g:method:draw"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [feed]("GI.Vte.Objects.Terminal#g:method:feed"), [feedChild]("GI.Vte.Objects.Terminal#g:method:feedChild"), [feedChildBinary]("GI.Vte.Objects.Terminal#g:method:feedChildBinary"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeChildNotify]("GI.Gtk.Objects.Widget#g:method:freezeChildNotify"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabAdd]("GI.Gtk.Objects.Widget#g:method:grabAdd"), [grabDefault]("GI.Gtk.Objects.Widget#g:method:grabDefault"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabRemove]("GI.Gtk.Objects.Widget#g:method:grabRemove"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGrab]("GI.Gtk.Objects.Widget#g:method:hasGrab"), [hasRcStyle]("GI.Gtk.Objects.Widget#g:method:hasRcStyle"), [hasScreen]("GI.Gtk.Objects.Widget#g:method:hasScreen"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [hideOnDelete]("GI.Gtk.Objects.Widget#g:method:hideOnDelete"), [hyperlinkCheckEvent]("GI.Vte.Objects.Terminal#g:method:hyperlinkCheckEvent"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [inputShapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:inputShapeCombineRegion"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [matchAddGregex]("GI.Vte.Objects.Terminal#g:method:matchAddGregex"), [matchAddRegex]("GI.Vte.Objects.Terminal#g:method:matchAddRegex"), [matchCheck]("GI.Vte.Objects.Terminal#g:method:matchCheck"), [matchCheckEvent]("GI.Vte.Objects.Terminal#g:method:matchCheckEvent"), [matchRemove]("GI.Vte.Objects.Terminal#g:method:matchRemove"), [matchRemoveAll]("GI.Vte.Objects.Terminal#g:method:matchRemoveAll"), [matchSetCursor]("GI.Vte.Objects.Terminal#g:method:matchSetCursor"), [matchSetCursorName]("GI.Vte.Objects.Terminal#g:method:matchSetCursorName"), [matchSetCursorType]("GI.Vte.Objects.Terminal#g:method:matchSetCursorType"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [pasteClipboard]("GI.Vte.Objects.Terminal#g:method:pasteClipboard"), [pastePrimary]("GI.Vte.Objects.Terminal#g:method:pastePrimary"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [ptyNewSync]("GI.Vte.Objects.Terminal#g:method:ptyNewSync"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueComputeExpand]("GI.Gtk.Objects.Widget#g:method:queueComputeExpand"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueDrawArea]("GI.Gtk.Objects.Widget#g:method:queueDrawArea"), [queueDrawRegion]("GI.Gtk.Objects.Widget#g:method:queueDrawRegion"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [queueResizeNoRedraw]("GI.Gtk.Objects.Widget#g:method:queueResizeNoRedraw"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [reset]("GI.Vte.Objects.Terminal#g:method:reset"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [searchFindNext]("GI.Vte.Objects.Terminal#g:method:searchFindNext"), [searchFindPrevious]("GI.Vte.Objects.Terminal#g:method:searchFindPrevious"), [searchGetGregex]("GI.Vte.Objects.Terminal#g:method:searchGetGregex"), [searchGetRegex]("GI.Vte.Objects.Terminal#g:method:searchGetRegex"), [searchGetWrapAround]("GI.Vte.Objects.Terminal#g:method:searchGetWrapAround"), [searchSetGregex]("GI.Vte.Objects.Terminal#g:method:searchSetGregex"), [searchSetRegex]("GI.Vte.Objects.Terminal#g:method:searchSetRegex"), [searchSetWrapAround]("GI.Vte.Objects.Terminal#g:method:searchSetWrapAround"), [selectAll]("GI.Vte.Objects.Terminal#g:method:selectAll"), [sendExpose]("GI.Gtk.Objects.Widget#g:method:sendExpose"), [sendFocusChange]("GI.Gtk.Objects.Widget#g:method:sendFocusChange"), [shapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:shapeCombineRegion"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [showAll]("GI.Gtk.Objects.Widget#g:method:showAll"), [showNow]("GI.Gtk.Objects.Widget#g:method:showNow"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [sizeAllocateWithBaseline]("GI.Gtk.Objects.Widget#g:method:sizeAllocateWithBaseline"), [sizeRequest]("GI.Gtk.Objects.Widget#g:method:sizeRequest"), [spawnAsync]("GI.Vte.Objects.Terminal#g:method:spawnAsync"), [spawnSync]("GI.Vte.Objects.Terminal#g:method:spawnSync"), [spawnWithFdsAsync]("GI.Vte.Objects.Terminal#g:method:spawnWithFdsAsync"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [styleAttach]("GI.Gtk.Objects.Widget#g:method:styleAttach"), [styleGetProperty]("GI.Gtk.Objects.Widget#g:method:styleGetProperty"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unregisterWindow]("GI.Gtk.Objects.Widget#g:method:unregisterWindow"), [unselectAll]("GI.Vte.Objects.Terminal#g:method:unselectAll"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [watchChild]("GI.Vte.Objects.Terminal#g:method:watchChild"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [writeContentsSync]("GI.Vte.Objects.Terminal#g:method:writeContentsSync").
-- 
-- ==== Getters
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAllowBold]("GI.Vte.Objects.Terminal#g:method:getAllowBold"), [getAllowHyperlink]("GI.Vte.Objects.Terminal#g:method:getAllowHyperlink"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getAudibleBell]("GI.Vte.Objects.Terminal#g:method:getAudibleBell"), [getBoldIsBright]("GI.Vte.Objects.Terminal#g:method:getBoldIsBright"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCellHeightScale]("GI.Vte.Objects.Terminal#g:method:getCellHeightScale"), [getCellWidthScale]("GI.Vte.Objects.Terminal#g:method:getCellWidthScale"), [getCharHeight]("GI.Vte.Objects.Terminal#g:method:getCharHeight"), [getCharWidth]("GI.Vte.Objects.Terminal#g:method:getCharWidth"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getCjkAmbiguousWidth]("GI.Vte.Objects.Terminal#g:method:getCjkAmbiguousWidth"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColorBackgroundForDraw]("GI.Vte.Objects.Terminal#g:method:getColorBackgroundForDraw"), [getColumnCount]("GI.Vte.Objects.Terminal#g:method:getColumnCount"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getCurrentContainerName]("GI.Vte.Objects.Terminal#g:method:getCurrentContainerName"), [getCurrentContainerRuntime]("GI.Vte.Objects.Terminal#g:method:getCurrentContainerRuntime"), [getCurrentDirectoryUri]("GI.Vte.Objects.Terminal#g:method:getCurrentDirectoryUri"), [getCurrentFileUri]("GI.Vte.Objects.Terminal#g:method:getCurrentFileUri"), [getCursorBlinkMode]("GI.Vte.Objects.Terminal#g:method:getCursorBlinkMode"), [getCursorPosition]("GI.Vte.Objects.Terminal#g:method:getCursorPosition"), [getCursorShape]("GI.Vte.Objects.Terminal#g:method:getCursorShape"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:getDeviceEnabled"), [getDeviceEvents]("GI.Gtk.Objects.Widget#g:method:getDeviceEvents"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:getDoubleBuffered"), [getEnableBidi]("GI.Vte.Objects.Terminal#g:method:getEnableBidi"), [getEnableShaping]("GI.Vte.Objects.Terminal#g:method:getEnableShaping"), [getEnableSixel]("GI.Vte.Objects.Terminal#g:method:getEnableSixel"), [getEncoding]("GI.Vte.Objects.Terminal#g:method:getEncoding"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFont]("GI.Vte.Objects.Terminal#g:method:getFont"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFontScale]("GI.Vte.Objects.Terminal#g:method:getFontScale"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGeometryHints]("GI.Vte.Objects.Terminal#g:method:getGeometryHints"), [getHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasSelection]("GI.Vte.Objects.Terminal#g:method:getHasSelection"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getIconTitle]("GI.Vte.Objects.Terminal#g:method:getIconTitle"), [getInputEnabled]("GI.Vte.Objects.Terminal#g:method:getInputEnabled"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginLeft]("GI.Gtk.Objects.Widget#g:method:getMarginLeft"), [getMarginRight]("GI.Gtk.Objects.Widget#g:method:getMarginRight"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getMouseAutohide]("GI.Vte.Objects.Terminal#g:method:getMouseAutohide"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPreferredHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredHeight"), [getPreferredHeightAndBaselineForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightAndBaselineForWidth"), [getPreferredHeightForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredWidthForHeight"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPty]("GI.Vte.Objects.Terminal#g:method:getPty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getRewrapOnResize]("GI.Vte.Objects.Terminal#g:method:getRewrapOnResize"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getRowCount]("GI.Vte.Objects.Terminal#g:method:getRowCount"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getScrollOnKeystroke]("GI.Vte.Objects.Terminal#g:method:getScrollOnKeystroke"), [getScrollOnOutput]("GI.Vte.Objects.Terminal#g:method:getScrollOnOutput"), [getScrollbackLines]("GI.Vte.Objects.Terminal#g:method:getScrollbackLines"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Vte.Objects.Terminal#g:method:getText"), [getTextBlinkMode]("GI.Vte.Objects.Terminal#g:method:getTextBlinkMode"), [getTextIncludeTrailingSpaces]("GI.Vte.Objects.Terminal#g:method:getTextIncludeTrailingSpaces"), [getTextRange]("GI.Vte.Objects.Terminal#g:method:getTextRange"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow"), [getWindowTitle]("GI.Vte.Objects.Terminal#g:method:getWindowTitle"), [getWordCharExceptions]("GI.Vte.Objects.Terminal#g:method:getWordCharExceptions").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAllowBold]("GI.Vte.Objects.Terminal#g:method:setAllowBold"), [setAllowHyperlink]("GI.Vte.Objects.Terminal#g:method:setAllowHyperlink"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setAudibleBell]("GI.Vte.Objects.Terminal#g:method:setAudibleBell"), [setBackspaceBinding]("GI.Vte.Objects.Terminal#g:method:setBackspaceBinding"), [setBoldIsBright]("GI.Vte.Objects.Terminal#g:method:setBoldIsBright"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCellHeightScale]("GI.Vte.Objects.Terminal#g:method:setCellHeightScale"), [setCellWidthScale]("GI.Vte.Objects.Terminal#g:method:setCellWidthScale"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCjkAmbiguousWidth]("GI.Vte.Objects.Terminal#g:method:setCjkAmbiguousWidth"), [setClearBackground]("GI.Vte.Objects.Terminal#g:method:setClearBackground"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setColorBackground]("GI.Vte.Objects.Terminal#g:method:setColorBackground"), [setColorBold]("GI.Vte.Objects.Terminal#g:method:setColorBold"), [setColorCursor]("GI.Vte.Objects.Terminal#g:method:setColorCursor"), [setColorCursorForeground]("GI.Vte.Objects.Terminal#g:method:setColorCursorForeground"), [setColorForeground]("GI.Vte.Objects.Terminal#g:method:setColorForeground"), [setColorHighlight]("GI.Vte.Objects.Terminal#g:method:setColorHighlight"), [setColorHighlightForeground]("GI.Vte.Objects.Terminal#g:method:setColorHighlightForeground"), [setColors]("GI.Vte.Objects.Terminal#g:method:setColors"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setCursorBlinkMode]("GI.Vte.Objects.Terminal#g:method:setCursorBlinkMode"), [setCursorShape]("GI.Vte.Objects.Terminal#g:method:setCursorShape"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDefaultColors]("GI.Vte.Objects.Terminal#g:method:setDefaultColors"), [setDeleteBinding]("GI.Vte.Objects.Terminal#g:method:setDeleteBinding"), [setDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:setDeviceEnabled"), [setDeviceEvents]("GI.Gtk.Objects.Widget#g:method:setDeviceEvents"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:setDoubleBuffered"), [setEnableBidi]("GI.Vte.Objects.Terminal#g:method:setEnableBidi"), [setEnableShaping]("GI.Vte.Objects.Terminal#g:method:setEnableShaping"), [setEnableSixel]("GI.Vte.Objects.Terminal#g:method:setEnableSixel"), [setEncoding]("GI.Vte.Objects.Terminal#g:method:setEncoding"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFont]("GI.Vte.Objects.Terminal#g:method:setFont"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setFontScale]("GI.Vte.Objects.Terminal#g:method:setFontScale"), [setGeometryHintsForWindow]("GI.Vte.Objects.Terminal#g:method:setGeometryHintsForWindow"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setInputEnabled]("GI.Vte.Objects.Terminal#g:method:setInputEnabled"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMouseAutohide]("GI.Vte.Objects.Terminal#g:method:setMouseAutohide"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPty]("GI.Vte.Objects.Terminal#g:method:setPty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setRewrapOnResize]("GI.Vte.Objects.Terminal#g:method:setRewrapOnResize"), [setScrollOnKeystroke]("GI.Vte.Objects.Terminal#g:method:setScrollOnKeystroke"), [setScrollOnOutput]("GI.Vte.Objects.Terminal#g:method:setScrollOnOutput"), [setScrollSpeed]("GI.Vte.Objects.Terminal#g:method:setScrollSpeed"), [setScrollbackLines]("GI.Vte.Objects.Terminal#g:method:setScrollbackLines"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSize]("GI.Vte.Objects.Terminal#g:method:setSize"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTextBlinkMode]("GI.Vte.Objects.Terminal#g:method:setTextBlinkMode"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setVadjustment"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow"), [setWordCharExceptions]("GI.Vte.Objects.Terminal#g:method:setWordCharExceptions").

#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                  ,


-- ** getEnableBidi #method:getEnableBidi#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableBidiMethodInfo         ,
#endif
    terminalGetEnableBidi                   ,


-- ** getEnableShaping #method:getEnableShaping#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableShapingMethodInfo      ,
#endif
    terminalGetEnableShaping                ,


-- ** getEnableSixel #method:getEnableSixel#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableSixelMethodInfo        ,
#endif
    terminalGetEnableSixel                  ,


-- ** 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              ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextMethodInfo               ,
#endif
    terminalGetText                         ,


-- ** getTextBlinkMode #method:getTextBlinkMode#

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


-- ** getTextIncludeTrailingSpaces #method:getTextIncludeTrailingSpaces#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextIncludeTrailingSpacesMethodInfo,
#endif
    terminalGetTextIncludeTrailingSpaces    ,


-- ** getTextRange #method:getTextRange#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextRangeMethodInfo          ,
#endif
    terminalGetTextRange                    ,


-- ** 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                ,


-- ** setEnableBidi #method:setEnableBidi#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableBidiMethodInfo         ,
#endif
    terminalSetEnableBidi                   ,


-- ** setEnableShaping #method:setEnableShaping#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableShapingMethodInfo      ,
#endif
    terminalSetEnableShaping                ,


-- ** setEnableSixel #method:setEnableSixel#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableSixelMethodInfo        ,
#endif
    terminalSetEnableSixel                  ,


-- ** 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           ,


-- ** spawnAsync #method:spawnAsync#

#if defined(ENABLE_OVERLOADING)
    TerminalSpawnAsyncMethodInfo            ,
#endif
    terminalSpawnAsync                      ,


-- ** 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,
-- by using a bold font variant.

#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


-- ** enableBidi #attr:enableBidi#
-- | Controls whether or not the terminal will perform bidirectional text rendering.
-- 
-- /Since: 0.58/

#if defined(ENABLE_OVERLOADING)
    TerminalEnableBidiPropertyInfo          ,
#endif
    constructTerminalEnableBidi             ,
    getTerminalEnableBidi                   ,
    setTerminalEnableBidi                   ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableBidi                      ,
#endif


-- ** enableShaping #attr:enableShaping#
-- | Controls whether or not the terminal will shape Arabic text.
-- 
-- /Since: 0.58/

#if defined(ENABLE_OVERLOADING)
    TerminalEnableShapingPropertyInfo       ,
#endif
    constructTerminalEnableShaping          ,
    getTerminalEnableShaping                ,
    setTerminalEnableShaping                ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableShaping                   ,
#endif


-- ** enableSixel #attr:enableSixel#
-- | Controls whether SIXEL image support is enabled.
-- 
-- /Since: 0.62/

#if defined(ENABLE_OVERLOADING)
    TerminalEnableSixelPropertyInfo         ,
#endif
    constructTerminalEnableSixel            ,
    getTerminalEnableSixel                  ,
    setTerminalEnableSixel                  ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableSixel                     ,
#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   ,


-- ** shellPrecmd #signal:shellPrecmd#

    C_TerminalShellPrecmdCallback           ,
    TerminalShellPrecmdCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalShellPrecmdSignalInfo           ,
#endif
    afterTerminalShellPrecmd                ,
    genClosure_TerminalShellPrecmd          ,
    mk_TerminalShellPrecmdCallback          ,
    noTerminalShellPrecmdCallback           ,
    onTerminalShellPrecmd                   ,
    wrap_TerminalShellPrecmdCallback        ,


-- ** shellPreexec #signal:shellPreexec#

    C_TerminalShellPreexecCallback          ,
    TerminalShellPreexecCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalShellPreexecSignalInfo          ,
#endif
    afterTerminalShellPreexec               ,
    genClosure_TerminalShellPreexec         ,
    mk_TerminalShellPreexecCallback         ,
    noTerminalShellPreexecCallback          ,
    onTerminalShellPreexec                  ,
    wrap_TerminalShellPreexecCallback       ,


-- ** 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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 Control.Monad.IO.Class as MIO
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 GHC.Records as R

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 qualified GI.Vte.Callbacks as Vte.Callbacks
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.CharAttributes as Vte.CharAttributes
import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex

-- | Memory-managed wrapper type.
newtype Terminal = Terminal (SP.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)

instance SP.ManagedPtrNewtype Terminal where
    toManagedPtr :: Terminal -> ManagedPtr Terminal
toManagedPtr (Terminal ManagedPtr Terminal
p) = ManagedPtr Terminal
p

foreign import ccall "vte_terminal_get_type"
    c_vte_terminal_get_type :: IO B.Types.GType

instance B.Types.TypedObject Terminal where
    glibType :: IO GType
glibType = IO GType
c_vte_terminal_get_type

instance B.Types.GObject Terminal

-- | Type class for types which can be safely cast to `Terminal`, for instance with `toTerminal`.
class (SP.GObject o, O.IsDescendantOf Terminal o) => IsTerminal o
instance (SP.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 :: (MIO.MonadIO m, IsTerminal o) => o -> m Terminal
toTerminal :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m Terminal
toTerminal = IO Terminal -> m Terminal
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Terminal -> Terminal
Terminal

-- | Convert 'Terminal' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Terminal) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vte_terminal_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Terminal -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Terminal
P.Nothing = Ptr GValue -> Ptr Terminal -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Terminal
forall a. Ptr a
FP.nullPtr :: FP.Ptr Terminal)
    gvalueSet_ Ptr GValue
gv (P.Just Terminal
obj) = Terminal -> (Ptr Terminal -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Terminal
obj (Ptr GValue -> Ptr Terminal -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Terminal)
gvalueGet_ Ptr GValue
gv = do
        Ptr Terminal
ptr <- Ptr GValue -> IO (Ptr Terminal)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Terminal)
        if Ptr Terminal
ptr Ptr Terminal -> Ptr Terminal -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Terminal
forall a. Ptr a
FP.nullPtr
        then Terminal -> Maybe Terminal
forall a. a -> Maybe a
P.Just (Terminal -> Maybe Terminal) -> IO Terminal -> IO (Maybe Terminal)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe Terminal -> IO (Maybe Terminal)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Terminal
forall a. Maybe a
P.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 "spawnAsync" o = TerminalSpawnAsyncMethodInfo
    ResolveTerminalMethod "spawnSync" o = TerminalSpawnSyncMethodInfo
    ResolveTerminalMethod "spawnWithFdsAsync" o = TerminalSpawnWithFdsAsyncMethodInfo
    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 "getEnableBidi" o = TerminalGetEnableBidiMethodInfo
    ResolveTerminalMethod "getEnableShaping" o = TerminalGetEnableShapingMethodInfo
    ResolveTerminalMethod "getEnableSixel" o = TerminalGetEnableSixelMethodInfo
    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 "setEnableBidi" o = TerminalSetEnableBidiMethodInfo
    ResolveTerminalMethod "setEnableShaping" o = TerminalSetEnableShapingMethodInfo
    ResolveTerminalMethod "setEnableSixel" o = TerminalSetEnableSixelMethodInfo
    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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTerminalMethod t Terminal, O.OverloadedMethod info Terminal p, R.HasField t Terminal p) => R.HasField t Terminal p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTerminalMethod t Terminal, O.OverloadedMethodInfo info Terminal) => OL.IsLabel t (O.MethodProxy info Terminal) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalBell 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalBell a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalBell a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalCharSizeChanged 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 TerminalCharSizeChangedCallback
_cb Ptr ()
_ Word32
width Word32
height Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalCharSizeChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalCharSizeChanged a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalChildExitedCallback
-> m (GClosure C_TerminalChildExitedCallback)
genClosure_TerminalChildExited 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 TerminalChildExitedCallback
_cb Ptr ()
_ Int32
status Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalChildExited a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalChildExited a
obj 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 Text
"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.
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 :: forall (m :: * -> *).
MonadIO m =>
TerminalCommitCallback -> m (GClosure C_TerminalCommitCallback)
genClosure_TerminalCommit 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 TerminalCommitCallback
_cb Ptr ()
_ CString
text Word32
size Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCommitCallback -> m SignalHandlerId
onTerminalCommit a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCommitCallback -> m SignalHandlerId
afterTerminalCommit a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalContentsChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalContentsChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalContentsChanged a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCopyClipboard 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalCopyClipboard a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalCopyClipboard a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCurrentDirectoryUriChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCurrentFileUriChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalCurrentFileUriChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalCurrentFileUriChanged a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalCursorMoved 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalCursorMoved a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalCursorMoved a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalDecreaseFontSize 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalDecreaseFontSize a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalDecreaseFontSize a
obj 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 Text
"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
{-# DEPRECATED TerminalDeiconifyWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalDeiconifyWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalDeiconifyWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalDeiconifyWindow a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalEncodingChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalEncodingChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalEncodingChanged a
obj 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 Text
"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#g: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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalEof 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalEof a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalEof a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalHyperlinkHoverUriChangedCallback
-> m (GClosure C_TerminalHyperlinkHoverUriChangedCallback)
genClosure_TerminalHyperlinkHoverUriChanged 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 TerminalHyperlinkHoverUriChangedCallback
_cb Ptr ()
_ CString
uri Ptr Rectangle
bbox Ptr ()
_ = 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
$ \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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIconTitleChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalIconTitleChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalIconTitleChanged a
obj 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 Text
"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
{-# DEPRECATED TerminalIconifyWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIconifyWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalIconifyWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalIconifyWindow a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalIncreaseFontSize 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalIncreaseFontSize a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalIncreaseFontSize a
obj 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 Text
"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
{-# DEPRECATED TerminalLowerWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalLowerWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalLowerWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalLowerWindow a
obj 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 Text
"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
{-# DEPRECATED TerminalMaximizeWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalMaximizeWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalMaximizeWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalMaximizeWindow a
obj 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 Text
"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
{-# DEPRECATED TerminalMoveWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalMoveWindow 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 TerminalCharSizeChangedCallback
_cb Ptr ()
_ Word32
x Word32
y Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalMoveWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalMoveWindow a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalNotificationReceivedCallback
-> m (GClosure C_TerminalNotificationReceivedCallback)
genClosure_TerminalNotificationReceived 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 TerminalNotificationReceivedCallback
_cb Ptr ()
_ CString
summary CString
body Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
onTerminalNotificationReceived a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
afterTerminalNotificationReceived a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalPasteClipboard 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalPasteClipboard a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalPasteClipboard a
obj 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 Text
"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
{-# DEPRECATED TerminalRaiseWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRaiseWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalRaiseWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalRaiseWindow a
obj 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 Text
"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
{-# DEPRECATED TerminalRefreshWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRefreshWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalRefreshWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalRefreshWindow a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalCharSizeChangedCallback
-> m (GClosure C_TerminalCharSizeChangedCallback)
genClosure_TerminalResizeWindow 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 TerminalCharSizeChangedCallback
_cb Ptr ()
_ Word32
width Word32
height Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalResizeWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalResizeWindow a
obj 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 Text
"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
{-# DEPRECATED TerminalRestoreWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalRestoreWindow 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalRestoreWindow a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalRestoreWindow a
obj 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 Text
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalSelectionChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalSelectionChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalSelectionChanged a
obj 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 Text
"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::shell-precmd
-- | Emitted right before an interactive shell shows a
-- first-level prompt.
type TerminalShellPrecmdCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalShellPrecmd :: MonadIO m => TerminalShellPrecmdCallback -> m (GClosure C_TerminalShellPrecmdCallback)
genClosure_TerminalShellPrecmd :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalShellPrecmd 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_TerminalShellPrecmdCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPrecmdCallback 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 `TerminalShellPrecmdCallback` into a `C_TerminalShellPrecmdCallback`.
wrap_TerminalShellPrecmdCallback ::
    TerminalShellPrecmdCallback ->
    C_TerminalShellPrecmdCallback
wrap_TerminalShellPrecmdCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalShellPrecmdCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [shellPrecmd](#signal:shellPrecmd) 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 #shellPrecmd callback
-- @
-- 
-- 
onTerminalShellPrecmd :: (IsTerminal a, MonadIO m) => a -> TerminalShellPrecmdCallback -> m SignalHandlerId
onTerminalShellPrecmd :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalShellPrecmd a
obj 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_TerminalShellPrecmdCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPrecmdCallback 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
"shell-precmd" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [shellPrecmd](#signal:shellPrecmd) 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 #shellPrecmd callback
-- @
-- 
-- 
afterTerminalShellPrecmd :: (IsTerminal a, MonadIO m) => a -> TerminalShellPrecmdCallback -> m SignalHandlerId
afterTerminalShellPrecmd :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalShellPrecmd a
obj 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_TerminalShellPrecmdCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPrecmdCallback 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
"shell-precmd" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalShellPrecmdSignalInfo
instance SignalInfo TerminalShellPrecmdSignalInfo where
    type HaskellCallbackType TerminalShellPrecmdSignalInfo = TerminalShellPrecmdCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalShellPrecmdCallback cb
        cb'' <- mk_TerminalShellPrecmdCallback cb'
        connectSignalFunPtr obj "shell-precmd" cb'' connectMode detail

#endif

-- signal Terminal::shell-preexec
-- | Emitted when the interactive shell has read in a complete
-- command and is about to execute it.
type TerminalShellPreexecCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TerminalShellPreexec :: MonadIO m => TerminalShellPreexecCallback -> m (GClosure C_TerminalShellPreexecCallback)
genClosure_TerminalShellPreexec :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalShellPreexec 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_TerminalShellPreexecCallback IO ()
cb
    C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPreexecCallback 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 `TerminalShellPreexecCallback` into a `C_TerminalShellPreexecCallback`.
wrap_TerminalShellPreexecCallback ::
    TerminalShellPreexecCallback ->
    C_TerminalShellPreexecCallback
wrap_TerminalShellPreexecCallback :: IO () -> C_TerminalBellCallback
wrap_TerminalShellPreexecCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [shellPreexec](#signal:shellPreexec) 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 #shellPreexec callback
-- @
-- 
-- 
onTerminalShellPreexec :: (IsTerminal a, MonadIO m) => a -> TerminalShellPreexecCallback -> m SignalHandlerId
onTerminalShellPreexec :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalShellPreexec a
obj 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_TerminalShellPreexecCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPreexecCallback 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
"shell-preexec" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [shellPreexec](#signal:shellPreexec) 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 #shellPreexec callback
-- @
-- 
-- 
afterTerminalShellPreexec :: (IsTerminal a, MonadIO m) => a -> TerminalShellPreexecCallback -> m SignalHandlerId
afterTerminalShellPreexec :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalShellPreexec a
obj 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_TerminalShellPreexecCallback IO ()
cb
    FunPtr C_TerminalBellCallback
cb'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalShellPreexecCallback 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
"shell-preexec" FunPtr C_TerminalBellCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalShellPreexecSignalInfo
instance SignalInfo TerminalShellPreexecSignalInfo where
    type HaskellCallbackType TerminalShellPreexecSignalInfo = TerminalShellPreexecCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalShellPreexecCallback cb
        cb'' <- mk_TerminalShellPreexecCallback cb'
        connectSignalFunPtr obj "shell-preexec" 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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextDeleted 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalTextDeleted a
obj 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
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalTextDeleted a
obj 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
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextInserted 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalTextInserted a
obj 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
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalTextInserted a
obj 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
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalTextModified 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalTextModified a
obj 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
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalTextModified a
obj 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
"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 :: forall (m :: * -> *).
MonadIO m =>
TerminalChildExitedCallback
-> m (GClosure C_TerminalChildExitedCallback)
genClosure_TerminalTextScrolled 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 TerminalChildExitedCallback
_cb Ptr ()
_ Int32
delta Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalTextScrolled a
obj 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
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalTextScrolled a
obj 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
"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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_TerminalBellCallback)
genClosure_TerminalWindowTitleChanged 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 IO ()
_cb Ptr ()
_ Ptr ()
_ = 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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onTerminalWindowTitleChanged a
obj 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 Text
"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 :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterTerminalWindowTitleChanged a
obj 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 Text
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowBold o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalAllowBold o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalAllowBold :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalAllowBold Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowHyperlink o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalAllowHyperlink o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalAllowHyperlink :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalAllowHyperlink Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAudibleBell o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalAudibleBell o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalAudibleBell :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalAudibleBell Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m EraseBinding
getTerminalBackspaceBinding o
obj = IO EraseBinding -> m EraseBinding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> EraseBinding -> m ()
setTerminalBackspaceBinding o
obj EraseBinding
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> EraseBinding -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"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, MIO.MonadIO m) => Vte.Enums.EraseBinding -> m (GValueConstruct o)
constructTerminalBackspaceBinding :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
EraseBinding -> m (GValueConstruct o)
constructTerminalBackspaceBinding EraseBinding
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> EraseBinding -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalBoldIsBright o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalBoldIsBright o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalBoldIsBright :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalBoldIsBright Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellHeightScale o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Double -> m ()
setTerminalCellHeightScale o
obj Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"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, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTerminalCellHeightScale :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTerminalCellHeightScale Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellWidthScale o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Double -> m ()
setTerminalCellWidthScale o
obj Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"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, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTerminalCellWidthScale :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTerminalCellWidthScale Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Int32
getTerminalCjkAmbiguousWidth o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Int32 -> m ()
setTerminalCjkAmbiguousWidth o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> TerminalChildExitedCallback
forall a. GObject a => a -> String -> TerminalChildExitedCallback
B.Properties.setObjectPropertyInt32 o
obj String
"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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTerminalCjkAmbiguousWidth :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructTerminalCjkAmbiguousWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalCurrentContainerName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalCurrentContainerRuntime o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalCurrentDirectoryUri o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalCurrentFileUri o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m CursorBlinkMode
getTerminalCursorBlinkMode o
obj = IO CursorBlinkMode -> m CursorBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> CursorBlinkMode -> m ()
setTerminalCursorBlinkMode o
obj CursorBlinkMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> CursorBlinkMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"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, MIO.MonadIO m) => Vte.Enums.CursorBlinkMode -> m (GValueConstruct o)
constructTerminalCursorBlinkMode :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
CursorBlinkMode -> m (GValueConstruct o)
constructTerminalCursorBlinkMode CursorBlinkMode
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> CursorBlinkMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m CursorShape
getTerminalCursorShape o
obj = IO CursorShape -> m CursorShape
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> CursorShape -> m ()
setTerminalCursorShape o
obj CursorShape
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> CursorShape -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"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, MIO.MonadIO m) => Vte.Enums.CursorShape -> m (GValueConstruct o)
constructTerminalCursorShape :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
CursorShape -> m (GValueConstruct o)
constructTerminalCursorShape CursorShape
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> CursorShape -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m EraseBinding
getTerminalDeleteBinding o
obj = IO EraseBinding -> m EraseBinding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> EraseBinding -> m ()
setTerminalDeleteBinding o
obj EraseBinding
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> EraseBinding -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"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, MIO.MonadIO m) => Vte.Enums.EraseBinding -> m (GValueConstruct o)
constructTerminalDeleteBinding :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
EraseBinding -> m (GValueConstruct o)
constructTerminalDeleteBinding EraseBinding
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> EraseBinding -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"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 "enable-bidi"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@enable-bidi@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #enableBidi
-- @
getTerminalEnableBidi :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableBidi :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableBidi o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"enable-bidi"

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

-- | Construct a `GValueConstruct` with valid value for the “@enable-bidi@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalEnableBidi :: (IsTerminal o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalEnableBidi :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalEnableBidi Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enable-bidi" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalEnableBidiPropertyInfo
instance AttrInfo TerminalEnableBidiPropertyInfo where
    type AttrAllowedOps TerminalEnableBidiPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableBidiPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableBidiPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableBidiPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableBidiPropertyInfo = Bool
    type AttrGetType TerminalEnableBidiPropertyInfo = Bool
    type AttrLabel TerminalEnableBidiPropertyInfo = "enable-bidi"
    type AttrOrigin TerminalEnableBidiPropertyInfo = Terminal
    attrGet = getTerminalEnableBidi
    attrSet = setTerminalEnableBidi
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableBidi
    attrClear = undefined
#endif

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

-- | Get the value of the “@enable-shaping@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #enableShaping
-- @
getTerminalEnableShaping :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableShaping :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableShaping o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"enable-shaping"

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

-- | Construct a `GValueConstruct` with valid value for the “@enable-shaping@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalEnableShaping :: (IsTerminal o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalEnableShaping :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalEnableShaping Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enable-shaping" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalEnableShapingPropertyInfo
instance AttrInfo TerminalEnableShapingPropertyInfo where
    type AttrAllowedOps TerminalEnableShapingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableShapingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableShapingPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableShapingPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableShapingPropertyInfo = Bool
    type AttrGetType TerminalEnableShapingPropertyInfo = Bool
    type AttrLabel TerminalEnableShapingPropertyInfo = "enable-shaping"
    type AttrOrigin TerminalEnableShapingPropertyInfo = Terminal
    attrGet = getTerminalEnableShaping
    attrSet = setTerminalEnableShaping
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableShaping
    attrClear = undefined
#endif

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

-- | Get the value of the “@enable-sixel@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' terminal #enableSixel
-- @
getTerminalEnableSixel :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableSixel :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalEnableSixel o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"enable-sixel"

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

-- | Construct a `GValueConstruct` with valid value for the “@enable-sixel@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalEnableSixel :: (IsTerminal o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalEnableSixel :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalEnableSixel Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enable-sixel" Bool
val

#if defined(ENABLE_OVERLOADING)
data TerminalEnableSixelPropertyInfo
instance AttrInfo TerminalEnableSixelPropertyInfo where
    type AttrAllowedOps TerminalEnableSixelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableSixelPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableSixelPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableSixelPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableSixelPropertyInfo = Bool
    type AttrGetType TerminalEnableSixelPropertyInfo = Bool
    type AttrLabel TerminalEnableSixelPropertyInfo = "enable-sixel"
    type AttrOrigin TerminalEnableSixelPropertyInfo = Terminal
    attrGet = getTerminalEnableSixel
    attrSet = setTerminalEnableSixel
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableSixel
    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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalEncoding o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Text -> m ()
setTerminalEncoding o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructTerminalEncoding :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructTerminalEncoding Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"encoding" (Text -> Maybe Text
forall a. a -> Maybe a
P.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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalEncoding 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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe FontDescription)
getTerminalFontDesc o
obj = IO (Maybe FontDescription) -> m (Maybe FontDescription)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> FontDescription -> m ()
setTerminalFontDesc o
obj FontDescription
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe FontDescription -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"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, MIO.MonadIO m) => Pango.FontDescription.FontDescription -> m (GValueConstruct o)
constructTerminalFontDesc :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
FontDescription -> m (GValueConstruct o)
constructTerminalFontDesc FontDescription
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe FontDescription -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"font-desc" (FontDescription -> Maybe FontDescription
forall a. a -> Maybe a
P.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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalFontDesc 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, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Double
getTerminalFontScale o
obj = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Double -> m ()
setTerminalFontScale o
obj Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"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, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTerminalFontScale :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTerminalFontScale Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalHyperlinkHoverUri o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalIconTitle o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalInputEnabled o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalInputEnabled o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalInputEnabled :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalInputEnabled Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalPointerAutohide o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalPointerAutohide o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalPointerAutohide :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalPointerAutohide Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Pty
getTerminalPty o
obj = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 Text
"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 String
"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 :: forall (m :: * -> *) o a.
(MonadIO m, IsTerminal o, IsPty a) =>
o -> a -> m ()
setTerminalPty o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"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, MIO.MonadIO m, Vte.Pty.IsPty a) => a -> m (GValueConstruct o)
constructTerminalPty :: forall o (m :: * -> *) a.
(IsTerminal o, MonadIO m, IsPty a) =>
a -> m (GValueConstruct o)
constructTerminalPty a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"pty" (a -> Maybe a
forall a. a -> Maybe a
P.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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalPty 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 String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalRewrapOnResize o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalRewrapOnResize o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalRewrapOnResize :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalRewrapOnResize Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnKeystroke o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalScrollOnKeystroke o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalScrollOnKeystroke :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalScrollOnKeystroke Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnOutput o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Bool -> m ()
setTerminalScrollOnOutput o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTerminalScrollOnOutput :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTerminalScrollOnOutput Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollSpeed o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Word32 -> m ()
setTerminalScrollSpeed o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"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, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructTerminalScrollSpeed :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructTerminalScrollSpeed Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"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 :: forall (m :: * -> *) o. (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollbackLines o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> Word32 -> m ()
setTerminalScrollbackLines o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"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, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructTerminalScrollbackLines :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructTerminalScrollbackLines Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m TextBlinkMode
getTerminalTextBlinkMode o
obj = IO TextBlinkMode -> m TextBlinkMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> TextBlinkMode -> m ()
setTerminalTextBlinkMode o
obj TextBlinkMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> TextBlinkMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"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, MIO.MonadIO m) => Vte.Enums.TextBlinkMode -> m (GValueConstruct o)
constructTerminalTextBlinkMode :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
TextBlinkMode -> m (GValueConstruct o)
constructTerminalTextBlinkMode TextBlinkMode
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TextBlinkMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalWindowTitle o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsTerminal o) =>
o -> m (Maybe Text)
getTerminalWordCharExceptions o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"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), '("enableBidi", TerminalEnableBidiPropertyInfo), '("enableShaping", TerminalEnableShapingPropertyInfo), '("enableSixel", TerminalEnableSixelPropertyInfo), '("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

terminalEnableBidi :: AttrLabelProxy "enableBidi"
terminalEnableBidi = AttrLabelProxy

terminalEnableShaping :: AttrLabelProxy "enableShaping"
terminalEnableShaping = AttrLabelProxy

terminalEnableSixel :: AttrLabelProxy "enableSixel"
terminalEnableSixel = 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), '("shellPrecmd", TerminalShellPrecmdSignalInfo), '("shellPreexec", TerminalShellPreexecSignalInfo), '("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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => 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 Text
"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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalCopyClipboard 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.OverloadedMethod TerminalCopyClipboardMethodInfo a signature where
    overloadedMethod = terminalCopyClipboard

instance O.OverloadedMethodInfo TerminalCopyClipboardMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalCopyClipboard",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Format -> m ()
terminalCopyClipboardFormat a
terminal 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.OverloadedMethod TerminalCopyClipboardFormatMethodInfo a signature where
    overloadedMethod = terminalCopyClipboardFormat

instance O.OverloadedMethodInfo TerminalCopyClipboardFormatMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalCopyClipboardFormat",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalCopyPrimary 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.OverloadedMethod TerminalCopyPrimaryMethodInfo a signature where
    overloadedMethod = terminalCopyPrimary

instance O.OverloadedMethodInfo TerminalCopyPrimaryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalCopyPrimary",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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.
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe ByteString -> m ()
terminalFeed a
terminal 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
            Maybe ByteString
Nothing -> Int64
0
            Just 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
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalFeedMethodInfo a signature where
    overloadedMethod = terminalFeed

instance O.OverloadedMethodInfo TerminalFeedMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalFeed",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 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 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 Word8 ->                            -- text : TCArray False (-1) 2 (TBasicType TUInt8)
    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 (ByteString)
    -- ^ /@text@/: data to send to the child
    -> m ()
terminalFeedChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe ByteString -> m ()
terminalFeedChild a
terminal Maybe ByteString
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 ByteString
text of
            Maybe ByteString
Nothing -> Int64
0
            Just ByteString
jText -> 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
jText
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Word8
maybeText <- case Maybe ByteString
text of
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just ByteString
jText -> do
            Ptr Word8
jText' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jText
            Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jText'
    Ptr Terminal -> Ptr Word8 -> Int64 -> IO ()
vte_terminal_feed_child Ptr Terminal
terminal' Ptr Word8
maybeText Int64
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeText
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TerminalFeedChildMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalFeedChild",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 ()

{-# DEPRECATED terminalFeedChildBinary ["(Since version 0.60)","Don\\'t send binary data. Use 'GI.Vte.Objects.Terminal.terminalFeedChild' instead to send","  UTF-8 text"] #-}
-- | 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe ByteString -> m ()
terminalFeedChildBinary a
terminal 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
            Maybe ByteString
Nothing -> Word64
0
            Just 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
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalFeedChildBinaryMethodInfo a signature where
    overloadedMethod = terminalFeedChildBinary

instance O.OverloadedMethodInfo TerminalFeedChildBinaryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalFeedChildBinary",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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

{-# DEPRECATED terminalGetAllowBold ["(Since version 0.60)","There\\'s probably no reason for this feature to exist."] #-}
-- | Checks whether or not the terminal will attempt to draw bold text,
-- by using a bold font variant.
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetAllowBold 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
/= CInt
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.OverloadedMethod TerminalGetAllowBoldMethodInfo a signature where
    overloadedMethod = terminalGetAllowBold

instance O.OverloadedMethodInfo TerminalGetAllowBoldMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetAllowBold",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetAllowHyperlink 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
/= CInt
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.OverloadedMethod TerminalGetAllowHyperlinkMethodInfo a signature where
    overloadedMethod = terminalGetAllowHyperlink

instance O.OverloadedMethodInfo TerminalGetAllowHyperlinkMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetAllowHyperlink",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetAudibleBell 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
/= CInt
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.OverloadedMethod TerminalGetAudibleBellMethodInfo a signature where
    overloadedMethod = terminalGetAudibleBell

instance O.OverloadedMethodInfo TerminalGetAudibleBellMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetAudibleBell",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetBoldIsBright 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
/= CInt
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.OverloadedMethod TerminalGetBoldIsBrightMethodInfo a signature where
    overloadedMethod = terminalGetBoldIsBright

instance O.OverloadedMethodInfo TerminalGetBoldIsBrightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetBoldIsBright",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Double
terminalGetCellHeightScale 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.OverloadedMethod TerminalGetCellHeightScaleMethodInfo a signature where
    overloadedMethod = terminalGetCellHeightScale

instance O.OverloadedMethodInfo TerminalGetCellHeightScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCellHeightScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Double
terminalGetCellWidthScale 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.OverloadedMethod TerminalGetCellWidthScaleMethodInfo a signature where
    overloadedMethod = terminalGetCellWidthScale

instance O.OverloadedMethodInfo TerminalGetCellWidthScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCellWidthScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetCharHeight 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.OverloadedMethod TerminalGetCharHeightMethodInfo a signature where
    overloadedMethod = terminalGetCharHeight

instance O.OverloadedMethodInfo TerminalGetCharHeightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCharHeight",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetCharWidth 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.OverloadedMethod TerminalGetCharWidthMethodInfo a signature where
    overloadedMethod = terminalGetCharWidth

instance O.OverloadedMethodInfo TerminalGetCharWidthMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCharWidth",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Int32
terminalGetCjkAmbiguousWidth 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.OverloadedMethod TerminalGetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod = terminalGetCjkAmbiguousWidth

instance O.OverloadedMethodInfo TerminalGetCjkAmbiguousWidthMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCjkAmbiguousWidth",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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](#g: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m RGBA
terminalGetColorBackgroundForDraw 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. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
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, GBoxed 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.OverloadedMethod TerminalGetColorBackgroundForDrawMethodInfo a signature where
    overloadedMethod = terminalGetColorBackgroundForDraw

instance O.OverloadedMethodInfo TerminalGetColorBackgroundForDrawMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetColorBackgroundForDraw",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetColumnCount 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.OverloadedMethod TerminalGetColumnCountMethodInfo a signature where
    overloadedMethod = terminalGetColumnCount

instance O.OverloadedMethodInfo TerminalGetColumnCountMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetColumnCount",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetCurrentContainerName 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
$ \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.OverloadedMethod TerminalGetCurrentContainerNameMethodInfo a signature where
    overloadedMethod = terminalGetCurrentContainerName

instance O.OverloadedMethodInfo TerminalGetCurrentContainerNameMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCurrentContainerName",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetCurrentContainerRuntime 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
$ \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.OverloadedMethod TerminalGetCurrentContainerRuntimeMethodInfo a signature where
    overloadedMethod = terminalGetCurrentContainerRuntime

instance O.OverloadedMethodInfo TerminalGetCurrentContainerRuntimeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCurrentContainerRuntime",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetCurrentDirectoryUri 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
$ \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.OverloadedMethod TerminalGetCurrentDirectoryUriMethodInfo a signature where
    overloadedMethod = terminalGetCurrentDirectoryUri

instance O.OverloadedMethodInfo TerminalGetCurrentDirectoryUriMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetCurrentFileUri 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
$ \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.OverloadedMethod TerminalGetCurrentFileUriMethodInfo a signature where
    overloadedMethod = terminalGetCurrentFileUri

instance O.OverloadedMethodInfo TerminalGetCurrentFileUriMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCurrentFileUri",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CursorBlinkMode
terminalGetCursorBlinkMode 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.OverloadedMethod TerminalGetCursorBlinkModeMethodInfo a signature where
    overloadedMethod = terminalGetCursorBlinkMode

instance O.OverloadedMethodInfo TerminalGetCursorBlinkModeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCursorBlinkMode",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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.
-- 
-- This method is unaware of BiDi. The returned column is logical column.
terminalGetCursorPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ((CLong, CLong))
terminalGetCursorPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (CLong, CLong)
terminalGetCursorPosition 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.OverloadedMethod TerminalGetCursorPositionMethodInfo a signature where
    overloadedMethod = terminalGetCursorPosition

instance O.OverloadedMethodInfo TerminalGetCursorPositionMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCursorPosition",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CursorShape
terminalGetCursorShape 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.OverloadedMethod TerminalGetCursorShapeMethodInfo a signature where
    overloadedMethod = terminalGetCursorShape

instance O.OverloadedMethodInfo TerminalGetCursorShapeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetCursorShape",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCursorShape"
        }


#endif

-- method Terminal::get_enable_bidi
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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_enable_bidi" vte_terminal_get_enable_bidi :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether the terminal performs bidirectional text rendering.
-- 
-- /Since: 0.58/
terminalGetEnableBidi ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if BiDi is enabled, 'P.False' if not
terminalGetEnableBidi :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableBidi 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_enable_bidi Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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 TerminalGetEnableBidiMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableBidiMethodInfo a signature where
    overloadedMethod = terminalGetEnableBidi

instance O.OverloadedMethodInfo TerminalGetEnableBidiMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetEnableBidi",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableBidi"
        }


#endif

-- method Terminal::get_enable_shaping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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_enable_shaping" vte_terminal_get_enable_shaping :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | Checks whether the terminal shapes Arabic text.
-- 
-- /Since: 0.58/
terminalGetEnableShaping ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if Arabic shaping is enabled, 'P.False' if not
terminalGetEnableShaping :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableShaping 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_enable_shaping Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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 TerminalGetEnableShapingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableShapingMethodInfo a signature where
    overloadedMethod = terminalGetEnableShaping

instance O.OverloadedMethodInfo TerminalGetEnableShapingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetEnableShaping",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableShaping"
        }


#endif

-- method Terminal::get_enable_sixel
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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_enable_sixel" vte_terminal_get_enable_sixel :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 0.62/
terminalGetEnableSixel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.False'
terminalGetEnableSixel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableSixel 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_enable_sixel Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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 TerminalGetEnableSixelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableSixelMethodInfo a signature where
    overloadedMethod = terminalGetEnableSixel

instance O.OverloadedMethodInfo TerminalGetEnableSixelMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetEnableSixel",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableSixel"
        }


#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetEncoding 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
$ \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.OverloadedMethod TerminalGetEncodingMethodInfo a signature where
    overloadedMethod = terminalGetEncoding

instance O.OverloadedMethodInfo TerminalGetEncodingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetEncoding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m FontDescription
terminalGetFont 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 Text
"terminalGetFont" Ptr FontDescription
result
    FontDescription
result' <- ((ManagedPtr FontDescription -> FontDescription)
-> Ptr FontDescription -> IO FontDescription
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod TerminalGetFontMethodInfo a signature where
    overloadedMethod = terminalGetFont

instance O.OverloadedMethodInfo TerminalGetFontMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetFont",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Double
terminalGetFontScale 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.OverloadedMethod TerminalGetFontScaleMethodInfo a signature where
    overloadedMethod = terminalGetFontScale

instance O.OverloadedMethodInfo TerminalGetFontScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetFontScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> Int32 -> m Geometry
terminalGetGeometryHints a
terminal Int32
minRows 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)
SP.callocBytes Int
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, BoxedPtr 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.OverloadedMethod TerminalGetGeometryHintsMethodInfo a signature where
    overloadedMethod = terminalGetGeometryHints

instance O.OverloadedMethodInfo TerminalGetGeometryHintsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetGeometryHints",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetHasSelection 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
/= CInt
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.OverloadedMethod TerminalGetHasSelectionMethodInfo a signature where
    overloadedMethod = terminalGetHasSelection

instance O.OverloadedMethodInfo TerminalGetHasSelectionMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetHasSelection",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetIconTitle 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
$ \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.OverloadedMethod TerminalGetIconTitleMethodInfo a signature where
    overloadedMethod = terminalGetIconTitle

instance O.OverloadedMethodInfo TerminalGetIconTitleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetIconTitle",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetInputEnabled 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
/= CInt
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.OverloadedMethod TerminalGetInputEnabledMethodInfo a signature where
    overloadedMethod = terminalGetInputEnabled

instance O.OverloadedMethodInfo TerminalGetInputEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetInputEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetMouseAutohide 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
/= CInt
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.OverloadedMethod TerminalGetMouseAutohideMethodInfo a signature where
    overloadedMethod = terminalGetMouseAutohide

instance O.OverloadedMethodInfo TerminalGetMouseAutohideMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetMouseAutohide",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Pty
terminalGetPty 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 Text
"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.OverloadedMethod TerminalGetPtyMethodInfo a signature where
    overloadedMethod = terminalGetPty

instance O.OverloadedMethodInfo TerminalGetPtyMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetPty",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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

{-# DEPRECATED terminalGetRewrapOnResize ["(Since version 0.58)"] #-}
-- | 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetRewrapOnResize 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
/= CInt
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.OverloadedMethod TerminalGetRewrapOnResizeMethodInfo a signature where
    overloadedMethod = terminalGetRewrapOnResize

instance O.OverloadedMethodInfo TerminalGetRewrapOnResizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetRewrapOnResize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetRowCount 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.OverloadedMethod TerminalGetRowCountMethodInfo a signature where
    overloadedMethod = terminalGetRowCount

instance O.OverloadedMethodInfo TerminalGetRowCountMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetRowCount",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetScrollOnKeystroke 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
/= CInt
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.OverloadedMethod TerminalGetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod = terminalGetScrollOnKeystroke

instance O.OverloadedMethodInfo TerminalGetScrollOnKeystrokeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetScrollOnKeystroke",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetScrollOnOutput 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
/= CInt
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.OverloadedMethod TerminalGetScrollOnOutputMethodInfo a signature where
    overloadedMethod = terminalGetScrollOnOutput

instance O.OverloadedMethodInfo TerminalGetScrollOnOutputMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetScrollOnOutput",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetScrollbackLines 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.OverloadedMethod TerminalGetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalGetScrollbackLines

instance O.OverloadedMethodInfo TerminalGetScrollbackLinesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetScrollbackLines",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollbackLines"
        }


#endif

-- method Terminal::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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_selected"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "SelectionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteSelectionFunc callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to be passed to the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TGArray
--                 (TInterface Name { namespace = "Vte" , name = "CharAttributes" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location for storing text attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text" vte_terminal_get_text :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    FunPtr Vte.Callbacks.C_SelectionFunc -> -- is_selected : TInterface (Name {namespace = "Vte", name = "SelectionFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)) -> -- attributes : TGArray (TInterface (Name {namespace = "Vte", name = "CharAttributes"}))
    IO CString

-- | Extracts a view of the visible part of the terminal.  If /@isSelected@/ is not
-- 'P.Nothing', characters will only be read if /@isSelected@/ returns 'P.True' after being
-- passed the column and row, respectively.  A t'GI.Vte.Structs.CharAttributes.CharAttributes' structure
-- is added to /@attributes@/ for each byte added to the returned string detailing
-- the character\'s position, colors, and other characteristics.
-- 
-- This method is unaware of BiDi. The columns returned in /@attributes@/ are
-- logical columns.
terminalGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback
    -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe SelectionFunc -> m (Text, [CharAttributes])
terminalGetText a
terminal Maybe SelectionFunc
isSelected = IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, [CharAttributes]) -> m (Text, [CharAttributes]))
-> IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
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
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SelectionFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text Ptr Terminal
terminal' FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    [Ptr CharAttributes]
attributes' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes
    [CharAttributes]
attributes'' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes'
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Text, [CharAttributes]) -> IO (Text, [CharAttributes])
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', [CharAttributes]
attributes'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextMethodInfo
instance (signature ~ (Maybe (Vte.Callbacks.SelectionFunc) -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextMethodInfo a signature where
    overloadedMethod = terminalGetText

instance O.OverloadedMethodInfo TerminalGetTextMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetText",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetText"
        }


#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m TextBlinkMode
terminalGetTextBlinkMode 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.OverloadedMethod TerminalGetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalGetTextBlinkMode

instance O.OverloadedMethodInfo TerminalGetTextBlinkModeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetTextBlinkMode",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextBlinkMode"
        }


#endif

-- method Terminal::get_text_include_trailing_spaces
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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_selected"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "SelectionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteSelectionFunc callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to be passed to the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TGArray
--                 (TInterface Name { namespace = "Vte" , name = "CharAttributes" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location for storing text attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_include_trailing_spaces" vte_terminal_get_text_include_trailing_spaces :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    FunPtr Vte.Callbacks.C_SelectionFunc -> -- is_selected : TInterface (Name {namespace = "Vte", name = "SelectionFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)) -> -- attributes : TGArray (TInterface (Name {namespace = "Vte", name = "CharAttributes"}))
    IO CString

{-# DEPRECATED terminalGetTextIncludeTrailingSpaces ["(Since version 0.56)","Use 'GI.Vte.Objects.Terminal.terminalGetText' instead."] #-}
-- | Extracts a view of the visible part of the terminal.  If /@isSelected@/ is not
-- 'P.Nothing', characters will only be read if /@isSelected@/ returns 'P.True' after being
-- passed the column and row, respectively.  A t'GI.Vte.Structs.CharAttributes.CharAttributes' structure
-- is added to /@attributes@/ for each byte added to the returned string detailing
-- the character\'s position, colors, and other characteristics.
-- 
-- This method is unaware of BiDi. The columns returned in /@attributes@/ are
-- logical columns.
terminalGetTextIncludeTrailingSpaces ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback
    -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetTextIncludeTrailingSpaces :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe SelectionFunc -> m (Text, [CharAttributes])
terminalGetTextIncludeTrailingSpaces a
terminal Maybe SelectionFunc
isSelected = IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, [CharAttributes]) -> m (Text, [CharAttributes]))
-> IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
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
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SelectionFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text_include_trailing_spaces Ptr Terminal
terminal' FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalGetTextIncludeTrailingSpaces" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    [Ptr CharAttributes]
attributes' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes
    [CharAttributes]
attributes'' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes'
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Text, [CharAttributes]) -> IO (Text, [CharAttributes])
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', [CharAttributes]
attributes'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextIncludeTrailingSpacesMethodInfo
instance (signature ~ (Maybe (Vte.Callbacks.SelectionFunc) -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextIncludeTrailingSpacesMethodInfo a signature where
    overloadedMethod = terminalGetTextIncludeTrailingSpaces

instance O.OverloadedMethodInfo TerminalGetTextIncludeTrailingSpacesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetTextIncludeTrailingSpaces",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextIncludeTrailingSpaces"
        }


#endif

-- method Terminal::get_text_range
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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 = "start_row"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "first row to search for data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_col"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "first column to search for data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_row"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "last row to search for data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_col"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "last column to search for data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_selected"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "SelectionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteSelectionFunc callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 6
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to be passed to the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TGArray
--                 (TInterface Name { namespace = "Vte" , name = "CharAttributes" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location for storing text attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_range" vte_terminal_get_text_range :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- start_row : TBasicType TLong
    CLong ->                                -- start_col : TBasicType TLong
    CLong ->                                -- end_row : TBasicType TLong
    CLong ->                                -- end_col : TBasicType TLong
    FunPtr Vte.Callbacks.C_SelectionFunc -> -- is_selected : TInterface (Name {namespace = "Vte", name = "SelectionFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)) -> -- attributes : TGArray (TInterface (Name {namespace = "Vte", name = "CharAttributes"}))
    IO CString

-- | Extracts a view of the visible part of the terminal.  If /@isSelected@/ is not
-- 'P.Nothing', characters will only be read if /@isSelected@/ returns 'P.True' after being
-- passed the column and row, respectively.  A t'GI.Vte.Structs.CharAttributes.CharAttributes' structure
-- is added to /@attributes@/ for each byte added to the returned string detailing
-- the character\'s position, colors, and other characteristics.  The
-- entire scrollback buffer is scanned, so it is possible to read the entire
-- contents of the buffer using this function.
-- 
-- This method is unaware of BiDi. The columns passed in /@startCol@/ and /@endRow@/,
-- and returned in /@attributes@/ are logical columns.
terminalGetTextRange ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> CLong
    -- ^ /@startRow@/: first row to search for data
    -> CLong
    -- ^ /@startCol@/: first column to search for data
    -> CLong
    -- ^ /@endRow@/: last row to search for data
    -> CLong
    -- ^ /@endCol@/: last column to search for data
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback
    -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetTextRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a
-> CLong
-> CLong
-> CLong
-> CLong
-> Maybe SelectionFunc
-> m (Text, [CharAttributes])
terminalGetTextRange a
terminal CLong
startRow CLong
startCol CLong
endRow CLong
endCol Maybe SelectionFunc
isSelected = IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, [CharAttributes]) -> m (Text, [CharAttributes]))
-> IO (Text, [CharAttributes]) -> m (Text, [CharAttributes])
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
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SelectionFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> CLong
-> CLong
-> CLong
-> CLong
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text_range Ptr Terminal
terminal' CLong
startRow CLong
startCol CLong
endRow CLong
endCol FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalGetTextRange" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    [Ptr CharAttributes]
attributes' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes
    [CharAttributes]
attributes'' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes'
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Text, [CharAttributes]) -> IO (Text, [CharAttributes])
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', [CharAttributes]
attributes'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextRangeMethodInfo
instance (signature ~ (CLong -> CLong -> CLong -> CLong -> Maybe (Vte.Callbacks.SelectionFunc) -> m ((T.Text, [Vte.CharAttributes.CharAttributes]))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextRangeMethodInfo a signature where
    overloadedMethod = terminalGetTextRange

instance O.OverloadedMethodInfo TerminalGetTextRangeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetTextRange",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextRange"
        }


#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetWindowTitle 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
$ \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.OverloadedMethod TerminalGetWindowTitleMethodInfo a signature where
    overloadedMethod = terminalGetWindowTitle

instance O.OverloadedMethodInfo TerminalGetWindowTitleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetWindowTitle",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetWordCharExceptions 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
$ \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.OverloadedMethod TerminalGetWordCharExceptionsMethodInfo a signature where
    overloadedMethod = terminalGetWordCharExceptions

instance O.OverloadedMethodInfo TerminalGetWordCharExceptionsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalGetWordCharExceptions",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 (Maybe T.Text)
    -- ^ __Returns:__ a newly allocated string containing the target of the hyperlink,
    --  or 'P.Nothing'
terminalHyperlinkCheckEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Event -> m (Maybe Text)
terminalHyperlinkCheckEvent a
terminal Event
event = 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
    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'
    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
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem 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
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalHyperlinkCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalHyperlinkCheckEventMethodInfo a signature where
    overloadedMethod = terminalHyperlinkCheckEvent

instance O.OverloadedMethodInfo TerminalHyperlinkCheckEventMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalHyperlinkCheckEvent",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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."] #-}
-- | This function does nothing since version 0.60.
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:__ -1
terminalMatchAddGregex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Regex -> [RegexMatchFlags] -> m Int32
terminalMatchAddGregex a
terminal Regex
gregex [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.OverloadedMethod TerminalMatchAddGregexMethodInfo a signature where
    overloadedMethod = terminalMatchAddGregex

instance O.OverloadedMethodInfo TerminalMatchAddGregexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchAddGregex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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.
-- 
-- Note that /@regex@/ should have been created using the @/PCRE2_MULTILINE/@ flag.
-- 
-- /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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Regex -> Word32 -> m Int32
terminalMatchAddRegex a
terminal Regex
regex 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.OverloadedMethod TerminalMatchAddRegexMethodInfo a signature where
    overloadedMethod = terminalMatchAddRegex

instance O.OverloadedMethodInfo TerminalMatchAddRegexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchAddRegex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 ((Maybe T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions
terminalMatchCheck :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> CLong -> m (Maybe Text, Int32)
terminalMatchCheck a
terminal CLong
column CLong
row = IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Int32) -> m (Maybe Text, Int32))
-> IO (Maybe Text, Int32) -> m (Maybe 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
    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
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
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
    (Maybe Text, Int32) -> IO (Maybe Text, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Int32
tag')

#if defined(ENABLE_OVERLOADING)
data TerminalMatchCheckMethodInfo
instance (signature ~ (CLong -> CLong -> m ((Maybe T.Text, Int32))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchCheckMethodInfo a signature where
    overloadedMethod = terminalMatchCheck

instance O.OverloadedMethodInfo TerminalMatchCheckMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchCheck",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 ((Maybe T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions, or 'P.Nothing' if there is no match
terminalMatchCheckEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Event -> m (Maybe Text, Int32)
terminalMatchCheckEvent a
terminal Event
event = IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Int32) -> m (Maybe Text, Int32))
-> IO (Maybe Text, Int32) -> m (Maybe 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
    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
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
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
    (Maybe Text, Int32) -> IO (Maybe Text, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Int32
tag')

#if defined(ENABLE_OVERLOADING)
data TerminalMatchCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m ((Maybe T.Text, Int32))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchCheckEventMethodInfo a signature where
    overloadedMethod = terminalMatchCheckEvent

instance O.OverloadedMethodInfo TerminalMatchCheckEventMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchCheckEvent",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m ()
terminalMatchRemove a
terminal 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.OverloadedMethod TerminalMatchRemoveMethodInfo a signature where
    overloadedMethod = terminalMatchRemove

instance O.OverloadedMethodInfo TerminalMatchRemoveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchRemove",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalMatchRemoveAll 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.OverloadedMethod TerminalMatchRemoveAllMethodInfo a signature where
    overloadedMethod = terminalMatchRemoveAll

instance O.OverloadedMethodInfo TerminalMatchRemoveAllMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchRemoveAll",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCursor b) =>
a -> Int32 -> Maybe b -> m ()
terminalMatchSetCursor a
terminal Int32
tag 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
        Maybe b
Nothing -> Ptr Cursor -> IO (Ptr Cursor)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cursor
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalMatchSetCursorMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursor

instance O.OverloadedMethodInfo TerminalMatchSetCursorMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchSetCursor",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> Text -> m ()
terminalMatchSetCursorName a
terminal Int32
tag 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.OverloadedMethod TerminalMatchSetCursorNameMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursorName

instance O.OverloadedMethodInfo TerminalMatchSetCursorNameMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchSetCursorName",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> CursorType -> m ()
terminalMatchSetCursorType a
terminal Int32
tag 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.OverloadedMethod TerminalMatchSetCursorTypeMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursorType

instance O.OverloadedMethodInfo TerminalMatchSetCursorTypeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalMatchSetCursorType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalPasteClipboard 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.OverloadedMethod TerminalPasteClipboardMethodInfo a signature where
    overloadedMethod = terminalPasteClipboard

instance O.OverloadedMethodInfo TerminalPasteClipboardMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalPasteClipboard",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalPastePrimary 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.OverloadedMethod TerminalPastePrimaryMethodInfo a signature where
    overloadedMethod = terminalPastePrimary

instance O.OverloadedMethodInfo TerminalPastePrimaryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalPastePrimary",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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', sets the emulation property
-- from t'GI.Vte.Objects.Terminal.Terminal':@/emulation/@, and sets the size using
-- /@terminal@/\'s size.
-- 
-- 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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a -> [PtyFlags] -> Maybe b -> m Pty
terminalPtyNewSync a
terminal [PtyFlags]
flags 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
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just 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 Text
"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.OverloadedMethod TerminalPtyNewSyncMethodInfo a signature where
    overloadedMethod = terminalPtyNewSync

instance O.OverloadedMethodInfo TerminalPtyNewSyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalPtyNewSync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> Bool -> m ()
terminalReset a
terminal Bool
clearTabstops 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.OverloadedMethod TerminalResetMethodInfo a signature where
    overloadedMethod = terminalReset

instance O.OverloadedMethodInfo TerminalResetMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalReset",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchFindNext 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
/= CInt
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.OverloadedMethod TerminalSearchFindNextMethodInfo a signature where
    overloadedMethod = terminalSearchFindNext

instance O.OverloadedMethodInfo TerminalSearchFindNextMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchFindNext",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchFindPrevious 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
/= CInt
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.OverloadedMethod TerminalSearchFindPreviousMethodInfo a signature where
    overloadedMethod = terminalSearchFindPrevious

instance O.OverloadedMethodInfo TerminalSearchFindPreviousMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchFindPrevious",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Regex
terminalSearchGetGregex 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 Text
"terminalSearchGetGregex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod TerminalSearchGetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchGetGregex

instance O.OverloadedMethodInfo TerminalSearchGetGregexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchGetGregex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Regex
terminalSearchGetRegex 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 Text
"terminalSearchGetRegex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod TerminalSearchGetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchGetRegex

instance O.OverloadedMethodInfo TerminalSearchGetRegexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchGetRegex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchGetWrapAround 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
/= CInt
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.OverloadedMethod TerminalSearchGetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchGetWrapAround

instance O.OverloadedMethodInfo TerminalSearchGetWrapAroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchGetWrapAround",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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."] #-}
-- | This function does nothing since version 0.60.
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Regex -> [RegexMatchFlags] -> m ()
terminalSearchSetGregex a
terminal Maybe Regex
gregex [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
        Maybe Regex
Nothing -> Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSearchSetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchSetGregex

instance O.OverloadedMethodInfo TerminalSearchSetGregexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchSetGregex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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'.
-- 
-- Note that /@regex@/ should have been created using the @/PCRE2_MULTILINE/@ flag.
-- 
-- /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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Regex -> Word32 -> m ()
terminalSearchSetRegex a
terminal Maybe Regex
regex 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
        Maybe Regex
Nothing -> Ptr Regex -> IO (Ptr Regex)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSearchSetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchSetRegex

instance O.OverloadedMethodInfo TerminalSearchSetRegexMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchSetRegex",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSearchSetWrapAround a
terminal 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.OverloadedMethod TerminalSearchSetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchSetWrapAround

instance O.OverloadedMethodInfo TerminalSearchSetWrapAroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSearchSetWrapAround",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalSelectAll 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.OverloadedMethod TerminalSelectAllMethodInfo a signature where
    overloadedMethod = terminalSelectAll

instance O.OverloadedMethodInfo TerminalSelectAllMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSelectAll",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 ()

{-# DEPRECATED terminalSetAllowBold ["(Since version 0.60)","There\\'s probably no reason for this feature to exist."] #-}
-- | Controls whether or not the terminal will attempt to draw bold text,
-- by using a bold font variant.
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAllowBold a
terminal 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.OverloadedMethod TerminalSetAllowBoldMethodInfo a signature where
    overloadedMethod = terminalSetAllowBold

instance O.OverloadedMethodInfo TerminalSetAllowBoldMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetAllowBold",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAllowHyperlink a
terminal 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.OverloadedMethod TerminalSetAllowHyperlinkMethodInfo a signature where
    overloadedMethod = terminalSetAllowHyperlink

instance O.OverloadedMethodInfo TerminalSetAllowHyperlinkMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetAllowHyperlink",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAudibleBell a
terminal 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.OverloadedMethod TerminalSetAudibleBellMethodInfo a signature where
    overloadedMethod = terminalSetAudibleBell

instance O.OverloadedMethodInfo TerminalSetAudibleBellMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetAudibleBell",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> EraseBinding -> m ()
terminalSetBackspaceBinding a
terminal 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.OverloadedMethod TerminalSetBackspaceBindingMethodInfo a signature where
    overloadedMethod = terminalSetBackspaceBinding

instance O.OverloadedMethodInfo TerminalSetBackspaceBindingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetBackspaceBinding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetBoldIsBright a
terminal 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.OverloadedMethod TerminalSetBoldIsBrightMethodInfo a signature where
    overloadedMethod = terminalSetBoldIsBright

instance O.OverloadedMethodInfo TerminalSetBoldIsBrightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetBoldIsBright",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetCellHeightScale a
terminal 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.OverloadedMethod TerminalSetCellHeightScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellHeightScale

instance O.OverloadedMethodInfo TerminalSetCellHeightScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetCellHeightScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetCellWidthScale a
terminal 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.OverloadedMethod TerminalSetCellWidthScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellWidthScale

instance O.OverloadedMethodInfo TerminalSetCellWidthScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetCellWidthScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m ()
terminalSetCjkAmbiguousWidth a
terminal 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.OverloadedMethod TerminalSetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod = terminalSetCjkAmbiguousWidth

instance O.OverloadedMethodInfo TerminalSetCjkAmbiguousWidthMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetCjkAmbiguousWidth",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetClearBackground a
terminal 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.OverloadedMethod TerminalSetClearBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetClearBackground

instance O.OverloadedMethodInfo TerminalSetClearBackgroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetClearBackground",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> RGBA -> m ()
terminalSetColorBackground a
terminal 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.OverloadedMethod TerminalSetColorBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetColorBackground

instance O.OverloadedMethodInfo TerminalSetColorBackgroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorBackground",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorBold a
terminal 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetColorBoldMethodInfo a signature where
    overloadedMethod = terminalSetColorBold

instance O.OverloadedMethodInfo TerminalSetColorBoldMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorBold",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorCursor a
terminal 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetColorCursorMethodInfo a signature where
    overloadedMethod = terminalSetColorCursor

instance O.OverloadedMethodInfo TerminalSetColorCursorMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorCursor",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorCursorForeground a
terminal 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetColorCursorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorCursorForeground

instance O.OverloadedMethodInfo TerminalSetColorCursorForegroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorCursorForeground",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> RGBA -> m ()
terminalSetColorForeground a
terminal 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.OverloadedMethod TerminalSetColorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorForeground

instance O.OverloadedMethodInfo TerminalSetColorForegroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorForeground",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorHighlight a
terminal 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetColorHighlightMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlight

instance O.OverloadedMethodInfo TerminalSetColorHighlightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorHighlight",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorHighlightForeground a
terminal 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetColorHighlightForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlightForeground

instance O.OverloadedMethodInfo TerminalSetColorHighlightForegroundMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColorHighlightForeground",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()
terminalSetColors a
terminal Maybe RGBA
foreground Maybe RGBA
background 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
            Maybe [RGBA]
Nothing -> Word64
0
            Just [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
P.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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just 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
        Maybe [RGBA]
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just [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 Int
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.OverloadedMethod TerminalSetColorsMethodInfo a signature where
    overloadedMethod = terminalSetColors

instance O.OverloadedMethodInfo TerminalSetColorsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetColors",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CursorBlinkMode -> m ()
terminalSetCursorBlinkMode a
terminal 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.OverloadedMethod TerminalSetCursorBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetCursorBlinkMode

instance O.OverloadedMethodInfo TerminalSetCursorBlinkModeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetCursorBlinkMode",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CursorShape -> m ()
terminalSetCursorShape a
terminal 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.OverloadedMethod TerminalSetCursorShapeMethodInfo a signature where
    overloadedMethod = terminalSetCursorShape

instance O.OverloadedMethodInfo TerminalSetCursorShapeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetCursorShape",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalSetDefaultColors 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.OverloadedMethod TerminalSetDefaultColorsMethodInfo a signature where
    overloadedMethod = terminalSetDefaultColors

instance O.OverloadedMethodInfo TerminalSetDefaultColorsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetDefaultColors",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> EraseBinding -> m ()
terminalSetDeleteBinding a
terminal 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.OverloadedMethod TerminalSetDeleteBindingMethodInfo a signature where
    overloadedMethod = terminalSetDeleteBinding

instance O.OverloadedMethodInfo TerminalSetDeleteBindingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetDeleteBinding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSetDeleteBinding"
        }


#endif

-- method Terminal::set_enable_bidi
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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 = "enable_bidi"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to enable BiDi support"
--                 , 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_enable_bidi" vte_terminal_set_enable_bidi :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- enable_bidi : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will perform bidirectional text rendering.
-- 
-- /Since: 0.58/
terminalSetEnableBidi ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enableBidi@/: 'P.True' to enable BiDi support
    -> m ()
terminalSetEnableBidi :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableBidi a
terminal Bool
enableBidi = 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 enableBidi' :: CInt
enableBidi' = (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
enableBidi
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_bidi Ptr Terminal
terminal' CInt
enableBidi'
    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 TerminalSetEnableBidiMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableBidiMethodInfo a signature where
    overloadedMethod = terminalSetEnableBidi

instance O.OverloadedMethodInfo TerminalSetEnableBidiMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetEnableBidi",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableBidi"
        }


#endif

-- method Terminal::set_enable_shaping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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 = "enable_shaping"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to enable Arabic shaping"
--                 , 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_enable_shaping" vte_terminal_set_enable_shaping :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- enable_shaping : TBasicType TBoolean
    IO ()

-- | Controls whether or not the terminal will shape Arabic text.
-- 
-- /Since: 0.58/
terminalSetEnableShaping ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enableShaping@/: 'P.True' to enable Arabic shaping
    -> m ()
terminalSetEnableShaping :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableShaping a
terminal Bool
enableShaping = 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 enableShaping' :: CInt
enableShaping' = (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
enableShaping
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_shaping Ptr Terminal
terminal' CInt
enableShaping'
    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 TerminalSetEnableShapingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableShapingMethodInfo a signature where
    overloadedMethod = terminalSetEnableShaping

instance O.OverloadedMethodInfo TerminalSetEnableShapingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetEnableShaping",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableShaping"
        }


#endif

-- method Terminal::set_enable_sixel
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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 SIXEL images"
--                 , 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_enable_sixel" vte_terminal_set_enable_sixel :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | This function does nothing.
-- 
-- /Since: 0.62/
terminalSetEnableSixel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enabled@/: whether to enable SIXEL images
    -> m ()
terminalSetEnableSixel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableSixel a
terminal 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_enable_sixel 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 TerminalSetEnableSixelMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableSixelMethodInfo a signature where
    overloadedMethod = terminalSetEnableSixel

instance O.OverloadedMethodInfo TerminalSetEnableSixelMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetEnableSixel",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableSixel"
        }


#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 "target charset, 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@/: target charset, or 'P.Nothing' to use UTF-8
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalSetEncoding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Text -> m ()
terminalSetEncoding a
terminal 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
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetEncodingMethodInfo a signature where
    overloadedMethod = terminalSetEncoding

instance O.OverloadedMethodInfo TerminalSetEncodingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetEncoding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe FontDescription -> m ()
terminalSetFont a
terminal 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
        Maybe FontDescription
Nothing -> Ptr FontDescription -> IO (Ptr FontDescription)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDescription
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetFontMethodInfo a signature where
    overloadedMethod = terminalSetFont

instance O.OverloadedMethodInfo TerminalSetFontMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetFont",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetFontScale a
terminal 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.OverloadedMethod TerminalSetFontScaleMethodInfo a signature where
    overloadedMethod = terminalSetFontScale

instance O.OverloadedMethodInfo TerminalSetFontScaleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetFontScale",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsWindow b) =>
a -> b -> m ()
terminalSetGeometryHintsForWindow a
terminal 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.OverloadedMethod TerminalSetGeometryHintsForWindowMethodInfo a signature where
    overloadedMethod = terminalSetGeometryHintsForWindow

instance O.OverloadedMethodInfo TerminalSetGeometryHintsForWindowMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetGeometryHintsForWindow",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetInputEnabled a
terminal 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.OverloadedMethod TerminalSetInputEnabledMethodInfo a signature where
    overloadedMethod = terminalSetInputEnabled

instance O.OverloadedMethodInfo TerminalSetInputEnabledMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetInputEnabled",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetMouseAutohide a
terminal 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.OverloadedMethod TerminalSetMouseAutohideMethodInfo a signature where
    overloadedMethod = terminalSetMouseAutohide

instance O.OverloadedMethodInfo TerminalSetMouseAutohideMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetMouseAutohide",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsPty b) =>
a -> Maybe b -> m ()
terminalSetPty a
terminal 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
        Maybe b
Nothing -> Ptr Pty -> IO (Ptr Pty)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pty
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSetPtyMethodInfo a signature where
    overloadedMethod = terminalSetPty

instance O.OverloadedMethodInfo TerminalSetPtyMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetPty",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 ()

{-# DEPRECATED terminalSetRewrapOnResize ["(Since version 0.58)"] #-}
-- | 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetRewrapOnResize a
terminal 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.OverloadedMethod TerminalSetRewrapOnResizeMethodInfo a signature where
    overloadedMethod = terminalSetRewrapOnResize

instance O.OverloadedMethodInfo TerminalSetRewrapOnResizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetRewrapOnResize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollOnKeystroke a
terminal 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.OverloadedMethod TerminalSetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnKeystroke

instance O.OverloadedMethodInfo TerminalSetScrollOnKeystrokeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetScrollOnKeystroke",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollOnOutput a
terminal 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.OverloadedMethod TerminalSetScrollOnOutputMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnOutput

instance O.OverloadedMethodInfo TerminalSetScrollOnOutputMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetScrollOnOutput",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Word32 -> m ()
terminalSetScrollSpeed a
terminal 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.OverloadedMethod TerminalSetScrollSpeedMethodInfo a signature where
    overloadedMethod = terminalSetScrollSpeed

instance O.OverloadedMethodInfo TerminalSetScrollSpeedMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetScrollSpeed",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> m ()
terminalSetScrollbackLines a
terminal 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.OverloadedMethod TerminalSetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalSetScrollbackLines

instance O.OverloadedMethodInfo TerminalSetScrollbackLinesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetScrollbackLines",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> CLong -> m ()
terminalSetSize a
terminal CLong
columns 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.OverloadedMethod TerminalSetSizeMethodInfo a signature where
    overloadedMethod = terminalSetSize

instance O.OverloadedMethodInfo TerminalSetSizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetSize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> TextBlinkMode -> m ()
terminalSetTextBlinkMode a
terminal 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.OverloadedMethod TerminalSetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetTextBlinkMode

instance O.OverloadedMethodInfo TerminalSetTextBlinkModeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetTextBlinkMode",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m ()
terminalSetWordCharExceptions a
terminal 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.OverloadedMethod TerminalSetWordCharExceptionsMethodInfo a signature where
    overloadedMethod = terminalSetWordCharExceptions

instance O.OverloadedMethodInfo TerminalSetWordCharExceptionsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSetWordCharExceptions",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSetWordCharExceptions"
        }


#endif

-- method Terminal::spawn_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , 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 = ScopeTypeAsync
--           , argClosure = 7
--           , argDestroy = 8
--           , 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, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GDestroyNotify for @child_setup_data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely"
--                 , 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
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface
--                 Name { namespace = "Vte" , name = "TerminalSpawnAsyncCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminalSpawnAsyncCallback, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 12
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @callback, 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_spawn_async" vte_terminal_spawn_async :: 
    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
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- child_setup_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    Int32 ->                                -- timeout : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback -> -- callback : TInterface (Name {namespace = "Vte", name = "TerminalSpawnAsyncCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | A convenience function that wraps creating the t'GI.Vte.Objects.Pty.Pty' and spawning
-- the child process on it. Like 'GI.Vte.Objects.Terminal.terminalSpawnWithFdsAsync',
-- except that this function does not allow passing file descriptors to
-- the child process. See 'GI.Vte.Objects.Terminal.terminalSpawnWithFdsAsync' for more
-- information.
-- 
-- /Since: 0.48/
terminalSpawnAsync ::
    (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'
    -> Int32
    -- ^ /@timeout@/: a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Vte.Callbacks.TerminalSpawnAsyncCallback)
    -- ^ /@callback@/: a t'GI.Vte.Callbacks.TerminalSpawnAsyncCallback', or 'P.Nothing'
    -> m ()
terminalSpawnAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe (IO ())
-> Int32
-> Maybe b
-> Maybe TerminalSpawnAsyncCallback
-> m ()
terminalSpawnAsync a
terminal [PtyFlags]
ptyFlags Maybe Text
workingDirectory [String]
argv Maybe [String]
envv [SpawnFlags]
spawnFlags Maybe (IO ())
childSetup Int32
timeout Maybe b
cancellable Maybe TerminalSpawnAsyncCallback
callback = 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 ptyFlags' :: CUInt
ptyFlags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
ptyFlags
    CString
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just 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
        Maybe [String]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
        Just [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
        Maybe (IO ())
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 IO ()
jChildSetup -> do
            Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup <- IO (Ptr (FunPtr C_SpawnChildSetupFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_SpawnChildSetupFunc))
            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 (Ptr (FunPtr C_SpawnChildSetupFunc)
-> Maybe (Ptr (FunPtr C_SpawnChildSetupFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup) (IO () -> C_SpawnChildSetupFunc
GLib.Callbacks.drop_closures_SpawnChildSetupFunc IO ()
jChildSetup))
            Ptr (FunPtr C_SpawnChildSetupFunc)
-> FunPtr C_SpawnChildSetupFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup FunPtr C_SpawnChildSetupFunc
jChildSetup'
            FunPtr C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SpawnChildSetupFunc
jChildSetup'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just 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'
    FunPtr C_TerminalSpawnAsyncCallback
maybeCallback <- case Maybe TerminalSpawnAsyncCallback
callback of
        Maybe TerminalSpawnAsyncCallback
Nothing -> FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_TerminalSpawnAsyncCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just TerminalSpawnAsyncCallback
jCallback -> do
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback <- IO (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback))
            FunPtr C_TerminalSpawnAsyncCallback
jCallback' <- C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
Vte.Callbacks.mk_TerminalSpawnAsyncCallback (Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
-> TerminalSpawnAsyncCallback_WithClosures
-> C_TerminalSpawnAsyncCallback
Vte.Callbacks.wrap_TerminalSpawnAsyncCallback (Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback) (TerminalSpawnAsyncCallback
-> TerminalSpawnAsyncCallback_WithClosures
Vte.Callbacks.drop_closures_TerminalSpawnAsyncCallback TerminalSpawnAsyncCallback
jCallback))
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> FunPtr C_TerminalSpawnAsyncCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback FunPtr C_TerminalSpawnAsyncCallback
jCallback'
            FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TerminalSpawnAsyncCallback
jCallback'
    let childSetupData :: Ptr a
childSetupData = Ptr a
forall a. Ptr a
nullPtr
    let childSetupDataDestroy :: FunPtr a
childSetupDataDestroy = FunPtr a
forall a. FunPtr a
FP.nullFunPtr
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Terminal
-> CUInt
-> CString
-> Ptr CString
-> Ptr CString
-> CUInt
-> FunPtr C_SpawnChildSetupFunc
-> Ptr ()
-> FunPtr C_SpawnChildSetupFunc
-> Int32
-> Ptr Cancellable
-> FunPtr C_TerminalSpawnAsyncCallback
-> C_SpawnChildSetupFunc
vte_terminal_spawn_async 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 FunPtr C_SpawnChildSetupFunc
forall a. FunPtr a
childSetupDataDestroy Int32
timeout Ptr Cancellable
maybeCancellable FunPtr C_TerminalSpawnAsyncCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    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
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSpawnAsyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (T.Text) -> [[Char]] -> Maybe ([[Char]]) -> [GLib.Flags.SpawnFlags] -> Maybe (GLib.Callbacks.SpawnChildSetupFunc) -> Int32 -> Maybe (b) -> Maybe (Vte.Callbacks.TerminalSpawnAsyncCallback) -> m ()), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod TerminalSpawnAsyncMethodInfo a signature where
    overloadedMethod = terminalSpawnAsync

instance O.OverloadedMethodInfo TerminalSpawnAsyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSpawnAsync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSpawnAsync"
        }


#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 'GI.Vte.Objects.Terminal.terminalSpawnAsync' 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 also that 'GI.GLib.Flags.SpawnFlagsStdoutToDevNull', 'GI.GLib.Flags.SpawnFlagsStderrToDevNull',
-- and 'GI.GLib.Flags.SpawnFlagsChildInheritsStdin' are not supported in /@spawnFlags@/, since
-- stdin, stdout and stderr of the child process will always be connected to
-- the PTY.
-- 
-- 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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe (IO ())
-> Maybe b
-> m Int32
terminalSpawnSync a
terminal [PtyFlags]
ptyFlags Maybe Text
workingDirectory [String]
argv Maybe [String]
envv [SpawnFlags]
spawnFlags Maybe (IO ())
childSetup 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
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just 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
        Maybe [String]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
        Just [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
        Maybe (IO ())
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 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
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalSpawnSyncMethodInfo a signature where
    overloadedMethod = terminalSpawnSync

instance O.OverloadedMethodInfo TerminalSpawnSyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalSpawnSync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalSpawnSync"
        }


#endif

-- XXX Could not generate method Terminal::spawn_with_fds_async
-- Bad introspection data: Closure "childSetupData" is not a callback.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalSpawnWithFdsAsyncMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "spawnWithFdsAsync" Terminal) => O.OverloadedMethod TerminalSpawnWithFdsAsyncMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "spawnWithFdsAsync" Terminal) => O.OverloadedMethodInfo TerminalSpawnWithFdsAsyncMethodInfo o where
    overloadedMethodInfo = undefined

#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalUnselectAll 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.OverloadedMethod TerminalUnselectAllMethodInfo a signature where
    overloadedMethod = terminalUnselectAll

instance O.OverloadedMethodInfo TerminalUnselectAllMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalUnselectAll",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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#g: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m ()
terminalWatchChild a
terminal 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.OverloadedMethod TerminalWatchChildMethodInfo a signature where
    overloadedMethod = terminalWatchChild

instance O.OverloadedMethodInfo TerminalWatchChildMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalWatchChild",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v: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 :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsTerminal a, IsOutputStream b,
 IsCancellable c) =>
a -> b -> WriteFlags -> Maybe c -> m ()
terminalWriteContentsSync a
terminal b
stream WriteFlags
flags 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
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just 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.OverloadedMethod TerminalWriteContentsSyncMethodInfo a signature where
    overloadedMethod = terminalWriteContentsSync

instance O.OverloadedMethodInfo TerminalWriteContentsSyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Vte.Objects.Terminal.terminalWriteContentsSync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Terminal.html#v:terminalWriteContentsSync"
        }


#endif