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