{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


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

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.Vte.Objects.Terminal
    ( 

-- * 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"), [dupTermpropString]("GI.Vte.Objects.Terminal#g:method:dupTermpropString"), [dupTermpropStringById]("GI.Vte.Objects.Terminal#g:method:dupTermpropStringById"), [dupTermpropUuid]("GI.Vte.Objects.Terminal#g:method:dupTermpropUuid"), [dupTermpropUuidById]("GI.Vte.Objects.Terminal#g:method:dupTermpropUuidById"), [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"), [pasteText]("GI.Vte.Objects.Terminal#g:method:pasteText"), [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"), [refTermpropDataBytes]("GI.Vte.Objects.Terminal#g:method:refTermpropDataBytes"), [refTermpropDataBytesById]("GI.Vte.Objects.Terminal#g:method:refTermpropDataBytesById"), [refTermpropImagePixbuf]("GI.Vte.Objects.Terminal#g:method:refTermpropImagePixbuf"), [refTermpropImagePixbufById]("GI.Vte.Objects.Terminal#g:method:refTermpropImagePixbufById"), [refTermpropImageSurface]("GI.Vte.Objects.Terminal#g:method:refTermpropImageSurface"), [refTermpropImageSurfaceById]("GI.Vte.Objects.Terminal#g:method:refTermpropImageSurfaceById"), [refTermpropUri]("GI.Vte.Objects.Terminal#g:method:refTermpropUri"), [refTermpropUriById]("GI.Vte.Objects.Terminal#g:method:refTermpropUriById"), [refTermpropVariant]("GI.Vte.Objects.Terminal#g:method:refTermpropVariant"), [refTermpropVariantById]("GI.Vte.Objects.Terminal#g:method:refTermpropVariantById"), [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"), [getContextMenu]("GI.Vte.Objects.Terminal#g:method:getContextMenu"), [getContextMenuModel]("GI.Vte.Objects.Terminal#g:method:getContextMenuModel"), [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"), [getEnableA11y]("GI.Vte.Objects.Terminal#g:method:getEnableA11y"), [getEnableBidi]("GI.Vte.Objects.Terminal#g:method:getEnableBidi"), [getEnableFallbackScrolling]("GI.Vte.Objects.Terminal#g:method:getEnableFallbackScrolling"), [getEnableLegacyOsc777]("GI.Vte.Objects.Terminal#g:method:getEnableLegacyOsc777"), [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.Vte.Objects.Terminal#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"), [getScrollOnInsert]("GI.Vte.Objects.Terminal#g:method:getScrollOnInsert"), [getScrollOnKeystroke]("GI.Vte.Objects.Terminal#g:method:getScrollOnKeystroke"), [getScrollOnOutput]("GI.Vte.Objects.Terminal#g:method:getScrollOnOutput"), [getScrollUnitIsPixels]("GI.Vte.Objects.Terminal#g:method:getScrollUnitIsPixels"), [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"), [getTermpropBool]("GI.Vte.Objects.Terminal#g:method:getTermpropBool"), [getTermpropBoolById]("GI.Vte.Objects.Terminal#g:method:getTermpropBoolById"), [getTermpropData]("GI.Vte.Objects.Terminal#g:method:getTermpropData"), [getTermpropDataById]("GI.Vte.Objects.Terminal#g:method:getTermpropDataById"), [getTermpropDouble]("GI.Vte.Objects.Terminal#g:method:getTermpropDouble"), [getTermpropDoubleById]("GI.Vte.Objects.Terminal#g:method:getTermpropDoubleById"), [getTermpropInt]("GI.Vte.Objects.Terminal#g:method:getTermpropInt"), [getTermpropIntById]("GI.Vte.Objects.Terminal#g:method:getTermpropIntById"), [getTermpropRgba]("GI.Vte.Objects.Terminal#g:method:getTermpropRgba"), [getTermpropRgbaById]("GI.Vte.Objects.Terminal#g:method:getTermpropRgbaById"), [getTermpropString]("GI.Vte.Objects.Terminal#g:method:getTermpropString"), [getTermpropStringById]("GI.Vte.Objects.Terminal#g:method:getTermpropStringById"), [getTermpropUint]("GI.Vte.Objects.Terminal#g:method:getTermpropUint"), [getTermpropUintById]("GI.Vte.Objects.Terminal#g:method:getTermpropUintById"), [getTermpropValue]("GI.Vte.Objects.Terminal#g:method:getTermpropValue"), [getTermpropValueById]("GI.Vte.Objects.Terminal#g:method:getTermpropValueById"), [getText]("GI.Vte.Objects.Terminal#g:method:getText"), [getTextBlinkMode]("GI.Vte.Objects.Terminal#g:method:getTextBlinkMode"), [getTextFormat]("GI.Vte.Objects.Terminal#g:method:getTextFormat"), [getTextIncludeTrailingSpaces]("GI.Vte.Objects.Terminal#g:method:getTextIncludeTrailingSpaces"), [getTextRange]("GI.Vte.Objects.Terminal#g:method:getTextRange"), [getTextRangeFormat]("GI.Vte.Objects.Terminal#g:method:getTextRangeFormat"), [getTextSelected]("GI.Vte.Objects.Terminal#g:method:getTextSelected"), [getTextSelectedFull]("GI.Vte.Objects.Terminal#g:method:getTextSelectedFull"), [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"), [getXalign]("GI.Vte.Objects.Terminal#g:method:getXalign"), [getXfill]("GI.Vte.Objects.Terminal#g:method:getXfill"), [getYalign]("GI.Vte.Objects.Terminal#g:method:getYalign"), [getYfill]("GI.Vte.Objects.Terminal#g:method:getYfill").
-- 
-- ==== 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"), [setContextMenu]("GI.Vte.Objects.Terminal#g:method:setContextMenu"), [setContextMenuModel]("GI.Vte.Objects.Terminal#g:method:setContextMenuModel"), [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"), [setEnableA11y]("GI.Vte.Objects.Terminal#g:method:setEnableA11y"), [setEnableBidi]("GI.Vte.Objects.Terminal#g:method:setEnableBidi"), [setEnableFallbackScrolling]("GI.Vte.Objects.Terminal#g:method:setEnableFallbackScrolling"), [setEnableLegacyOsc777]("GI.Vte.Objects.Terminal#g:method:setEnableLegacyOsc777"), [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.Vte.Objects.Terminal#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"), [setScrollOnInsert]("GI.Vte.Objects.Terminal#g:method:setScrollOnInsert"), [setScrollOnKeystroke]("GI.Vte.Objects.Terminal#g:method:setScrollOnKeystroke"), [setScrollOnOutput]("GI.Vte.Objects.Terminal#g:method:setScrollOnOutput"), [setScrollUnitIsPixels]("GI.Vte.Objects.Terminal#g:method:setScrollUnitIsPixels"), [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"), [setSuppressLegacySignals]("GI.Vte.Objects.Terminal#g:method:setSuppressLegacySignals"), [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"), [setXalign]("GI.Vte.Objects.Terminal#g:method:setXalign"), [setXfill]("GI.Vte.Objects.Terminal#g:method:setXfill"), [setYalign]("GI.Vte.Objects.Terminal#g:method:setYalign"), [setYfill]("GI.Vte.Objects.Terminal#g:method:setYfill").

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


-- ** dupTermpropString #method:dupTermpropString#

#if defined(ENABLE_OVERLOADING)
    TerminalDupTermpropStringMethodInfo     ,
#endif
    terminalDupTermpropString               ,


-- ** dupTermpropStringById #method:dupTermpropStringById#

#if defined(ENABLE_OVERLOADING)
    TerminalDupTermpropStringByIdMethodInfo ,
#endif
    terminalDupTermpropStringById           ,


-- ** dupTermpropUuid #method:dupTermpropUuid#

#if defined(ENABLE_OVERLOADING)
    TerminalDupTermpropUuidMethodInfo       ,
#endif
    terminalDupTermpropUuid                 ,


-- ** dupTermpropUuidById #method:dupTermpropUuidById#

#if defined(ENABLE_OVERLOADING)
    TerminalDupTermpropUuidByIdMethodInfo   ,
#endif
    terminalDupTermpropUuidById             ,


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


-- ** getContextMenu #method:getContextMenu#

#if defined(ENABLE_OVERLOADING)
    TerminalGetContextMenuMethodInfo        ,
#endif
    terminalGetContextMenu                  ,


-- ** getContextMenuModel #method:getContextMenuModel#

#if defined(ENABLE_OVERLOADING)
    TerminalGetContextMenuModelMethodInfo   ,
#endif
    terminalGetContextMenuModel             ,


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


-- ** getEnableA11y #method:getEnableA11y#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableA11yMethodInfo         ,
#endif
    terminalGetEnableA11y                   ,


-- ** getEnableBidi #method:getEnableBidi#

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


-- ** getEnableFallbackScrolling #method:getEnableFallbackScrolling#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableFallbackScrollingMethodInfo,
#endif
    terminalGetEnableFallbackScrolling      ,


-- ** getEnableLegacyOsc777 #method:getEnableLegacyOsc777#

#if defined(ENABLE_OVERLOADING)
    TerminalGetEnableLegacyOsc777MethodInfo ,
#endif
    terminalGetEnableLegacyOsc777           ,


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


-- ** getFontOptions #method:getFontOptions#

#if defined(ENABLE_OVERLOADING)
    TerminalGetFontOptionsMethodInfo        ,
#endif
    terminalGetFontOptions                  ,


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


-- ** getScrollOnInsert #method:getScrollOnInsert#

#if defined(ENABLE_OVERLOADING)
    TerminalGetScrollOnInsertMethodInfo     ,
#endif
    terminalGetScrollOnInsert               ,


-- ** getScrollOnKeystroke #method:getScrollOnKeystroke#

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


-- ** getScrollOnOutput #method:getScrollOnOutput#

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


-- ** getScrollUnitIsPixels #method:getScrollUnitIsPixels#

#if defined(ENABLE_OVERLOADING)
    TerminalGetScrollUnitIsPixelsMethodInfo ,
#endif
    terminalGetScrollUnitIsPixels           ,


-- ** getScrollbackLines #method:getScrollbackLines#

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


-- ** getTermpropBool #method:getTermpropBool#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropBoolMethodInfo       ,
#endif
    terminalGetTermpropBool                 ,


-- ** getTermpropBoolById #method:getTermpropBoolById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropBoolByIdMethodInfo   ,
#endif
    terminalGetTermpropBoolById             ,


-- ** getTermpropData #method:getTermpropData#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropDataMethodInfo       ,
#endif
    terminalGetTermpropData                 ,


-- ** getTermpropDataById #method:getTermpropDataById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropDataByIdMethodInfo   ,
#endif
    terminalGetTermpropDataById             ,


-- ** getTermpropDouble #method:getTermpropDouble#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropDoubleMethodInfo     ,
#endif
    terminalGetTermpropDouble               ,


-- ** getTermpropDoubleById #method:getTermpropDoubleById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropDoubleByIdMethodInfo ,
#endif
    terminalGetTermpropDoubleById           ,


-- ** getTermpropInt #method:getTermpropInt#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropIntMethodInfo        ,
#endif
    terminalGetTermpropInt                  ,


-- ** getTermpropIntById #method:getTermpropIntById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropIntByIdMethodInfo    ,
#endif
    terminalGetTermpropIntById              ,


-- ** getTermpropRgba #method:getTermpropRgba#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropRgbaMethodInfo       ,
#endif
    terminalGetTermpropRgba                 ,


-- ** getTermpropRgbaById #method:getTermpropRgbaById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropRgbaByIdMethodInfo   ,
#endif
    terminalGetTermpropRgbaById             ,


-- ** getTermpropString #method:getTermpropString#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropStringMethodInfo     ,
#endif
    terminalGetTermpropString               ,


-- ** getTermpropStringById #method:getTermpropStringById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropStringByIdMethodInfo ,
#endif
    terminalGetTermpropStringById           ,


-- ** getTermpropUint #method:getTermpropUint#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropUintMethodInfo       ,
#endif
    terminalGetTermpropUint                 ,


-- ** getTermpropUintById #method:getTermpropUintById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropUintByIdMethodInfo   ,
#endif
    terminalGetTermpropUintById             ,


-- ** getTermpropValue #method:getTermpropValue#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropValueMethodInfo      ,
#endif
    terminalGetTermpropValue                ,


-- ** getTermpropValueById #method:getTermpropValueById#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTermpropValueByIdMethodInfo  ,
#endif
    terminalGetTermpropValueById            ,


-- ** getText #method:getText#

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


-- ** getTextBlinkMode #method:getTextBlinkMode#

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


-- ** getTextFormat #method:getTextFormat#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextFormatMethodInfo         ,
#endif
    terminalGetTextFormat                   ,


-- ** getTextIncludeTrailingSpaces #method:getTextIncludeTrailingSpaces#

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


-- ** getTextRange #method:getTextRange#

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


-- ** getTextRangeFormat #method:getTextRangeFormat#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextRangeFormatMethodInfo    ,
#endif
    terminalGetTextRangeFormat              ,


-- ** getTextSelected #method:getTextSelected#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextSelectedMethodInfo       ,
#endif
    terminalGetTextSelected                 ,


-- ** getTextSelectedFull #method:getTextSelectedFull#

#if defined(ENABLE_OVERLOADING)
    TerminalGetTextSelectedFullMethodInfo   ,
#endif
    terminalGetTextSelectedFull             ,


-- ** getWindowTitle #method:getWindowTitle#

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


-- ** getWordCharExceptions #method:getWordCharExceptions#

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


-- ** getXalign #method:getXalign#

#if defined(ENABLE_OVERLOADING)
    TerminalGetXalignMethodInfo             ,
#endif
    terminalGetXalign                       ,


-- ** getXfill #method:getXfill#

#if defined(ENABLE_OVERLOADING)
    TerminalGetXfillMethodInfo              ,
#endif
    terminalGetXfill                        ,


-- ** getYalign #method:getYalign#

#if defined(ENABLE_OVERLOADING)
    TerminalGetYalignMethodInfo             ,
#endif
    terminalGetYalign                       ,


-- ** getYfill #method:getYfill#

#if defined(ENABLE_OVERLOADING)
    TerminalGetYfillMethodInfo              ,
#endif
    terminalGetYfill                        ,


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


-- ** pasteText #method:pasteText#

#if defined(ENABLE_OVERLOADING)
    TerminalPasteTextMethodInfo             ,
#endif
    terminalPasteText                       ,


-- ** ptyNewSync #method:ptyNewSync#

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


-- ** refTermpropDataBytes #method:refTermpropDataBytes#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropDataBytesMethodInfo  ,
#endif
    terminalRefTermpropDataBytes            ,


-- ** refTermpropDataBytesById #method:refTermpropDataBytesById#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropDataBytesByIdMethodInfo,
#endif
    terminalRefTermpropDataBytesById        ,


-- ** refTermpropImagePixbuf #method:refTermpropImagePixbuf#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropImagePixbufMethodInfo,
#endif
    terminalRefTermpropImagePixbuf          ,


-- ** refTermpropImagePixbufById #method:refTermpropImagePixbufById#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropImagePixbufByIdMethodInfo,
#endif
    terminalRefTermpropImagePixbufById      ,


-- ** refTermpropImageSurface #method:refTermpropImageSurface#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropImageSurfaceMethodInfo,
#endif
    terminalRefTermpropImageSurface         ,


-- ** refTermpropImageSurfaceById #method:refTermpropImageSurfaceById#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropImageSurfaceByIdMethodInfo,
#endif
    terminalRefTermpropImageSurfaceById     ,


-- ** refTermpropUri #method:refTermpropUri#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropUriMethodInfo        ,
#endif
    terminalRefTermpropUri                  ,


-- ** refTermpropUriById #method:refTermpropUriById#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropUriByIdMethodInfo    ,
#endif
    terminalRefTermpropUriById              ,


-- ** refTermpropVariant #method:refTermpropVariant#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropVariantMethodInfo    ,
#endif
    terminalRefTermpropVariant              ,


-- ** refTermpropVariantById #method:refTermpropVariantById#

#if defined(ENABLE_OVERLOADING)
    TerminalRefTermpropVariantByIdMethodInfo,
#endif
    terminalRefTermpropVariantById          ,


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


-- ** setContextMenu #method:setContextMenu#

#if defined(ENABLE_OVERLOADING)
    TerminalSetContextMenuMethodInfo        ,
#endif
    terminalSetContextMenu                  ,


-- ** setContextMenuModel #method:setContextMenuModel#

#if defined(ENABLE_OVERLOADING)
    TerminalSetContextMenuModelMethodInfo   ,
#endif
    terminalSetContextMenuModel             ,


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


-- ** setEnableA11y #method:setEnableA11y#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableA11yMethodInfo         ,
#endif
    terminalSetEnableA11y                   ,


-- ** setEnableBidi #method:setEnableBidi#

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


-- ** setEnableFallbackScrolling #method:setEnableFallbackScrolling#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableFallbackScrollingMethodInfo,
#endif
    terminalSetEnableFallbackScrolling      ,


-- ** setEnableLegacyOsc777 #method:setEnableLegacyOsc777#

#if defined(ENABLE_OVERLOADING)
    TerminalSetEnableLegacyOsc777MethodInfo ,
#endif
    terminalSetEnableLegacyOsc777           ,


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


-- ** setFontOptions #method:setFontOptions#

#if defined(ENABLE_OVERLOADING)
    TerminalSetFontOptionsMethodInfo        ,
#endif
    terminalSetFontOptions                  ,


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


-- ** setScrollOnInsert #method:setScrollOnInsert#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollOnInsertMethodInfo     ,
#endif
    terminalSetScrollOnInsert               ,


-- ** setScrollOnKeystroke #method:setScrollOnKeystroke#

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


-- ** setScrollOnOutput #method:setScrollOnOutput#

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


-- ** setScrollUnitIsPixels #method:setScrollUnitIsPixels#

#if defined(ENABLE_OVERLOADING)
    TerminalSetScrollUnitIsPixelsMethodInfo ,
#endif
    terminalSetScrollUnitIsPixels           ,


-- ** setScrollbackLines #method:setScrollbackLines#

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


-- ** setSize #method:setSize#

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


-- ** setSuppressLegacySignals #method:setSuppressLegacySignals#

#if defined(ENABLE_OVERLOADING)
    TerminalSetSuppressLegacySignalsMethodInfo,
#endif
    terminalSetSuppressLegacySignals        ,


-- ** setTextBlinkMode #method:setTextBlinkMode#

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


-- ** setWordCharExceptions #method:setWordCharExceptions#

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


-- ** setXalign #method:setXalign#

#if defined(ENABLE_OVERLOADING)
    TerminalSetXalignMethodInfo             ,
#endif
    terminalSetXalign                       ,


-- ** setXfill #method:setXfill#

#if defined(ENABLE_OVERLOADING)
    TerminalSetXfillMethodInfo              ,
#endif
    terminalSetXfill                        ,


-- ** setYalign #method:setYalign#

#if defined(ENABLE_OVERLOADING)
    TerminalSetYalignMethodInfo             ,
#endif
    terminalSetYalign                       ,


-- ** setYfill #method:setYfill#

#if defined(ENABLE_OVERLOADING)
    TerminalSetYfillMethodInfo              ,
#endif
    terminalSetYfill                        ,


-- ** spawnAsync #method:spawnAsync#

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


-- ** spawnSync #method:spawnSync#

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


-- ** spawnWithFdsAsync #method:spawnWithFdsAsync#

#if defined(ENABLE_OVERLOADING)
    TerminalSpawnWithFdsAsyncMethodInfo     ,
#endif
    terminalSpawnWithFdsAsync               ,


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


-- ** contextMenu #attr:contextMenu#
-- | The menu used for context menus. Note that context menu model set with the
-- t'GI.Vte.Objects.Terminal.Terminal'::@/context-menu-model/@ property or 'GI.Vte.Objects.Terminal.terminalSetContextMenuModel'
-- takes precedence over this.
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalContextMenuPropertyInfo         ,
#endif
    clearTerminalContextMenu                ,
    constructTerminalContextMenu            ,
    getTerminalContextMenu                  ,
    setTerminalContextMenu                  ,
#if defined(ENABLE_OVERLOADING)
    terminalContextMenu                     ,
#endif


-- ** contextMenuModel #attr:contextMenuModel#
-- | The menu model used for context menus. If non-'P.Nothing', the context menu is
-- generated from this model, and overrides a context menu set with the
-- t'GI.Vte.Objects.Terminal.Terminal'::@/context-menu/@ property or 'GI.Vte.Objects.Terminal.terminalSetContextMenu'.
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalContextMenuModelPropertyInfo    ,
#endif
    clearTerminalContextMenuModel           ,
    constructTerminalContextMenuModel       ,
    getTerminalContextMenuModel             ,
    setTerminalContextMenuModel             ,
#if defined(ENABLE_OVERLOADING)
    terminalContextMenuModel                ,
#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 [Settings:gtkCursorBlink]("GI.Gtk.Objects.Settings#g:attr:gtkCursorBlink") 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


-- ** enableA11y #attr:enableA11y#
-- | Controls whether or not a11y is enabled for the widget.
-- 
-- /Since: 0.78/

#if defined(ENABLE_OVERLOADING)
    TerminalEnableA11yPropertyInfo          ,
#endif
    constructTerminalEnableA11y             ,
    getTerminalEnableA11y                   ,
    setTerminalEnableA11y                   ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableA11y                      ,
#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


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

#if defined(ENABLE_OVERLOADING)
    TerminalEnableFallbackScrollingPropertyInfo,
#endif
    constructTerminalEnableFallbackScrolling,
    getTerminalEnableFallbackScrolling      ,
    setTerminalEnableFallbackScrolling      ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableFallbackScrolling         ,
#endif


-- ** enableLegacyOsc777 #attr:enableLegacyOsc777#
-- | Whether legacy OSC 777 sequences are translated to
-- their corresponding termprops.
-- 
-- /Since: 0.78/

#if defined(ENABLE_OVERLOADING)
    TerminalEnableLegacyOsc777PropertyInfo  ,
#endif
    constructTerminalEnableLegacyOsc777     ,
    getTerminalEnableLegacyOsc777           ,
    setTerminalEnableLegacyOsc777           ,
#if defined(ENABLE_OVERLOADING)
    terminalEnableLegacyOsc777              ,
#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


-- ** fontOptions #attr:fontOptions#
-- | The terminal\'s font options, or 'P.Nothing' to use the default font options.
-- 
-- Note that on GTK4, the terminal by default uses font options
-- with 'GI.Cairo.Enums.HintMetricsOn' set; to override that, use this
-- function to set a t'GI.Cairo.Structs.FontOptions.FontOptions' that has
-- 'GI.Cairo.Enums.HintMetricsOff' set.
-- 
-- /Since: 0.74/

#if defined(ENABLE_OVERLOADING)
    TerminalFontOptionsPropertyInfo         ,
#endif
    clearTerminalFontOptions                ,
    constructTerminalFontOptions            ,
    getTerminalFontOptions                  ,
    setTerminalFontOptions                  ,
#if defined(ENABLE_OVERLOADING)
    terminalFontOptions                     ,
#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


-- ** scrollOnInsert #attr:scrollOnInsert#
-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the text is inserted (e.g. by a paste).
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalScrollOnInsertPropertyInfo      ,
#endif
    constructTerminalScrollOnInsert         ,
    getTerminalScrollOnInsert               ,
    setTerminalScrollOnInsert               ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollOnInsert                  ,
#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


-- ** scrollUnitIsPixels #attr:scrollUnitIsPixels#
-- | Controls whether the terminal\'s GtkAdjustment values unit is lines
-- or pixels. This can be enabled when the terminal is the child of a
-- GtkScrolledWindow to fix some bugs with its kinetic scrolling.
-- 
-- /Since: 0.66/

#if defined(ENABLE_OVERLOADING)
    TerminalScrollUnitIsPixelsPropertyInfo  ,
#endif
    constructTerminalScrollUnitIsPixels     ,
    getTerminalScrollUnitIsPixels           ,
    setTerminalScrollUnitIsPixels           ,
#if defined(ENABLE_OVERLOADING)
    terminalScrollUnitIsPixels              ,
#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


-- ** xalign #attr:xalign#
-- | The horizontal alignment of /@terminal@/ within its allocation.
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalXalignPropertyInfo              ,
#endif
    constructTerminalXalign                 ,
    getTerminalXalign                       ,
    setTerminalXalign                       ,
#if defined(ENABLE_OVERLOADING)
    terminalXalign                          ,
#endif


-- ** xfill #attr:xfill#
-- | The horizontal fillment of /@terminal@/ within its allocation.
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalXfillPropertyInfo               ,
#endif
    constructTerminalXfill                  ,
    getTerminalXfill                        ,
    setTerminalXfill                        ,
#if defined(ENABLE_OVERLOADING)
    terminalXfill                           ,
#endif


-- ** yalign #attr:yalign#
-- | The vertical alignment of /@terminal@/ within its allocation
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalYalignPropertyInfo              ,
#endif
    constructTerminalYalign                 ,
    getTerminalYalign                       ,
    setTerminalYalign                       ,
#if defined(ENABLE_OVERLOADING)
    terminalYalign                          ,
#endif


-- ** yfill #attr:yfill#
-- | The vertical fillment of /@terminal@/ within its allocation.
-- Note that [Terminal:yfill]("GI.Vte.Objects.Terminal#g:attr:yfill")='P.True' is only supported with
-- [Terminal:yalign]("GI.Vte.Objects.Terminal#g:attr:yalign")='GI.Vte.Enums.AlignStart', and is ignored for
-- all other yalign values.
-- 
-- /Since: 0.76/

#if defined(ENABLE_OVERLOADING)
    TerminalYfillPropertyInfo               ,
#endif
    constructTerminalYfill                  ,
    getTerminalYfill                        ,
    setTerminalYfill                        ,
#if defined(ENABLE_OVERLOADING)
    terminalYfill                           ,
#endif




 -- * Signals


-- ** bell #signal:bell#

    TerminalBellCallback                    ,
#if defined(ENABLE_OVERLOADING)
    TerminalBellSignalInfo                  ,
#endif
    afterTerminalBell                       ,
    onTerminalBell                          ,


-- ** charSizeChanged #signal:charSizeChanged#

    TerminalCharSizeChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalCharSizeChangedSignalInfo       ,
#endif
    afterTerminalCharSizeChanged            ,
    onTerminalCharSizeChanged               ,


-- ** childExited #signal:childExited#

    TerminalChildExitedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalChildExitedSignalInfo           ,
#endif
    afterTerminalChildExited                ,
    onTerminalChildExited                   ,


-- ** commit #signal:commit#

    TerminalCommitCallback                  ,
#if defined(ENABLE_OVERLOADING)
    TerminalCommitSignalInfo                ,
#endif
    afterTerminalCommit                     ,
    onTerminalCommit                        ,


-- ** contentsChanged #signal:contentsChanged#

    TerminalContentsChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalContentsChangedSignalInfo       ,
#endif
    afterTerminalContentsChanged            ,
    onTerminalContentsChanged               ,


-- ** copyClipboard #signal:copyClipboard#

    TerminalCopyClipboardCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalCopyClipboardSignalInfo         ,
#endif
    afterTerminalCopyClipboard              ,
    onTerminalCopyClipboard                 ,


-- ** currentDirectoryUriChanged #signal:currentDirectoryUriChanged#

    TerminalCurrentDirectoryUriChangedCallback,
#if defined(ENABLE_OVERLOADING)
    TerminalCurrentDirectoryUriChangedSignalInfo,
#endif
    afterTerminalCurrentDirectoryUriChanged ,
    onTerminalCurrentDirectoryUriChanged    ,


-- ** currentFileUriChanged #signal:currentFileUriChanged#

    TerminalCurrentFileUriChangedCallback   ,
#if defined(ENABLE_OVERLOADING)
    TerminalCurrentFileUriChangedSignalInfo ,
#endif
    afterTerminalCurrentFileUriChanged      ,
    onTerminalCurrentFileUriChanged         ,


-- ** cursorMoved #signal:cursorMoved#

    TerminalCursorMovedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalCursorMovedSignalInfo           ,
#endif
    afterTerminalCursorMoved                ,
    onTerminalCursorMoved                   ,


-- ** decreaseFontSize #signal:decreaseFontSize#

    TerminalDecreaseFontSizeCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalDecreaseFontSizeSignalInfo      ,
#endif
    afterTerminalDecreaseFontSize           ,
    onTerminalDecreaseFontSize              ,


-- ** deiconifyWindow #signal:deiconifyWindow#

    TerminalDeiconifyWindowCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalDeiconifyWindowSignalInfo       ,
#endif
    afterTerminalDeiconifyWindow            ,
    onTerminalDeiconifyWindow               ,


-- ** encodingChanged #signal:encodingChanged#

    TerminalEncodingChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalEncodingChangedSignalInfo       ,
#endif
    afterTerminalEncodingChanged            ,
    onTerminalEncodingChanged               ,


-- ** eof #signal:eof#

    TerminalEofCallback                     ,
#if defined(ENABLE_OVERLOADING)
    TerminalEofSignalInfo                   ,
#endif
    afterTerminalEof                        ,
    onTerminalEof                           ,


-- ** hyperlinkHoverUriChanged #signal:hyperlinkHoverUriChanged#

    TerminalHyperlinkHoverUriChangedCallback,
#if defined(ENABLE_OVERLOADING)
    TerminalHyperlinkHoverUriChangedSignalInfo,
#endif
    afterTerminalHyperlinkHoverUriChanged   ,
    onTerminalHyperlinkHoverUriChanged      ,


-- ** iconTitleChanged #signal:iconTitleChanged#

    TerminalIconTitleChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalIconTitleChangedSignalInfo      ,
#endif
    afterTerminalIconTitleChanged           ,
    onTerminalIconTitleChanged              ,


-- ** iconifyWindow #signal:iconifyWindow#

    TerminalIconifyWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalIconifyWindowSignalInfo         ,
#endif
    afterTerminalIconifyWindow              ,
    onTerminalIconifyWindow                 ,


-- ** increaseFontSize #signal:increaseFontSize#

    TerminalIncreaseFontSizeCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalIncreaseFontSizeSignalInfo      ,
#endif
    afterTerminalIncreaseFontSize           ,
    onTerminalIncreaseFontSize              ,


-- ** lowerWindow #signal:lowerWindow#

    TerminalLowerWindowCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalLowerWindowSignalInfo           ,
#endif
    afterTerminalLowerWindow                ,
    onTerminalLowerWindow                   ,


-- ** maximizeWindow #signal:maximizeWindow#

    TerminalMaximizeWindowCallback          ,
#if defined(ENABLE_OVERLOADING)
    TerminalMaximizeWindowSignalInfo        ,
#endif
    afterTerminalMaximizeWindow             ,
    onTerminalMaximizeWindow                ,


-- ** moveWindow #signal:moveWindow#

    TerminalMoveWindowCallback              ,
#if defined(ENABLE_OVERLOADING)
    TerminalMoveWindowSignalInfo            ,
#endif
    afterTerminalMoveWindow                 ,
    onTerminalMoveWindow                    ,


-- ** pasteClipboard #signal:pasteClipboard#

    TerminalPasteClipboardCallback          ,
#if defined(ENABLE_OVERLOADING)
    TerminalPasteClipboardSignalInfo        ,
#endif
    afterTerminalPasteClipboard             ,
    onTerminalPasteClipboard                ,


-- ** raiseWindow #signal:raiseWindow#

    TerminalRaiseWindowCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalRaiseWindowSignalInfo           ,
#endif
    afterTerminalRaiseWindow                ,
    onTerminalRaiseWindow                   ,


-- ** refreshWindow #signal:refreshWindow#

    TerminalRefreshWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalRefreshWindowSignalInfo         ,
#endif
    afterTerminalRefreshWindow              ,
    onTerminalRefreshWindow                 ,


-- ** resizeWindow #signal:resizeWindow#

    TerminalResizeWindowCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalResizeWindowSignalInfo          ,
#endif
    afterTerminalResizeWindow               ,
    onTerminalResizeWindow                  ,


-- ** restoreWindow #signal:restoreWindow#

    TerminalRestoreWindowCallback           ,
#if defined(ENABLE_OVERLOADING)
    TerminalRestoreWindowSignalInfo         ,
#endif
    afterTerminalRestoreWindow              ,
    onTerminalRestoreWindow                 ,


-- ** selectionChanged #signal:selectionChanged#

    TerminalSelectionChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalSelectionChangedSignalInfo      ,
#endif
    afterTerminalSelectionChanged           ,
    onTerminalSelectionChanged              ,


-- ** setupContextMenu #signal:setupContextMenu#

    TerminalSetupContextMenuCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalSetupContextMenuSignalInfo      ,
#endif
    afterTerminalSetupContextMenu           ,
    onTerminalSetupContextMenu              ,


-- ** termpropChanged #signal:termpropChanged#

    TerminalTermpropChangedCallback         ,
#if defined(ENABLE_OVERLOADING)
    TerminalTermpropChangedSignalInfo       ,
#endif
    afterTerminalTermpropChanged            ,
    onTerminalTermpropChanged               ,


-- ** termpropsChanged #signal:termpropsChanged#

    TerminalTermpropsChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TerminalTermpropsChangedSignalInfo      ,
#endif
    afterTerminalTermpropsChanged           ,
    onTerminalTermpropsChanged              ,


-- ** textDeleted #signal:textDeleted#

    TerminalTextDeletedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextDeletedSignalInfo           ,
#endif
    afterTerminalTextDeleted                ,
    onTerminalTextDeleted                   ,


-- ** textInserted #signal:textInserted#

    TerminalTextInsertedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextInsertedSignalInfo          ,
#endif
    afterTerminalTextInserted               ,
    onTerminalTextInserted                  ,


-- ** textModified #signal:textModified#

    TerminalTextModifiedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextModifiedSignalInfo          ,
#endif
    afterTerminalTextModified               ,
    onTerminalTextModified                  ,


-- ** textScrolled #signal:textScrolled#

    TerminalTextScrolledCallback            ,
#if defined(ENABLE_OVERLOADING)
    TerminalTextScrolledSignalInfo          ,
#endif
    afterTerminalTextScrolled               ,
    onTerminalTextScrolled                  ,


-- ** windowTitleChanged #signal:windowTitleChanged#

    TerminalWindowTitleChangedCallback      ,
#if defined(ENABLE_OVERLOADING)
    TerminalWindowTitleChangedSignalInfo    ,
#endif
    afterTerminalWindowTitleChanged         ,
    onTerminalWindowTitleChanged            ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Regex as GLib.Regex
import qualified GI.GLib.Structs.Uri as GLib.Uri
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.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
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.Menu as Gtk.Menu
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.EventContext as Vte.EventContext
import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex
import {-# SOURCE #-} qualified GI.Vte.Structs.Uuid as Vte.Uuid

#else
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Regex as GLib.Regex
import qualified GI.GLib.Structs.Uri as GLib.Uri
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.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
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.Menu as Gtk.Menu
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.EventContext as Vte.EventContext
import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex
import {-# SOURCE #-} qualified GI.Vte.Structs.Uuid as Vte.Uuid

#endif

-- | 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
$c== :: Terminal -> Terminal -> Bool
== :: Terminal -> Terminal -> Bool
$c/= :: Terminal -> Terminal -> Bool
/= :: 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 a. IO a -> m a
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 a. a -> IO a
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 :: DK.Type) :: DK.Type 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 "dupTermpropString" o = TerminalDupTermpropStringMethodInfo
    ResolveTerminalMethod "dupTermpropStringById" o = TerminalDupTermpropStringByIdMethodInfo
    ResolveTerminalMethod "dupTermpropUuid" o = TerminalDupTermpropUuidMethodInfo
    ResolveTerminalMethod "dupTermpropUuidById" o = TerminalDupTermpropUuidByIdMethodInfo
    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 "pasteText" o = TerminalPasteTextMethodInfo
    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 "refTermpropDataBytes" o = TerminalRefTermpropDataBytesMethodInfo
    ResolveTerminalMethod "refTermpropDataBytesById" o = TerminalRefTermpropDataBytesByIdMethodInfo
    ResolveTerminalMethod "refTermpropImagePixbuf" o = TerminalRefTermpropImagePixbufMethodInfo
    ResolveTerminalMethod "refTermpropImagePixbufById" o = TerminalRefTermpropImagePixbufByIdMethodInfo
    ResolveTerminalMethod "refTermpropImageSurface" o = TerminalRefTermpropImageSurfaceMethodInfo
    ResolveTerminalMethod "refTermpropImageSurfaceById" o = TerminalRefTermpropImageSurfaceByIdMethodInfo
    ResolveTerminalMethod "refTermpropUri" o = TerminalRefTermpropUriMethodInfo
    ResolveTerminalMethod "refTermpropUriById" o = TerminalRefTermpropUriByIdMethodInfo
    ResolveTerminalMethod "refTermpropVariant" o = TerminalRefTermpropVariantMethodInfo
    ResolveTerminalMethod "refTermpropVariantById" o = TerminalRefTermpropVariantByIdMethodInfo
    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 "getContextMenu" o = TerminalGetContextMenuMethodInfo
    ResolveTerminalMethod "getContextMenuModel" o = TerminalGetContextMenuModelMethodInfo
    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 "getEnableA11y" o = TerminalGetEnableA11yMethodInfo
    ResolveTerminalMethod "getEnableBidi" o = TerminalGetEnableBidiMethodInfo
    ResolveTerminalMethod "getEnableFallbackScrolling" o = TerminalGetEnableFallbackScrollingMethodInfo
    ResolveTerminalMethod "getEnableLegacyOsc777" o = TerminalGetEnableLegacyOsc777MethodInfo
    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 = TerminalGetFontOptionsMethodInfo
    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 "getScrollOnInsert" o = TerminalGetScrollOnInsertMethodInfo
    ResolveTerminalMethod "getScrollOnKeystroke" o = TerminalGetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "getScrollOnOutput" o = TerminalGetScrollOnOutputMethodInfo
    ResolveTerminalMethod "getScrollUnitIsPixels" o = TerminalGetScrollUnitIsPixelsMethodInfo
    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 "getTermpropBool" o = TerminalGetTermpropBoolMethodInfo
    ResolveTerminalMethod "getTermpropBoolById" o = TerminalGetTermpropBoolByIdMethodInfo
    ResolveTerminalMethod "getTermpropData" o = TerminalGetTermpropDataMethodInfo
    ResolveTerminalMethod "getTermpropDataById" o = TerminalGetTermpropDataByIdMethodInfo
    ResolveTerminalMethod "getTermpropDouble" o = TerminalGetTermpropDoubleMethodInfo
    ResolveTerminalMethod "getTermpropDoubleById" o = TerminalGetTermpropDoubleByIdMethodInfo
    ResolveTerminalMethod "getTermpropInt" o = TerminalGetTermpropIntMethodInfo
    ResolveTerminalMethod "getTermpropIntById" o = TerminalGetTermpropIntByIdMethodInfo
    ResolveTerminalMethod "getTermpropRgba" o = TerminalGetTermpropRgbaMethodInfo
    ResolveTerminalMethod "getTermpropRgbaById" o = TerminalGetTermpropRgbaByIdMethodInfo
    ResolveTerminalMethod "getTermpropString" o = TerminalGetTermpropStringMethodInfo
    ResolveTerminalMethod "getTermpropStringById" o = TerminalGetTermpropStringByIdMethodInfo
    ResolveTerminalMethod "getTermpropUint" o = TerminalGetTermpropUintMethodInfo
    ResolveTerminalMethod "getTermpropUintById" o = TerminalGetTermpropUintByIdMethodInfo
    ResolveTerminalMethod "getTermpropValue" o = TerminalGetTermpropValueMethodInfo
    ResolveTerminalMethod "getTermpropValueById" o = TerminalGetTermpropValueByIdMethodInfo
    ResolveTerminalMethod "getText" o = TerminalGetTextMethodInfo
    ResolveTerminalMethod "getTextBlinkMode" o = TerminalGetTextBlinkModeMethodInfo
    ResolveTerminalMethod "getTextFormat" o = TerminalGetTextFormatMethodInfo
    ResolveTerminalMethod "getTextIncludeTrailingSpaces" o = TerminalGetTextIncludeTrailingSpacesMethodInfo
    ResolveTerminalMethod "getTextRange" o = TerminalGetTextRangeMethodInfo
    ResolveTerminalMethod "getTextRangeFormat" o = TerminalGetTextRangeFormatMethodInfo
    ResolveTerminalMethod "getTextSelected" o = TerminalGetTextSelectedMethodInfo
    ResolveTerminalMethod "getTextSelectedFull" o = TerminalGetTextSelectedFullMethodInfo
    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 "getXalign" o = TerminalGetXalignMethodInfo
    ResolveTerminalMethod "getXfill" o = TerminalGetXfillMethodInfo
    ResolveTerminalMethod "getYalign" o = TerminalGetYalignMethodInfo
    ResolveTerminalMethod "getYfill" o = TerminalGetYfillMethodInfo
    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 "setContextMenu" o = TerminalSetContextMenuMethodInfo
    ResolveTerminalMethod "setContextMenuModel" o = TerminalSetContextMenuModelMethodInfo
    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 "setEnableA11y" o = TerminalSetEnableA11yMethodInfo
    ResolveTerminalMethod "setEnableBidi" o = TerminalSetEnableBidiMethodInfo
    ResolveTerminalMethod "setEnableFallbackScrolling" o = TerminalSetEnableFallbackScrollingMethodInfo
    ResolveTerminalMethod "setEnableLegacyOsc777" o = TerminalSetEnableLegacyOsc777MethodInfo
    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 = TerminalSetFontOptionsMethodInfo
    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 "setScrollOnInsert" o = TerminalSetScrollOnInsertMethodInfo
    ResolveTerminalMethod "setScrollOnKeystroke" o = TerminalSetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "setScrollOnOutput" o = TerminalSetScrollOnOutputMethodInfo
    ResolveTerminalMethod "setScrollUnitIsPixels" o = TerminalSetScrollUnitIsPixelsMethodInfo
    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 "setSuppressLegacySignals" o = TerminalSetSuppressLegacySignalsMethodInfo
    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 "setXalign" o = TerminalSetXalignMethodInfo
    ResolveTerminalMethod "setXfill" o = TerminalSetXfillMethodInfo
    ResolveTerminalMethod "setYalign" o = TerminalSetYalignMethodInfo
    ResolveTerminalMethod "setYfill" o = TerminalSetYfillMethodInfo
    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 ()

type C_TerminalBellCallback =
    Ptr Terminal ->                         -- 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_TerminalBellCallback :: 
    GObject a => (a -> TerminalBellCallback) ->
    C_TerminalBellCallback
wrap_TerminalBellCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalBellCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalBellCallback) -> m SignalHandlerId
onTerminalBell :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalBell a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalBellCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalBellCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalBell :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalBellCallback) -> m SignalHandlerId
afterTerminalBell :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalBell a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalBellCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalBellCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::bell"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:bell"})

#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 ()

type C_TerminalCharSizeChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalCharSizeChangedCallback :: 
    GObject a => (a -> TerminalCharSizeChangedCallback) ->
    C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback :: forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback a -> TerminalCharSizeChangedCallback
gi'cb Ptr Terminal
gi'selfPtr Word32
width Word32
height Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalCharSizeChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  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 -> ((?self :: a) => TerminalCharSizeChangedCallback) -> m SignalHandlerId
onTerminalCharSizeChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalCharSizeChangedCallback)
-> m SignalHandlerId
onTerminalCharSizeChanged a
obj (?self::a) => TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCharSizeChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCharSizeChangedCallback
TerminalCharSizeChangedCallback
cb
    let wrapped' :: C_TerminalCharSizeChangedCallback
wrapped' = (a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback a -> TerminalCharSizeChangedCallback
wrapped
    FunPtr C_TerminalCharSizeChangedCallback
wrapped'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalCharSizeChangedCallback C_TerminalCharSizeChangedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCharSizeChangedCallback) -> m SignalHandlerId
afterTerminalCharSizeChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalCharSizeChangedCallback)
-> m SignalHandlerId
afterTerminalCharSizeChanged a
obj (?self::a) => TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCharSizeChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCharSizeChangedCallback
TerminalCharSizeChangedCallback
cb
    let wrapped' :: C_TerminalCharSizeChangedCallback
wrapped' = (a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback a -> TerminalCharSizeChangedCallback
wrapped
    FunPtr C_TerminalCharSizeChangedCallback
wrapped'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalCharSizeChangedCallback C_TerminalCharSizeChangedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::char-size-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:charSizeChanged"})

#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 ()

type C_TerminalChildExitedCallback =
    Ptr Terminal ->                         -- 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_TerminalChildExitedCallback :: 
    GObject a => (a -> TerminalChildExitedCallback) ->
    C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback :: forall a.
GObject a =>
(a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback a -> TerminalChildExitedCallback
gi'cb Ptr Terminal
gi'selfPtr Int32
status Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalChildExitedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  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 -> ((?self :: a) => TerminalChildExitedCallback) -> m SignalHandlerId
onTerminalChildExited :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalChildExitedCallback) -> m SignalHandlerId
onTerminalChildExited a
obj (?self::a) => TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalChildExitedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalChildExitedCallback
TerminalChildExitedCallback
cb
    let wrapped' :: C_TerminalChildExitedCallback
wrapped' = (a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
forall a.
GObject a =>
(a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback a -> TerminalChildExitedCallback
wrapped
    FunPtr C_TerminalChildExitedCallback
wrapped'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalChildExitedCallback C_TerminalChildExitedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalChildExitedCallback) -> m SignalHandlerId
afterTerminalChildExited :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalChildExitedCallback) -> m SignalHandlerId
afterTerminalChildExited a
obj (?self::a) => TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalChildExitedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalChildExitedCallback
TerminalChildExitedCallback
cb
    let wrapped' :: C_TerminalChildExitedCallback
wrapped' = (a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
forall a.
GObject a =>
(a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback a -> TerminalChildExitedCallback
wrapped
    FunPtr C_TerminalChildExitedCallback
wrapped'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalChildExitedCallback C_TerminalChildExitedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::child-exited"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:childExited"})

#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 ()

type C_TerminalCommitCallback =
    Ptr Terminal ->                         -- 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_TerminalCommitCallback :: 
    GObject a => (a -> TerminalCommitCallback) ->
    C_TerminalCommitCallback
wrap_TerminalCommitCallback :: forall a.
GObject a =>
(a -> TerminalCommitCallback) -> C_TerminalCommitCallback
wrap_TerminalCommitCallback a -> TerminalCommitCallback
gi'cb Ptr Terminal
gi'selfPtr CString
text Word32
size Ptr ()
_ = do
    Text
text' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
text
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalCommitCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  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 -> ((?self :: a) => TerminalCommitCallback) -> m SignalHandlerId
onTerminalCommit :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => TerminalCommitCallback) -> m SignalHandlerId
onTerminalCommit a
obj (?self::a) => TerminalCommitCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCommitCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCommitCallback
TerminalCommitCallback
cb
    let wrapped' :: C_TerminalCommitCallback
wrapped' = (a -> TerminalCommitCallback) -> C_TerminalCommitCallback
forall a.
GObject a =>
(a -> TerminalCommitCallback) -> C_TerminalCommitCallback
wrap_TerminalCommitCallback a -> TerminalCommitCallback
wrapped
    FunPtr C_TerminalCommitCallback
wrapped'' <- C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)
mk_TerminalCommitCallback C_TerminalCommitCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCommit :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCommitCallback) -> m SignalHandlerId
afterTerminalCommit :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => TerminalCommitCallback) -> m SignalHandlerId
afterTerminalCommit a
obj (?self::a) => TerminalCommitCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCommitCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCommitCallback
TerminalCommitCallback
cb
    let wrapped' :: C_TerminalCommitCallback
wrapped' = (a -> TerminalCommitCallback) -> C_TerminalCommitCallback
forall a.
GObject a =>
(a -> TerminalCommitCallback) -> C_TerminalCommitCallback
wrap_TerminalCommitCallback a -> TerminalCommitCallback
wrapped
    FunPtr C_TerminalCommitCallback
wrapped'' <- C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)
mk_TerminalCommitCallback C_TerminalCommitCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::commit"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:commit"})

#endif

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

type C_TerminalContentsChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalContentsChangedCallback :: 
    GObject a => (a -> TerminalContentsChangedCallback) ->
    C_TerminalContentsChangedCallback
wrap_TerminalContentsChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalContentsChangedCallback) -> m SignalHandlerId
onTerminalContentsChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalContentsChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalContentsChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalContentsChangedCallback) -> m SignalHandlerId
afterTerminalContentsChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalContentsChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalContentsChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalContentsChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::contents-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:contentsChanged"})

#endif

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

type C_TerminalCopyClipboardCallback =
    Ptr Terminal ->                         -- 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_TerminalCopyClipboardCallback :: 
    GObject a => (a -> TerminalCopyClipboardCallback) ->
    C_TerminalCopyClipboardCallback
wrap_TerminalCopyClipboardCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalCopyClipboardCallback) -> m SignalHandlerId
onTerminalCopyClipboard :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalCopyClipboard a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCopyClipboardCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCopyClipboardCallback) -> m SignalHandlerId
afterTerminalCopyClipboard :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalCopyClipboard a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCopyClipboardCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCopyClipboardCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::copy-clipboard"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:copyClipboard"})

#endif

-- signal Terminal::current-directory-uri-changed
{-# DEPRECATED TerminalCurrentDirectoryUriChangedCallback ["(Since version 0.78)","Use the t'GI.Vte.Objects.Terminal.Terminal':@/termprop-changed/@ signal","  for the 'GI.Vte.Constants.TERMPROP_CURRENT_DIRECTORY_URI' termprop."] #-}
-- | Emitted when the current directory URI is modified.
type TerminalCurrentDirectoryUriChangedCallback =
    IO ()

type C_TerminalCurrentDirectoryUriChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalCurrentDirectoryUriChangedCallback :: 
    GObject a => (a -> TerminalCurrentDirectoryUriChangedCallback) ->
    C_TerminalCurrentDirectoryUriChangedCallback
wrap_TerminalCurrentDirectoryUriChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalCurrentDirectoryUriChangedCallback) -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentDirectoryUriChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCurrentDirectoryUriChangedCallback) -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentDirectoryUriChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentDirectoryUriChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::current-directory-uri-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:currentDirectoryUriChanged"})

#endif

-- signal Terminal::current-file-uri-changed
{-# DEPRECATED TerminalCurrentFileUriChangedCallback ["(Since version 0.78)","Use the t'GI.Vte.Objects.Terminal.Terminal':@/termprop-changed/@ signal","  for the 'GI.Vte.Constants.TERMPROP_CURRENT_FILE_URI' termprop."] #-}
-- | Emitted when the current file URI is modified.
type TerminalCurrentFileUriChangedCallback =
    IO ()

type C_TerminalCurrentFileUriChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalCurrentFileUriChangedCallback :: 
    GObject a => (a -> TerminalCurrentFileUriChangedCallback) ->
    C_TerminalCurrentFileUriChangedCallback
wrap_TerminalCurrentFileUriChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalCurrentFileUriChangedCallback) -> m SignalHandlerId
onTerminalCurrentFileUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalCurrentFileUriChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentFileUriChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCurrentFileUriChangedCallback) -> m SignalHandlerId
afterTerminalCurrentFileUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalCurrentFileUriChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCurrentFileUriChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCurrentFileUriChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::current-file-uri-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:currentFileUriChanged"})

#endif

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

type C_TerminalCursorMovedCallback =
    Ptr Terminal ->                         -- 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_TerminalCursorMovedCallback :: 
    GObject a => (a -> TerminalCursorMovedCallback) ->
    C_TerminalCursorMovedCallback
wrap_TerminalCursorMovedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalCursorMovedCallback) -> m SignalHandlerId
onTerminalCursorMoved :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalCursorMoved a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCursorMovedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalCursorMovedCallback) -> m SignalHandlerId
afterTerminalCursorMoved :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalCursorMoved a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalCursorMovedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalCursorMovedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::cursor-moved"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:cursorMoved"})

#endif

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

type C_TerminalDecreaseFontSizeCallback =
    Ptr Terminal ->                         -- 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_TerminalDecreaseFontSizeCallback :: 
    GObject a => (a -> TerminalDecreaseFontSizeCallback) ->
    C_TerminalDecreaseFontSizeCallback
wrap_TerminalDecreaseFontSizeCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalDecreaseFontSizeCallback) -> m SignalHandlerId
onTerminalDecreaseFontSize :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalDecreaseFontSize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDecreaseFontSizeCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalDecreaseFontSizeCallback) -> m SignalHandlerId
afterTerminalDecreaseFontSize :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalDecreaseFontSize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDecreaseFontSizeCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDecreaseFontSizeCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::decrease-font-size"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:decreaseFontSize"})

#endif

-- signal Terminal::deiconify-window
{-# DEPRECATED TerminalDeiconifyWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalDeiconifyWindowCallback =
    IO ()

type C_TerminalDeiconifyWindowCallback =
    Ptr Terminal ->                         -- 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_TerminalDeiconifyWindowCallback :: 
    GObject a => (a -> TerminalDeiconifyWindowCallback) ->
    C_TerminalDeiconifyWindowCallback
wrap_TerminalDeiconifyWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalDeiconifyWindowCallback) -> m SignalHandlerId
onTerminalDeiconifyWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalDeiconifyWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDeiconifyWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalDeiconifyWindowCallback) -> m SignalHandlerId
afterTerminalDeiconifyWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalDeiconifyWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalDeiconifyWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalDeiconifyWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::deiconify-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:deiconifyWindow"})

#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 ()

type C_TerminalEncodingChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalEncodingChangedCallback :: 
    GObject a => (a -> TerminalEncodingChangedCallback) ->
    C_TerminalEncodingChangedCallback
wrap_TerminalEncodingChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalEncodingChangedCallback) -> m SignalHandlerId
onTerminalEncodingChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalEncodingChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEncodingChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalEncodingChangedCallback) -> m SignalHandlerId
afterTerminalEncodingChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalEncodingChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEncodingChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEncodingChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::encoding-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:encodingChanged"})

#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 [Terminal::childExited]("GI.Vte.Objects.Terminal#g:signal:childExited") signal.
type TerminalEofCallback =
    IO ()

type C_TerminalEofCallback =
    Ptr Terminal ->                         -- 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_TerminalEofCallback :: 
    GObject a => (a -> TerminalEofCallback) ->
    C_TerminalEofCallback
wrap_TerminalEofCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEofCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalEofCallback) -> m SignalHandlerId
onTerminalEof :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalEof a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEofCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEofCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalEof :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalEofCallback) -> m SignalHandlerId
afterTerminalEof :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalEof a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalEofCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalEofCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::eof"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:eof"})

#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 ()

type C_TerminalHyperlinkHoverUriChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalHyperlinkHoverUriChangedCallback :: 
    GObject a => (a -> TerminalHyperlinkHoverUriChangedCallback) ->
    C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback :: forall a.
GObject a =>
(a -> TerminalHyperlinkHoverUriChangedCallback)
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback a -> TerminalHyperlinkHoverUriChangedCallback
gi'cb Ptr Terminal
gi'selfPtr CString
uri Ptr Rectangle
bbox Ptr ()
_ = do
    Text
uri' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
uri
    Ptr Rectangle -> (Rectangle -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Rectangle
bbox ((Rectangle -> IO ()) -> IO ()) -> (Rectangle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Rectangle
bbox' -> do
        Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalHyperlinkHoverUriChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  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 -> ((?self :: a) => TerminalHyperlinkHoverUriChangedCallback) -> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalHyperlinkHoverUriChangedCallback)
-> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged a
obj (?self::a) => TerminalHyperlinkHoverUriChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalHyperlinkHoverUriChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalHyperlinkHoverUriChangedCallback
TerminalHyperlinkHoverUriChangedCallback
cb
    let wrapped' :: C_TerminalHyperlinkHoverUriChangedCallback
wrapped' = (a -> TerminalHyperlinkHoverUriChangedCallback)
-> C_TerminalHyperlinkHoverUriChangedCallback
forall a.
GObject a =>
(a -> TerminalHyperlinkHoverUriChangedCallback)
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback a -> TerminalHyperlinkHoverUriChangedCallback
wrapped
    FunPtr C_TerminalHyperlinkHoverUriChangedCallback
wrapped'' <- C_TerminalHyperlinkHoverUriChangedCallback
-> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
mk_TerminalHyperlinkHoverUriChangedCallback C_TerminalHyperlinkHoverUriChangedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalHyperlinkHoverUriChangedCallback) -> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalHyperlinkHoverUriChangedCallback)
-> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged a
obj (?self::a) => TerminalHyperlinkHoverUriChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalHyperlinkHoverUriChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalHyperlinkHoverUriChangedCallback
TerminalHyperlinkHoverUriChangedCallback
cb
    let wrapped' :: C_TerminalHyperlinkHoverUriChangedCallback
wrapped' = (a -> TerminalHyperlinkHoverUriChangedCallback)
-> C_TerminalHyperlinkHoverUriChangedCallback
forall a.
GObject a =>
(a -> TerminalHyperlinkHoverUriChangedCallback)
-> C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback a -> TerminalHyperlinkHoverUriChangedCallback
wrapped
    FunPtr C_TerminalHyperlinkHoverUriChangedCallback
wrapped'' <- C_TerminalHyperlinkHoverUriChangedCallback
-> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)
mk_TerminalHyperlinkHoverUriChangedCallback C_TerminalHyperlinkHoverUriChangedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::hyperlink-hover-uri-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:hyperlinkHoverUriChanged"})

#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 ()

type C_TerminalIconTitleChangedCallback =
    Ptr Terminal ->                         -- 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_TerminalIconTitleChangedCallback :: 
    GObject a => (a -> TerminalIconTitleChangedCallback) ->
    C_TerminalIconTitleChangedCallback
wrap_TerminalIconTitleChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalIconTitleChangedCallback) -> m SignalHandlerId
onTerminalIconTitleChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalIconTitleChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconTitleChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalIconTitleChangedCallback) -> m SignalHandlerId
afterTerminalIconTitleChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalIconTitleChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconTitleChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconTitleChangedCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::icon-title-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:iconTitleChanged"})

#endif

-- signal Terminal::iconify-window
{-# DEPRECATED TerminalIconifyWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalIconifyWindowCallback =
    IO ()

type C_TerminalIconifyWindowCallback =
    Ptr Terminal ->                         -- 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_TerminalIconifyWindowCallback :: 
    GObject a => (a -> TerminalIconifyWindowCallback) ->
    C_TerminalIconifyWindowCallback
wrap_TerminalIconifyWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalIconifyWindowCallback) -> m SignalHandlerId
onTerminalIconifyWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalIconifyWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconifyWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalIconifyWindowCallback) -> m SignalHandlerId
afterTerminalIconifyWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalIconifyWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIconifyWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIconifyWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::iconify-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:iconifyWindow"})

#endif

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

type C_TerminalIncreaseFontSizeCallback =
    Ptr Terminal ->                         -- 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_TerminalIncreaseFontSizeCallback :: 
    GObject a => (a -> TerminalIncreaseFontSizeCallback) ->
    C_TerminalIncreaseFontSizeCallback
wrap_TerminalIncreaseFontSizeCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalIncreaseFontSizeCallback) -> m SignalHandlerId
onTerminalIncreaseFontSize :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalIncreaseFontSize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIncreaseFontSizeCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalIncreaseFontSizeCallback) -> m SignalHandlerId
afterTerminalIncreaseFontSize :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalIncreaseFontSize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalIncreaseFontSizeCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalIncreaseFontSizeCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::increase-font-size"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:increaseFontSize"})

#endif

-- signal Terminal::lower-window
{-# DEPRECATED TerminalLowerWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalLowerWindowCallback =
    IO ()

type C_TerminalLowerWindowCallback =
    Ptr Terminal ->                         -- 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_TerminalLowerWindowCallback :: 
    GObject a => (a -> TerminalLowerWindowCallback) ->
    C_TerminalLowerWindowCallback
wrap_TerminalLowerWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalLowerWindowCallback) -> m SignalHandlerId
onTerminalLowerWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalLowerWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalLowerWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalLowerWindowCallback) -> m SignalHandlerId
afterTerminalLowerWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalLowerWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalLowerWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalLowerWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::lower-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:lowerWindow"})

#endif

-- signal Terminal::maximize-window
{-# DEPRECATED TerminalMaximizeWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalMaximizeWindowCallback =
    IO ()

type C_TerminalMaximizeWindowCallback =
    Ptr Terminal ->                         -- 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_TerminalMaximizeWindowCallback :: 
    GObject a => (a -> TerminalMaximizeWindowCallback) ->
    C_TerminalMaximizeWindowCallback
wrap_TerminalMaximizeWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


-- | 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 -> ((?self :: a) => TerminalMaximizeWindowCallback) -> m SignalHandlerId
onTerminalMaximizeWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTerminalMaximizeWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalMaximizeWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalMaximizeWindowCallback) -> m SignalHandlerId
afterTerminalMaximizeWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalMaximizeWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalMaximizeWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalMaximizeWindowCallback C_TerminalBellCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::maximize-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:maximizeWindow"})

#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 ()

type C_TerminalMoveWindowCallback =
    Ptr Terminal ->                         -- 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_TerminalMoveWindowCallback :: 
    GObject a => (a -> TerminalMoveWindowCallback) ->
    C_TerminalMoveWindowCallback
wrap_TerminalMoveWindowCallback :: forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback a -> TerminalCharSizeChangedCallback
gi'cb Ptr Terminal
gi'selfPtr Word32
x Word32
y Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalCharSizeChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  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 -> ((?self :: a) => TerminalMoveWindowCallback) -> m SignalHandlerId
onTerminalMoveWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalCharSizeChangedCallback)
-> m SignalHandlerId
onTerminalMoveWindow a
obj (?self::a) => TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCharSizeChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCharSizeChangedCallback
TerminalCharSizeChangedCallback
cb
    let wrapped' :: C_TerminalCharSizeChangedCallback
wrapped' = (a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback a -> TerminalCharSizeChangedCallback
wrapped
    FunPtr C_TerminalCharSizeChangedCallback
wrapped'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalMoveWindowCallback C_TerminalCharSizeChangedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalMoveWindowCallback) -> m SignalHandlerId
afterTerminalMoveWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalCharSizeChangedCallback)
-> m SignalHandlerId
afterTerminalMoveWindow a
obj (?self::a) => TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCharSizeChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCharSizeChangedCallback
TerminalCharSizeChangedCallback
cb
    let wrapped' :: C_TerminalCharSizeChangedCallback
wrapped' = (a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalMoveWindowCallback a -> TerminalCharSizeChangedCallback
wrapped
    FunPtr C_TerminalCharSizeChangedCallback
wrapped'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalMoveWindowCallback C_TerminalCharSizeChangedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::move-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:moveWindow"})

#endif

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

type C_TerminalPasteClipboardCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalPasteClipboardCallback :: 
    GObject a => (a -> TerminalPasteClipboardCallback) ->
    C_TerminalPasteClipboardCallback
wrap_TerminalPasteClipboardCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [pasteClipboard](#signal:pasteClipboard) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #pasteClipboard callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalPasteClipboardCallback) -> m SignalHandlerId
afterTerminalPasteClipboard :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalPasteClipboard a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalPasteClipboardCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalPasteClipboardCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"paste-clipboard" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalPasteClipboardSignalInfo
instance SignalInfo TerminalPasteClipboardSignalInfo where
    type HaskellCallbackType TerminalPasteClipboardSignalInfo = TerminalPasteClipboardCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalPasteClipboardCallback cb
        cb'' <- mk_TerminalPasteClipboardCallback cb'
        connectSignalFunPtr obj "paste-clipboard" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::paste-clipboard"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:pasteClipboard"})

#endif

-- signal Terminal::raise-window
{-# DEPRECATED TerminalRaiseWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalRaiseWindowCallback =
    IO ()

type C_TerminalRaiseWindowCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalRaiseWindowCallback :: 
    GObject a => (a -> TerminalRaiseWindowCallback) ->
    C_TerminalRaiseWindowCallback
wrap_TerminalRaiseWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [raiseWindow](#signal:raiseWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #raiseWindow callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalRaiseWindowCallback) -> m SignalHandlerId
afterTerminalRaiseWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalRaiseWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRaiseWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRaiseWindowCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"raise-window" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRaiseWindowSignalInfo
instance SignalInfo TerminalRaiseWindowSignalInfo where
    type HaskellCallbackType TerminalRaiseWindowSignalInfo = TerminalRaiseWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRaiseWindowCallback cb
        cb'' <- mk_TerminalRaiseWindowCallback cb'
        connectSignalFunPtr obj "raise-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::raise-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:raiseWindow"})

#endif

-- signal Terminal::refresh-window
{-# DEPRECATED TerminalRefreshWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalRefreshWindowCallback =
    IO ()

type C_TerminalRefreshWindowCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalRefreshWindowCallback :: 
    GObject a => (a -> TerminalRefreshWindowCallback) ->
    C_TerminalRefreshWindowCallback
wrap_TerminalRefreshWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [refreshWindow](#signal:refreshWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #refreshWindow callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalRefreshWindowCallback) -> m SignalHandlerId
afterTerminalRefreshWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalRefreshWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRefreshWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRefreshWindowCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"refresh-window" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRefreshWindowSignalInfo
instance SignalInfo TerminalRefreshWindowSignalInfo where
    type HaskellCallbackType TerminalRefreshWindowSignalInfo = TerminalRefreshWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRefreshWindowCallback cb
        cb'' <- mk_TerminalRefreshWindowCallback cb'
        connectSignalFunPtr obj "refresh-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::refresh-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:refreshWindow"})

#endif

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

type C_TerminalResizeWindowCallback =
    Ptr Terminal ->                         -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalResizeWindowCallback :: 
    GObject a => (a -> TerminalResizeWindowCallback) ->
    C_TerminalResizeWindowCallback
wrap_TerminalResizeWindowCallback :: forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback a -> TerminalCharSizeChangedCallback
gi'cb Ptr Terminal
gi'selfPtr Word32
width Word32
height Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalCharSizeChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  Word32
width Word32
height


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

-- | Connect a signal handler for the [resizeWindow](#signal:resizeWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #resizeWindow callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalResizeWindowCallback) -> m SignalHandlerId
afterTerminalResizeWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalCharSizeChangedCallback)
-> m SignalHandlerId
afterTerminalResizeWindow a
obj (?self::a) => TerminalCharSizeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalCharSizeChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalCharSizeChangedCallback
TerminalCharSizeChangedCallback
cb
    let wrapped' :: C_TerminalCharSizeChangedCallback
wrapped' = (a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
forall a.
GObject a =>
(a -> TerminalCharSizeChangedCallback)
-> C_TerminalCharSizeChangedCallback
wrap_TerminalResizeWindowCallback a -> TerminalCharSizeChangedCallback
wrapped
    FunPtr C_TerminalCharSizeChangedCallback
wrapped'' <- C_TerminalCharSizeChangedCallback
-> IO (FunPtr C_TerminalCharSizeChangedCallback)
mk_TerminalResizeWindowCallback C_TerminalCharSizeChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalCharSizeChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"resize-window" FunPtr C_TerminalCharSizeChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalResizeWindowSignalInfo
instance SignalInfo TerminalResizeWindowSignalInfo where
    type HaskellCallbackType TerminalResizeWindowSignalInfo = TerminalResizeWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalResizeWindowCallback cb
        cb'' <- mk_TerminalResizeWindowCallback cb'
        connectSignalFunPtr obj "resize-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::resize-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:resizeWindow"})

#endif

-- signal Terminal::restore-window
{-# DEPRECATED TerminalRestoreWindowCallback ["(Since version 0.60)"] #-}
-- | Never emitted.
type TerminalRestoreWindowCallback =
    IO ()

type C_TerminalRestoreWindowCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalRestoreWindowCallback :: 
    GObject a => (a -> TerminalRestoreWindowCallback) ->
    C_TerminalRestoreWindowCallback
wrap_TerminalRestoreWindowCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [restoreWindow](#signal:restoreWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #restoreWindow callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalRestoreWindowCallback) -> m SignalHandlerId
afterTerminalRestoreWindow :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalRestoreWindow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalRestoreWindowCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalRestoreWindowCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"restore-window" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalRestoreWindowSignalInfo
instance SignalInfo TerminalRestoreWindowSignalInfo where
    type HaskellCallbackType TerminalRestoreWindowSignalInfo = TerminalRestoreWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalRestoreWindowCallback cb
        cb'' <- mk_TerminalRestoreWindowCallback cb'
        connectSignalFunPtr obj "restore-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::restore-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:restoreWindow"})

#endif

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

type C_TerminalSelectionChangedCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalSelectionChangedCallback :: 
    GObject a => (a -> TerminalSelectionChangedCallback) ->
    C_TerminalSelectionChangedCallback
wrap_TerminalSelectionChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [selectionChanged](#signal:selectionChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #selectionChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalSelectionChangedCallback) -> m SignalHandlerId
afterTerminalSelectionChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalSelectionChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalSelectionChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalSelectionChangedCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"selection-changed" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalSelectionChangedSignalInfo
instance SignalInfo TerminalSelectionChangedSignalInfo where
    type HaskellCallbackType TerminalSelectionChangedSignalInfo = TerminalSelectionChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalSelectionChangedCallback cb
        cb'' <- mk_TerminalSelectionChangedCallback cb'
        connectSignalFunPtr obj "selection-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::selection-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:selectionChanged"})

#endif

-- signal Terminal::setup-context-menu
-- | Emitted with non-'P.Nothing' context before /@terminal@/ shows a context menu.
-- The handler may set either a menu model using
-- 'GI.Vte.Objects.Terminal.terminalSetContextMenuModel', or a menu using
-- 'GI.Vte.Objects.Terminal.terminalSetContextMenu', which will then be used as context
-- menu.
-- If neither a menu model nor a menu are set, a context menu
-- will not be shown.
-- 
-- Note that /@context@/ is only valid during the signal emission; you may
-- not retain it to call methods on it afterwards.
-- 
-- Also emitted with 'P.Nothing' context after the context menu has been dismissed.
type TerminalSetupContextMenuCallback =
    Maybe Vte.EventContext.EventContext
    -- ^ /@context@/: the context
    -> IO ()

type C_TerminalSetupContextMenuCallback =
    Ptr Terminal ->                         -- object
    Ptr Vte.EventContext.EventContext ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalSetupContextMenuCallback :: 
    GObject a => (a -> TerminalSetupContextMenuCallback) ->
    C_TerminalSetupContextMenuCallback
wrap_TerminalSetupContextMenuCallback :: forall a.
GObject a =>
(a -> TerminalSetupContextMenuCallback)
-> C_TerminalSetupContextMenuCallback
wrap_TerminalSetupContextMenuCallback a -> TerminalSetupContextMenuCallback
gi'cb Ptr Terminal
gi'selfPtr Ptr EventContext
context Ptr ()
_ = do
    Maybe EventContext
maybeContext <-
        if Ptr EventContext
context Ptr EventContext -> Ptr EventContext -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr EventContext
forall a. Ptr a
FP.nullPtr
        then Maybe EventContext -> IO (Maybe EventContext)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe EventContext
forall a. Maybe a
Nothing
        else do
            EventContext
context' <- ((ManagedPtr EventContext -> EventContext)
-> Ptr EventContext -> IO EventContext
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr EventContext -> EventContext
Vte.EventContext.EventContext) Ptr EventContext
context
            Maybe EventContext -> IO (Maybe EventContext)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EventContext -> IO (Maybe EventContext))
-> Maybe EventContext -> IO (Maybe EventContext)
forall a b. (a -> b) -> a -> b
$ EventContext -> Maybe EventContext
forall a. a -> Maybe a
Just EventContext
context'
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalSetupContextMenuCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  Maybe EventContext
maybeContext


-- | Connect a signal handler for the [setupContextMenu](#signal:setupContextMenu) 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 #setupContextMenu callback
-- @
-- 
-- 
onTerminalSetupContextMenu :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalSetupContextMenuCallback) -> m SignalHandlerId
onTerminalSetupContextMenu :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalSetupContextMenuCallback)
-> m SignalHandlerId
onTerminalSetupContextMenu a
obj (?self::a) => TerminalSetupContextMenuCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalSetupContextMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalSetupContextMenuCallback
TerminalSetupContextMenuCallback
cb
    let wrapped' :: C_TerminalSetupContextMenuCallback
wrapped' = (a -> TerminalSetupContextMenuCallback)
-> C_TerminalSetupContextMenuCallback
forall a.
GObject a =>
(a -> TerminalSetupContextMenuCallback)
-> C_TerminalSetupContextMenuCallback
wrap_TerminalSetupContextMenuCallback a -> TerminalSetupContextMenuCallback
wrapped
    FunPtr C_TerminalSetupContextMenuCallback
wrapped'' <- C_TerminalSetupContextMenuCallback
-> IO (FunPtr C_TerminalSetupContextMenuCallback)
mk_TerminalSetupContextMenuCallback C_TerminalSetupContextMenuCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalSetupContextMenuCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup-context-menu" FunPtr C_TerminalSetupContextMenuCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setupContextMenu](#signal:setupContextMenu) 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 #setupContextMenu callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalSetupContextMenu :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalSetupContextMenuCallback) -> m SignalHandlerId
afterTerminalSetupContextMenu :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalSetupContextMenuCallback)
-> m SignalHandlerId
afterTerminalSetupContextMenu a
obj (?self::a) => TerminalSetupContextMenuCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalSetupContextMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalSetupContextMenuCallback
TerminalSetupContextMenuCallback
cb
    let wrapped' :: C_TerminalSetupContextMenuCallback
wrapped' = (a -> TerminalSetupContextMenuCallback)
-> C_TerminalSetupContextMenuCallback
forall a.
GObject a =>
(a -> TerminalSetupContextMenuCallback)
-> C_TerminalSetupContextMenuCallback
wrap_TerminalSetupContextMenuCallback a -> TerminalSetupContextMenuCallback
wrapped
    FunPtr C_TerminalSetupContextMenuCallback
wrapped'' <- C_TerminalSetupContextMenuCallback
-> IO (FunPtr C_TerminalSetupContextMenuCallback)
mk_TerminalSetupContextMenuCallback C_TerminalSetupContextMenuCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalSetupContextMenuCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup-context-menu" FunPtr C_TerminalSetupContextMenuCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalSetupContextMenuSignalInfo
instance SignalInfo TerminalSetupContextMenuSignalInfo where
    type HaskellCallbackType TerminalSetupContextMenuSignalInfo = TerminalSetupContextMenuCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalSetupContextMenuCallback cb
        cb'' <- mk_TerminalSetupContextMenuCallback cb'
        connectSignalFunPtr obj "setup-context-menu" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::setup-context-menu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:setupContextMenu"})

#endif

-- signal Terminal::termprop-changed
-- | The \"termprop-changed\" signal is emitted when a termprop
-- has changed or been reset.
-- 
-- The handler may use the vte_terminal_get_termprop_*()
-- functions (and their by-ID variants), to retrieve the value of
-- any termprop (not just /@name@/), as well as call
-- @/vte_terminal_reset_termprop()/@ (and its by-ID variant) to
-- reset any termprop (not just /@name@/); but it must *not* call *any*
-- other API on /@terminal@/, including API of its parent classes.
-- 
-- This signal supports detailed connections, so e.g. subscribing
-- to \"termprop-changed[name](#g:signal:name)\" only runs the callback when the
-- termprop \"name\" has changed.
-- 
-- /Since: 0.78/
type TerminalTermpropChangedCallback =
    T.Text
    -- ^ /@name@/: the name of the changed property
    -> IO ()

type C_TerminalTermpropChangedCallback =
    Ptr Terminal ->                         -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalTermpropChangedCallback :: 
    GObject a => (a -> TerminalTermpropChangedCallback) ->
    C_TerminalTermpropChangedCallback
wrap_TerminalTermpropChangedCallback :: forall a.
GObject a =>
(a -> TerminalTermpropChangedCallback)
-> C_TerminalTermpropChangedCallback
wrap_TerminalTermpropChangedCallback a -> TerminalTermpropChangedCallback
gi'cb Ptr Terminal
gi'selfPtr CString
name Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalTermpropChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  Text
name'


-- | Connect a signal handler for the [termpropChanged](#signal:termpropChanged) 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 #termpropChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@termprop-changed::detail@” instead.
-- 
onTerminalTermpropChanged :: (IsTerminal a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TerminalTermpropChangedCallback) -> m SignalHandlerId
onTerminalTermpropChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TerminalTermpropChangedCallback)
-> m SignalHandlerId
onTerminalTermpropChanged a
obj Maybe Text
detail (?self::a) => TerminalTermpropChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalTermpropChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalTermpropChangedCallback
TerminalTermpropChangedCallback
cb
    let wrapped' :: C_TerminalTermpropChangedCallback
wrapped' = (a -> TerminalTermpropChangedCallback)
-> C_TerminalTermpropChangedCallback
forall a.
GObject a =>
(a -> TerminalTermpropChangedCallback)
-> C_TerminalTermpropChangedCallback
wrap_TerminalTermpropChangedCallback a -> TerminalTermpropChangedCallback
wrapped
    FunPtr C_TerminalTermpropChangedCallback
wrapped'' <- C_TerminalTermpropChangedCallback
-> IO (FunPtr C_TerminalTermpropChangedCallback)
mk_TerminalTermpropChangedCallback C_TerminalTermpropChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalTermpropChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"termprop-changed" FunPtr C_TerminalTermpropChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [termpropChanged](#signal:termpropChanged) 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 #termpropChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@termprop-changed::detail@” instead.
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTermpropChanged :: (IsTerminal a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TerminalTermpropChangedCallback) -> m SignalHandlerId
afterTerminalTermpropChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TerminalTermpropChangedCallback)
-> m SignalHandlerId
afterTerminalTermpropChanged a
obj Maybe Text
detail (?self::a) => TerminalTermpropChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalTermpropChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalTermpropChangedCallback
TerminalTermpropChangedCallback
cb
    let wrapped' :: C_TerminalTermpropChangedCallback
wrapped' = (a -> TerminalTermpropChangedCallback)
-> C_TerminalTermpropChangedCallback
forall a.
GObject a =>
(a -> TerminalTermpropChangedCallback)
-> C_TerminalTermpropChangedCallback
wrap_TerminalTermpropChangedCallback a -> TerminalTermpropChangedCallback
wrapped
    FunPtr C_TerminalTermpropChangedCallback
wrapped'' <- C_TerminalTermpropChangedCallback
-> IO (FunPtr C_TerminalTermpropChangedCallback)
mk_TerminalTermpropChangedCallback C_TerminalTermpropChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalTermpropChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"termprop-changed" FunPtr C_TerminalTermpropChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data TerminalTermpropChangedSignalInfo
instance SignalInfo TerminalTermpropChangedSignalInfo where
    type HaskellCallbackType TerminalTermpropChangedSignalInfo = TerminalTermpropChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTermpropChangedCallback cb
        cb'' <- mk_TerminalTermpropChangedCallback cb'
        connectSignalFunPtr obj "termprop-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::termprop-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:termpropChanged"})

#endif

-- signal Terminal::termprops-changed
-- | Emitted when termprops have changed. /@props@/ is an array containing
-- the IDs of the terminal properties that may have changed since
-- the last emission of this signal, in an undefined order.
-- Note that emission of this signal is delayed from the receipt of the
-- OSC sequences, and a termprop may have been changed more than once
-- inbetween signal emissions, but only the value set last is retrievable.
-- 
-- The default handler for this signal emits the \"termprop-changed\"
-- signal for each changed property. Returning 'P.True' from a handler
-- running before the default will prevent this.
-- 
-- The handler may use the vte_terminal_get_termprop_*()
-- functions (and their by-ID variants), to retrieve the value of
-- any termprop, as well as call @/vte_terminal_reset_termprop()/@
-- (and its by-ID variant) to reset any termprop, or emit the
-- VteTerminal[termpropChanged](#g:signal:termpropChanged) signal; but it must *not*
-- call *any* other API on /@terminal@/, including API of its parent classes.
-- 
-- /Since: 0.78/
type TerminalTermpropsChangedCallback =
    [Int32]
    -- ^ /@props@/: an array of termprop IDs
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to stop further handlers being invoked for this signal,
    --   or 'P.False' to continue signal emission

type C_TerminalTermpropsChangedCallback =
    Ptr Terminal ->                         -- object
    Ptr Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TerminalTermpropsChangedCallback :: 
    GObject a => (a -> TerminalTermpropsChangedCallback) ->
    C_TerminalTermpropsChangedCallback
wrap_TerminalTermpropsChangedCallback :: forall a.
GObject a =>
(a -> TerminalTermpropsChangedCallback)
-> C_TerminalTermpropsChangedCallback
wrap_TerminalTermpropsChangedCallback a -> TerminalTermpropsChangedCallback
gi'cb Ptr Terminal
gi'selfPtr Ptr Int32
props Int32
nProps Ptr ()
_ = do
    [Int32]
props' <- (Int32 -> Ptr Int32 -> IO [Int32]
forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackStorableArrayWithLength Int32
nProps) Ptr Int32
props
    Bool
result <- Ptr Terminal -> (Terminal -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO Bool) -> IO Bool)
-> (Terminal -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalTermpropsChangedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  [Int32]
props'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [termpropsChanged](#signal:termpropsChanged) 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 #termpropsChanged callback
-- @
-- 
-- 
onTerminalTermpropsChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTermpropsChangedCallback) -> m SignalHandlerId
onTerminalTermpropsChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalTermpropsChangedCallback)
-> m SignalHandlerId
onTerminalTermpropsChanged a
obj (?self::a) => TerminalTermpropsChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalTermpropsChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalTermpropsChangedCallback
TerminalTermpropsChangedCallback
cb
    let wrapped' :: C_TerminalTermpropsChangedCallback
wrapped' = (a -> TerminalTermpropsChangedCallback)
-> C_TerminalTermpropsChangedCallback
forall a.
GObject a =>
(a -> TerminalTermpropsChangedCallback)
-> C_TerminalTermpropsChangedCallback
wrap_TerminalTermpropsChangedCallback a -> TerminalTermpropsChangedCallback
wrapped
    FunPtr C_TerminalTermpropsChangedCallback
wrapped'' <- C_TerminalTermpropsChangedCallback
-> IO (FunPtr C_TerminalTermpropsChangedCallback)
mk_TerminalTermpropsChangedCallback C_TerminalTermpropsChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalTermpropsChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"termprops-changed" FunPtr C_TerminalTermpropsChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [termpropsChanged](#signal:termpropsChanged) 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 #termpropsChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTermpropsChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTermpropsChangedCallback) -> m SignalHandlerId
afterTerminalTermpropsChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalTermpropsChangedCallback)
-> m SignalHandlerId
afterTerminalTermpropsChanged a
obj (?self::a) => TerminalTermpropsChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalTermpropsChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalTermpropsChangedCallback
TerminalTermpropsChangedCallback
cb
    let wrapped' :: C_TerminalTermpropsChangedCallback
wrapped' = (a -> TerminalTermpropsChangedCallback)
-> C_TerminalTermpropsChangedCallback
forall a.
GObject a =>
(a -> TerminalTermpropsChangedCallback)
-> C_TerminalTermpropsChangedCallback
wrap_TerminalTermpropsChangedCallback a -> TerminalTermpropsChangedCallback
wrapped
    FunPtr C_TerminalTermpropsChangedCallback
wrapped'' <- C_TerminalTermpropsChangedCallback
-> IO (FunPtr C_TerminalTermpropsChangedCallback)
mk_TerminalTermpropsChangedCallback C_TerminalTermpropsChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalTermpropsChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"termprops-changed" FunPtr C_TerminalTermpropsChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTermpropsChangedSignalInfo
instance SignalInfo TerminalTermpropsChangedSignalInfo where
    type HaskellCallbackType TerminalTermpropsChangedSignalInfo = TerminalTermpropsChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTermpropsChangedCallback cb
        cb'' <- mk_TerminalTermpropsChangedCallback cb'
        connectSignalFunPtr obj "termprops-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::termprops-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:termpropsChanged"})

#endif

-- signal Terminal::text-deleted
{-# DEPRECATED TerminalTextDeletedCallback ["(Since version 0.66)","This signal is never emitted."] #-}
-- | /No description available in the introspection data./
type TerminalTextDeletedCallback =
    IO ()

type C_TerminalTextDeletedCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalTextDeletedCallback :: 
    GObject a => (a -> TerminalTextDeletedCallback) ->
    C_TerminalTextDeletedCallback
wrap_TerminalTextDeletedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [textDeleted](#signal:textDeleted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textDeleted callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTextDeletedCallback) -> m SignalHandlerId
afterTerminalTextDeleted :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalTextDeleted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextDeletedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextDeletedCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-deleted" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextDeletedSignalInfo
instance SignalInfo TerminalTextDeletedSignalInfo where
    type HaskellCallbackType TerminalTextDeletedSignalInfo = TerminalTextDeletedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextDeletedCallback cb
        cb'' <- mk_TerminalTextDeletedCallback cb'
        connectSignalFunPtr obj "text-deleted" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::text-deleted"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:textDeleted"})

#endif

-- signal Terminal::text-inserted
{-# DEPRECATED TerminalTextInsertedCallback ["(Since version 0.66)","This signal is never emitted."] #-}
-- | /No description available in the introspection data./
type TerminalTextInsertedCallback =
    IO ()

type C_TerminalTextInsertedCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalTextInsertedCallback :: 
    GObject a => (a -> TerminalTextInsertedCallback) ->
    C_TerminalTextInsertedCallback
wrap_TerminalTextInsertedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [textInserted](#signal:textInserted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textInserted callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTextInsertedCallback) -> m SignalHandlerId
afterTerminalTextInserted :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalTextInserted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextInsertedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextInsertedCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-inserted" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextInsertedSignalInfo
instance SignalInfo TerminalTextInsertedSignalInfo where
    type HaskellCallbackType TerminalTextInsertedSignalInfo = TerminalTextInsertedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextInsertedCallback cb
        cb'' <- mk_TerminalTextInsertedCallback cb'
        connectSignalFunPtr obj "text-inserted" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::text-inserted"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:textInserted"})

#endif

-- signal Terminal::text-modified
{-# DEPRECATED TerminalTextModifiedCallback ["(Since version 0.66)","This signal is never emitted."] #-}
-- | /No description available in the introspection data./
type TerminalTextModifiedCallback =
    IO ()

type C_TerminalTextModifiedCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalTextModifiedCallback :: 
    GObject a => (a -> TerminalTextModifiedCallback) ->
    C_TerminalTextModifiedCallback
wrap_TerminalTextModifiedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [textModified](#signal:textModified) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textModified callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTextModifiedCallback) -> m SignalHandlerId
afterTerminalTextModified :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalTextModified a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalTextModifiedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalTextModifiedCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-modified" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextModifiedSignalInfo
instance SignalInfo TerminalTextModifiedSignalInfo where
    type HaskellCallbackType TerminalTextModifiedSignalInfo = TerminalTextModifiedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextModifiedCallback cb
        cb'' <- mk_TerminalTextModifiedCallback cb'
        connectSignalFunPtr obj "text-modified" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::text-modified"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:textModified"})

#endif

-- signal Terminal::text-scrolled
{-# DEPRECATED TerminalTextScrolledCallback ["(Since version 0.66)","This signal is never emitted."] #-}
-- | /No description available in the introspection data./
type TerminalTextScrolledCallback =
    Int32
    -> IO ()

type C_TerminalTextScrolledCallback =
    Ptr Terminal ->                         -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalTextScrolledCallback :: 
    GObject a => (a -> TerminalTextScrolledCallback) ->
    C_TerminalTextScrolledCallback
wrap_TerminalTextScrolledCallback :: forall a.
GObject a =>
(a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback a -> TerminalChildExitedCallback
gi'cb Ptr Terminal
gi'selfPtr Int32
delta Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> TerminalChildExitedCallback
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self)  Int32
delta


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

-- | Connect a signal handler for the [textScrolled](#signal:textScrolled) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #textScrolled callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalTextScrolledCallback) -> m SignalHandlerId
afterTerminalTextScrolled :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a
-> ((?self::a) => TerminalChildExitedCallback) -> m SignalHandlerId
afterTerminalTextScrolled a
obj (?self::a) => TerminalChildExitedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> TerminalChildExitedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TerminalChildExitedCallback
TerminalChildExitedCallback
cb
    let wrapped' :: C_TerminalChildExitedCallback
wrapped' = (a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
forall a.
GObject a =>
(a -> TerminalChildExitedCallback) -> C_TerminalChildExitedCallback
wrap_TerminalTextScrolledCallback a -> TerminalChildExitedCallback
wrapped
    FunPtr C_TerminalChildExitedCallback
wrapped'' <- C_TerminalChildExitedCallback
-> IO (FunPtr C_TerminalChildExitedCallback)
mk_TerminalTextScrolledCallback C_TerminalChildExitedCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalChildExitedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-scrolled" FunPtr C_TerminalChildExitedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalTextScrolledSignalInfo
instance SignalInfo TerminalTextScrolledSignalInfo where
    type HaskellCallbackType TerminalTextScrolledSignalInfo = TerminalTextScrolledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalTextScrolledCallback cb
        cb'' <- mk_TerminalTextScrolledCallback cb'
        connectSignalFunPtr obj "text-scrolled" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::text-scrolled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:textScrolled"})

#endif

-- signal Terminal::window-title-changed
{-# DEPRECATED TerminalWindowTitleChangedCallback ["(Since version 0.78)","Use the t'GI.Vte.Objects.Terminal.Terminal':@/termprop-changed/@ signal","  for the 'GI.Vte.Constants.TERMPROP_XTERM_TITLE' termprop."] #-}
-- | Emitted when the [Terminal:windowTitle]("GI.Vte.Objects.Terminal#g:attr:windowTitle") property is modified.
type TerminalWindowTitleChangedCallback =
    IO ()

type C_TerminalWindowTitleChangedCallback =
    Ptr Terminal ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TerminalWindowTitleChangedCallback :: 
    GObject a => (a -> TerminalWindowTitleChangedCallback) ->
    C_TerminalWindowTitleChangedCallback
wrap_TerminalWindowTitleChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback a -> IO ()
gi'cb Ptr Terminal
gi'selfPtr Ptr ()
_ = do
    Ptr Terminal -> (Terminal -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Terminal
gi'selfPtr ((Terminal -> IO ()) -> IO ()) -> (Terminal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Terminal
gi'self -> a -> IO ()
gi'cb (Terminal -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Terminal
gi'self) 


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

-- | Connect a signal handler for the [windowTitleChanged](#signal:windowTitleChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' terminal #windowTitleChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> ((?self :: a) => TerminalWindowTitleChangedCallback) -> m SignalHandlerId
afterTerminalWindowTitleChanged :: forall a (m :: * -> *).
(IsTerminal a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTerminalWindowTitleChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TerminalBellCallback
wrapped' = (a -> IO ()) -> C_TerminalBellCallback
forall a. GObject a => (a -> IO ()) -> C_TerminalBellCallback
wrap_TerminalWindowTitleChangedCallback a -> IO ()
wrapped
    FunPtr C_TerminalBellCallback
wrapped'' <- C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)
mk_TerminalWindowTitleChangedCallback C_TerminalBellCallback
wrapped'
    a
-> Text
-> FunPtr C_TerminalBellCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"window-title-changed" FunPtr C_TerminalBellCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TerminalWindowTitleChangedSignalInfo
instance SignalInfo TerminalWindowTitleChangedSignalInfo where
    type HaskellCallbackType TerminalWindowTitleChangedSignalInfo = TerminalWindowTitleChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TerminalWindowTitleChangedCallback cb
        cb'' <- mk_TerminalWindowTitleChangedCallback cb'
        connectSignalFunPtr obj "window-title-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal::window-title-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:signal:windowTitleChanged"})

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalAllowBoldPropertyInfo
instance AttrInfo TerminalAllowBoldPropertyInfo where
    type AttrAllowedOps TerminalAllowBoldPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAllowBoldPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool
    type AttrTransferType TerminalAllowBoldPropertyInfo = Bool
    type AttrGetType TerminalAllowBoldPropertyInfo = Bool
    type AttrLabel TerminalAllowBoldPropertyInfo = "allow-bold"
    type AttrOrigin TerminalAllowBoldPropertyInfo = Terminal
    attrGet = getTerminalAllowBold
    attrSet = setTerminalAllowBold
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAllowBold
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.allowBold"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:allowBold"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalAllowHyperlinkPropertyInfo
instance AttrInfo TerminalAllowHyperlinkPropertyInfo where
    type AttrAllowedOps TerminalAllowHyperlinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAllowHyperlinkPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool
    type AttrTransferType TerminalAllowHyperlinkPropertyInfo = Bool
    type AttrGetType TerminalAllowHyperlinkPropertyInfo = Bool
    type AttrLabel TerminalAllowHyperlinkPropertyInfo = "allow-hyperlink"
    type AttrOrigin TerminalAllowHyperlinkPropertyInfo = Terminal
    attrGet = getTerminalAllowHyperlink
    attrSet = setTerminalAllowHyperlink
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAllowHyperlink
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.allowHyperlink"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:allowHyperlink"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalAudibleBellPropertyInfo
instance AttrInfo TerminalAudibleBellPropertyInfo where
    type AttrAllowedOps TerminalAudibleBellPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalAudibleBellPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool
    type AttrTransferType TerminalAudibleBellPropertyInfo = Bool
    type AttrGetType TerminalAudibleBellPropertyInfo = Bool
    type AttrLabel TerminalAudibleBellPropertyInfo = "audible-bell"
    type AttrOrigin TerminalAudibleBellPropertyInfo = Terminal
    attrGet = getTerminalAudibleBell
    attrSet = setTerminalAudibleBell
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalAudibleBell
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.audibleBell"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:audibleBell"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalBackspaceBindingPropertyInfo
instance AttrInfo TerminalBackspaceBindingPropertyInfo where
    type AttrAllowedOps TerminalBackspaceBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalBackspaceBindingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrGetType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalBackspaceBindingPropertyInfo = "backspace-binding"
    type AttrOrigin TerminalBackspaceBindingPropertyInfo = Terminal
    attrGet = getTerminalBackspaceBinding
    attrSet = setTerminalBackspaceBinding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalBackspaceBinding
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.backspaceBinding"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:backspaceBinding"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalBoldIsBrightPropertyInfo
instance AttrInfo TerminalBoldIsBrightPropertyInfo where
    type AttrAllowedOps TerminalBoldIsBrightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalBoldIsBrightPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool
    type AttrTransferType TerminalBoldIsBrightPropertyInfo = Bool
    type AttrGetType TerminalBoldIsBrightPropertyInfo = Bool
    type AttrLabel TerminalBoldIsBrightPropertyInfo = "bold-is-bright"
    type AttrOrigin TerminalBoldIsBrightPropertyInfo = Terminal
    attrGet = getTerminalBoldIsBright
    attrSet = setTerminalBoldIsBright
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalBoldIsBright
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.boldIsBright"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:boldIsBright"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCellHeightScalePropertyInfo
instance AttrInfo TerminalCellHeightScalePropertyInfo where
    type AttrAllowedOps TerminalCellHeightScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCellHeightScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double
    type AttrTransferType TerminalCellHeightScalePropertyInfo = Double
    type AttrGetType TerminalCellHeightScalePropertyInfo = Double
    type AttrLabel TerminalCellHeightScalePropertyInfo = "cell-height-scale"
    type AttrOrigin TerminalCellHeightScalePropertyInfo = Terminal
    attrGet = getTerminalCellHeightScale
    attrSet = setTerminalCellHeightScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCellHeightScale
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.cellHeightScale"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:cellHeightScale"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCellWidthScalePropertyInfo
instance AttrInfo TerminalCellWidthScalePropertyInfo where
    type AttrAllowedOps TerminalCellWidthScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCellWidthScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double
    type AttrTransferType TerminalCellWidthScalePropertyInfo = Double
    type AttrGetType TerminalCellWidthScalePropertyInfo = Double
    type AttrLabel TerminalCellWidthScalePropertyInfo = "cell-width-scale"
    type AttrOrigin TerminalCellWidthScalePropertyInfo = Terminal
    attrGet = getTerminalCellWidthScale
    attrSet = setTerminalCellWidthScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCellWidthScale
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.cellWidthScale"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:cellWidthScale"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCjkAmbiguousWidthPropertyInfo
instance AttrInfo TerminalCjkAmbiguousWidthPropertyInfo where
    type AttrAllowedOps TerminalCjkAmbiguousWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32
    type AttrTransferType TerminalCjkAmbiguousWidthPropertyInfo = Int32
    type AttrGetType TerminalCjkAmbiguousWidthPropertyInfo = Int32
    type AttrLabel TerminalCjkAmbiguousWidthPropertyInfo = "cjk-ambiguous-width"
    type AttrOrigin TerminalCjkAmbiguousWidthPropertyInfo = Terminal
    attrGet = getTerminalCjkAmbiguousWidth
    attrSet = setTerminalCjkAmbiguousWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCjkAmbiguousWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.cjkAmbiguousWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:cjkAmbiguousWidth"
        })
#endif

-- VVV Prop "context-menu"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Menu"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

-- | Construct a `GValueConstruct` with valid value for the “@context-menu@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalContextMenu :: (IsTerminal o, MIO.MonadIO m, Gtk.Menu.IsMenu a) => a -> m (GValueConstruct o)
constructTerminalContextMenu :: forall o (m :: * -> *) a.
(IsTerminal o, MonadIO m, IsMenu a) =>
a -> m (GValueConstruct o)
constructTerminalContextMenu a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"context-menu" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data TerminalContextMenuPropertyInfo
instance AttrInfo TerminalContextMenuPropertyInfo where
    type AttrAllowedOps TerminalContextMenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalContextMenuPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalContextMenuPropertyInfo = Gtk.Menu.IsMenu
    type AttrTransferTypeConstraint TerminalContextMenuPropertyInfo = Gtk.Menu.IsMenu
    type AttrTransferType TerminalContextMenuPropertyInfo = Gtk.Menu.Menu
    type AttrGetType TerminalContextMenuPropertyInfo = (Maybe Gtk.Menu.Menu)
    type AttrLabel TerminalContextMenuPropertyInfo = "context-menu"
    type AttrOrigin TerminalContextMenuPropertyInfo = Terminal
    attrGet = getTerminalContextMenu
    attrSet = setTerminalContextMenu
    attrTransfer _ v = do
        unsafeCastTo Gtk.Menu.Menu v
    attrConstruct = constructTerminalContextMenu
    attrClear = clearTerminalContextMenu
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.contextMenu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:contextMenu"
        })
#endif

-- VVV Prop "context-menu-model"
   -- Type: TInterface (Name {namespace = "Gio", name = "MenuModel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

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

-- | Construct a `GValueConstruct` with valid value for the “@context-menu-model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalContextMenuModel :: (IsTerminal o, MIO.MonadIO m, Gio.MenuModel.IsMenuModel a) => a -> m (GValueConstruct o)
constructTerminalContextMenuModel :: forall o (m :: * -> *) a.
(IsTerminal o, MonadIO m, IsMenuModel a) =>
a -> m (GValueConstruct o)
constructTerminalContextMenuModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"context-menu-model" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data TerminalContextMenuModelPropertyInfo
instance AttrInfo TerminalContextMenuModelPropertyInfo where
    type AttrAllowedOps TerminalContextMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalContextMenuModelPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalContextMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint TerminalContextMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType TerminalContextMenuModelPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType TerminalContextMenuModelPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel TerminalContextMenuModelPropertyInfo = "context-menu-model"
    type AttrOrigin TerminalContextMenuModelPropertyInfo = Terminal
    attrGet = getTerminalContextMenuModel
    attrSet = setTerminalContextMenuModel
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructTerminalContextMenuModel
    attrClear = clearTerminalContextMenuModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.contextMenuModel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:contextMenuModel"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentDirectoryUriPropertyInfo
instance AttrInfo TerminalCurrentDirectoryUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentDirectoryUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentDirectoryUriPropertyInfo = ()
    type AttrGetType TerminalCurrentDirectoryUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentDirectoryUriPropertyInfo = "current-directory-uri"
    type AttrOrigin TerminalCurrentDirectoryUriPropertyInfo = Terminal
    attrGet = getTerminalCurrentDirectoryUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.currentDirectoryUri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:currentDirectoryUri"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCurrentFileUriPropertyInfo
instance AttrInfo TerminalCurrentFileUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentFileUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalCurrentFileUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()
    type AttrTransferType TerminalCurrentFileUriPropertyInfo = ()
    type AttrGetType TerminalCurrentFileUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalCurrentFileUriPropertyInfo = "current-file-uri"
    type AttrOrigin TerminalCurrentFileUriPropertyInfo = Terminal
    attrGet = getTerminalCurrentFileUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.currentFileUri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:currentFileUri"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCursorBlinkModePropertyInfo
instance AttrInfo TerminalCursorBlinkModePropertyInfo where
    type AttrAllowedOps TerminalCursorBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCursorBlinkModePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode
    type AttrTransferTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode
    type AttrTransferType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode
    type AttrGetType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode
    type AttrLabel TerminalCursorBlinkModePropertyInfo = "cursor-blink-mode"
    type AttrOrigin TerminalCursorBlinkModePropertyInfo = Terminal
    attrGet = getTerminalCursorBlinkMode
    attrSet = setTerminalCursorBlinkMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCursorBlinkMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.cursorBlinkMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:cursorBlinkMode"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalCursorShapePropertyInfo
instance AttrInfo TerminalCursorShapePropertyInfo where
    type AttrAllowedOps TerminalCursorShapePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalCursorShapePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape
    type AttrTransferTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape
    type AttrTransferType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape
    type AttrGetType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape
    type AttrLabel TerminalCursorShapePropertyInfo = "cursor-shape"
    type AttrOrigin TerminalCursorShapePropertyInfo = Terminal
    attrGet = getTerminalCursorShape
    attrSet = setTerminalCursorShape
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalCursorShape
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.cursorShape"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:cursorShape"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalDeleteBindingPropertyInfo
instance AttrInfo TerminalDeleteBindingPropertyInfo where
    type AttrAllowedOps TerminalDeleteBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalDeleteBindingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrTransferType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrGetType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalDeleteBindingPropertyInfo = "delete-binding"
    type AttrOrigin TerminalDeleteBindingPropertyInfo = Terminal
    attrGet = getTerminalDeleteBinding
    attrSet = setTerminalDeleteBinding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalDeleteBinding
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.deleteBinding"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:deleteBinding"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableA11yPropertyInfo
instance AttrInfo TerminalEnableA11yPropertyInfo where
    type AttrAllowedOps TerminalEnableA11yPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableA11yPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableA11yPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableA11yPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableA11yPropertyInfo = Bool
    type AttrGetType TerminalEnableA11yPropertyInfo = Bool
    type AttrLabel TerminalEnableA11yPropertyInfo = "enable-a11y"
    type AttrOrigin TerminalEnableA11yPropertyInfo = Terminal
    attrGet = getTerminalEnableA11y
    attrSet = setTerminalEnableA11y
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableA11y
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableA11y"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableA11y"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableBidiPropertyInfo
instance AttrInfo TerminalEnableBidiPropertyInfo where
    type AttrAllowedOps TerminalEnableBidiPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableBidiPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableBidiPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableBidiPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableBidiPropertyInfo = Bool
    type AttrGetType TerminalEnableBidiPropertyInfo = Bool
    type AttrLabel TerminalEnableBidiPropertyInfo = "enable-bidi"
    type AttrOrigin TerminalEnableBidiPropertyInfo = Terminal
    attrGet = getTerminalEnableBidi
    attrSet = setTerminalEnableBidi
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableBidi
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableBidi"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableBidi"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableFallbackScrollingPropertyInfo
instance AttrInfo TerminalEnableFallbackScrollingPropertyInfo where
    type AttrAllowedOps TerminalEnableFallbackScrollingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableFallbackScrollingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableFallbackScrollingPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableFallbackScrollingPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableFallbackScrollingPropertyInfo = Bool
    type AttrGetType TerminalEnableFallbackScrollingPropertyInfo = Bool
    type AttrLabel TerminalEnableFallbackScrollingPropertyInfo = "enable-fallback-scrolling"
    type AttrOrigin TerminalEnableFallbackScrollingPropertyInfo = Terminal
    attrGet = getTerminalEnableFallbackScrolling
    attrSet = setTerminalEnableFallbackScrolling
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableFallbackScrolling
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableFallbackScrolling"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableFallbackScrolling"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableLegacyOsc777PropertyInfo
instance AttrInfo TerminalEnableLegacyOsc777PropertyInfo where
    type AttrAllowedOps TerminalEnableLegacyOsc777PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableLegacyOsc777PropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableLegacyOsc777PropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableLegacyOsc777PropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableLegacyOsc777PropertyInfo = Bool
    type AttrGetType TerminalEnableLegacyOsc777PropertyInfo = Bool
    type AttrLabel TerminalEnableLegacyOsc777PropertyInfo = "enable-legacy-osc777"
    type AttrOrigin TerminalEnableLegacyOsc777PropertyInfo = Terminal
    attrGet = getTerminalEnableLegacyOsc777
    attrSet = setTerminalEnableLegacyOsc777
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableLegacyOsc777
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableLegacyOsc777"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableLegacyOsc777"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableShapingPropertyInfo
instance AttrInfo TerminalEnableShapingPropertyInfo where
    type AttrAllowedOps TerminalEnableShapingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableShapingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableShapingPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableShapingPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableShapingPropertyInfo = Bool
    type AttrGetType TerminalEnableShapingPropertyInfo = Bool
    type AttrLabel TerminalEnableShapingPropertyInfo = "enable-shaping"
    type AttrOrigin TerminalEnableShapingPropertyInfo = Terminal
    attrGet = getTerminalEnableShaping
    attrSet = setTerminalEnableShaping
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableShaping
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableShaping"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableShaping"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEnableSixelPropertyInfo
instance AttrInfo TerminalEnableSixelPropertyInfo where
    type AttrAllowedOps TerminalEnableSixelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalEnableSixelPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEnableSixelPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalEnableSixelPropertyInfo = (~) Bool
    type AttrTransferType TerminalEnableSixelPropertyInfo = Bool
    type AttrGetType TerminalEnableSixelPropertyInfo = Bool
    type AttrLabel TerminalEnableSixelPropertyInfo = "enable-sixel"
    type AttrOrigin TerminalEnableSixelPropertyInfo = Terminal
    attrGet = getTerminalEnableSixel
    attrSet = setTerminalEnableSixel
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEnableSixel
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.enableSixel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:enableSixel"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalEncodingPropertyInfo
instance AttrInfo TerminalEncodingPropertyInfo where
    type AttrAllowedOps TerminalEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalEncodingPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text
    type AttrTransferType TerminalEncodingPropertyInfo = T.Text
    type AttrGetType TerminalEncodingPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalEncodingPropertyInfo = "encoding"
    type AttrOrigin TerminalEncodingPropertyInfo = Terminal
    attrGet = getTerminalEncoding
    attrSet = setTerminalEncoding
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalEncoding
    attrClear = clearTerminalEncoding
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.encoding"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:encoding"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalFontDescPropertyInfo
instance AttrInfo TerminalFontDescPropertyInfo where
    type AttrAllowedOps TerminalFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalFontDescPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferType TerminalFontDescPropertyInfo = Pango.FontDescription.FontDescription
    type AttrGetType TerminalFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription)
    type AttrLabel TerminalFontDescPropertyInfo = "font-desc"
    type AttrOrigin TerminalFontDescPropertyInfo = Terminal
    attrGet = getTerminalFontDesc
    attrSet = setTerminalFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalFontDesc
    attrClear = clearTerminalFontDesc
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.fontDesc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:fontDesc"
        })
#endif

-- VVV Prop "font-options"
   -- Type: TInterface (Name {namespace = "cairo", name = "FontOptions"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

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

-- | Construct a `GValueConstruct` with valid value for the “@font-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTerminalFontOptions :: (IsTerminal o, MIO.MonadIO m) => Cairo.FontOptions.FontOptions -> m (GValueConstruct o)
constructTerminalFontOptions :: forall o (m :: * -> *).
(IsTerminal o, MonadIO m) =>
FontOptions -> m (GValueConstruct o)
constructTerminalFontOptions FontOptions
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe FontOptions -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"font-options" (FontOptions -> Maybe FontOptions
forall a. a -> Maybe a
P.Just FontOptions
val)

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

#if defined(ENABLE_OVERLOADING)
data TerminalFontOptionsPropertyInfo
instance AttrInfo TerminalFontOptionsPropertyInfo where
    type AttrAllowedOps TerminalFontOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalFontOptionsPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalFontOptionsPropertyInfo = (~) Cairo.FontOptions.FontOptions
    type AttrTransferTypeConstraint TerminalFontOptionsPropertyInfo = (~) Cairo.FontOptions.FontOptions
    type AttrTransferType TerminalFontOptionsPropertyInfo = Cairo.FontOptions.FontOptions
    type AttrGetType TerminalFontOptionsPropertyInfo = (Maybe Cairo.FontOptions.FontOptions)
    type AttrLabel TerminalFontOptionsPropertyInfo = "font-options"
    type AttrOrigin TerminalFontOptionsPropertyInfo = Terminal
    attrGet = getTerminalFontOptions
    attrSet = setTerminalFontOptions
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalFontOptions
    attrClear = clearTerminalFontOptions
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.fontOptions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:fontOptions"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalFontScalePropertyInfo
instance AttrInfo TerminalFontScalePropertyInfo where
    type AttrAllowedOps TerminalFontScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalFontScalePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalFontScalePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TerminalFontScalePropertyInfo = (~) Double
    type AttrTransferType TerminalFontScalePropertyInfo = Double
    type AttrGetType TerminalFontScalePropertyInfo = Double
    type AttrLabel TerminalFontScalePropertyInfo = "font-scale"
    type AttrOrigin TerminalFontScalePropertyInfo = Terminal
    attrGet = getTerminalFontScale
    attrSet = setTerminalFontScale
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalFontScale
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.fontScale"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:fontScale"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalHyperlinkHoverUriPropertyInfo
instance AttrInfo TerminalHyperlinkHoverUriPropertyInfo where
    type AttrAllowedOps TerminalHyperlinkHoverUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()
    type AttrTransferType TerminalHyperlinkHoverUriPropertyInfo = ()
    type AttrGetType TerminalHyperlinkHoverUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalHyperlinkHoverUriPropertyInfo = "hyperlink-hover-uri"
    type AttrOrigin TerminalHyperlinkHoverUriPropertyInfo = Terminal
    attrGet = getTerminalHyperlinkHoverUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.hyperlinkHoverUri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:hyperlinkHoverUri"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalIconTitlePropertyInfo
instance AttrInfo TerminalIconTitlePropertyInfo where
    type AttrAllowedOps TerminalIconTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalIconTitlePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalIconTitlePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalIconTitlePropertyInfo = (~) ()
    type AttrTransferType TerminalIconTitlePropertyInfo = ()
    type AttrGetType TerminalIconTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalIconTitlePropertyInfo = "icon-title"
    type AttrOrigin TerminalIconTitlePropertyInfo = Terminal
    attrGet = getTerminalIconTitle
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.iconTitle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:iconTitle"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalInputEnabledPropertyInfo
instance AttrInfo TerminalInputEnabledPropertyInfo where
    type AttrAllowedOps TerminalInputEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalInputEnabledPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool
    type AttrTransferType TerminalInputEnabledPropertyInfo = Bool
    type AttrGetType TerminalInputEnabledPropertyInfo = Bool
    type AttrLabel TerminalInputEnabledPropertyInfo = "input-enabled"
    type AttrOrigin TerminalInputEnabledPropertyInfo = Terminal
    attrGet = getTerminalInputEnabled
    attrSet = setTerminalInputEnabled
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalInputEnabled
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.inputEnabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:inputEnabled"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalPointerAutohidePropertyInfo
instance AttrInfo TerminalPointerAutohidePropertyInfo where
    type AttrAllowedOps TerminalPointerAutohidePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalPointerAutohidePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool
    type AttrTransferType TerminalPointerAutohidePropertyInfo = Bool
    type AttrGetType TerminalPointerAutohidePropertyInfo = Bool
    type AttrLabel TerminalPointerAutohidePropertyInfo = "pointer-autohide"
    type AttrOrigin TerminalPointerAutohidePropertyInfo = Terminal
    attrGet = getTerminalPointerAutohide
    attrSet = setTerminalPointerAutohide
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalPointerAutohide
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.pointerAutohide"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:pointerAutohide"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalPtyPropertyInfo
instance AttrInfo TerminalPtyPropertyInfo where
    type AttrAllowedOps TerminalPtyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalPtyPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty
    type AttrTransferTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty
    type AttrTransferType TerminalPtyPropertyInfo = Vte.Pty.Pty
    type AttrGetType TerminalPtyPropertyInfo = (Maybe Vte.Pty.Pty)
    type AttrLabel TerminalPtyPropertyInfo = "pty"
    type AttrOrigin TerminalPtyPropertyInfo = Terminal
    attrGet = getTerminalPty
    attrSet = setTerminalPty
    attrTransfer _ v = do
        unsafeCastTo Vte.Pty.Pty v
    attrConstruct = constructTerminalPty
    attrClear = clearTerminalPty
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.pty"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:pty"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalRewrapOnResizePropertyInfo
instance AttrInfo TerminalRewrapOnResizePropertyInfo where
    type AttrAllowedOps TerminalRewrapOnResizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalRewrapOnResizePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool
    type AttrTransferType TerminalRewrapOnResizePropertyInfo = Bool
    type AttrGetType TerminalRewrapOnResizePropertyInfo = Bool
    type AttrLabel TerminalRewrapOnResizePropertyInfo = "rewrap-on-resize"
    type AttrOrigin TerminalRewrapOnResizePropertyInfo = Terminal
    attrGet = getTerminalRewrapOnResize
    attrSet = setTerminalRewrapOnResize
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalRewrapOnResize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.rewrapOnResize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:rewrapOnResize"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalScrollOnInsertPropertyInfo
instance AttrInfo TerminalScrollOnInsertPropertyInfo where
    type AttrAllowedOps TerminalScrollOnInsertPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollOnInsertPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollOnInsertPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollOnInsertPropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollOnInsertPropertyInfo = Bool
    type AttrGetType TerminalScrollOnInsertPropertyInfo = Bool
    type AttrLabel TerminalScrollOnInsertPropertyInfo = "scroll-on-insert"
    type AttrOrigin TerminalScrollOnInsertPropertyInfo = Terminal
    attrGet = getTerminalScrollOnInsert
    attrSet = setTerminalScrollOnInsert
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollOnInsert
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.scrollOnInsert"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:scrollOnInsert"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalScrollOnKeystrokePropertyInfo
instance AttrInfo TerminalScrollOnKeystrokePropertyInfo where
    type AttrAllowedOps TerminalScrollOnKeystrokePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollOnKeystrokePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollOnKeystrokePropertyInfo = Bool
    type AttrGetType TerminalScrollOnKeystrokePropertyInfo = Bool
    type AttrLabel TerminalScrollOnKeystrokePropertyInfo = "scroll-on-keystroke"
    type AttrOrigin TerminalScrollOnKeystrokePropertyInfo = Terminal
    attrGet = getTerminalScrollOnKeystroke
    attrSet = setTerminalScrollOnKeystroke
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollOnKeystroke
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.scrollOnKeystroke"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:scrollOnKeystroke"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalScrollOnOutputPropertyInfo
instance AttrInfo TerminalScrollOnOutputPropertyInfo where
    type AttrAllowedOps TerminalScrollOnOutputPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollOnOutputPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollOnOutputPropertyInfo = Bool
    type AttrGetType TerminalScrollOnOutputPropertyInfo = Bool
    type AttrLabel TerminalScrollOnOutputPropertyInfo = "scroll-on-output"
    type AttrOrigin TerminalScrollOnOutputPropertyInfo = Terminal
    attrGet = getTerminalScrollOnOutput
    attrSet = setTerminalScrollOnOutput
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollOnOutput
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.scrollOnOutput"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:scrollOnOutput"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalScrollUnitIsPixelsPropertyInfo
instance AttrInfo TerminalScrollUnitIsPixelsPropertyInfo where
    type AttrAllowedOps TerminalScrollUnitIsPixelsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollUnitIsPixelsPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollUnitIsPixelsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalScrollUnitIsPixelsPropertyInfo = (~) Bool
    type AttrTransferType TerminalScrollUnitIsPixelsPropertyInfo = Bool
    type AttrGetType TerminalScrollUnitIsPixelsPropertyInfo = Bool
    type AttrLabel TerminalScrollUnitIsPixelsPropertyInfo = "scroll-unit-is-pixels"
    type AttrOrigin TerminalScrollUnitIsPixelsPropertyInfo = Terminal
    attrGet = getTerminalScrollUnitIsPixels
    attrSet = setTerminalScrollUnitIsPixels
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollUnitIsPixels
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.scrollUnitIsPixels"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:scrollUnitIsPixels"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalScrollbackLinesPropertyInfo
instance AttrInfo TerminalScrollbackLinesPropertyInfo where
    type AttrAllowedOps TerminalScrollbackLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalScrollbackLinesPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32
    type AttrTransferType TerminalScrollbackLinesPropertyInfo = Word32
    type AttrGetType TerminalScrollbackLinesPropertyInfo = Word32
    type AttrLabel TerminalScrollbackLinesPropertyInfo = "scrollback-lines"
    type AttrOrigin TerminalScrollbackLinesPropertyInfo = Terminal
    attrGet = getTerminalScrollbackLines
    attrSet = setTerminalScrollbackLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalScrollbackLines
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.scrollbackLines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:scrollbackLines"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalTextBlinkModePropertyInfo
instance AttrInfo TerminalTextBlinkModePropertyInfo where
    type AttrAllowedOps TerminalTextBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalTextBlinkModePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode
    type AttrTransferTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode
    type AttrTransferType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode
    type AttrGetType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode
    type AttrLabel TerminalTextBlinkModePropertyInfo = "text-blink-mode"
    type AttrOrigin TerminalTextBlinkModePropertyInfo = Terminal
    attrGet = getTerminalTextBlinkMode
    attrSet = setTerminalTextBlinkMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalTextBlinkMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.textBlinkMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:textBlinkMode"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalWindowTitlePropertyInfo
instance AttrInfo TerminalWindowTitlePropertyInfo where
    type AttrAllowedOps TerminalWindowTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TerminalWindowTitlePropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()
    type AttrTransferType TerminalWindowTitlePropertyInfo = ()
    type AttrGetType TerminalWindowTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalWindowTitlePropertyInfo = "window-title"
    type AttrOrigin TerminalWindowTitlePropertyInfo = Terminal
    attrGet = getTerminalWindowTitle
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.windowTitle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:windowTitle"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalWordCharExceptionsPropertyInfo
instance AttrInfo TerminalWordCharExceptionsPropertyInfo where
    type AttrAllowedOps TerminalWordCharExceptionsPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TerminalWordCharExceptionsPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()
    type AttrTransferType TerminalWordCharExceptionsPropertyInfo = ()
    type AttrGetType TerminalWordCharExceptionsPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalWordCharExceptionsPropertyInfo = "word-char-exceptions"
    type AttrOrigin TerminalWordCharExceptionsPropertyInfo = Terminal
    attrGet = getTerminalWordCharExceptions
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.wordCharExceptions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:wordCharExceptions"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalXalignPropertyInfo
instance AttrInfo TerminalXalignPropertyInfo where
    type AttrAllowedOps TerminalXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalXalignPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalXalignPropertyInfo = (~) Vte.Enums.Align
    type AttrTransferTypeConstraint TerminalXalignPropertyInfo = (~) Vte.Enums.Align
    type AttrTransferType TerminalXalignPropertyInfo = Vte.Enums.Align
    type AttrGetType TerminalXalignPropertyInfo = Vte.Enums.Align
    type AttrLabel TerminalXalignPropertyInfo = "xalign"
    type AttrOrigin TerminalXalignPropertyInfo = Terminal
    attrGet = getTerminalXalign
    attrSet = setTerminalXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalXalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.xalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:xalign"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalXfillPropertyInfo
instance AttrInfo TerminalXfillPropertyInfo where
    type AttrAllowedOps TerminalXfillPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalXfillPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalXfillPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalXfillPropertyInfo = (~) Bool
    type AttrTransferType TerminalXfillPropertyInfo = Bool
    type AttrGetType TerminalXfillPropertyInfo = Bool
    type AttrLabel TerminalXfillPropertyInfo = "xfill"
    type AttrOrigin TerminalXfillPropertyInfo = Terminal
    attrGet = getTerminalXfill
    attrSet = setTerminalXfill
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalXfill
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.xfill"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:xfill"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalYalignPropertyInfo
instance AttrInfo TerminalYalignPropertyInfo where
    type AttrAllowedOps TerminalYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalYalignPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalYalignPropertyInfo = (~) Vte.Enums.Align
    type AttrTransferTypeConstraint TerminalYalignPropertyInfo = (~) Vte.Enums.Align
    type AttrTransferType TerminalYalignPropertyInfo = Vte.Enums.Align
    type AttrGetType TerminalYalignPropertyInfo = Vte.Enums.Align
    type AttrLabel TerminalYalignPropertyInfo = "yalign"
    type AttrOrigin TerminalYalignPropertyInfo = Terminal
    attrGet = getTerminalYalign
    attrSet = setTerminalYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalYalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.yalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:yalign"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalYfillPropertyInfo
instance AttrInfo TerminalYfillPropertyInfo where
    type AttrAllowedOps TerminalYfillPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TerminalYfillPropertyInfo = IsTerminal
    type AttrSetTypeConstraint TerminalYfillPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TerminalYfillPropertyInfo = (~) Bool
    type AttrTransferType TerminalYfillPropertyInfo = Bool
    type AttrGetType TerminalYfillPropertyInfo = Bool
    type AttrLabel TerminalYfillPropertyInfo = "yfill"
    type AttrOrigin TerminalYfillPropertyInfo = Terminal
    attrGet = getTerminalYfill
    attrSet = setTerminalYfill
    attrTransfer _ v = do
        return v
    attrConstruct = constructTerminalYfill
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.yfill"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#g:attr:yfill"
        })
#endif

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

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

terminalAllowHyperlink :: AttrLabelProxy "allowHyperlink"
terminalAllowHyperlink = AttrLabelProxy

terminalAudibleBell :: AttrLabelProxy "audibleBell"
terminalAudibleBell = AttrLabelProxy

terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"
terminalBackspaceBinding = AttrLabelProxy

terminalBoldIsBright :: AttrLabelProxy "boldIsBright"
terminalBoldIsBright = AttrLabelProxy

terminalCellHeightScale :: AttrLabelProxy "cellHeightScale"
terminalCellHeightScale = AttrLabelProxy

terminalCellWidthScale :: AttrLabelProxy "cellWidthScale"
terminalCellWidthScale = AttrLabelProxy

terminalCjkAmbiguousWidth :: AttrLabelProxy "cjkAmbiguousWidth"
terminalCjkAmbiguousWidth = AttrLabelProxy

terminalContextMenu :: AttrLabelProxy "contextMenu"
terminalContextMenu = AttrLabelProxy

terminalContextMenuModel :: AttrLabelProxy "contextMenuModel"
terminalContextMenuModel = AttrLabelProxy

terminalCurrentDirectoryUri :: AttrLabelProxy "currentDirectoryUri"
terminalCurrentDirectoryUri = AttrLabelProxy

terminalCurrentFileUri :: AttrLabelProxy "currentFileUri"
terminalCurrentFileUri = AttrLabelProxy

terminalCursorBlinkMode :: AttrLabelProxy "cursorBlinkMode"
terminalCursorBlinkMode = AttrLabelProxy

terminalCursorShape :: AttrLabelProxy "cursorShape"
terminalCursorShape = AttrLabelProxy

terminalDeleteBinding :: AttrLabelProxy "deleteBinding"
terminalDeleteBinding = AttrLabelProxy

terminalEnableA11y :: AttrLabelProxy "enableA11y"
terminalEnableA11y = AttrLabelProxy

terminalEnableBidi :: AttrLabelProxy "enableBidi"
terminalEnableBidi = AttrLabelProxy

terminalEnableFallbackScrolling :: AttrLabelProxy "enableFallbackScrolling"
terminalEnableFallbackScrolling = AttrLabelProxy

terminalEnableLegacyOsc777 :: AttrLabelProxy "enableLegacyOsc777"
terminalEnableLegacyOsc777 = AttrLabelProxy

terminalEnableShaping :: AttrLabelProxy "enableShaping"
terminalEnableShaping = AttrLabelProxy

terminalEnableSixel :: AttrLabelProxy "enableSixel"
terminalEnableSixel = AttrLabelProxy

terminalEncoding :: AttrLabelProxy "encoding"
terminalEncoding = AttrLabelProxy

terminalFontDesc :: AttrLabelProxy "fontDesc"
terminalFontDesc = AttrLabelProxy

terminalFontOptions :: AttrLabelProxy "fontOptions"
terminalFontOptions = AttrLabelProxy

terminalFontScale :: AttrLabelProxy "fontScale"
terminalFontScale = AttrLabelProxy

terminalHyperlinkHoverUri :: AttrLabelProxy "hyperlinkHoverUri"
terminalHyperlinkHoverUri = AttrLabelProxy

terminalIconTitle :: AttrLabelProxy "iconTitle"
terminalIconTitle = AttrLabelProxy

terminalInputEnabled :: AttrLabelProxy "inputEnabled"
terminalInputEnabled = AttrLabelProxy

terminalPointerAutohide :: AttrLabelProxy "pointerAutohide"
terminalPointerAutohide = AttrLabelProxy

terminalPty :: AttrLabelProxy "pty"
terminalPty = AttrLabelProxy

terminalRewrapOnResize :: AttrLabelProxy "rewrapOnResize"
terminalRewrapOnResize = AttrLabelProxy

terminalScrollOnInsert :: AttrLabelProxy "scrollOnInsert"
terminalScrollOnInsert = AttrLabelProxy

terminalScrollOnKeystroke :: AttrLabelProxy "scrollOnKeystroke"
terminalScrollOnKeystroke = AttrLabelProxy

terminalScrollOnOutput :: AttrLabelProxy "scrollOnOutput"
terminalScrollOnOutput = AttrLabelProxy

terminalScrollUnitIsPixels :: AttrLabelProxy "scrollUnitIsPixels"
terminalScrollUnitIsPixels = AttrLabelProxy

terminalScrollbackLines :: AttrLabelProxy "scrollbackLines"
terminalScrollbackLines = AttrLabelProxy

terminalTextBlinkMode :: AttrLabelProxy "textBlinkMode"
terminalTextBlinkMode = AttrLabelProxy

terminalWindowTitle :: AttrLabelProxy "windowTitle"
terminalWindowTitle = AttrLabelProxy

terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"
terminalWordCharExceptions = AttrLabelProxy

terminalXalign :: AttrLabelProxy "xalign"
terminalXalign = AttrLabelProxy

terminalXfill :: AttrLabelProxy "xfill"
terminalXfill = AttrLabelProxy

terminalYalign :: AttrLabelProxy "yalign"
terminalYalign = AttrLabelProxy

terminalYfill :: AttrLabelProxy "yfill"
terminalYfill = AttrLabelProxy

#endif

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

#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalCopyClipboardMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalCopyClipboard",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalCopyClipboard"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalCopyClipboardFormatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalCopyClipboardFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalCopyClipboardFormat"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalCopyPrimaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalCopyPrimary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalCopyPrimary"
        })


#endif

-- method Terminal::dup_termprop_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a location to store the string length, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_dup_termprop_string" vte_terminal_dup_termprop_string :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO CString

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeString' termprop, or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalDupTermpropString ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalDupTermpropString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Text, CSize)
terminalDupTermpropString a
terminal Text
prop = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal -> CString -> Ptr CSize -> IO CString
vte_terminal_dup_termprop_string Ptr Terminal
terminal' CString
prop' Ptr CSize
size
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
size')

#if defined(ENABLE_OVERLOADING)
data TerminalDupTermpropStringMethodInfo
instance (signature ~ (T.Text -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalDupTermpropStringMethodInfo a signature where
    overloadedMethod = terminalDupTermpropString

instance O.OverloadedMethodInfo TerminalDupTermpropStringMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalDupTermpropString",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalDupTermpropString"
        })


#endif

-- method Terminal::dup_termprop_string_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a location to store the string length, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_dup_termprop_string_by_id" vte_terminal_dup_termprop_string_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO CString

-- | Like 'GI.Vte.Objects.Terminal.terminalDupTermpropString' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalDupTermpropStringById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalDupTermpropStringById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Text, CSize)
terminalDupTermpropStringById a
terminal Int32
prop = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal -> Int32 -> Ptr CSize -> IO CString
vte_terminal_dup_termprop_string_by_id Ptr Terminal
terminal' Int32
prop Ptr CSize
size
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
size')

#if defined(ENABLE_OVERLOADING)
data TerminalDupTermpropStringByIdMethodInfo
instance (signature ~ (Int32 -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalDupTermpropStringByIdMethodInfo a signature where
    overloadedMethod = terminalDupTermpropStringById

instance O.OverloadedMethodInfo TerminalDupTermpropStringByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalDupTermpropStringById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalDupTermpropStringById"
        })


#endif

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

foreign import ccall "vte_terminal_dup_termprop_uuid" vte_terminal_dup_termprop_uuid :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr Vte.Uuid.Uuid)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeUuid' termprop as a t'GI.Vte.Structs.Uuid.Uuid', or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalDupTermpropUuid ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe Vte.Uuid.Uuid)
    -- ^ __Returns:__ the property\'s value as a t'GI.Vte.Structs.Uuid.Uuid', or 'P.Nothing'
terminalDupTermpropUuid :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Uuid)
terminalDupTermpropUuid a
terminal Text
prop = IO (Maybe Uuid) -> m (Maybe Uuid)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Uuid) -> m (Maybe Uuid))
-> IO (Maybe Uuid) -> m (Maybe Uuid)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Uuid
result <- Ptr Terminal -> CString -> IO (Ptr Uuid)
vte_terminal_dup_termprop_uuid Ptr Terminal
terminal' CString
prop'
    Maybe Uuid
maybeResult <- Ptr Uuid -> (Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Uuid
result ((Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid))
-> (Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid)
forall a b. (a -> b) -> a -> b
$ \Ptr Uuid
result' -> do
        Uuid
result'' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Uuid -> Uuid
Vte.Uuid.Uuid) Ptr Uuid
result'
        Uuid -> IO Uuid
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uuid
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe Uuid -> IO (Maybe Uuid)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Uuid
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalDupTermpropUuidMethodInfo
instance (signature ~ (T.Text -> m (Maybe Vte.Uuid.Uuid)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalDupTermpropUuidMethodInfo a signature where
    overloadedMethod = terminalDupTermpropUuid

instance O.OverloadedMethodInfo TerminalDupTermpropUuidMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalDupTermpropUuid",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalDupTermpropUuid"
        })


#endif

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

foreign import ccall "vte_terminal_dup_termprop_uuid_by_id" vte_terminal_dup_termprop_uuid_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr Vte.Uuid.Uuid)

-- | Like 'GI.Vte.Objects.Terminal.terminalDupTermpropUuid' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalDupTermpropUuidById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe Vte.Uuid.Uuid)
    -- ^ __Returns:__ the property\'s value as a t'GI.Vte.Structs.Uuid.Uuid', or 'P.Nothing'
terminalDupTermpropUuidById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Uuid)
terminalDupTermpropUuidById a
terminal Int32
prop = IO (Maybe Uuid) -> m (Maybe Uuid)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Uuid) -> m (Maybe Uuid))
-> IO (Maybe Uuid) -> m (Maybe Uuid)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Uuid
result <- Ptr Terminal -> Int32 -> IO (Ptr Uuid)
vte_terminal_dup_termprop_uuid_by_id Ptr Terminal
terminal' Int32
prop
    Maybe Uuid
maybeResult <- Ptr Uuid -> (Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Uuid
result ((Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid))
-> (Ptr Uuid -> IO Uuid) -> IO (Maybe Uuid)
forall a b. (a -> b) -> a -> b
$ \Ptr Uuid
result' -> do
        Uuid
result'' <- ((ManagedPtr Uuid -> Uuid) -> Ptr Uuid -> IO Uuid
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Uuid -> Uuid
Vte.Uuid.Uuid) Ptr Uuid
result'
        Uuid -> IO Uuid
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uuid
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Uuid -> IO (Maybe Uuid)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Uuid
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalDupTermpropUuidByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe Vte.Uuid.Uuid)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalDupTermpropUuidByIdMethodInfo a signature where
    overloadedMethod = terminalDupTermpropUuidById

instance O.OverloadedMethodInfo TerminalDupTermpropUuidByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalDupTermpropUuidById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalDupTermpropUuidById"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalFeedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalFeed",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalFeed"
        })


#endif

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

foreign import ccall "vte_terminal_feed_child" vte_terminal_feed_child :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Word8 ->                            -- text : TCArray False (-1) 2 (TBasicType TUInt8)
    DI.Int64 ->                             -- length : TBasicType TSSize
    IO ()

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

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

instance O.OverloadedMethodInfo TerminalFeedChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalFeedChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalFeedChild"
        })


#endif

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

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

{-# DEPRECATED terminalFeedChildBinary ["(Since version 0.60)","Don\\'t send binary data. Use 'GI.Vte.Objects.Terminal.terminalFeedChild' instead to send","  UTF-8 text"] #-}
-- | Sends a block of binary data to the child.
terminalFeedChildBinary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (ByteString)
    -- ^ /@data@/: data to send to the child
    -> m ()
terminalFeedChildBinary :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe ByteString -> m ()
terminalFeedChildBinary a
terminal Maybe ByteString
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let length_ :: CSize
length_ = case Maybe ByteString
data_ of
            Maybe ByteString
Nothing -> CSize
0
            Just ByteString
jData_ -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jData_
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Word8
maybeData_ <- case Maybe ByteString
data_ of
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
FP.nullPtr
        Just ByteString
jData_ -> do
            Ptr Word8
jData_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jData_
            Ptr Word8 -> IO (Ptr Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jData_'
    Ptr Terminal -> Ptr Word8 -> CSize -> IO ()
vte_terminal_feed_child_binary Ptr Terminal
terminal' Ptr Word8
maybeData_ CSize
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeData_
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TerminalFeedChildBinaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalFeedChildBinary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalFeedChildBinary"
        })


#endif

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

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

{-# DEPRECATED terminalGetAllowBold ["(Since version 0.60)","There\\'s probably no reason for this feature to exist."] #-}
-- | Checks whether or not the terminal will attempt to draw bold text,
-- by using a bold font variant.
terminalGetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if bolding is enabled, 'P.False' if not
terminalGetAllowBold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetAllowBold a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_allow_bold Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo TerminalGetAllowBoldMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetAllowBold",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetAllowBold"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetAllowHyperlinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetAllowHyperlink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetAllowHyperlink"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetAudibleBellMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetAudibleBell",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetAudibleBell"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetBoldIsBrightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetBoldIsBright",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetBoldIsBright"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCellHeightScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCellHeightScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCellHeightScale"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCellWidthScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCellWidthScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCellWidthScale"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCharHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCharHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCharHeight"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCharWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCharWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCharWidth"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCjkAmbiguousWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCjkAmbiguousWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCjkAmbiguousWidth"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetColorBackgroundForDrawMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetColorBackgroundForDraw",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetColorBackgroundForDraw"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetColumnCountMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetColumnCount",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetColumnCount"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetContextMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the context menu, or 'P.Nothing'
terminalGetContextMenu :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Widget)
terminalGetContextMenu a
terminal = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Widget
result <- Ptr Terminal -> IO (Ptr Widget)
vte_terminal_get_context_menu Ptr Terminal
terminal'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetContextMenuMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetContextMenuMethodInfo a signature where
    overloadedMethod = terminalGetContextMenu

instance O.OverloadedMethodInfo TerminalGetContextMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetContextMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetContextMenu"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetContextMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the context menu model, or 'P.Nothing'
terminalGetContextMenuModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe MenuModel)
terminalGetContextMenuModel a
terminal = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr MenuModel
result <- Ptr Terminal -> IO (Ptr MenuModel)
vte_terminal_get_context_menu_model Ptr Terminal
terminal'
    Maybe MenuModel
maybeResult <- Ptr MenuModel
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MenuModel
result ((Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel))
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ \Ptr MenuModel
result' -> do
        MenuModel
result'' <- ((ManagedPtr MenuModel -> MenuModel)
-> Ptr MenuModel -> IO MenuModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result'
        MenuModel -> IO MenuModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe MenuModel -> IO (Maybe MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetContextMenuModelMethodInfo
instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetContextMenuModelMethodInfo a signature where
    overloadedMethod = terminalGetContextMenuModel

instance O.OverloadedMethodInfo TerminalGetContextMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetContextMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetContextMenuModel"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCurrentDirectoryUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCurrentDirectoryUri"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCurrentFileUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCurrentFileUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCurrentFileUri"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCursorBlinkModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCursorBlinkMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCursorBlinkMode"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCursorPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCursorPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCursorPosition"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetCursorShapeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetCursorShape",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetCursorShape"
        })


#endif

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

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

-- | Checks whether the terminal communicates with a11y backends
-- 
-- /Since: 0.78/
terminalGetEnableA11y ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a11y is enabled, 'P.False' if not
terminalGetEnableA11y :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableA11y a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_a11y Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableA11yMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableA11yMethodInfo a signature where
    overloadedMethod = terminalGetEnableA11y

instance O.OverloadedMethodInfo TerminalGetEnableA11yMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableA11y",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableA11y"
        })


#endif

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

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

-- | Checks whether the terminal performs bidirectional text rendering.
-- 
-- /Since: 0.58/
terminalGetEnableBidi ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if BiDi is enabled, 'P.False' if not
terminalGetEnableBidi :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableBidi a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_bidi Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableBidiMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableBidiMethodInfo a signature where
    overloadedMethod = terminalGetEnableBidi

instance O.OverloadedMethodInfo TerminalGetEnableBidiMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableBidi",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableBidi"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.64/
terminalGetEnableFallbackScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if fallback scrolling is enabled
terminalGetEnableFallbackScrolling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableFallbackScrolling a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_fallback_scrolling Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableFallbackScrollingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableFallbackScrollingMethodInfo a signature where
    overloadedMethod = terminalGetEnableFallbackScrolling

instance O.OverloadedMethodInfo TerminalGetEnableFallbackScrollingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableFallbackScrolling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableFallbackScrolling"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.78/
terminalGetEnableLegacyOsc777 ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' iff legacy OSC 777 is enabled
terminalGetEnableLegacyOsc777 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableLegacyOsc777 a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_legacy_osc777 Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableLegacyOsc777MethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableLegacyOsc777MethodInfo a signature where
    overloadedMethod = terminalGetEnableLegacyOsc777

instance O.OverloadedMethodInfo TerminalGetEnableLegacyOsc777MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableLegacyOsc777",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableLegacyOsc777"
        })


#endif

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

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

-- | Checks whether the terminal shapes Arabic text.
-- 
-- /Since: 0.58/
terminalGetEnableShaping ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if Arabic shaping is enabled, 'P.False' if not
terminalGetEnableShaping :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableShaping a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_shaping Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableShapingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableShapingMethodInfo a signature where
    overloadedMethod = terminalGetEnableShaping

instance O.OverloadedMethodInfo TerminalGetEnableShapingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableShaping",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableShaping"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.62/
terminalGetEnableSixel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.False'
terminalGetEnableSixel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetEnableSixel a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_enable_sixel Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetEnableSixelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetEnableSixelMethodInfo a signature where
    overloadedMethod = terminalGetEnableSixel

instance O.OverloadedMethodInfo TerminalGetEnableSixelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEnableSixel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEnableSixel"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetEncodingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetEncoding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetEncoding"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetFontMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetFont",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetFont"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.74/
terminalGetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe Cairo.FontOptions.FontOptions)
    -- ^ __Returns:__ the terminal\'s font options, or 'P.Nothing'
terminalGetFontOptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe FontOptions)
terminalGetFontOptions a
terminal = IO (Maybe FontOptions) -> m (Maybe FontOptions)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FontOptions) -> m (Maybe FontOptions))
-> IO (Maybe FontOptions) -> m (Maybe FontOptions)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr FontOptions
result <- Ptr Terminal -> IO (Ptr FontOptions)
vte_terminal_get_font_options Ptr Terminal
terminal'
    Maybe FontOptions
maybeResult <- Ptr FontOptions
-> (Ptr FontOptions -> IO FontOptions) -> IO (Maybe FontOptions)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr FontOptions
result ((Ptr FontOptions -> IO FontOptions) -> IO (Maybe FontOptions))
-> (Ptr FontOptions -> IO FontOptions) -> IO (Maybe FontOptions)
forall a b. (a -> b) -> a -> b
$ \Ptr FontOptions
result' -> do
        FontOptions
result'' <- ((ManagedPtr FontOptions -> FontOptions)
-> Ptr FontOptions -> IO FontOptions
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr FontOptions -> FontOptions
Cairo.FontOptions.FontOptions) Ptr FontOptions
result'
        FontOptions -> IO FontOptions
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontOptions
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe FontOptions -> IO (Maybe FontOptions)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FontOptions
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetFontOptionsMethodInfo
instance (signature ~ (m (Maybe Cairo.FontOptions.FontOptions)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetFontOptionsMethodInfo a signature where
    overloadedMethod = terminalGetFontOptions

instance O.OverloadedMethodInfo TerminalGetFontOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetFontOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetFontOptions"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetFontScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetFontScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetFontScale"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetGeometryHintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetGeometryHints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetGeometryHints"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetHasSelectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetHasSelection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetHasSelection"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetIconTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetIconTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetIconTitle"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetInputEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetInputEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetInputEnabled"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetMouseAutohideMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetMouseAutohide",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetMouseAutohide"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetPtyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetPty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetPty"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetRewrapOnResizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetRewrapOnResize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetRewrapOnResize"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetRowCountMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetRowCount",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetRowCount"
        })


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollOnInsertMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetScrollOnInsertMethodInfo a signature where
    overloadedMethod = terminalGetScrollOnInsert

instance O.OverloadedMethodInfo TerminalGetScrollOnInsertMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetScrollOnInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollOnInsert"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetScrollOnKeystrokeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetScrollOnKeystroke",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollOnKeystroke"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetScrollOnOutputMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetScrollOnOutput",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollOnOutput"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.66/
terminalGetScrollUnitIsPixels ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the scroll unit is pixels; or 'P.False' if the unit is lines
terminalGetScrollUnitIsPixels :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetScrollUnitIsPixels a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_scroll_unit_is_pixels Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollUnitIsPixelsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetScrollUnitIsPixelsMethodInfo a signature where
    overloadedMethod = terminalGetScrollUnitIsPixels

instance O.OverloadedMethodInfo TerminalGetScrollUnitIsPixelsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetScrollUnitIsPixels",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollUnitIsPixels"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.52/
terminalGetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m FCT.CLong
    -- ^ __Returns:__ length of the scrollback buffer used by the terminal.
    -- A negative value means \"infinite scrollback\".
terminalGetScrollbackLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m CLong
terminalGetScrollbackLines a
terminal = IO CLong -> m CLong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CLong
result <- Ptr Terminal -> IO CLong
vte_terminal_get_scrollback_lines Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CLong -> IO CLong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result

#if defined(ENABLE_OVERLOADING)
data TerminalGetScrollbackLinesMethodInfo
instance (signature ~ (m FCT.CLong), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalGetScrollbackLines

instance O.OverloadedMethodInfo TerminalGetScrollbackLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetScrollbackLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetScrollbackLines"
        })


#endif

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

foreign import ccall "vte_terminal_get_termprop_bool" vte_terminal_get_termprop_bool :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr CInt ->                             -- valuep : TBasicType TBoolean
    IO CInt

-- | For a 'GI.Vte.Enums.PropertyTypeBool' termprop, sets /@value@/ to /@prop@/\'s value,
--   or to 'P.False' if /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalGetTermpropBool ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, Bool))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropBool :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, Bool)
terminalGetTermpropBool a
terminal Text
prop = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr CInt
valuep <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    CInt
result <- Ptr Terminal -> CString -> Ptr CInt -> IO CInt
vte_terminal_get_termprop_bool Ptr Terminal
terminal' CString
prop' Ptr CInt
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CInt
valuep' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
valuep
    let valuep'' :: Bool
valuep'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
valuep'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
valuep
    (Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
valuep'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropBoolMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Bool))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropBoolMethodInfo a signature where
    overloadedMethod = terminalGetTermpropBool

instance O.OverloadedMethodInfo TerminalGetTermpropBoolMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropBool",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropBool"
        })


#endif

-- method Terminal::get_termprop_bool_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_bool_by_id" vte_terminal_get_termprop_bool_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr CInt ->                             -- valuep : TBasicType TBoolean
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropBool' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropBoolById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, Bool))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropBoolById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, Bool)
terminalGetTermpropBoolById a
terminal Int32
prop = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CInt
valuep <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr CInt -> IO CInt
vte_terminal_get_termprop_bool_by_id Ptr Terminal
terminal' Int32
prop Ptr CInt
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CInt
valuep' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
valuep
    let valuep'' :: Bool
valuep'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
valuep'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
valuep
    (Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
valuep'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropBoolByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Bool))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropBoolByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropBoolById

instance O.OverloadedMethodInfo TerminalGetTermpropBoolByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropBoolById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropBoolById"
        })


#endif

-- method Terminal::get_termprop_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the size of the data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TSize
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "a location to store the size of the data"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 2 (TBasicType TUInt8))
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_data" vte_terminal_get_termprop_data :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO (Ptr Word8)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeData' termprop, or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalGetTermpropData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe ByteString)
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalGetTermpropData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe ByteString)
terminalGetTermpropData a
terminal Text
prop = IO (Maybe ByteString) -> m (Maybe ByteString)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ByteString) -> m (Maybe ByteString))
-> IO (Maybe ByteString) -> m (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    Ptr Word8
result <- Ptr Terminal -> CString -> Ptr CSize -> IO (Ptr Word8)
vte_terminal_get_termprop_data Ptr Terminal
terminal' CString
prop' Ptr CSize
size
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    Maybe ByteString
maybeResult <- Ptr Word8 -> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Word8
result ((Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString))
-> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
result' -> do
        ByteString
result'' <- (CSize -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength CSize
size') Ptr Word8
result'
        ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    Maybe ByteString -> IO (Maybe ByteString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ByteString
maybeResult

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

instance O.OverloadedMethodInfo TerminalGetTermpropDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropData"
        })


#endif

-- method Terminal::get_termprop_data_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the size of the data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TSize
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "a location to store the size of the data"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 2 (TBasicType TUInt8))
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_data_by_id" vte_terminal_get_termprop_data_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO (Ptr Word8)

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropData' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropDataById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe ByteString)
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalGetTermpropDataById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe ByteString)
terminalGetTermpropDataById a
terminal Int32
prop = IO (Maybe ByteString) -> m (Maybe ByteString)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ByteString) -> m (Maybe ByteString))
-> IO (Maybe ByteString) -> m (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    Ptr Word8
result <- Ptr Terminal -> Int32 -> Ptr CSize -> IO (Ptr Word8)
vte_terminal_get_termprop_data_by_id Ptr Terminal
terminal' Int32
prop Ptr CSize
size
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    Maybe ByteString
maybeResult <- Ptr Word8 -> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Word8
result ((Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString))
-> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
result' -> do
        ByteString
result'' <- (CSize -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength CSize
size') Ptr Word8
result'
        ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    Maybe ByteString -> IO (Maybe ByteString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ByteString
maybeResult

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

instance O.OverloadedMethodInfo TerminalGetTermpropDataByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropDataById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropDataById"
        })


#endif

-- method Terminal::get_termprop_double
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_double" vte_terminal_get_termprop_double :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr CDouble ->                          -- valuep : TBasicType TDouble
    IO CInt

-- | For a 'GI.Vte.Enums.PropertyTypeDouble' termprop, sets /@value@/ to /@prop@/\'s value,
--   which is finite; or to 0.0 if /@prop@/ is unset, or /@prop@/ is not a
--   registered property.
-- 
-- /Since: 0.78/
terminalGetTermpropDouble ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, Double))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropDouble :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, Double)
terminalGetTermpropDouble a
terminal Text
prop = IO (Bool, Double) -> m (Bool, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double) -> m (Bool, Double))
-> IO (Bool, Double) -> m (Bool, Double)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr CDouble
valuep <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
    CInt
result <- Ptr Terminal -> CString -> Ptr CDouble -> IO CInt
vte_terminal_get_termprop_double Ptr Terminal
terminal' CString
prop' Ptr CDouble
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CDouble
valuep' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
valuep
    let valuep'' :: Double
valuep'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
valuep'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
valuep
    (Bool, Double) -> IO (Bool, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
valuep'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropDoubleMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Double))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropDoubleMethodInfo a signature where
    overloadedMethod = terminalGetTermpropDouble

instance O.OverloadedMethodInfo TerminalGetTermpropDoubleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropDouble",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropDouble"
        })


#endif

-- method Terminal::get_termprop_double_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_double_by_id" vte_terminal_get_termprop_double_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr CDouble ->                          -- valuep : TBasicType TDouble
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropDouble' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropDoubleById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, Double))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropDoubleById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, Double)
terminalGetTermpropDoubleById a
terminal Int32
prop = IO (Bool, Double) -> m (Bool, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double) -> m (Bool, Double))
-> IO (Bool, Double) -> m (Bool, Double)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CDouble
valuep <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr CDouble -> IO CInt
vte_terminal_get_termprop_double_by_id Ptr Terminal
terminal' Int32
prop Ptr CDouble
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CDouble
valuep' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
valuep
    let valuep'' :: Double
valuep'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
valuep'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
valuep
    (Bool, Double) -> IO (Bool, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
valuep'')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropDoubleByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Double))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropDoubleByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropDoubleById

instance O.OverloadedMethodInfo TerminalGetTermpropDoubleByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropDoubleById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropDoubleById"
        })


#endif

-- method Terminal::get_termprop_int
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_int" vte_terminal_get_termprop_int :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr Int64 ->                            -- valuep : TBasicType TInt64
    IO CInt

-- | For a 'GI.Vte.Enums.PropertyTypeInt' termprop, sets /@value@/ to /@prop@/\'s value,
-- or to 0 if /@prop@/ is unset, or if /@prop@/ is not a registered property.
-- 
-- If only a subset or range of values are acceptable for the given property,
-- the caller must validate the returned value and treat any out-of-bounds
-- value as if the termprop had no value; in particular it *must not* clamp
-- the values to the expected range.
-- 
-- /Since: 0.78/
terminalGetTermpropInt ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, Int64))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropInt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, Int64)
terminalGetTermpropInt a
terminal Text
prop = IO (Bool, Int64) -> m (Bool, Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Int64
valuep <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
    CInt
result <- Ptr Terminal -> CString -> Ptr Int64 -> IO CInt
vte_terminal_get_termprop_int Ptr Terminal
terminal' CString
prop' Ptr Int64
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Int64
valuep' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
valuep
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
valuep
    (Bool, Int64) -> IO (Bool, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
valuep')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropIntMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Int64))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropIntMethodInfo a signature where
    overloadedMethod = terminalGetTermpropInt

instance O.OverloadedMethodInfo TerminalGetTermpropIntMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropInt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropInt"
        })


#endif

-- method Terminal::get_termprop_int_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_int_by_id" vte_terminal_get_termprop_int_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr Int64 ->                            -- valuep : TBasicType TInt64
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropInt' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropIntById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, Int64))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropIntById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, Int64)
terminalGetTermpropIntById a
terminal Int32
prop = IO (Bool, Int64) -> m (Bool, Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Int64
valuep <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr Int64 -> IO CInt
vte_terminal_get_termprop_int_by_id Ptr Terminal
terminal' Int32
prop Ptr Int64
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Int64
valuep' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
valuep
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
valuep
    (Bool, Int64) -> IO (Bool, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
valuep')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropIntByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Int64))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropIntByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropIntById

instance O.OverloadedMethodInfo TerminalGetTermpropIntByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropIntById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropIntById"
        })


#endif

-- method Terminal::get_termprop_rgba
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkRGBA to fill in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_rgba" vte_terminal_get_termprop_rgba :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO CInt

-- | Stores the value of a 'GI.Vte.Enums.PropertyTypeRgb' or 'GI.Vte.Enums.PropertyTypeRgba' termprop in /@color@/ and
-- returns 'P.True' if the termprop is set, or stores rgb(0,0,0) or rgba(0,0,0,1) in /@color@/
-- and returns 'P.False' if the termprop is unset.
-- 
-- /Since: 0.78/
terminalGetTermpropRgba ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, Gdk.RGBA.RGBA))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropRgba :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, RGBA)
terminalGetTermpropRgba a
terminal Text
prop = IO (Bool, RGBA) -> m (Bool, RGBA)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, RGBA) -> m (Bool, RGBA))
-> IO (Bool, RGBA) -> m (Bool, RGBA)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    CInt
result <- Ptr Terminal -> CString -> Ptr RGBA -> IO CInt
vte_terminal_get_termprop_rgba Ptr Terminal
terminal' CString
prop' Ptr RGBA
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    (Bool, RGBA) -> IO (Bool, RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', RGBA
color')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropRgbaMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropRgbaMethodInfo a signature where
    overloadedMethod = terminalGetTermpropRgba

instance O.OverloadedMethodInfo TerminalGetTermpropRgbaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropRgba",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropRgba"
        })


#endif

-- method Terminal::get_termprop_rgba_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkRGBA to fill in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_rgba_by_id" vte_terminal_get_termprop_rgba_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropRgba' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropRgbaById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, Gdk.RGBA.RGBA))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropRgbaById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, RGBA)
terminalGetTermpropRgbaById a
terminal Int32
prop = IO (Bool, RGBA) -> m (Bool, RGBA)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, RGBA) -> m (Bool, RGBA))
-> IO (Bool, RGBA) -> m (Bool, RGBA)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr RGBA -> IO CInt
vte_terminal_get_termprop_rgba_by_id Ptr Terminal
terminal' Int32
prop Ptr RGBA
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Bool, RGBA) -> IO (Bool, RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', RGBA
color')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropRgbaByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropRgbaByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropRgbaById

instance O.OverloadedMethodInfo TerminalGetTermpropRgbaByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropRgbaById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropRgbaById"
        })


#endif

-- method Terminal::get_termprop_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a location to store the string length, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_string" vte_terminal_get_termprop_string :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO CString

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeString' termprop, or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalGetTermpropString ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalGetTermpropString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Text, CSize)
terminalGetTermpropString a
terminal Text
prop = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal -> CString -> Ptr CSize -> IO CString
vte_terminal_get_termprop_string Ptr Terminal
terminal' CString
prop' Ptr CSize
size
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
size')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropStringMethodInfo
instance (signature ~ (T.Text -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropStringMethodInfo a signature where
    overloadedMethod = terminalGetTermpropString

instance O.OverloadedMethodInfo TerminalGetTermpropStringMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropString",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropString"
        })


#endif

-- method Terminal::get_termprop_string_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a location to store the string length, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_string_by_id" vte_terminal_get_termprop_string_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr FCT.CSize ->                        -- size : TBasicType TSize
    IO CString

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropString' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropStringById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ the property\'s value, or 'P.Nothing'
terminalGetTermpropStringById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Text, CSize)
terminalGetTermpropStringById a
terminal Int32
prop = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr CSize
size <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal -> Int32 -> Ptr CSize -> IO CString
vte_terminal_get_termprop_string_by_id Ptr Terminal
terminal' Int32
prop Ptr CSize
size
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
size' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
size
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
size')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropStringByIdMethodInfo
instance (signature ~ (Int32 -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropStringByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropStringById

instance O.OverloadedMethodInfo TerminalGetTermpropStringByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropStringById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropStringById"
        })


#endif

-- method Terminal::get_termprop_uint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TUInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_uint" vte_terminal_get_termprop_uint :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr Word64 ->                           -- valuep : TBasicType TUInt64
    IO CInt

-- | For a 'GI.Vte.Enums.PropertyTypeUint' termprop, sets /@value@/ to /@prop@/\'s value,
-- or to 0 if /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- If only a subset or range of values are acceptable for the given property,
-- the caller must validate the returned value and treat any out-of-bounds
-- value as if the termprop had no value; in particular it *must not* clamp
-- the values to the expected range.
-- 
-- /Since: 0.78/
terminalGetTermpropUint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, Word64))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropUint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, Word64)
terminalGetTermpropUint a
terminal Text
prop = IO (Bool, Word64) -> m (Bool, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64) -> m (Bool, Word64))
-> IO (Bool, Word64) -> m (Bool, Word64)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Word64
valuep <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    CInt
result <- Ptr Terminal -> CString -> Ptr Word64 -> IO CInt
vte_terminal_get_termprop_uint Ptr Terminal
terminal' CString
prop' Ptr Word64
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Word64
valuep' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
valuep
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
valuep
    (Bool, Word64) -> IO (Bool, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
valuep')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropUintMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Word64))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropUintMethodInfo a signature where
    overloadedMethod = terminalGetTermpropUint

instance O.OverloadedMethodInfo TerminalGetTermpropUintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropUint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropUint"
        })


#endif

-- method Terminal::get_termprop_uint_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valuep"
--           , argType = TBasicType TUInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the value, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_uint_by_id" vte_terminal_get_termprop_uint_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr Word64 ->                           -- valuep : TBasicType TUInt64
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropUint' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropUintById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, Word64))
    -- ^ __Returns:__ 'P.True' iff the termprop is set
terminalGetTermpropUintById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, Word64)
terminalGetTermpropUintById a
terminal Int32
prop = IO (Bool, Word64) -> m (Bool, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64) -> m (Bool, Word64))
-> IO (Bool, Word64) -> m (Bool, Word64)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Word64
valuep <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr Word64 -> IO CInt
vte_terminal_get_termprop_uint_by_id Ptr Terminal
terminal' Int32
prop Ptr Word64
valuep
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Word64
valuep' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
valuep
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
valuep
    (Bool, Word64) -> IO (Bool, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
valuep')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropUintByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Word64))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropUintByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropUintById

instance O.OverloadedMethodInfo TerminalGetTermpropUintByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropUintById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropUintById"
        })


#endif

-- method Terminal::get_termprop_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gvalue"
--           , argType = TGValue
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GValue to be filled in, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_value" vte_terminal_get_termprop_value :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    Ptr GValue ->                           -- gvalue : TGValue
    IO CInt

-- | Returns 'P.True' with the value of /@prop@/ stored in /@value@/ (if not 'P.Nothing') if,
--   the termprop has a value, or 'P.False' if /@prop@/ is unset, or /@prop@/ is not
--   a registered property; in that case /@value@/ will not be set.
-- 
-- The value type returned depends on the termprop type:
-- * A 'GI.Vte.Enums.PropertyTypeValueless' termprop stores no value, and returns 'P.False'
--   from this function.
-- * A 'GI.Vte.Enums.PropertyTypeBool' termprop stores a @/G_TYPE_BOOLEAN/@ value.
-- * A 'GI.Vte.Enums.PropertyTypeInt' termprop stores a @/G_TYPE_INT64/@ value.
-- * A 'GI.Vte.Enums.PropertyTypeUint' termprop stores a @/G_TYPE_UINT64/@ value.
-- * A 'GI.Vte.Enums.PropertyTypeDouble' termprop stores a @/G_TYPE_DOUBLE/@ value.
-- * A 'GI.Vte.Enums.PropertyTypeRgb' termprop stores a boxed t'GI.Gdk.Structs.RGBA.RGBA' value with alpha 1.0 on gtk3,
--    and nothing on gtk4.
-- * A 'GI.Vte.Enums.PropertyTypeRgba' termprop stores a boxed t'GI.Gdk.Structs.RGBA.RGBA' value on gtk3,
--    and nothing on gtk4.
-- * A 'GI.Vte.Enums.PropertyTypeString' termprop stores a @/G_TYPE_STRING/@ value.
-- * A 'GI.Vte.Enums.PropertyTypeData' termprop stores a boxed t'GI.GLib.Structs.Bytes.Bytes' value.
-- * A 'GI.Vte.Enums.PropertyTypeUuid' termprop stores a boxed t'GI.Vte.Structs.Uuid.Uuid' value.
-- * A 'GI.Vte.Enums.PropertyTypeUri' termprop stores a boxed t'GI.GLib.Structs.Uri.Uri' value.
-- * A 'GI.Vte.Enums.PropertyTypeImage' termprop stores a boxed t'GI.Cairo.Structs.Surface.Surface' value on gtk3,
--     and a boxed @/GdkTexture/@ on gtk4
-- 
-- /Since: 0.78/
terminalGetTermpropValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m ((Bool, GValue))
    -- ^ __Returns:__ 'P.True' iff the property has a value, with /@gvalue@/ containig
    --   the property\'s value.
terminalGetTermpropValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Bool, GValue)
terminalGetTermpropValue a
terminal Text
prop = IO (Bool, GValue) -> m (Bool, GValue)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, GValue) -> m (Bool, GValue))
-> IO (Bool, GValue) -> m (Bool, GValue)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr GValue
gvalue <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    CInt
result <- Ptr Terminal -> CString -> Ptr GValue -> IO CInt
vte_terminal_get_termprop_value Ptr Terminal
terminal' CString
prop' Ptr GValue
gvalue
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    GValue
gvalue' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
gvalue
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    (Bool, GValue) -> IO (Bool, GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', GValue
gvalue')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropValueMethodInfo
instance (signature ~ (T.Text -> m ((Bool, GValue))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropValueMethodInfo a signature where
    overloadedMethod = terminalGetTermpropValue

instance O.OverloadedMethodInfo TerminalGetTermpropValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropValue"
        })


#endif

-- method Terminal::get_termprop_value_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a termprop ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gvalue"
--           , argType = TGValue
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GValue to be filled in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_termprop_value_by_id" vte_terminal_get_termprop_value_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    Ptr GValue ->                           -- gvalue : TGValue
    IO CInt

-- | Like 'GI.Vte.Objects.Terminal.terminalGetTermpropValue' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalGetTermpropValueById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m ((Bool, GValue))
    -- ^ __Returns:__ 'P.True' iff the property has a value, with /@gvalue@/ containig
    --   the property\'s value.
terminalGetTermpropValueById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Bool, GValue)
terminalGetTermpropValueById a
terminal Int32
prop = IO (Bool, GValue) -> m (Bool, GValue)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, GValue) -> m (Bool, GValue))
-> IO (Bool, GValue) -> m (Bool, GValue)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr GValue
gvalue <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    CInt
result <- Ptr Terminal -> Int32 -> Ptr GValue -> IO CInt
vte_terminal_get_termprop_value_by_id Ptr Terminal
terminal' Int32
prop Ptr GValue
gvalue
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    GValue
gvalue' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
gvalue
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Bool, GValue) -> IO (Bool, GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', GValue
gvalue')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTermpropValueByIdMethodInfo
instance (signature ~ (Int32 -> m ((Bool, GValue))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTermpropValueByIdMethodInfo a signature where
    overloadedMethod = terminalGetTermpropValueById

instance O.OverloadedMethodInfo TerminalGetTermpropValueByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTermpropValueById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTermpropValueById"
        })


#endif

-- method Terminal::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_selected"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "SelectionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #VteSelectionFunc callback. Deprecated: 0.44: Always pass %NULL here."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to be passed to the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TGArray
--                 (TInterface Name { namespace = "Vte" , name = "CharAttributes" })
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location for storing text attributes. Deprecated: 0.68: Always pass %NULL here."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

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

{-# DEPRECATED terminalGetText ["(Since version 0.76)","Use 'GI.Vte.Objects.Terminal.terminalGetTextFormat' instead"] #-}
-- | Extracts a view of the visible part of the terminal.
-- 
-- This method is unaware of BiDi. The columns returned in /@attributes@/ are
-- logical columns.
-- 
-- Note: since 0.68, passing a non-'P.Nothing' /@attributes@/ parameter is deprecated. Starting with
-- 0.72, passing a non-'P.Nothing' /@attributes@/ parameter will make this function itself return 'P.Nothing'.
-- Since 0.72, passing a non-'P.Nothing' /@isSelected@/ parameter will make this function itself return 'P.Nothing'.
terminalGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback. Deprecated: 0.44: Always pass 'P.Nothing' here.
    -> m ((Maybe T.Text, Maybe [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe SelectionFunc -> m (Maybe Text, Maybe [CharAttributes])
terminalGetText a
terminal Maybe SelectionFunc
isSelected = IO (Maybe Text, Maybe [CharAttributes])
-> m (Maybe Text, Maybe [CharAttributes])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Maybe [CharAttributes])
 -> m (Maybe Text, Maybe [CharAttributes]))
-> IO (Maybe Text, Maybe [CharAttributes])
-> m (Maybe Text, Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text Ptr Terminal
terminal' FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    Maybe [CharAttributes]
maybeAttributes <- Ptr (GArray (Ptr CharAttributes))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GArray (Ptr CharAttributes))
attributes ((Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
 -> IO (Maybe [CharAttributes]))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ \Ptr (GArray (Ptr CharAttributes))
attributes' -> do
        [Ptr CharAttributes]
attributes'' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes'
        [CharAttributes]
attributes''' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes''
        [CharAttributes] -> IO [CharAttributes]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [CharAttributes]
attributes'''
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Maybe Text, Maybe [CharAttributes])
-> IO (Maybe Text, Maybe [CharAttributes])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Maybe [CharAttributes]
maybeAttributes)

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

instance O.OverloadedMethodInfo TerminalGetTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetText"
        })


#endif

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

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

-- | Checks whether or not the terminal will allow blinking text.
-- 
-- /Since: 0.52/
terminalGetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.TextBlinkMode
    -- ^ __Returns:__ the blinking setting
terminalGetTextBlinkMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m TextBlinkMode
terminalGetTextBlinkMode a
terminal = IO TextBlinkMode -> m TextBlinkMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextBlinkMode -> m TextBlinkMode)
-> IO TextBlinkMode -> m TextBlinkMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_text_blink_mode Ptr Terminal
terminal'
    let result' :: TextBlinkMode
result' = (Int -> TextBlinkMode
forall a. Enum a => Int -> a
toEnum (Int -> TextBlinkMode) -> (CUInt -> Int) -> CUInt -> TextBlinkMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    TextBlinkMode -> IO TextBlinkMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextBlinkMode
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextBlinkModeMethodInfo
instance (signature ~ (m Vte.Enums.TextBlinkMode), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalGetTextBlinkMode

instance O.OverloadedMethodInfo TerminalGetTextBlinkModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextBlinkMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextBlinkMode"
        })


#endif

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

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

-- | Returns text from the visible part of the terminal in the specified format.
-- 
-- This method is unaware of BiDi. The columns returned in /@attributes@/ are
-- logical columns.
-- 
-- /Since: 0.76/
terminalGetTextFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Format
    -- ^ /@format@/: the t'GI.Vte.Enums.Format' to use
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetTextFormat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Format -> m (Maybe Text)
terminalGetTextFormat a
terminal Format
format = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
    CString
result <- Ptr Terminal -> CUInt -> IO CString
vte_terminal_get_text_format Ptr Terminal
terminal' CUInt
format'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextFormatMethodInfo
instance (signature ~ (Vte.Enums.Format -> m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextFormatMethodInfo a signature where
    overloadedMethod = terminalGetTextFormat

instance O.OverloadedMethodInfo TerminalGetTextFormatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextFormat"
        })


#endif

-- method Terminal::get_text_include_trailing_spaces
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_selected"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "SelectionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #VteSelectionFunc callback. Deprecated: 0.44: Always pass %NULL here."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to be passed to the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TGArray
--                 (TInterface Name { namespace = "Vte" , name = "CharAttributes" })
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location for storing text attributes. Deprecated: 0.68: Always pass %NULL here."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

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

{-# DEPRECATED terminalGetTextIncludeTrailingSpaces ["(Since version 0.56)","Use 'GI.Vte.Objects.Terminal.terminalGetTextFormat' instead."] #-}
-- | Extracts a view of the visible part of the terminal.
-- 
-- This method is unaware of BiDi. The columns returned in /@attributes@/ are
-- logical columns.
-- 
-- Note: since 0.68, passing a non-'P.Nothing' /@array@/ parameter is deprecated. Starting with
-- 0.72, passing a non-'P.Nothing' /@array@/ parameter will make this function itself return 'P.Nothing'.
-- Since 0.72, passing a non-'P.Nothing' /@isSelected@/ parameter will make this function itself return 'P.Nothing'.
terminalGetTextIncludeTrailingSpaces ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback. Deprecated: 0.44: Always pass 'P.Nothing' here.
    -> m ((T.Text, Maybe [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetTextIncludeTrailingSpaces :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe SelectionFunc -> m (Text, Maybe [CharAttributes])
terminalGetTextIncludeTrailingSpaces a
terminal Maybe SelectionFunc
isSelected = IO (Text, Maybe [CharAttributes])
-> m (Text, Maybe [CharAttributes])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Maybe [CharAttributes])
 -> m (Text, Maybe [CharAttributes]))
-> IO (Text, Maybe [CharAttributes])
-> m (Text, Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text_include_trailing_spaces Ptr Terminal
terminal' FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalGetTextIncludeTrailingSpaces" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    Maybe [CharAttributes]
maybeAttributes <- Ptr (GArray (Ptr CharAttributes))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GArray (Ptr CharAttributes))
attributes ((Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
 -> IO (Maybe [CharAttributes]))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ \Ptr (GArray (Ptr CharAttributes))
attributes' -> do
        [Ptr CharAttributes]
attributes'' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes'
        [CharAttributes]
attributes''' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes''
        [CharAttributes] -> IO [CharAttributes]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [CharAttributes]
attributes'''
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Text, Maybe [CharAttributes]) -> IO (Text, Maybe [CharAttributes])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Maybe [CharAttributes]
maybeAttributes)

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

instance O.OverloadedMethodInfo TerminalGetTextIncludeTrailingSpacesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextIncludeTrailingSpaces",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextIncludeTrailingSpaces"
        })


#endif

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

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

{-# DEPRECATED terminalGetTextRange ["(Since version 0.76)","Use 'GI.Vte.Objects.Terminal.terminalGetTextRangeFormat' instead"] #-}
-- | Extracts a view of the visible part of the terminal. The
-- entire scrollback buffer is scanned, so it is possible to read the entire
-- contents of the buffer using this function.
-- 
-- This method is unaware of BiDi. The columns passed in /@startCol@/ and /@endRow@/,
-- and returned in /@attributes@/ are logical columns.
-- 
-- Since 0.68, passing a non-'P.Nothing' /@array@/ parameter is deprecated.
-- Since 0.72, passing a non-'P.Nothing' /@array@/ parameter will make this function
--   itself return 'P.Nothing'.
-- Since 0.72, passing a non-'P.Nothing' /@isSelected@/ function will make this function
--   itself return 'P.Nothing'.
terminalGetTextRange ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> FCT.CLong
    -- ^ /@startRow@/: first row to search for data
    -> FCT.CLong
    -- ^ /@startCol@/: first column to search for data
    -> FCT.CLong
    -- ^ /@endRow@/: last row to search for data
    -> FCT.CLong
    -- ^ /@endCol@/: last column to search for data
    -> Maybe (Vte.Callbacks.SelectionFunc)
    -- ^ /@isSelected@/: a t'GI.Vte.Callbacks.SelectionFunc' callback. Deprecated: 0.44: Always pass 'P.Nothing' here
    -> m ((Maybe T.Text, Maybe [Vte.CharAttributes.CharAttributes]))
    -- ^ __Returns:__ a newly allocated text string, or 'P.Nothing'.
terminalGetTextRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a
-> CLong
-> CLong
-> CLong
-> CLong
-> Maybe SelectionFunc
-> m (Maybe Text, Maybe [CharAttributes])
terminalGetTextRange a
terminal CLong
startRow CLong
startCol CLong
endRow CLong
endCol Maybe SelectionFunc
isSelected = IO (Maybe Text, Maybe [CharAttributes])
-> m (Maybe Text, Maybe [CharAttributes])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Maybe [CharAttributes])
 -> m (Maybe Text, Maybe [CharAttributes]))
-> IO (Maybe Text, Maybe [CharAttributes])
-> m (Maybe Text, Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    FunPtr C_SelectionFunc
maybeIsSelected <- case Maybe SelectionFunc
isSelected of
        Maybe SelectionFunc
Nothing -> FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SelectionFunc
jIsSelected -> do
            FunPtr C_SelectionFunc
jIsSelected' <- C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
Vte.Callbacks.mk_SelectionFunc (Maybe (Ptr (FunPtr C_SelectionFunc))
-> SelectionFunc_WithClosures -> C_SelectionFunc
Vte.Callbacks.wrap_SelectionFunc Maybe (Ptr (FunPtr C_SelectionFunc))
forall a. Maybe a
Nothing (SelectionFunc -> SelectionFunc_WithClosures
Vte.Callbacks.drop_closures_SelectionFunc SelectionFunc
jIsSelected))
            FunPtr C_SelectionFunc -> IO (FunPtr C_SelectionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SelectionFunc
jIsSelected'
    Ptr (GArray (Ptr CharAttributes))
attributes <- CUInt -> IO (Ptr (GArray (Ptr CharAttributes)))
forall a. CUInt -> IO (Ptr (GArray a))
B.GArray.allocGArray CUInt
40 :: IO (Ptr (GArray (Ptr Vte.CharAttributes.CharAttributes)))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
result <- Ptr Terminal
-> CLong
-> CLong
-> CLong
-> CLong
-> FunPtr C_SelectionFunc
-> Ptr ()
-> Ptr (GArray (Ptr CharAttributes))
-> IO CString
vte_terminal_get_text_range Ptr Terminal
terminal' CLong
startRow CLong
startCol CLong
endRow CLong
endCol FunPtr C_SelectionFunc
maybeIsSelected Ptr ()
forall a. Ptr a
userData Ptr (GArray (Ptr CharAttributes))
attributes
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    Maybe [CharAttributes]
maybeAttributes <- Ptr (GArray (Ptr CharAttributes))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GArray (Ptr CharAttributes))
attributes ((Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
 -> IO (Maybe [CharAttributes]))
-> (Ptr (GArray (Ptr CharAttributes)) -> IO [CharAttributes])
-> IO (Maybe [CharAttributes])
forall a b. (a -> b) -> a -> b
$ \Ptr (GArray (Ptr CharAttributes))
attributes' -> do
        [Ptr CharAttributes]
attributes'' <- Ptr (GArray (Ptr CharAttributes)) -> IO [Ptr CharAttributes]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray (Ptr CharAttributes))
attributes'
        [CharAttributes]
attributes''' <- (Ptr CharAttributes -> IO CharAttributes)
-> [Ptr CharAttributes] -> IO [CharAttributes]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr CharAttributes -> CharAttributes)
-> Ptr CharAttributes -> IO CharAttributes
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CharAttributes -> CharAttributes
Vte.CharAttributes.CharAttributes) [Ptr CharAttributes]
attributes''
        [CharAttributes] -> IO [CharAttributes]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [CharAttributes]
attributes'''
    Ptr (GArray (Ptr CharAttributes)) -> IO ()
forall a. Ptr (GArray a) -> IO ()
unrefGArray Ptr (GArray (Ptr CharAttributes))
attributes
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SelectionFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SelectionFunc
maybeIsSelected
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    (Maybe Text, Maybe [CharAttributes])
-> IO (Maybe Text, Maybe [CharAttributes])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Maybe [CharAttributes]
maybeAttributes)

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

instance O.OverloadedMethodInfo TerminalGetTextRangeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextRange",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextRange"
        })


#endif

-- method Terminal::get_text_range_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType = TInterface Name { namespace = "Vte" , name = "Format" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VteFormat to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_row"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first row of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_col"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first column of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_row"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the last row of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_col"
--           , argType = TBasicType TLong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the last column of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to a #gsize to store the string length"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_range_format" vte_terminal_get_text_range_format :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Vte", name = "Format"})
    FCT.CLong ->                            -- start_row : TBasicType TLong
    FCT.CLong ->                            -- start_col : TBasicType TLong
    FCT.CLong ->                            -- end_row : TBasicType TLong
    FCT.CLong ->                            -- end_col : TBasicType TLong
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    IO CString

-- | Returns the specified range of text in the specified format.
-- 
-- /Since: 0.72/
terminalGetTextRangeFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Format
    -- ^ /@format@/: the t'GI.Vte.Enums.Format' to use
    -> FCT.CLong
    -- ^ /@startRow@/: the first row of the range
    -> FCT.CLong
    -- ^ /@startCol@/: the first column of the range
    -> FCT.CLong
    -- ^ /@endRow@/: the last row of the range
    -> FCT.CLong
    -- ^ /@endCol@/: the last column of the range
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ a newly allocated string, or 'P.Nothing'.
terminalGetTextRangeFormat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a
-> Format
-> CLong
-> CLong
-> CLong
-> CLong
-> m (Maybe Text, CSize)
terminalGetTextRangeFormat a
terminal Format
format CLong
startRow CLong
startCol CLong
endRow CLong
endCol = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
    Ptr CSize
length_ <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal
-> CUInt
-> CLong
-> CLong
-> CLong
-> CLong
-> Ptr CSize
-> IO CString
vte_terminal_get_text_range_format Ptr Terminal
terminal' CUInt
format' CLong
startRow CLong
startCol CLong
endRow CLong
endCol Ptr CSize
length_
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
length_' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
length_
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
length_')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextRangeFormatMethodInfo
instance (signature ~ (Vte.Enums.Format -> FCT.CLong -> FCT.CLong -> FCT.CLong -> FCT.CLong -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextRangeFormatMethodInfo a signature where
    overloadedMethod = terminalGetTextRangeFormat

instance O.OverloadedMethodInfo TerminalGetTextRangeFormatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextRangeFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextRangeFormat"
        })


#endif

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

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

-- | Gets the currently selected text in the format specified by /@format@/.
-- Since 0.72, this function also supports 'GI.Vte.Enums.FormatHtml' format.
-- 
-- /Since: 0.70/
terminalGetTextSelected ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Format
    -- ^ /@format@/: the t'GI.Vte.Enums.Format' to use
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a newly allocated string containing the selected text, or 'P.Nothing' if there is no selection or the format is not supported
terminalGetTextSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Format -> m (Maybe Text)
terminalGetTextSelected a
terminal Format
format = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
    CString
result <- Ptr Terminal -> CUInt -> IO CString
vte_terminal_get_text_selected Ptr Terminal
terminal' CUInt
format'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextSelectedMethodInfo
instance (signature ~ (Vte.Enums.Format -> m (Maybe T.Text)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextSelectedMethodInfo a signature where
    overloadedMethod = terminalGetTextSelected

instance O.OverloadedMethodInfo TerminalGetTextSelectedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextSelected",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextSelected"
        })


#endif

-- method Terminal::get_text_selected_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType = TInterface Name { namespace = "Vte" , name = "Format" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VteFormat to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TSize
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to a #gsize to store the string length"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_text_selected_full" vte_terminal_get_text_selected_full :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Vte", name = "Format"})
    Ptr FCT.CSize ->                        -- length : TBasicType TSize
    IO CString

-- | Gets the currently selected text in the format specified by /@format@/.
-- 
-- /Since: 0.72/
terminalGetTextSelectedFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Format
    -- ^ /@format@/: the t'GI.Vte.Enums.Format' to use
    -> m ((Maybe T.Text, FCT.CSize))
    -- ^ __Returns:__ a newly allocated string containing the selected text, or 'P.Nothing' if there is no selection or the format is not supported
terminalGetTextSelectedFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Format -> m (Maybe Text, CSize)
terminalGetTextSelectedFull a
terminal Format
format = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
    Ptr CSize
length_ <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
    CString
result <- Ptr Terminal -> CUInt -> Ptr CSize -> IO CString
vte_terminal_get_text_selected_full Ptr Terminal
terminal' CUInt
format' Ptr CSize
length_
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    CSize
length_' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
length_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
length_
    (Maybe Text, CSize) -> IO (Maybe Text, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, CSize
length_')

#if defined(ENABLE_OVERLOADING)
data TerminalGetTextSelectedFullMethodInfo
instance (signature ~ (Vte.Enums.Format -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetTextSelectedFullMethodInfo a signature where
    overloadedMethod = terminalGetTextSelectedFull

instance O.OverloadedMethodInfo TerminalGetTextSelectedFullMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetTextSelectedFull",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetTextSelectedFull"
        })


#endif

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

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

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

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

instance O.OverloadedMethodInfo TerminalGetWindowTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetWindowTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetWindowTitle"
        })


#endif

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

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

-- | Returns the set of characters which will be considered parts of a word
-- when doing word-wise selection, in addition to the default which only
-- considers alphanumeric characters part of a word.
-- 
-- If 'P.Nothing', a built-in set is used.
-- 
-- /Since: 0.40/
terminalGetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a string, or 'P.Nothing'
terminalGetWordCharExceptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m (Maybe Text)
terminalGetWordCharExceptions a
terminal = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
result <- Ptr Terminal -> IO CString
vte_terminal_get_word_char_exceptions Ptr Terminal
terminal'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo TerminalGetWordCharExceptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetWordCharExceptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetWordCharExceptions"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.Align
    -- ^ __Returns:__ the horizontal alignment of /@terminal@/ within its allocation
terminalGetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Align
terminalGetXalign a
terminal = IO Align -> m Align
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Align -> m Align) -> IO Align -> m Align
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_xalign Ptr Terminal
terminal'
    let result' :: Align
result' = (Int -> Align
forall a. Enum a => Int -> a
toEnum (Int -> Align) -> (CUInt -> Int) -> CUInt -> Align
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Align -> IO Align
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Align
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetXalignMethodInfo
instance (signature ~ (m Vte.Enums.Align), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetXalignMethodInfo a signature where
    overloadedMethod = terminalGetXalign

instance O.OverloadedMethodInfo TerminalGetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetXalign"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetXfill ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ the horizontal fillment of /@terminal@/ within its allocation
terminalGetXfill :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetXfill a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_xfill Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetXfillMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetXfillMethodInfo a signature where
    overloadedMethod = terminalGetXfill

instance O.OverloadedMethodInfo TerminalGetXfillMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetXfill",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetXfill"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Enums.Align
    -- ^ __Returns:__ the vertical alignment of /@terminal@/ within its allocation
terminalGetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Align
terminalGetYalign a
terminal = IO Align -> m Align
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Align -> m Align) -> IO Align -> m Align
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CUInt
result <- Ptr Terminal -> IO CUInt
vte_terminal_get_yalign Ptr Terminal
terminal'
    let result' :: Align
result' = (Int -> Align
forall a. Enum a => Int -> a
toEnum (Int -> Align) -> (CUInt -> Int) -> CUInt -> Align
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Align -> IO Align
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Align
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetYalignMethodInfo
instance (signature ~ (m Vte.Enums.Align), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetYalignMethodInfo a signature where
    overloadedMethod = terminalGetYalign

instance O.OverloadedMethodInfo TerminalGetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetYalign"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.76/
terminalGetYfill ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ the vertical fillment of /@terminal@/ within its allocation
terminalGetYfill :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalGetYfill a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_get_yfill Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalGetYfillMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalGetYfillMethodInfo a signature where
    overloadedMethod = terminalGetYfill

instance O.OverloadedMethodInfo TerminalGetYfillMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalGetYfill",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalGetYfill"
        })


#endif

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

foreign import ccall "vte_terminal_hyperlink_check_event" vte_terminal_hyperlink_check_event :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CString

-- | Returns a nonempty string: the target of the explicit hyperlink (printed using the OSC 8
-- escape sequence) at the position of the event, or 'P.Nothing'.
-- 
-- Proper use of the escape sequence should result in URI-encoded URIs with a proper scheme
-- like \"http:\/\/\", \"https:\/\/\", \"file:\/\/\", \"mailto:\" etc. This is, however, not enforced by VTE.
-- The caller must tolerate the returned string potentially not being a valid URI.
-- 
-- /Since: 0.50/
terminalHyperlinkCheckEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.Event.Event
    -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a newly allocated string containing the target of the hyperlink,
    --  or 'P.Nothing'
terminalHyperlinkCheckEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Event -> m (Maybe Text)
terminalHyperlinkCheckEvent a
terminal Event
event = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    CString
result <- Ptr Terminal -> Ptr Event -> IO CString
vte_terminal_hyperlink_check_event Ptr Terminal
terminal' Ptr Event
event'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo TerminalHyperlinkCheckEventMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalHyperlinkCheckEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalHyperlinkCheckEvent"
        })


#endif

-- method Terminal::match_add_gregex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gregex"
--           , argType = TInterface Name { namespace = "GLib" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GRegex" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gflags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "RegexMatchFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GRegexMatchFlags to use when matching the regex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_gregex" vte_terminal_match_add_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO Int32

{-# DEPRECATED terminalMatchAddGregex ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' instead."] #-}
-- | This function does nothing since version 0.60.
terminalMatchAddGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> GLib.Regex.Regex
    -- ^ /@gregex@/: a t'GI.GLib.Structs.Regex.Regex'
    -> [GLib.Flags.RegexMatchFlags]
    -- ^ /@gflags@/: the t'GI.GLib.Flags.RegexMatchFlags' to use when matching the regex
    -> m Int32
    -- ^ __Returns:__ -1
terminalMatchAddGregex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Regex -> [RegexMatchFlags] -> m Int32
terminalMatchAddGregex a
terminal Regex
gregex [RegexMatchFlags]
gflags = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
gregex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
gregex
    let gflags' :: CUInt
gflags' = [RegexMatchFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RegexMatchFlags]
gflags
    Int32
result <- Ptr Terminal -> Ptr Regex -> CUInt -> IO Int32
vte_terminal_match_add_gregex Ptr Terminal
terminal' Ptr Regex
gregex' CUInt
gflags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Regex
gregex
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TerminalMatchAddGregexMethodInfo
instance (signature ~ (GLib.Regex.Regex -> [GLib.Flags.RegexMatchFlags] -> m Int32), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchAddGregexMethodInfo a signature where
    overloadedMethod = terminalMatchAddGregex

instance O.OverloadedMethodInfo TerminalMatchAddGregexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchAddGregex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchAddGregex"
        })


#endif

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

foreign import ccall "vte_terminal_match_add_regex" vte_terminal_match_add_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO Int32

-- | Adds the regular expression /@regex@/ to the list of matching expressions.  When the
-- user moves the mouse cursor over a section of displayed text which matches
-- this expression, the text will be highlighted.
-- 
-- Note that /@regex@/ should have been created using the \<literal>PCRE2_MULTILINE\<\/literal>
-- flag.
-- 
-- /Since: 0.46/
terminalMatchAddRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Regex.Regex
    -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
    -> Word32
    -- ^ /@flags@/: PCRE2 match flags, or 0
    -> m Int32
    -- ^ __Returns:__ an integer associated with this expression
terminalMatchAddRegex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Regex -> Word32 -> m Int32
terminalMatchAddRegex a
terminal Regex
regex Word32
flags = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
regex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
regex
    Int32
result <- Ptr Terminal -> Ptr Regex -> Word32 -> IO Int32
vte_terminal_match_add_regex Ptr Terminal
terminal' Ptr Regex
regex' Word32
flags
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Regex
regex
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TerminalMatchAddRegexMethodInfo
instance (signature ~ (Vte.Regex.Regex -> Word32 -> m Int32), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchAddRegexMethodInfo a signature where
    overloadedMethod = terminalMatchAddRegex

instance O.OverloadedMethodInfo TerminalMatchAddRegexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchAddRegex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchAddRegex"
        })


#endif

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

foreign import ccall "vte_terminal_match_check" vte_terminal_match_check :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    FCT.CLong ->                            -- column : TBasicType TLong
    FCT.CLong ->                            -- row : TBasicType TLong
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

{-# DEPRECATED terminalMatchCheck ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchCheckEvent' instead."] #-}
-- | Checks if the text in and around the specified position matches any of the
-- regular expressions previously set using @/vte_terminal_match_add()/@.  If a
-- match exists, the text string is returned and if /@tag@/ is not 'P.Nothing', the number
-- associated with the matched regular expression will be stored in /@tag@/.
-- 
-- If more than one regular expression has been set with
-- @/vte_terminal_match_add()/@, then expressions are checked in the order in
-- which they were added.
terminalMatchCheck ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> FCT.CLong
    -- ^ /@column@/: the text column
    -> FCT.CLong
    -- ^ /@row@/: the text row
    -> m ((Maybe T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions
terminalMatchCheck :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> CLong -> m (Maybe Text, Int32)
terminalMatchCheck a
terminal CLong
column CLong
row = IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Int32) -> m (Maybe Text, Int32))
-> IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Int32
tag <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CString
result <- Ptr Terminal -> CLong -> CLong -> Ptr Int32 -> IO CString
vte_terminal_match_check Ptr Terminal
terminal' CLong
column CLong
row Ptr Int32
tag
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    Int32
tag' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
tag
    (Maybe Text, Int32) -> IO (Maybe Text, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Int32
tag')

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

instance O.OverloadedMethodInfo TerminalMatchCheckMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchCheck",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchCheck"
        })


#endif

-- method Terminal::match_check_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the tag, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check_event" vte_terminal_match_check_event :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

-- | Checks if the text in and around the position of the event matches any of the
-- regular expressions previously set using @/vte_terminal_match_add()/@.  If a
-- match exists, the text string is returned and if /@tag@/ is not 'P.Nothing', the number
-- associated with the matched regular expression will be stored in /@tag@/.
-- 
-- If more than one regular expression has been set with
-- @/vte_terminal_match_add()/@, then expressions are checked in the order in
-- which they were added.
terminalMatchCheckEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.Event.Event
    -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
    -> m ((Maybe T.Text, Int32))
    -- ^ __Returns:__ a newly allocated string which matches one of the previously
    --   set regular expressions, or 'P.Nothing' if there is no match
terminalMatchCheckEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Event -> m (Maybe Text, Int32)
terminalMatchCheckEvent a
terminal Event
event = IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Int32) -> m (Maybe Text, Int32))
-> IO (Maybe Text, Int32) -> m (Maybe Text, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    Ptr Int32
tag <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CString
result <- Ptr Terminal -> Ptr Event -> Ptr Int32 -> IO CString
vte_terminal_match_check_event Ptr Terminal
terminal' Ptr Event
event' Ptr Int32
tag
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    Int32
tag' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
tag
    (Maybe Text, Int32) -> IO (Maybe Text, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Int32
tag')

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

instance O.OverloadedMethodInfo TerminalMatchCheckEventMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchCheckEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchCheckEvent"
        })


#endif

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

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

-- | Removes the regular expression which is associated with the given /@tag@/ from
-- the list of expressions which the terminal will highlight when the user
-- moves the mouse cursor over matching text.
terminalMatchRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex to remove
    -> m ()
terminalMatchRemove :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m ()
terminalMatchRemove a
terminal Int32
tag = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> TerminalChildExitedCallback
vte_terminal_match_remove Ptr Terminal
terminal' Int32
tag
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchRemoveMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchRemoveMethodInfo a signature where
    overloadedMethod = terminalMatchRemove

instance O.OverloadedMethodInfo TerminalMatchRemoveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchRemove",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchRemove"
        })


#endif

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

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

-- | Clears the list of regular expressions the terminal uses to highlight text
-- when the user moves the mouse cursor.
terminalMatchRemoveAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalMatchRemoveAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalMatchRemoveAll a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_match_remove_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchRemoveAllMethodInfo a signature where
    overloadedMethod = terminalMatchRemoveAll

instance O.OverloadedMethodInfo TerminalMatchRemoveAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchRemoveAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchRemoveAll"
        })


#endif

-- method Terminal::match_set_cursor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Cursor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GdkCursor which the terminal should use when the pattern is\n  highlighted, or %NULL to use the standard cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor" vte_terminal_match_set_cursor :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
    IO ()

{-# DEPRECATED terminalMatchSetCursor ["(Since version 0.40)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}
-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.  The terminal keeps a reference to /@cursor@/.
terminalMatchSetCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> Maybe (b)
    -- ^ /@cursor@/: the t'GI.Gdk.Objects.Cursor.Cursor' which the terminal should use when the pattern is
    --   highlighted, or 'P.Nothing' to use the standard cursor
    -> m ()
terminalMatchSetCursor :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCursor b) =>
a -> Int32 -> Maybe b -> m ()
terminalMatchSetCursor a
terminal Int32
tag Maybe b
cursor = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Cursor
maybeCursor <- case Maybe b
cursor of
        Maybe b
Nothing -> Ptr Cursor -> IO (Ptr Cursor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cursor
forall a. Ptr a
FP.nullPtr
        Just b
jCursor -> do
            Ptr Cursor
jCursor' <- b -> IO (Ptr Cursor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCursor
            Ptr Cursor -> IO (Ptr Cursor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cursor
jCursor'
    Ptr Terminal -> Int32 -> Ptr Cursor -> IO ()
vte_terminal_match_set_cursor Ptr Terminal
terminal' Int32
tag Ptr Cursor
maybeCursor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cursor b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchSetCursorMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) => O.OverloadedMethod TerminalMatchSetCursorMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursor

instance O.OverloadedMethodInfo TerminalMatchSetCursorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchSetCursor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchSetCursor"
        })


#endif

-- method Terminal::match_set_cursor_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_name" vte_terminal_match_set_cursor_name :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CString ->                              -- cursor_name : TBasicType TUTF8
    IO ()

-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.
terminalMatchSetCursorName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> T.Text
    -- ^ /@cursorName@/: the name of the cursor
    -> m ()
terminalMatchSetCursorName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> Text -> m ()
terminalMatchSetCursorName a
terminal Int32
tag Text
cursorName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
cursorName' <- Text -> IO CString
textToCString Text
cursorName
    Ptr Terminal -> Int32 -> CString -> IO ()
vte_terminal_match_set_cursor_name Ptr Terminal
terminal' Int32
tag CString
cursorName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
cursorName'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TerminalMatchSetCursorNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchSetCursorName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchSetCursorName"
        })


#endif

-- method Terminal::match_set_cursor_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the tag of the regex which should use the specified cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_type"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "CursorType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkCursorType" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_type" vte_terminal_match_set_cursor_type :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CInt ->                                 -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})
    IO ()

{-# DEPRECATED terminalMatchSetCursorType ["(Since version 0.54)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}
-- | Sets which cursor the terminal will use if the pointer is over the pattern
-- specified by /@tag@/.
terminalMatchSetCursorType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@tag@/: the tag of the regex which should use the specified cursor
    -> Gdk.Enums.CursorType
    -- ^ /@cursorType@/: a t'GI.Gdk.Enums.CursorType'
    -> m ()
terminalMatchSetCursorType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> CursorType -> m ()
terminalMatchSetCursorType a
terminal Int32
tag CursorType
cursorType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let cursorType' :: CInt
cursorType' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (CursorType -> Int) -> CursorType -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorType -> Int
forall a. Enum a => a -> Int
fromEnum) CursorType
cursorType
    Ptr Terminal -> Int32 -> CInt -> IO ()
vte_terminal_match_set_cursor_type Ptr Terminal
terminal' Int32
tag CInt
cursorType'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalMatchSetCursorTypeMethodInfo
instance (signature ~ (Int32 -> Gdk.Enums.CursorType -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalMatchSetCursorTypeMethodInfo a signature where
    overloadedMethod = terminalMatchSetCursorType

instance O.OverloadedMethodInfo TerminalMatchSetCursorTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalMatchSetCursorType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalMatchSetCursorType"
        })


#endif

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

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

-- | Sends the contents of the @/GDK_SELECTION_CLIPBOARD/@ selection to the
-- terminal\'s child. It\'s called on paste menu item, or when
-- user presses Shift+Insert.
terminalPasteClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalPasteClipboard :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalPasteClipboard a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_paste_clipboard Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalPasteClipboardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalPasteClipboardMethodInfo a signature where
    overloadedMethod = terminalPasteClipboard

instance O.OverloadedMethodInfo TerminalPasteClipboardMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalPasteClipboard",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalPasteClipboard"
        })


#endif

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

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

-- | Sends the contents of the @/GDK_SELECTION_PRIMARY/@ selection to the terminal\'s
-- child. The terminal will call also paste the
-- @/GDK_SELECTION_PRIMARY/@ selection when the user clicks with the the second
-- mouse button.
terminalPastePrimary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalPastePrimary :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalPastePrimary a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_paste_primary Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalPastePrimaryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalPastePrimaryMethodInfo a signature where
    overloadedMethod = terminalPastePrimary

instance O.OverloadedMethodInfo TerminalPastePrimaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalPastePrimary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalPastePrimary"
        })


#endif

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

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

-- | Sends /@text@/ to the terminal\'s child as if retrived from the clipboard,
-- this differs from 'GI.Vte.Objects.Terminal.terminalFeedChild' in that it may process
-- /@text@/ before passing it to the child (e.g. apply bracketed mode)
-- 
-- /Since: 0.68/
terminalPasteText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@text@/: a string to paste
    -> m ()
terminalPasteText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m ()
terminalPasteText a
terminal Text
text = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr Terminal -> CString -> IO ()
vte_terminal_paste_text Ptr Terminal
terminal' CString
text'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalPasteTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalPasteTextMethodInfo a signature where
    overloadedMethod = terminalPasteText

instance O.OverloadedMethodInfo TerminalPasteTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalPasteText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalPasteText"
        })


#endif

-- method Terminal::pty_new_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vte" , name = "Pty" })
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_pty_new_sync" vte_terminal_pty_new_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Vte.Pty.Pty)

-- | Creates a new t'GI.Vte.Objects.Pty.Pty', sets the emulation property
-- from t'GI.Vte.Objects.Terminal.Terminal':@/emulation/@, and sets the size using
-- /@terminal@/\'s size.
-- 
-- See @/vte_pty_new()/@ for more information.
terminalPtyNewSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@flags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m Vte.Pty.Pty
    -- ^ __Returns:__ a new t'GI.Vte.Objects.Pty.Pty' /(Can throw 'Data.GI.Base.GError.GError')/
terminalPtyNewSync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a -> [PtyFlags] -> Maybe b -> m Pty
terminalPtyNewSync a
terminal [PtyFlags]
flags Maybe b
cancellable = IO Pty -> m Pty
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let flags' :: CUInt
flags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
flags
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO Pty -> IO () -> IO Pty
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Pty
result <- (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty))
-> (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Pty)
vte_terminal_pty_new_sync Ptr Terminal
terminal' CUInt
flags' Ptr Cancellable
maybeCancellable
        Text -> Ptr Pty -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalPtyNewSync" Ptr Pty
result
        Pty
result' <- ((ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pty -> Pty
Vte.Pty.Pty) Ptr Pty
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Pty -> IO Pty
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Pty
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TerminalPtyNewSyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (b) -> m Vte.Pty.Pty), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod TerminalPtyNewSyncMethodInfo a signature where
    overloadedMethod = terminalPtyNewSync

instance O.OverloadedMethodInfo TerminalPtyNewSyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalPtyNewSync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalPtyNewSync"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_data_bytes" vte_terminal_ref_termprop_data_bytes :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr GLib.Bytes.Bytes)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeData' termprop as a t'GI.GLib.Structs.Bytes.Bytes', or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalRefTermpropDataBytes ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe GLib.Bytes.Bytes)
    -- ^ __Returns:__ the property\'s value as a t'GI.GLib.Structs.Bytes.Bytes', or 'P.Nothing'
terminalRefTermpropDataBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Bytes)
terminalRefTermpropDataBytes a
terminal Text
prop = IO (Maybe Bytes) -> m (Maybe Bytes)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
-> IO (Maybe Bytes) -> m (Maybe Bytes)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Bytes
result <- Ptr Terminal -> CString -> IO (Ptr Bytes)
vte_terminal_ref_termprop_data_bytes Ptr Terminal
terminal' CString
prop'
    Maybe Bytes
maybeResult <- Ptr Bytes -> (Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Bytes
result ((Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes))
-> (Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes)
forall a b. (a -> b) -> a -> b
$ \Ptr Bytes
result' -> do
        Bytes
result'' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result'
        Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe Bytes -> IO (Maybe Bytes)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Bytes
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropDataBytesMethodInfo
instance (signature ~ (T.Text -> m (Maybe GLib.Bytes.Bytes)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropDataBytesMethodInfo a signature where
    overloadedMethod = terminalRefTermpropDataBytes

instance O.OverloadedMethodInfo TerminalRefTermpropDataBytesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropDataBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropDataBytes"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_data_bytes_by_id" vte_terminal_ref_termprop_data_bytes_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr GLib.Bytes.Bytes)

-- | Like 'GI.Vte.Objects.Terminal.terminalRefTermpropDataBytes' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalRefTermpropDataBytesById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe GLib.Bytes.Bytes)
    -- ^ __Returns:__ the property\'s value as a t'GI.GLib.Structs.Bytes.Bytes', or 'P.Nothing'
terminalRefTermpropDataBytesById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Bytes)
terminalRefTermpropDataBytesById a
terminal Int32
prop = IO (Maybe Bytes) -> m (Maybe Bytes)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
-> IO (Maybe Bytes) -> m (Maybe Bytes)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Bytes
result <- Ptr Terminal -> Int32 -> IO (Ptr Bytes)
vte_terminal_ref_termprop_data_bytes_by_id Ptr Terminal
terminal' Int32
prop
    Maybe Bytes
maybeResult <- Ptr Bytes -> (Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Bytes
result ((Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes))
-> (Ptr Bytes -> IO Bytes) -> IO (Maybe Bytes)
forall a b. (a -> b) -> a -> b
$ \Ptr Bytes
result' -> do
        Bytes
result'' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result'
        Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Bytes -> IO (Maybe Bytes)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Bytes
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropDataBytesByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe GLib.Bytes.Bytes)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropDataBytesByIdMethodInfo a signature where
    overloadedMethod = terminalRefTermpropDataBytesById

instance O.OverloadedMethodInfo TerminalRefTermpropDataBytesByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropDataBytesById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropDataBytesById"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_image_pixbuf" vte_terminal_ref_termprop_image_pixbuf :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeImage' termprop as a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.80/
terminalRefTermpropImagePixbuf ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    -- ^ __Returns:__ the property\'s value as a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'P.Nothing'
terminalRefTermpropImagePixbuf :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Pixbuf)
terminalRefTermpropImagePixbuf a
terminal Text
prop = IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pixbuf) -> m (Maybe Pixbuf))
-> IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Pixbuf
result <- Ptr Terminal -> CString -> IO (Ptr Pixbuf)
vte_terminal_ref_termprop_image_pixbuf Ptr Terminal
terminal' CString
prop'
    Maybe Pixbuf
maybeResult <- Ptr Pixbuf -> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pixbuf
result ((Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf))
-> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ \Ptr Pixbuf
result' -> do
        Pixbuf
result'' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result'
        Pixbuf -> IO Pixbuf
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe Pixbuf -> IO (Maybe Pixbuf)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pixbuf
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropImagePixbufMethodInfo
instance (signature ~ (T.Text -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropImagePixbufMethodInfo a signature where
    overloadedMethod = terminalRefTermpropImagePixbuf

instance O.OverloadedMethodInfo TerminalRefTermpropImagePixbufMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropImagePixbuf",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropImagePixbuf"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_image_pixbuf_by_id" vte_terminal_ref_termprop_image_pixbuf_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

-- | Like 'GI.Vte.Objects.Terminal.terminalRefTermpropImagePixbuf' except that it takes the
-- termprop by ID. See that function for more information.
-- 
-- /Since: 0.80/
terminalRefTermpropImagePixbufById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    -- ^ __Returns:__ the property\'s value as a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'P.Nothing'
terminalRefTermpropImagePixbufById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Pixbuf)
terminalRefTermpropImagePixbufById a
terminal Int32
prop = IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pixbuf) -> m (Maybe Pixbuf))
-> IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Pixbuf
result <- Ptr Terminal -> Int32 -> IO (Ptr Pixbuf)
vte_terminal_ref_termprop_image_pixbuf_by_id Ptr Terminal
terminal' Int32
prop
    Maybe Pixbuf
maybeResult <- Ptr Pixbuf -> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pixbuf
result ((Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf))
-> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ \Ptr Pixbuf
result' -> do
        Pixbuf
result'' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result'
        Pixbuf -> IO Pixbuf
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Pixbuf -> IO (Maybe Pixbuf)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pixbuf
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropImagePixbufByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropImagePixbufByIdMethodInfo a signature where
    overloadedMethod = terminalRefTermpropImagePixbufById

instance O.OverloadedMethodInfo TerminalRefTermpropImagePixbufByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropImagePixbufById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropImagePixbufById"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_image_surface" vte_terminal_ref_termprop_image_surface :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr Cairo.Surface.Surface)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeImage' termprop as a t'GI.Cairo.Structs.Surface.Surface',
--   or 'P.Nothing' if /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- The surface will be a 'GI.Cairo.Enums.SurfaceTypeImage' with format
-- 'GI.Cairo.Enums.FormatArgb32' or 'GI.Cairo.Enums.FormatRgb24'.
-- 
-- Note that the returned surface is owned by /@terminal@/ and its contents
-- must not be modified.
-- 
-- /Since: 0.80/
terminalRefTermpropImageSurface ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe Cairo.Surface.Surface)
    -- ^ __Returns:__ the property\'s value as a t'GI.Cairo.Structs.Surface.Surface', or 'P.Nothing'
terminalRefTermpropImageSurface :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Surface)
terminalRefTermpropImageSurface a
terminal Text
prop = IO (Maybe Surface) -> m (Maybe Surface)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Surface) -> m (Maybe Surface))
-> IO (Maybe Surface) -> m (Maybe Surface)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Surface
result <- Ptr Terminal -> CString -> IO (Ptr Surface)
vte_terminal_ref_termprop_image_surface Ptr Terminal
terminal' CString
prop'
    Maybe Surface
maybeResult <- Ptr Surface -> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Surface
result ((Ptr Surface -> IO Surface) -> IO (Maybe Surface))
-> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
forall a b. (a -> b) -> a -> b
$ \Ptr Surface
result' -> do
        Surface
result'' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Surface -> Surface
Cairo.Surface.Surface) Ptr Surface
result'
        Surface -> IO Surface
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Surface
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe Surface -> IO (Maybe Surface)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Surface
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropImageSurfaceMethodInfo
instance (signature ~ (T.Text -> m (Maybe Cairo.Surface.Surface)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropImageSurfaceMethodInfo a signature where
    overloadedMethod = terminalRefTermpropImageSurface

instance O.OverloadedMethodInfo TerminalRefTermpropImageSurfaceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropImageSurface",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropImageSurface"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_image_surface_by_id" vte_terminal_ref_termprop_image_surface_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr Cairo.Surface.Surface)

-- | Like 'GI.Vte.Objects.Terminal.terminalRefTermpropImageSurface' except that it takes the
-- termprop by ID. See that function for more information.
-- 
-- /Since: 0.80/
terminalRefTermpropImageSurfaceById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe Cairo.Surface.Surface)
    -- ^ __Returns:__ the property\'s value as a t'GI.Cairo.Structs.Surface.Surface', or 'P.Nothing'
terminalRefTermpropImageSurfaceById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Surface)
terminalRefTermpropImageSurfaceById a
terminal Int32
prop = IO (Maybe Surface) -> m (Maybe Surface)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Surface) -> m (Maybe Surface))
-> IO (Maybe Surface) -> m (Maybe Surface)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Surface
result <- Ptr Terminal -> Int32 -> IO (Ptr Surface)
vte_terminal_ref_termprop_image_surface_by_id Ptr Terminal
terminal' Int32
prop
    Maybe Surface
maybeResult <- Ptr Surface -> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Surface
result ((Ptr Surface -> IO Surface) -> IO (Maybe Surface))
-> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
forall a b. (a -> b) -> a -> b
$ \Ptr Surface
result' -> do
        Surface
result'' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Surface -> Surface
Cairo.Surface.Surface) Ptr Surface
result'
        Surface -> IO Surface
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Surface
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Surface -> IO (Maybe Surface)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Surface
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropImageSurfaceByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe Cairo.Surface.Surface)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropImageSurfaceByIdMethodInfo a signature where
    overloadedMethod = terminalRefTermpropImageSurfaceById

instance O.OverloadedMethodInfo TerminalRefTermpropImageSurfaceByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropImageSurfaceById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropImageSurfaceById"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_uri" vte_terminal_ref_termprop_uri :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr GLib.Uri.Uri)

-- | Returns the value of a 'GI.Vte.Enums.PropertyTypeUri' termprop as a t'GI.GLib.Structs.Uri.Uri', or 'P.Nothing' if
--   /@prop@/ is unset, or /@prop@/ is not a registered property.
-- 
-- /Since: 0.78/
terminalRefTermpropUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe GLib.Uri.Uri)
    -- ^ __Returns:__ the property\'s value as a t'GI.GLib.Structs.Uri.Uri', or 'P.Nothing'
terminalRefTermpropUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe Uri)
terminalRefTermpropUri a
terminal Text
prop = IO (Maybe Uri) -> m (Maybe Uri)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Uri) -> m (Maybe Uri))
-> IO (Maybe Uri) -> m (Maybe Uri)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr Uri
result <- Ptr Terminal -> CString -> IO (Ptr Uri)
vte_terminal_ref_termprop_uri Ptr Terminal
terminal' CString
prop'
    Maybe Uri
maybeResult <- Ptr Uri -> (Ptr Uri -> IO Uri) -> IO (Maybe Uri)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Uri
result ((Ptr Uri -> IO Uri) -> IO (Maybe Uri))
-> (Ptr Uri -> IO Uri) -> IO (Maybe Uri)
forall a b. (a -> b) -> a -> b
$ \Ptr Uri
result' -> do
        Uri
result'' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result'
        Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe Uri -> IO (Maybe Uri)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Uri
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropUriMethodInfo
instance (signature ~ (T.Text -> m (Maybe GLib.Uri.Uri)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropUriMethodInfo a signature where
    overloadedMethod = terminalRefTermpropUri

instance O.OverloadedMethodInfo TerminalRefTermpropUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropUri"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_uri_by_id" vte_terminal_ref_termprop_uri_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr GLib.Uri.Uri)

-- | Like 'GI.Vte.Objects.Terminal.terminalRefTermpropUri' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalRefTermpropUriById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe GLib.Uri.Uri)
    -- ^ __Returns:__ the property\'s value as a t'GI.GLib.Structs.Uri.Uri', or 'P.Nothing'
terminalRefTermpropUriById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe Uri)
terminalRefTermpropUriById a
terminal Int32
prop = IO (Maybe Uri) -> m (Maybe Uri)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Uri) -> m (Maybe Uri))
-> IO (Maybe Uri) -> m (Maybe Uri)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Uri
result <- Ptr Terminal -> Int32 -> IO (Ptr Uri)
vte_terminal_ref_termprop_uri_by_id Ptr Terminal
terminal' Int32
prop
    Maybe Uri
maybeResult <- Ptr Uri -> (Ptr Uri -> IO Uri) -> IO (Maybe Uri)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Uri
result ((Ptr Uri -> IO Uri) -> IO (Maybe Uri))
-> (Ptr Uri -> IO Uri) -> IO (Maybe Uri)
forall a b. (a -> b) -> a -> b
$ \Ptr Uri
result' -> do
        Uri
result'' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result'
        Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Uri -> IO (Maybe Uri)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Uri
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropUriByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe GLib.Uri.Uri)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropUriByIdMethodInfo a signature where
    overloadedMethod = terminalRefTermpropUriById

instance O.OverloadedMethodInfo TerminalRefTermpropUriByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropUriById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropUriById"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_variant" vte_terminal_ref_termprop_variant :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- prop : TBasicType TUTF8
    IO (Ptr GVariant)

-- | Returns the value of /@prop@/ as a t'GVariant', or 'P.Nothing' if
--   /@prop@/ unset, or /@prop@/ is not a registered property.
-- 
-- The t'GI.GLib.Structs.VariantType.VariantType' of the returned t'GVariant' depends on the termprop type:
-- * A 'GI.Vte.Enums.PropertyTypeValueless' termprop returns a @/G_VARIANT_TYPE_UNIT/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeBool' termprop returns a @/G_VARIANT_TYPE_BOOLEAN/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeInt' termprop returns a @/G_VARIANT_TYPE_INT64/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeUint' termprop returns a @/G_VARIANT_TYPE_UINT64/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeDouble' termprop returns a @/G_VARIANT_TYPE_DOUBLE/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeRgb' or 'GI.Vte.Enums.PropertyTypeRgba' termprop returns a \"(ddddv)\"
--   tuple containing the red, green, blue, and alpha (1.0 for 'GI.Vte.Enums.PropertyTypeRgb')
--   components of the color and a variant of unspecified contents
-- * A 'GI.Vte.Enums.PropertyTypeString' termprop returns a @/G_VARIANT_TYPE_STRING/@ variant.
-- * A 'GI.Vte.Enums.PropertyTypeData' termprop returns a \"ay\" variant (which is *not* a bytestring!).
-- * A 'GI.Vte.Enums.PropertyTypeUuid' termprop returns a @/G_VARIANT_TYPE_STRING/@ variant
--   containing a string representation of the UUID in simple form.
-- * A 'GI.Vte.Enums.PropertyTypeUri' termprop returns a @/G_VARIANT_TYPE_STRING/@ variant
--   containing a string representation of the URI
-- * A 'GI.Vte.Enums.PropertyTypeImage' termprop returns 'P.Nothing' since an image has no
--   variant representation.
-- 
-- /Since: 0.78/
terminalRefTermpropVariant ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@prop@/: a termprop name
    -> m (Maybe GVariant)
    -- ^ __Returns:__ a floating t'GVariant', or 'P.Nothing'
terminalRefTermpropVariant :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m (Maybe GVariant)
terminalRefTermpropVariant a
terminal Text
prop = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
prop' <- Text -> IO CString
textToCString Text
prop
    Ptr GVariant
result <- Ptr Terminal -> CString -> IO (Ptr GVariant)
vte_terminal_ref_termprop_variant Ptr Terminal
terminal' CString
prop'
    Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
        GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
        GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prop'
    Maybe GVariant -> IO (Maybe GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropVariantMethodInfo
instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropVariantMethodInfo a signature where
    overloadedMethod = terminalRefTermpropVariant

instance O.OverloadedMethodInfo TerminalRefTermpropVariantMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropVariant",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropVariant"
        })


#endif

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

foreign import ccall "vte_terminal_ref_termprop_variant_by_id" vte_terminal_ref_termprop_variant_by_id :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- prop : TBasicType TInt
    IO (Ptr GVariant)

-- | Like 'GI.Vte.Objects.Terminal.terminalRefTermpropVariant' except that it takes the termprop
-- by ID. See that function for more information.
-- 
-- /Since: 0.78/
terminalRefTermpropVariantById ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@prop@/: a termprop ID
    -> m (Maybe GVariant)
    -- ^ __Returns:__ a floating t'GVariant', or 'P.Nothing'
terminalRefTermpropVariantById :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m (Maybe GVariant)
terminalRefTermpropVariantById a
terminal Int32
prop = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr GVariant
result <- Ptr Terminal -> Int32 -> IO (Ptr GVariant)
vte_terminal_ref_termprop_variant_by_id Ptr Terminal
terminal' Int32
prop
    Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
        GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
        GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe GVariant -> IO (Maybe GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult

#if defined(ENABLE_OVERLOADING)
data TerminalRefTermpropVariantByIdMethodInfo
instance (signature ~ (Int32 -> m (Maybe GVariant)), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalRefTermpropVariantByIdMethodInfo a signature where
    overloadedMethod = terminalRefTermpropVariantById

instance O.OverloadedMethodInfo TerminalRefTermpropVariantByIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalRefTermpropVariantById",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalRefTermpropVariantById"
        })


#endif

-- method Terminal::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clear_tabstops"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to reset tabstops"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clear_history"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to empty the terminal's scrollback buffer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_reset" vte_terminal_reset :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- clear_tabstops : TBasicType TBoolean
    CInt ->                                 -- clear_history : TBasicType TBoolean
    IO ()

-- | Resets as much of the terminal\'s internal state as possible, discarding any
-- unprocessed input data, resetting character attributes, cursor state,
-- national character set state, status line, terminal modes (insert\/delete),
-- selection state, and encoding.
terminalReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@clearTabstops@/: whether to reset tabstops
    -> Bool
    -- ^ /@clearHistory@/: whether to empty the terminal\'s scrollback buffer
    -> m ()
terminalReset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> Bool -> m ()
terminalReset a
terminal Bool
clearTabstops Bool
clearHistory = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let clearTabstops' :: CInt
clearTabstops' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
clearTabstops
    let clearHistory' :: CInt
clearHistory' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
clearHistory
    Ptr Terminal -> CInt -> CInt -> IO ()
vte_terminal_reset Ptr Terminal
terminal' CInt
clearTabstops' CInt
clearHistory'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalResetMethodInfo
instance (signature ~ (Bool -> Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalResetMethodInfo a signature where
    overloadedMethod = terminalReset

instance O.OverloadedMethodInfo TerminalResetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalReset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalReset"
        })


#endif

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

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

-- | Searches the next string matching the search regex set with
-- 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
terminalSearchFindNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a match was found
terminalSearchFindNext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchFindNext a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_find_next Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchFindNextMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchFindNextMethodInfo a signature where
    overloadedMethod = terminalSearchFindNext

instance O.OverloadedMethodInfo TerminalSearchFindNextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchFindNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchFindNext"
        })


#endif

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

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

-- | Searches the previous string matching the search regex set with
-- 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
terminalSearchFindPrevious ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a match was found
terminalSearchFindPrevious :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchFindPrevious a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_find_previous Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchFindPreviousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchFindPreviousMethodInfo a signature where
    overloadedMethod = terminalSearchFindPrevious

instance O.OverloadedMethodInfo TerminalSearchFindPreviousMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchFindPrevious",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchFindPrevious"
        })


#endif

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

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

{-# DEPRECATED terminalSearchGetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchGetRegex' instead."] #-}
-- | /No description available in the introspection data./
terminalSearchGetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m GLib.Regex.Regex
    -- ^ __Returns:__ 'P.Nothing'
terminalSearchGetGregex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Regex
terminalSearchGetGregex a
terminal = IO Regex -> m Regex
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
result <- Ptr Terminal -> IO (Ptr Regex)
vte_terminal_search_get_gregex Ptr Terminal
terminal'
    Text -> Ptr Regex -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalSearchGetGregex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Regex -> Regex
GLib.Regex.Regex) Ptr Regex
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO Regex
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Regex
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetGregexMethodInfo
instance (signature ~ (m GLib.Regex.Regex), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchGetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchGetGregex

instance O.OverloadedMethodInfo TerminalSearchGetGregexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchGetGregex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchGetGregex"
        })


#endif

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

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

-- | /No description available in the introspection data./
-- 
-- /Since: 0.46/
terminalSearchGetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Vte.Regex.Regex
    -- ^ __Returns:__ the search t'GI.Vte.Structs.Regex.Regex' regex set in /@terminal@/, or 'P.Nothing'
terminalSearchGetRegex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Regex
terminalSearchGetRegex a
terminal = IO Regex -> m Regex
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
result <- Ptr Terminal -> IO (Ptr Regex)
vte_terminal_search_get_regex Ptr Terminal
terminal'
    Text -> Ptr Regex -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"terminalSearchGetRegex" Ptr Regex
result
    Regex
result' <- ((ManagedPtr Regex -> Regex) -> Ptr Regex -> IO Regex
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Regex -> Regex
Vte.Regex.Regex) Ptr Regex
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Regex -> IO Regex
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Regex
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetRegexMethodInfo
instance (signature ~ (m Vte.Regex.Regex), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchGetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchGetRegex

instance O.OverloadedMethodInfo TerminalSearchGetRegexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchGetRegex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchGetRegex"
        })


#endif

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

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

-- | /No description available in the introspection data./
terminalSearchGetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m Bool
    -- ^ __Returns:__ whether searching will wrap around
terminalSearchGetWrapAround :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m Bool
terminalSearchGetWrapAround a
terminal = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CInt
result <- Ptr Terminal -> IO CInt
vte_terminal_search_get_wrap_around Ptr Terminal
terminal'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TerminalSearchGetWrapAroundMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchGetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchGetWrapAround

instance O.OverloadedMethodInfo TerminalSearchGetWrapAroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchGetWrapAround",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchGetWrapAround"
        })


#endif

-- method Terminal::search_set_gregex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gregex"
--           , argType = TInterface Name { namespace = "GLib" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GRegex, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gflags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "RegexMatchFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GRegexMatchFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_gregex" vte_terminal_search_set_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO ()

{-# DEPRECATED terminalSearchSetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchSetRegex' instead."] #-}
-- | This function does nothing since version 0.60.
terminalSearchSetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (GLib.Regex.Regex)
    -- ^ /@gregex@/: a t'GI.GLib.Structs.Regex.Regex', or 'P.Nothing'
    -> [GLib.Flags.RegexMatchFlags]
    -- ^ /@gflags@/: flags from t'GI.GLib.Flags.RegexMatchFlags'
    -> m ()
terminalSearchSetGregex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Regex -> [RegexMatchFlags] -> m ()
terminalSearchSetGregex a
terminal Maybe Regex
gregex [RegexMatchFlags]
gflags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
maybeGregex <- case Maybe Regex
gregex of
        Maybe Regex
Nothing -> Ptr Regex -> IO (Ptr Regex)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
FP.nullPtr
        Just Regex
jGregex -> do
            Ptr Regex
jGregex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
jGregex
            Ptr Regex -> IO (Ptr Regex)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
jGregex'
    let gflags' :: CUInt
gflags' = [RegexMatchFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RegexMatchFlags]
gflags
    Ptr Terminal -> Ptr Regex -> CUInt -> IO ()
vte_terminal_search_set_gregex Ptr Terminal
terminal' Ptr Regex
maybeGregex CUInt
gflags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Regex -> (Regex -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Regex
gregex Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetGregexMethodInfo
instance (signature ~ (Maybe (GLib.Regex.Regex) -> [GLib.Flags.RegexMatchFlags] -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchSetGregexMethodInfo a signature where
    overloadedMethod = terminalSearchSetGregex

instance O.OverloadedMethodInfo TerminalSearchSetGregexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchSetGregex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchSetGregex"
        })


#endif

-- method Terminal::search_set_regex
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "regex"
--           , argType = TInterface Name { namespace = "Vte" , name = "Regex" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteRegex, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "PCRE2 match flags, or 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_regex" vte_terminal_search_set_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO ()

-- | Sets the regex to search for. Unsets the search regex when passed 'P.Nothing'.
-- 
-- Note that /@regex@/ should have been created using the
-- \<literal>PCRE2_MULTILINE\<\/literal> flag.
-- 
-- /Since: 0.46/
terminalSearchSetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Vte.Regex.Regex)
    -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing'
    -> Word32
    -- ^ /@flags@/: PCRE2 match flags, or 0
    -> m ()
terminalSearchSetRegex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Regex -> Word32 -> m ()
terminalSearchSetRegex a
terminal Maybe Regex
regex Word32
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Regex
maybeRegex <- case Maybe Regex
regex of
        Maybe Regex
Nothing -> Ptr Regex -> IO (Ptr Regex)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
forall a. Ptr a
FP.nullPtr
        Just Regex
jRegex -> do
            Ptr Regex
jRegex' <- Regex -> IO (Ptr Regex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Regex
jRegex
            Ptr Regex -> IO (Ptr Regex)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Regex
jRegex'
    Ptr Terminal -> Ptr Regex -> Word32 -> IO ()
vte_terminal_search_set_regex Ptr Terminal
terminal' Ptr Regex
maybeRegex Word32
flags
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe Regex -> (Regex -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Regex
regex Regex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetRegexMethodInfo
instance (signature ~ (Maybe (Vte.Regex.Regex) -> Word32 -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchSetRegexMethodInfo a signature where
    overloadedMethod = terminalSearchSetRegex

instance O.OverloadedMethodInfo TerminalSearchSetRegexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchSetRegex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchSetRegex"
        })


#endif

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

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

-- | Sets whether search should wrap around to the beginning of the
-- terminal content when reaching its end.
terminalSearchSetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@wrapAround@/: whether search should wrap
    -> m ()
terminalSearchSetWrapAround :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSearchSetWrapAround a
terminal Bool
wrapAround = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let wrapAround' :: CInt
wrapAround' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
wrapAround
    Ptr Terminal -> CInt -> IO ()
vte_terminal_search_set_wrap_around Ptr Terminal
terminal' CInt
wrapAround'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSearchSetWrapAroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSearchSetWrapAroundMethodInfo a signature where
    overloadedMethod = terminalSearchSetWrapAround

instance O.OverloadedMethodInfo TerminalSearchSetWrapAroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSearchSetWrapAround",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSearchSetWrapAround"
        })


#endif

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

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

-- | Selects all text within the terminal (not including the scrollback buffer).
terminalSelectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalSelectAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalSelectAll a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_select_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSelectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSelectAllMethodInfo a signature where
    overloadedMethod = terminalSelectAll

instance O.OverloadedMethodInfo TerminalSelectAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSelectAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSelectAll"
        })


#endif

-- method Terminal::set_allow_bold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_bold"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if the terminal should attempt to draw bold text"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

{-# DEPRECATED terminalSetAllowBold ["(Since version 0.60)","There\\'s probably no reason for this feature to exist."] #-}
-- | Controls whether or not the terminal will attempt to draw bold text,
-- by using a bold font variant.
terminalSetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@allowBold@/: 'P.True' if the terminal should attempt to draw bold text
    -> m ()
terminalSetAllowBold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAllowBold a
terminal Bool
allowBold = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let allowBold' :: CInt
allowBold' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
allowBold
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_allow_bold Ptr Terminal
terminal' CInt
allowBold'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAllowBoldMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetAllowBoldMethodInfo a signature where
    overloadedMethod = terminalSetAllowBold

instance O.OverloadedMethodInfo TerminalSetAllowBoldMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetAllowBold",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetAllowBold"
        })


#endif

-- method Terminal::set_allow_hyperlink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_hyperlink"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the terminal should allow hyperlinks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Controls whether or not hyperlinks (OSC 8 escape sequence) are allowed.
-- 
-- /Since: 0.50/
terminalSetAllowHyperlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@allowHyperlink@/: 'P.True' if the terminal should allow hyperlinks
    -> m ()
terminalSetAllowHyperlink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAllowHyperlink a
terminal Bool
allowHyperlink = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let allowHyperlink' :: CInt
allowHyperlink' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
allowHyperlink
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_allow_hyperlink Ptr Terminal
terminal' CInt
allowHyperlink'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAllowHyperlinkMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetAllowHyperlinkMethodInfo a signature where
    overloadedMethod = terminalSetAllowHyperlink

instance O.OverloadedMethodInfo TerminalSetAllowHyperlinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetAllowHyperlink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetAllowHyperlink"
        })


#endif

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

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

-- | Controls whether or not the terminal will beep when the child outputs the
-- \"bl\" sequence.
terminalSetAudibleBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@isAudible@/: 'P.True' if the terminal should beep
    -> m ()
terminalSetAudibleBell :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetAudibleBell a
terminal Bool
isAudible = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let isAudible' :: CInt
isAudible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isAudible
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_audible_bell Ptr Terminal
terminal' CInt
isAudible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetAudibleBellMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetAudibleBellMethodInfo a signature where
    overloadedMethod = terminalSetAudibleBell

instance O.OverloadedMethodInfo TerminalSetAudibleBellMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetAudibleBell",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetAudibleBell"
        })


#endif

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

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

-- | Modifies the terminal\'s backspace key binding, which controls what
-- string or control sequence the terminal sends to its child when the user
-- presses the backspace key.
terminalSetBackspaceBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.EraseBinding
    -- ^ /@binding@/: a t'GI.Vte.Enums.EraseBinding' for the backspace key
    -> m ()
terminalSetBackspaceBinding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> EraseBinding -> m ()
terminalSetBackspaceBinding a
terminal EraseBinding
binding = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let binding' :: CUInt
binding' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EraseBinding -> Int) -> EraseBinding -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EraseBinding -> Int
forall a. Enum a => a -> Int
fromEnum) EraseBinding
binding
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_backspace_binding Ptr Terminal
terminal' CUInt
binding'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetBackspaceBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetBackspaceBindingMethodInfo a signature where
    overloadedMethod = terminalSetBackspaceBinding

instance O.OverloadedMethodInfo TerminalSetBackspaceBindingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetBackspaceBinding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetBackspaceBinding"
        })


#endif

-- method Terminal::set_bold_is_bright
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bold_is_bright"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if bold should also enable bright"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the SGR 1 attribute also switches to the bright counterpart
-- of the first 8 palette colors, in addition to making them bold (legacy behavior)
-- or if SGR 1 only enables bold and leaves the color intact.
-- 
-- /Since: 0.52/
terminalSetBoldIsBright ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@boldIsBright@/: 'P.True' if bold should also enable bright
    -> m ()
terminalSetBoldIsBright :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetBoldIsBright a
terminal Bool
boldIsBright = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let boldIsBright' :: CInt
boldIsBright' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
boldIsBright
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_bold_is_bright Ptr Terminal
terminal' CInt
boldIsBright'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetBoldIsBrightMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetBoldIsBrightMethodInfo a signature where
    overloadedMethod = terminalSetBoldIsBright

instance O.OverloadedMethodInfo TerminalSetBoldIsBrightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetBoldIsBright",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetBoldIsBright"
        })


#endif

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

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

-- | Sets the terminal\'s cell height scale to /@scale@/.
-- 
-- This can be used to increase the line spacing. (The font\'s height is not affected.)
-- Valid values go from 1.0 (default) to 2.0 (\"double spacing\").
-- 
-- /Since: 0.52/
terminalSetCellHeightScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the cell height scale
    -> m ()
terminalSetCellHeightScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetCellHeightScale a
terminal Double
scale = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_cell_height_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCellHeightScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetCellHeightScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellHeightScale

instance O.OverloadedMethodInfo TerminalSetCellHeightScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetCellHeightScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetCellHeightScale"
        })


#endif

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

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

-- | Sets the terminal\'s cell width scale to /@scale@/.
-- 
-- This can be used to increase the letter spacing. (The font\'s width is not affected.)
-- Valid values go from 1.0 (default) to 2.0.
-- 
-- /Since: 0.52/
terminalSetCellWidthScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the cell width scale
    -> m ()
terminalSetCellWidthScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetCellWidthScale a
terminal Double
scale = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_cell_width_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCellWidthScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetCellWidthScaleMethodInfo a signature where
    overloadedMethod = terminalSetCellWidthScale

instance O.OverloadedMethodInfo TerminalSetCellWidthScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetCellWidthScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetCellWidthScale"
        })


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data TerminalSetCjkAmbiguousWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod = terminalSetCjkAmbiguousWidth

instance O.OverloadedMethodInfo TerminalSetCjkAmbiguousWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetCjkAmbiguousWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetCjkAmbiguousWidth"
        })


#endif

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

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

-- | Sets whether to paint the background with the background colour.
-- The default is 'P.True'.
-- 
-- This function is rarely useful. One use for it is to add a background
-- image to the terminal.
-- 
-- /Since: 0.52/
terminalSetClearBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@setting@/: whether to clear the background
    -> m ()
terminalSetClearBackground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetClearBackground a
terminal Bool
setting = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
setting
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_clear_background Ptr Terminal
terminal' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetClearBackgroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetClearBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetClearBackground

instance O.OverloadedMethodInfo TerminalSetClearBackgroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetClearBackground",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetClearBackground"
        })


#endif

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

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

-- | Sets the background color for text which does not have a specific background
-- color assigned.  Only has effect when no background image is set and when
-- the terminal is not transparent.
terminalSetColorBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.RGBA.RGBA
    -- ^ /@background@/: the new background color
    -> m ()
terminalSetColorBackground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> RGBA -> m ()
terminalSetColorBackground a
terminal RGBA
background = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
background' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
background
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_background Ptr Terminal
terminal' Ptr RGBA
background'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
background
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorBackgroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorBackgroundMethodInfo a signature where
    overloadedMethod = terminalSetColorBackground

instance O.OverloadedMethodInfo TerminalSetColorBackgroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorBackground",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorBackground"
        })


#endif

-- method Terminal::set_color_bold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bold"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new bold color or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the color used to draw bold text in the default foreground color.
-- If /@bold@/ is 'P.Nothing' then the default color is used.
terminalSetColorBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@bold@/: the new bold color or 'P.Nothing'
    -> m ()
terminalSetColorBold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorBold a
terminal Maybe RGBA
bold = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeBold <- case Maybe RGBA
bold of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jBold -> do
            Ptr RGBA
jBold' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jBold
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jBold'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_bold Ptr Terminal
terminal' Ptr RGBA
maybeBold
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
bold RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorBoldMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorBoldMethodInfo a signature where
    overloadedMethod = terminalSetColorBold

instance O.OverloadedMethodInfo TerminalSetColorBoldMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorBold",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorBold"
        })


#endif

-- method Terminal::set_color_cursor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for the text cursor, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the background color for text which is under the cursor.  If 'P.Nothing', text
-- under the cursor will be drawn with foreground and background colors
-- reversed.
terminalSetColorCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@cursorBackground@/: the new color to use for the text cursor, or 'P.Nothing'
    -> m ()
terminalSetColorCursor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorCursor a
terminal Maybe RGBA
cursorBackground = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeCursorBackground <- case Maybe RGBA
cursorBackground of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jCursorBackground -> do
            Ptr RGBA
jCursorBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jCursorBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jCursorBackground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_cursor Ptr Terminal
terminal' Ptr RGBA
maybeCursorBackground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
cursorBackground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorCursorMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorCursorMethodInfo a signature where
    overloadedMethod = terminalSetColorCursor

instance O.OverloadedMethodInfo TerminalSetColorCursorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorCursor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorCursor"
        })


#endif

-- method Terminal::set_color_cursor_foreground
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for the text cursor, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the foreground color for text which is under the cursor.  If 'P.Nothing', text
-- under the cursor will be drawn with foreground and background colors
-- reversed.
-- 
-- /Since: 0.44/
terminalSetColorCursorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@cursorForeground@/: the new color to use for the text cursor, or 'P.Nothing'
    -> m ()
terminalSetColorCursorForeground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorCursorForeground a
terminal Maybe RGBA
cursorForeground = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeCursorForeground <- case Maybe RGBA
cursorForeground of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jCursorForeground -> do
            Ptr RGBA
jCursorForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jCursorForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jCursorForeground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_cursor_foreground Ptr Terminal
terminal' Ptr RGBA
maybeCursorForeground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
cursorForeground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorCursorForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorCursorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorCursorForeground

instance O.OverloadedMethodInfo TerminalSetColorCursorForegroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorCursorForeground",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorCursorForeground"
        })


#endif

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

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

-- | Sets the foreground color used to draw normal text.
terminalSetColorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Gdk.RGBA.RGBA
    -- ^ /@foreground@/: the new foreground color
    -> m ()
terminalSetColorForeground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> RGBA -> m ()
terminalSetColorForeground a
terminal RGBA
foreground = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
foreground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
foreground
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_foreground Ptr Terminal
terminal' Ptr RGBA
foreground'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
foreground
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorForegroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorForeground

instance O.OverloadedMethodInfo TerminalSetColorForegroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorForeground",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorForeground"
        })


#endif

-- method Terminal::set_color_highlight
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight_background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for highlighted text, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the background color for text which is highlighted.  If 'P.Nothing',
-- it is unset.  If neither highlight background nor highlight foreground are set,
-- highlighted text (which is usually highlighted because it is selected) will
-- be drawn with foreground and background colors reversed.
terminalSetColorHighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@highlightBackground@/: the new color to use for highlighted text, or 'P.Nothing'
    -> m ()
terminalSetColorHighlight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorHighlight a
terminal Maybe RGBA
highlightBackground = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeHighlightBackground <- case Maybe RGBA
highlightBackground of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jHighlightBackground -> do
            Ptr RGBA
jHighlightBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jHighlightBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jHighlightBackground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_highlight Ptr Terminal
terminal' Ptr RGBA
maybeHighlightBackground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
highlightBackground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorHighlightMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorHighlightMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlight

instance O.OverloadedMethodInfo TerminalSetColorHighlightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorHighlight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorHighlight"
        })


#endif

-- method Terminal::set_color_highlight_foreground
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight_foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the new color to use for highlighted text, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the foreground color for text which is highlighted.  If 'P.Nothing',
-- it is unset.  If neither highlight background nor highlight foreground are set,
-- highlighted text (which is usually highlighted because it is selected) will
-- be drawn with foreground and background colors reversed.
terminalSetColorHighlightForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@highlightForeground@/: the new color to use for highlighted text, or 'P.Nothing'
    -> m ()
terminalSetColorHighlightForeground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> m ()
terminalSetColorHighlightForeground a
terminal Maybe RGBA
highlightForeground = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeHighlightForeground <- case Maybe RGBA
highlightForeground of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jHighlightForeground -> do
            Ptr RGBA
jHighlightForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jHighlightForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jHighlightForeground'
    Ptr Terminal -> Ptr RGBA -> IO ()
vte_terminal_set_color_highlight_foreground Ptr Terminal
terminal' Ptr RGBA
maybeHighlightForeground
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
highlightForeground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorHighlightForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorHighlightForegroundMethodInfo a signature where
    overloadedMethod = terminalSetColorHighlightForeground

instance O.OverloadedMethodInfo TerminalSetColorHighlightForegroundMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColorHighlightForeground",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColorHighlightForeground"
        })


#endif

-- method Terminal::set_colors
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "foreground"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new foreground color, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new background color, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "palette"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 4
--                 (TInterface Name { namespace = "Gdk" , name = "RGBA" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color palette" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "palette_size"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of entries in @palette"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "palette_size"
--              , argType = TBasicType TSize
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of entries in @palette"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_colors" vte_terminal_set_colors :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- palette : TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"}))
    FCT.CSize ->                            -- palette_size : TBasicType TSize
    IO ()

-- | /@palette@/ specifies the new values for the 256 palette colors: 8 standard colors,
-- their 8 bright counterparts, 6x6x6 color cube, and 24 grayscale colors.
-- Omitted entries will default to a hardcoded value.
-- 
-- /@paletteSize@/ must be 0, 8, 16, 232 or 256.
-- 
-- If /@foreground@/ is 'P.Nothing' and /@paletteSize@/ is greater than 0, the new foreground
-- color is taken from /@palette@/[7].  If /@background@/ is 'P.Nothing' and /@paletteSize@/ is
-- greater than 0, the new background color is taken from /@palette@/[0].
terminalSetColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@foreground@/: the new foreground color, or 'P.Nothing'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@background@/: the new background color, or 'P.Nothing'
    -> Maybe ([Gdk.RGBA.RGBA])
    -- ^ /@palette@/: the color palette
    -> m ()
terminalSetColors :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()
terminalSetColors a
terminal Maybe RGBA
foreground Maybe RGBA
background Maybe [RGBA]
palette = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let paletteSize :: CSize
paletteSize = case Maybe [RGBA]
palette of
            Maybe [RGBA]
Nothing -> CSize
0
            Just [RGBA]
jPalette -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ [RGBA] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [RGBA]
jPalette
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr RGBA
maybeForeground <- case Maybe RGBA
foreground of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jForeground -> do
            Ptr RGBA
jForeground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jForeground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jForeground'
    Ptr RGBA
maybeBackground <- case Maybe RGBA
background of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just RGBA
jBackground -> do
            Ptr RGBA
jBackground' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jBackground
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jBackground'
    Ptr RGBA
maybePalette <- case Maybe [RGBA]
palette of
        Maybe [RGBA]
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
FP.nullPtr
        Just [RGBA]
jPalette -> do
            [Ptr RGBA]
jPalette' <- (RGBA -> IO (Ptr RGBA)) -> [RGBA] -> IO [Ptr RGBA]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [RGBA]
jPalette
            Ptr RGBA
jPalette'' <- Int -> [Ptr RGBA] -> IO (Ptr RGBA)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
32 [Ptr RGBA]
jPalette'
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jPalette''
    Ptr Terminal -> Ptr RGBA -> Ptr RGBA -> Ptr RGBA -> CSize -> IO ()
vte_terminal_set_colors Ptr Terminal
terminal' Ptr RGBA
maybeForeground Ptr RGBA
maybeBackground Ptr RGBA
maybePalette CSize
paletteSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
foreground RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
background RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe [RGBA] -> ([RGBA] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [RGBA]
palette ((RGBA -> IO ()) -> [RGBA] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
    Ptr RGBA -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr RGBA
maybePalette
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetColorsMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> Maybe (Gdk.RGBA.RGBA) -> Maybe ([Gdk.RGBA.RGBA]) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetColorsMethodInfo a signature where
    overloadedMethod = terminalSetColors

instance O.OverloadedMethodInfo TerminalSetColorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetColors",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetColors"
        })


#endif

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

foreign import ccall "vte_terminal_set_context_menu" vte_terminal_set_context_menu :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gtk.Widget.Widget ->                -- menu : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets /@menu@/ as the context menu in /@terminal@/.
-- Use 'P.Nothing' to unset the current menu.
-- 
-- Note that a menu model set with 'GI.Vte.Objects.Terminal.terminalSetContextMenuModel'
-- takes precedence over a menu set using this function.
-- 
-- /Since: 0.76/
terminalSetContextMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (b)
    -- ^ /@menu@/: a menu
    -> m ()
terminalSetContextMenu :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsWidget b) =>
a -> Maybe b -> m ()
terminalSetContextMenu a
terminal Maybe b
menu = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Widget
maybeMenu <- case Maybe b
menu of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just b
jMenu -> do
            Ptr Widget
jMenu' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMenu
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jMenu'
    Ptr Terminal -> Ptr Widget -> IO ()
vte_terminal_set_context_menu Ptr Terminal
terminal' Ptr Widget
maybeMenu
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
menu b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetContextMenuMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TerminalSetContextMenuMethodInfo a signature where
    overloadedMethod = terminalSetContextMenu

instance O.OverloadedMethodInfo TerminalSetContextMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetContextMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetContextMenu"
        })


#endif

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

foreign import ccall "vte_terminal_set_context_menu_model" vte_terminal_set_context_menu_model :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gio.MenuModel.MenuModel ->          -- model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets /@model@/ as the context menu model in /@terminal@/.
-- Use 'P.Nothing' to unset the current menu model.
-- 
-- /Since: 0.76/
terminalSetContextMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (b)
    -- ^ /@model@/: a t'GI.Gio.Objects.MenuModel.MenuModel'
    -> m ()
terminalSetContextMenuModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsMenuModel b) =>
a -> Maybe b -> m ()
terminalSetContextMenuModel a
terminal Maybe b
model = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr MenuModel
maybeModel <- case Maybe b
model of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
FP.nullPtr
        Just b
jModel -> do
            Ptr MenuModel
jModel' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jModel'
    Ptr Terminal -> Ptr MenuModel -> IO ()
vte_terminal_set_context_menu_model Ptr Terminal
terminal' Ptr MenuModel
maybeModel
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetContextMenuModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod TerminalSetContextMenuModelMethodInfo a signature where
    overloadedMethod = terminalSetContextMenuModel

instance O.OverloadedMethodInfo TerminalSetContextMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetContextMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetContextMenuModel"
        })


#endif

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

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

-- | Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'
-- will use the t'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.
terminalSetCursorBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.CursorBlinkMode
    -- ^ /@mode@/: the t'GI.Vte.Enums.CursorBlinkMode' to use
    -> m ()
terminalSetCursorBlinkMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CursorBlinkMode -> m ()
terminalSetCursorBlinkMode a
terminal CursorBlinkMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (CursorBlinkMode -> Int) -> CursorBlinkMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorBlinkMode -> Int
forall a. Enum a => a -> Int
fromEnum) CursorBlinkMode
mode
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_cursor_blink_mode Ptr Terminal
terminal' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCursorBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.CursorBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetCursorBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetCursorBlinkMode

instance O.OverloadedMethodInfo TerminalSetCursorBlinkModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetCursorBlinkMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetCursorBlinkMode"
        })


#endif

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

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

-- | Sets the shape of the cursor drawn.
terminalSetCursorShape ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.CursorShape
    -- ^ /@shape@/: the t'GI.Vte.Enums.CursorShape' to use
    -> m ()
terminalSetCursorShape :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CursorShape -> m ()
terminalSetCursorShape a
terminal CursorShape
shape = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let shape' :: CUInt
shape' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CursorShape -> Int) -> CursorShape -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CursorShape -> Int
forall a. Enum a => a -> Int
fromEnum) CursorShape
shape
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_cursor_shape Ptr Terminal
terminal' CUInt
shape'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetCursorShapeMethodInfo
instance (signature ~ (Vte.Enums.CursorShape -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetCursorShapeMethodInfo a signature where
    overloadedMethod = terminalSetCursorShape

instance O.OverloadedMethodInfo TerminalSetCursorShapeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetCursorShape",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetCursorShape"
        })


#endif

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

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

-- | Reset the terminal palette to reasonable compiled-in default color.
terminalSetDefaultColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalSetDefaultColors :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalSetDefaultColors a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_set_default_colors Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetDefaultColorsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetDefaultColorsMethodInfo a signature where
    overloadedMethod = terminalSetDefaultColors

instance O.OverloadedMethodInfo TerminalSetDefaultColorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetDefaultColors",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetDefaultColors"
        })


#endif

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

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

-- | Modifies the terminal\'s delete key binding, which controls what
-- string or control sequence the terminal sends to its child when the user
-- presses the delete key.
terminalSetDeleteBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.EraseBinding
    -- ^ /@binding@/: a t'GI.Vte.Enums.EraseBinding' for the delete key
    -> m ()
terminalSetDeleteBinding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> EraseBinding -> m ()
terminalSetDeleteBinding a
terminal EraseBinding
binding = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let binding' :: CUInt
binding' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EraseBinding -> Int) -> EraseBinding -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EraseBinding -> Int
forall a. Enum a => a -> Int
fromEnum) EraseBinding
binding
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_delete_binding Ptr Terminal
terminal' CUInt
binding'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetDeleteBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetDeleteBindingMethodInfo a signature where
    overloadedMethod = terminalSetDeleteBinding

instance O.OverloadedMethodInfo TerminalSetDeleteBindingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetDeleteBinding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetDeleteBinding"
        })


#endif

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

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

-- | Controls whether or not the terminal will communicate with a11y backends.
-- 
-- /Since: 0.78/
terminalSetEnableA11y ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enableA11y@/: 'P.True' to enable a11y support
    -> m ()
terminalSetEnableA11y :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableA11y a
terminal Bool
enableA11y = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enableA11y' :: CInt
enableA11y' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableA11y
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_a11y Ptr Terminal
terminal' CInt
enableA11y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableA11yMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableA11yMethodInfo a signature where
    overloadedMethod = terminalSetEnableA11y

instance O.OverloadedMethodInfo TerminalSetEnableA11yMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableA11y",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableA11y"
        })


#endif

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

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

-- | Controls whether or not the terminal will perform bidirectional text rendering.
-- 
-- /Since: 0.58/
terminalSetEnableBidi ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enableBidi@/: 'P.True' to enable BiDi support
    -> m ()
terminalSetEnableBidi :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableBidi a
terminal Bool
enableBidi = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enableBidi' :: CInt
enableBidi' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableBidi
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_bidi Ptr Terminal
terminal' CInt
enableBidi'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableBidiMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableBidiMethodInfo a signature where
    overloadedMethod = terminalSetEnableBidi

instance O.OverloadedMethodInfo TerminalSetEnableBidiMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableBidi",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableBidi"
        })


#endif

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

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

-- | Controls whether the terminal uses scroll events to scroll the history
-- if the event was not otherwise consumed by it.
-- 
-- This function is rarely useful, except when the terminal is added to a
-- t'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow', to perform kinetic scrolling (while vte itself does
-- not, yet, implement kinetic scrolling by itself).
-- 
-- /Since: 0.64/
terminalSetEnableFallbackScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enable@/: whether to enable fallback scrolling
    -> m ()
terminalSetEnableFallbackScrolling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableFallbackScrolling a
terminal Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_fallback_scrolling Ptr Terminal
terminal' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableFallbackScrollingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableFallbackScrollingMethodInfo a signature where
    overloadedMethod = terminalSetEnableFallbackScrolling

instance O.OverloadedMethodInfo TerminalSetEnableFallbackScrollingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableFallbackScrolling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableFallbackScrolling"
        })


#endif

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

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

-- | Sets whether legacy OSC 777 sequences are translated to
-- their corresponding termprops.
-- 
-- /Since: 0.78/
terminalSetEnableLegacyOsc777 ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enable@/: whether to enable legacy OSC 777
    -> m ()
terminalSetEnableLegacyOsc777 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableLegacyOsc777 a
terminal Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_legacy_osc777 Ptr Terminal
terminal' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableLegacyOsc777MethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableLegacyOsc777MethodInfo a signature where
    overloadedMethod = terminalSetEnableLegacyOsc777

instance O.OverloadedMethodInfo TerminalSetEnableLegacyOsc777MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableLegacyOsc777",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableLegacyOsc777"
        })


#endif

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

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

-- | Controls whether or not the terminal will shape Arabic text.
-- 
-- /Since: 0.58/
terminalSetEnableShaping ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enableShaping@/: 'P.True' to enable Arabic shaping
    -> m ()
terminalSetEnableShaping :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableShaping a
terminal Bool
enableShaping = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enableShaping' :: CInt
enableShaping' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableShaping
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_shaping Ptr Terminal
terminal' CInt
enableShaping'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableShapingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableShapingMethodInfo a signature where
    overloadedMethod = terminalSetEnableShaping

instance O.OverloadedMethodInfo TerminalSetEnableShapingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableShaping",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableShaping"
        })


#endif

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

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

-- | Set whether to enable SIXEL images.
-- 
-- /Since: 0.62/
terminalSetEnableSixel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enabled@/: whether to enable SIXEL images
    -> m ()
terminalSetEnableSixel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetEnableSixel a
terminal Bool
enabled = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enabled
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_enable_sixel Ptr Terminal
terminal' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetEnableSixelMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetEnableSixelMethodInfo a signature where
    overloadedMethod = terminalSetEnableSixel

instance O.OverloadedMethodInfo TerminalSetEnableSixelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEnableSixel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEnableSixel"
        })


#endif

-- method Terminal::set_encoding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "codeset"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "target charset, or %NULL to use UTF-8"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_set_encoding" vte_terminal_set_encoding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- codeset : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED terminalSetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}
-- | Changes the encoding the terminal will expect data from the child to
-- be encoded with.  For certain terminal types, applications executing in the
-- terminal can change the encoding. If /@codeset@/ is 'P.Nothing', it uses \"UTF-8\".
-- 
-- Note: Support for non-UTF-8 is deprecated and may get removed altogether.
-- Instead of this function, you should use a wrapper like luit(1) when
-- spawning the child process.
terminalSetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (T.Text)
    -- ^ /@codeset@/: target charset, or 'P.Nothing' to use UTF-8
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalSetEncoding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe Text -> m ()
terminalSetEncoding a
terminal Maybe Text
codeset = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
maybeCodeset <- case Maybe Text
codeset of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jCodeset -> do
            CString
jCodeset' <- Text -> IO CString
textToCString Text
jCodeset
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCodeset'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal -> CString -> Ptr (Ptr GError) -> IO CInt
vte_terminal_set_encoding Ptr Terminal
terminal' CString
maybeCodeset
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCodeset
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCodeset
     )

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

instance O.OverloadedMethodInfo TerminalSetEncodingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetEncoding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetEncoding"
        })


#endif

-- method Terminal::set_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_desc"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "FontDescription" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #PangoFontDescription for the desired font, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the font used for rendering all text displayed by the terminal,
-- overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal
-- will immediately attempt to load the desired font, retrieve its
-- metrics, and attempt to resize itself to keep the same number of rows
-- and columns.  The font scale is applied to the specified font.
terminalSetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Pango.FontDescription.FontDescription)
    -- ^ /@fontDesc@/: a t'GI.Pango.Structs.FontDescription.FontDescription' for the desired font, or 'P.Nothing'
    -> m ()
terminalSetFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe FontDescription -> m ()
terminalSetFont a
terminal Maybe FontDescription
fontDesc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr FontDescription
maybeFontDesc <- case Maybe FontDescription
fontDesc of
        Maybe FontDescription
Nothing -> Ptr FontDescription -> IO (Ptr FontDescription)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDescription
forall a. Ptr a
FP.nullPtr
        Just FontDescription
jFontDesc -> do
            Ptr FontDescription
jFontDesc' <- FontDescription -> IO (Ptr FontDescription)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontDescription
jFontDesc
            Ptr FontDescription -> IO (Ptr FontDescription)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDescription
jFontDesc'
    Ptr Terminal -> Ptr FontDescription -> IO ()
vte_terminal_set_font Ptr Terminal
terminal' Ptr FontDescription
maybeFontDesc
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe FontDescription -> (FontDescription -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe FontDescription
fontDesc FontDescription -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetFontMethodInfo
instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetFontMethodInfo a signature where
    overloadedMethod = terminalSetFont

instance O.OverloadedMethodInfo TerminalSetFontMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetFont",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetFont"
        })


#endif

-- method Terminal::set_font_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_options"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "FontOptions" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the font options, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font_options" vte_terminal_set_font_options :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Cairo.FontOptions.FontOptions ->    -- font_options : TInterface (Name {namespace = "cairo", name = "FontOptions"})
    IO ()

-- | Sets the terminal\'s font options to /@options@/.
-- 
-- Note that on GTK4, the terminal by default uses font options
-- with 'GI.Cairo.Enums.HintMetricsOn' set; to override that, use this
-- function to set a t'GI.Cairo.Structs.FontOptions.FontOptions' that has
-- 'GI.Cairo.Enums.HintMetricsOff' set.
-- 
-- /Since: 0.74/
terminalSetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (Cairo.FontOptions.FontOptions)
    -- ^ /@fontOptions@/: the font options, or 'P.Nothing'
    -> m ()
terminalSetFontOptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Maybe FontOptions -> m ()
terminalSetFontOptions a
terminal Maybe FontOptions
fontOptions = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr FontOptions
maybeFontOptions <- case Maybe FontOptions
fontOptions of
        Maybe FontOptions
Nothing -> Ptr FontOptions -> IO (Ptr FontOptions)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontOptions
forall a. Ptr a
FP.nullPtr
        Just FontOptions
jFontOptions -> do
            Ptr FontOptions
jFontOptions' <- FontOptions -> IO (Ptr FontOptions)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontOptions
jFontOptions
            Ptr FontOptions -> IO (Ptr FontOptions)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontOptions
jFontOptions'
    Ptr Terminal -> Ptr FontOptions -> IO ()
vte_terminal_set_font_options Ptr Terminal
terminal' Ptr FontOptions
maybeFontOptions
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe FontOptions -> (FontOptions -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe FontOptions
fontOptions FontOptions -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetFontOptionsMethodInfo
instance (signature ~ (Maybe (Cairo.FontOptions.FontOptions) -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetFontOptionsMethodInfo a signature where
    overloadedMethod = terminalSetFontOptions

instance O.OverloadedMethodInfo TerminalSetFontOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetFontOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetFontOptions"
        })


#endif

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

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

-- | Sets the terminal\'s font scale to /@scale@/.
terminalSetFontScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Double
    -- ^ /@scale@/: the font scale
    -> m ()
terminalSetFontScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Double -> m ()
terminalSetFontScale a
terminal Double
scale = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scale' :: CDouble
scale' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scale
    Ptr Terminal -> CDouble -> IO ()
vte_terminal_set_font_scale Ptr Terminal
terminal' CDouble
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetFontScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetFontScaleMethodInfo a signature where
    overloadedMethod = terminalSetFontScale

instance O.OverloadedMethodInfo TerminalSetFontScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetFontScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetFontScale"
        })


#endif

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

foreign import ccall "vte_terminal_set_geometry_hints_for_window" vte_terminal_set_geometry_hints_for_window :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gtk.Window.Window ->                -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

{-# DEPRECATED terminalSetGeometryHintsForWindow ["(Since version 0.52)"] #-}
-- | Sets /@terminal@/ as /@window@/\'s geometry widget. See
-- 'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.
-- 
-- /@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').
terminalSetGeometryHintsForWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> b
    -- ^ /@window@/: a t'GI.Gtk.Objects.Window.Window'
    -> m ()
terminalSetGeometryHintsForWindow :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsWindow b) =>
a -> b -> m ()
terminalSetGeometryHintsForWindow a
terminal b
window = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Window
window' <- b -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
window
    Ptr Terminal -> Ptr Window -> IO ()
vte_terminal_set_geometry_hints_for_window Ptr Terminal
terminal' Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetGeometryHintsForWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) => O.OverloadedMethod TerminalSetGeometryHintsForWindowMethodInfo a signature where
    overloadedMethod = terminalSetGeometryHintsForWindow

instance O.OverloadedMethodInfo TerminalSetGeometryHintsForWindowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetGeometryHintsForWindow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetGeometryHintsForWindow"
        })


#endif

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

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

-- | Enables or disables user input. When user input is disabled,
-- the terminal\'s child will not receive any key press, or mouse button
-- press or motion events sent to it.
terminalSetInputEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enabled@/: whether to enable user input
    -> m ()
terminalSetInputEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetInputEnabled a
terminal Bool
enabled = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enabled
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_input_enabled Ptr Terminal
terminal' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetInputEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetInputEnabledMethodInfo a signature where
    overloadedMethod = terminalSetInputEnabled

instance O.OverloadedMethodInfo TerminalSetInputEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetInputEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetInputEnabled"
        })


#endif

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

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

-- | Changes the value of the terminal\'s mouse autohide setting.  When autohiding
-- is enabled, the mouse cursor will be hidden when the user presses a key and
-- shown when the user moves the mouse.  This setting can be read using
-- 'GI.Vte.Objects.Terminal.terminalGetMouseAutohide'.
terminalSetMouseAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@setting@/: whether the mouse pointer should autohide
    -> m ()
terminalSetMouseAutohide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetMouseAutohide a
terminal Bool
setting = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
setting
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_mouse_autohide Ptr Terminal
terminal' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetMouseAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetMouseAutohideMethodInfo a signature where
    overloadedMethod = terminalSetMouseAutohide

instance O.OverloadedMethodInfo TerminalSetMouseAutohideMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetMouseAutohide",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetMouseAutohide"
        })


#endif

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

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

-- | Sets /@pty@/ as the PTY to use in /@terminal@/.
-- Use 'P.Nothing' to unset the PTY.
terminalSetPty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Vte.Pty.IsPty b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Maybe (b)
    -- ^ /@pty@/: a t'GI.Vte.Objects.Pty.Pty', or 'P.Nothing'
    -> m ()
terminalSetPty :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsPty b) =>
a -> Maybe b -> m ()
terminalSetPty a
terminal Maybe b
pty = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Pty
maybePty <- case Maybe b
pty of
        Maybe b
Nothing -> Ptr Pty -> IO (Ptr Pty)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pty
forall a. Ptr a
FP.nullPtr
        Just b
jPty -> do
            Ptr Pty
jPty' <- b -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jPty
            Ptr Pty -> IO (Ptr Pty)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Pty
jPty'
    Ptr Terminal -> Ptr Pty -> IO ()
vte_terminal_set_pty Ptr Terminal
terminal' Ptr Pty
maybePty
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
pty b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetPtyMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Vte.Pty.IsPty b) => O.OverloadedMethod TerminalSetPtyMethodInfo a signature where
    overloadedMethod = terminalSetPty

instance O.OverloadedMethodInfo TerminalSetPtyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetPty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetPty"
        })


#endif

-- method Terminal::set_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rewrap"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the terminal should rewrap on resize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

{-# DEPRECATED terminalSetRewrapOnResize ["(Since version 0.58)"] #-}
-- | Controls whether or not the terminal will rewrap its contents, including
-- the scrollback history, whenever the terminal\'s width changes.
terminalSetRewrapOnResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@rewrap@/: 'P.True' if the terminal should rewrap on resize
    -> m ()
terminalSetRewrapOnResize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetRewrapOnResize a
terminal Bool
rewrap = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let rewrap' :: CInt
rewrap' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
rewrap
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_rewrap_on_resize Ptr Terminal
terminal' CInt
rewrap'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetRewrapOnResizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetRewrapOnResizeMethodInfo a signature where
    overloadedMethod = terminalSetRewrapOnResize

instance O.OverloadedMethodInfo TerminalSetRewrapOnResizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetRewrapOnResize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetRewrapOnResize"
        })


#endif

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

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

-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when text is inserted, e.g. by a paste.
-- 
-- /Since: 0.76/
terminalSetScrollOnInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@scroll@/: whether the terminal should scroll on insert
    -> m ()
terminalSetScrollOnInsert :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollOnInsert a
terminal Bool
scroll = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scroll' :: CInt
scroll' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
scroll
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_on_insert Ptr Terminal
terminal' CInt
scroll'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollOnInsertMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetScrollOnInsertMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnInsert

instance O.OverloadedMethodInfo TerminalSetScrollOnInsertMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetScrollOnInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetScrollOnInsert"
        })


#endif

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

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

-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the user presses a key.  Modifier keys do not
-- trigger this behavior.
-- 
-- /Since: 0.52/
terminalSetScrollOnKeystroke ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@scroll@/: whether the terminal should scroll on keystrokes
    -> m ()
terminalSetScrollOnKeystroke :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollOnKeystroke a
terminal Bool
scroll = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scroll' :: CInt
scroll' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
scroll
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_on_keystroke Ptr Terminal
terminal' CInt
scroll'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollOnKeystrokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnKeystroke

instance O.OverloadedMethodInfo TerminalSetScrollOnKeystrokeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetScrollOnKeystroke",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetScrollOnKeystroke"
        })


#endif

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

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

-- | Controls whether or not the terminal will forcibly scroll to the bottom of
-- the viewable history when the new data is received from the child.
-- 
-- /Since: 0.52/
terminalSetScrollOnOutput ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@scroll@/: whether the terminal should scroll on output
    -> m ()
terminalSetScrollOnOutput :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollOnOutput a
terminal Bool
scroll = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let scroll' :: CInt
scroll' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
scroll
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_on_output Ptr Terminal
terminal' CInt
scroll'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollOnOutputMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetScrollOnOutputMethodInfo a signature where
    overloadedMethod = terminalSetScrollOnOutput

instance O.OverloadedMethodInfo TerminalSetScrollOnOutputMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetScrollOnOutput",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetScrollOnOutput"
        })


#endif

-- method Terminal::set_scroll_unit_is_pixels
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to use pixels as scroll unit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Controls whether the terminal\'s scroll unit is lines or pixels.
-- 
-- This function is rarely useful, except when the terminal is added to a
-- t'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow'.
-- 
-- /Since: 0.66/
terminalSetScrollUnitIsPixels ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@enable@/: whether to use pixels as scroll unit
    -> m ()
terminalSetScrollUnitIsPixels :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetScrollUnitIsPixels a
terminal Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_scroll_unit_is_pixels Ptr Terminal
terminal' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollUnitIsPixelsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetScrollUnitIsPixelsMethodInfo a signature where
    overloadedMethod = terminalSetScrollUnitIsPixels

instance O.OverloadedMethodInfo TerminalSetScrollUnitIsPixelsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetScrollUnitIsPixels",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetScrollUnitIsPixels"
        })


#endif

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

foreign import ccall "vte_terminal_set_scrollback_lines" vte_terminal_set_scrollback_lines :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    FCT.CLong ->                            -- lines : TBasicType TLong
    IO ()

-- | Sets the length of the scrollback buffer used by the terminal.  The size of
-- the scrollback buffer will be set to the larger of this value and the number
-- of visible rows the widget can display, so 0 can safely be used to disable
-- scrollback.
-- 
-- A negative value means \"infinite scrollback\".
-- 
-- Using a large scrollback buffer (roughly 1M+ lines) may lead to performance
-- degradation or exhaustion of system resources, and is therefore not recommended.
-- 
-- Note that this setting only affects the normal screen buffer.
-- No scrollback is allowed on the alternate screen buffer.
terminalSetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> FCT.CLong
    -- ^ /@lines@/: the length of the history buffer
    -> m ()
terminalSetScrollbackLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> m ()
terminalSetScrollbackLines a
terminal CLong
lines = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> CLong -> IO ()
vte_terminal_set_scrollback_lines Ptr Terminal
terminal' CLong
lines
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetScrollbackLinesMethodInfo
instance (signature ~ (FCT.CLong -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetScrollbackLinesMethodInfo a signature where
    overloadedMethod = terminalSetScrollbackLines

instance O.OverloadedMethodInfo TerminalSetScrollbackLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetScrollbackLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetScrollbackLines"
        })


#endif

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

foreign import ccall "vte_terminal_set_size" vte_terminal_set_size :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    FCT.CLong ->                            -- columns : TBasicType TLong
    FCT.CLong ->                            -- rows : TBasicType TLong
    IO ()

-- | Attempts to change the terminal\'s size in terms of rows and columns.  If
-- the attempt succeeds, the widget will resize itself to the proper size.
terminalSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> FCT.CLong
    -- ^ /@columns@/: the desired number of columns
    -> FCT.CLong
    -- ^ /@rows@/: the desired number of rows
    -> m ()
terminalSetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> CLong -> CLong -> m ()
terminalSetSize a
terminal CLong
columns CLong
rows = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> CLong -> CLong -> IO ()
vte_terminal_set_size Ptr Terminal
terminal' CLong
columns CLong
rows
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetSizeMethodInfo
instance (signature ~ (FCT.CLong -> FCT.CLong -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetSizeMethodInfo a signature where
    overloadedMethod = terminalSetSize

instance O.OverloadedMethodInfo TerminalSetSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetSize"
        })


#endif

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

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

-- | Suppress emissions of signals and property notifications
-- that are deprecated.
-- 
-- /Since: 0.78/
terminalSetSuppressLegacySignals ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalSetSuppressLegacySignals :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalSetSuppressLegacySignals a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_set_suppress_legacy_signals Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetSuppressLegacySignalsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetSuppressLegacySignalsMethodInfo a signature where
    overloadedMethod = terminalSetSuppressLegacySignals

instance O.OverloadedMethodInfo TerminalSetSuppressLegacySignalsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetSuppressLegacySignals",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetSuppressLegacySignals"
        })


#endif

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

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

-- | Controls whether or not the terminal will allow blinking text.
-- 
-- /Since: 0.52/
terminalSetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.TextBlinkMode
    -- ^ /@textBlinkMode@/: the t'GI.Vte.Enums.TextBlinkMode' to use
    -> m ()
terminalSetTextBlinkMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> TextBlinkMode -> m ()
terminalSetTextBlinkMode a
terminal TextBlinkMode
textBlinkMode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let textBlinkMode' :: CUInt
textBlinkMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextBlinkMode -> Int) -> TextBlinkMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBlinkMode -> Int
forall a. Enum a => a -> Int
fromEnum) TextBlinkMode
textBlinkMode
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_text_blink_mode Ptr Terminal
terminal' CUInt
textBlinkMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetTextBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.TextBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetTextBlinkModeMethodInfo a signature where
    overloadedMethod = terminalSetTextBlinkMode

instance O.OverloadedMethodInfo TerminalSetTextBlinkModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetTextBlinkMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetTextBlinkMode"
        })


#endif

-- method Terminal::set_word_char_exceptions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "exceptions"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a string of ASCII punctuation characters, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | With this function you can provide a set of characters which will
-- be considered parts of a word when doing word-wise selection, in
-- addition to the default which only considers alphanumeric characters
-- part of a word.
-- 
-- The characters in /@exceptions@/ must be non-alphanumeric, each character
-- must occur only once, and if /@exceptions@/ contains the character
-- U+002D HYPHEN-MINUS, it must be at the start of the string.
-- 
-- Use 'P.Nothing' to reset the set of exception characters to the default.
-- 
-- /Since: 0.40/
terminalSetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> T.Text
    -- ^ /@exceptions@/: a string of ASCII punctuation characters, or 'P.Nothing'
    -> m ()
terminalSetWordCharExceptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Text -> m ()
terminalSetWordCharExceptions a
terminal Text
exceptions = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    CString
exceptions' <- Text -> IO CString
textToCString Text
exceptions
    Ptr Terminal -> CString -> IO ()
vte_terminal_set_word_char_exceptions Ptr Terminal
terminal' CString
exceptions'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
exceptions'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetWordCharExceptionsMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetWordCharExceptionsMethodInfo a signature where
    overloadedMethod = terminalSetWordCharExceptions

instance O.OverloadedMethodInfo TerminalSetWordCharExceptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetWordCharExceptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetWordCharExceptions"
        })


#endif

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

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

-- | Sets the horizontal alignment of /@terminal@/ within its allocation.
-- 
-- Note: @/VTE_ALIGN_START_FILL/@ is not supported, and will be treated
--   like 'GI.Vte.Enums.AlignStart'.
-- 
-- /Since: 0.76/
terminalSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Align
    -- ^ /@align@/: alignment value from t'GI.Vte.Enums.Align'
    -> m ()
terminalSetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Align -> m ()
terminalSetXalign a
terminal Align
align = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let align' :: CUInt
align' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Align -> Int) -> Align -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Align -> Int
forall a. Enum a => a -> Int
fromEnum) Align
align
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_xalign Ptr Terminal
terminal' CUInt
align'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetXalignMethodInfo
instance (signature ~ (Vte.Enums.Align -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetXalignMethodInfo a signature where
    overloadedMethod = terminalSetXalign

instance O.OverloadedMethodInfo TerminalSetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetXalign"
        })


#endif

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

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

-- | Sets the horizontal fillment of /@terminal@/ within its allocation.
-- 
-- Note: @/VTE_FILL_START_FILL/@ is not supported, and will be treated
--   like @/VTE_FILL_START/@.
-- 
-- /Since: 0.76/
terminalSetXfill ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@fill@/: fillment value from @/VteFill/@
    -> m ()
terminalSetXfill :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetXfill a
terminal Bool
fill = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let fill' :: CInt
fill' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
fill
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_xfill Ptr Terminal
terminal' CInt
fill'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetXfillMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetXfillMethodInfo a signature where
    overloadedMethod = terminalSetXfill

instance O.OverloadedMethodInfo TerminalSetXfillMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetXfill",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetXfill"
        })


#endif

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

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

-- | Sets the vertical alignment of /@terminal@/ within its allocation.
-- 
-- /Since: 0.76/
terminalSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Vte.Enums.Align
    -- ^ /@align@/: alignment value from t'GI.Vte.Enums.Align'
    -> m ()
terminalSetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Align -> m ()
terminalSetYalign a
terminal Align
align = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let align' :: CUInt
align' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Align -> Int) -> Align -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Align -> Int
forall a. Enum a => a -> Int
fromEnum) Align
align
    Ptr Terminal -> CUInt -> IO ()
vte_terminal_set_yalign Ptr Terminal
terminal' CUInt
align'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetYalignMethodInfo
instance (signature ~ (Vte.Enums.Align -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetYalignMethodInfo a signature where
    overloadedMethod = terminalSetYalign

instance O.OverloadedMethodInfo TerminalSetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetYalign"
        })


#endif

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

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

-- | Sets the vertical fillment of /@terminal@/ within its allocation.
-- Note that yfill is only supported with yalign set to
-- 'GI.Vte.Enums.AlignStart', and is ignored for all other yalign values.
-- 
-- /Since: 0.76/
terminalSetYfill ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Bool
    -- ^ /@fill@/: fillment value from @/VteFill/@
    -> m ()
terminalSetYfill :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Bool -> m ()
terminalSetYfill a
terminal Bool
fill = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let fill' :: CInt
fill' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
fill
    Ptr Terminal -> CInt -> IO ()
vte_terminal_set_yfill Ptr Terminal
terminal' CInt
fill'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalSetYfillMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalSetYfillMethodInfo a signature where
    overloadedMethod = terminalSetYfill

instance O.OverloadedMethodInfo TerminalSetYfillMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSetYfill",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSetYfill"
        })


#endif

-- method Terminal::spawn_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pty_flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "working_directory"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of a directory the command should start\n  in, or %NULL to use the current working directory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "child's argument vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "envv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a list of environment\n  variables to be added to the environment before starting the process, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spawn_flags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "SpawnFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GSpawnFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup"
--           , argType =
--               TInterface
--                 Name { namespace = "GLib" , name = "SpawnChildSetupFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an extra child setup function to run in the child just before exec(), or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 7
--           , argDestroy = 8
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @child_setup, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GDestroyNotify for @child_setup_data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface
--                 Name { namespace = "Vte" , name = "TerminalSpawnAsyncCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminalSpawnAsyncCallback, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 12
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @callback, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_spawn_async" vte_terminal_spawn_async :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    CString ->                              -- working_directory : TBasicType TUTF8
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)
    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})
    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})
    Ptr () ->                               -- child_setup_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- child_setup_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    Int32 ->                                -- timeout : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback -> -- callback : TInterface (Name {namespace = "Vte", name = "TerminalSpawnAsyncCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | A convenience function that wraps creating the t'GI.Vte.Objects.Pty.Pty' and spawning
-- the child process on it. Like 'GI.Vte.Objects.Terminal.terminalSpawnWithFdsAsync',
-- except that this function does not allow passing file descriptors to
-- the child process. See 'GI.Vte.Objects.Terminal.terminalSpawnWithFdsAsync' for more
-- information.
-- 
-- /Since: 0.48/
terminalSpawnAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@ptyFlags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (T.Text)
    -- ^ /@workingDirectory@/: the name of a directory the command should start
    --   in, or 'P.Nothing' to use the current working directory
    -> [[Char]]
    -- ^ /@argv@/: child\'s argument vector
    -> Maybe ([[Char]])
    -- ^ /@envv@/: a list of environment
    --   variables to be added to the environment before starting the process, or 'P.Nothing'
    -> [GLib.Flags.SpawnFlags]
    -- ^ /@spawnFlags@/: flags from t'GI.GLib.Flags.SpawnFlags'
    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
    -- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'P.Nothing'
    -> Int32
    -- ^ /@timeout@/: a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Vte.Callbacks.TerminalSpawnAsyncCallback)
    -- ^ /@callback@/: a t'GI.Vte.Callbacks.TerminalSpawnAsyncCallback', or 'P.Nothing'
    -> m ()
terminalSpawnAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe SpawnChildSetupFunc
-> Int32
-> Maybe b
-> Maybe TerminalSpawnAsyncCallback
-> m ()
terminalSpawnAsync a
terminal [PtyFlags]
ptyFlags Maybe Text
workingDirectory [String]
argv Maybe [String]
envv [SpawnFlags]
spawnFlags Maybe SpawnChildSetupFunc
childSetup Int32
timeout Maybe b
cancellable Maybe TerminalSpawnAsyncCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let ptyFlags' :: CUInt
ptyFlags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
ptyFlags
    CString
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jWorkingDirectory -> do
            CString
jWorkingDirectory' <- Text -> IO CString
textToCString Text
jWorkingDirectory
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jWorkingDirectory'
    Ptr CString
argv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
argv
    Ptr CString
maybeEnvv <- case Maybe [String]
envv of
        Maybe [String]
Nothing -> Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
FP.nullPtr
        Just [String]
jEnvv -> do
            Ptr CString
jEnvv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
jEnvv
            Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jEnvv'
    let spawnFlags' :: CUInt
spawnFlags' = [SpawnFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SpawnFlags]
spawnFlags
    FunPtr SpawnChildSetupFunc
maybeChildSetup <- case Maybe SpawnChildSetupFunc
childSetup of
        Maybe SpawnChildSetupFunc
Nothing -> FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SpawnChildSetupFunc
jChildSetup -> do
            Ptr (FunPtr SpawnChildSetupFunc)
ptrchildSetup <- IO (Ptr (FunPtr SpawnChildSetupFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_SpawnChildSetupFunc))
            FunPtr SpawnChildSetupFunc
jChildSetup' <- SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
GLib.Callbacks.mk_SpawnChildSetupFunc (Maybe (Ptr (FunPtr SpawnChildSetupFunc))
-> SpawnChildSetupFunc -> SpawnChildSetupFunc
GLib.Callbacks.wrap_SpawnChildSetupFunc (Ptr (FunPtr SpawnChildSetupFunc)
-> Maybe (Ptr (FunPtr SpawnChildSetupFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr SpawnChildSetupFunc)
ptrchildSetup) SpawnChildSetupFunc
jChildSetup)
            Ptr (FunPtr SpawnChildSetupFunc)
-> FunPtr SpawnChildSetupFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr SpawnChildSetupFunc)
ptrchildSetup FunPtr SpawnChildSetupFunc
jChildSetup'
            FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
jChildSetup'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_TerminalSpawnAsyncCallback
maybeCallback <- case Maybe TerminalSpawnAsyncCallback
callback of
        Maybe TerminalSpawnAsyncCallback
Nothing -> FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TerminalSpawnAsyncCallback
forall a. FunPtr a
FP.nullFunPtr
        Just TerminalSpawnAsyncCallback
jCallback -> do
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback <- IO (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback))
            FunPtr C_TerminalSpawnAsyncCallback
jCallback' <- C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
Vte.Callbacks.mk_TerminalSpawnAsyncCallback (Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
-> TerminalSpawnAsyncCallback_WithClosures
-> C_TerminalSpawnAsyncCallback
Vte.Callbacks.wrap_TerminalSpawnAsyncCallback (Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback) (TerminalSpawnAsyncCallback
-> TerminalSpawnAsyncCallback_WithClosures
Vte.Callbacks.drop_closures_TerminalSpawnAsyncCallback TerminalSpawnAsyncCallback
jCallback))
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> FunPtr C_TerminalSpawnAsyncCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback FunPtr C_TerminalSpawnAsyncCallback
jCallback'
            FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TerminalSpawnAsyncCallback
jCallback'
    let childSetupData :: Ptr a
childSetupData = Ptr a
forall a. Ptr a
nullPtr
    let childSetupDataDestroy :: FunPtr a
childSetupDataDestroy = FunPtr a
forall a. FunPtr a
FP.nullFunPtr
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Terminal
-> CUInt
-> CString
-> Ptr CString
-> Ptr CString
-> CUInt
-> FunPtr SpawnChildSetupFunc
-> Ptr ()
-> FunPtr SpawnChildSetupFunc
-> Int32
-> Ptr Cancellable
-> FunPtr C_TerminalSpawnAsyncCallback
-> SpawnChildSetupFunc
vte_terminal_spawn_async Ptr Terminal
terminal' CUInt
ptyFlags' CString
maybeWorkingDirectory Ptr CString
argv' Ptr CString
maybeEnvv CUInt
spawnFlags' FunPtr SpawnChildSetupFunc
maybeChildSetup Ptr ()
forall a. Ptr a
childSetupData FunPtr SpawnChildSetupFunc
forall a. FunPtr a
childSetupDataDestroy Int32
timeout Ptr Cancellable
maybeCancellable FunPtr C_TerminalSpawnAsyncCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TerminalSpawnAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSpawnAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSpawnAsync"
        })


#endif

-- method Terminal::spawn_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pty_flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "working_directory"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of a directory the command should start\n  in, or %NULL to use the current working directory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "child's argument vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "envv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a list of environment\n  variables to be added to the environment before starting the process, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spawn_flags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "SpawnFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GSpawnFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup"
--           , argType =
--               TInterface
--                 Name { namespace = "GLib" , name = "SpawnChildSetupFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an extra child setup function to run in the child just before exec(), or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 7
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @child_setup"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_pid"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a location to store the child PID, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_spawn_sync" vte_terminal_spawn_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    CString ->                              -- working_directory : TBasicType TUTF8
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)
    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})
    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})
    Ptr () ->                               -- child_setup_data : TBasicType TPtr
    Ptr Int32 ->                            -- child_pid : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED terminalSpawnSync ["(Since version 0.48)","Use 'GI.Vte.Objects.Terminal.terminalSpawnAsync' instead."] #-}
-- | Starts the specified command under a newly-allocated controlling
-- pseudo-terminal.  The /@argv@/ and /@envv@/ lists should be 'P.Nothing'-terminated.
-- The \"TERM\" environment variable is automatically set to a default value,
-- but can be overridden from /@envv@/.
-- /@ptyFlags@/ controls logging the session to the specified system log files.
-- 
-- Note that 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' will always be added to /@spawnFlags@/.
-- 
-- Note also that 'GI.GLib.Flags.SpawnFlagsStdoutToDevNull', 'GI.GLib.Flags.SpawnFlagsStderrToDevNull',
-- and 'GI.GLib.Flags.SpawnFlagsChildInheritsStdin' are not supported in /@spawnFlags@/, since
-- stdin, stdout and stderr of the child process will always be connected to
-- the PTY.
-- 
-- Note that all open file descriptors will be closed in the child. If you want
-- to keep some file descriptor open for use in the child process, you need to
-- use a child setup function that unsets the FD_CLOEXEC flag on that file
-- descriptor.
-- 
-- See @/vte_pty_new()/@, 'GI.GLib.Functions.spawnAsync' and 'GI.Vte.Objects.Terminal.terminalWatchChild' for more information.
-- 
-- Beginning with 0.52, sets PWD to /@workingDirectory@/ in order to preserve symlink components.
-- The caller should also make sure that symlinks were preserved while constructing the value of /@workingDirectory@/,
-- e.g. by using 'GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri', 'GI.GLib.Functions.getCurrentDir' or @/get_current_dir_name()/@.
terminalSpawnSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@ptyFlags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (T.Text)
    -- ^ /@workingDirectory@/: the name of a directory the command should start
    --   in, or 'P.Nothing' to use the current working directory
    -> [[Char]]
    -- ^ /@argv@/: child\'s argument vector
    -> Maybe ([[Char]])
    -- ^ /@envv@/: a list of environment
    --   variables to be added to the environment before starting the process, or 'P.Nothing'
    -> [GLib.Flags.SpawnFlags]
    -- ^ /@spawnFlags@/: flags from t'GI.GLib.Flags.SpawnFlags'
    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
    -- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m (Int32)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalSpawnSync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe SpawnChildSetupFunc
-> Maybe b
-> m Int32
terminalSpawnSync a
terminal [PtyFlags]
ptyFlags Maybe Text
workingDirectory [String]
argv Maybe [String]
envv [SpawnFlags]
spawnFlags Maybe SpawnChildSetupFunc
childSetup Maybe b
cancellable = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let ptyFlags' :: CUInt
ptyFlags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
ptyFlags
    CString
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jWorkingDirectory -> do
            CString
jWorkingDirectory' <- Text -> IO CString
textToCString Text
jWorkingDirectory
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jWorkingDirectory'
    Ptr CString
argv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
argv
    Ptr CString
maybeEnvv <- case Maybe [String]
envv of
        Maybe [String]
Nothing -> Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
FP.nullPtr
        Just [String]
jEnvv -> do
            Ptr CString
jEnvv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
jEnvv
            Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jEnvv'
    let spawnFlags' :: CUInt
spawnFlags' = [SpawnFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SpawnFlags]
spawnFlags
    FunPtr SpawnChildSetupFunc
maybeChildSetup <- case Maybe SpawnChildSetupFunc
childSetup of
        Maybe SpawnChildSetupFunc
Nothing -> FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SpawnChildSetupFunc
jChildSetup -> do
            FunPtr SpawnChildSetupFunc
jChildSetup' <- SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
GLib.Callbacks.mk_SpawnChildSetupFunc (Maybe (Ptr (FunPtr SpawnChildSetupFunc))
-> SpawnChildSetupFunc -> SpawnChildSetupFunc
GLib.Callbacks.wrap_SpawnChildSetupFunc Maybe (Ptr (FunPtr SpawnChildSetupFunc))
forall a. Maybe a
Nothing SpawnChildSetupFunc
jChildSetup)
            FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
jChildSetup'
    Ptr Int32
childPid <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    let childSetupData :: Ptr a
childSetupData = Ptr a
forall a. Ptr a
nullPtr
    IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> CUInt
-> CString
-> Ptr CString
-> Ptr CString
-> CUInt
-> FunPtr SpawnChildSetupFunc
-> Ptr ()
-> Ptr Int32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
vte_terminal_spawn_sync Ptr Terminal
terminal' CUInt
ptyFlags' CString
maybeWorkingDirectory Ptr CString
argv' Ptr CString
maybeEnvv CUInt
spawnFlags' FunPtr SpawnChildSetupFunc
maybeChildSetup Ptr ()
forall a. Ptr a
childSetupData Ptr Int32
childPid Ptr Cancellable
maybeCancellable
        Int32
childPid' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
childPid
        Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr SpawnChildSetupFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr SpawnChildSetupFunc
maybeChildSetup
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
        Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
childPid'
     ) (do
        Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr SpawnChildSetupFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr SpawnChildSetupFunc
maybeChildSetup
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
        (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
        Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
     )

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

instance O.OverloadedMethodInfo TerminalSpawnSyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSpawnSync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSpawnSync"
        })


#endif

-- method Terminal::spawn_with_fds_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pty_flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "PtyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #VtePtyFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "working_directory"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of a directory the command should start\n  in, or %NULL to use the current working directory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "child's argument vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "envv"
--           , argType = TCArray True (-1) (-1) (TBasicType TFileName)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a list of environment\n  variables to be added to the environment before starting the process, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fds"
--           , argType = TCArray False (-1) 6 (TBasicType TInt)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of file descriptors, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_fds"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of file descriptors in @fds, or 0 if @fds is %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "map_fds"
--           , argType = TCArray False (-1) 8 (TBasicType TInt)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of integers, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_map_fds"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of elements in @map_fds, or 0 if @map_fds is %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spawn_flags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "SpawnFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags from #GSpawnFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup"
--           , argType =
--               TInterface
--                 Name { namespace = "GLib" , name = "SpawnChildSetupFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an extra child setup function to run in the child just before exec(), or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 11
--           , argDestroy = 12
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @child_setup, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_setup_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GDestroyNotify for @child_setup_data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface
--                 Name { namespace = "Vte" , name = "TerminalSpawnAsyncCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminalSpawnAsyncCallback, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 16
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @callback, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_map_fds"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "the number of elements in @map_fds, or 0 if @map_fds is %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_fds"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "the number of file descriptors in @fds, or 0 if @fds is %NULL"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_spawn_with_fds_async" vte_terminal_spawn_with_fds_async :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    CString ->                              -- working_directory : TBasicType TUTF8
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr Int32 ->                            -- fds : TCArray False (-1) 6 (TBasicType TInt)
    Int32 ->                                -- n_fds : TBasicType TInt
    Ptr Int32 ->                            -- map_fds : TCArray False (-1) 8 (TBasicType TInt)
    Int32 ->                                -- n_map_fds : TBasicType TInt
    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})
    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})
    Ptr () ->                               -- child_setup_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- child_setup_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    Int32 ->                                -- timeout : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback -> -- callback : TInterface (Name {namespace = "Vte", name = "TerminalSpawnAsyncCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | A convenience function that wraps creating the t'GI.Vte.Objects.Pty.Pty' and spawning
-- the child process on it. See 'GI.Vte.Objects.Pty.ptyNewSync', 'GI.Vte.Objects.Pty.ptySpawnWithFdsAsync',
-- and 'GI.Vte.Objects.Pty.ptySpawnFinish' for more information.
-- 
-- When the operation is finished successfully, /@callback@/ will be called
-- with the child @/GPid/@, and a 'P.Nothing' t'GError'. The child PID will already be
-- watched via 'GI.Vte.Objects.Terminal.terminalWatchChild'.
-- 
-- When the operation fails, /@callback@/ will be called with a -1 @/GPid/@,
-- and a non-'P.Nothing' t'GError' containing the error information.
-- 
-- Note that 'GI.GLib.Flags.SpawnFlagsStdoutToDevNull', 'GI.GLib.Flags.SpawnFlagsStderrToDevNull',
-- and 'GI.GLib.Flags.SpawnFlagsChildInheritsStdin' are not supported in /@spawnFlags@/, since
-- stdin, stdout and stderr of the child process will always be connected to
-- the PTY.
-- 
-- If /@fds@/ is not 'P.Nothing', the child process will map the file descriptors from
-- /@fds@/ according to /@mapFds@/; /@nMapFds@/ must be less or equal to /@nFds@/.
-- This function will take ownership of the file descriptors in /@fds@/;
-- you must not use or close them after this call.
-- 
-- Note that all  open file descriptors apart from those mapped as above
-- will be closed in the child. (If you want to keep some other file descriptor
-- open for use in the child process, you need to use a child setup function
-- that unsets the FD_CLOEXEC flag on that file descriptor manually.)
-- 
-- Beginning with 0.60, and on linux only, and unless 'GI.Vte.Constants.SPAWN_NO_SYSTEMD_SCOPE' is
-- passed in /@spawnFlags@/, the newly created child process will be moved to its own
-- systemd user scope; and if 'GI.Vte.Constants.SPAWN_REQUIRE_SYSTEMD_SCOPE' is passed, and creation
-- of the systemd user scope fails, the whole spawn will fail.
-- You can override the options used for the systemd user scope by
-- providing a systemd override file for \'vte-spawn-.scope\' unit. See man:systemd.unit(5)
-- for further information.
-- 
-- Note that if /@terminal@/ has been destroyed before the operation is called,
-- /@callback@/ will be called with a 'P.Nothing' /@terminal@/; you must not do anything
-- in the callback besides freeing any resources associated with /@userData@/,
-- but taking care not to access the now-destroyed t'GI.Vte.Objects.Terminal.Terminal'. Note that
-- in this case, if spawning was successful, the child process will be aborted
-- automatically.
-- 
-- Beginning with 0.52, sets PWD to /@workingDirectory@/ in order to preserve symlink components.
-- The caller should also make sure that symlinks were preserved while constructing the value of /@workingDirectory@/,
-- e.g. by using 'GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri', 'GI.GLib.Functions.getCurrentDir' or @/get_current_dir_name()/@.
-- 
-- /Since: 0.62/
terminalSpawnWithFdsAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> [Vte.Flags.PtyFlags]
    -- ^ /@ptyFlags@/: flags from t'GI.Vte.Flags.PtyFlags'
    -> Maybe (T.Text)
    -- ^ /@workingDirectory@/: the name of a directory the command should start
    --   in, or 'P.Nothing' to use the current working directory
    -> [[Char]]
    -- ^ /@argv@/: child\'s argument vector
    -> Maybe ([[Char]])
    -- ^ /@envv@/: a list of environment
    --   variables to be added to the environment before starting the process, or 'P.Nothing'
    -> Maybe ([Int32])
    -- ^ /@fds@/: an array of file descriptors, or 'P.Nothing'
    -> Maybe ([Int32])
    -- ^ /@mapFds@/: an array of integers, or 'P.Nothing'
    -> [GLib.Flags.SpawnFlags]
    -- ^ /@spawnFlags@/: flags from t'GI.GLib.Flags.SpawnFlags'
    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
    -- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'P.Nothing'
    -> Int32
    -- ^ /@timeout@/: a timeout value in ms, -1 for the default timeout, or G_MAXINT to wait indefinitely
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Vte.Callbacks.TerminalSpawnAsyncCallback)
    -- ^ /@callback@/: a t'GI.Vte.Callbacks.TerminalSpawnAsyncCallback', or 'P.Nothing'
    -> m ()
terminalSpawnWithFdsAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) =>
a
-> [PtyFlags]
-> Maybe Text
-> [String]
-> Maybe [String]
-> Maybe [Int32]
-> Maybe [Int32]
-> [SpawnFlags]
-> Maybe SpawnChildSetupFunc
-> Int32
-> Maybe b
-> Maybe TerminalSpawnAsyncCallback
-> m ()
terminalSpawnWithFdsAsync a
terminal [PtyFlags]
ptyFlags Maybe Text
workingDirectory [String]
argv Maybe [String]
envv Maybe [Int32]
fds Maybe [Int32]
mapFds [SpawnFlags]
spawnFlags Maybe SpawnChildSetupFunc
childSetup Int32
timeout Maybe b
cancellable Maybe TerminalSpawnAsyncCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let nMapFds :: Int32
nMapFds = case Maybe [Int32]
mapFds of
            Maybe [Int32]
Nothing -> Int32
0
            Just [Int32]
jMapFds -> Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Int32] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Int32]
jMapFds
    let nFds :: Int32
nFds = case Maybe [Int32]
fds of
            Maybe [Int32]
Nothing -> Int32
0
            Just [Int32]
jFds -> Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Int32] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Int32]
jFds
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    let ptyFlags' :: CUInt
ptyFlags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
ptyFlags
    CString
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jWorkingDirectory -> do
            CString
jWorkingDirectory' <- Text -> IO CString
textToCString Text
jWorkingDirectory
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jWorkingDirectory'
    Ptr CString
argv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
argv
    Ptr CString
maybeEnvv <- case Maybe [String]
envv of
        Maybe [String]
Nothing -> Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
FP.nullPtr
        Just [String]
jEnvv -> do
            Ptr CString
jEnvv' <- [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray [String]
jEnvv
            Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jEnvv'
    Ptr Int32
maybeFds <- case Maybe [Int32]
fds of
        Maybe [Int32]
Nothing -> Ptr Int32 -> IO (Ptr Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int32
forall a. Ptr a
FP.nullPtr
        Just [Int32]
jFds -> do
            Ptr Int32
jFds' <- [Int32] -> IO (Ptr Int32)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [Int32]
jFds
            Ptr Int32 -> IO (Ptr Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int32
jFds'
    Ptr Int32
maybeMapFds <- case Maybe [Int32]
mapFds of
        Maybe [Int32]
Nothing -> Ptr Int32 -> IO (Ptr Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int32
forall a. Ptr a
FP.nullPtr
        Just [Int32]
jMapFds -> do
            Ptr Int32
jMapFds' <- [Int32] -> IO (Ptr Int32)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [Int32]
jMapFds
            Ptr Int32 -> IO (Ptr Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Int32
jMapFds'
    let spawnFlags' :: CUInt
spawnFlags' = [SpawnFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SpawnFlags]
spawnFlags
    FunPtr SpawnChildSetupFunc
maybeChildSetup <- case Maybe SpawnChildSetupFunc
childSetup of
        Maybe SpawnChildSetupFunc
Nothing -> FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
forall a. FunPtr a
FP.nullFunPtr
        Just SpawnChildSetupFunc
jChildSetup -> do
            FunPtr SpawnChildSetupFunc
jChildSetup' <- SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
GLib.Callbacks.mk_SpawnChildSetupFunc (Maybe (Ptr (FunPtr SpawnChildSetupFunc))
-> SpawnChildSetupFunc -> SpawnChildSetupFunc
GLib.Callbacks.wrap_SpawnChildSetupFunc Maybe (Ptr (FunPtr SpawnChildSetupFunc))
forall a. Maybe a
Nothing SpawnChildSetupFunc
jChildSetup)
            FunPtr SpawnChildSetupFunc -> IO (FunPtr SpawnChildSetupFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr SpawnChildSetupFunc
jChildSetup'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_TerminalSpawnAsyncCallback
maybeCallback <- case Maybe TerminalSpawnAsyncCallback
callback of
        Maybe TerminalSpawnAsyncCallback
Nothing -> FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TerminalSpawnAsyncCallback
forall a. FunPtr a
FP.nullFunPtr
        Just TerminalSpawnAsyncCallback
jCallback -> do
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback <- IO (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Vte.Callbacks.C_TerminalSpawnAsyncCallback))
            FunPtr C_TerminalSpawnAsyncCallback
jCallback' <- C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
Vte.Callbacks.mk_TerminalSpawnAsyncCallback (Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
-> TerminalSpawnAsyncCallback_WithClosures
-> C_TerminalSpawnAsyncCallback
Vte.Callbacks.wrap_TerminalSpawnAsyncCallback (Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback) (TerminalSpawnAsyncCallback
-> TerminalSpawnAsyncCallback_WithClosures
Vte.Callbacks.drop_closures_TerminalSpawnAsyncCallback TerminalSpawnAsyncCallback
jCallback))
            Ptr (FunPtr C_TerminalSpawnAsyncCallback)
-> FunPtr C_TerminalSpawnAsyncCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_TerminalSpawnAsyncCallback)
ptrcallback FunPtr C_TerminalSpawnAsyncCallback
jCallback'
            FunPtr C_TerminalSpawnAsyncCallback
-> IO (FunPtr C_TerminalSpawnAsyncCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TerminalSpawnAsyncCallback
jCallback'
    let childSetupData :: Ptr ()
childSetupData = FunPtr SpawnChildSetupFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr SpawnChildSetupFunc
maybeChildSetup
    let childSetupDataDestroy :: FunPtr (Ptr a -> IO ())
childSetupDataDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Terminal
-> CUInt
-> CString
-> Ptr CString
-> Ptr CString
-> Ptr Int32
-> Int32
-> Ptr Int32
-> Int32
-> CUInt
-> FunPtr SpawnChildSetupFunc
-> Ptr ()
-> FunPtr SpawnChildSetupFunc
-> Int32
-> Ptr Cancellable
-> FunPtr C_TerminalSpawnAsyncCallback
-> SpawnChildSetupFunc
vte_terminal_spawn_with_fds_async Ptr Terminal
terminal' CUInt
ptyFlags' CString
maybeWorkingDirectory Ptr CString
argv' Ptr CString
maybeEnvv Ptr Int32
maybeFds Int32
nFds Ptr Int32
maybeMapFds Int32
nMapFds CUInt
spawnFlags' FunPtr SpawnChildSetupFunc
maybeChildSetup Ptr ()
childSetupData FunPtr SpawnChildSetupFunc
forall a. FunPtr (Ptr a -> IO ())
childSetupDataDestroy Int32
timeout Ptr Cancellable
maybeCancellable FunPtr C_TerminalSpawnAsyncCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeWorkingDirectory
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
argv'
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvv
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
maybeFds
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
maybeMapFds
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TerminalSpawnWithFdsAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalSpawnWithFdsAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalSpawnWithFdsAsync"
        })


#endif

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

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

-- | Clears the current selection.
terminalUnselectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> m ()
terminalUnselectAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> m ()
terminalUnselectAll a
terminal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> IO ()
vte_terminal_unselect_all Ptr Terminal
terminal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalUnselectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalUnselectAllMethodInfo a signature where
    overloadedMethod = terminalUnselectAll

instance O.OverloadedMethodInfo TerminalUnselectAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalUnselectAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalUnselectAll"
        })


#endif

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

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

-- | Watches /@childPid@/. When the process exists, the [Terminal::childExited]("GI.Vte.Objects.Terminal#g:signal:childExited")
-- signal will be called with the child\'s exit status.
-- 
-- Prior to calling this function, a t'GI.Vte.Objects.Pty.Pty' must have been set in /@terminal@/
-- using 'GI.Vte.Objects.Terminal.terminalSetPty'.
-- When the child exits, the terminal\'s t'GI.Vte.Objects.Pty.Pty' will be set to 'P.Nothing'.
-- 
-- Note: @/g_child_watch_add()/@ or 'GI.GLib.Functions.childWatchAdd' must not have
-- been called for /@childPid@/, nor a t'GI.GLib.Structs.Source.Source' for it been created with
-- 'GI.GLib.Functions.childWatchSourceNew'.
-- 
-- Note: when using the 'GI.GLib.Functions.spawnAsync' family of functions,
-- the 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' flag MUST have been passed.
terminalWatchChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> Int32
    -- ^ /@childPid@/: a @/GPid/@
    -> m ()
terminalWatchChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTerminal a) =>
a -> Int32 -> m ()
terminalWatchChild a
terminal Int32
childPid = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr Terminal -> TerminalChildExitedCallback
vte_terminal_watch_child Ptr Terminal
terminal' Int32
childPid
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TerminalWatchChildMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.OverloadedMethod TerminalWatchChildMethodInfo a signature where
    overloadedMethod = terminalWatchChild

instance O.OverloadedMethodInfo TerminalWatchChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalWatchChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalWatchChild"
        })


#endif

-- method Terminal::write_contents_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "terminal"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "Terminal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #VteTerminal" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "OutputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOutputStream to write to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Vte" , name = "WriteFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #VteWriteFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable object, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_write_contents_sync" vte_terminal_write_contents_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "WriteFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Write contents of the current contents of /@terminal@/ (including any
-- scrollback history) to /@stream@/ according to /@flags@/.
-- 
-- If /@cancellable@/ is not 'P.Nothing', then the operation can be cancelled by triggering
-- the cancellable object from another thread. If the operation was cancelled,
-- the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned in /@error@/.
-- 
-- This is a synchronous operation and will make the widget (and input
-- processing) during the write operation, which may take a long time
-- depending on scrollback history and /@stream@/ availability for writing.
terminalWriteContentsSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@terminal@/: a t'GI.Vte.Objects.Terminal.Terminal'
    -> b
    -- ^ /@stream@/: a t'GI.Gio.Objects.OutputStream.OutputStream' to write to
    -> Vte.Enums.WriteFlags
    -- ^ /@flags@/: a set of t'GI.Vte.Enums.WriteFlags'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' object, or 'P.Nothing'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
terminalWriteContentsSync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsTerminal a, IsOutputStream b,
 IsCancellable c) =>
a -> b -> WriteFlags -> Maybe c -> m ()
terminalWriteContentsSync a
terminal b
stream WriteFlags
flags Maybe c
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Terminal
terminal' <- a -> IO (Ptr Terminal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
terminal
    Ptr OutputStream
stream' <- b -> IO (Ptr OutputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
stream
    let flags' :: CUInt
flags' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WriteFlags -> Int) -> WriteFlags -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriteFlags -> Int
forall a. Enum a => a -> Int
fromEnum) WriteFlags
flags
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Terminal
-> Ptr OutputStream
-> CUInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
vte_terminal_write_contents_sync Ptr Terminal
terminal' Ptr OutputStream
stream' CUInt
flags' Ptr Cancellable
maybeCancellable
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
terminal
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
stream
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TerminalWriteContentsSyncMethodInfo
instance (signature ~ (b -> Vte.Enums.WriteFlags -> Maybe (c) -> m ()), MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod TerminalWriteContentsSyncMethodInfo a signature where
    overloadedMethod = terminalWriteContentsSync

instance O.OverloadedMethodInfo TerminalWriteContentsSyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vte.Objects.Terminal.terminalWriteContentsSync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.33/docs/GI-Vte-Objects-Terminal.html#v:terminalWriteContentsSync"
        })


#endif