gi-gtksource-3.0.18: GI/GtkSource/Objects/GutterRenderer.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.GtkSource.Objects.GutterRenderer
    ( 
#if ENABLE_OVERLOADING
    GutterRendererGetAlignmentMethodInfo    ,
#endif
#if ENABLE_OVERLOADING
    GutterRendererGetPaddingMethodInfo      ,
#endif

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


 -- * Methods
-- ** activate #method:activate#

#if ENABLE_OVERLOADING
    GutterRendererActivateMethodInfo        ,
#endif
    gutterRendererActivate                  ,


-- ** begin #method:begin#

#if ENABLE_OVERLOADING
    GutterRendererBeginMethodInfo           ,
#endif
    gutterRendererBegin                     ,


-- ** draw #method:draw#

#if ENABLE_OVERLOADING
    GutterRendererDrawMethodInfo            ,
#endif
    gutterRendererDraw                      ,


-- ** end #method:end#

#if ENABLE_OVERLOADING
    GutterRendererEndMethodInfo             ,
#endif
    gutterRendererEnd                       ,


-- ** getAlignmentMode #method:getAlignmentMode#

#if ENABLE_OVERLOADING
    GutterRendererGetAlignmentModeMethodInfo,
#endif
    gutterRendererGetAlignmentMode          ,


-- ** getBackground #method:getBackground#

#if ENABLE_OVERLOADING
    GutterRendererGetBackgroundMethodInfo   ,
#endif
    gutterRendererGetBackground             ,


-- ** getSize #method:getSize#

#if ENABLE_OVERLOADING
    GutterRendererGetSizeMethodInfo         ,
#endif
    gutterRendererGetSize                   ,


-- ** getView #method:getView#

#if ENABLE_OVERLOADING
    GutterRendererGetViewMethodInfo         ,
#endif
    gutterRendererGetView                   ,


-- ** getVisible #method:getVisible#

#if ENABLE_OVERLOADING
    GutterRendererGetVisibleMethodInfo      ,
#endif
    gutterRendererGetVisible                ,


-- ** getWindowType #method:getWindowType#

#if ENABLE_OVERLOADING
    GutterRendererGetWindowTypeMethodInfo   ,
#endif
    gutterRendererGetWindowType             ,


-- ** queryActivatable #method:queryActivatable#

#if ENABLE_OVERLOADING
    GutterRendererQueryActivatableMethodInfo,
#endif
    gutterRendererQueryActivatable          ,


-- ** queryData #method:queryData#

#if ENABLE_OVERLOADING
    GutterRendererQueryDataMethodInfo       ,
#endif
    gutterRendererQueryData                 ,


-- ** queryTooltip #method:queryTooltip#

#if ENABLE_OVERLOADING
    GutterRendererQueryTooltipMethodInfo    ,
#endif
    gutterRendererQueryTooltip              ,


-- ** queueDraw #method:queueDraw#

#if ENABLE_OVERLOADING
    GutterRendererQueueDrawMethodInfo       ,
#endif
    gutterRendererQueueDraw                 ,


-- ** setAlignment #method:setAlignment#

#if ENABLE_OVERLOADING
    GutterRendererSetAlignmentMethodInfo    ,
#endif
    gutterRendererSetAlignment              ,


-- ** setAlignmentMode #method:setAlignmentMode#

#if ENABLE_OVERLOADING
    GutterRendererSetAlignmentModeMethodInfo,
#endif
    gutterRendererSetAlignmentMode          ,


-- ** setBackground #method:setBackground#

#if ENABLE_OVERLOADING
    GutterRendererSetBackgroundMethodInfo   ,
#endif
    gutterRendererSetBackground             ,


-- ** setPadding #method:setPadding#

#if ENABLE_OVERLOADING
    GutterRendererSetPaddingMethodInfo      ,
#endif
    gutterRendererSetPadding                ,


-- ** setSize #method:setSize#

#if ENABLE_OVERLOADING
    GutterRendererSetSizeMethodInfo         ,
#endif
    gutterRendererSetSize                   ,


-- ** setVisible #method:setVisible#

#if ENABLE_OVERLOADING
    GutterRendererSetVisibleMethodInfo      ,
#endif
    gutterRendererSetVisible                ,




 -- * 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 ENABLE_OVERLOADING
    GutterRendererAlignmentModePropertyInfo ,
#endif
    constructGutterRendererAlignmentMode    ,
    getGutterRendererAlignmentMode          ,
#if ENABLE_OVERLOADING
    gutterRendererAlignmentMode             ,
#endif
    setGutterRendererAlignmentMode          ,


-- ** backgroundRgba #attr:backgroundRgba#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    GutterRendererBackgroundRgbaPropertyInfo,
#endif
    clearGutterRendererBackgroundRgba       ,
    constructGutterRendererBackgroundRgba   ,
    getGutterRendererBackgroundRgba         ,
#if ENABLE_OVERLOADING
    gutterRendererBackgroundRgba            ,
#endif
    setGutterRendererBackgroundRgba         ,


-- ** backgroundSet #attr:backgroundSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    GutterRendererBackgroundSetPropertyInfo ,
#endif
    constructGutterRendererBackgroundSet    ,
    getGutterRendererBackgroundSet          ,
#if ENABLE_OVERLOADING
    gutterRendererBackgroundSet             ,
#endif
    setGutterRendererBackgroundSet          ,


-- ** size #attr:size#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    GutterRendererSizePropertyInfo          ,
#endif
    constructGutterRendererSize             ,
    getGutterRendererSize                   ,
#if ENABLE_OVERLOADING
    gutterRendererSize                      ,
#endif
    setGutterRendererSize                   ,


-- ** view #attr:view#
{- | The view on which the renderer is placed.
-}
#if ENABLE_OVERLOADING
    GutterRendererViewPropertyInfo          ,
#endif
    getGutterRendererView                   ,
#if ENABLE_OVERLOADING
    gutterRendererView                      ,
#endif


-- ** visible #attr:visible#
{- | The visibility of the renderer.
-}
#if ENABLE_OVERLOADING
    GutterRendererVisiblePropertyInfo       ,
#endif
    constructGutterRendererVisible          ,
    getGutterRendererVisible                ,
#if ENABLE_OVERLOADING
    gutterRendererVisible                   ,
#endif
    setGutterRendererVisible                ,


-- ** windowType #attr:windowType#
{- | The window type of the view on which the renderer is placed (left,
or right).
-}
#if ENABLE_OVERLOADING
    GutterRendererWindowTypePropertyInfo    ,
#endif
    getGutterRendererWindowType             ,
#if ENABLE_OVERLOADING
    gutterRendererWindowType                ,
#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 ENABLE_OVERLOADING
    GutterRendererXalignPropertyInfo        ,
#endif
    constructGutterRendererXalign           ,
    getGutterRendererXalign                 ,
#if ENABLE_OVERLOADING
    gutterRendererXalign                    ,
#endif
    setGutterRendererXalign                 ,


-- ** xpad #attr:xpad#
{- | The left and right padding of the renderer.
-}
#if ENABLE_OVERLOADING
    GutterRendererXpadPropertyInfo          ,
#endif
    constructGutterRendererXpad             ,
    getGutterRendererXpad                   ,
#if 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 ENABLE_OVERLOADING
    GutterRendererYalignPropertyInfo        ,
#endif
    constructGutterRendererYalign           ,
    getGutterRendererYalign                 ,
#if ENABLE_OVERLOADING
    gutterRendererYalign                    ,
#endif
    setGutterRendererYalign                 ,


-- ** ypad #attr:ypad#
{- | The top and bottom padding of the renderer.
-}
#if ENABLE_OVERLOADING
    GutterRendererYpadPropertyInfo          ,
#endif
    constructGutterRendererYpad             ,
    getGutterRendererYpad                   ,
#if ENABLE_OVERLOADING
    gutterRendererYpad                      ,
#endif
    setGutterRendererYpad                   ,




 -- * Signals
-- ** activate #signal:activate#

    C_GutterRendererActivateCallback        ,
    GutterRendererActivateCallback          ,
#if ENABLE_OVERLOADING
    GutterRendererActivateSignalInfo        ,
#endif
    afterGutterRendererActivate             ,
    genClosure_GutterRendererActivate       ,
    mk_GutterRendererActivateCallback       ,
    noGutterRendererActivateCallback        ,
    onGutterRendererActivate                ,
    wrap_GutterRendererActivateCallback     ,


-- ** queryActivatable #signal:queryActivatable#

    C_GutterRendererQueryActivatableCallback,
    GutterRendererQueryActivatableCallback  ,
#if ENABLE_OVERLOADING
    GutterRendererQueryActivatableSignalInfo,
#endif
    afterGutterRendererQueryActivatable     ,
    genClosure_GutterRendererQueryActivatable,
    mk_GutterRendererQueryActivatableCallback,
    noGutterRendererQueryActivatableCallback,
    onGutterRendererQueryActivatable        ,
    wrap_GutterRendererQueryActivatableCallback,


-- ** queryData #signal:queryData#

    C_GutterRendererQueryDataCallback       ,
    GutterRendererQueryDataCallback         ,
#if ENABLE_OVERLOADING
    GutterRendererQueryDataSignalInfo       ,
#endif
    afterGutterRendererQueryData            ,
    genClosure_GutterRendererQueryData      ,
    mk_GutterRendererQueryDataCallback      ,
    noGutterRendererQueryDataCallback       ,
    onGutterRendererQueryData               ,
    wrap_GutterRendererQueryDataCallback    ,


-- ** queryTooltip #signal:queryTooltip#

    C_GutterRendererQueryTooltipCallback    ,
    GutterRendererQueryTooltipCallback      ,
#if ENABLE_OVERLOADING
    GutterRendererQueryTooltipSignalInfo    ,
#endif
    afterGutterRendererQueryTooltip         ,
    genClosure_GutterRendererQueryTooltip   ,
    mk_GutterRendererQueryTooltipCallback   ,
    noGutterRendererQueryTooltipCallback    ,
    onGutterRendererQueryTooltip            ,
    wrap_GutterRendererQueryTooltipCallback ,


-- ** queueDraw #signal:queueDraw#

    C_GutterRendererQueueDrawCallback       ,
    GutterRendererQueueDrawCallback         ,
#if ENABLE_OVERLOADING
    GutterRendererQueueDrawSignalInfo       ,
#endif
    afterGutterRendererQueueDraw            ,
    genClosure_GutterRendererQueueDraw      ,
    mk_GutterRendererQueueDrawCallback      ,
    noGutterRendererQueueDrawCallback       ,
    onGutterRendererQueueDraw               ,
    wrap_GutterRendererQueueDrawCallback    ,




    ) where

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

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

import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Objects.TextView as Gtk.TextView
import qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums
import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags

-- | Memory-managed wrapper type.
newtype GutterRenderer = GutterRenderer (ManagedPtr GutterRenderer)
foreign import ccall "gtk_source_gutter_renderer_get_type"
    c_gtk_source_gutter_renderer_get_type :: IO GType

instance GObject GutterRenderer where
    gobjectType = c_gtk_source_gutter_renderer_get_type
    

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

instance O.HasParentTypes GutterRenderer
type instance O.ParentTypes GutterRenderer = '[GObject.Object.Object]

-- | Cast to `GutterRenderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toGutterRenderer :: (MonadIO m, IsGutterRenderer o) => o -> m GutterRenderer
toGutterRenderer = liftIO . unsafeCastTo GutterRenderer

-- | A convenience alias for `Nothing` :: `Maybe` `GutterRenderer`.
noGutterRenderer :: Maybe GutterRenderer
noGutterRenderer = Nothing

#if ENABLE_OVERLOADING
type family ResolveGutterRendererMethod (t :: Symbol) (o :: *) :: * where
    ResolveGutterRendererMethod "activate" o = GutterRendererActivateMethodInfo
    ResolveGutterRendererMethod "begin" o = GutterRendererBeginMethodInfo
    ResolveGutterRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveGutterRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveGutterRendererMethod "draw" o = GutterRendererDrawMethodInfo
    ResolveGutterRendererMethod "end" o = GutterRendererEndMethodInfo
    ResolveGutterRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveGutterRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveGutterRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveGutterRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveGutterRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveGutterRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveGutterRendererMethod "queryActivatable" o = GutterRendererQueryActivatableMethodInfo
    ResolveGutterRendererMethod "queryData" o = GutterRendererQueryDataMethodInfo
    ResolveGutterRendererMethod "queryTooltip" o = GutterRendererQueryTooltipMethodInfo
    ResolveGutterRendererMethod "queueDraw" o = GutterRendererQueueDrawMethodInfo
    ResolveGutterRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveGutterRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveGutterRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveGutterRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveGutterRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveGutterRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveGutterRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveGutterRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveGutterRendererMethod "getAlignment" o = GutterRendererGetAlignmentMethodInfo
    ResolveGutterRendererMethod "getAlignmentMode" o = GutterRendererGetAlignmentModeMethodInfo
    ResolveGutterRendererMethod "getBackground" o = GutterRendererGetBackgroundMethodInfo
    ResolveGutterRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveGutterRendererMethod "getPadding" o = GutterRendererGetPaddingMethodInfo
    ResolveGutterRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveGutterRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveGutterRendererMethod "getSize" o = GutterRendererGetSizeMethodInfo
    ResolveGutterRendererMethod "getView" o = GutterRendererGetViewMethodInfo
    ResolveGutterRendererMethod "getVisible" o = GutterRendererGetVisibleMethodInfo
    ResolveGutterRendererMethod "getWindowType" o = GutterRendererGetWindowTypeMethodInfo
    ResolveGutterRendererMethod "setAlignment" o = GutterRendererSetAlignmentMethodInfo
    ResolveGutterRendererMethod "setAlignmentMode" o = GutterRendererSetAlignmentModeMethodInfo
    ResolveGutterRendererMethod "setBackground" o = GutterRendererSetBackgroundMethodInfo
    ResolveGutterRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGutterRendererMethod "setPadding" o = GutterRendererSetPaddingMethodInfo
    ResolveGutterRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveGutterRendererMethod "setSize" o = GutterRendererSetSizeMethodInfo
    ResolveGutterRendererMethod "setVisible" o = GutterRendererSetVisibleMethodInfo
    ResolveGutterRendererMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal GutterRenderer::activate
{- |
The ::activate signal is emitted when the renderer is
activated.
-}
type GutterRendererActivateCallback =
    Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: the event that caused the activation -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererActivateCallback`@.
noGutterRendererActivateCallback :: Maybe GutterRendererActivateCallback
noGutterRendererActivateCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GutterRendererActivateCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr Gdk.Event.Event ->
    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 the callback into a `GClosure`.
genClosure_GutterRendererActivate :: MonadIO m => GutterRendererActivateCallback -> m (GClosure C_GutterRendererActivateCallback)
genClosure_GutterRendererActivate cb = liftIO $ do
    let cb' = wrap_GutterRendererActivateCallback cb
    mk_GutterRendererActivateCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `GutterRendererActivateCallback` into a `C_GutterRendererActivateCallback`.
wrap_GutterRendererActivateCallback ::
    GutterRendererActivateCallback ->
    C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback _cb _ iter area event _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do
        B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do
            B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do
                _cb  iter' area' event'


{- |
Connect a signal handler for the “@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 -> GutterRendererActivateCallback -> m SignalHandlerId
onGutterRendererActivate obj cb = liftIO $ do
    let cb' = wrap_GutterRendererActivateCallback cb
    cb'' <- mk_GutterRendererActivateCallback cb'
    connectSignalFunPtr obj "activate" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@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
@
-}
afterGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererActivateCallback -> m SignalHandlerId
afterGutterRendererActivate obj cb = liftIO $ do
    let cb' = wrap_GutterRendererActivateCallback cb
    cb'' <- mk_GutterRendererActivateCallback cb'
    connectSignalFunPtr obj "activate" cb'' SignalConnectAfter


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

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryActivatableCallback`@.
noGutterRendererQueryActivatableCallback :: Maybe GutterRendererQueryActivatableCallback
noGutterRendererQueryActivatableCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GutterRendererQueryActivatableCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr Gdk.Event.Event ->
    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 the callback into a `GClosure`.
genClosure_GutterRendererQueryActivatable :: MonadIO m => GutterRendererQueryActivatableCallback -> m (GClosure C_GutterRendererQueryActivatableCallback)
genClosure_GutterRendererQueryActivatable cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryActivatableCallback cb
    mk_GutterRendererQueryActivatableCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryActivatableCallback` into a `C_GutterRendererQueryActivatableCallback`.
wrap_GutterRendererQueryActivatableCallback ::
    GutterRendererQueryActivatableCallback ->
    C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback _cb _ iter area event _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do
        B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do
            B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do
                result <- _cb  iter' area' event'
                let result' = (fromIntegral . fromEnum) result
                return result'


{- |
Connect a signal handler for the “@query-activatable@” 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 -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
onGutterRendererQueryActivatable obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryActivatableCallback cb
    cb'' <- mk_GutterRendererQueryActivatableCallback cb'
    connectSignalFunPtr obj "query-activatable" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@query-activatable@” 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
@
-}
afterGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
afterGutterRendererQueryActivatable obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryActivatableCallback cb
    cb'' <- mk_GutterRendererQueryActivatableCallback cb'
    connectSignalFunPtr obj "query-activatable" cb'' SignalConnectAfter


-- signal GutterRenderer::query-data
{- |
The ::query-data signal is emitted when the renderer needs
to be filled with data just before a cell is drawn. This can
be used by general renderer implementations to allow render
data to be filled in externally.
-}
type GutterRendererQueryDataCallback =
    Gtk.TextIter.TextIter
    {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> [GtkSource.Flags.GutterRendererState]
    {- ^ /@state@/: the renderer state -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryDataCallback`@.
noGutterRendererQueryDataCallback :: Maybe GutterRendererQueryDataCallback
noGutterRendererQueryDataCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GutterRendererQueryDataCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gtk.TextIter.TextIter ->
    CUInt ->
    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 the callback into a `GClosure`.
genClosure_GutterRendererQueryData :: MonadIO m => GutterRendererQueryDataCallback -> m (GClosure C_GutterRendererQueryDataCallback)
genClosure_GutterRendererQueryData cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryDataCallback cb
    mk_GutterRendererQueryDataCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryDataCallback` into a `C_GutterRendererQueryDataCallback`.
wrap_GutterRendererQueryDataCallback ::
    GutterRendererQueryDataCallback ->
    C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback _cb _ start end state _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do
        B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do
            let state' = wordToGFlags state
            _cb  start' end' state'


{- |
Connect a signal handler for the “@query-data@” 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 -> GutterRendererQueryDataCallback -> m SignalHandlerId
onGutterRendererQueryData obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryDataCallback cb
    cb'' <- mk_GutterRendererQueryDataCallback cb'
    connectSignalFunPtr obj "query-data" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@query-data@” 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
@
-}
afterGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryDataCallback -> m SignalHandlerId
afterGutterRendererQueryData obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryDataCallback cb
    cb'' <- mk_GutterRendererQueryDataCallback cb'
    connectSignalFunPtr obj "query-data" cb'' SignalConnectAfter


-- signal GutterRenderer::query-tooltip
{- |
The ::query-tooltip signal is emitted when the renderer can
show a tooltip.
-}
type GutterRendererQueryTooltipCallback =
    Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -}
    -> Int32
    {- ^ /@x@/: the x position (in window coordinates) -}
    -> Int32
    {- ^ /@y@/: the y position (in window coordinates) -}
    -> Gtk.Tooltip.Tooltip
    {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -}
    -> IO Bool

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryTooltipCallback`@.
noGutterRendererQueryTooltipCallback :: Maybe GutterRendererQueryTooltipCallback
noGutterRendererQueryTooltipCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GutterRendererQueryTooltipCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TextIter.TextIter ->
    Ptr Gdk.Rectangle.Rectangle ->
    Int32 ->
    Int32 ->
    Ptr Gtk.Tooltip.Tooltip ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_GutterRendererQueryTooltip :: MonadIO m => GutterRendererQueryTooltipCallback -> m (GClosure C_GutterRendererQueryTooltipCallback)
genClosure_GutterRendererQueryTooltip cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryTooltipCallback cb
    mk_GutterRendererQueryTooltipCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryTooltipCallback` into a `C_GutterRendererQueryTooltipCallback`.
wrap_GutterRendererQueryTooltipCallback ::
    GutterRendererQueryTooltipCallback ->
    C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback _cb _ iter area x y tooltip _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do
        B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do
            tooltip' <- (newObject Gtk.Tooltip.Tooltip) tooltip
            result <- _cb  iter' area' x y tooltip'
            let result' = (fromIntegral . fromEnum) result
            return result'


{- |
Connect a signal handler for the “@query-tooltip@” 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 #queryTooltip callback
@
-}
onGutterRendererQueryTooltip :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId
onGutterRendererQueryTooltip obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryTooltipCallback cb
    cb'' <- mk_GutterRendererQueryTooltipCallback cb'
    connectSignalFunPtr obj "query-tooltip" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@query-tooltip@” 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 #queryTooltip callback
@
-}
afterGutterRendererQueryTooltip :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId
afterGutterRendererQueryTooltip obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueryTooltipCallback cb
    cb'' <- mk_GutterRendererQueryTooltipCallback cb'
    connectSignalFunPtr obj "query-tooltip" cb'' SignalConnectAfter


-- signal GutterRenderer::queue-draw
{- |
The ::queue-draw signal is emitted when the renderer needs
to be redrawn. Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererQueueDraw'
to emit this signal from an implementation of the
'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' interface.
-}
type GutterRendererQueueDrawCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueueDrawCallback`@.
noGutterRendererQueueDrawCallback :: Maybe GutterRendererQueueDrawCallback
noGutterRendererQueueDrawCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_GutterRendererQueueDraw :: MonadIO m => GutterRendererQueueDrawCallback -> m (GClosure C_GutterRendererQueueDrawCallback)
genClosure_GutterRendererQueueDraw cb = liftIO $ do
    let cb' = wrap_GutterRendererQueueDrawCallback cb
    mk_GutterRendererQueueDrawCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueueDrawCallback` into a `C_GutterRendererQueueDrawCallback`.
wrap_GutterRendererQueueDrawCallback ::
    GutterRendererQueueDrawCallback ->
    C_GutterRendererQueueDrawCallback
wrap_GutterRendererQueueDrawCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@queue-draw@” 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 #queueDraw callback
@
-}
onGutterRendererQueueDraw :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueueDrawCallback -> m SignalHandlerId
onGutterRendererQueueDraw obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueueDrawCallback cb
    cb'' <- mk_GutterRendererQueueDrawCallback cb'
    connectSignalFunPtr obj "queue-draw" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@queue-draw@” 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 #queueDraw callback
@
-}
afterGutterRendererQueueDraw :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueueDrawCallback -> m SignalHandlerId
afterGutterRendererQueueDraw obj cb = liftIO $ do
    let cb' = wrap_GutterRendererQueueDrawCallback cb
    cb'' <- mk_GutterRendererQueueDrawCallback cb'
    connectSignalFunPtr obj "queue-draw" cb'' SignalConnectAfter


-- VVV Prop "alignment-mode"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- 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 obj = liftIO $ B.Properties.getObjectPropertyEnum obj "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 obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "alignment-mode" 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) => GtkSource.Enums.GutterRendererAlignmentMode -> IO (GValueConstruct o)
constructGutterRendererAlignmentMode val = B.Properties.constructObjectPropertyEnum "alignment-mode" val

#if ENABLE_OVERLOADING
data GutterRendererAlignmentModePropertyInfo
instance AttrInfo GutterRendererAlignmentModePropertyInfo where
    type AttrAllowedOps GutterRendererAlignmentModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode
    type AttrBaseTypeConstraint GutterRendererAlignmentModePropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode
    type AttrLabel GutterRendererAlignmentModePropertyInfo = "alignment-mode"
    type AttrOrigin GutterRendererAlignmentModePropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererAlignmentMode
    attrSet _ = setGutterRendererAlignmentMode
    attrConstruct _ = constructGutterRendererAlignmentMode
    attrClear _ = undefined
#endif

-- VVV Prop "background-rgba"
   -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@background-rgba@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' gutterRenderer #backgroundRgba
@
-}
getGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> m (Maybe Gdk.RGBA.RGBA)
getGutterRendererBackgroundRgba obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "background-rgba" Gdk.RGBA.RGBA

{- |
Set the value of the “@background-rgba@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' gutterRenderer [ #backgroundRgba 'Data.GI.Base.Attributes.:=' value ]
@
-}
setGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> Gdk.RGBA.RGBA -> m ()
setGutterRendererBackgroundRgba obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "background-rgba" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@background-rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructGutterRendererBackgroundRgba :: (IsGutterRenderer o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o)
constructGutterRendererBackgroundRgba val = B.Properties.constructObjectPropertyBoxed "background-rgba" (Just val)

{- |
Set the value of the “@background-rgba@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #backgroundRgba
@
-}
clearGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> m ()
clearGutterRendererBackgroundRgba obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "background-rgba" (Nothing :: Maybe Gdk.RGBA.RGBA)

#if ENABLE_OVERLOADING
data GutterRendererBackgroundRgbaPropertyInfo
instance AttrInfo GutterRendererBackgroundRgbaPropertyInfo where
    type AttrAllowedOps GutterRendererBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA
    type AttrBaseTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererBackgroundRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA)
    type AttrLabel GutterRendererBackgroundRgbaPropertyInfo = "background-rgba"
    type AttrOrigin GutterRendererBackgroundRgbaPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererBackgroundRgba
    attrSet _ = setGutterRendererBackgroundRgba
    attrConstruct _ = constructGutterRendererBackgroundRgba
    attrClear _ = clearGutterRendererBackgroundRgba
#endif

-- VVV Prop "background-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@background-set@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' gutterRenderer #backgroundSet
@
-}
getGutterRendererBackgroundSet :: (MonadIO m, IsGutterRenderer o) => o -> m Bool
getGutterRendererBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "background-set"

{- |
Set the value of the “@background-set@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' gutterRenderer [ #backgroundSet 'Data.GI.Base.Attributes.:=' value ]
@
-}
setGutterRendererBackgroundSet :: (MonadIO m, IsGutterRenderer o) => o -> Bool -> m ()
setGutterRendererBackgroundSet obj val = liftIO $ B.Properties.setObjectPropertyBool obj "background-set" val

{- |
Construct a `GValueConstruct` with valid value for the “@background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructGutterRendererBackgroundSet :: (IsGutterRenderer o) => Bool -> IO (GValueConstruct o)
constructGutterRendererBackgroundSet val = B.Properties.constructObjectPropertyBool "background-set" val

#if ENABLE_OVERLOADING
data GutterRendererBackgroundSetPropertyInfo
instance AttrInfo GutterRendererBackgroundSetPropertyInfo where
    type AttrAllowedOps GutterRendererBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererBackgroundSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint GutterRendererBackgroundSetPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererBackgroundSetPropertyInfo = Bool
    type AttrLabel GutterRendererBackgroundSetPropertyInfo = "background-set"
    type AttrOrigin GutterRendererBackgroundSetPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererBackgroundSet
    attrSet _ = setGutterRendererBackgroundSet
    attrConstruct _ = constructGutterRendererBackgroundSet
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' gutterRenderer #size
@
-}
getGutterRendererSize :: (MonadIO m, IsGutterRenderer o) => o -> m Int32
getGutterRendererSize obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "size"

{- |
Set the value of the “@size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' gutterRenderer [ #size 'Data.GI.Base.Attributes.:=' value ]
@
-}
setGutterRendererSize :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m ()
setGutterRendererSize obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "size" val

{- |
Construct a `GValueConstruct` with valid value for the “@size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructGutterRendererSize :: (IsGutterRenderer o) => Int32 -> IO (GValueConstruct o)
constructGutterRendererSize val = B.Properties.constructObjectPropertyInt32 "size" val

#if ENABLE_OVERLOADING
data GutterRendererSizePropertyInfo
instance AttrInfo GutterRendererSizePropertyInfo where
    type AttrAllowedOps GutterRendererSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererSizePropertyInfo = (~) Int32
    type AttrBaseTypeConstraint GutterRendererSizePropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererSizePropertyInfo = Int32
    type AttrLabel GutterRendererSizePropertyInfo = "size"
    type AttrOrigin GutterRendererSizePropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererSize
    attrSet _ = setGutterRendererSize
    attrConstruct _ = constructGutterRendererSize
    attrClear _ = undefined
#endif

-- VVV Prop "view"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextView"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,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 Gtk.TextView.TextView
getGutterRendererView obj = liftIO $ checkUnexpectedNothing "getGutterRendererView" $ B.Properties.getObjectPropertyObject obj "view" Gtk.TextView.TextView

#if ENABLE_OVERLOADING
data GutterRendererViewPropertyInfo
instance AttrInfo GutterRendererViewPropertyInfo where
    type AttrAllowedOps GutterRendererViewPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint GutterRendererViewPropertyInfo = (~) ()
    type AttrBaseTypeConstraint GutterRendererViewPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererViewPropertyInfo = Gtk.TextView.TextView
    type AttrLabel GutterRendererViewPropertyInfo = "view"
    type AttrOrigin GutterRendererViewPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererView
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@visible@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' gutterRenderer #visible
@
-}
getGutterRendererVisible :: (MonadIO m, IsGutterRenderer o) => o -> m Bool
getGutterRendererVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible"

{- |
Set the value of the “@visible@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' gutterRenderer [ #visible 'Data.GI.Base.Attributes.:=' value ]
@
-}
setGutterRendererVisible :: (MonadIO m, IsGutterRenderer o) => o -> Bool -> m ()
setGutterRendererVisible obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible" val

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

#if ENABLE_OVERLOADING
data GutterRendererVisiblePropertyInfo
instance AttrInfo GutterRendererVisiblePropertyInfo where
    type AttrAllowedOps GutterRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint GutterRendererVisiblePropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererVisiblePropertyInfo = Bool
    type AttrLabel GutterRendererVisiblePropertyInfo = "visible"
    type AttrOrigin GutterRendererVisiblePropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererVisible
    attrSet _ = setGutterRendererVisible
    attrConstruct _ = constructGutterRendererVisible
    attrClear _ = undefined
#endif

-- VVV Prop "window-type"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextWindowType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@window-type@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' gutterRenderer #windowType
@
-}
getGutterRendererWindowType :: (MonadIO m, IsGutterRenderer o) => o -> m Gtk.Enums.TextWindowType
getGutterRendererWindowType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "window-type"

#if ENABLE_OVERLOADING
data GutterRendererWindowTypePropertyInfo
instance AttrInfo GutterRendererWindowTypePropertyInfo where
    type AttrAllowedOps GutterRendererWindowTypePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint GutterRendererWindowTypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint GutterRendererWindowTypePropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererWindowTypePropertyInfo = Gtk.Enums.TextWindowType
    type AttrLabel GutterRendererWindowTypePropertyInfo = "window-type"
    type AttrOrigin GutterRendererWindowTypePropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererWindowType
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

{- |
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 obj = liftIO $ B.Properties.getObjectPropertyFloat obj "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 obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "xalign" 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) => Float -> IO (GValueConstruct o)
constructGutterRendererXalign val = B.Properties.constructObjectPropertyFloat "xalign" val

#if ENABLE_OVERLOADING
data GutterRendererXalignPropertyInfo
instance AttrInfo GutterRendererXalignPropertyInfo where
    type AttrAllowedOps GutterRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererXalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint GutterRendererXalignPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererXalignPropertyInfo = Float
    type AttrLabel GutterRendererXalignPropertyInfo = "xalign"
    type AttrOrigin GutterRendererXalignPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererXalign
    attrSet _ = setGutterRendererXalign
    attrConstruct _ = constructGutterRendererXalign
    attrClear _ = undefined
#endif

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

{- |
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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "xpad" 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) => Int32 -> IO (GValueConstruct o)
constructGutterRendererXpad val = B.Properties.constructObjectPropertyInt32 "xpad" val

#if ENABLE_OVERLOADING
data GutterRendererXpadPropertyInfo
instance AttrInfo GutterRendererXpadPropertyInfo where
    type AttrAllowedOps GutterRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint GutterRendererXpadPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererXpadPropertyInfo = Int32
    type AttrLabel GutterRendererXpadPropertyInfo = "xpad"
    type AttrOrigin GutterRendererXpadPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererXpad
    attrSet _ = setGutterRendererXpad
    attrConstruct _ = constructGutterRendererXpad
    attrClear _ = undefined
#endif

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

{- |
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 obj = liftIO $ B.Properties.getObjectPropertyFloat obj "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 obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "yalign" 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) => Float -> IO (GValueConstruct o)
constructGutterRendererYalign val = B.Properties.constructObjectPropertyFloat "yalign" val

#if ENABLE_OVERLOADING
data GutterRendererYalignPropertyInfo
instance AttrInfo GutterRendererYalignPropertyInfo where
    type AttrAllowedOps GutterRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererYalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint GutterRendererYalignPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererYalignPropertyInfo = Float
    type AttrLabel GutterRendererYalignPropertyInfo = "yalign"
    type AttrOrigin GutterRendererYalignPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererYalign
    attrSet _ = setGutterRendererYalign
    attrConstruct _ = constructGutterRendererYalign
    attrClear _ = undefined
#endif

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

{- |
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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "ypad" 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) => Int32 -> IO (GValueConstruct o)
constructGutterRendererYpad val = B.Properties.constructObjectPropertyInt32 "ypad" val

#if ENABLE_OVERLOADING
data GutterRendererYpadPropertyInfo
instance AttrInfo GutterRendererYpadPropertyInfo where
    type AttrAllowedOps GutterRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint GutterRendererYpadPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint GutterRendererYpadPropertyInfo = IsGutterRenderer
    type AttrGetType GutterRendererYpadPropertyInfo = Int32
    type AttrLabel GutterRendererYpadPropertyInfo = "ypad"
    type AttrOrigin GutterRendererYpadPropertyInfo = GutterRenderer
    attrGet _ = getGutterRendererYpad
    attrSet _ = setGutterRendererYpad
    attrConstruct _ = constructGutterRendererYpad
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList GutterRenderer
type instance O.AttributeList GutterRenderer = GutterRendererAttributeList
type GutterRendererAttributeList = ('[ '("alignmentMode", GutterRendererAlignmentModePropertyInfo), '("backgroundRgba", GutterRendererBackgroundRgbaPropertyInfo), '("backgroundSet", GutterRendererBackgroundSetPropertyInfo), '("size", GutterRendererSizePropertyInfo), '("view", GutterRendererViewPropertyInfo), '("visible", GutterRendererVisiblePropertyInfo), '("windowType", GutterRendererWindowTypePropertyInfo), '("xalign", GutterRendererXalignPropertyInfo), '("xpad", GutterRendererXpadPropertyInfo), '("yalign", GutterRendererYalignPropertyInfo), '("ypad", GutterRendererYpadPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
gutterRendererAlignmentMode :: AttrLabelProxy "alignmentMode"
gutterRendererAlignmentMode = AttrLabelProxy

gutterRendererBackgroundRgba :: AttrLabelProxy "backgroundRgba"
gutterRendererBackgroundRgba = AttrLabelProxy

gutterRendererBackgroundSet :: AttrLabelProxy "backgroundSet"
gutterRendererBackgroundSet = AttrLabelProxy

gutterRendererSize :: AttrLabelProxy "size"
gutterRendererSize = AttrLabelProxy

gutterRendererView :: AttrLabelProxy "view"
gutterRendererView = AttrLabelProxy

gutterRendererVisible :: AttrLabelProxy "visible"
gutterRendererVisible = AttrLabelProxy

gutterRendererWindowType :: AttrLabelProxy "windowType"
gutterRendererWindowType = AttrLabelProxy

gutterRendererXalign :: AttrLabelProxy "xalign"
gutterRendererXalign = AttrLabelProxy

gutterRendererXpad :: AttrLabelProxy "xpad"
gutterRendererXpad = AttrLabelProxy

gutterRendererYalign :: AttrLabelProxy "yalign"
gutterRendererYalign = AttrLabelProxy

gutterRendererYpad :: AttrLabelProxy "ypad"
gutterRendererYpad = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data GutterRendererActivateSignalInfo
instance SignalInfo GutterRendererActivateSignalInfo where
    type HaskellCallbackType GutterRendererActivateSignalInfo = GutterRendererActivateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_GutterRendererActivateCallback cb
        cb'' <- mk_GutterRendererActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode

data GutterRendererQueryActivatableSignalInfo
instance SignalInfo GutterRendererQueryActivatableSignalInfo where
    type HaskellCallbackType GutterRendererQueryActivatableSignalInfo = GutterRendererQueryActivatableCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_GutterRendererQueryActivatableCallback cb
        cb'' <- mk_GutterRendererQueryActivatableCallback cb'
        connectSignalFunPtr obj "query-activatable" cb'' connectMode

data GutterRendererQueryDataSignalInfo
instance SignalInfo GutterRendererQueryDataSignalInfo where
    type HaskellCallbackType GutterRendererQueryDataSignalInfo = GutterRendererQueryDataCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_GutterRendererQueryDataCallback cb
        cb'' <- mk_GutterRendererQueryDataCallback cb'
        connectSignalFunPtr obj "query-data" cb'' connectMode

data GutterRendererQueryTooltipSignalInfo
instance SignalInfo GutterRendererQueryTooltipSignalInfo where
    type HaskellCallbackType GutterRendererQueryTooltipSignalInfo = GutterRendererQueryTooltipCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_GutterRendererQueryTooltipCallback cb
        cb'' <- mk_GutterRendererQueryTooltipCallback cb'
        connectSignalFunPtr obj "query-tooltip" cb'' connectMode

data GutterRendererQueueDrawSignalInfo
instance SignalInfo GutterRendererQueueDrawSignalInfo where
    type HaskellCallbackType GutterRendererQueueDrawSignalInfo = GutterRendererQueueDrawCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_GutterRendererQueueDrawCallback cb
        cb'' <- mk_GutterRendererQueueDrawCallback cb'
        connectSignalFunPtr obj "queue-draw" cb'' connectMode

type instance O.SignalList GutterRenderer = GutterRendererSignalList
type GutterRendererSignalList = ('[ '("activate", GutterRendererActivateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryActivatable", GutterRendererQueryActivatableSignalInfo), '("queryData", GutterRendererQueryDataSignalInfo), '("queryTooltip", GutterRendererQueryTooltipSignalInfo), '("queueDraw", GutterRendererQueueDrawSignalInfo)] :: [(Symbol, *)])

#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, 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, 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, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the event that triggered the activation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO ()

{- |
Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/activate/@ signal of the renderer. This is
called from 'GI.GtkSource.Objects.Gutter.Gutter' and should never have to be called manually.
-}
gutterRendererActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' at the start of the line where the renderer is activated -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area where the renderer is activated -}
    -> Gdk.Event.Event
    {- ^ /@event@/: the event that triggered the activation -}
    -> m ()
gutterRendererActivate renderer iter area event = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    iter' <- unsafeManagedPtrGetPtr iter
    area' <- unsafeManagedPtrGetPtr area
    event' <- unsafeManagedPtrGetPtr event
    gtk_source_gutter_renderer_activate renderer' iter' area' event'
    touchManagedPtr renderer
    touchManagedPtr iter
    touchManagedPtr area
    touchManagedPtr event
    return ()

#if ENABLE_OVERLOADING
data GutterRendererActivateMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Gdk.Event.Event -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererActivateMethodInfo a signature where
    overloadedMethod _ = gutterRendererActivate

#endif

-- method GutterRenderer::begin
-- 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, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #cairo_t", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_begin" gtk_source_gutter_renderer_begin :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Cairo.Context.Context ->            -- cr : TInterface (Name {namespace = "cairo", name = "Context"})
    Ptr Gdk.Rectangle.Rectangle ->          -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Called when drawing a region begins. The region to be drawn is indicated
by /@start@/ and /@end@/. The purpose is to allow the implementation to precompute
some state before the draw method is called for each cell.
-}
gutterRendererBegin ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Cairo.Context.Context
    {- ^ /@cr@/: a 'GI.Cairo.Structs.Context.Context' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@backgroundArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@cellArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> m ()
gutterRendererBegin renderer cr backgroundArea cellArea start end = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    cr' <- unsafeManagedPtrGetPtr cr
    backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    gtk_source_gutter_renderer_begin renderer' cr' backgroundArea' cellArea' start' end'
    touchManagedPtr renderer
    touchManagedPtr cr
    touchManagedPtr backgroundArea
    touchManagedPtr cellArea
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
data GutterRendererBeginMethodInfo
instance (signature ~ (Cairo.Context.Context -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererBeginMethodInfo a signature where
    overloadedMethod _ = gutterRendererBegin

#endif

-- method GutterRenderer::draw
-- 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, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the cairo render context", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle indicating the total area to be drawn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle indicating the area to draw content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_draw" gtk_source_gutter_renderer_draw :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Cairo.Context.Context ->            -- cr : TInterface (Name {namespace = "cairo", name = "Context"})
    Ptr Gdk.Rectangle.Rectangle ->          -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CUInt ->                                -- state : TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"})
    IO ()

{- |
Main renderering method. Implementations should implement this method to draw
onto the cairo context. The /@backgroundArea@/ indicates the total area of the
cell to be drawn. The /@cellArea@/ indicates the area where content can be
drawn (text, images, etc).

The /@backgroundArea@/ is the /@cellArea@/ plus the padding on each side (two
times the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer':@/xpad/@ horizontally and two times the
'GI.GtkSource.Objects.GutterRenderer.GutterRenderer':@/ypad/@ vertically, so that the /@cellArea@/ is centered
inside /@backgroundArea@/).

The /@state@/ argument indicates the current state of the renderer and should
be taken into account to properly draw the different possible states
(cursor, prelit, selected) if appropriate.
-}
gutterRendererDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Cairo.Context.Context
    {- ^ /@cr@/: the cairo render context -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@backgroundArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' indicating the total area to be drawn -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@cellArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' indicating the area to draw content -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -}
    -> [GtkSource.Flags.GutterRendererState]
    {- ^ /@state@/: a 'GI.GtkSource.Flags.GutterRendererState' -}
    -> m ()
gutterRendererDraw renderer cr backgroundArea cellArea start end state = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    cr' <- unsafeManagedPtrGetPtr cr
    backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    let state' = gflagsToWord state
    gtk_source_gutter_renderer_draw renderer' cr' backgroundArea' cellArea' start' end' state'
    touchManagedPtr renderer
    touchManagedPtr cr
    touchManagedPtr backgroundArea
    touchManagedPtr cellArea
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
data GutterRendererDrawMethodInfo
instance (signature ~ (Cairo.Context.Context -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.GutterRendererState] -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererDrawMethodInfo a signature where
    overloadedMethod _ = gutterRendererDraw

#endif

-- method GutterRenderer::end
-- 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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Called when drawing a region of lines has ended.
-}
gutterRendererEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m ()
gutterRendererEnd renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    gtk_source_gutter_renderer_end renderer'
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererEndMethodInfo
instance (signature ~ (m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererEndMethodInfo a signature where
    overloadedMethod _ = gutterRendererEnd

#endif

-- XXX Could not generate method GutterRenderer::get_alignment
-- Error was : Not implemented: "Don't know how to allocate \"xalign\" of type TBasicType TFloat"
#if ENABLE_OVERLOADING
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data GutterRendererGetAlignmentMethodInfo
instance (p ~ (), o ~ O.MethodResolutionFailed "getAlignment" GutterRenderer) => O.MethodInfo GutterRendererGetAlignmentMethodInfo o p where
    overloadedMethod _ = undefined
#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, 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 :xalign and :yalign).
-}
gutterRendererGetAlignmentMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m GtkSource.Enums.GutterRendererAlignmentMode
    {- ^ __Returns:__ a 'GI.GtkSource.Enums.GutterRendererAlignmentMode' -}
gutterRendererGetAlignmentMode renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    result <- gtk_source_gutter_renderer_get_alignment_mode renderer'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr renderer
    return result'

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

#endif

-- method GutterRenderer::get_background
-- 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, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for a #GdkRGBA", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_get_background" gtk_source_gutter_renderer_get_background :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO CInt

{- |
Get the background color of the renderer.
-}
gutterRendererGetBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m ((Bool, Gdk.RGBA.RGBA))
    {- ^ __Returns:__ 'True' if the background color is set, 'False' otherwise -}
gutterRendererGetBackground renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    result <- gtk_source_gutter_renderer_get_background renderer' color
    let result' = (/= 0) result
    color' <- (wrapBoxed Gdk.RGBA.RGBA) color
    touchManagedPtr renderer
    return (result', color')

#if ENABLE_OVERLOADING
data GutterRendererGetBackgroundMethodInfo
instance (signature ~ (m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetBackgroundMethodInfo a signature where
    overloadedMethod _ = gutterRendererGetBackground

#endif

-- XXX Could not generate method GutterRenderer::get_padding
-- Error was : Not implemented: "Don't know how to allocate \"xpad\" of type TBasicType TInt"
#if ENABLE_OVERLOADING
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data GutterRendererGetPaddingMethodInfo
instance (p ~ (), o ~ O.MethodResolutionFailed "getPadding" GutterRenderer) => O.MethodInfo GutterRendererGetPaddingMethodInfo o p where
    overloadedMethod _ = undefined
#endif

-- method GutterRenderer::get_size
-- 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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

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

{- |
Get the size of the renderer.
-}
gutterRendererGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m Int32
    {- ^ __Returns:__ the size of the renderer. -}
gutterRendererGetSize renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    result <- gtk_source_gutter_renderer_get_size renderer'
    touchManagedPtr renderer
    return result

#if ENABLE_OVERLOADING
data GutterRendererGetSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetSizeMethodInfo a signature where
    overloadedMethod _ = gutterRendererGetSize

#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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextView"}))
-- 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 Gtk.TextView.TextView)

{- |
Get the view associated to the gutter renderer
-}
gutterRendererGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m Gtk.TextView.TextView
    {- ^ __Returns:__ a 'GI.Gtk.Objects.TextView.TextView' -}
gutterRendererGetView renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    result <- gtk_source_gutter_renderer_get_view renderer'
    checkUnexpectedReturnNULL "gutterRendererGetView" result
    result' <- (newObject Gtk.TextView.TextView) result
    touchManagedPtr renderer
    return result'

#if ENABLE_OVERLOADING
data GutterRendererGetViewMethodInfo
instance (signature ~ (m Gtk.TextView.TextView), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetViewMethodInfo a signature where
    overloadedMethod _ = gutterRendererGetView

#endif

-- method GutterRenderer::get_visible
-- 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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

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

{- |
Get whether the gutter renderer is visible.
-}
gutterRendererGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the renderer is visible, 'False' otherwise -}
gutterRendererGetVisible renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    result <- gtk_source_gutter_renderer_get_visible renderer'
    let result' = (/= 0) result
    touchManagedPtr renderer
    return result'

#if ENABLE_OVERLOADING
data GutterRendererGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetVisibleMethodInfo a signature where
    overloadedMethod _ = gutterRendererGetVisible

#endif

-- method GutterRenderer::get_window_type
-- 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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextWindowType"}))
-- throws : False
-- Skip return : False

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

{- |
Get the 'GI.Gtk.Enums.TextWindowType' associated with the gutter renderer.
-}
gutterRendererGetWindowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m Gtk.Enums.TextWindowType
    {- ^ __Returns:__ a 'GI.Gtk.Enums.TextWindowType' -}
gutterRendererGetWindowType renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    result <- gtk_source_gutter_renderer_get_window_type renderer'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr renderer
    return result'

#if ENABLE_OVERLOADING
data GutterRendererGetWindowTypeMethodInfo
instance (signature ~ (m Gtk.Enums.TextWindowType), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetWindowTypeMethodInfo a signature where
    overloadedMethod _ = gutterRendererGetWindowType

#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, 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, 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, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the event that triggered the query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "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"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CInt

{- |
Get whether the renderer is activatable at the location in /@event@/. This is
called from 'GI.GtkSource.Objects.Gutter.Gutter' to determine whether a renderer is activatable
using the mouse pointer.
-}
gutterRendererQueryActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' at the start of the line to be activated -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area to be activated -}
    -> Gdk.Event.Event
    {- ^ /@event@/: the event that triggered the query -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the renderer can be activated, 'False' otherwise -}
gutterRendererQueryActivatable renderer iter area event = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    iter' <- unsafeManagedPtrGetPtr iter
    area' <- unsafeManagedPtrGetPtr area
    event' <- unsafeManagedPtrGetPtr event
    result <- gtk_source_gutter_renderer_query_activatable renderer' iter' area' event'
    let result' = (/= 0) result
    touchManagedPtr renderer
    touchManagedPtr iter
    touchManagedPtr area
    touchManagedPtr event
    return result'

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

#endif

-- method GutterRenderer::query_data
-- 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, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererState.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_query_data" gtk_source_gutter_renderer_query_data :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CUInt ->                                -- state : TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"})
    IO ()

{- |
Emit the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-data/@ signal. This function is called
to query for data just before rendering a cell. This is called from the
'GI.GtkSource.Objects.Gutter.Gutter'.  Implementations can override the default signal handler or
can connect a signal handler externally to the
'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-data/@ signal.
-}
gutterRendererQueryData ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -}
    -> [GtkSource.Flags.GutterRendererState]
    {- ^ /@state@/: a 'GI.GtkSource.Flags.GutterRendererState'. -}
    -> m ()
gutterRendererQueryData renderer start end state = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    let state' = gflagsToWord state
    gtk_source_gutter_renderer_query_data renderer' start' end' state'
    touchManagedPtr renderer
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
data GutterRendererQueryDataMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.GutterRendererState] -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererQueryDataMethodInfo a signature where
    overloadedMethod _ = gutterRendererQueryData

#endif

-- method GutterRenderer::query_tooltip
-- 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, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x position of the tooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y position of the tooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TInterface (Name {namespace = "Gtk", name = "Tooltip"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_query_tooltip" gtk_source_gutter_renderer_query_tooltip :: 
    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"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Ptr Gtk.Tooltip.Tooltip ->              -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"})
    IO CInt

{- |
Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-tooltip/@ signal. This function is
called from 'GI.GtkSource.Objects.Gutter.Gutter'. Implementations can override the default signal
handler or can connect to the signal externally.
-}
gutterRendererQueryTooltip ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a, Gtk.Tooltip.IsTooltip b) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle'. -}
    -> Int32
    {- ^ /@x@/: The x position of the tooltip. -}
    -> Int32
    {- ^ /@y@/: The y position of the tooltip. -}
    -> b
    {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the tooltip has been set, 'False' otherwise -}
gutterRendererQueryTooltip renderer iter area x y tooltip = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    iter' <- unsafeManagedPtrGetPtr iter
    area' <- unsafeManagedPtrGetPtr area
    tooltip' <- unsafeManagedPtrCastPtr tooltip
    result <- gtk_source_gutter_renderer_query_tooltip renderer' iter' area' x y tooltip'
    let result' = (/= 0) result
    touchManagedPtr renderer
    touchManagedPtr iter
    touchManagedPtr area
    touchManagedPtr tooltip
    return result'

#if ENABLE_OVERLOADING
data GutterRendererQueryTooltipMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Int32 -> Int32 -> b -> m Bool), MonadIO m, IsGutterRenderer a, Gtk.Tooltip.IsTooltip b) => O.MethodInfo GutterRendererQueryTooltipMethodInfo a signature where
    overloadedMethod _ = gutterRendererQueryTooltip

#endif

-- method GutterRenderer::queue_draw
-- 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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/queue-draw/@ signal of the renderer. Call
this from an implementation to inform that the renderer has changed such that
it needs to redraw.
-}
gutterRendererQueueDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> m ()
gutterRendererQueueDraw renderer = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    gtk_source_gutter_renderer_queue_draw renderer'
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererQueueDrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererQueueDrawMethodInfo a signature where
    overloadedMethod _ = gutterRendererQueueDraw

#endif

-- method GutterRenderer::set_alignment
-- 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, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x-alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y-alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_set_alignment" gtk_source_gutter_renderer_set_alignment :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    CFloat ->                               -- xalign : TBasicType TFloat
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

{- |
Set the alignment of the gutter renderer. Both /@xalign@/ and /@yalign@/ can be
-1, which means the values will not be changed (this allows changing only
one of the values).

/@xalign@/ is the horizontal alignment. Set to 0 for a left alignment. 1 for a
right alignment. And 0.5 for centering the cells. /@yalign@/ is the vertical
alignment. Set to 0 for a top alignment. 1 for a bottom alignment.
-}
gutterRendererSetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Float
    {- ^ /@xalign@/: the x-alignment -}
    -> Float
    {- ^ /@yalign@/: the y-alignment -}
    -> m ()
gutterRendererSetAlignment renderer xalign yalign = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    let xalign' = realToFrac xalign
    let yalign' = realToFrac yalign
    gtk_source_gutter_renderer_set_alignment renderer' xalign' yalign'
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererSetAlignmentMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetAlignmentMethodInfo a signature where
    overloadedMethod _ = gutterRendererSetAlignment

#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, 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, 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 :xalign and :yalign).
-}
gutterRendererSetAlignmentMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> GtkSource.Enums.GutterRendererAlignmentMode
    {- ^ /@mode@/: a 'GI.GtkSource.Enums.GutterRendererAlignmentMode' -}
    -> m ()
gutterRendererSetAlignmentMode renderer mode = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    let mode' = (fromIntegral . fromEnum) mode
    gtk_source_gutter_renderer_set_alignment_mode renderer' mode'
    touchManagedPtr renderer
    return ()

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

#endif

-- method GutterRenderer::set_background
-- 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, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GdkRGBA or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_set_background" gtk_source_gutter_renderer_set_background :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Set the background color of the renderer. If /@color@/ is set to 'Nothing', the
renderer will not have a background color.
-}
gutterRendererSetBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@color@/: a 'GI.Gdk.Structs.RGBA.RGBA' or 'Nothing' -}
    -> m ()
gutterRendererSetBackground renderer color = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_source_gutter_renderer_set_background renderer' maybeColor
    touchManagedPtr renderer
    whenJust color touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data GutterRendererSetBackgroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetBackgroundMethodInfo a signature where
    overloadedMethod _ = gutterRendererSetBackground

#endif

-- method GutterRenderer::set_padding
-- 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, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x-padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y-padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_set_padding" gtk_source_gutter_renderer_set_padding :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- xpad : TBasicType TInt
    Int32 ->                                -- ypad : TBasicType TInt
    IO ()

{- |
Set the padding of the gutter renderer. Both /@xpad@/ and /@ypad@/ can be
-1, which means the values will not be changed (this allows changing only
one of the values).

/@xpad@/ is the left and right padding. /@ypad@/ is the top and bottom padding.
-}
gutterRendererSetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Int32
    {- ^ /@xpad@/: the x-padding -}
    -> Int32
    {- ^ /@ypad@/: the y-padding -}
    -> m ()
gutterRendererSetPadding renderer xpad ypad = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    gtk_source_gutter_renderer_set_padding renderer' xpad ypad
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererSetPaddingMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetPaddingMethodInfo a signature where
    overloadedMethod _ = gutterRendererSetPadding

#endif

-- method GutterRenderer::set_size
-- 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, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_set_size" gtk_source_gutter_renderer_set_size :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- size : TBasicType TInt
    IO ()

{- |
Sets the size of the renderer. A value of -1 specifies that the size
is to be determined dynamically.
-}
gutterRendererSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Int32
    {- ^ /@size@/: the size -}
    -> m ()
gutterRendererSetSize renderer size = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    gtk_source_gutter_renderer_set_size renderer' size
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererSetSizeMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetSizeMethodInfo a signature where
    overloadedMethod _ = gutterRendererSetSize

#endif

-- method GutterRenderer::set_visible
-- 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, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the visibility", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_renderer_set_visible" gtk_source_gutter_renderer_set_visible :: 
    Ptr GutterRenderer ->                   -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

{- |
Set whether the gutter renderer is visible.
-}
gutterRendererSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -}
    -> Bool
    {- ^ /@visible@/: the visibility -}
    -> m ()
gutterRendererSetVisible renderer visible = liftIO $ do
    renderer' <- unsafeManagedPtrCastPtr renderer
    let visible' = (fromIntegral . fromEnum) visible
    gtk_source_gutter_renderer_set_visible renderer' visible'
    touchManagedPtr renderer
    return ()

#if ENABLE_OVERLOADING
data GutterRendererSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetVisibleMethodInfo a signature where
    overloadedMethod _ = gutterRendererSetVisible

#endif