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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Gutter cell renderer.
-- 
-- A @GtkSourceGutterRenderer@ represents a column in a [class/@gutter@/]. The
-- column contains one cell for each visible line of the t'GI.Gtk.Objects.TextBuffer.TextBuffer'. Due to
-- text wrapping, a cell can thus span multiple lines of the t'GI.Gtk.Objects.TextView.TextView'. In
-- this case, [enum/@gutterRendererAlignmentMode@/] controls the alignment of
-- the cell.
-- 
-- The gutter renderer is a t'GI.Gtk.Objects.Widget.Widget' and is measured using the normal widget
-- measurement facilities. The width of the gutter will be determined by the
-- measurements of the gutter renderers.
-- 
-- The width of a gutter renderer generally takes into account the entire text
-- buffer. For instance, to display the line numbers, if the buffer contains 100
-- lines, the gutter renderer will always set its width such as three digits can
-- be printed, even if only the first 20 lines are shown. Another strategy is to
-- take into account only the visible lines.  In this case, only two digits are
-- necessary to display the line numbers of the first 20 lines. To take another
-- example, the gutter renderer for [class/@mark@/]s doesn\'t need to take
-- into account the text buffer to announce its width. It only depends on the
-- icons size displayed in the gutter column.
-- 
-- When the available size to render a cell is greater than the required size to
-- render the cell contents, the cell contents can be aligned horizontally and
-- vertically with [method/@gutterRenderer@/.set_alignment_mode].
-- 
-- The cells rendering occurs using t'GI.Gtk.Objects.Widget.Widget'.@/snapshot/@(). Implementations
-- should use @gtk_source_gutter_renderer_get_lines()@ to retrieve information
-- about the lines to be rendered. To help with aligning content which takes
-- into account the padding and alignment of a cell, implementations may call
-- [method/@gutterRenderer@/.align_cell] for a given line number with the
-- width and height measurement of the content they width to render.

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

module GI.GtkSource.Objects.GutterRenderer
    ( 

-- * Exported types
    GutterRenderer(..)                      ,
    IsGutterRenderer                        ,
    toGutterRenderer                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.GtkSource.Objects.GutterRenderer#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [alignCell]("GI.GtkSource.Objects.GutterRenderer#g:method:alignCell"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [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"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queryActivatable]("GI.GtkSource.Objects.GutterRenderer#g:method:queryActivatable"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [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"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAlignmentMode]("GI.GtkSource.Objects.GutterRenderer#g:method:getAlignmentMode"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuffer]("GI.GtkSource.Objects.GutterRenderer#g:method:getBuffer"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [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"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getView]("GI.GtkSource.Objects.GutterRenderer#g:method:getView"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getXalign]("GI.GtkSource.Objects.GutterRenderer#g:method:getXalign"), [getXpad]("GI.GtkSource.Objects.GutterRenderer#g:method:getXpad"), [getYalign]("GI.GtkSource.Objects.GutterRenderer#g:method:getYalign"), [getYpad]("GI.GtkSource.Objects.GutterRenderer#g:method:getYpad").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setAlignmentMode]("GI.GtkSource.Objects.GutterRenderer#g:method:setAlignmentMode"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [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"), [setXalign]("GI.GtkSource.Objects.GutterRenderer#g:method:setXalign"), [setXpad]("GI.GtkSource.Objects.GutterRenderer#g:method:setXpad"), [setYalign]("GI.GtkSource.Objects.GutterRenderer#g:method:setYalign"), [setYpad]("GI.GtkSource.Objects.GutterRenderer#g:method:setYpad").

#if defined(ENABLE_OVERLOADING)
    ResolveGutterRendererMethod             ,
#endif

-- ** activate #method:activate#

#if defined(ENABLE_OVERLOADING)
    GutterRendererActivateMethodInfo        ,
#endif
    gutterRendererActivate                  ,


-- ** alignCell #method:alignCell#

#if defined(ENABLE_OVERLOADING)
    GutterRendererAlignCellMethodInfo       ,
#endif
    gutterRendererAlignCell                 ,


-- ** getAlignmentMode #method:getAlignmentMode#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetAlignmentModeMethodInfo,
#endif
    gutterRendererGetAlignmentMode          ,


-- ** getBuffer #method:getBuffer#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetBufferMethodInfo       ,
#endif
    gutterRendererGetBuffer                 ,


-- ** getView #method:getView#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetViewMethodInfo         ,
#endif
    gutterRendererGetView                   ,


-- ** getXalign #method:getXalign#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetXalignMethodInfo       ,
#endif
    gutterRendererGetXalign                 ,


-- ** getXpad #method:getXpad#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetXpadMethodInfo         ,
#endif
    gutterRendererGetXpad                   ,


-- ** getYalign #method:getYalign#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetYalignMethodInfo       ,
#endif
    gutterRendererGetYalign                 ,


-- ** getYpad #method:getYpad#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetYpadMethodInfo         ,
#endif
    gutterRendererGetYpad                   ,


-- ** queryActivatable #method:queryActivatable#

#if defined(ENABLE_OVERLOADING)
    GutterRendererQueryActivatableMethodInfo,
#endif
    gutterRendererQueryActivatable          ,


-- ** setAlignmentMode #method:setAlignmentMode#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetAlignmentModeMethodInfo,
#endif
    gutterRendererSetAlignmentMode          ,


-- ** setXalign #method:setXalign#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetXalignMethodInfo       ,
#endif
    gutterRendererSetXalign                 ,


-- ** setXpad #method:setXpad#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetXpadMethodInfo         ,
#endif
    gutterRendererSetXpad                   ,


-- ** setYalign #method:setYalign#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetYalignMethodInfo       ,
#endif
    gutterRendererSetYalign                 ,


-- ** setYpad #method:setYpad#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetYpadMethodInfo         ,
#endif
    gutterRendererSetYpad                   ,




 -- * Properties


-- ** alignmentMode #attr:alignmentMode#
-- | The alignment mode of the renderer.
-- 
-- This can be used to indicate that in the case a cell spans multiple lines (due to text wrapping)
-- the alignment should work on either the full cell, the first line or the last line.

#if defined(ENABLE_OVERLOADING)
    GutterRendererAlignmentModePropertyInfo ,
#endif
    constructGutterRendererAlignmentMode    ,
    getGutterRendererAlignmentMode          ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererAlignmentMode             ,
#endif
    setGutterRendererAlignmentMode          ,


-- ** lines #attr:lines#
-- | Contains information about the lines to be rendered.
-- 
-- It should be used by t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' implementations from t'GI.Gtk.Objects.Widget.Widget'.@/snapshot/@().

#if defined(ENABLE_OVERLOADING)
    GutterRendererLinesPropertyInfo         ,
#endif
    getGutterRendererLines                  ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererLines                     ,
#endif


-- ** view #attr:view#
-- | The view on which the renderer is placed.

#if defined(ENABLE_OVERLOADING)
    GutterRendererViewPropertyInfo          ,
#endif
    getGutterRendererView                   ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererView                      ,
#endif


-- ** xalign #attr:xalign#
-- | The horizontal alignment of the renderer.
-- 
-- Set to 0 for a left alignment. 1 for a right alignment. And 0.5 for centering the cells.
-- A value lower than 0 doesn\'t modify the alignment.

#if defined(ENABLE_OVERLOADING)
    GutterRendererXalignPropertyInfo        ,
#endif
    constructGutterRendererXalign           ,
    getGutterRendererXalign                 ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererXalign                    ,
#endif
    setGutterRendererXalign                 ,


-- ** xpad #attr:xpad#
-- | The left and right padding of the renderer.

#if defined(ENABLE_OVERLOADING)
    GutterRendererXpadPropertyInfo          ,
#endif
    constructGutterRendererXpad             ,
    getGutterRendererXpad                   ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererXpad                      ,
#endif
    setGutterRendererXpad                   ,


-- ** yalign #attr:yalign#
-- | The vertical alignment of the renderer.
-- 
-- Set to 0 for a top alignment. 1 for a bottom alignment. And 0.5 for centering the cells.
-- A value lower than 0 doesn\'t modify the alignment.

#if defined(ENABLE_OVERLOADING)
    GutterRendererYalignPropertyInfo        ,
#endif
    constructGutterRendererYalign           ,
    getGutterRendererYalign                 ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererYalign                    ,
#endif
    setGutterRendererYalign                 ,


-- ** ypad #attr:ypad#
-- | The top and bottom padding of the renderer.

#if defined(ENABLE_OVERLOADING)
    GutterRendererYpadPropertyInfo          ,
#endif
    constructGutterRendererYpad             ,
    getGutterRendererYpad                   ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererYpad                      ,
#endif
    setGutterRendererYpad                   ,




 -- * Signals


-- ** activate #signal:activate#

    GutterRendererActivateCallback          ,
#if defined(ENABLE_OVERLOADING)
    GutterRendererActivateSignalInfo        ,
#endif
    afterGutterRendererActivate             ,
    onGutterRendererActivate                ,


-- ** queryActivatable #signal:queryActivatable#

    GutterRendererQueryActivatableCallback  ,
#if defined(ENABLE_OVERLOADING)
    GutterRendererQueryActivatableSignalInfo,
#endif
    afterGutterRendererQueryActivatable     ,
    onGutterRendererQueryActivatable        ,


-- ** queryData #signal:queryData#

    GutterRendererQueryDataCallback         ,
#if defined(ENABLE_OVERLOADING)
    GutterRendererQueryDataSignalInfo       ,
#endif
    afterGutterRendererQueryData            ,
    onGutterRendererQueryData               ,




    ) 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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.TextView as Gtk.TextView
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer
import {-# SOURCE #-} qualified GI.GtkSource.Objects.GutterLines as GtkSource.GutterLines
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View

-- | Memory-managed wrapper type.
newtype GutterRenderer = GutterRenderer (SP.ManagedPtr GutterRenderer)
    deriving (GutterRenderer -> GutterRenderer -> Bool
(GutterRenderer -> GutterRenderer -> Bool)
-> (GutterRenderer -> GutterRenderer -> Bool) -> Eq GutterRenderer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GutterRenderer -> GutterRenderer -> Bool
== :: GutterRenderer -> GutterRenderer -> Bool
$c/= :: GutterRenderer -> GutterRenderer -> Bool
/= :: GutterRenderer -> GutterRenderer -> Bool
Eq)

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

foreign import ccall "gtk_source_gutter_renderer_get_type"
    c_gtk_source_gutter_renderer_get_type :: IO B.Types.GType

instance B.Types.TypedObject GutterRenderer where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_gutter_renderer_get_type

instance B.Types.GObject GutterRenderer

-- | Type class for types which can be safely cast to `GutterRenderer`, for instance with `toGutterRenderer`.
class (SP.GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o
instance (SP.GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o

instance O.HasParentTypes GutterRenderer
type instance O.ParentTypes GutterRenderer = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

-- | Cast to `GutterRenderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toGutterRenderer :: (MIO.MonadIO m, IsGutterRenderer o) => o -> m GutterRenderer
toGutterRenderer :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> m GutterRenderer
toGutterRenderer = IO GutterRenderer -> m GutterRenderer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO GutterRenderer -> m GutterRenderer)
-> (o -> IO GutterRenderer) -> o -> m GutterRenderer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr GutterRenderer -> GutterRenderer)
-> o -> IO GutterRenderer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr GutterRenderer -> GutterRenderer
GutterRenderer

-- | Convert 'GutterRenderer' 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 GutterRenderer) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_gutter_renderer_get_type
    gvalueSet_ :: Ptr GValue -> Maybe GutterRenderer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe GutterRenderer
P.Nothing = Ptr GValue -> Ptr GutterRenderer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr GutterRenderer
forall a. Ptr a
FP.nullPtr :: FP.Ptr GutterRenderer)
    gvalueSet_ Ptr GValue
gv (P.Just GutterRenderer
obj) = GutterRenderer -> (Ptr GutterRenderer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GutterRenderer
obj (Ptr GValue -> Ptr GutterRenderer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe GutterRenderer)
gvalueGet_ Ptr GValue
gv = do
        Ptr GutterRenderer
ptr <- Ptr GValue -> IO (Ptr GutterRenderer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr GutterRenderer)
        if Ptr GutterRenderer
ptr Ptr GutterRenderer -> Ptr GutterRenderer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr GutterRenderer
forall a. Ptr a
FP.nullPtr
        then GutterRenderer -> Maybe GutterRenderer
forall a. a -> Maybe a
P.Just (GutterRenderer -> Maybe GutterRenderer)
-> IO GutterRenderer -> IO (Maybe GutterRenderer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr GutterRenderer -> GutterRenderer)
-> Ptr GutterRenderer -> IO GutterRenderer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GutterRenderer -> GutterRenderer
GutterRenderer Ptr GutterRenderer
ptr
        else Maybe GutterRenderer -> IO (Maybe GutterRenderer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GutterRenderer
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveGutterRendererMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveGutterRendererMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveGutterRendererMethod "activate" o = GutterRendererActivateMethodInfo
    ResolveGutterRendererMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveGutterRendererMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveGutterRendererMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveGutterRendererMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveGutterRendererMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveGutterRendererMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveGutterRendererMethod "alignCell" o = GutterRendererAlignCellMethodInfo
    ResolveGutterRendererMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveGutterRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveGutterRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveGutterRendererMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveGutterRendererMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveGutterRendererMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveGutterRendererMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveGutterRendererMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveGutterRendererMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveGutterRendererMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveGutterRendererMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveGutterRendererMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveGutterRendererMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveGutterRendererMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveGutterRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveGutterRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveGutterRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveGutterRendererMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveGutterRendererMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveGutterRendererMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveGutterRendererMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveGutterRendererMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveGutterRendererMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveGutterRendererMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveGutterRendererMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveGutterRendererMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveGutterRendererMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveGutterRendererMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveGutterRendererMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveGutterRendererMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveGutterRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveGutterRendererMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveGutterRendererMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveGutterRendererMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveGutterRendererMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveGutterRendererMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveGutterRendererMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveGutterRendererMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveGutterRendererMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveGutterRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveGutterRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveGutterRendererMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveGutterRendererMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveGutterRendererMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveGutterRendererMethod "queryActivatable" o = GutterRendererQueryActivatableMethodInfo
    ResolveGutterRendererMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveGutterRendererMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveGutterRendererMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveGutterRendererMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveGutterRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveGutterRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveGutterRendererMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveGutterRendererMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveGutterRendererMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveGutterRendererMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveGutterRendererMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveGutterRendererMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveGutterRendererMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveGutterRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveGutterRendererMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveGutterRendererMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveGutterRendererMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveGutterRendererMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveGutterRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveGutterRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveGutterRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveGutterRendererMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveGutterRendererMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveGutterRendererMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveGutterRendererMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveGutterRendererMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveGutterRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveGutterRendererMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveGutterRendererMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveGutterRendererMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveGutterRendererMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveGutterRendererMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveGutterRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveGutterRendererMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveGutterRendererMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveGutterRendererMethod "getAlignmentMode" o = GutterRendererGetAlignmentModeMethodInfo
    ResolveGutterRendererMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveGutterRendererMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveGutterRendererMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveGutterRendererMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveGutterRendererMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveGutterRendererMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveGutterRendererMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveGutterRendererMethod "getBuffer" o = GutterRendererGetBufferMethodInfo
    ResolveGutterRendererMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveGutterRendererMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveGutterRendererMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveGutterRendererMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveGutterRendererMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveGutterRendererMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveGutterRendererMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveGutterRendererMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveGutterRendererMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveGutterRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveGutterRendererMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveGutterRendererMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveGutterRendererMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveGutterRendererMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveGutterRendererMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveGutterRendererMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveGutterRendererMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveGutterRendererMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveGutterRendererMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveGutterRendererMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveGutterRendererMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveGutterRendererMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveGutterRendererMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveGutterRendererMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveGutterRendererMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveGutterRendererMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveGutterRendererMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveGutterRendererMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveGutterRendererMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveGutterRendererMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveGutterRendererMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveGutterRendererMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveGutterRendererMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveGutterRendererMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveGutterRendererMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveGutterRendererMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveGutterRendererMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveGutterRendererMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveGutterRendererMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveGutterRendererMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveGutterRendererMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveGutterRendererMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveGutterRendererMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveGutterRendererMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveGutterRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveGutterRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveGutterRendererMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveGutterRendererMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveGutterRendererMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveGutterRendererMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveGutterRendererMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveGutterRendererMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveGutterRendererMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveGutterRendererMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveGutterRendererMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveGutterRendererMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveGutterRendererMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveGutterRendererMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveGutterRendererMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveGutterRendererMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveGutterRendererMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveGutterRendererMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveGutterRendererMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveGutterRendererMethod "getView" o = GutterRendererGetViewMethodInfo
    ResolveGutterRendererMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveGutterRendererMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveGutterRendererMethod "getXalign" o = GutterRendererGetXalignMethodInfo
    ResolveGutterRendererMethod "getXpad" o = GutterRendererGetXpadMethodInfo
    ResolveGutterRendererMethod "getYalign" o = GutterRendererGetYalignMethodInfo
    ResolveGutterRendererMethod "getYpad" o = GutterRendererGetYpadMethodInfo
    ResolveGutterRendererMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveGutterRendererMethod "setAlignmentMode" o = GutterRendererSetAlignmentModeMethodInfo
    ResolveGutterRendererMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveGutterRendererMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveGutterRendererMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveGutterRendererMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveGutterRendererMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveGutterRendererMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveGutterRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGutterRendererMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveGutterRendererMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveGutterRendererMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveGutterRendererMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveGutterRendererMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveGutterRendererMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveGutterRendererMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveGutterRendererMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveGutterRendererMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveGutterRendererMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveGutterRendererMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveGutterRendererMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveGutterRendererMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveGutterRendererMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveGutterRendererMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveGutterRendererMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveGutterRendererMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveGutterRendererMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveGutterRendererMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveGutterRendererMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveGutterRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveGutterRendererMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveGutterRendererMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveGutterRendererMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveGutterRendererMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveGutterRendererMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveGutterRendererMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveGutterRendererMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveGutterRendererMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveGutterRendererMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveGutterRendererMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveGutterRendererMethod "setXalign" o = GutterRendererSetXalignMethodInfo
    ResolveGutterRendererMethod "setXpad" o = GutterRendererSetXpadMethodInfo
    ResolveGutterRendererMethod "setYalign" o = GutterRendererSetYalignMethodInfo
    ResolveGutterRendererMethod "setYpad" o = GutterRendererSetYpadMethodInfo
    ResolveGutterRendererMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveGutterRendererMethod t GutterRenderer, O.OverloadedMethod info GutterRenderer p) => OL.IsLabel t (GutterRenderer -> 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 ~ ResolveGutterRendererMethod t GutterRenderer, O.OverloadedMethod info GutterRenderer p, R.HasField t GutterRenderer p) => R.HasField t GutterRenderer p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveGutterRendererMethod t GutterRenderer, O.OverloadedMethodInfo info GutterRenderer) => OL.IsLabel t (O.MethodProxy info GutterRenderer) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal GutterRenderer::activate
-- | The signal is emitted when the renderer is activated.
type GutterRendererActivateCallback =
    Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle'
    -> Word32
    -- ^ /@button@/: the button that was pressed
    -> [Gdk.Flags.ModifierType]
    -- ^ /@state@/: a t'GI.Gdk.Flags.ModifierType' of state
    -> Int32
    -- ^ /@nPresses@/: the number of button presses
    -> IO ()

type C_GutterRendererActivateCallback =
    Ptr GutterRenderer ->                   -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gdk.Rectangle.Rectangle ->
    Word32 ->
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_GutterRendererActivateCallback :: 
    GObject a => (a -> GutterRendererActivateCallback) ->
    C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback :: forall a.
GObject a =>
(a -> GutterRendererActivateCallback)
-> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback a -> GutterRendererActivateCallback
gi'cb Ptr GutterRenderer
gi'selfPtr Ptr TextIter
iter Ptr Rectangle
area Word32
button CUInt
state Int32
nPresses Ptr ()
_ = do
    Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr TextIter
iter ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        Ptr Rectangle -> (Rectangle -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Rectangle
area ((Rectangle -> IO ()) -> IO ()) -> (Rectangle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Rectangle
area' -> do
            let state' :: [ModifierType]
state' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
state
            Ptr GutterRenderer -> (GutterRenderer -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr GutterRenderer
gi'selfPtr ((GutterRenderer -> IO ()) -> IO ())
-> (GutterRenderer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \GutterRenderer
gi'self -> a -> GutterRendererActivateCallback
gi'cb (GutterRenderer -> a
forall a b. Coercible a b => a -> b
Coerce.coerce GutterRenderer
gi'self)  TextIter
iter' Rectangle
area' Word32
button [ModifierType]
state' Int32
nPresses


-- | Connect a signal handler for the [activate](#signal:activate) 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' gutterRenderer #activate callback
-- @
-- 
-- 
onGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererActivateCallback) -> m SignalHandlerId
onGutterRendererActivate :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererActivateCallback)
-> m SignalHandlerId
onGutterRendererActivate a
obj (?self::a) => GutterRendererActivateCallback
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 -> GutterRendererActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererActivateCallback
GutterRendererActivateCallback
cb
    let wrapped' :: C_GutterRendererActivateCallback
wrapped' = (a -> GutterRendererActivateCallback)
-> C_GutterRendererActivateCallback
forall a.
GObject a =>
(a -> GutterRendererActivateCallback)
-> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback a -> GutterRendererActivateCallback
wrapped
    FunPtr C_GutterRendererActivateCallback
wrapped'' <- C_GutterRendererActivateCallback
-> IO (FunPtr C_GutterRendererActivateCallback)
mk_GutterRendererActivateCallback C_GutterRendererActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_GutterRendererActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) 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' gutterRenderer #activate 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.
-- 
afterGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererActivateCallback) -> m SignalHandlerId
afterGutterRendererActivate :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererActivateCallback)
-> m SignalHandlerId
afterGutterRendererActivate a
obj (?self::a) => GutterRendererActivateCallback
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 -> GutterRendererActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererActivateCallback
GutterRendererActivateCallback
cb
    let wrapped' :: C_GutterRendererActivateCallback
wrapped' = (a -> GutterRendererActivateCallback)
-> C_GutterRendererActivateCallback
forall a.
GObject a =>
(a -> GutterRendererActivateCallback)
-> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback a -> GutterRendererActivateCallback
wrapped
    FunPtr C_GutterRendererActivateCallback
wrapped'' <- C_GutterRendererActivateCallback
-> IO (FunPtr C_GutterRendererActivateCallback)
mk_GutterRendererActivateCallback C_GutterRendererActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_GutterRendererActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererActivateSignalInfo
instance SignalInfo GutterRendererActivateSignalInfo where
    type HaskellCallbackType GutterRendererActivateSignalInfo = GutterRendererActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererActivateCallback cb
        cb'' <- mk_GutterRendererActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:signal:activate"})

#endif

-- signal GutterRenderer::query-activatable
-- | The signal is emitted when the renderer can possibly be activated.
type GutterRendererQueryActivatableCallback =
    Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle'
    -> IO Bool

type C_GutterRendererQueryActivatableCallback =
    Ptr GutterRenderer ->                   -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_GutterRendererQueryActivatableCallback :: 
    GObject a => (a -> GutterRendererQueryActivatableCallback) ->
    C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback :: forall a.
GObject a =>
(a -> GutterRendererQueryActivatableCallback)
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback a -> GutterRendererQueryActivatableCallback
gi'cb Ptr GutterRenderer
gi'selfPtr Ptr TextIter
iter Ptr Rectangle
area Ptr ()
_ = do
    Ptr TextIter -> (TextIter -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr TextIter
iter ((TextIter -> IO CInt) -> IO CInt)
-> (TextIter -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        Ptr Rectangle -> (Rectangle -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Rectangle
area ((Rectangle -> IO CInt) -> IO CInt)
-> (Rectangle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Rectangle
area' -> do
            Bool
result <- Ptr GutterRenderer -> (GutterRenderer -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr GutterRenderer
gi'selfPtr ((GutterRenderer -> IO Bool) -> IO Bool)
-> (GutterRenderer -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \GutterRenderer
gi'self -> a -> GutterRendererQueryActivatableCallback
gi'cb (GutterRenderer -> a
forall a b. Coercible a b => a -> b
Coerce.coerce GutterRenderer
gi'self)  TextIter
iter' Rectangle
area'
            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 [queryActivatable](#signal:queryActivatable) 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' gutterRenderer #queryActivatable callback
-- @
-- 
-- 
onGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererQueryActivatableCallback) -> m SignalHandlerId
onGutterRendererQueryActivatable :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererQueryActivatableCallback)
-> m SignalHandlerId
onGutterRendererQueryActivatable a
obj (?self::a) => GutterRendererQueryActivatableCallback
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 -> GutterRendererQueryActivatableCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererQueryActivatableCallback
GutterRendererQueryActivatableCallback
cb
    let wrapped' :: C_GutterRendererQueryActivatableCallback
wrapped' = (a -> GutterRendererQueryActivatableCallback)
-> C_GutterRendererQueryActivatableCallback
forall a.
GObject a =>
(a -> GutterRendererQueryActivatableCallback)
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback a -> GutterRendererQueryActivatableCallback
wrapped
    FunPtr C_GutterRendererQueryActivatableCallback
wrapped'' <- C_GutterRendererQueryActivatableCallback
-> IO (FunPtr C_GutterRendererQueryActivatableCallback)
mk_GutterRendererQueryActivatableCallback C_GutterRendererQueryActivatableCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererQueryActivatableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-activatable" FunPtr C_GutterRendererQueryActivatableCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queryActivatable](#signal:queryActivatable) 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' gutterRenderer #queryActivatable 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.
-- 
afterGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererQueryActivatableCallback) -> m SignalHandlerId
afterGutterRendererQueryActivatable :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererQueryActivatableCallback)
-> m SignalHandlerId
afterGutterRendererQueryActivatable a
obj (?self::a) => GutterRendererQueryActivatableCallback
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 -> GutterRendererQueryActivatableCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererQueryActivatableCallback
GutterRendererQueryActivatableCallback
cb
    let wrapped' :: C_GutterRendererQueryActivatableCallback
wrapped' = (a -> GutterRendererQueryActivatableCallback)
-> C_GutterRendererQueryActivatableCallback
forall a.
GObject a =>
(a -> GutterRendererQueryActivatableCallback)
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback a -> GutterRendererQueryActivatableCallback
wrapped
    FunPtr C_GutterRendererQueryActivatableCallback
wrapped'' <- C_GutterRendererQueryActivatableCallback
-> IO (FunPtr C_GutterRendererQueryActivatableCallback)
mk_GutterRendererQueryActivatableCallback C_GutterRendererQueryActivatableCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererQueryActivatableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-activatable" FunPtr C_GutterRendererQueryActivatableCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryActivatableSignalInfo
instance SignalInfo GutterRendererQueryActivatableSignalInfo where
    type HaskellCallbackType GutterRendererQueryActivatableSignalInfo = GutterRendererQueryActivatableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueryActivatableCallback cb
        cb'' <- mk_GutterRendererQueryActivatableCallback cb'
        connectSignalFunPtr obj "query-activatable" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer::query-activatable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:signal:queryActivatable"})

#endif

-- signal GutterRenderer::query-data
-- | /No description available in the introspection data./
type GutterRendererQueryDataCallback =
    GObject.Object.Object
    -> Word32
    -> IO ()

type C_GutterRendererQueryDataCallback =
    Ptr GutterRenderer ->                   -- object
    Ptr GObject.Object.Object ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_GutterRendererQueryDataCallback :: 
    GObject a => (a -> GutterRendererQueryDataCallback) ->
    C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback :: forall a.
GObject a =>
(a -> GutterRendererQueryDataCallback)
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback a -> GutterRendererQueryDataCallback
gi'cb Ptr GutterRenderer
gi'selfPtr Ptr Object
object Word32
p0 Ptr ()
_ = do
    Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
    Ptr GutterRenderer -> (GutterRenderer -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr GutterRenderer
gi'selfPtr ((GutterRenderer -> IO ()) -> IO ())
-> (GutterRenderer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \GutterRenderer
gi'self -> a -> GutterRendererQueryDataCallback
gi'cb (GutterRenderer -> a
forall a b. Coercible a b => a -> b
Coerce.coerce GutterRenderer
gi'self)  Object
object' Word32
p0


-- | Connect a signal handler for the [queryData](#signal:queryData) 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' gutterRenderer #queryData callback
-- @
-- 
-- 
onGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererQueryDataCallback) -> m SignalHandlerId
onGutterRendererQueryData :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererQueryDataCallback)
-> m SignalHandlerId
onGutterRendererQueryData a
obj (?self::a) => GutterRendererQueryDataCallback
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 -> GutterRendererQueryDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererQueryDataCallback
GutterRendererQueryDataCallback
cb
    let wrapped' :: C_GutterRendererQueryDataCallback
wrapped' = (a -> GutterRendererQueryDataCallback)
-> C_GutterRendererQueryDataCallback
forall a.
GObject a =>
(a -> GutterRendererQueryDataCallback)
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback a -> GutterRendererQueryDataCallback
wrapped
    FunPtr C_GutterRendererQueryDataCallback
wrapped'' <- C_GutterRendererQueryDataCallback
-> IO (FunPtr C_GutterRendererQueryDataCallback)
mk_GutterRendererQueryDataCallback C_GutterRendererQueryDataCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererQueryDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-data" FunPtr C_GutterRendererQueryDataCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queryData](#signal:queryData) 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' gutterRenderer #queryData 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.
-- 
afterGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> ((?self :: a) => GutterRendererQueryDataCallback) -> m SignalHandlerId
afterGutterRendererQueryData :: forall a (m :: * -> *).
(IsGutterRenderer a, MonadIO m) =>
a
-> ((?self::a) => GutterRendererQueryDataCallback)
-> m SignalHandlerId
afterGutterRendererQueryData a
obj (?self::a) => GutterRendererQueryDataCallback
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 -> GutterRendererQueryDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GutterRendererQueryDataCallback
GutterRendererQueryDataCallback
cb
    let wrapped' :: C_GutterRendererQueryDataCallback
wrapped' = (a -> GutterRendererQueryDataCallback)
-> C_GutterRendererQueryDataCallback
forall a.
GObject a =>
(a -> GutterRendererQueryDataCallback)
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback a -> GutterRendererQueryDataCallback
wrapped
    FunPtr C_GutterRendererQueryDataCallback
wrapped'' <- C_GutterRendererQueryDataCallback
-> IO (FunPtr C_GutterRendererQueryDataCallback)
mk_GutterRendererQueryDataCallback C_GutterRendererQueryDataCallback
wrapped'
    a
-> Text
-> FunPtr C_GutterRendererQueryDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-data" FunPtr C_GutterRendererQueryDataCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryDataSignalInfo
instance SignalInfo GutterRendererQueryDataSignalInfo where
    type HaskellCallbackType GutterRendererQueryDataSignalInfo = GutterRendererQueryDataCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueryDataCallback cb
        cb'' <- mk_GutterRendererQueryDataCallback cb'
        connectSignalFunPtr obj "query-data" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer::query-data"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:signal:queryData"})

#endif

-- VVV Prop "alignment-mode"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@alignment-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gutterRenderer [ #alignmentMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setGutterRendererAlignmentMode :: (MonadIO m, IsGutterRenderer o) => o -> GtkSource.Enums.GutterRendererAlignmentMode -> m ()
setGutterRendererAlignmentMode :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> GutterRendererAlignmentMode -> m ()
setGutterRendererAlignmentMode o
obj GutterRendererAlignmentMode
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 -> GutterRendererAlignmentMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"alignment-mode" GutterRendererAlignmentMode
val

-- | Construct a `GValueConstruct` with valid value for the “@alignment-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGutterRendererAlignmentMode :: (IsGutterRenderer o, MIO.MonadIO m) => GtkSource.Enums.GutterRendererAlignmentMode -> m (GValueConstruct o)
constructGutterRendererAlignmentMode :: forall o (m :: * -> *).
(IsGutterRenderer o, MonadIO m) =>
GutterRendererAlignmentMode -> m (GValueConstruct o)
constructGutterRendererAlignmentMode GutterRendererAlignmentMode
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 -> GutterRendererAlignmentMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"alignment-mode" GutterRendererAlignmentMode
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererAlignmentModePropertyInfo
instance AttrInfo GutterRendererAlignmentModePropertyInfo where
    type AttrAllowedOps GutterRendererAlignmentModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererAlignmentModePropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode
    type AttrTransferTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode
    type AttrTransferType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode
    type AttrGetType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode
    type AttrLabel GutterRendererAlignmentModePropertyInfo = "alignment-mode"
    type AttrOrigin GutterRendererAlignmentModePropertyInfo = GutterRenderer
    attrGet = getGutterRendererAlignmentMode
    attrSet = setGutterRendererAlignmentMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererAlignmentMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.alignmentMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:alignmentMode"
        })
#endif

-- VVV Prop "lines"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "GutterLines"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererLinesPropertyInfo
instance AttrInfo GutterRendererLinesPropertyInfo where
    type AttrAllowedOps GutterRendererLinesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GutterRendererLinesPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererLinesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint GutterRendererLinesPropertyInfo = (~) ()
    type AttrTransferType GutterRendererLinesPropertyInfo = ()
    type AttrGetType GutterRendererLinesPropertyInfo = (Maybe GtkSource.GutterLines.GutterLines)
    type AttrLabel GutterRendererLinesPropertyInfo = "lines"
    type AttrOrigin GutterRendererLinesPropertyInfo = GutterRenderer
    attrGet = getGutterRendererLines
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.lines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:lines"
        })
#endif

-- VVV Prop "view"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextView"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererViewPropertyInfo
instance AttrInfo GutterRendererViewPropertyInfo where
    type AttrAllowedOps GutterRendererViewPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GutterRendererViewPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererViewPropertyInfo = (~) ()
    type AttrTransferTypeConstraint GutterRendererViewPropertyInfo = (~) ()
    type AttrTransferType GutterRendererViewPropertyInfo = ()
    type AttrGetType GutterRendererViewPropertyInfo = (Maybe Gtk.TextView.TextView)
    type AttrLabel GutterRendererViewPropertyInfo = "view"
    type AttrOrigin GutterRendererViewPropertyInfo = GutterRenderer
    attrGet = getGutterRendererView
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.view"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:view"
        })
#endif

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- 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' gutterRenderer #xalign
-- @
getGutterRendererXalign :: (MonadIO m, IsGutterRenderer o) => o -> m Float
getGutterRendererXalign :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> m Float
getGutterRendererXalign o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat 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' gutterRenderer [ #xalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setGutterRendererXalign :: (MonadIO m, IsGutterRenderer o) => o -> Float -> m ()
setGutterRendererXalign :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> Float -> m ()
setGutterRendererXalign o
obj Float
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 -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"xalign" Float
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`.
constructGutterRendererXalign :: (IsGutterRenderer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructGutterRendererXalign :: forall o (m :: * -> *).
(IsGutterRenderer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructGutterRendererXalign Float
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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"xalign" Float
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererXalignPropertyInfo
instance AttrInfo GutterRendererXalignPropertyInfo where
    type AttrAllowedOps GutterRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererXalignPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint GutterRendererXalignPropertyInfo = (~) Float
    type AttrTransferType GutterRendererXalignPropertyInfo = Float
    type AttrGetType GutterRendererXalignPropertyInfo = Float
    type AttrLabel GutterRendererXalignPropertyInfo = "xalign"
    type AttrOrigin GutterRendererXalignPropertyInfo = GutterRenderer
    attrGet = getGutterRendererXalign
    attrSet = setGutterRendererXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererXalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.xalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:xalign"
        })
#endif

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

-- | Get the value of the “@xpad@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' gutterRenderer #xpad
-- @
getGutterRendererXpad :: (MonadIO m, IsGutterRenderer o) => o -> m Int32
getGutterRendererXpad :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> m Int32
getGutterRendererXpad 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
"xpad"

-- | Set the value of the “@xpad@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gutterRenderer [ #xpad 'Data.GI.Base.Attributes.:=' value ]
-- @
setGutterRendererXpad :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m ()
setGutterRendererXpad :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> Int32 -> m ()
setGutterRendererXpad 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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"xpad" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@xpad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGutterRendererXpad :: (IsGutterRenderer o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructGutterRendererXpad :: forall o (m :: * -> *).
(IsGutterRenderer o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructGutterRendererXpad 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
"xpad" Int32
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererXpadPropertyInfo
instance AttrInfo GutterRendererXpadPropertyInfo where
    type AttrAllowedOps GutterRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererXpadPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32
    type AttrTransferType GutterRendererXpadPropertyInfo = Int32
    type AttrGetType GutterRendererXpadPropertyInfo = Int32
    type AttrLabel GutterRendererXpadPropertyInfo = "xpad"
    type AttrOrigin GutterRendererXpadPropertyInfo = GutterRenderer
    attrGet = getGutterRendererXpad
    attrSet = setGutterRendererXpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererXpad
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.xpad"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:xpad"
        })
#endif

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- 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' gutterRenderer #yalign
-- @
getGutterRendererYalign :: (MonadIO m, IsGutterRenderer o) => o -> m Float
getGutterRendererYalign :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> m Float
getGutterRendererYalign o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat 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' gutterRenderer [ #yalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setGutterRendererYalign :: (MonadIO m, IsGutterRenderer o) => o -> Float -> m ()
setGutterRendererYalign :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> Float -> m ()
setGutterRendererYalign o
obj Float
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 -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"yalign" Float
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`.
constructGutterRendererYalign :: (IsGutterRenderer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructGutterRendererYalign :: forall o (m :: * -> *).
(IsGutterRenderer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructGutterRendererYalign Float
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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"yalign" Float
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererYalignPropertyInfo
instance AttrInfo GutterRendererYalignPropertyInfo where
    type AttrAllowedOps GutterRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererYalignPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint GutterRendererYalignPropertyInfo = (~) Float
    type AttrTransferType GutterRendererYalignPropertyInfo = Float
    type AttrGetType GutterRendererYalignPropertyInfo = Float
    type AttrLabel GutterRendererYalignPropertyInfo = "yalign"
    type AttrOrigin GutterRendererYalignPropertyInfo = GutterRenderer
    attrGet = getGutterRendererYalign
    attrSet = setGutterRendererYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererYalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.yalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:yalign"
        })
#endif

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

-- | Get the value of the “@ypad@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' gutterRenderer #ypad
-- @
getGutterRendererYpad :: (MonadIO m, IsGutterRenderer o) => o -> m Int32
getGutterRendererYpad :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> m Int32
getGutterRendererYpad 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
"ypad"

-- | Set the value of the “@ypad@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gutterRenderer [ #ypad 'Data.GI.Base.Attributes.:=' value ]
-- @
setGutterRendererYpad :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m ()
setGutterRendererYpad :: forall (m :: * -> *) o.
(MonadIO m, IsGutterRenderer o) =>
o -> Int32 -> m ()
setGutterRendererYpad 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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"ypad" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@ypad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGutterRendererYpad :: (IsGutterRenderer o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructGutterRendererYpad :: forall o (m :: * -> *).
(IsGutterRenderer o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructGutterRendererYpad 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
"ypad" Int32
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererYpadPropertyInfo
instance AttrInfo GutterRendererYpadPropertyInfo where
    type AttrAllowedOps GutterRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererYpadPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererYpadPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterRendererYpadPropertyInfo = (~) Int32
    type AttrTransferType GutterRendererYpadPropertyInfo = Int32
    type AttrGetType GutterRendererYpadPropertyInfo = Int32
    type AttrLabel GutterRendererYpadPropertyInfo = "ypad"
    type AttrOrigin GutterRendererYpadPropertyInfo = GutterRenderer
    attrGet = getGutterRendererYpad
    attrSet = setGutterRendererYpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererYpad
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.ypad"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#g:attr:ypad"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GutterRenderer
type instance O.AttributeList GutterRenderer = GutterRendererAttributeList
type GutterRendererAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("alignmentMode", GutterRendererAlignmentModePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("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), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("lines", GutterRendererLinesPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("view", GutterRendererViewPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("xalign", GutterRendererXalignPropertyInfo), '("xpad", GutterRendererXpadPropertyInfo), '("yalign", GutterRendererYalignPropertyInfo), '("ypad", GutterRendererYpadPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
gutterRendererAlignmentMode :: AttrLabelProxy "alignmentMode"
gutterRendererAlignmentMode = AttrLabelProxy

gutterRendererLines :: AttrLabelProxy "lines"
gutterRendererLines = AttrLabelProxy

gutterRendererView :: AttrLabelProxy "view"
gutterRendererView = AttrLabelProxy

gutterRendererXalign :: AttrLabelProxy "xalign"
gutterRendererXalign = AttrLabelProxy

gutterRendererXpad :: AttrLabelProxy "xpad"
gutterRendererXpad = AttrLabelProxy

gutterRendererYalign :: AttrLabelProxy "yalign"
gutterRendererYalign = AttrLabelProxy

gutterRendererYpad :: AttrLabelProxy "ypad"
gutterRendererYpad = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList GutterRenderer = GutterRendererSignalList
type GutterRendererSignalList = ('[ '("activate", GutterRendererActivateSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryActivatable", GutterRendererQueryActivatableSignalInfo), '("queryData", GutterRendererQueryDataSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method GutterRenderer::activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GtkTextIter at the start of the line where the renderer is activated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GdkRectangle of the cell area where the renderer is activated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "button"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the button that was pressed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkModifierType" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_presses"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of button presses"
--                 , 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 "gtk_source_gutter_renderer_activate" gtk_source_gutter_renderer_activate :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gdk.Rectangle.Rectangle ->          -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Word32 ->                               -- button : TBasicType TUInt
    CUInt ->                                -- state : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    Int32 ->                                -- n_presses : TBasicType TInt
    IO ()

-- | Emits the [signal/@gutterRenderer@/[activate](#g:signal:activate)] signal of the renderer. This is
-- called from [class/@gutter@/] and should never have to be called manually.
gutterRendererActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter' at the start of the line where the renderer is activated
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area where the renderer is activated
    -> Word32
    -- ^ /@button@/: the button that was pressed
    -> [Gdk.Flags.ModifierType]
    -- ^ /@state@/: a t'GI.Gdk.Flags.ModifierType'
    -> Int32
    -- ^ /@nPresses@/: the number of button presses
    -> m ()
gutterRendererActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a
-> TextIter
-> Rectangle
-> Word32
-> [ModifierType]
-> Int32
-> m ()
gutterRendererActivate a
renderer TextIter
iter Rectangle
area Word32
button [ModifierType]
state Int32
nPresses = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    let state' :: CUInt
state' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
state
    Ptr GutterRenderer
-> Ptr TextIter
-> Ptr Rectangle
-> Word32
-> CUInt
-> Int32
-> IO ()
gtk_source_gutter_renderer_activate Ptr GutterRenderer
renderer' Ptr TextIter
iter' Ptr Rectangle
area' Word32
button CUInt
state' Int32
nPresses
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererActivateMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Word32 -> [Gdk.Flags.ModifierType] -> Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererActivateMethodInfo a signature where
    overloadedMethod = gutterRendererActivate

instance O.OverloadedMethodInfo GutterRendererActivateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererActivate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererActivate"
        })


#endif

-- method GutterRenderer::align_cell
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the line number for content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width of the content to draw"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height of the content to draw"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the X position to render the content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y position to render the content"
--                 , 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 "gtk_source_gutter_renderer_align_cell" gtk_source_gutter_renderer_align_cell :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Word32 ->                               -- line : TBasicType TUInt
    CFloat ->                               -- width : TBasicType TFloat
    CFloat ->                               -- height : TBasicType TFloat
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    IO ()

-- | Locates where to render content that is /@width@/ x /@height@/ based on
-- the renderers alignment and padding.
-- 
-- The location will be placed into /@x@/ and /@y@/ and is relative to the
-- renderer\'s coordinates.
-- 
-- It is encouraged that renderers use this function when snappshotting
-- to ensure consistent placement of their contents.
gutterRendererAlignCell ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: the t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Word32
    -- ^ /@line@/: the line number for content
    -> Float
    -- ^ /@width@/: the width of the content to draw
    -> Float
    -- ^ /@height@/: the height of the content to draw
    -> m ((Float, Float))
gutterRendererAlignCell :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> Word32 -> Float -> Float -> m (Float, Float)
gutterRendererAlignCell a
renderer Word32
line Float
width Float
height = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr GutterRenderer
-> Word32 -> CFloat -> CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
gtk_source_gutter_renderer_align_cell Ptr GutterRenderer
renderer' Word32
line CFloat
width' CFloat
height' Ptr CFloat
x Ptr CFloat
y
    CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
    let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
    CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
    let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
x'', Float
y'')

#if defined(ENABLE_OVERLOADING)
data GutterRendererAlignCellMethodInfo
instance (signature ~ (Word32 -> Float -> Float -> m ((Float, Float))), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererAlignCellMethodInfo a signature where
    overloadedMethod = gutterRendererAlignCell

instance O.OverloadedMethodInfo GutterRendererAlignCellMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererAlignCell",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererAlignCell"
        })


#endif

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

foreign import ccall "gtk_source_gutter_renderer_get_alignment_mode" gtk_source_gutter_renderer_get_alignment_mode :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO CUInt

-- | Get the alignment mode.
-- 
-- The alignment mode describes the manner in which the
-- renderer is aligned (see [property/@gutterRenderer@/:xalign] and
-- [property/@gutterRenderer@/:yalign]).
gutterRendererGetAlignmentMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m GtkSource.Enums.GutterRendererAlignmentMode
    -- ^ __Returns:__ a t'GI.GtkSource.Enums.GutterRendererAlignmentMode'
gutterRendererGetAlignmentMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m GutterRendererAlignmentMode
gutterRendererGetAlignmentMode a
renderer = IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode)
-> IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CUInt
result <- Ptr GutterRenderer -> IO CUInt
gtk_source_gutter_renderer_get_alignment_mode Ptr GutterRenderer
renderer'
    let result' :: GutterRendererAlignmentMode
result' = (Int -> GutterRendererAlignmentMode
forall a. Enum a => Int -> a
toEnum (Int -> GutterRendererAlignmentMode)
-> (CUInt -> Int) -> CUInt -> GutterRendererAlignmentMode
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
renderer
    GutterRendererAlignmentMode -> IO GutterRendererAlignmentMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GutterRendererAlignmentMode
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetAlignmentModeMethodInfo
instance (signature ~ (m GtkSource.Enums.GutterRendererAlignmentMode), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetAlignmentModeMethodInfo a signature where
    overloadedMethod = gutterRendererGetAlignmentMode

instance O.OverloadedMethodInfo GutterRendererGetAlignmentModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetAlignmentMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetAlignmentMode"
        })


#endif

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

foreign import ccall "gtk_source_gutter_renderer_get_buffer" gtk_source_gutter_renderer_get_buffer :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO (Ptr GtkSource.Buffer.Buffer)

-- | Gets the [class/@buffer@/] for which the gutter renderer is drawing.
gutterRendererGetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m (Maybe GtkSource.Buffer.Buffer)
    -- ^ __Returns:__ a t'GI.Gtk.Objects.TextBuffer.TextBuffer' or 'P.Nothing'
gutterRendererGetBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m (Maybe Buffer)
gutterRendererGetBuffer a
renderer = IO (Maybe Buffer) -> m (Maybe Buffer)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr Buffer
result <- Ptr GutterRenderer -> IO (Ptr Buffer)
gtk_source_gutter_renderer_get_buffer Ptr GutterRenderer
renderer'
    Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
        Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Buffer -> Buffer
GtkSource.Buffer.Buffer) Ptr Buffer
result'
        Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Maybe Buffer -> IO (Maybe Buffer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetBufferMethodInfo
instance (signature ~ (m (Maybe GtkSource.Buffer.Buffer)), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetBufferMethodInfo a signature where
    overloadedMethod = gutterRendererGetBuffer

instance O.OverloadedMethodInfo GutterRendererGetBufferMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetBuffer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetBuffer"
        })


#endif

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

foreign import ccall "gtk_source_gutter_renderer_get_view" gtk_source_gutter_renderer_get_view :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO (Ptr GtkSource.View.View)

-- | Get the view associated to the gutter renderer
gutterRendererGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m GtkSource.View.View
    -- ^ __Returns:__ a t'GI.GtkSource.Objects.View.View'
gutterRendererGetView :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m View
gutterRendererGetView a
renderer = IO View -> m View
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO View -> m View) -> IO View -> m View
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr View
result <- Ptr GutterRenderer -> IO (Ptr View)
gtk_source_gutter_renderer_get_view Ptr GutterRenderer
renderer'
    Text -> Ptr View -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gutterRendererGetView" Ptr View
result
    View
result' <- ((ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr View -> View
GtkSource.View.View) Ptr View
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    View -> IO View
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return View
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetViewMethodInfo
instance (signature ~ (m GtkSource.View.View), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetViewMethodInfo a signature where
    overloadedMethod = gutterRendererGetView

instance O.OverloadedMethodInfo GutterRendererGetViewMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetView",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetView"
        })


#endif

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

foreign import ccall "gtk_source_gutter_renderer_get_xalign" gtk_source_gutter_renderer_get_xalign :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO CFloat

-- | Gets the @xalign@ property.
-- 
-- This may be used to adjust where within the cell rectangle the renderer will draw.
gutterRendererGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Float
gutterRendererGetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m Float
gutterRendererGetXalign a
renderer = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CFloat
result <- Ptr GutterRenderer -> IO CFloat
gtk_source_gutter_renderer_get_xalign Ptr GutterRenderer
renderer'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetXalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetXalignMethodInfo a signature where
    overloadedMethod = gutterRendererGetXalign

instance O.OverloadedMethodInfo GutterRendererGetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetXalign"
        })


#endif

-- method GutterRenderer::get_xpad
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , 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 "gtk_source_gutter_renderer_get_xpad" gtk_source_gutter_renderer_get_xpad :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO Int32

-- | Gets the @xpad@ property.
-- 
-- This may be used to adjust the cell rectangle that the renderer will use to draw.
gutterRendererGetXpad ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Int32
gutterRendererGetXpad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m Int32
gutterRendererGetXpad a
renderer = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Int32
result <- Ptr GutterRenderer -> IO Int32
gtk_source_gutter_renderer_get_xpad Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetXpadMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetXpadMethodInfo a signature where
    overloadedMethod = gutterRendererGetXpad

instance O.OverloadedMethodInfo GutterRendererGetXpadMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetXpad",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetXpad"
        })


#endif

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

foreign import ccall "gtk_source_gutter_renderer_get_yalign" gtk_source_gutter_renderer_get_yalign :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO CFloat

-- | Gets the @yalign@ property.
-- 
-- This may be used to adjust where within the cell rectangle the renderer will draw.
gutterRendererGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Float
gutterRendererGetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m Float
gutterRendererGetYalign a
renderer = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CFloat
result <- Ptr GutterRenderer -> IO CFloat
gtk_source_gutter_renderer_get_yalign Ptr GutterRenderer
renderer'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetYalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetYalignMethodInfo a signature where
    overloadedMethod = gutterRendererGetYalign

instance O.OverloadedMethodInfo GutterRendererGetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetYalign"
        })


#endif

-- method GutterRenderer::get_ypad
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , 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 "gtk_source_gutter_renderer_get_ypad" gtk_source_gutter_renderer_get_ypad :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO Int32

-- | Gets the @ypad@ property.
-- 
-- This may be used to adjust the cell rectangle that the renderer will use to draw.
gutterRendererGetYpad ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Int32
gutterRendererGetYpad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> m Int32
gutterRendererGetYpad a
renderer = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Int32
result <- Ptr GutterRenderer -> IO Int32
gtk_source_gutter_renderer_get_ypad Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetYpadMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererGetYpadMethodInfo a signature where
    overloadedMethod = gutterRendererGetYpad

instance O.OverloadedMethodInfo GutterRendererGetYpadMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererGetYpad",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererGetYpad"
        })


#endif

-- method GutterRenderer::query_activatable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GtkTextIter at the start of the line to be activated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GdkRectangle of the cell area to be activated"
--                 , 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 "gtk_source_gutter_renderer_query_activatable" gtk_source_gutter_renderer_query_activatable :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gdk.Rectangle.Rectangle ->          -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO CInt

-- | Get whether the renderer is activatable at the location provided. This is
-- called from [class/@gutter@/] to determine whether a renderer is activatable
-- using the mouse pointer.
gutterRendererQueryActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter' at the start of the line to be activated
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area to be activated
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the renderer can be activated, 'P.False' otherwise
gutterRendererQueryActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> TextIter -> Rectangle -> m Bool
gutterRendererQueryActivatable a
renderer TextIter
iter Rectangle
area = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    CInt
result <- Ptr GutterRenderer -> Ptr TextIter -> Ptr Rectangle -> IO CInt
gtk_source_gutter_renderer_query_activatable Ptr GutterRenderer
renderer' Ptr TextIter
iter' Ptr Rectangle
area'
    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
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryActivatableMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> m Bool), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererQueryActivatableMethodInfo a signature where
    overloadedMethod = gutterRendererQueryActivatable

instance O.OverloadedMethodInfo GutterRendererQueryActivatableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererQueryActivatable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererQueryActivatable"
        })


#endif

-- method GutterRenderer::set_alignment_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface
--                 Name
--                   { namespace = "GtkSource" , name = "GutterRendererAlignmentMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRendererAlignmentMode"
--                 , 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 "gtk_source_gutter_renderer_set_alignment_mode" gtk_source_gutter_renderer_set_alignment_mode :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"})
    IO ()

-- | Set the alignment mode. The alignment mode describes the manner in which the
-- renderer is aligned (see [property/@gutterRenderer@/:xalign] and
-- [property/@gutterRenderer@/:yalign]).
gutterRendererSetAlignmentMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> GtkSource.Enums.GutterRendererAlignmentMode
    -- ^ /@mode@/: a t'GI.GtkSource.Enums.GutterRendererAlignmentMode'
    -> m ()
gutterRendererSetAlignmentMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> GutterRendererAlignmentMode -> m ()
gutterRendererSetAlignmentMode a
renderer GutterRendererAlignmentMode
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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (GutterRendererAlignmentMode -> Int)
-> GutterRendererAlignmentMode
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GutterRendererAlignmentMode -> Int
forall a. Enum a => a -> Int
fromEnum) GutterRendererAlignmentMode
mode
    Ptr GutterRenderer -> CUInt -> IO ()
gtk_source_gutter_renderer_set_alignment_mode Ptr GutterRenderer
renderer' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetAlignmentModeMethodInfo
instance (signature ~ (GtkSource.Enums.GutterRendererAlignmentMode -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererSetAlignmentModeMethodInfo a signature where
    overloadedMethod = gutterRendererSetAlignmentMode

instance O.OverloadedMethodInfo GutterRendererSetAlignmentModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererSetAlignmentMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererSetAlignmentMode"
        })


#endif

-- method GutterRenderer::set_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y padding for the drawing cell"
--                 , 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 "gtk_source_gutter_renderer_set_xalign" gtk_source_gutter_renderer_set_xalign :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

-- | Adjusts the @xalign@ property.
-- 
-- This may be used to adjust where within the cell rectangle the renderer will draw.
gutterRendererSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Float
    -- ^ /@xalign@/: the Y padding for the drawing cell
    -> m ()
gutterRendererSetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> Float -> m ()
gutterRendererSetXalign a
renderer Float
xalign = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    Ptr GutterRenderer -> CFloat -> IO ()
gtk_source_gutter_renderer_set_xalign Ptr GutterRenderer
renderer' CFloat
xalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetXalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererSetXalignMethodInfo a signature where
    overloadedMethod = gutterRendererSetXalign

instance O.OverloadedMethodInfo GutterRendererSetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererSetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererSetXalign"
        })


#endif

-- method GutterRenderer::set_xpad
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xpad"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y padding for the drawing cell"
--                 , 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 "gtk_source_gutter_renderer_set_xpad" gtk_source_gutter_renderer_set_xpad :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- xpad : TBasicType TInt
    IO ()

-- | Adjusts the @xpad@ property.
-- 
-- This may be used to adjust the cell rectangle that the renderer will use to draw.
gutterRendererSetXpad ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Int32
    -- ^ /@xpad@/: the Y padding for the drawing cell
    -> m ()
gutterRendererSetXpad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> Int32 -> m ()
gutterRendererSetXpad a
renderer Int32
xpad = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> Int32 -> IO ()
gtk_source_gutter_renderer_set_xpad Ptr GutterRenderer
renderer' Int32
xpad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetXpadMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererSetXpadMethodInfo a signature where
    overloadedMethod = gutterRendererSetXpad

instance O.OverloadedMethodInfo GutterRendererSetXpadMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererSetXpad",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererSetXpad"
        })


#endif

-- method GutterRenderer::set_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y padding for the drawing cell"
--                 , 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 "gtk_source_gutter_renderer_set_yalign" gtk_source_gutter_renderer_set_yalign :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

-- | Adjusts the @yalign@ property.
-- 
-- This may be used to adjust where within the cell rectangle the renderer will draw.
gutterRendererSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Float
    -- ^ /@yalign@/: the Y padding for the drawing cell
    -> m ()
gutterRendererSetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> Float -> m ()
gutterRendererSetYalign a
renderer Float
yalign = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr GutterRenderer -> CFloat -> IO ()
gtk_source_gutter_renderer_set_yalign Ptr GutterRenderer
renderer' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetYalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererSetYalignMethodInfo a signature where
    overloadedMethod = gutterRendererSetYalign

instance O.OverloadedMethodInfo GutterRendererSetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererSetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererSetYalign"
        })


#endif

-- method GutterRenderer::set_ypad
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ypad"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y padding for the drawing cell"
--                 , 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 "gtk_source_gutter_renderer_set_ypad" gtk_source_gutter_renderer_set_ypad :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- ypad : TBasicType TInt
    IO ()

-- | Adjusts the @ypad@ property.
-- 
-- This may be used to adjust the cell rectangle that the renderer will use to draw.
gutterRendererSetYpad ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Int32
    -- ^ /@ypad@/: the Y padding for the drawing cell
    -> m ()
gutterRendererSetYpad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutterRenderer a) =>
a -> Int32 -> m ()
gutterRendererSetYpad a
renderer Int32
ypad = 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 GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> Int32 -> IO ()
gtk_source_gutter_renderer_set_ypad Ptr GutterRenderer
renderer' Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetYpadMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.OverloadedMethod GutterRendererSetYpadMethodInfo a signature where
    overloadedMethod = gutterRendererSetYpad

instance O.OverloadedMethodInfo GutterRendererSetYpadMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.GutterRenderer.gutterRendererSetYpad",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-GutterRenderer.html#v:gutterRendererSetYpad"
        })


#endif