{-# LANGUAGE TypeApplications #-}


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

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

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

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


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveGutterRendererMethod             ,
#endif


-- ** activate #method:activate#

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


-- ** begin #method:begin#

#if defined(ENABLE_OVERLOADING)
    GutterRendererBeginMethodInfo           ,
#endif
    gutterRendererBegin                     ,


-- ** draw #method:draw#

#if defined(ENABLE_OVERLOADING)
    GutterRendererDrawMethodInfo            ,
#endif
    gutterRendererDraw                      ,


-- ** end #method:end#

#if defined(ENABLE_OVERLOADING)
    GutterRendererEndMethodInfo             ,
#endif
    gutterRendererEnd                       ,


-- ** getAlignmentMode #method:getAlignmentMode#

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


-- ** getBackground #method:getBackground#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetBackgroundMethodInfo   ,
#endif
    gutterRendererGetBackground             ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetSizeMethodInfo         ,
#endif
    gutterRendererGetSize                   ,


-- ** getView #method:getView#

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


-- ** getVisible #method:getVisible#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetVisibleMethodInfo      ,
#endif
    gutterRendererGetVisible                ,


-- ** getWindowType #method:getWindowType#

#if defined(ENABLE_OVERLOADING)
    GutterRendererGetWindowTypeMethodInfo   ,
#endif
    gutterRendererGetWindowType             ,


-- ** queryActivatable #method:queryActivatable#

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


-- ** queryData #method:queryData#

#if defined(ENABLE_OVERLOADING)
    GutterRendererQueryDataMethodInfo       ,
#endif
    gutterRendererQueryData                 ,


-- ** queryTooltip #method:queryTooltip#

#if defined(ENABLE_OVERLOADING)
    GutterRendererQueryTooltipMethodInfo    ,
#endif
    gutterRendererQueryTooltip              ,


-- ** queueDraw #method:queueDraw#

#if defined(ENABLE_OVERLOADING)
    GutterRendererQueueDrawMethodInfo       ,
#endif
    gutterRendererQueueDraw                 ,


-- ** setAlignment #method:setAlignment#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetAlignmentMethodInfo    ,
#endif
    gutterRendererSetAlignment              ,


-- ** setAlignmentMode #method:setAlignmentMode#

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


-- ** setBackground #method:setBackground#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetBackgroundMethodInfo   ,
#endif
    gutterRendererSetBackground             ,


-- ** setPadding #method:setPadding#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetPaddingMethodInfo      ,
#endif
    gutterRendererSetPadding                ,


-- ** setSize #method:setSize#

#if defined(ENABLE_OVERLOADING)
    GutterRendererSetSizeMethodInfo         ,
#endif
    gutterRendererSetSize                   ,


-- ** setVisible #method:setVisible#

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


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

#if defined(ENABLE_OVERLOADING)
    GutterRendererBackgroundRgbaPropertyInfo,
#endif
    clearGutterRendererBackgroundRgba       ,
    constructGutterRendererBackgroundRgba   ,
    getGutterRendererBackgroundRgba         ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererBackgroundRgba            ,
#endif
    setGutterRendererBackgroundRgba         ,


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

#if defined(ENABLE_OVERLOADING)
    GutterRendererBackgroundSetPropertyInfo ,
#endif
    constructGutterRendererBackgroundSet    ,
    getGutterRendererBackgroundSet          ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererBackgroundSet             ,
#endif
    setGutterRendererBackgroundSet          ,


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

#if defined(ENABLE_OVERLOADING)
    GutterRendererSizePropertyInfo          ,
#endif
    constructGutterRendererSize             ,
    getGutterRendererSize                   ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererSize                      ,
#endif
    setGutterRendererSize                   ,


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

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


-- ** visible #attr:visible#
-- | The visibility of the renderer.

#if defined(ENABLE_OVERLOADING)
    GutterRendererVisiblePropertyInfo       ,
#endif
    constructGutterRendererVisible          ,
    getGutterRendererVisible                ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererVisible                   ,
#endif
    setGutterRendererVisible                ,


-- ** windowType #attr:windowType#
-- | The window type of the view on which the renderer is placed (left,
-- or right).

#if defined(ENABLE_OVERLOADING)
    GutterRendererWindowTypePropertyInfo    ,
#endif
    getGutterRendererWindowType             ,
#if defined(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 defined(ENABLE_OVERLOADING)
    GutterRendererXalignPropertyInfo        ,
#endif
    constructGutterRendererXalign           ,
    getGutterRendererXalign                 ,
#if defined(ENABLE_OVERLOADING)
    gutterRendererXalign                    ,
#endif
    setGutterRendererXalign                 ,


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

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


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

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


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

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




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

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


-- ** queryActivatable #signal:queryActivatable#

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


-- ** queryData #signal:queryData#

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


-- ** queryTooltip #signal:queryTooltip#

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


-- ** queueDraw #signal:queueDraw#

    C_GutterRendererQueueDrawCallback       ,
    GutterRendererQueueDrawCallback         ,
#if defined(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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified 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 (SP.ManagedPtr GutterRenderer)
    deriving (GutterRenderer -> GutterRenderer -> Bool
(GutterRenderer -> GutterRenderer -> Bool)
-> (GutterRenderer -> GutterRenderer -> Bool) -> Eq GutterRenderer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GutterRenderer -> GutterRenderer -> Bool
$c/= :: GutterRenderer -> GutterRenderer -> Bool
== :: GutterRenderer -> GutterRenderer -> Bool
$c== :: GutterRenderer -> GutterRenderer -> Bool
Eq)

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

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

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

instance B.Types.GObject GutterRenderer

-- | Convert 'GutterRenderer' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue GutterRenderer where
    toGValue :: GutterRenderer -> IO GValue
toGValue GutterRenderer
o = do
        GType
gtype <- IO GType
c_gtk_source_gutter_renderer_get_type
        GutterRenderer -> (Ptr GutterRenderer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GutterRenderer
o (GType
-> (GValue -> Ptr GutterRenderer -> IO ())
-> Ptr GutterRenderer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr GutterRenderer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO GutterRenderer
fromGValue GValue
gv = do
        Ptr GutterRenderer
ptr <- GValue -> IO (Ptr GutterRenderer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr GutterRenderer)
        (ManagedPtr GutterRenderer -> GutterRenderer)
-> Ptr GutterRenderer -> IO GutterRenderer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GutterRenderer -> GutterRenderer
GutterRenderer Ptr GutterRenderer
ptr
        
    

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

instance O.HasParentTypes GutterRenderer
type instance O.ParentTypes GutterRenderer = '[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 :: o -> m GutterRenderer
toGutterRenderer = IO GutterRenderer -> m GutterRenderer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GutterRenderer -> m GutterRenderer)
-> (o -> IO GutterRenderer) -> o -> m GutterRenderer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr GutterRenderer -> GutterRenderer)
-> o -> IO GutterRenderer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr GutterRenderer -> GutterRenderer
GutterRenderer

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

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

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererActivateCallback`@.
noGutterRendererActivateCallback :: Maybe GutterRendererActivateCallback
noGutterRendererActivateCallback :: Maybe GutterRendererActivateCallback
noGutterRendererActivateCallback = Maybe GutterRendererActivateCallback
forall a. Maybe a
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 :: GutterRendererActivateCallback
-> m (GClosure C_GutterRendererActivateCallback)
genClosure_GutterRendererActivate GutterRendererActivateCallback
cb = IO (GClosure C_GutterRendererActivateCallback)
-> m (GClosure C_GutterRendererActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GutterRendererActivateCallback)
 -> m (GClosure C_GutterRendererActivateCallback))
-> IO (GClosure C_GutterRendererActivateCallback)
-> m (GClosure C_GutterRendererActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererActivateCallback
cb' = GutterRendererActivateCallback -> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback GutterRendererActivateCallback
cb
    C_GutterRendererActivateCallback
-> IO (FunPtr C_GutterRendererActivateCallback)
mk_GutterRendererActivateCallback C_GutterRendererActivateCallback
cb' IO (FunPtr C_GutterRendererActivateCallback)
-> (FunPtr C_GutterRendererActivateCallback
    -> IO (GClosure C_GutterRendererActivateCallback))
-> IO (GClosure C_GutterRendererActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GutterRendererActivateCallback
-> IO (GClosure C_GutterRendererActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GutterRendererActivateCallback` into a `C_GutterRendererActivateCallback`.
wrap_GutterRendererActivateCallback ::
    GutterRendererActivateCallback ->
    C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback :: GutterRendererActivateCallback -> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback GutterRendererActivateCallback
_cb Ptr ()
_ Ptr TextIter
iter Ptr Rectangle
area Ptr Event
event Ptr ()
_ = do
    (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter Ptr TextIter
iter ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        (ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> (Rectangle -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle Ptr Rectangle
area ((Rectangle -> IO ()) -> IO ()) -> (Rectangle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Rectangle
area' -> do
            (ManagedPtr Event -> Event)
-> Ptr Event -> (Event -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Event -> Event
Gdk.Event.Event Ptr Event
event ((Event -> IO ()) -> IO ()) -> (Event -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
                GutterRendererActivateCallback
_cb  TextIter
iter' Rectangle
area' Event
event'


-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' gutterRenderer #activate callback
-- @
-- 
-- 
onGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererActivateCallback -> m SignalHandlerId
onGutterRendererActivate :: a -> GutterRendererActivateCallback -> m SignalHandlerId
onGutterRendererActivate a
obj GutterRendererActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererActivateCallback
cb' = GutterRendererActivateCallback -> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback GutterRendererActivateCallback
cb
    FunPtr C_GutterRendererActivateCallback
cb'' <- C_GutterRendererActivateCallback
-> IO (FunPtr C_GutterRendererActivateCallback)
mk_GutterRendererActivateCallback C_GutterRendererActivateCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_GutterRendererActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' gutterRenderer #activate callback
-- @
-- 
-- 
afterGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererActivateCallback -> m SignalHandlerId
afterGutterRendererActivate :: a -> GutterRendererActivateCallback -> m SignalHandlerId
afterGutterRendererActivate a
obj GutterRendererActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererActivateCallback
cb' = GutterRendererActivateCallback -> C_GutterRendererActivateCallback
wrap_GutterRendererActivateCallback GutterRendererActivateCallback
cb
    FunPtr C_GutterRendererActivateCallback
cb'' <- C_GutterRendererActivateCallback
-> IO (FunPtr C_GutterRendererActivateCallback)
mk_GutterRendererActivateCallback C_GutterRendererActivateCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_GutterRendererActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryActivatableCallback`@.
noGutterRendererQueryActivatableCallback :: Maybe GutterRendererQueryActivatableCallback
noGutterRendererQueryActivatableCallback :: Maybe GutterRendererQueryActivatableCallback
noGutterRendererQueryActivatableCallback = Maybe GutterRendererQueryActivatableCallback
forall a. Maybe a
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 :: GutterRendererQueryActivatableCallback
-> m (GClosure C_GutterRendererQueryActivatableCallback)
genClosure_GutterRendererQueryActivatable GutterRendererQueryActivatableCallback
cb = IO (GClosure C_GutterRendererQueryActivatableCallback)
-> m (GClosure C_GutterRendererQueryActivatableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GutterRendererQueryActivatableCallback)
 -> m (GClosure C_GutterRendererQueryActivatableCallback))
-> IO (GClosure C_GutterRendererQueryActivatableCallback)
-> m (GClosure C_GutterRendererQueryActivatableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryActivatableCallback
cb' = GutterRendererQueryActivatableCallback
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback GutterRendererQueryActivatableCallback
cb
    C_GutterRendererQueryActivatableCallback
-> IO (FunPtr C_GutterRendererQueryActivatableCallback)
mk_GutterRendererQueryActivatableCallback C_GutterRendererQueryActivatableCallback
cb' IO (FunPtr C_GutterRendererQueryActivatableCallback)
-> (FunPtr C_GutterRendererQueryActivatableCallback
    -> IO (GClosure C_GutterRendererQueryActivatableCallback))
-> IO (GClosure C_GutterRendererQueryActivatableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GutterRendererQueryActivatableCallback
-> IO (GClosure C_GutterRendererQueryActivatableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryActivatableCallback` into a `C_GutterRendererQueryActivatableCallback`.
wrap_GutterRendererQueryActivatableCallback ::
    GutterRendererQueryActivatableCallback ->
    C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback :: GutterRendererQueryActivatableCallback
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback GutterRendererQueryActivatableCallback
_cb Ptr ()
_ Ptr TextIter
iter Ptr Rectangle
area Ptr Event
event Ptr ()
_ = do
    (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter -> (TextIter -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter Ptr TextIter
iter ((TextIter -> IO CInt) -> IO CInt)
-> (TextIter -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        (ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> (Rectangle -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle Ptr Rectangle
area ((Rectangle -> IO CInt) -> IO CInt)
-> (Rectangle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Rectangle
area' -> do
            (ManagedPtr Event -> Event)
-> Ptr Event -> (Event -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Event -> Event
Gdk.Event.Event Ptr Event
event ((Event -> IO CInt) -> IO CInt) -> (Event -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
                Bool
result <- GutterRendererQueryActivatableCallback
_cb  TextIter
iter' Rectangle
area' Event
event'
                let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
                CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [queryActivatable](#signal:queryActivatable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' gutterRenderer #queryActivatable callback
-- @
-- 
-- 
onGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
onGutterRendererQueryActivatable :: a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
onGutterRendererQueryActivatable a
obj GutterRendererQueryActivatableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryActivatableCallback
cb' = GutterRendererQueryActivatableCallback
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback GutterRendererQueryActivatableCallback
cb
    FunPtr C_GutterRendererQueryActivatableCallback
cb'' <- C_GutterRendererQueryActivatableCallback
-> IO (FunPtr C_GutterRendererQueryActivatableCallback)
mk_GutterRendererQueryActivatableCallback C_GutterRendererQueryActivatableCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryActivatableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-activatable" FunPtr C_GutterRendererQueryActivatableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queryActivatable](#signal:queryActivatable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' gutterRenderer #queryActivatable callback
-- @
-- 
-- 
afterGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
afterGutterRendererQueryActivatable :: a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId
afterGutterRendererQueryActivatable a
obj GutterRendererQueryActivatableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryActivatableCallback
cb' = GutterRendererQueryActivatableCallback
-> C_GutterRendererQueryActivatableCallback
wrap_GutterRendererQueryActivatableCallback GutterRendererQueryActivatableCallback
cb
    FunPtr C_GutterRendererQueryActivatableCallback
cb'' <- C_GutterRendererQueryActivatableCallback
-> IO (FunPtr C_GutterRendererQueryActivatableCallback)
mk_GutterRendererQueryActivatableCallback C_GutterRendererQueryActivatableCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryActivatableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-activatable" FunPtr C_GutterRendererQueryActivatableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryActivatableSignalInfo
instance SignalInfo GutterRendererQueryActivatableSignalInfo where
    type HaskellCallbackType GutterRendererQueryActivatableSignalInfo = GutterRendererQueryActivatableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueryActivatableCallback cb
        cb'' <- mk_GutterRendererQueryActivatableCallback cb'
        connectSignalFunPtr obj "query-activatable" cb'' connectMode detail

#endif

-- signal GutterRenderer::query-data
-- | The [queryData](#g:signal:queryData) 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 t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> [GtkSource.Flags.GutterRendererState]
    -- ^ /@state@/: the renderer state
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryDataCallback`@.
noGutterRendererQueryDataCallback :: Maybe GutterRendererQueryDataCallback
noGutterRendererQueryDataCallback :: Maybe GutterRendererQueryDataCallback
noGutterRendererQueryDataCallback = Maybe GutterRendererQueryDataCallback
forall a. Maybe a
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 :: GutterRendererQueryDataCallback
-> m (GClosure C_GutterRendererQueryDataCallback)
genClosure_GutterRendererQueryData GutterRendererQueryDataCallback
cb = IO (GClosure C_GutterRendererQueryDataCallback)
-> m (GClosure C_GutterRendererQueryDataCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GutterRendererQueryDataCallback)
 -> m (GClosure C_GutterRendererQueryDataCallback))
-> IO (GClosure C_GutterRendererQueryDataCallback)
-> m (GClosure C_GutterRendererQueryDataCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryDataCallback
cb' = GutterRendererQueryDataCallback
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback GutterRendererQueryDataCallback
cb
    C_GutterRendererQueryDataCallback
-> IO (FunPtr C_GutterRendererQueryDataCallback)
mk_GutterRendererQueryDataCallback C_GutterRendererQueryDataCallback
cb' IO (FunPtr C_GutterRendererQueryDataCallback)
-> (FunPtr C_GutterRendererQueryDataCallback
    -> IO (GClosure C_GutterRendererQueryDataCallback))
-> IO (GClosure C_GutterRendererQueryDataCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GutterRendererQueryDataCallback
-> IO (GClosure C_GutterRendererQueryDataCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryDataCallback` into a `C_GutterRendererQueryDataCallback`.
wrap_GutterRendererQueryDataCallback ::
    GutterRendererQueryDataCallback ->
    C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback :: GutterRendererQueryDataCallback
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback GutterRendererQueryDataCallback
_cb Ptr ()
_ Ptr TextIter
start Ptr TextIter
end CUInt
state Ptr ()
_ = do
    (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter Ptr TextIter
start ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
start' -> do
        (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter Ptr TextIter
end ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
end' -> do
            let state' :: [GutterRendererState]
state' = CUInt -> [GutterRendererState]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
state
            GutterRendererQueryDataCallback
_cb  TextIter
start' TextIter
end' [GutterRendererState]
state'


-- | Connect a signal handler for the [queryData](#signal:queryData) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' gutterRenderer #queryData callback
-- @
-- 
-- 
onGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryDataCallback -> m SignalHandlerId
onGutterRendererQueryData :: a -> GutterRendererQueryDataCallback -> m SignalHandlerId
onGutterRendererQueryData a
obj GutterRendererQueryDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryDataCallback
cb' = GutterRendererQueryDataCallback
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback GutterRendererQueryDataCallback
cb
    FunPtr C_GutterRendererQueryDataCallback
cb'' <- C_GutterRendererQueryDataCallback
-> IO (FunPtr C_GutterRendererQueryDataCallback)
mk_GutterRendererQueryDataCallback C_GutterRendererQueryDataCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-data" FunPtr C_GutterRendererQueryDataCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queryData](#signal:queryData) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' gutterRenderer #queryData callback
-- @
-- 
-- 
afterGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryDataCallback -> m SignalHandlerId
afterGutterRendererQueryData :: a -> GutterRendererQueryDataCallback -> m SignalHandlerId
afterGutterRendererQueryData a
obj GutterRendererQueryDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryDataCallback
cb' = GutterRendererQueryDataCallback
-> C_GutterRendererQueryDataCallback
wrap_GutterRendererQueryDataCallback GutterRendererQueryDataCallback
cb
    FunPtr C_GutterRendererQueryDataCallback
cb'' <- C_GutterRendererQueryDataCallback
-> IO (FunPtr C_GutterRendererQueryDataCallback)
mk_GutterRendererQueryDataCallback C_GutterRendererQueryDataCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-data" FunPtr C_GutterRendererQueryDataCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryDataSignalInfo
instance SignalInfo GutterRendererQueryDataSignalInfo where
    type HaskellCallbackType GutterRendererQueryDataSignalInfo = GutterRendererQueryDataCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueryDataCallback cb
        cb'' <- mk_GutterRendererQueryDataCallback cb'
        connectSignalFunPtr obj "query-data" cb'' connectMode detail

#endif

-- signal GutterRenderer::query-tooltip
-- | The [queryTooltip](#g:signal:queryTooltip) signal is emitted when the renderer can
-- show a tooltip.
type GutterRendererQueryTooltipCallback =
    Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'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 t'GI.Gtk.Objects.Tooltip.Tooltip'
    -> IO Bool

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryTooltipCallback`@.
noGutterRendererQueryTooltipCallback :: Maybe GutterRendererQueryTooltipCallback
noGutterRendererQueryTooltipCallback :: Maybe GutterRendererQueryTooltipCallback
noGutterRendererQueryTooltipCallback = Maybe GutterRendererQueryTooltipCallback
forall a. Maybe a
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 :: GutterRendererQueryTooltipCallback
-> m (GClosure C_GutterRendererQueryTooltipCallback)
genClosure_GutterRendererQueryTooltip GutterRendererQueryTooltipCallback
cb = IO (GClosure C_GutterRendererQueryTooltipCallback)
-> m (GClosure C_GutterRendererQueryTooltipCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GutterRendererQueryTooltipCallback)
 -> m (GClosure C_GutterRendererQueryTooltipCallback))
-> IO (GClosure C_GutterRendererQueryTooltipCallback)
-> m (GClosure C_GutterRendererQueryTooltipCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryTooltipCallback
cb' = GutterRendererQueryTooltipCallback
-> C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback GutterRendererQueryTooltipCallback
cb
    C_GutterRendererQueryTooltipCallback
-> IO (FunPtr C_GutterRendererQueryTooltipCallback)
mk_GutterRendererQueryTooltipCallback C_GutterRendererQueryTooltipCallback
cb' IO (FunPtr C_GutterRendererQueryTooltipCallback)
-> (FunPtr C_GutterRendererQueryTooltipCallback
    -> IO (GClosure C_GutterRendererQueryTooltipCallback))
-> IO (GClosure C_GutterRendererQueryTooltipCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GutterRendererQueryTooltipCallback
-> IO (GClosure C_GutterRendererQueryTooltipCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GutterRendererQueryTooltipCallback` into a `C_GutterRendererQueryTooltipCallback`.
wrap_GutterRendererQueryTooltipCallback ::
    GutterRendererQueryTooltipCallback ->
    C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback :: GutterRendererQueryTooltipCallback
-> C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback GutterRendererQueryTooltipCallback
_cb Ptr ()
_ Ptr TextIter
iter Ptr Rectangle
area Int32
x Int32
y Ptr Tooltip
tooltip Ptr ()
_ = do
    (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter -> (TextIter -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter Ptr TextIter
iter ((TextIter -> IO CInt) -> IO CInt)
-> (TextIter -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        (ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> (Rectangle -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle Ptr Rectangle
area ((Rectangle -> IO CInt) -> IO CInt)
-> (Rectangle -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Rectangle
area' -> do
            Tooltip
tooltip' <- ((ManagedPtr Tooltip -> Tooltip) -> Ptr Tooltip -> IO Tooltip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Tooltip -> Tooltip
Gtk.Tooltip.Tooltip) Ptr Tooltip
tooltip
            Bool
result <- GutterRendererQueryTooltipCallback
_cb  TextIter
iter' Rectangle
area' Int32
x Int32
y Tooltip
tooltip'
            let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
            CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [queryTooltip](#signal:queryTooltip) 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 :: a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId
onGutterRendererQueryTooltip a
obj GutterRendererQueryTooltipCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryTooltipCallback
cb' = GutterRendererQueryTooltipCallback
-> C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback GutterRendererQueryTooltipCallback
cb
    FunPtr C_GutterRendererQueryTooltipCallback
cb'' <- C_GutterRendererQueryTooltipCallback
-> IO (FunPtr C_GutterRendererQueryTooltipCallback)
mk_GutterRendererQueryTooltipCallback C_GutterRendererQueryTooltipCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryTooltipCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-tooltip" FunPtr C_GutterRendererQueryTooltipCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queryTooltip](#signal:queryTooltip) 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 :: a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId
afterGutterRendererQueryTooltip a
obj GutterRendererQueryTooltipCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueryTooltipCallback
cb' = GutterRendererQueryTooltipCallback
-> C_GutterRendererQueryTooltipCallback
wrap_GutterRendererQueryTooltipCallback GutterRendererQueryTooltipCallback
cb
    FunPtr C_GutterRendererQueryTooltipCallback
cb'' <- C_GutterRendererQueryTooltipCallback
-> IO (FunPtr C_GutterRendererQueryTooltipCallback)
mk_GutterRendererQueryTooltipCallback C_GutterRendererQueryTooltipCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueryTooltipCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"query-tooltip" FunPtr C_GutterRendererQueryTooltipCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryTooltipSignalInfo
instance SignalInfo GutterRendererQueryTooltipSignalInfo where
    type HaskellCallbackType GutterRendererQueryTooltipSignalInfo = GutterRendererQueryTooltipCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueryTooltipCallback cb
        cb'' <- mk_GutterRendererQueryTooltipCallback cb'
        connectSignalFunPtr obj "query-tooltip" cb'' connectMode detail

#endif

-- signal GutterRenderer::queue-draw
-- | The [queueDraw](#g:signal:queueDraw) 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
-- t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' interface.
type GutterRendererQueueDrawCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueueDrawCallback`@.
noGutterRendererQueueDrawCallback :: Maybe GutterRendererQueueDrawCallback
noGutterRendererQueueDrawCallback :: Maybe (IO ())
noGutterRendererQueueDrawCallback = Maybe (IO ())
forall a. Maybe a
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 :: IO () -> m (GClosure C_GutterRendererQueueDrawCallback)
genClosure_GutterRendererQueueDraw IO ()
cb = IO (GClosure C_GutterRendererQueueDrawCallback)
-> m (GClosure C_GutterRendererQueueDrawCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GutterRendererQueueDrawCallback)
 -> m (GClosure C_GutterRendererQueueDrawCallback))
-> IO (GClosure C_GutterRendererQueueDrawCallback)
-> m (GClosure C_GutterRendererQueueDrawCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueueDrawCallback
cb' = IO () -> C_GutterRendererQueueDrawCallback
wrap_GutterRendererQueueDrawCallback IO ()
cb
    C_GutterRendererQueueDrawCallback
-> IO (FunPtr C_GutterRendererQueueDrawCallback)
mk_GutterRendererQueueDrawCallback C_GutterRendererQueueDrawCallback
cb' IO (FunPtr C_GutterRendererQueueDrawCallback)
-> (FunPtr C_GutterRendererQueueDrawCallback
    -> IO (GClosure C_GutterRendererQueueDrawCallback))
-> IO (GClosure C_GutterRendererQueueDrawCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GutterRendererQueueDrawCallback
-> IO (GClosure C_GutterRendererQueueDrawCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [queueDraw](#signal:queueDraw) 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 :: a -> IO () -> m SignalHandlerId
onGutterRendererQueueDraw a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueueDrawCallback
cb' = IO () -> C_GutterRendererQueueDrawCallback
wrap_GutterRendererQueueDrawCallback IO ()
cb
    FunPtr C_GutterRendererQueueDrawCallback
cb'' <- C_GutterRendererQueueDrawCallback
-> IO (FunPtr C_GutterRendererQueueDrawCallback)
mk_GutterRendererQueueDrawCallback C_GutterRendererQueueDrawCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueueDrawCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-draw" FunPtr C_GutterRendererQueueDrawCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queueDraw](#signal:queueDraw) 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 :: a -> IO () -> m SignalHandlerId
afterGutterRendererQueueDraw a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GutterRendererQueueDrawCallback
cb' = IO () -> C_GutterRendererQueueDrawCallback
wrap_GutterRendererQueueDrawCallback IO ()
cb
    FunPtr C_GutterRendererQueueDrawCallback
cb'' <- C_GutterRendererQueueDrawCallback
-> IO (FunPtr C_GutterRendererQueueDrawCallback)
mk_GutterRendererQueueDrawCallback C_GutterRendererQueueDrawCallback
cb'
    a
-> Text
-> FunPtr C_GutterRendererQueueDrawCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-draw" FunPtr C_GutterRendererQueueDrawCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GutterRendererQueueDrawSignalInfo
instance SignalInfo GutterRendererQueueDrawSignalInfo where
    type HaskellCallbackType GutterRendererQueueDrawSignalInfo = GutterRendererQueueDrawCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GutterRendererQueueDrawCallback cb
        cb'' <- mk_GutterRendererQueueDrawCallback cb'
        connectSignalFunPtr obj "queue-draw" cb'' connectMode detail

#endif

-- 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 :: o -> m GutterRendererAlignmentMode
getGutterRendererAlignmentMode o
obj = IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode)
-> IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO GutterRendererAlignmentMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"alignment-mode"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererAlignmentModePropertyInfo
instance AttrInfo GutterRendererAlignmentModePropertyInfo where
    type AttrAllowedOps GutterRendererAlignmentModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererAlignmentModePropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode
    type AttrTransferTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode
    type AttrTransferType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode
    type AttrGetType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode
    type AttrLabel GutterRendererAlignmentModePropertyInfo = "alignment-mode"
    type AttrOrigin GutterRendererAlignmentModePropertyInfo = GutterRenderer
    attrGet = getGutterRendererAlignmentMode
    attrSet = setGutterRendererAlignmentMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererAlignmentMode
    attrClear = undefined
#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 :: o -> m (Maybe RGBA)
getGutterRendererBackgroundRgba o
obj = IO (Maybe RGBA) -> m (Maybe RGBA)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe RGBA) -> m (Maybe RGBA))
-> IO (Maybe RGBA) -> m (Maybe RGBA)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr RGBA -> RGBA) -> IO (Maybe RGBA)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"background-rgba" ManagedPtr RGBA -> 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 :: o -> RGBA -> m ()
setGutterRendererBackgroundRgba o
obj RGBA
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe RGBA -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"background-rgba" (RGBA -> Maybe RGBA
forall a. a -> Maybe a
Just RGBA
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, MIO.MonadIO m) => Gdk.RGBA.RGBA -> m (GValueConstruct o)
constructGutterRendererBackgroundRgba :: RGBA -> m (GValueConstruct o)
constructGutterRendererBackgroundRgba RGBA
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe RGBA -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"background-rgba" (RGBA -> Maybe RGBA
forall a. a -> Maybe a
P.Just RGBA
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 :: o -> m ()
clearGutterRendererBackgroundRgba o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe RGBA -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"background-rgba" (Maybe RGBA
forall a. Maybe a
Nothing :: Maybe Gdk.RGBA.RGBA)

#if defined(ENABLE_OVERLOADING)
data GutterRendererBackgroundRgbaPropertyInfo
instance AttrInfo GutterRendererBackgroundRgbaPropertyInfo where
    type AttrAllowedOps GutterRendererBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA
    type AttrTransferTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA
    type AttrTransferType GutterRendererBackgroundRgbaPropertyInfo = Gdk.RGBA.RGBA
    type AttrGetType GutterRendererBackgroundRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA)
    type AttrLabel GutterRendererBackgroundRgbaPropertyInfo = "background-rgba"
    type AttrOrigin GutterRendererBackgroundRgbaPropertyInfo = GutterRenderer
    attrGet = getGutterRendererBackgroundRgba
    attrSet = setGutterRendererBackgroundRgba
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getGutterRendererBackgroundSet o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setGutterRendererBackgroundSet o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"background-set" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructGutterRendererBackgroundSet :: Bool -> m (GValueConstruct o)
constructGutterRendererBackgroundSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"background-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererBackgroundSetPropertyInfo
instance AttrInfo GutterRendererBackgroundSetPropertyInfo where
    type AttrAllowedOps GutterRendererBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererBackgroundSetPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint GutterRendererBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferType GutterRendererBackgroundSetPropertyInfo = Bool
    type AttrGetType GutterRendererBackgroundSetPropertyInfo = Bool
    type AttrLabel GutterRendererBackgroundSetPropertyInfo = "background-set"
    type AttrOrigin GutterRendererBackgroundSetPropertyInfo = GutterRenderer
    attrGet = getGutterRendererBackgroundSet
    attrSet = setGutterRendererBackgroundSet
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getGutterRendererSize o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setGutterRendererSize o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"size" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructGutterRendererSize :: Int32 -> m (GValueConstruct o)
constructGutterRendererSize Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"size" Int32
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererSizePropertyInfo
instance AttrInfo GutterRendererSizePropertyInfo where
    type AttrAllowedOps GutterRendererSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererSizePropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererSizePropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterRendererSizePropertyInfo = (~) Int32
    type AttrTransferType GutterRendererSizePropertyInfo = Int32
    type AttrGetType GutterRendererSizePropertyInfo = Int32
    type AttrLabel GutterRendererSizePropertyInfo = "size"
    type AttrOrigin GutterRendererSizePropertyInfo = GutterRenderer
    attrGet = getGutterRendererSize
    attrSet = setGutterRendererSize
    attrTransfer _ v = do
        return v
    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 :: o -> m TextView
getGutterRendererView o
obj = IO TextView -> m TextView
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextView -> m TextView) -> IO TextView -> m TextView
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe TextView) -> IO TextView
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getGutterRendererView" (IO (Maybe TextView) -> IO TextView)
-> IO (Maybe TextView) -> IO TextView
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr TextView -> TextView)
-> IO (Maybe TextView)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"view" ManagedPtr TextView -> TextView
Gtk.TextView.TextView

#if defined(ENABLE_OVERLOADING)
data GutterRendererViewPropertyInfo
instance AttrInfo GutterRendererViewPropertyInfo where
    type AttrAllowedOps GutterRendererViewPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GutterRendererViewPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererViewPropertyInfo = (~) ()
    type AttrTransferTypeConstraint GutterRendererViewPropertyInfo = (~) ()
    type AttrTransferType GutterRendererViewPropertyInfo = ()
    type AttrGetType GutterRendererViewPropertyInfo = Gtk.TextView.TextView
    type AttrLabel GutterRendererViewPropertyInfo = "view"
    type AttrOrigin GutterRendererViewPropertyInfo = GutterRenderer
    attrGet = getGutterRendererView
    attrSet = undefined
    attrTransfer _ = 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 :: o -> m Bool
getGutterRendererVisible o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setGutterRendererVisible o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"visible" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructGutterRendererVisible :: Bool -> m (GValueConstruct o)
constructGutterRendererVisible Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data GutterRendererVisiblePropertyInfo
instance AttrInfo GutterRendererVisiblePropertyInfo where
    type AttrAllowedOps GutterRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererVisiblePropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint GutterRendererVisiblePropertyInfo = (~) Bool
    type AttrTransferType GutterRendererVisiblePropertyInfo = Bool
    type AttrGetType GutterRendererVisiblePropertyInfo = Bool
    type AttrLabel GutterRendererVisiblePropertyInfo = "visible"
    type AttrOrigin GutterRendererVisiblePropertyInfo = GutterRenderer
    attrGet = getGutterRendererVisible
    attrSet = setGutterRendererVisible
    attrTransfer _ v = do
        return v
    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 :: o -> m TextWindowType
getGutterRendererWindowType o
obj = IO TextWindowType -> m TextWindowType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextWindowType -> m TextWindowType)
-> IO TextWindowType -> m TextWindowType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextWindowType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"window-type"

#if defined(ENABLE_OVERLOADING)
data GutterRendererWindowTypePropertyInfo
instance AttrInfo GutterRendererWindowTypePropertyInfo where
    type AttrAllowedOps GutterRendererWindowTypePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererWindowTypePropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererWindowTypePropertyInfo = (~) ()
    type AttrTransferTypeConstraint GutterRendererWindowTypePropertyInfo = (~) ()
    type AttrTransferType GutterRendererWindowTypePropertyInfo = ()
    type AttrGetType GutterRendererWindowTypePropertyInfo = Gtk.Enums.TextWindowType
    type AttrLabel GutterRendererWindowTypePropertyInfo = "window-type"
    type AttrOrigin GutterRendererWindowTypePropertyInfo = GutterRenderer
    attrGet = getGutterRendererWindowType
    attrSet = undefined
    attrTransfer _ = 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 :: o -> m Float
getGutterRendererXalign o
obj = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"xalign"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererXalignPropertyInfo
instance AttrInfo GutterRendererXalignPropertyInfo where
    type AttrAllowedOps GutterRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererXalignPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint GutterRendererXalignPropertyInfo = (~) Float
    type AttrTransferType GutterRendererXalignPropertyInfo = Float
    type AttrGetType GutterRendererXalignPropertyInfo = Float
    type AttrLabel GutterRendererXalignPropertyInfo = "xalign"
    type AttrOrigin GutterRendererXalignPropertyInfo = GutterRenderer
    attrGet = getGutterRendererXalign
    attrSet = setGutterRendererXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererXalign
    attrClear = undefined
#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 :: o -> m Int32
getGutterRendererXpad o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"xpad"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererXpadPropertyInfo
instance AttrInfo GutterRendererXpadPropertyInfo where
    type AttrAllowedOps GutterRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererXpadPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32
    type AttrTransferType GutterRendererXpadPropertyInfo = Int32
    type AttrGetType GutterRendererXpadPropertyInfo = Int32
    type AttrLabel GutterRendererXpadPropertyInfo = "xpad"
    type AttrOrigin GutterRendererXpadPropertyInfo = GutterRenderer
    attrGet = getGutterRendererXpad
    attrSet = setGutterRendererXpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererXpad
    attrClear = undefined
#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 :: o -> m Float
getGutterRendererYalign o
obj = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"yalign"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterRendererYalignPropertyInfo
instance AttrInfo GutterRendererYalignPropertyInfo where
    type AttrAllowedOps GutterRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterRendererYalignPropertyInfo = IsGutterRenderer
    type AttrSetTypeConstraint GutterRendererYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint GutterRendererYalignPropertyInfo = (~) Float
    type AttrTransferType GutterRendererYalignPropertyInfo = Float
    type AttrGetType GutterRendererYalignPropertyInfo = Float
    type AttrLabel GutterRendererYalignPropertyInfo = "yalign"
    type AttrOrigin GutterRendererYalignPropertyInfo = GutterRenderer
    attrGet = getGutterRendererYalign
    attrSet = setGutterRendererYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterRendererYalign
    attrClear = undefined
#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 :: o -> m Int32
getGutterRendererYpad o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"ypad"

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

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

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

#if defined(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 defined(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 defined(ENABLE_OVERLOADING)
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 [activate]("GI.GtkSource.Objects.GutterRenderer#g:signal:activate") signal of the renderer. This is
-- called from t'GI.GtkSource.Objects.Gutter.Gutter' and should never have to be called manually.
gutterRendererActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter' at the start of the line where the renderer is activated
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area where the renderer is activated
    -> Gdk.Event.Event
    -- ^ /@event@/: the event that triggered the activation
    -> m ()
gutterRendererActivate :: a -> TextIter -> Rectangle -> Event -> m ()
gutterRendererActivate a
renderer TextIter
iter Rectangle
area Event
event = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    Ptr GutterRenderer
-> Ptr TextIter -> Ptr Rectangle -> Ptr Event -> IO ()
gtk_source_gutter_renderer_activate Ptr GutterRenderer
renderer' Ptr TextIter
iter' Ptr Rectangle
area' Ptr Event
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Cairo.Context.Context
    -- ^ /@cr@/: a t'GI.Cairo.Structs.Context.Context'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: a t'GI.Gdk.Structs.Rectangle.Rectangle'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: a t'GI.Gdk.Structs.Rectangle.Rectangle'
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> m ()
gutterRendererBegin :: a
-> Context
-> Rectangle
-> Rectangle
-> TextIter
-> TextIter
-> m ()
gutterRendererBegin a
renderer Context
cr Rectangle
backgroundArea Rectangle
cellArea TextIter
start TextIter
end = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr Context
cr' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Context
cr
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    Ptr TextIter
start' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
start
    Ptr TextIter
end' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
end
    Ptr GutterRenderer
-> Ptr Context
-> Ptr Rectangle
-> Ptr Rectangle
-> Ptr TextIter
-> Ptr TextIter
-> IO ()
gtk_source_gutter_renderer_begin Ptr GutterRenderer
renderer' Ptr Context
cr' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
cr
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer':@/xpad/@ horizontally and two times the
-- t'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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Cairo.Context.Context
    -- ^ /@cr@/: the cairo render context
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' indicating the total area to be drawn
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' indicating the area to draw content
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> [GtkSource.Flags.GutterRendererState]
    -- ^ /@state@/: a t'GI.GtkSource.Flags.GutterRendererState'
    -> m ()
gutterRendererDraw :: a
-> Context
-> Rectangle
-> Rectangle
-> TextIter
-> TextIter
-> [GutterRendererState]
-> m ()
gutterRendererDraw a
renderer Context
cr Rectangle
backgroundArea Rectangle
cellArea TextIter
start TextIter
end [GutterRendererState]
state = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr Context
cr' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Context
cr
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    Ptr TextIter
start' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
start
    Ptr TextIter
end' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
end
    let state' :: CUInt
state' = [GutterRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [GutterRendererState]
state
    Ptr GutterRenderer
-> Ptr Context
-> Ptr Rectangle
-> Ptr Rectangle
-> Ptr TextIter
-> Ptr TextIter
-> CUInt
-> IO ()
gtk_source_gutter_renderer_draw Ptr GutterRenderer
renderer' Ptr Context
cr' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' Ptr TextIter
start' Ptr TextIter
end' CUInt
state'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
cr
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m ()
gutterRendererEnd :: a -> m ()
gutterRendererEnd a
renderer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> IO ()
gtk_source_gutter_renderer_end Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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
-- Not implemented: Don't know how to allocate "xalign" of type TBasicType TFloat
#if defined(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.UnsupportedMethodError "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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m GtkSource.Enums.GutterRendererAlignmentMode
    -- ^ __Returns:__ a t'GI.GtkSource.Enums.GutterRendererAlignmentMode'
gutterRendererGetAlignmentMode :: a -> m GutterRendererAlignmentMode
gutterRendererGetAlignmentMode a
renderer = IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode)
-> IO GutterRendererAlignmentMode -> m GutterRendererAlignmentMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CUInt
result <- Ptr GutterRenderer -> IO CUInt
gtk_source_gutter_renderer_get_alignment_mode Ptr GutterRenderer
renderer'
    let result' :: GutterRendererAlignmentMode
result' = (Int -> GutterRendererAlignmentMode
forall a. Enum a => Int -> a
toEnum (Int -> GutterRendererAlignmentMode)
-> (CUInt -> Int) -> CUInt -> GutterRendererAlignmentMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    GutterRendererAlignmentMode -> IO GutterRendererAlignmentMode
forall (m :: * -> *) a. Monad m => a -> m a
return GutterRendererAlignmentMode
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererGetAlignmentModeMethodInfo
instance (signature ~ (m GtkSource.Enums.GutterRendererAlignmentMode), MonadIO m, IsGutterRenderer a) => O.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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m ((Bool, Gdk.RGBA.RGBA))
    -- ^ __Returns:__ 'P.True' if the background color is set, 'P.False' otherwise
gutterRendererGetBackground :: a -> m (Bool, RGBA)
gutterRendererGetBackground a
renderer = IO (Bool, RGBA) -> m (Bool, RGBA)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, RGBA) -> m (Bool, RGBA))
-> IO (Bool, RGBA) -> m (Bool, RGBA)
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr RGBA
color <- Int -> IO (Ptr RGBA)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gdk.RGBA.RGBA)
    CInt
result <- Ptr GutterRenderer -> Ptr RGBA -> IO CInt
gtk_source_gutter_renderer_get_background Ptr GutterRenderer
renderer' Ptr RGBA
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RGBA
color' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    (Bool, RGBA) -> IO (Bool, RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', RGBA
color')

#if defined(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
-- Not implemented: Don't know how to allocate "xpad" of type TBasicType TInt
#if defined(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.UnsupportedMethodError "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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Int32
    -- ^ __Returns:__ the size of the renderer.
gutterRendererGetSize :: a -> m Int32
gutterRendererGetSize a
renderer = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Int32
result <- Ptr GutterRenderer -> IO Int32
gtk_source_gutter_renderer_get_size Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Gtk.TextView.TextView
    -- ^ __Returns:__ a t'GI.Gtk.Objects.TextView.TextView'
gutterRendererGetView :: a -> m TextView
gutterRendererGetView a
renderer = IO TextView -> m TextView
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextView -> m TextView) -> IO TextView -> m TextView
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextView
result <- Ptr GutterRenderer -> IO (Ptr TextView)
gtk_source_gutter_renderer_get_view Ptr GutterRenderer
renderer'
    Text -> Ptr TextView -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gutterRendererGetView" Ptr TextView
result
    TextView
result' <- ((ManagedPtr TextView -> TextView) -> Ptr TextView -> IO TextView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextView -> TextView
Gtk.TextView.TextView) Ptr TextView
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextView -> IO TextView
forall (m :: * -> *) a. Monad m => a -> m a
return TextView
result'

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the renderer is visible, 'P.False' otherwise
gutterRendererGetVisible :: a -> m Bool
gutterRendererGetVisible a
renderer = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CInt
result <- Ptr GutterRenderer -> IO CInt
gtk_source_gutter_renderer_get_visible Ptr GutterRenderer
renderer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Enums.TextWindowType' associated with the gutter renderer.
gutterRendererGetWindowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m Gtk.Enums.TextWindowType
    -- ^ __Returns:__ a t'GI.Gtk.Enums.TextWindowType'
gutterRendererGetWindowType :: a -> m TextWindowType
gutterRendererGetWindowType a
renderer = IO TextWindowType -> m TextWindowType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextWindowType -> m TextWindowType)
-> IO TextWindowType -> m TextWindowType
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    CUInt
result <- Ptr GutterRenderer -> IO CUInt
gtk_source_gutter_renderer_get_window_type Ptr GutterRenderer
renderer'
    let result' :: TextWindowType
result' = (Int -> TextWindowType
forall a. Enum a => Int -> a
toEnum (Int -> TextWindowType)
-> (CUInt -> Int) -> CUInt -> TextWindowType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextWindowType -> IO TextWindowType
forall (m :: * -> *) a. Monad m => a -> m a
return TextWindowType
result'

#if defined(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 t'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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter' at the start of the line to be activated
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area to be activated
    -> Gdk.Event.Event
    -- ^ /@event@/: the event that triggered the query
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the renderer can be activated, 'P.False' otherwise
gutterRendererQueryActivatable :: a -> TextIter -> Rectangle -> Event -> m Bool
gutterRendererQueryActivatable a
renderer TextIter
iter Rectangle
area Event
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    CInt
result <- Ptr GutterRenderer
-> Ptr TextIter -> Ptr Rectangle -> Ptr Event -> IO CInt
gtk_source_gutter_renderer_query_activatable Ptr GutterRenderer
renderer' Ptr TextIter
iter' Ptr Rectangle
area' Ptr Event
event'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data GutterRendererQueryActivatableMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> 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 [queryData]("GI.GtkSource.Objects.GutterRenderer#g:signal:queryData") signal. This function is called
-- to query for data just before rendering a cell. This is called from the
-- t'GI.GtkSource.Objects.Gutter.Gutter'.  Implementations can override the default signal handler or
-- can connect a signal handler externally to the
-- [queryData]("GI.GtkSource.Objects.GutterRenderer#g:signal:queryData") signal.
gutterRendererQueryData ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> [GtkSource.Flags.GutterRendererState]
    -- ^ /@state@/: a t'GI.GtkSource.Flags.GutterRendererState'.
    -> m ()
gutterRendererQueryData :: a -> TextIter -> TextIter -> [GutterRendererState] -> m ()
gutterRendererQueryData a
renderer TextIter
start TextIter
end [GutterRendererState]
state = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
start' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
start
    Ptr TextIter
end' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
end
    let state' :: CUInt
state' = [GutterRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [GutterRendererState]
state
    Ptr GutterRenderer
-> Ptr TextIter -> Ptr TextIter -> CUInt -> IO ()
gtk_source_gutter_renderer_query_data Ptr GutterRenderer
renderer' Ptr TextIter
start' Ptr TextIter
end' CUInt
state'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 [queryTooltip]("GI.GtkSource.Objects.GutterRenderer#g:signal:queryTooltip") signal. This function is
-- called from t'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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gdk.Rectangle.Rectangle
    -- ^ /@area@/: a t'GI.Gdk.Structs.Rectangle.Rectangle'.
    -> Int32
    -- ^ /@x@/: The x position of the tooltip.
    -> Int32
    -- ^ /@y@/: The y position of the tooltip.
    -> b
    -- ^ /@tooltip@/: a t'GI.Gtk.Objects.Tooltip.Tooltip'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the tooltip has been set, 'P.False' otherwise
gutterRendererQueryTooltip :: a -> TextIter -> Rectangle -> Int32 -> Int32 -> b -> m Bool
gutterRendererQueryTooltip a
renderer TextIter
iter Rectangle
area Int32
x Int32
y b
tooltip = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    Ptr Tooltip
tooltip' <- b -> IO (Ptr Tooltip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
tooltip
    CInt
result <- Ptr GutterRenderer
-> Ptr TextIter
-> Ptr Rectangle
-> Int32
-> Int32
-> Ptr Tooltip
-> IO CInt
gtk_source_gutter_renderer_query_tooltip Ptr GutterRenderer
renderer' Ptr TextIter
iter' Ptr Rectangle
area' Int32
x Int32
y Ptr Tooltip
tooltip'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
tooltip
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 [queueDraw]("GI.GtkSource.Objects.GutterRenderer#g:signal:queueDraw") 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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> m ()
gutterRendererQueueDraw :: a -> m ()
gutterRendererQueueDraw a
renderer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> IO ()
gtk_source_gutter_renderer_queue_draw Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Float
    -- ^ /@xalign@/: the x-alignment
    -> Float
    -- ^ /@yalign@/: the y-alignment
    -> m ()
gutterRendererSetAlignment :: a -> Float -> Float -> m ()
gutterRendererSetAlignment a
renderer Float
xalign Float
yalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr GutterRenderer -> CFloat -> CFloat -> IO ()
gtk_source_gutter_renderer_set_alignment Ptr GutterRenderer
renderer' CFloat
xalign' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> GtkSource.Enums.GutterRendererAlignmentMode
    -- ^ /@mode@/: a t'GI.GtkSource.Enums.GutterRendererAlignmentMode'
    -> m ()
gutterRendererSetAlignmentMode :: a -> GutterRendererAlignmentMode -> m ()
gutterRendererSetAlignmentMode a
renderer GutterRendererAlignmentMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (GutterRendererAlignmentMode -> Int)
-> GutterRendererAlignmentMode
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GutterRendererAlignmentMode -> Int
forall a. Enum a => a -> Int
fromEnum) GutterRendererAlignmentMode
mode
    Ptr GutterRenderer -> CUInt -> IO ()
gtk_source_gutter_renderer_set_alignment_mode Ptr GutterRenderer
renderer' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRendererSetAlignmentModeMethodInfo
instance (signature ~ (GtkSource.Enums.GutterRendererAlignmentMode -> m ()), MonadIO m, IsGutterRenderer a) => O.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 'P.Nothing', the
-- renderer will not have a background color.
gutterRendererSetBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) =>
    a
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@color@/: a t'GI.Gdk.Structs.RGBA.RGBA' or 'P.Nothing'
    -> m ()
gutterRendererSetBackground :: a -> Maybe RGBA -> m ()
gutterRendererSetBackground a
renderer Maybe RGBA
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr RGBA
maybeColor <- case Maybe RGBA
color of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just RGBA
jColor -> do
            Ptr RGBA
jColor' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jColor
            Ptr RGBA -> IO (Ptr RGBA)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jColor'
    Ptr GutterRenderer -> Ptr RGBA -> IO ()
gtk_source_gutter_renderer_set_background Ptr GutterRenderer
renderer' Ptr RGBA
maybeColor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
color RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Int32
    -- ^ /@xpad@/: the x-padding
    -> Int32
    -- ^ /@ypad@/: the y-padding
    -> m ()
gutterRendererSetPadding :: a -> Int32 -> Int32 -> m ()
gutterRendererSetPadding a
renderer Int32
xpad Int32
ypad = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> Int32 -> Int32 -> IO ()
gtk_source_gutter_renderer_set_padding Ptr GutterRenderer
renderer' Int32
xpad Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Int32
    -- ^ /@size@/: the size
    -> m ()
gutterRendererSetSize :: a -> Int32 -> m ()
gutterRendererSetSize a
renderer Int32
size = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    Ptr GutterRenderer -> Int32 -> IO ()
gtk_source_gutter_renderer_set_size Ptr GutterRenderer
renderer' Int32
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'
    -> Bool
    -- ^ /@visible@/: the visibility
    -> m ()
gutterRendererSetVisible :: a -> Bool -> m ()
gutterRendererSetVisible a
renderer Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GutterRenderer
renderer' <- a -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
renderer
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr GutterRenderer -> CInt -> IO ()
gtk_source_gutter_renderer_set_visible Ptr GutterRenderer
renderer' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif