{-# 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.Gutter
    ( 

-- * Exported types
    Gutter(..)                              ,
    IsGutter                                ,
    toGutter                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [insert]("GI.GtkSource.Objects.Gutter#g:method:insert"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [queueDraw]("GI.GtkSource.Objects.Gutter#g:method:queueDraw"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.GtkSource.Objects.Gutter#g:method:remove"), [reorder]("GI.GtkSource.Objects.Gutter#g:method:reorder"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getPadding]("GI.GtkSource.Objects.Gutter#g:method:getPadding"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRendererAtPos]("GI.GtkSource.Objects.Gutter#g:method:getRendererAtPos"), [getView]("GI.GtkSource.Objects.Gutter#g:method:getView"), [getWindow]("GI.GtkSource.Objects.Gutter#g:method:getWindow"), [getWindowType]("GI.GtkSource.Objects.Gutter#g:method:getWindowType").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setPadding]("GI.GtkSource.Objects.Gutter#g:method:setPadding"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveGutterMethod                     ,
#endif

-- ** getPadding #method:getPadding#

#if defined(ENABLE_OVERLOADING)
    GutterGetPaddingMethodInfo              ,
#endif
    gutterGetPadding                        ,


-- ** getRendererAtPos #method:getRendererAtPos#

#if defined(ENABLE_OVERLOADING)
    GutterGetRendererAtPosMethodInfo        ,
#endif
    gutterGetRendererAtPos                  ,


-- ** getView #method:getView#

#if defined(ENABLE_OVERLOADING)
    GutterGetViewMethodInfo                 ,
#endif
    gutterGetView                           ,


-- ** getWindow #method:getWindow#

#if defined(ENABLE_OVERLOADING)
    GutterGetWindowMethodInfo               ,
#endif
    gutterGetWindow                         ,


-- ** getWindowType #method:getWindowType#

#if defined(ENABLE_OVERLOADING)
    GutterGetWindowTypeMethodInfo           ,
#endif
    gutterGetWindowType                     ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    GutterInsertMethodInfo                  ,
#endif
    gutterInsert                            ,


-- ** queueDraw #method:queueDraw#

#if defined(ENABLE_OVERLOADING)
    GutterQueueDrawMethodInfo               ,
#endif
    gutterQueueDraw                         ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    GutterRemoveMethodInfo                  ,
#endif
    gutterRemove                            ,


-- ** reorder #method:reorder#

#if defined(ENABLE_OVERLOADING)
    GutterReorderMethodInfo                 ,
#endif
    gutterReorder                           ,


-- ** setPadding #method:setPadding#

#if defined(ENABLE_OVERLOADING)
    GutterSetPaddingMethodInfo              ,
#endif
    gutterSetPadding                        ,




 -- * Properties


-- ** view #attr:view#
-- | The t'GI.GtkSource.Objects.View.View' of the gutter.

#if defined(ENABLE_OVERLOADING)
    GutterViewPropertyInfo                  ,
#endif
    constructGutterView                     ,
    getGutterView                           ,
#if defined(ENABLE_OVERLOADING)
    gutterView                              ,
#endif


-- ** windowType #attr:windowType#
-- | The text window type on which the window is placed.

#if defined(ENABLE_OVERLOADING)
    GutterWindowTypePropertyInfo            ,
#endif
    constructGutterWindowType               ,
    getGutterWindowType                     ,
#if defined(ENABLE_OVERLOADING)
    gutterWindowType                        ,
#endif


-- ** xpad #attr:xpad#
-- | The x-padding.

#if defined(ENABLE_OVERLOADING)
    GutterXpadPropertyInfo                  ,
#endif
    constructGutterXpad                     ,
    getGutterXpad                           ,
#if defined(ENABLE_OVERLOADING)
    gutterXpad                              ,
#endif
    setGutterXpad                           ,


-- ** ypad #attr:ypad#
-- | The y-padding.

#if defined(ENABLE_OVERLOADING)
    GutterYpadPropertyInfo                  ,
#endif
    constructGutterYpad                     ,
    getGutterYpad                           ,
#if defined(ENABLE_OVERLOADING)
    gutterYpad                              ,
#endif
    setGutterYpad                           ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Objects.Window as Gdk.Window
import qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.GtkSource.Objects.GutterRenderer as GtkSource.GutterRenderer
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View

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

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

foreign import ccall "gtk_source_gutter_get_type"
    c_gtk_source_gutter_get_type :: IO B.Types.GType

instance B.Types.TypedObject Gutter where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_gutter_get_type

instance B.Types.GObject Gutter

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

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

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

-- | Convert 'Gutter' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Gutter) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_gutter_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Gutter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Gutter
P.Nothing = Ptr GValue -> Ptr Gutter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Gutter
forall a. Ptr a
FP.nullPtr :: FP.Ptr Gutter)
    gvalueSet_ Ptr GValue
gv (P.Just Gutter
obj) = Gutter -> (Ptr Gutter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Gutter
obj (Ptr GValue -> Ptr Gutter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Gutter)
gvalueGet_ Ptr GValue
gv = do
        Ptr Gutter
ptr <- Ptr GValue -> IO (Ptr Gutter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Gutter)
        if Ptr Gutter
ptr Ptr Gutter -> Ptr Gutter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Gutter
forall a. Ptr a
FP.nullPtr
        then Gutter -> Maybe Gutter
forall a. a -> Maybe a
P.Just (Gutter -> Maybe Gutter) -> IO Gutter -> IO (Maybe Gutter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Gutter -> Gutter) -> Ptr Gutter -> IO Gutter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Gutter -> Gutter
Gutter Ptr Gutter
ptr
        else Maybe Gutter -> IO (Maybe Gutter)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Gutter
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveGutterMethod (t :: Symbol) (o :: *) :: * where
    ResolveGutterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveGutterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveGutterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveGutterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveGutterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveGutterMethod "insert" o = GutterInsertMethodInfo
    ResolveGutterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveGutterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveGutterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveGutterMethod "queueDraw" o = GutterQueueDrawMethodInfo
    ResolveGutterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveGutterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveGutterMethod "remove" o = GutterRemoveMethodInfo
    ResolveGutterMethod "reorder" o = GutterReorderMethodInfo
    ResolveGutterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveGutterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveGutterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveGutterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveGutterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveGutterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveGutterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveGutterMethod "getPadding" o = GutterGetPaddingMethodInfo
    ResolveGutterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveGutterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveGutterMethod "getRendererAtPos" o = GutterGetRendererAtPosMethodInfo
    ResolveGutterMethod "getView" o = GutterGetViewMethodInfo
    ResolveGutterMethod "getWindow" o = GutterGetWindowMethodInfo
    ResolveGutterMethod "getWindowType" o = GutterGetWindowTypeMethodInfo
    ResolveGutterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGutterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveGutterMethod "setPadding" o = GutterSetPaddingMethodInfo
    ResolveGutterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveGutterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveGutterMethod t Gutter, O.OverloadedMethod info Gutter p) => OL.IsLabel t (Gutter -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveGutterMethod t Gutter, O.OverloadedMethod info Gutter p, R.HasField t Gutter p) => R.HasField t Gutter p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- VVV Prop "view"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "View"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- 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' gutter #view
-- @
getGutterView :: (MonadIO m, IsGutter o) => o -> m GtkSource.View.View
getGutterView :: forall (m :: * -> *) o. (MonadIO m, IsGutter o) => o -> m View
getGutterView o
obj = IO View -> m View
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO View -> m View) -> IO View -> m View
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe View) -> IO View
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getGutterView" (IO (Maybe View) -> IO View) -> IO (Maybe View) -> IO View
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr View -> View) -> IO (Maybe View)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"view" ManagedPtr View -> View
GtkSource.View.View

-- | Construct a `GValueConstruct` with valid value for the “@view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGutterView :: (IsGutter o, MIO.MonadIO m, GtkSource.View.IsView a) => a -> m (GValueConstruct o)
constructGutterView :: forall o (m :: * -> *) a.
(IsGutter o, MonadIO m, IsView a) =>
a -> m (GValueConstruct o)
constructGutterView a
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"view" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data GutterViewPropertyInfo
instance AttrInfo GutterViewPropertyInfo where
    type AttrAllowedOps GutterViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GutterViewPropertyInfo = IsGutter
    type AttrSetTypeConstraint GutterViewPropertyInfo = GtkSource.View.IsView
    type AttrTransferTypeConstraint GutterViewPropertyInfo = GtkSource.View.IsView
    type AttrTransferType GutterViewPropertyInfo = GtkSource.View.View
    type AttrGetType GutterViewPropertyInfo = GtkSource.View.View
    type AttrLabel GutterViewPropertyInfo = "view"
    type AttrOrigin GutterViewPropertyInfo = Gutter
    attrGet = getGutterView
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo GtkSource.View.View v
    attrConstruct = constructGutterView
    attrClear = undefined
#endif

-- VVV Prop "window-type"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextWindowType"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- 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' gutter #windowType
-- @
getGutterWindowType :: (MonadIO m, IsGutter o) => o -> m Gtk.Enums.TextWindowType
getGutterWindowType :: forall (m :: * -> *) o.
(MonadIO m, IsGutter o) =>
o -> m TextWindowType
getGutterWindowType o
obj = IO TextWindowType -> m TextWindowType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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"

-- | Construct a `GValueConstruct` with valid value for the “@window-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGutterWindowType :: (IsGutter o, MIO.MonadIO m) => Gtk.Enums.TextWindowType -> m (GValueConstruct o)
constructGutterWindowType :: forall o (m :: * -> *).
(IsGutter o, MonadIO m) =>
TextWindowType -> m (GValueConstruct o)
constructGutterWindowType TextWindowType
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TextWindowType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"window-type" TextWindowType
val

#if defined(ENABLE_OVERLOADING)
data GutterWindowTypePropertyInfo
instance AttrInfo GutterWindowTypePropertyInfo where
    type AttrAllowedOps GutterWindowTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterWindowTypePropertyInfo = IsGutter
    type AttrSetTypeConstraint GutterWindowTypePropertyInfo = (~) Gtk.Enums.TextWindowType
    type AttrTransferTypeConstraint GutterWindowTypePropertyInfo = (~) Gtk.Enums.TextWindowType
    type AttrTransferType GutterWindowTypePropertyInfo = Gtk.Enums.TextWindowType
    type AttrGetType GutterWindowTypePropertyInfo = Gtk.Enums.TextWindowType
    type AttrLabel GutterWindowTypePropertyInfo = "window-type"
    type AttrOrigin GutterWindowTypePropertyInfo = Gutter
    attrGet = getGutterWindowType
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterWindowType
    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' gutter #xpad
-- @
getGutterXpad :: (MonadIO m, IsGutter o) => o -> m Int32
getGutterXpad :: forall (m :: * -> *) o. (MonadIO m, IsGutter o) => o -> m Int32
getGutterXpad o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"xpad"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterXpadPropertyInfo
instance AttrInfo GutterXpadPropertyInfo where
    type AttrAllowedOps GutterXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterXpadPropertyInfo = IsGutter
    type AttrSetTypeConstraint GutterXpadPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterXpadPropertyInfo = (~) Int32
    type AttrTransferType GutterXpadPropertyInfo = Int32
    type AttrGetType GutterXpadPropertyInfo = Int32
    type AttrLabel GutterXpadPropertyInfo = "xpad"
    type AttrOrigin GutterXpadPropertyInfo = Gutter
    attrGet = getGutterXpad
    attrSet = setGutterXpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterXpad
    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' gutter #ypad
-- @
getGutterYpad :: (MonadIO m, IsGutter o) => o -> m Int32
getGutterYpad :: forall (m :: * -> *) o. (MonadIO m, IsGutter o) => o -> m Int32
getGutterYpad o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"ypad"

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

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

#if defined(ENABLE_OVERLOADING)
data GutterYpadPropertyInfo
instance AttrInfo GutterYpadPropertyInfo where
    type AttrAllowedOps GutterYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GutterYpadPropertyInfo = IsGutter
    type AttrSetTypeConstraint GutterYpadPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint GutterYpadPropertyInfo = (~) Int32
    type AttrTransferType GutterYpadPropertyInfo = Int32
    type AttrGetType GutterYpadPropertyInfo = Int32
    type AttrLabel GutterYpadPropertyInfo = "ypad"
    type AttrOrigin GutterYpadPropertyInfo = Gutter
    attrGet = getGutterYpad
    attrSet = setGutterYpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructGutterYpad
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Gutter
type instance O.AttributeList Gutter = GutterAttributeList
type GutterAttributeList = ('[ '("view", GutterViewPropertyInfo), '("windowType", GutterWindowTypePropertyInfo), '("xpad", GutterXpadPropertyInfo), '("ypad", GutterYpadPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
gutterView :: AttrLabelProxy "view"
gutterView = AttrLabelProxy

gutterWindowType :: AttrLabelProxy "windowType"
gutterWindowType = AttrLabelProxy

gutterXpad :: AttrLabelProxy "xpad"
gutterXpad = AttrLabelProxy

gutterYpad :: AttrLabelProxy "ypad"
gutterYpad = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Gutter = GutterSignalList
type GutterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Gutter::get_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 = Nothing , 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 = Nothing , 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_get_padding" gtk_source_gutter_get_padding :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Int32 ->                                -- xpad : TBasicType TInt
    Int32 ->                                -- ypad : TBasicType TInt
    IO ()

{-# DEPRECATED gutterGetPadding ["(Since version 3.12)","Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererGetPadding' instead."] #-}
-- | /No description available in the introspection data./
gutterGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -> Int32
    -> Int32
    -> m ()
gutterGetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> Int32 -> Int32 -> m ()
gutterGetPadding a
gutter 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr Gutter -> Int32 -> Int32 -> IO ()
gtk_source_gutter_get_padding Ptr Gutter
gutter' Int32
xpad Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterGetPaddingMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutter a) => O.OverloadedMethod GutterGetPaddingMethodInfo a signature where
    overloadedMethod = gutterGetPadding

instance O.OverloadedMethodInfo GutterGetPaddingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterGetPadding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterGetPadding"
        }


#endif

-- method Gutter::get_renderer_at_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkSourceGutter."
--                 , 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 to get identified."
--                 , 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 to get identified."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "GutterRenderer" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_get_renderer_at_pos" gtk_source_gutter_get_renderer_at_pos :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO (Ptr GtkSource.GutterRenderer.GutterRenderer)

-- | Finds the t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' at (x, y).
gutterGetRendererAtPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -- ^ /@gutter@/: A t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> Int32
    -- ^ /@x@/: The x position to get identified.
    -> Int32
    -- ^ /@y@/: The y position to get identified.
    -> m (Maybe GtkSource.GutterRenderer.GutterRenderer)
    -- ^ __Returns:__ the renderer at (x, y) or 'P.Nothing'.
gutterGetRendererAtPos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> Int32 -> Int32 -> m (Maybe GutterRenderer)
gutterGetRendererAtPos a
gutter Int32
x Int32
y = IO (Maybe GutterRenderer) -> m (Maybe GutterRenderer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GutterRenderer) -> m (Maybe GutterRenderer))
-> IO (Maybe GutterRenderer) -> m (Maybe GutterRenderer)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr GutterRenderer
result <- Ptr Gutter -> Int32 -> Int32 -> IO (Ptr GutterRenderer)
gtk_source_gutter_get_renderer_at_pos Ptr Gutter
gutter' Int32
x Int32
y
    Maybe GutterRenderer
maybeResult <- Ptr GutterRenderer
-> (Ptr GutterRenderer -> IO GutterRenderer)
-> IO (Maybe GutterRenderer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GutterRenderer
result ((Ptr GutterRenderer -> IO GutterRenderer)
 -> IO (Maybe GutterRenderer))
-> (Ptr GutterRenderer -> IO GutterRenderer)
-> IO (Maybe GutterRenderer)
forall a b. (a -> b) -> a -> b
$ \Ptr GutterRenderer
result' -> do
        GutterRenderer
result'' <- ((ManagedPtr GutterRenderer -> GutterRenderer)
-> Ptr GutterRenderer -> IO GutterRenderer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr GutterRenderer -> GutterRenderer
GtkSource.GutterRenderer.GutterRenderer) Ptr GutterRenderer
result'
        GutterRenderer -> IO GutterRenderer
forall (m :: * -> *) a. Monad m => a -> m a
return GutterRenderer
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    Maybe GutterRenderer -> IO (Maybe GutterRenderer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GutterRenderer
maybeResult

#if defined(ENABLE_OVERLOADING)
data GutterGetRendererAtPosMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Maybe GtkSource.GutterRenderer.GutterRenderer)), MonadIO m, IsGutter a) => O.OverloadedMethod GutterGetRendererAtPosMethodInfo a signature where
    overloadedMethod = gutterGetRendererAtPos

instance O.OverloadedMethodInfo GutterGetRendererAtPosMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterGetRendererAtPos",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterGetRendererAtPos"
        }


#endif

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

foreign import ccall "gtk_source_gutter_get_view" gtk_source_gutter_get_view :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    IO (Ptr GtkSource.View.View)

-- | /No description available in the introspection data./
-- 
-- /Since: 3.24/
gutterGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> m GtkSource.View.View
    -- ^ __Returns:__ the associated t'GI.GtkSource.Objects.View.View'.
gutterGetView :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> m View
gutterGetView a
gutter = IO View -> m View
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO View -> m View) -> IO View -> m View
forall a b. (a -> b) -> a -> b
$ do
    Ptr Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr View
result <- Ptr Gutter -> IO (Ptr View)
gtk_source_gutter_get_view Ptr Gutter
gutter'
    Text -> Ptr View -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gutterGetView" Ptr View
result
    View
result' <- ((ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr View -> View
GtkSource.View.View) Ptr View
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    View -> IO View
forall (m :: * -> *) a. Monad m => a -> m a
return View
result'

#if defined(ENABLE_OVERLOADING)
data GutterGetViewMethodInfo
instance (signature ~ (m GtkSource.View.View), MonadIO m, IsGutter a) => O.OverloadedMethod GutterGetViewMethodInfo a signature where
    overloadedMethod = gutterGetView

instance O.OverloadedMethodInfo GutterGetViewMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterGetView",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterGetView"
        }


#endif

-- method Gutter::get_window
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutter."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Window" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_gutter_get_window" gtk_source_gutter_get_window :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    IO (Ptr Gdk.Window.Window)

{-# DEPRECATED gutterGetWindow ["(Since version 3.12)","Use 'GI.Gtk.Objects.TextView.textViewGetWindow' instead."] #-}
-- | Get the t'GI.Gdk.Objects.Window.Window' of the gutter. The window will only be available when the
-- gutter has at least one, non-zero width, cell renderer packed.
-- 
-- /Since: 2.8/
gutterGetWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> m Gdk.Window.Window
    -- ^ __Returns:__ the t'GI.Gdk.Objects.Window.Window' of the gutter, or 'P.Nothing'
    -- if the gutter has no window.
gutterGetWindow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> m Window
gutterGetWindow a
gutter = IO Window -> m Window
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Window -> m Window) -> IO Window -> m Window
forall a b. (a -> b) -> a -> b
$ do
    Ptr Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr Window
result <- Ptr Gutter -> IO (Ptr Window)
gtk_source_gutter_get_window Ptr Gutter
gutter'
    Text -> Ptr Window -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gutterGetWindow" Ptr Window
result
    Window
result' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    Window -> IO Window
forall (m :: * -> *) a. Monad m => a -> m a
return Window
result'

#if defined(ENABLE_OVERLOADING)
data GutterGetWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsGutter a) => O.OverloadedMethod GutterGetWindowMethodInfo a signature where
    overloadedMethod = gutterGetWindow

instance O.OverloadedMethodInfo GutterGetWindowMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterGetWindow",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterGetWindow"
        }


#endif

-- method Gutter::get_window_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutter."
--                 , 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_get_window_type" gtk_source_gutter_get_window_type :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    IO CUInt

-- | /No description available in the introspection data./
-- 
-- /Since: 3.24/
gutterGetWindowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> m Gtk.Enums.TextWindowType
    -- ^ __Returns:__ the t'GI.Gtk.Enums.TextWindowType' of /@gutter@/.
gutterGetWindowType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> m TextWindowType
gutterGetWindowType a
gutter = 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    CUInt
result <- Ptr Gutter -> IO CUInt
gtk_source_gutter_get_window_type Ptr Gutter
gutter'
    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
gutter
    TextWindowType -> IO TextWindowType
forall (m :: * -> *) a. Monad m => a -> m a
return TextWindowType
result'

#if defined(ENABLE_OVERLOADING)
data GutterGetWindowTypeMethodInfo
instance (signature ~ (m Gtk.Enums.TextWindowType), MonadIO m, IsGutter a) => O.OverloadedMethod GutterGetWindowTypeMethodInfo a signature where
    overloadedMethod = gutterGetWindowType

instance O.OverloadedMethodInfo GutterGetWindowTypeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterGetWindowType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterGetWindowType"
        }


#endif

-- method Gutter::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutter."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a gutter renderer (must inherit from #GtkSourceGutterRenderer)."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the renderer position."
--                 , 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_insert" gtk_source_gutter_insert :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- position : TBasicType TInt
    IO CInt

-- | Insert /@renderer@/ into the gutter. If /@renderer@/ is yet unowned then gutter
-- claims its ownership. Otherwise just increases renderer\'s reference count.
-- /@renderer@/ cannot be already inserted to another gutter.
-- 
-- /Since: 3.0/
gutterInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> b
    -- ^ /@renderer@/: a gutter renderer (must inherit from t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer').
    -> Int32
    -- ^ /@position@/: the renderer position.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if operation succeeded. Otherwise 'P.False'.
gutterInsert :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsGutter a, IsGutterRenderer b) =>
a -> b -> Int32 -> m Bool
gutterInsert a
gutter b
renderer Int32
position = 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr GutterRenderer
renderer' <- b -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
renderer
    CInt
result <- Ptr Gutter -> Ptr GutterRenderer -> Int32 -> IO CInt
gtk_source_gutter_insert Ptr Gutter
gutter' Ptr GutterRenderer
renderer' Int32
position
    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
gutter
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
renderer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data GutterInsertMethodInfo
instance (signature ~ (b -> Int32 -> m Bool), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.OverloadedMethod GutterInsertMethodInfo a signature where
    overloadedMethod = gutterInsert

instance O.OverloadedMethodInfo GutterInsertMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterInsert",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterInsert"
        }


#endif

-- method Gutter::queue_draw
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutter."
--                 , 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_queue_draw" gtk_source_gutter_queue_draw :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    IO ()

-- | Invalidates the drawable area of the gutter. You can use this to force a
-- redraw of the gutter if something has changed and needs to be redrawn.
-- 
-- /Since: 2.8/
gutterQueueDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> m ()
gutterQueueDraw :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> m ()
gutterQueueDraw a
gutter = 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr Gutter -> IO ()
gtk_source_gutter_queue_draw Ptr Gutter
gutter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterQueueDrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsGutter a) => O.OverloadedMethod GutterQueueDrawMethodInfo a signature where
    overloadedMethod = gutterQueueDraw

instance O.OverloadedMethodInfo GutterQueueDrawMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterQueueDraw",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterQueueDraw"
        }


#endif

-- method Gutter::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutter."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , 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_remove" gtk_source_gutter_remove :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    IO ()

-- | Removes /@renderer@/ from /@gutter@/.
-- 
-- /Since: 2.8/
gutterRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.Gutter.Gutter'.
    -> b
    -- ^ /@renderer@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'.
    -> m ()
gutterRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsGutter a, IsGutterRenderer b) =>
a -> b -> m ()
gutterRemove a
gutter b
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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr GutterRenderer
renderer' <- b -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
renderer
    Ptr Gutter -> Ptr GutterRenderer -> IO ()
gtk_source_gutter_remove Ptr Gutter
gutter' Ptr GutterRenderer
renderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.OverloadedMethod GutterRemoveMethodInfo a signature where
    overloadedMethod = gutterRemove

instance O.OverloadedMethodInfo GutterRemoveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterRemove",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterRemove"
        }


#endif

-- method Gutter::reorder
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceGutterRenderer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "renderer"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "GutterRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new renderer position."
--                 , 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_reorder" gtk_source_gutter_reorder :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Reorders /@renderer@/ in /@gutter@/ to new /@position@/.
-- 
-- /Since: 2.8/
gutterReorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) =>
    a
    -- ^ /@gutter@/: a t'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'.
    -> b
    -- ^ /@renderer@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'.
    -> Int32
    -- ^ /@position@/: the new renderer position.
    -> m ()
gutterReorder :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsGutter a, IsGutterRenderer b) =>
a -> b -> Int32 -> m ()
gutterReorder a
gutter b
renderer Int32
position = 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr GutterRenderer
renderer' <- b -> IO (Ptr GutterRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
renderer
    Ptr Gutter -> Ptr GutterRenderer -> Int32 -> IO ()
gtk_source_gutter_reorder Ptr Gutter
gutter' Ptr GutterRenderer
renderer' Int32
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
renderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterReorderMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.OverloadedMethod GutterReorderMethodInfo a signature where
    overloadedMethod = gutterReorder

instance O.OverloadedMethodInfo GutterReorderMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterReorder",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterReorder"
        }


#endif

-- method Gutter::set_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gutter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Gutter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 = Nothing , 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 = Nothing , 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_set_padding" gtk_source_gutter_set_padding :: 
    Ptr Gutter ->                           -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"})
    Int32 ->                                -- xpad : TBasicType TInt
    Int32 ->                                -- ypad : TBasicType TInt
    IO ()

{-# DEPRECATED gutterSetPadding ["(Since version 3.12)","Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererSetPadding' instead."] #-}
-- | /No description available in the introspection data./
gutterSetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsGutter a) =>
    a
    -> Int32
    -> Int32
    -> m ()
gutterSetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGutter a) =>
a -> Int32 -> Int32 -> m ()
gutterSetPadding a
gutter 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 Gutter
gutter' <- a -> IO (Ptr Gutter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gutter
    Ptr Gutter -> Int32 -> Int32 -> IO ()
gtk_source_gutter_set_padding Ptr Gutter
gutter' Int32
xpad Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gutter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GutterSetPaddingMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutter a) => O.OverloadedMethod GutterSetPaddingMethodInfo a signature where
    overloadedMethod = gutterSetPadding

instance O.OverloadedMethodInfo GutterSetPaddingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GtkSource.Objects.Gutter.gutterSetPadding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.24/docs/GI-GtkSource-Objects-Gutter.html#v:gutterSetPadding"
        }


#endif