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

-- * Exported types
    Buffer(..)                              ,
    IsBuffer                                ,
    toBuffer                                ,
    noBuffer                                ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveBufferMethod                     ,
#endif


-- ** backwardIterToSourceMark #method:backwardIterToSourceMark#

#if defined(ENABLE_OVERLOADING)
    BufferBackwardIterToSourceMarkMethodInfo,
#endif
    bufferBackwardIterToSourceMark          ,


-- ** beginNotUndoableAction #method:beginNotUndoableAction#

#if defined(ENABLE_OVERLOADING)
    BufferBeginNotUndoableActionMethodInfo  ,
#endif
    bufferBeginNotUndoableAction            ,


-- ** canRedo #method:canRedo#

#if defined(ENABLE_OVERLOADING)
    BufferCanRedoMethodInfo                 ,
#endif
    bufferCanRedo                           ,


-- ** canUndo #method:canUndo#

#if defined(ENABLE_OVERLOADING)
    BufferCanUndoMethodInfo                 ,
#endif
    bufferCanUndo                           ,


-- ** changeCase #method:changeCase#

#if defined(ENABLE_OVERLOADING)
    BufferChangeCaseMethodInfo              ,
#endif
    bufferChangeCase                        ,


-- ** createSourceMark #method:createSourceMark#

#if defined(ENABLE_OVERLOADING)
    BufferCreateSourceMarkMethodInfo        ,
#endif
    bufferCreateSourceMark                  ,


-- ** endNotUndoableAction #method:endNotUndoableAction#

#if defined(ENABLE_OVERLOADING)
    BufferEndNotUndoableActionMethodInfo    ,
#endif
    bufferEndNotUndoableAction              ,


-- ** ensureHighlight #method:ensureHighlight#

#if defined(ENABLE_OVERLOADING)
    BufferEnsureHighlightMethodInfo         ,
#endif
    bufferEnsureHighlight                   ,


-- ** forwardIterToSourceMark #method:forwardIterToSourceMark#

#if defined(ENABLE_OVERLOADING)
    BufferForwardIterToSourceMarkMethodInfo ,
#endif
    bufferForwardIterToSourceMark           ,


-- ** getContextClassesAtIter #method:getContextClassesAtIter#

#if defined(ENABLE_OVERLOADING)
    BufferGetContextClassesAtIterMethodInfo ,
#endif
    bufferGetContextClassesAtIter           ,


-- ** getHighlightMatchingBrackets #method:getHighlightMatchingBrackets#

#if defined(ENABLE_OVERLOADING)
    BufferGetHighlightMatchingBracketsMethodInfo,
#endif
    bufferGetHighlightMatchingBrackets      ,


-- ** getHighlightSyntax #method:getHighlightSyntax#

#if defined(ENABLE_OVERLOADING)
    BufferGetHighlightSyntaxMethodInfo      ,
#endif
    bufferGetHighlightSyntax                ,


-- ** getImplicitTrailingNewline #method:getImplicitTrailingNewline#

#if defined(ENABLE_OVERLOADING)
    BufferGetImplicitTrailingNewlineMethodInfo,
#endif
    bufferGetImplicitTrailingNewline        ,


-- ** getLanguage #method:getLanguage#

#if defined(ENABLE_OVERLOADING)
    BufferGetLanguageMethodInfo             ,
#endif
    bufferGetLanguage                       ,


-- ** getMaxUndoLevels #method:getMaxUndoLevels#

#if defined(ENABLE_OVERLOADING)
    BufferGetMaxUndoLevelsMethodInfo        ,
#endif
    bufferGetMaxUndoLevels                  ,


-- ** getSourceMarksAtIter #method:getSourceMarksAtIter#

#if defined(ENABLE_OVERLOADING)
    BufferGetSourceMarksAtIterMethodInfo    ,
#endif
    bufferGetSourceMarksAtIter              ,


-- ** getSourceMarksAtLine #method:getSourceMarksAtLine#

#if defined(ENABLE_OVERLOADING)
    BufferGetSourceMarksAtLineMethodInfo    ,
#endif
    bufferGetSourceMarksAtLine              ,


-- ** getStyleScheme #method:getStyleScheme#

#if defined(ENABLE_OVERLOADING)
    BufferGetStyleSchemeMethodInfo          ,
#endif
    bufferGetStyleScheme                    ,


-- ** getUndoManager #method:getUndoManager#

#if defined(ENABLE_OVERLOADING)
    BufferGetUndoManagerMethodInfo          ,
#endif
    bufferGetUndoManager                    ,


-- ** iterBackwardToContextClassToggle #method:iterBackwardToContextClassToggle#

#if defined(ENABLE_OVERLOADING)
    BufferIterBackwardToContextClassToggleMethodInfo,
#endif
    bufferIterBackwardToContextClassToggle  ,


-- ** iterForwardToContextClassToggle #method:iterForwardToContextClassToggle#

#if defined(ENABLE_OVERLOADING)
    BufferIterForwardToContextClassToggleMethodInfo,
#endif
    bufferIterForwardToContextClassToggle   ,


-- ** iterHasContextClass #method:iterHasContextClass#

#if defined(ENABLE_OVERLOADING)
    BufferIterHasContextClassMethodInfo     ,
#endif
    bufferIterHasContextClass               ,


-- ** joinLines #method:joinLines#

#if defined(ENABLE_OVERLOADING)
    BufferJoinLinesMethodInfo               ,
#endif
    bufferJoinLines                         ,


-- ** new #method:new#

    bufferNew                               ,


-- ** newWithLanguage #method:newWithLanguage#

    bufferNewWithLanguage                   ,


-- ** redo #method:redo#

#if defined(ENABLE_OVERLOADING)
    BufferRedoMethodInfo                    ,
#endif
    bufferRedo                              ,


-- ** removeSourceMarks #method:removeSourceMarks#

#if defined(ENABLE_OVERLOADING)
    BufferRemoveSourceMarksMethodInfo       ,
#endif
    bufferRemoveSourceMarks                 ,


-- ** setHighlightMatchingBrackets #method:setHighlightMatchingBrackets#

#if defined(ENABLE_OVERLOADING)
    BufferSetHighlightMatchingBracketsMethodInfo,
#endif
    bufferSetHighlightMatchingBrackets      ,


-- ** setHighlightSyntax #method:setHighlightSyntax#

#if defined(ENABLE_OVERLOADING)
    BufferSetHighlightSyntaxMethodInfo      ,
#endif
    bufferSetHighlightSyntax                ,


-- ** setImplicitTrailingNewline #method:setImplicitTrailingNewline#

#if defined(ENABLE_OVERLOADING)
    BufferSetImplicitTrailingNewlineMethodInfo,
#endif
    bufferSetImplicitTrailingNewline        ,


-- ** setLanguage #method:setLanguage#

#if defined(ENABLE_OVERLOADING)
    BufferSetLanguageMethodInfo             ,
#endif
    bufferSetLanguage                       ,


-- ** setMaxUndoLevels #method:setMaxUndoLevels#

#if defined(ENABLE_OVERLOADING)
    BufferSetMaxUndoLevelsMethodInfo        ,
#endif
    bufferSetMaxUndoLevels                  ,


-- ** setStyleScheme #method:setStyleScheme#

#if defined(ENABLE_OVERLOADING)
    BufferSetStyleSchemeMethodInfo          ,
#endif
    bufferSetStyleScheme                    ,


-- ** setUndoManager #method:setUndoManager#

#if defined(ENABLE_OVERLOADING)
    BufferSetUndoManagerMethodInfo          ,
#endif
    bufferSetUndoManager                    ,


-- ** sortLines #method:sortLines#

#if defined(ENABLE_OVERLOADING)
    BufferSortLinesMethodInfo               ,
#endif
    bufferSortLines                         ,


-- ** undo #method:undo#

#if defined(ENABLE_OVERLOADING)
    BufferUndoMethodInfo                    ,
#endif
    bufferUndo                              ,




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

#if defined(ENABLE_OVERLOADING)
    BufferCanRedoPropertyInfo               ,
#endif
    getBufferCanRedo                        ,


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

#if defined(ENABLE_OVERLOADING)
    BufferCanUndoPropertyInfo               ,
#endif
    getBufferCanUndo                        ,


-- ** highlightMatchingBrackets #attr:highlightMatchingBrackets#
-- | Whether to highlight matching brackets in the buffer.

#if defined(ENABLE_OVERLOADING)
    BufferHighlightMatchingBracketsPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferHighlightMatchingBrackets         ,
#endif
    constructBufferHighlightMatchingBrackets,
    getBufferHighlightMatchingBrackets      ,
    setBufferHighlightMatchingBrackets      ,


-- ** highlightSyntax #attr:highlightSyntax#
-- | Whether to highlight syntax in the buffer.

#if defined(ENABLE_OVERLOADING)
    BufferHighlightSyntaxPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferHighlightSyntax                   ,
#endif
    constructBufferHighlightSyntax          ,
    getBufferHighlightSyntax                ,
    setBufferHighlightSyntax                ,


-- ** implicitTrailingNewline #attr:implicitTrailingNewline#
-- | Whether the buffer has an implicit trailing newline. See
-- 'GI.GtkSource.Objects.Buffer.bufferSetImplicitTrailingNewline'.
-- 
-- /Since: 3.14/

#if defined(ENABLE_OVERLOADING)
    BufferImplicitTrailingNewlinePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferImplicitTrailingNewline           ,
#endif
    constructBufferImplicitTrailingNewline  ,
    getBufferImplicitTrailingNewline        ,
    setBufferImplicitTrailingNewline        ,


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

#if defined(ENABLE_OVERLOADING)
    BufferLanguagePropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferLanguage                          ,
#endif
    clearBufferLanguage                     ,
    constructBufferLanguage                 ,
    getBufferLanguage                       ,
    setBufferLanguage                       ,


-- ** maxUndoLevels #attr:maxUndoLevels#
-- | Number of undo levels for the buffer. -1 means no limit. This property
-- will only affect the default undo manager.

#if defined(ENABLE_OVERLOADING)
    BufferMaxUndoLevelsPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferMaxUndoLevels                     ,
#endif
    constructBufferMaxUndoLevels            ,
    getBufferMaxUndoLevels                  ,
    setBufferMaxUndoLevels                  ,


-- ** styleScheme #attr:styleScheme#
-- | Style scheme. It contains styles for syntax highlighting, optionally
-- foreground, background, cursor color, current line color, and matching
-- brackets style.

#if defined(ENABLE_OVERLOADING)
    BufferStyleSchemePropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferStyleScheme                       ,
#endif
    clearBufferStyleScheme                  ,
    constructBufferStyleScheme              ,
    getBufferStyleScheme                    ,
    setBufferStyleScheme                    ,


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

#if defined(ENABLE_OVERLOADING)
    BufferUndoManagerPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    bufferUndoManager                       ,
#endif
    clearBufferUndoManager                  ,
    constructBufferUndoManager              ,
    getBufferUndoManager                    ,
    setBufferUndoManager                    ,




 -- * Signals
-- ** bracketMatched #signal:bracketMatched#

    BufferBracketMatchedCallback            ,
#if defined(ENABLE_OVERLOADING)
    BufferBracketMatchedSignalInfo          ,
#endif
    C_BufferBracketMatchedCallback          ,
    afterBufferBracketMatched               ,
    genClosure_BufferBracketMatched         ,
    mk_BufferBracketMatchedCallback         ,
    noBufferBracketMatchedCallback          ,
    onBufferBracketMatched                  ,
    wrap_BufferBracketMatchedCallback       ,


-- ** highlightUpdated #signal:highlightUpdated#

    BufferHighlightUpdatedCallback          ,
#if defined(ENABLE_OVERLOADING)
    BufferHighlightUpdatedSignalInfo        ,
#endif
    C_BufferHighlightUpdatedCallback        ,
    afterBufferHighlightUpdated             ,
    genClosure_BufferHighlightUpdated       ,
    mk_BufferHighlightUpdatedCallback       ,
    noBufferHighlightUpdatedCallback        ,
    onBufferHighlightUpdated                ,
    wrap_BufferHighlightUpdatedCallback     ,


-- ** redo #signal:redo#

    BufferRedoCallback                      ,
#if defined(ENABLE_OVERLOADING)
    BufferRedoSignalInfo                    ,
#endif
    C_BufferRedoCallback                    ,
    afterBufferRedo                         ,
    genClosure_BufferRedo                   ,
    mk_BufferRedoCallback                   ,
    noBufferRedoCallback                    ,
    onBufferRedo                            ,
    wrap_BufferRedoCallback                 ,


-- ** sourceMarkUpdated #signal:sourceMarkUpdated#

    BufferSourceMarkUpdatedCallback         ,
#if defined(ENABLE_OVERLOADING)
    BufferSourceMarkUpdatedSignalInfo       ,
#endif
    C_BufferSourceMarkUpdatedCallback       ,
    afterBufferSourceMarkUpdated            ,
    genClosure_BufferSourceMarkUpdated      ,
    mk_BufferSourceMarkUpdatedCallback      ,
    noBufferSourceMarkUpdatedCallback       ,
    onBufferSourceMarkUpdated               ,
    wrap_BufferSourceMarkUpdatedCallback    ,


-- ** undo #signal:undo#

    BufferUndoCallback                      ,
#if defined(ENABLE_OVERLOADING)
    BufferUndoSignalInfo                    ,
#endif
    C_BufferUndoCallback                    ,
    afterBufferUndo                         ,
    genClosure_BufferUndo                   ,
    mk_BufferUndoCallback                   ,
    noBufferUndoCallback                    ,
    onBufferUndo                            ,
    wrap_BufferUndoCallback                 ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer
import qualified GI.Gtk.Objects.TextMark as Gtk.TextMark
import qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable
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
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.UndoManager as GtkSource.UndoManager
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Language as GtkSource.Language
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Mark as GtkSource.Mark
import {-# SOURCE #-} qualified GI.GtkSource.Objects.StyleScheme as GtkSource.StyleScheme

-- | Memory-managed wrapper type.
newtype Buffer = Buffer (ManagedPtr Buffer)
    deriving (Buffer -> Buffer -> Bool
(Buffer -> Buffer -> Bool)
-> (Buffer -> Buffer -> Bool) -> Eq Buffer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Buffer -> Buffer -> Bool
$c/= :: Buffer -> Buffer -> Bool
== :: Buffer -> Buffer -> Bool
$c== :: Buffer -> Buffer -> Bool
Eq)
foreign import ccall "gtk_source_buffer_get_type"
    c_gtk_source_buffer_get_type :: IO GType

instance GObject Buffer where
    gobjectType :: IO GType
gobjectType = IO GType
c_gtk_source_buffer_get_type
    

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

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

instance O.HasParentTypes Buffer
type instance O.ParentTypes Buffer = '[Gtk.TextBuffer.TextBuffer, GObject.Object.Object]

-- | Cast to `Buffer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toBuffer :: (MonadIO m, IsBuffer o) => o -> m Buffer
toBuffer :: o -> m Buffer
toBuffer = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> (o -> IO Buffer) -> o -> m Buffer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Buffer -> Buffer) -> o -> IO Buffer
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Buffer -> Buffer
Buffer

-- | A convenience alias for `Nothing` :: `Maybe` `Buffer`.
noBuffer :: Maybe Buffer
noBuffer :: Maybe Buffer
noBuffer = Maybe Buffer
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where
    ResolveBufferMethod "addMark" o = Gtk.TextBuffer.TextBufferAddMarkMethodInfo
    ResolveBufferMethod "addSelectionClipboard" o = Gtk.TextBuffer.TextBufferAddSelectionClipboardMethodInfo
    ResolveBufferMethod "applyTag" o = Gtk.TextBuffer.TextBufferApplyTagMethodInfo
    ResolveBufferMethod "applyTagByName" o = Gtk.TextBuffer.TextBufferApplyTagByNameMethodInfo
    ResolveBufferMethod "backspace" o = Gtk.TextBuffer.TextBufferBackspaceMethodInfo
    ResolveBufferMethod "backwardIterToSourceMark" o = BufferBackwardIterToSourceMarkMethodInfo
    ResolveBufferMethod "beginNotUndoableAction" o = BufferBeginNotUndoableActionMethodInfo
    ResolveBufferMethod "beginUserAction" o = Gtk.TextBuffer.TextBufferBeginUserActionMethodInfo
    ResolveBufferMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBufferMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBufferMethod "canRedo" o = BufferCanRedoMethodInfo
    ResolveBufferMethod "canUndo" o = BufferCanUndoMethodInfo
    ResolveBufferMethod "changeCase" o = BufferChangeCaseMethodInfo
    ResolveBufferMethod "copyClipboard" o = Gtk.TextBuffer.TextBufferCopyClipboardMethodInfo
    ResolveBufferMethod "createChildAnchor" o = Gtk.TextBuffer.TextBufferCreateChildAnchorMethodInfo
    ResolveBufferMethod "createMark" o = Gtk.TextBuffer.TextBufferCreateMarkMethodInfo
    ResolveBufferMethod "createSourceMark" o = BufferCreateSourceMarkMethodInfo
    ResolveBufferMethod "cutClipboard" o = Gtk.TextBuffer.TextBufferCutClipboardMethodInfo
    ResolveBufferMethod "delete" o = Gtk.TextBuffer.TextBufferDeleteMethodInfo
    ResolveBufferMethod "deleteInteractive" o = Gtk.TextBuffer.TextBufferDeleteInteractiveMethodInfo
    ResolveBufferMethod "deleteMark" o = Gtk.TextBuffer.TextBufferDeleteMarkMethodInfo
    ResolveBufferMethod "deleteMarkByName" o = Gtk.TextBuffer.TextBufferDeleteMarkByNameMethodInfo
    ResolveBufferMethod "deleteSelection" o = Gtk.TextBuffer.TextBufferDeleteSelectionMethodInfo
    ResolveBufferMethod "deserialize" o = Gtk.TextBuffer.TextBufferDeserializeMethodInfo
    ResolveBufferMethod "deserializeGetCanCreateTags" o = Gtk.TextBuffer.TextBufferDeserializeGetCanCreateTagsMethodInfo
    ResolveBufferMethod "deserializeSetCanCreateTags" o = Gtk.TextBuffer.TextBufferDeserializeSetCanCreateTagsMethodInfo
    ResolveBufferMethod "endNotUndoableAction" o = BufferEndNotUndoableActionMethodInfo
    ResolveBufferMethod "endUserAction" o = Gtk.TextBuffer.TextBufferEndUserActionMethodInfo
    ResolveBufferMethod "ensureHighlight" o = BufferEnsureHighlightMethodInfo
    ResolveBufferMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBufferMethod "forwardIterToSourceMark" o = BufferForwardIterToSourceMarkMethodInfo
    ResolveBufferMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBufferMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBufferMethod "insert" o = Gtk.TextBuffer.TextBufferInsertMethodInfo
    ResolveBufferMethod "insertAtCursor" o = Gtk.TextBuffer.TextBufferInsertAtCursorMethodInfo
    ResolveBufferMethod "insertChildAnchor" o = Gtk.TextBuffer.TextBufferInsertChildAnchorMethodInfo
    ResolveBufferMethod "insertInteractive" o = Gtk.TextBuffer.TextBufferInsertInteractiveMethodInfo
    ResolveBufferMethod "insertInteractiveAtCursor" o = Gtk.TextBuffer.TextBufferInsertInteractiveAtCursorMethodInfo
    ResolveBufferMethod "insertMarkup" o = Gtk.TextBuffer.TextBufferInsertMarkupMethodInfo
    ResolveBufferMethod "insertPixbuf" o = Gtk.TextBuffer.TextBufferInsertPixbufMethodInfo
    ResolveBufferMethod "insertRange" o = Gtk.TextBuffer.TextBufferInsertRangeMethodInfo
    ResolveBufferMethod "insertRangeInteractive" o = Gtk.TextBuffer.TextBufferInsertRangeInteractiveMethodInfo
    ResolveBufferMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBufferMethod "iterBackwardToContextClassToggle" o = BufferIterBackwardToContextClassToggleMethodInfo
    ResolveBufferMethod "iterForwardToContextClassToggle" o = BufferIterForwardToContextClassToggleMethodInfo
    ResolveBufferMethod "iterHasContextClass" o = BufferIterHasContextClassMethodInfo
    ResolveBufferMethod "joinLines" o = BufferJoinLinesMethodInfo
    ResolveBufferMethod "moveMark" o = Gtk.TextBuffer.TextBufferMoveMarkMethodInfo
    ResolveBufferMethod "moveMarkByName" o = Gtk.TextBuffer.TextBufferMoveMarkByNameMethodInfo
    ResolveBufferMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBufferMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBufferMethod "pasteClipboard" o = Gtk.TextBuffer.TextBufferPasteClipboardMethodInfo
    ResolveBufferMethod "placeCursor" o = Gtk.TextBuffer.TextBufferPlaceCursorMethodInfo
    ResolveBufferMethod "redo" o = BufferRedoMethodInfo
    ResolveBufferMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBufferMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBufferMethod "registerDeserializeFormat" o = Gtk.TextBuffer.TextBufferRegisterDeserializeFormatMethodInfo
    ResolveBufferMethod "registerDeserializeTagset" o = Gtk.TextBuffer.TextBufferRegisterDeserializeTagsetMethodInfo
    ResolveBufferMethod "registerSerializeFormat" o = Gtk.TextBuffer.TextBufferRegisterSerializeFormatMethodInfo
    ResolveBufferMethod "registerSerializeTagset" o = Gtk.TextBuffer.TextBufferRegisterSerializeTagsetMethodInfo
    ResolveBufferMethod "removeAllTags" o = Gtk.TextBuffer.TextBufferRemoveAllTagsMethodInfo
    ResolveBufferMethod "removeSelectionClipboard" o = Gtk.TextBuffer.TextBufferRemoveSelectionClipboardMethodInfo
    ResolveBufferMethod "removeSourceMarks" o = BufferRemoveSourceMarksMethodInfo
    ResolveBufferMethod "removeTag" o = Gtk.TextBuffer.TextBufferRemoveTagMethodInfo
    ResolveBufferMethod "removeTagByName" o = Gtk.TextBuffer.TextBufferRemoveTagByNameMethodInfo
    ResolveBufferMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBufferMethod "selectRange" o = Gtk.TextBuffer.TextBufferSelectRangeMethodInfo
    ResolveBufferMethod "serialize" o = Gtk.TextBuffer.TextBufferSerializeMethodInfo
    ResolveBufferMethod "sortLines" o = BufferSortLinesMethodInfo
    ResolveBufferMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBufferMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBufferMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBufferMethod "undo" o = BufferUndoMethodInfo
    ResolveBufferMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBufferMethod "unregisterDeserializeFormat" o = Gtk.TextBuffer.TextBufferUnregisterDeserializeFormatMethodInfo
    ResolveBufferMethod "unregisterSerializeFormat" o = Gtk.TextBuffer.TextBufferUnregisterSerializeFormatMethodInfo
    ResolveBufferMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBufferMethod "getBounds" o = Gtk.TextBuffer.TextBufferGetBoundsMethodInfo
    ResolveBufferMethod "getCharCount" o = Gtk.TextBuffer.TextBufferGetCharCountMethodInfo
    ResolveBufferMethod "getContextClassesAtIter" o = BufferGetContextClassesAtIterMethodInfo
    ResolveBufferMethod "getCopyTargetList" o = Gtk.TextBuffer.TextBufferGetCopyTargetListMethodInfo
    ResolveBufferMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBufferMethod "getDeserializeFormats" o = Gtk.TextBuffer.TextBufferGetDeserializeFormatsMethodInfo
    ResolveBufferMethod "getEndIter" o = Gtk.TextBuffer.TextBufferGetEndIterMethodInfo
    ResolveBufferMethod "getHasSelection" o = Gtk.TextBuffer.TextBufferGetHasSelectionMethodInfo
    ResolveBufferMethod "getHighlightMatchingBrackets" o = BufferGetHighlightMatchingBracketsMethodInfo
    ResolveBufferMethod "getHighlightSyntax" o = BufferGetHighlightSyntaxMethodInfo
    ResolveBufferMethod "getImplicitTrailingNewline" o = BufferGetImplicitTrailingNewlineMethodInfo
    ResolveBufferMethod "getInsert" o = Gtk.TextBuffer.TextBufferGetInsertMethodInfo
    ResolveBufferMethod "getIterAtChildAnchor" o = Gtk.TextBuffer.TextBufferGetIterAtChildAnchorMethodInfo
    ResolveBufferMethod "getIterAtLine" o = Gtk.TextBuffer.TextBufferGetIterAtLineMethodInfo
    ResolveBufferMethod "getIterAtLineIndex" o = Gtk.TextBuffer.TextBufferGetIterAtLineIndexMethodInfo
    ResolveBufferMethod "getIterAtLineOffset" o = Gtk.TextBuffer.TextBufferGetIterAtLineOffsetMethodInfo
    ResolveBufferMethod "getIterAtMark" o = Gtk.TextBuffer.TextBufferGetIterAtMarkMethodInfo
    ResolveBufferMethod "getIterAtOffset" o = Gtk.TextBuffer.TextBufferGetIterAtOffsetMethodInfo
    ResolveBufferMethod "getLanguage" o = BufferGetLanguageMethodInfo
    ResolveBufferMethod "getLineCount" o = Gtk.TextBuffer.TextBufferGetLineCountMethodInfo
    ResolveBufferMethod "getMark" o = Gtk.TextBuffer.TextBufferGetMarkMethodInfo
    ResolveBufferMethod "getMaxUndoLevels" o = BufferGetMaxUndoLevelsMethodInfo
    ResolveBufferMethod "getModified" o = Gtk.TextBuffer.TextBufferGetModifiedMethodInfo
    ResolveBufferMethod "getPasteTargetList" o = Gtk.TextBuffer.TextBufferGetPasteTargetListMethodInfo
    ResolveBufferMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBufferMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBufferMethod "getSelectionBound" o = Gtk.TextBuffer.TextBufferGetSelectionBoundMethodInfo
    ResolveBufferMethod "getSelectionBounds" o = Gtk.TextBuffer.TextBufferGetSelectionBoundsMethodInfo
    ResolveBufferMethod "getSerializeFormats" o = Gtk.TextBuffer.TextBufferGetSerializeFormatsMethodInfo
    ResolveBufferMethod "getSlice" o = Gtk.TextBuffer.TextBufferGetSliceMethodInfo
    ResolveBufferMethod "getSourceMarksAtIter" o = BufferGetSourceMarksAtIterMethodInfo
    ResolveBufferMethod "getSourceMarksAtLine" o = BufferGetSourceMarksAtLineMethodInfo
    ResolveBufferMethod "getStartIter" o = Gtk.TextBuffer.TextBufferGetStartIterMethodInfo
    ResolveBufferMethod "getStyleScheme" o = BufferGetStyleSchemeMethodInfo
    ResolveBufferMethod "getTagTable" o = Gtk.TextBuffer.TextBufferGetTagTableMethodInfo
    ResolveBufferMethod "getText" o = Gtk.TextBuffer.TextBufferGetTextMethodInfo
    ResolveBufferMethod "getUndoManager" o = BufferGetUndoManagerMethodInfo
    ResolveBufferMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBufferMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveBufferMethod "setHighlightMatchingBrackets" o = BufferSetHighlightMatchingBracketsMethodInfo
    ResolveBufferMethod "setHighlightSyntax" o = BufferSetHighlightSyntaxMethodInfo
    ResolveBufferMethod "setImplicitTrailingNewline" o = BufferSetImplicitTrailingNewlineMethodInfo
    ResolveBufferMethod "setLanguage" o = BufferSetLanguageMethodInfo
    ResolveBufferMethod "setMaxUndoLevels" o = BufferSetMaxUndoLevelsMethodInfo
    ResolveBufferMethod "setModified" o = Gtk.TextBuffer.TextBufferSetModifiedMethodInfo
    ResolveBufferMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBufferMethod "setStyleScheme" o = BufferSetStyleSchemeMethodInfo
    ResolveBufferMethod "setText" o = Gtk.TextBuffer.TextBufferSetTextMethodInfo
    ResolveBufferMethod "setUndoManager" o = BufferSetUndoManagerMethodInfo
    ResolveBufferMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Buffer::bracket-matched
-- | /@iter@/ is set to a valid iterator pointing to the matching bracket
-- if /@state@/ is 'GI.GtkSource.Enums.BracketMatchTypeFound'. Otherwise /@iter@/ is
-- meaningless.
-- 
-- The signal is emitted only when the /@state@/ changes, typically when
-- the cursor moves.
-- 
-- A use-case for this signal is to show messages in a t'GI.Gtk.Objects.Statusbar.Statusbar'.
-- 
-- /Since: 2.12/
type BufferBracketMatchedCallback =
    Maybe Gtk.TextIter.TextIter
    -- ^ /@iter@/: if found, the location of the matching bracket.
    -> GtkSource.Enums.BracketMatchType
    -- ^ /@state@/: state of bracket matching.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferBracketMatchedCallback`@.
noBufferBracketMatchedCallback :: Maybe BufferBracketMatchedCallback
noBufferBracketMatchedCallback :: Maybe BufferBracketMatchedCallback
noBufferBracketMatchedCallback = Maybe BufferBracketMatchedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_BufferBracketMatched :: MonadIO m => BufferBracketMatchedCallback -> m (GClosure C_BufferBracketMatchedCallback)
genClosure_BufferBracketMatched :: BufferBracketMatchedCallback
-> m (GClosure C_BufferBracketMatchedCallback)
genClosure_BufferBracketMatched cb :: BufferBracketMatchedCallback
cb = IO (GClosure C_BufferBracketMatchedCallback)
-> m (GClosure C_BufferBracketMatchedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BufferBracketMatchedCallback)
 -> m (GClosure C_BufferBracketMatchedCallback))
-> IO (GClosure C_BufferBracketMatchedCallback)
-> m (GClosure C_BufferBracketMatchedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BufferBracketMatchedCallback
cb' = BufferBracketMatchedCallback -> C_BufferBracketMatchedCallback
wrap_BufferBracketMatchedCallback BufferBracketMatchedCallback
cb
    C_BufferBracketMatchedCallback
-> IO (FunPtr C_BufferBracketMatchedCallback)
mk_BufferBracketMatchedCallback C_BufferBracketMatchedCallback
cb' IO (FunPtr C_BufferBracketMatchedCallback)
-> (FunPtr C_BufferBracketMatchedCallback
    -> IO (GClosure C_BufferBracketMatchedCallback))
-> IO (GClosure C_BufferBracketMatchedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BufferBracketMatchedCallback
-> IO (GClosure C_BufferBracketMatchedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BufferBracketMatchedCallback` into a `C_BufferBracketMatchedCallback`.
wrap_BufferBracketMatchedCallback ::
    BufferBracketMatchedCallback ->
    C_BufferBracketMatchedCallback
wrap_BufferBracketMatchedCallback :: BufferBracketMatchedCallback -> C_BufferBracketMatchedCallback
wrap_BufferBracketMatchedCallback _cb :: BufferBracketMatchedCallback
_cb _ iter :: Ptr TextIter
iter state :: CUInt
state _ = do
    Maybe TextIter
maybeIter <-
        if Ptr TextIter
iter Ptr TextIter -> Ptr TextIter -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr TextIter
forall a. Ptr a
nullPtr
        then Maybe TextIter -> IO (Maybe TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TextIter
forall a. Maybe a
Nothing
        else do
            (ManagedPtr TextIter -> TextIter)
-> Ptr TextIter
-> (TextIter -> IO (Maybe TextIter))
-> IO (Maybe TextIter)
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 (Maybe TextIter)) -> IO (Maybe TextIter))
-> (TextIter -> IO (Maybe TextIter)) -> IO (Maybe TextIter)
forall a b. (a -> b) -> a -> b
$ \iter' :: TextIter
iter' -> do
                Maybe TextIter -> IO (Maybe TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TextIter -> IO (Maybe TextIter))
-> Maybe TextIter -> IO (Maybe TextIter)
forall a b. (a -> b) -> a -> b
$ TextIter -> Maybe TextIter
forall a. a -> Maybe a
Just TextIter
iter'
    let state' :: BracketMatchType
state' = (Int -> BracketMatchType
forall a. Enum a => Int -> a
toEnum (Int -> BracketMatchType)
-> (CUInt -> Int) -> CUInt -> BracketMatchType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
state
    BufferBracketMatchedCallback
_cb  Maybe TextIter
maybeIter BracketMatchType
state'


-- | Connect a signal handler for the [bracketMatched](#signal:bracketMatched) 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' buffer #bracketMatched callback
-- @
-- 
-- 
onBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId
onBufferBracketMatched :: a -> BufferBracketMatchedCallback -> m SignalHandlerId
onBufferBracketMatched obj :: a
obj cb :: BufferBracketMatchedCallback
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_BufferBracketMatchedCallback
cb' = BufferBracketMatchedCallback -> C_BufferBracketMatchedCallback
wrap_BufferBracketMatchedCallback BufferBracketMatchedCallback
cb
    FunPtr C_BufferBracketMatchedCallback
cb'' <- C_BufferBracketMatchedCallback
-> IO (FunPtr C_BufferBracketMatchedCallback)
mk_BufferBracketMatchedCallback C_BufferBracketMatchedCallback
cb'
    a
-> Text
-> FunPtr C_BufferBracketMatchedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bracket-matched" FunPtr C_BufferBracketMatchedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [bracketMatched](#signal:bracketMatched) 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' buffer #bracketMatched callback
-- @
-- 
-- 
afterBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId
afterBufferBracketMatched :: a -> BufferBracketMatchedCallback -> m SignalHandlerId
afterBufferBracketMatched obj :: a
obj cb :: BufferBracketMatchedCallback
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_BufferBracketMatchedCallback
cb' = BufferBracketMatchedCallback -> C_BufferBracketMatchedCallback
wrap_BufferBracketMatchedCallback BufferBracketMatchedCallback
cb
    FunPtr C_BufferBracketMatchedCallback
cb'' <- C_BufferBracketMatchedCallback
-> IO (FunPtr C_BufferBracketMatchedCallback)
mk_BufferBracketMatchedCallback C_BufferBracketMatchedCallback
cb'
    a
-> Text
-> FunPtr C_BufferBracketMatchedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "bracket-matched" FunPtr C_BufferBracketMatchedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BufferBracketMatchedSignalInfo
instance SignalInfo BufferBracketMatchedSignalInfo where
    type HaskellCallbackType BufferBracketMatchedSignalInfo = BufferBracketMatchedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BufferBracketMatchedCallback cb
        cb'' <- mk_BufferBracketMatchedCallback cb'
        connectSignalFunPtr obj "bracket-matched" cb'' connectMode detail

#endif

-- signal Buffer::highlight-updated
-- | The [highlightUpdated](#signal:highlightUpdated) signal is emitted when the syntax
-- highlighting and [context classes][context-classes] are updated in a
-- certain region of the /@buffer@/.
type BufferHighlightUpdatedCallback =
    Gtk.TextIter.TextIter
    -- ^ /@start@/: the start of the updated region
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: the end of the updated region
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferHighlightUpdatedCallback`@.
noBufferHighlightUpdatedCallback :: Maybe BufferHighlightUpdatedCallback
noBufferHighlightUpdatedCallback :: Maybe BufferHighlightUpdatedCallback
noBufferHighlightUpdatedCallback = Maybe BufferHighlightUpdatedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_BufferHighlightUpdated :: MonadIO m => BufferHighlightUpdatedCallback -> m (GClosure C_BufferHighlightUpdatedCallback)
genClosure_BufferHighlightUpdated :: BufferHighlightUpdatedCallback
-> m (GClosure C_BufferHighlightUpdatedCallback)
genClosure_BufferHighlightUpdated cb :: BufferHighlightUpdatedCallback
cb = IO (GClosure C_BufferHighlightUpdatedCallback)
-> m (GClosure C_BufferHighlightUpdatedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BufferHighlightUpdatedCallback)
 -> m (GClosure C_BufferHighlightUpdatedCallback))
-> IO (GClosure C_BufferHighlightUpdatedCallback)
-> m (GClosure C_BufferHighlightUpdatedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BufferHighlightUpdatedCallback
cb' = BufferHighlightUpdatedCallback -> C_BufferHighlightUpdatedCallback
wrap_BufferHighlightUpdatedCallback BufferHighlightUpdatedCallback
cb
    C_BufferHighlightUpdatedCallback
-> IO (FunPtr C_BufferHighlightUpdatedCallback)
mk_BufferHighlightUpdatedCallback C_BufferHighlightUpdatedCallback
cb' IO (FunPtr C_BufferHighlightUpdatedCallback)
-> (FunPtr C_BufferHighlightUpdatedCallback
    -> IO (GClosure C_BufferHighlightUpdatedCallback))
-> IO (GClosure C_BufferHighlightUpdatedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BufferHighlightUpdatedCallback
-> IO (GClosure C_BufferHighlightUpdatedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BufferHighlightUpdatedCallback` into a `C_BufferHighlightUpdatedCallback`.
wrap_BufferHighlightUpdatedCallback ::
    BufferHighlightUpdatedCallback ->
    C_BufferHighlightUpdatedCallback
wrap_BufferHighlightUpdatedCallback :: BufferHighlightUpdatedCallback -> C_BufferHighlightUpdatedCallback
wrap_BufferHighlightUpdatedCallback _cb :: BufferHighlightUpdatedCallback
_cb _ start :: Ptr TextIter
start end :: Ptr TextIter
end _ = 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
$ \start' :: 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
$ \end' :: TextIter
end' -> do
            BufferHighlightUpdatedCallback
_cb  TextIter
start' TextIter
end'


-- | Connect a signal handler for the [highlightUpdated](#signal:highlightUpdated) 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' buffer #highlightUpdated callback
-- @
-- 
-- 
onBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId
onBufferHighlightUpdated :: a -> BufferHighlightUpdatedCallback -> m SignalHandlerId
onBufferHighlightUpdated obj :: a
obj cb :: BufferHighlightUpdatedCallback
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_BufferHighlightUpdatedCallback
cb' = BufferHighlightUpdatedCallback -> C_BufferHighlightUpdatedCallback
wrap_BufferHighlightUpdatedCallback BufferHighlightUpdatedCallback
cb
    FunPtr C_BufferHighlightUpdatedCallback
cb'' <- C_BufferHighlightUpdatedCallback
-> IO (FunPtr C_BufferHighlightUpdatedCallback)
mk_BufferHighlightUpdatedCallback C_BufferHighlightUpdatedCallback
cb'
    a
-> Text
-> FunPtr C_BufferHighlightUpdatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "highlight-updated" FunPtr C_BufferHighlightUpdatedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [highlightUpdated](#signal:highlightUpdated) 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' buffer #highlightUpdated callback
-- @
-- 
-- 
afterBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId
afterBufferHighlightUpdated :: a -> BufferHighlightUpdatedCallback -> m SignalHandlerId
afterBufferHighlightUpdated obj :: a
obj cb :: BufferHighlightUpdatedCallback
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_BufferHighlightUpdatedCallback
cb' = BufferHighlightUpdatedCallback -> C_BufferHighlightUpdatedCallback
wrap_BufferHighlightUpdatedCallback BufferHighlightUpdatedCallback
cb
    FunPtr C_BufferHighlightUpdatedCallback
cb'' <- C_BufferHighlightUpdatedCallback
-> IO (FunPtr C_BufferHighlightUpdatedCallback)
mk_BufferHighlightUpdatedCallback C_BufferHighlightUpdatedCallback
cb'
    a
-> Text
-> FunPtr C_BufferHighlightUpdatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "highlight-updated" FunPtr C_BufferHighlightUpdatedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BufferHighlightUpdatedSignalInfo
instance SignalInfo BufferHighlightUpdatedSignalInfo where
    type HaskellCallbackType BufferHighlightUpdatedSignalInfo = BufferHighlightUpdatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BufferHighlightUpdatedCallback cb
        cb'' <- mk_BufferHighlightUpdatedCallback cb'
        connectSignalFunPtr obj "highlight-updated" cb'' connectMode detail

#endif

-- signal Buffer::redo
-- | The [redo](#signal:redo) signal is emitted to redo the last undo operation.
type BufferRedoCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferRedoCallback`@.
noBufferRedoCallback :: Maybe BufferRedoCallback
noBufferRedoCallback :: Maybe (IO ())
noBufferRedoCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_BufferRedo :: MonadIO m => BufferRedoCallback -> m (GClosure C_BufferRedoCallback)
genClosure_BufferRedo :: IO () -> m (GClosure C_BufferRedoCallback)
genClosure_BufferRedo cb :: IO ()
cb = IO (GClosure C_BufferRedoCallback)
-> m (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BufferRedoCallback)
 -> m (GClosure C_BufferRedoCallback))
-> IO (GClosure C_BufferRedoCallback)
-> m (GClosure C_BufferRedoCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferRedoCallback IO ()
cb
    C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferRedoCallback C_BufferRedoCallback
cb' IO (FunPtr C_BufferRedoCallback)
-> (FunPtr C_BufferRedoCallback
    -> IO (GClosure C_BufferRedoCallback))
-> IO (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BufferRedoCallback -> IO (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BufferRedoCallback` into a `C_BufferRedoCallback`.
wrap_BufferRedoCallback ::
    BufferRedoCallback ->
    C_BufferRedoCallback
wrap_BufferRedoCallback :: IO () -> C_BufferRedoCallback
wrap_BufferRedoCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [redo](#signal:redo) 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' buffer #redo callback
-- @
-- 
-- 
onBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId
onBufferRedo :: a -> IO () -> m SignalHandlerId
onBufferRedo obj :: a
obj cb :: 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_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferRedoCallback IO ()
cb
    FunPtr C_BufferRedoCallback
cb'' <- C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferRedoCallback C_BufferRedoCallback
cb'
    a
-> Text
-> FunPtr C_BufferRedoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "redo" FunPtr C_BufferRedoCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [redo](#signal:redo) 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' buffer #redo callback
-- @
-- 
-- 
afterBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId
afterBufferRedo :: a -> IO () -> m SignalHandlerId
afterBufferRedo obj :: a
obj cb :: 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_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferRedoCallback IO ()
cb
    FunPtr C_BufferRedoCallback
cb'' <- C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferRedoCallback C_BufferRedoCallback
cb'
    a
-> Text
-> FunPtr C_BufferRedoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "redo" FunPtr C_BufferRedoCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BufferRedoSignalInfo
instance SignalInfo BufferRedoSignalInfo where
    type HaskellCallbackType BufferRedoSignalInfo = BufferRedoCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BufferRedoCallback cb
        cb'' <- mk_BufferRedoCallback cb'
        connectSignalFunPtr obj "redo" cb'' connectMode detail

#endif

-- signal Buffer::source-mark-updated
-- | The [sourceMarkUpdated](#signal:sourceMarkUpdated) signal is emitted each time
-- a mark is added to, moved or removed from the /@buffer@/.
type BufferSourceMarkUpdatedCallback =
    Gtk.TextMark.TextMark
    -- ^ /@mark@/: the t'GI.GtkSource.Objects.Mark.Mark'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferSourceMarkUpdatedCallback`@.
noBufferSourceMarkUpdatedCallback :: Maybe BufferSourceMarkUpdatedCallback
noBufferSourceMarkUpdatedCallback :: Maybe BufferSourceMarkUpdatedCallback
noBufferSourceMarkUpdatedCallback = Maybe BufferSourceMarkUpdatedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_BufferSourceMarkUpdated :: MonadIO m => BufferSourceMarkUpdatedCallback -> m (GClosure C_BufferSourceMarkUpdatedCallback)
genClosure_BufferSourceMarkUpdated :: BufferSourceMarkUpdatedCallback
-> m (GClosure C_BufferSourceMarkUpdatedCallback)
genClosure_BufferSourceMarkUpdated cb :: BufferSourceMarkUpdatedCallback
cb = IO (GClosure C_BufferSourceMarkUpdatedCallback)
-> m (GClosure C_BufferSourceMarkUpdatedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BufferSourceMarkUpdatedCallback)
 -> m (GClosure C_BufferSourceMarkUpdatedCallback))
-> IO (GClosure C_BufferSourceMarkUpdatedCallback)
-> m (GClosure C_BufferSourceMarkUpdatedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BufferSourceMarkUpdatedCallback
cb' = BufferSourceMarkUpdatedCallback
-> C_BufferSourceMarkUpdatedCallback
wrap_BufferSourceMarkUpdatedCallback BufferSourceMarkUpdatedCallback
cb
    C_BufferSourceMarkUpdatedCallback
-> IO (FunPtr C_BufferSourceMarkUpdatedCallback)
mk_BufferSourceMarkUpdatedCallback C_BufferSourceMarkUpdatedCallback
cb' IO (FunPtr C_BufferSourceMarkUpdatedCallback)
-> (FunPtr C_BufferSourceMarkUpdatedCallback
    -> IO (GClosure C_BufferSourceMarkUpdatedCallback))
-> IO (GClosure C_BufferSourceMarkUpdatedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BufferSourceMarkUpdatedCallback
-> IO (GClosure C_BufferSourceMarkUpdatedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BufferSourceMarkUpdatedCallback` into a `C_BufferSourceMarkUpdatedCallback`.
wrap_BufferSourceMarkUpdatedCallback ::
    BufferSourceMarkUpdatedCallback ->
    C_BufferSourceMarkUpdatedCallback
wrap_BufferSourceMarkUpdatedCallback :: BufferSourceMarkUpdatedCallback
-> C_BufferSourceMarkUpdatedCallback
wrap_BufferSourceMarkUpdatedCallback _cb :: BufferSourceMarkUpdatedCallback
_cb _ mark :: Ptr TextMark
mark _ = do
    TextMark
mark' <- ((ManagedPtr TextMark -> TextMark) -> Ptr TextMark -> IO TextMark
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextMark -> TextMark
Gtk.TextMark.TextMark) Ptr TextMark
mark
    BufferSourceMarkUpdatedCallback
_cb  TextMark
mark'


-- | Connect a signal handler for the [sourceMarkUpdated](#signal:sourceMarkUpdated) 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' buffer #sourceMarkUpdated callback
-- @
-- 
-- 
onBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId
onBufferSourceMarkUpdated :: a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId
onBufferSourceMarkUpdated obj :: a
obj cb :: BufferSourceMarkUpdatedCallback
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_BufferSourceMarkUpdatedCallback
cb' = BufferSourceMarkUpdatedCallback
-> C_BufferSourceMarkUpdatedCallback
wrap_BufferSourceMarkUpdatedCallback BufferSourceMarkUpdatedCallback
cb
    FunPtr C_BufferSourceMarkUpdatedCallback
cb'' <- C_BufferSourceMarkUpdatedCallback
-> IO (FunPtr C_BufferSourceMarkUpdatedCallback)
mk_BufferSourceMarkUpdatedCallback C_BufferSourceMarkUpdatedCallback
cb'
    a
-> Text
-> FunPtr C_BufferSourceMarkUpdatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "source-mark-updated" FunPtr C_BufferSourceMarkUpdatedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [sourceMarkUpdated](#signal:sourceMarkUpdated) 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' buffer #sourceMarkUpdated callback
-- @
-- 
-- 
afterBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId
afterBufferSourceMarkUpdated :: a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId
afterBufferSourceMarkUpdated obj :: a
obj cb :: BufferSourceMarkUpdatedCallback
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_BufferSourceMarkUpdatedCallback
cb' = BufferSourceMarkUpdatedCallback
-> C_BufferSourceMarkUpdatedCallback
wrap_BufferSourceMarkUpdatedCallback BufferSourceMarkUpdatedCallback
cb
    FunPtr C_BufferSourceMarkUpdatedCallback
cb'' <- C_BufferSourceMarkUpdatedCallback
-> IO (FunPtr C_BufferSourceMarkUpdatedCallback)
mk_BufferSourceMarkUpdatedCallback C_BufferSourceMarkUpdatedCallback
cb'
    a
-> Text
-> FunPtr C_BufferSourceMarkUpdatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "source-mark-updated" FunPtr C_BufferSourceMarkUpdatedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BufferSourceMarkUpdatedSignalInfo
instance SignalInfo BufferSourceMarkUpdatedSignalInfo where
    type HaskellCallbackType BufferSourceMarkUpdatedSignalInfo = BufferSourceMarkUpdatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BufferSourceMarkUpdatedCallback cb
        cb'' <- mk_BufferSourceMarkUpdatedCallback cb'
        connectSignalFunPtr obj "source-mark-updated" cb'' connectMode detail

#endif

-- signal Buffer::undo
-- | The [undo](#signal:undo) signal is emitted to undo the last user action which
-- modified the buffer.
type BufferUndoCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferUndoCallback`@.
noBufferUndoCallback :: Maybe BufferUndoCallback
noBufferUndoCallback :: Maybe (IO ())
noBufferUndoCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_BufferUndo :: MonadIO m => BufferUndoCallback -> m (GClosure C_BufferUndoCallback)
genClosure_BufferUndo :: IO () -> m (GClosure C_BufferRedoCallback)
genClosure_BufferUndo cb :: IO ()
cb = IO (GClosure C_BufferRedoCallback)
-> m (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BufferRedoCallback)
 -> m (GClosure C_BufferRedoCallback))
-> IO (GClosure C_BufferRedoCallback)
-> m (GClosure C_BufferRedoCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferUndoCallback IO ()
cb
    C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferUndoCallback C_BufferRedoCallback
cb' IO (FunPtr C_BufferRedoCallback)
-> (FunPtr C_BufferRedoCallback
    -> IO (GClosure C_BufferRedoCallback))
-> IO (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BufferRedoCallback -> IO (GClosure C_BufferRedoCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BufferUndoCallback` into a `C_BufferUndoCallback`.
wrap_BufferUndoCallback ::
    BufferUndoCallback ->
    C_BufferUndoCallback
wrap_BufferUndoCallback :: IO () -> C_BufferRedoCallback
wrap_BufferUndoCallback _cb :: IO ()
_cb _ _ = do
    IO ()
_cb 


-- | Connect a signal handler for the [undo](#signal:undo) 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' buffer #undo callback
-- @
-- 
-- 
onBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId
onBufferUndo :: a -> IO () -> m SignalHandlerId
onBufferUndo obj :: a
obj cb :: 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_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferUndoCallback IO ()
cb
    FunPtr C_BufferRedoCallback
cb'' <- C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferUndoCallback C_BufferRedoCallback
cb'
    a
-> Text
-> FunPtr C_BufferRedoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "undo" FunPtr C_BufferRedoCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [undo](#signal:undo) 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' buffer #undo callback
-- @
-- 
-- 
afterBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId
afterBufferUndo :: a -> IO () -> m SignalHandlerId
afterBufferUndo obj :: a
obj cb :: 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_BufferRedoCallback
cb' = IO () -> C_BufferRedoCallback
wrap_BufferUndoCallback IO ()
cb
    FunPtr C_BufferRedoCallback
cb'' <- C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback)
mk_BufferUndoCallback C_BufferRedoCallback
cb'
    a
-> Text
-> FunPtr C_BufferRedoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "undo" FunPtr C_BufferRedoCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BufferUndoSignalInfo
instance SignalInfo BufferUndoSignalInfo where
    type HaskellCallbackType BufferUndoSignalInfo = BufferUndoCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BufferUndoCallback cb
        cb'' <- mk_BufferUndoCallback cb'
        connectSignalFunPtr obj "undo" cb'' connectMode detail

#endif

-- VVV Prop "can-redo"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@can-redo@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #canRedo
-- @
getBufferCanRedo :: (MonadIO m, IsBuffer o) => o -> m Bool
getBufferCanRedo :: o -> m Bool
getBufferCanRedo obj :: 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 "can-redo"

#if defined(ENABLE_OVERLOADING)
data BufferCanRedoPropertyInfo
instance AttrInfo BufferCanRedoPropertyInfo where
    type AttrAllowedOps BufferCanRedoPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint BufferCanRedoPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferCanRedoPropertyInfo = (~) ()
    type AttrTransferTypeConstraint BufferCanRedoPropertyInfo = (~) ()
    type AttrTransferType BufferCanRedoPropertyInfo = ()
    type AttrGetType BufferCanRedoPropertyInfo = Bool
    type AttrLabel BufferCanRedoPropertyInfo = "can-redo"
    type AttrOrigin BufferCanRedoPropertyInfo = Buffer
    attrGet = getBufferCanRedo
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "can-undo"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@can-undo@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #canUndo
-- @
getBufferCanUndo :: (MonadIO m, IsBuffer o) => o -> m Bool
getBufferCanUndo :: o -> m Bool
getBufferCanUndo obj :: 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 "can-undo"

#if defined(ENABLE_OVERLOADING)
data BufferCanUndoPropertyInfo
instance AttrInfo BufferCanUndoPropertyInfo where
    type AttrAllowedOps BufferCanUndoPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint BufferCanUndoPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferCanUndoPropertyInfo = (~) ()
    type AttrTransferTypeConstraint BufferCanUndoPropertyInfo = (~) ()
    type AttrTransferType BufferCanUndoPropertyInfo = ()
    type AttrGetType BufferCanUndoPropertyInfo = Bool
    type AttrLabel BufferCanUndoPropertyInfo = "can-undo"
    type AttrOrigin BufferCanUndoPropertyInfo = Buffer
    attrGet = getBufferCanUndo
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

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

-- | Get the value of the “@highlight-matching-brackets@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #highlightMatchingBrackets
-- @
getBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> m Bool
getBufferHighlightMatchingBrackets :: o -> m Bool
getBufferHighlightMatchingBrackets obj :: 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 "highlight-matching-brackets"

-- | Set the value of the “@highlight-matching-brackets@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #highlightMatchingBrackets 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()
setBufferHighlightMatchingBrackets :: o -> Bool -> m ()
setBufferHighlightMatchingBrackets obj :: o
obj val :: 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 "highlight-matching-brackets" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@highlight-matching-brackets@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferHighlightMatchingBrackets :: (IsBuffer o) => Bool -> IO (GValueConstruct o)
constructBufferHighlightMatchingBrackets :: Bool -> IO (GValueConstruct o)
constructBufferHighlightMatchingBrackets val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "highlight-matching-brackets" Bool
val

#if defined(ENABLE_OVERLOADING)
data BufferHighlightMatchingBracketsPropertyInfo
instance AttrInfo BufferHighlightMatchingBracketsPropertyInfo where
    type AttrAllowedOps BufferHighlightMatchingBracketsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = (~) Bool
    type AttrTransferType BufferHighlightMatchingBracketsPropertyInfo = Bool
    type AttrGetType BufferHighlightMatchingBracketsPropertyInfo = Bool
    type AttrLabel BufferHighlightMatchingBracketsPropertyInfo = "highlight-matching-brackets"
    type AttrOrigin BufferHighlightMatchingBracketsPropertyInfo = Buffer
    attrGet = getBufferHighlightMatchingBrackets
    attrSet = setBufferHighlightMatchingBrackets
    attrTransfer _ v = do
        return v
    attrConstruct = constructBufferHighlightMatchingBrackets
    attrClear = undefined
#endif

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

-- | Get the value of the “@highlight-syntax@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #highlightSyntax
-- @
getBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> m Bool
getBufferHighlightSyntax :: o -> m Bool
getBufferHighlightSyntax obj :: 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 "highlight-syntax"

-- | Set the value of the “@highlight-syntax@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()
setBufferHighlightSyntax :: o -> Bool -> m ()
setBufferHighlightSyntax obj :: o
obj val :: 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 "highlight-syntax" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data BufferHighlightSyntaxPropertyInfo
instance AttrInfo BufferHighlightSyntaxPropertyInfo where
    type AttrAllowedOps BufferHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint BufferHighlightSyntaxPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferHighlightSyntaxPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint BufferHighlightSyntaxPropertyInfo = (~) Bool
    type AttrTransferType BufferHighlightSyntaxPropertyInfo = Bool
    type AttrGetType BufferHighlightSyntaxPropertyInfo = Bool
    type AttrLabel BufferHighlightSyntaxPropertyInfo = "highlight-syntax"
    type AttrOrigin BufferHighlightSyntaxPropertyInfo = Buffer
    attrGet = getBufferHighlightSyntax
    attrSet = setBufferHighlightSyntax
    attrTransfer _ v = do
        return v
    attrConstruct = constructBufferHighlightSyntax
    attrClear = undefined
#endif

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

-- | Get the value of the “@implicit-trailing-newline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #implicitTrailingNewline
-- @
getBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> m Bool
getBufferImplicitTrailingNewline :: o -> m Bool
getBufferImplicitTrailingNewline obj :: 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 "implicit-trailing-newline"

-- | Set the value of the “@implicit-trailing-newline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #implicitTrailingNewline 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()
setBufferImplicitTrailingNewline :: o -> Bool -> m ()
setBufferImplicitTrailingNewline obj :: o
obj val :: 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 "implicit-trailing-newline" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@implicit-trailing-newline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferImplicitTrailingNewline :: (IsBuffer o) => Bool -> IO (GValueConstruct o)
constructBufferImplicitTrailingNewline :: Bool -> IO (GValueConstruct o)
constructBufferImplicitTrailingNewline val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "implicit-trailing-newline" Bool
val

#if defined(ENABLE_OVERLOADING)
data BufferImplicitTrailingNewlinePropertyInfo
instance AttrInfo BufferImplicitTrailingNewlinePropertyInfo where
    type AttrAllowedOps BufferImplicitTrailingNewlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = (~) Bool
    type AttrTransferType BufferImplicitTrailingNewlinePropertyInfo = Bool
    type AttrGetType BufferImplicitTrailingNewlinePropertyInfo = Bool
    type AttrLabel BufferImplicitTrailingNewlinePropertyInfo = "implicit-trailing-newline"
    type AttrOrigin BufferImplicitTrailingNewlinePropertyInfo = Buffer
    attrGet = getBufferImplicitTrailingNewline
    attrSet = setBufferImplicitTrailingNewline
    attrTransfer _ v = do
        return v
    attrConstruct = constructBufferImplicitTrailingNewline
    attrClear = undefined
#endif

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

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

-- | Set the value of the “@language@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #language 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferLanguage :: (MonadIO m, IsBuffer o, GtkSource.Language.IsLanguage a) => o -> a -> m ()
setBufferLanguage :: o -> a -> m ()
setBufferLanguage obj :: o
obj val :: a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "language" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@language@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferLanguage :: (IsBuffer o, GtkSource.Language.IsLanguage a) => a -> IO (GValueConstruct o)
constructBufferLanguage :: a -> IO (GValueConstruct o)
constructBufferLanguage val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "language" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Set the value of the “@language@” 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' #language
-- @
clearBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m ()
clearBufferLanguage :: o -> m ()
clearBufferLanguage obj :: 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 Language -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "language" (Maybe Language
forall a. Maybe a
Nothing :: Maybe GtkSource.Language.Language)

#if defined(ENABLE_OVERLOADING)
data BufferLanguagePropertyInfo
instance AttrInfo BufferLanguagePropertyInfo where
    type AttrAllowedOps BufferLanguagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint BufferLanguagePropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferLanguagePropertyInfo = GtkSource.Language.IsLanguage
    type AttrTransferTypeConstraint BufferLanguagePropertyInfo = GtkSource.Language.IsLanguage
    type AttrTransferType BufferLanguagePropertyInfo = GtkSource.Language.Language
    type AttrGetType BufferLanguagePropertyInfo = (Maybe GtkSource.Language.Language)
    type AttrLabel BufferLanguagePropertyInfo = "language"
    type AttrOrigin BufferLanguagePropertyInfo = Buffer
    attrGet = getBufferLanguage
    attrSet = setBufferLanguage
    attrTransfer _ v = do
        unsafeCastTo GtkSource.Language.Language v
    attrConstruct = constructBufferLanguage
    attrClear = clearBufferLanguage
#endif

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

-- | Get the value of the “@max-undo-levels@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buffer #maxUndoLevels
-- @
getBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> m Int32
getBufferMaxUndoLevels :: o -> m Int32
getBufferMaxUndoLevels obj :: 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 "max-undo-levels"

-- | Set the value of the “@max-undo-levels@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #maxUndoLevels 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> Int32 -> m ()
setBufferMaxUndoLevels :: o -> Int32 -> m ()
setBufferMaxUndoLevels obj :: o
obj val :: 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 "max-undo-levels" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@max-undo-levels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferMaxUndoLevels :: (IsBuffer o) => Int32 -> IO (GValueConstruct o)
constructBufferMaxUndoLevels :: Int32 -> IO (GValueConstruct o)
constructBufferMaxUndoLevels val :: Int32
val = String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 "max-undo-levels" Int32
val

#if defined(ENABLE_OVERLOADING)
data BufferMaxUndoLevelsPropertyInfo
instance AttrInfo BufferMaxUndoLevelsPropertyInfo where
    type AttrAllowedOps BufferMaxUndoLevelsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint BufferMaxUndoLevelsPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferMaxUndoLevelsPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint BufferMaxUndoLevelsPropertyInfo = (~) Int32
    type AttrTransferType BufferMaxUndoLevelsPropertyInfo = Int32
    type AttrGetType BufferMaxUndoLevelsPropertyInfo = Int32
    type AttrLabel BufferMaxUndoLevelsPropertyInfo = "max-undo-levels"
    type AttrOrigin BufferMaxUndoLevelsPropertyInfo = Buffer
    attrGet = getBufferMaxUndoLevels
    attrSet = setBufferMaxUndoLevels
    attrTransfer _ v = do
        return v
    attrConstruct = constructBufferMaxUndoLevels
    attrClear = undefined
#endif

-- VVV Prop "style-scheme"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

-- | Set the value of the “@style-scheme@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #styleScheme 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferStyleScheme :: (MonadIO m, IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => o -> a -> m ()
setBufferStyleScheme :: o -> a -> m ()
setBufferStyleScheme obj :: o
obj val :: a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "style-scheme" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@style-scheme@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferStyleScheme :: (IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => a -> IO (GValueConstruct o)
constructBufferStyleScheme :: a -> IO (GValueConstruct o)
constructBufferStyleScheme val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "style-scheme" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Set the value of the “@style-scheme@” 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' #styleScheme
-- @
clearBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m ()
clearBufferStyleScheme :: o -> m ()
clearBufferStyleScheme obj :: 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 StyleScheme -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "style-scheme" (Maybe StyleScheme
forall a. Maybe a
Nothing :: Maybe GtkSource.StyleScheme.StyleScheme)

#if defined(ENABLE_OVERLOADING)
data BufferStyleSchemePropertyInfo
instance AttrInfo BufferStyleSchemePropertyInfo where
    type AttrAllowedOps BufferStyleSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint BufferStyleSchemePropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferStyleSchemePropertyInfo = GtkSource.StyleScheme.IsStyleScheme
    type AttrTransferTypeConstraint BufferStyleSchemePropertyInfo = GtkSource.StyleScheme.IsStyleScheme
    type AttrTransferType BufferStyleSchemePropertyInfo = GtkSource.StyleScheme.StyleScheme
    type AttrGetType BufferStyleSchemePropertyInfo = (Maybe GtkSource.StyleScheme.StyleScheme)
    type AttrLabel BufferStyleSchemePropertyInfo = "style-scheme"
    type AttrOrigin BufferStyleSchemePropertyInfo = Buffer
    attrGet = getBufferStyleScheme
    attrSet = setBufferStyleScheme
    attrTransfer _ v = do
        unsafeCastTo GtkSource.StyleScheme.StyleScheme v
    attrConstruct = constructBufferStyleScheme
    attrClear = clearBufferStyleScheme
#endif

-- VVV Prop "undo-manager"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just True,Just True)

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

-- | Set the value of the “@undo-manager@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buffer [ #undoManager 'Data.GI.Base.Attributes.:=' value ]
-- @
setBufferUndoManager :: (MonadIO m, IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => o -> a -> m ()
setBufferUndoManager :: o -> a -> m ()
setBufferUndoManager obj :: o
obj val :: a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "undo-manager" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@undo-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBufferUndoManager :: (IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => a -> IO (GValueConstruct o)
constructBufferUndoManager :: a -> IO (GValueConstruct o)
constructBufferUndoManager val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "undo-manager" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Set the value of the “@undo-manager@” 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' #undoManager
-- @
clearBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m ()
clearBufferUndoManager :: o -> m ()
clearBufferUndoManager obj :: 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 UndoManager -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "undo-manager" (Maybe UndoManager
forall a. Maybe a
Nothing :: Maybe GtkSource.UndoManager.UndoManager)

#if defined(ENABLE_OVERLOADING)
data BufferUndoManagerPropertyInfo
instance AttrInfo BufferUndoManagerPropertyInfo where
    type AttrAllowedOps BufferUndoManagerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint BufferUndoManagerPropertyInfo = IsBuffer
    type AttrSetTypeConstraint BufferUndoManagerPropertyInfo = GtkSource.UndoManager.IsUndoManager
    type AttrTransferTypeConstraint BufferUndoManagerPropertyInfo = GtkSource.UndoManager.IsUndoManager
    type AttrTransferType BufferUndoManagerPropertyInfo = GtkSource.UndoManager.UndoManager
    type AttrGetType BufferUndoManagerPropertyInfo = (Maybe GtkSource.UndoManager.UndoManager)
    type AttrLabel BufferUndoManagerPropertyInfo = "undo-manager"
    type AttrOrigin BufferUndoManagerPropertyInfo = Buffer
    attrGet = getBufferUndoManager
    attrSet = setBufferUndoManager
    attrTransfer _ v = do
        unsafeCastTo GtkSource.UndoManager.UndoManager v
    attrConstruct = constructBufferUndoManager
    attrClear = clearBufferUndoManager
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Buffer
type instance O.AttributeList Buffer = BufferAttributeList
type BufferAttributeList = ('[ '("canRedo", BufferCanRedoPropertyInfo), '("canUndo", BufferCanUndoPropertyInfo), '("copyTargetList", Gtk.TextBuffer.TextBufferCopyTargetListPropertyInfo), '("cursorPosition", Gtk.TextBuffer.TextBufferCursorPositionPropertyInfo), '("hasSelection", Gtk.TextBuffer.TextBufferHasSelectionPropertyInfo), '("highlightMatchingBrackets", BufferHighlightMatchingBracketsPropertyInfo), '("highlightSyntax", BufferHighlightSyntaxPropertyInfo), '("implicitTrailingNewline", BufferImplicitTrailingNewlinePropertyInfo), '("language", BufferLanguagePropertyInfo), '("maxUndoLevels", BufferMaxUndoLevelsPropertyInfo), '("pasteTargetList", Gtk.TextBuffer.TextBufferPasteTargetListPropertyInfo), '("styleScheme", BufferStyleSchemePropertyInfo), '("tagTable", Gtk.TextBuffer.TextBufferTagTablePropertyInfo), '("text", Gtk.TextBuffer.TextBufferTextPropertyInfo), '("undoManager", BufferUndoManagerPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
bufferHighlightMatchingBrackets :: AttrLabelProxy "highlightMatchingBrackets"
bufferHighlightMatchingBrackets = AttrLabelProxy

bufferHighlightSyntax :: AttrLabelProxy "highlightSyntax"
bufferHighlightSyntax = AttrLabelProxy

bufferImplicitTrailingNewline :: AttrLabelProxy "implicitTrailingNewline"
bufferImplicitTrailingNewline = AttrLabelProxy

bufferLanguage :: AttrLabelProxy "language"
bufferLanguage = AttrLabelProxy

bufferMaxUndoLevels :: AttrLabelProxy "maxUndoLevels"
bufferMaxUndoLevels = AttrLabelProxy

bufferStyleScheme :: AttrLabelProxy "styleScheme"
bufferStyleScheme = AttrLabelProxy

bufferUndoManager :: AttrLabelProxy "undoManager"
bufferUndoManager = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Buffer = BufferSignalList
type BufferSignalList = ('[ '("applyTag", Gtk.TextBuffer.TextBufferApplyTagSignalInfo), '("beginUserAction", Gtk.TextBuffer.TextBufferBeginUserActionSignalInfo), '("bracketMatched", BufferBracketMatchedSignalInfo), '("changed", Gtk.TextBuffer.TextBufferChangedSignalInfo), '("deleteRange", Gtk.TextBuffer.TextBufferDeleteRangeSignalInfo), '("endUserAction", Gtk.TextBuffer.TextBufferEndUserActionSignalInfo), '("highlightUpdated", BufferHighlightUpdatedSignalInfo), '("insertChildAnchor", Gtk.TextBuffer.TextBufferInsertChildAnchorSignalInfo), '("insertPixbuf", Gtk.TextBuffer.TextBufferInsertPixbufSignalInfo), '("insertText", Gtk.TextBuffer.TextBufferInsertTextSignalInfo), '("markDeleted", Gtk.TextBuffer.TextBufferMarkDeletedSignalInfo), '("markSet", Gtk.TextBuffer.TextBufferMarkSetSignalInfo), '("modifiedChanged", Gtk.TextBuffer.TextBufferModifiedChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pasteDone", Gtk.TextBuffer.TextBufferPasteDoneSignalInfo), '("redo", BufferRedoSignalInfo), '("removeTag", Gtk.TextBuffer.TextBufferRemoveTagSignalInfo), '("sourceMarkUpdated", BufferSourceMarkUpdatedSignalInfo), '("undo", BufferUndoSignalInfo)] :: [(Symbol, *)])

#endif

-- method Buffer::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTagTable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GtkTextTagTable, or %NULL to create a new one."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GtkSource" , name = "Buffer" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_buffer_new" gtk_source_buffer_new :: 
    Ptr Gtk.TextTagTable.TextTagTable ->    -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
    IO (Ptr Buffer)

-- | Creates a new source buffer.
bufferNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.TextTagTable.IsTextTagTable a) =>
    Maybe (a)
    -- ^ /@table@/: a t'GI.Gtk.Objects.TextTagTable.TextTagTable', or 'P.Nothing' to create a new one.
    -> m Buffer
    -- ^ __Returns:__ a new source buffer.
bufferNew :: Maybe a -> m Buffer
bufferNew table :: Maybe a
table = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextTagTable
maybeTable <- case Maybe a
table of
        Nothing -> Ptr TextTagTable -> IO (Ptr TextTagTable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextTagTable
forall a. Ptr a
nullPtr
        Just jTable :: a
jTable -> do
            Ptr TextTagTable
jTable' <- a -> IO (Ptr TextTagTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jTable
            Ptr TextTagTable -> IO (Ptr TextTagTable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextTagTable
jTable'
    Ptr Buffer
result <- Ptr TextTagTable -> IO (Ptr Buffer)
gtk_source_buffer_new Ptr TextTagTable
maybeTable
    Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bufferNew" Ptr Buffer
result
    Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
table a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gtk_source_buffer_new_with_language" gtk_source_buffer_new_with_language :: 
    Ptr GtkSource.Language.Language ->      -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO (Ptr Buffer)

-- | Creates a new source buffer using the highlighting patterns in
-- /@language@/.  This is equivalent to creating a new source buffer with
-- a new tag table and then calling 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'.
bufferNewWithLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.Language.IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m Buffer
    -- ^ __Returns:__ a new source buffer which will highlight text
    -- according to the highlighting patterns in /@language@/.
bufferNewWithLanguage :: a -> m Buffer
bufferNewWithLanguage language :: a
language = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
    Ptr Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    Ptr Buffer
result <- Ptr Language -> IO (Ptr Buffer)
gtk_source_buffer_new_with_language Ptr Language
language'
    Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bufferNewWithLanguage" Ptr Buffer
result
    Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
language
    Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Buffer::backward_iter_to_source_mark
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 "an iterator." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "category to search for, or %NULL"
--                 , 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_buffer_backward_iter_to_source_mark" gtk_source_buffer_backward_iter_to_source_mark :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- category : TBasicType TUTF8
    IO CInt

-- | Moves /@iter@/ to the position of the previous t'GI.GtkSource.Objects.Mark.Mark' of the given
-- category. Returns 'P.True' if /@iter@/ was moved. If /@category@/ is NULL, the
-- previous source mark can be of any category.
-- 
-- /Since: 2.2/
bufferBackwardIterToSourceMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: an iterator.
    -> Maybe (T.Text)
    -- ^ /@category@/: category to search for, or 'P.Nothing'
    -> m Bool
    -- ^ __Returns:__ whether /@iter@/ was moved.
bufferBackwardIterToSourceMark :: a -> TextIter -> Maybe Text -> m Bool
bufferBackwardIterToSourceMark buffer :: a
buffer iter :: TextIter
iter category :: Maybe Text
category = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
maybeCategory <- case Maybe Text
category of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jCategory :: Text
jCategory -> do
            Ptr CChar
jCategory' <- Text -> IO (Ptr CChar)
textToCString Text
jCategory
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCategory'
    CInt
result <- Ptr Buffer -> Ptr TextIter -> Ptr CChar -> IO CInt
gtk_source_buffer_backward_iter_to_source_mark Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
maybeCategory
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCategory
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferBackwardIterToSourceMarkMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferBackwardIterToSourceMarkMethodInfo a signature where
    overloadedMethod = bufferBackwardIterToSourceMark

#endif

-- method Buffer::begin_not_undoable_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_begin_not_undoable_action" gtk_source_buffer_begin_not_undoable_action :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO ()

-- | Marks the beginning of a not undoable action on the buffer,
-- disabling the undo manager.  Typically you would call this function
-- before initially setting the contents of the buffer (e.g. when
-- loading a file in a text editor).
-- 
-- You may nest 'GI.GtkSource.Objects.Buffer.bufferBeginNotUndoableAction' \/
-- 'GI.GtkSource.Objects.Buffer.bufferEndNotUndoableAction' blocks.
bufferBeginNotUndoableAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m ()
bufferBeginNotUndoableAction :: a -> m ()
bufferBeginNotUndoableAction buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Buffer -> IO ()
gtk_source_buffer_begin_not_undoable_action Ptr Buffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferBeginNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferBeginNotUndoableActionMethodInfo a signature where
    overloadedMethod = bufferBeginNotUndoableAction

#endif

-- method Buffer::can_redo
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_can_redo" gtk_source_buffer_can_redo :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO CInt

-- | Determines whether a source buffer can redo the last action
-- (i.e. if the last operation was an undo).
bufferCanRedo ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if a redo is possible.
bufferCanRedo :: a -> m Bool
bufferCanRedo buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    CInt
result <- Ptr Buffer -> IO CInt
gtk_source_buffer_can_redo Ptr Buffer
buffer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferCanRedoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanRedoMethodInfo a signature where
    overloadedMethod = bufferCanRedo

#endif

-- method Buffer::can_undo
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_can_undo" gtk_source_buffer_can_undo :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO CInt

-- | Determines whether a source buffer can undo the last action.
bufferCanUndo ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if it\'s possible to undo the last action.
bufferCanUndo :: a -> m Bool
bufferCanUndo buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    CInt
result <- Ptr Buffer -> IO CInt
gtk_source_buffer_can_undo Ptr Buffer
buffer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferCanUndoMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanUndoMethodInfo a signature where
    overloadedMethod = bufferCanUndo

#endif

-- method Buffer::change_case
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "case_type"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "ChangeCaseType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how to change the case."
--                 , 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_buffer_change_case" gtk_source_buffer_change_case :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    CUInt ->                                -- case_type : TInterface (Name {namespace = "GtkSource", name = "ChangeCaseType"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Changes the case of the text between the specified iterators.
-- 
-- /Since: 3.12/
bufferChangeCase ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> GtkSource.Enums.ChangeCaseType
    -- ^ /@caseType@/: how to change the case.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> m ()
bufferChangeCase :: a -> ChangeCaseType -> TextIter -> TextIter -> m ()
bufferChangeCase buffer :: a
buffer caseType :: ChangeCaseType
caseType start :: TextIter
start end :: 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    let caseType' :: CUInt
caseType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ChangeCaseType -> Int) -> ChangeCaseType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChangeCaseType -> Int
forall a. Enum a => a -> Int
fromEnum) ChangeCaseType
caseType
    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 Buffer -> CUInt -> Ptr TextIter -> Ptr TextIter -> IO ()
gtk_source_buffer_change_case Ptr Buffer
buffer' CUInt
caseType' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    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 BufferChangeCaseMethodInfo
instance (signature ~ (GtkSource.Enums.ChangeCaseType -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferChangeCaseMethodInfo a signature where
    overloadedMethod = bufferChangeCase

#endif

-- method Buffer::create_source_mark
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the mark, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string defining the mark category."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "where"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to place the mark."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "Mark" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_buffer_create_source_mark" gtk_source_buffer_create_source_mark :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- category : TBasicType TUTF8
    Ptr Gtk.TextIter.TextIter ->            -- where : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO (Ptr GtkSource.Mark.Mark)

-- | Creates a source mark in the /@buffer@/ of category /@category@/.  A source mark is
-- a t'GI.Gtk.Objects.TextMark.TextMark' but organised into categories. Depending on the category
-- a pixbuf can be specified that will be displayed along the line of the mark.
-- 
-- Like a t'GI.Gtk.Objects.TextMark.TextMark', a t'GI.GtkSource.Objects.Mark.Mark' can be anonymous if the
-- passed /@name@/ is 'P.Nothing'.  Also, the buffer owns the marks so you
-- shouldn\'t unreference it.
-- 
-- Marks always have left gravity and are moved to the beginning of
-- the line when the user deletes the line they were in.
-- 
-- Typical uses for a source mark are bookmarks, breakpoints, current
-- executing instruction indication in a source file, etc..
-- 
-- /Since: 2.2/
bufferCreateSourceMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Maybe (T.Text)
    -- ^ /@name@/: the name of the mark, or 'P.Nothing'.
    -> T.Text
    -- ^ /@category@/: a string defining the mark category.
    -> Gtk.TextIter.TextIter
    -- ^ /@where@/: location to place the mark.
    -> m GtkSource.Mark.Mark
    -- ^ __Returns:__ a new t'GI.GtkSource.Objects.Mark.Mark', owned by the buffer.
bufferCreateSourceMark :: a -> Maybe Text -> Text -> TextIter -> m Mark
bufferCreateSourceMark buffer :: a
buffer name :: Maybe Text
name category :: Text
category where_ :: TextIter
where_ = IO Mark -> m Mark
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Mark -> m Mark) -> IO Mark -> m Mark
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr CChar
maybeName <- case Maybe Text
name of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jName :: Text
jName -> do
            Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
    Ptr CChar
category' <- Text -> IO (Ptr CChar)
textToCString Text
category
    Ptr TextIter
where_' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
where_
    Ptr Mark
result <- Ptr Buffer
-> Ptr CChar -> Ptr CChar -> Ptr TextIter -> IO (Ptr Mark)
gtk_source_buffer_create_source_mark Ptr Buffer
buffer' Ptr CChar
maybeName Ptr CChar
category' Ptr TextIter
where_'
    Text -> Ptr Mark -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bufferCreateSourceMark" Ptr Mark
result
    Mark
result' <- ((ManagedPtr Mark -> Mark) -> Ptr Mark -> IO Mark
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mark -> Mark
GtkSource.Mark.Mark) Ptr Mark
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
where_
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
category'
    Mark -> IO Mark
forall (m :: * -> *) a. Monad m => a -> m a
return Mark
result'

#if defined(ENABLE_OVERLOADING)
data BufferCreateSourceMarkMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Gtk.TextIter.TextIter -> m GtkSource.Mark.Mark), MonadIO m, IsBuffer a) => O.MethodInfo BufferCreateSourceMarkMethodInfo a signature where
    overloadedMethod = bufferCreateSourceMark

#endif

-- method Buffer::end_not_undoable_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_end_not_undoable_action" gtk_source_buffer_end_not_undoable_action :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO ()

-- | Marks the end of a not undoable action on the buffer.  When the
-- last not undoable block is closed through the call to this
-- function, the list of undo actions is cleared and the undo manager
-- is re-enabled.
bufferEndNotUndoableAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m ()
bufferEndNotUndoableAction :: a -> m ()
bufferEndNotUndoableAction buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Buffer -> IO ()
gtk_source_buffer_end_not_undoable_action Ptr Buffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferEndNotUndoableActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEndNotUndoableActionMethodInfo a signature where
    overloadedMethod = bufferEndNotUndoableAction

#endif

-- method Buffer::ensure_highlight
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 "start of the area to highlight."
--                 , 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 "end of the area to highlight."
--                 , 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_buffer_ensure_highlight" gtk_source_buffer_ensure_highlight :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Forces buffer to analyze and highlight the given area synchronously.
-- 
-- \<note>
--   \<para>
--     This is a potentially slow operation and should be used only
--     when you need to make sure that some text not currently
--     visible is highlighted, for instance before printing.
--   \<\/para>
-- \<\/note>
bufferEnsureHighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: start of the area to highlight.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: end of the area to highlight.
    -> m ()
bufferEnsureHighlight :: a -> TextIter -> TextIter -> m ()
bufferEnsureHighlight buffer :: a
buffer start :: TextIter
start end :: 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    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 Buffer -> Ptr TextIter -> Ptr TextIter -> IO ()
gtk_source_buffer_ensure_highlight Ptr Buffer
buffer' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    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 BufferEnsureHighlightMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEnsureHighlightMethodInfo a signature where
    overloadedMethod = bufferEnsureHighlight

#endif

-- method Buffer::forward_iter_to_source_mark
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 "an iterator." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "category to search for, or %NULL"
--                 , 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_buffer_forward_iter_to_source_mark" gtk_source_buffer_forward_iter_to_source_mark :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- category : TBasicType TUTF8
    IO CInt

-- | Moves /@iter@/ to the position of the next t'GI.GtkSource.Objects.Mark.Mark' of the given
-- /@category@/. Returns 'P.True' if /@iter@/ was moved. If /@category@/ is NULL, the
-- next source mark can be of any category.
-- 
-- /Since: 2.2/
bufferForwardIterToSourceMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: an iterator.
    -> Maybe (T.Text)
    -- ^ /@category@/: category to search for, or 'P.Nothing'
    -> m Bool
    -- ^ __Returns:__ whether /@iter@/ was moved.
bufferForwardIterToSourceMark :: a -> TextIter -> Maybe Text -> m Bool
bufferForwardIterToSourceMark buffer :: a
buffer iter :: TextIter
iter category :: Maybe Text
category = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
maybeCategory <- case Maybe Text
category of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jCategory :: Text
jCategory -> do
            Ptr CChar
jCategory' <- Text -> IO (Ptr CChar)
textToCString Text
jCategory
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCategory'
    CInt
result <- Ptr Buffer -> Ptr TextIter -> Ptr CChar -> IO CInt
gtk_source_buffer_forward_iter_to_source_mark Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
maybeCategory
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCategory
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferForwardIterToSourceMarkMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferForwardIterToSourceMarkMethodInfo a signature where
    overloadedMethod = bufferForwardIterToSourceMark

#endif

-- method Buffer::get_context_classes_at_iter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_buffer_get_context_classes_at_iter" gtk_source_buffer_get_context_classes_at_iter :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO (Ptr CString)

-- | Get all defined context classes at /@iter@/.
-- 
-- See the t'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes.
-- 
-- /Since: 2.10/
bufferGetContextClassesAtIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> m [T.Text]
    -- ^ __Returns:__ a new 'P.Nothing'
    -- terminated array of context class names.
    -- Use 'GI.GLib.Functions.strfreev' to free the array if it is no longer needed.
bufferGetContextClassesAtIter :: a -> TextIter -> m [Text]
bufferGetContextClassesAtIter buffer :: a
buffer iter :: TextIter
iter = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr (Ptr CChar)
result <- Ptr Buffer -> Ptr TextIter -> IO (Ptr (Ptr CChar))
gtk_source_buffer_get_context_classes_at_iter Ptr Buffer
buffer' Ptr TextIter
iter'
    Text -> Ptr (Ptr CChar) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bufferGetContextClassesAtIter" Ptr (Ptr CChar)
result
    [Text]
result' <- HasCallStack => Ptr (Ptr CChar) -> IO [Text]
Ptr (Ptr CChar) -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr (Ptr CChar)
result
    (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
result
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    [Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data BufferGetContextClassesAtIterMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> m [T.Text]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetContextClassesAtIterMethodInfo a signature where
    overloadedMethod = bufferGetContextClassesAtIter

#endif

-- method Buffer::get_highlight_matching_brackets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_get_highlight_matching_brackets" gtk_source_buffer_get_highlight_matching_brackets :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO CInt

-- | Determines whether bracket match highlighting is activated for the
-- source buffer.
bufferGetHighlightMatchingBrackets ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the source buffer will highlight matching
    -- brackets.
bufferGetHighlightMatchingBrackets :: a -> m Bool
bufferGetHighlightMatchingBrackets buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    CInt
result <- Ptr Buffer -> IO CInt
gtk_source_buffer_get_highlight_matching_brackets Ptr Buffer
buffer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferGetHighlightMatchingBracketsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightMatchingBracketsMethodInfo a signature where
    overloadedMethod = bufferGetHighlightMatchingBrackets

#endif

-- method Buffer::get_highlight_syntax
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_get_highlight_syntax" gtk_source_buffer_get_highlight_syntax :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO CInt

-- | Determines whether syntax highlighting is activated in the source
-- buffer.
bufferGetHighlightSyntax ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if syntax highlighting is enabled, 'P.False' otherwise.
bufferGetHighlightSyntax :: a -> m Bool
bufferGetHighlightSyntax buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    CInt
result <- Ptr Buffer -> IO CInt
gtk_source_buffer_get_highlight_syntax Ptr Buffer
buffer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferGetHighlightSyntaxMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = bufferGetHighlightSyntax

#endif

-- method Buffer::get_implicit_trailing_newline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_get_implicit_trailing_newline" gtk_source_buffer_get_implicit_trailing_newline :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 3.14/
bufferGetImplicitTrailingNewline ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Bool
    -- ^ __Returns:__ whether the /@buffer@/ has an implicit trailing newline.
bufferGetImplicitTrailingNewline :: a -> m Bool
bufferGetImplicitTrailingNewline buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    CInt
result <- Ptr Buffer -> IO CInt
gtk_source_buffer_get_implicit_trailing_newline Ptr Buffer
buffer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferGetImplicitTrailingNewlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetImplicitTrailingNewlineMethodInfo a signature where
    overloadedMethod = bufferGetImplicitTrailingNewline

#endif

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

foreign import ccall "gtk_source_buffer_get_language" gtk_source_buffer_get_language :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO (Ptr GtkSource.Language.Language)

-- | Returns the t'GI.GtkSource.Objects.Language.Language' associated with the buffer,
-- see 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'.  The returned object should not be
-- unreferenced by the user.
bufferGetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m (Maybe GtkSource.Language.Language)
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.Language.Language' associated
    -- with the buffer, or 'P.Nothing'.
bufferGetLanguage :: a -> m (Maybe Language)
bufferGetLanguage buffer :: a
buffer = IO (Maybe Language) -> m (Maybe Language)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Language) -> m (Maybe Language))
-> IO (Maybe Language) -> m (Maybe Language)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Language
result <- Ptr Buffer -> IO (Ptr Language)
gtk_source_buffer_get_language Ptr Buffer
buffer'
    Maybe Language
maybeResult <- Ptr Language
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Language
result ((Ptr Language -> IO Language) -> IO (Maybe Language))
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Language
result' -> do
        Language
result'' <- ((ManagedPtr Language -> Language) -> Ptr Language -> IO Language
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Language -> Language
GtkSource.Language.Language) Ptr Language
result'
        Language -> IO Language
forall (m :: * -> *) a. Monad m => a -> m a
return Language
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe Language -> IO (Maybe Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
maybeResult

#if defined(ENABLE_OVERLOADING)
data BufferGetLanguageMethodInfo
instance (signature ~ (m (Maybe GtkSource.Language.Language)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetLanguageMethodInfo a signature where
    overloadedMethod = bufferGetLanguage

#endif

-- method Buffer::get_max_undo_levels
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_get_max_undo_levels" gtk_source_buffer_get_max_undo_levels :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO Int32

-- | Determines the number of undo levels the buffer will track for buffer edits.
bufferGetMaxUndoLevels ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m Int32
    -- ^ __Returns:__ the maximum number of possible undo levels or -1 if no limit is set.
bufferGetMaxUndoLevels :: a -> m Int32
bufferGetMaxUndoLevels buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Int32
result <- Ptr Buffer -> IO Int32
gtk_source_buffer_get_max_undo_levels Ptr Buffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data BufferGetMaxUndoLevelsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetMaxUndoLevelsMethodInfo a signature where
    overloadedMethod = bufferGetMaxUndoLevels

#endif

-- method Buffer::get_source_marks_at_iter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 "an iterator." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "category to search for, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGSList
--                  (TInterface Name { namespace = "GtkSource" , name = "Mark" }))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_buffer_get_source_marks_at_iter" gtk_source_buffer_get_source_marks_at_iter :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- category : TBasicType TUTF8
    IO (Ptr (GSList (Ptr GtkSource.Mark.Mark)))

-- | Returns the list of marks of the given category at /@iter@/. If /@category@/
-- is 'P.Nothing' it returns all marks at /@iter@/.
-- 
-- /Since: 2.2/
bufferGetSourceMarksAtIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: an iterator.
    -> Maybe (T.Text)
    -- ^ /@category@/: category to search for, or 'P.Nothing'
    -> m [GtkSource.Mark.Mark]
    -- ^ __Returns:__ 
    -- a newly allocated t'GI.GLib.Structs.SList.SList'.
bufferGetSourceMarksAtIter :: a -> TextIter -> Maybe Text -> m [Mark]
bufferGetSourceMarksAtIter buffer :: a
buffer iter :: TextIter
iter category :: Maybe Text
category = IO [Mark] -> m [Mark]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Mark] -> m [Mark]) -> IO [Mark] -> m [Mark]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
maybeCategory <- case Maybe Text
category of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jCategory :: Text
jCategory -> do
            Ptr CChar
jCategory' <- Text -> IO (Ptr CChar)
textToCString Text
jCategory
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCategory'
    Ptr (GSList (Ptr Mark))
result <- Ptr Buffer
-> Ptr TextIter -> Ptr CChar -> IO (Ptr (GSList (Ptr Mark)))
gtk_source_buffer_get_source_marks_at_iter Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
maybeCategory
    [Ptr Mark]
result' <- Ptr (GSList (Ptr Mark)) -> IO [Ptr Mark]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Mark))
result
    [Mark]
result'' <- (Ptr Mark -> IO Mark) -> [Ptr Mark] -> IO [Mark]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Mark -> Mark) -> Ptr Mark -> IO Mark
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mark -> Mark
GtkSource.Mark.Mark) [Ptr Mark]
result'
    Ptr (GSList (Ptr Mark)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Mark))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCategory
    [Mark] -> IO [Mark]
forall (m :: * -> *) a. Monad m => a -> m a
return [Mark]
result''

#if defined(ENABLE_OVERLOADING)
data BufferGetSourceMarksAtIterMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtIterMethodInfo a signature where
    overloadedMethod = bufferGetSourceMarksAtIter

#endif

-- method Buffer::get_source_marks_at_line
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a line number." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "category to search for, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGSList
--                  (TInterface Name { namespace = "GtkSource" , name = "Mark" }))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_buffer_get_source_marks_at_line" gtk_source_buffer_get_source_marks_at_line :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Int32 ->                                -- line : TBasicType TInt
    CString ->                              -- category : TBasicType TUTF8
    IO (Ptr (GSList (Ptr GtkSource.Mark.Mark)))

-- | Returns the list of marks of the given category at /@line@/.
-- If /@category@/ is 'P.Nothing', all marks at /@line@/ are returned.
-- 
-- /Since: 2.2/
bufferGetSourceMarksAtLine ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Int32
    -- ^ /@line@/: a line number.
    -> Maybe (T.Text)
    -- ^ /@category@/: category to search for, or 'P.Nothing'
    -> m [GtkSource.Mark.Mark]
    -- ^ __Returns:__ 
    -- a newly allocated t'GI.GLib.Structs.SList.SList'.
bufferGetSourceMarksAtLine :: a -> Int32 -> Maybe Text -> m [Mark]
bufferGetSourceMarksAtLine buffer :: a
buffer line :: Int32
line category :: Maybe Text
category = IO [Mark] -> m [Mark]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Mark] -> m [Mark]) -> IO [Mark] -> m [Mark]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr CChar
maybeCategory <- case Maybe Text
category of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jCategory :: Text
jCategory -> do
            Ptr CChar
jCategory' <- Text -> IO (Ptr CChar)
textToCString Text
jCategory
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCategory'
    Ptr (GSList (Ptr Mark))
result <- Ptr Buffer -> Int32 -> Ptr CChar -> IO (Ptr (GSList (Ptr Mark)))
gtk_source_buffer_get_source_marks_at_line Ptr Buffer
buffer' Int32
line Ptr CChar
maybeCategory
    [Ptr Mark]
result' <- Ptr (GSList (Ptr Mark)) -> IO [Ptr Mark]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Mark))
result
    [Mark]
result'' <- (Ptr Mark -> IO Mark) -> [Ptr Mark] -> IO [Mark]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Mark -> Mark) -> Ptr Mark -> IO Mark
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mark -> Mark
GtkSource.Mark.Mark) [Ptr Mark]
result'
    Ptr (GSList (Ptr Mark)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Mark))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCategory
    [Mark] -> IO [Mark]
forall (m :: * -> *) a. Monad m => a -> m a
return [Mark]
result''

#if defined(ENABLE_OVERLOADING)
data BufferGetSourceMarksAtLineMethodInfo
instance (signature ~ (Int32 -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtLineMethodInfo a signature where
    overloadedMethod = bufferGetSourceMarksAtLine

#endif

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

foreign import ccall "gtk_source_buffer_get_style_scheme" gtk_source_buffer_get_style_scheme :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO (Ptr GtkSource.StyleScheme.StyleScheme)

-- | Returns the t'GI.GtkSource.Objects.StyleScheme.StyleScheme' associated with the buffer,
-- see 'GI.GtkSource.Objects.Buffer.bufferSetStyleScheme'.
-- The returned object should not be unreferenced by the user.
bufferGetStyleScheme ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m (Maybe GtkSource.StyleScheme.StyleScheme)
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.StyleScheme.StyleScheme'
    -- associated with the buffer, or 'P.Nothing'.
bufferGetStyleScheme :: a -> m (Maybe StyleScheme)
bufferGetStyleScheme buffer :: a
buffer = IO (Maybe StyleScheme) -> m (Maybe StyleScheme)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe StyleScheme) -> m (Maybe StyleScheme))
-> IO (Maybe StyleScheme) -> m (Maybe StyleScheme)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr StyleScheme
result <- Ptr Buffer -> IO (Ptr StyleScheme)
gtk_source_buffer_get_style_scheme Ptr Buffer
buffer'
    Maybe StyleScheme
maybeResult <- Ptr StyleScheme
-> (Ptr StyleScheme -> IO StyleScheme) -> IO (Maybe StyleScheme)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr StyleScheme
result ((Ptr StyleScheme -> IO StyleScheme) -> IO (Maybe StyleScheme))
-> (Ptr StyleScheme -> IO StyleScheme) -> IO (Maybe StyleScheme)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr StyleScheme
result' -> do
        StyleScheme
result'' <- ((ManagedPtr StyleScheme -> StyleScheme)
-> Ptr StyleScheme -> IO StyleScheme
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr StyleScheme -> StyleScheme
GtkSource.StyleScheme.StyleScheme) Ptr StyleScheme
result'
        StyleScheme -> IO StyleScheme
forall (m :: * -> *) a. Monad m => a -> m a
return StyleScheme
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe StyleScheme -> IO (Maybe StyleScheme)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StyleScheme
maybeResult

#if defined(ENABLE_OVERLOADING)
data BufferGetStyleSchemeMethodInfo
instance (signature ~ (m (Maybe GtkSource.StyleScheme.StyleScheme)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetStyleSchemeMethodInfo a signature where
    overloadedMethod = bufferGetStyleScheme

#endif

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

foreign import ccall "gtk_source_buffer_get_undo_manager" gtk_source_buffer_get_undo_manager :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO (Ptr GtkSource.UndoManager.UndoManager)

-- | Returns the t'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated with the buffer,
-- see 'GI.GtkSource.Objects.Buffer.bufferSetUndoManager'.  The returned object should not be
-- unreferenced by the user.
bufferGetUndoManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m (Maybe GtkSource.UndoManager.UndoManager)
    -- ^ __Returns:__ the t'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated
    -- with the buffer, or 'P.Nothing'.
bufferGetUndoManager :: a -> m (Maybe UndoManager)
bufferGetUndoManager buffer :: a
buffer = IO (Maybe UndoManager) -> m (Maybe UndoManager)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe UndoManager) -> m (Maybe UndoManager))
-> IO (Maybe UndoManager) -> m (Maybe UndoManager)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr UndoManager
result <- Ptr Buffer -> IO (Ptr UndoManager)
gtk_source_buffer_get_undo_manager Ptr Buffer
buffer'
    Maybe UndoManager
maybeResult <- Ptr UndoManager
-> (Ptr UndoManager -> IO UndoManager) -> IO (Maybe UndoManager)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr UndoManager
result ((Ptr UndoManager -> IO UndoManager) -> IO (Maybe UndoManager))
-> (Ptr UndoManager -> IO UndoManager) -> IO (Maybe UndoManager)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr UndoManager
result' -> do
        UndoManager
result'' <- ((ManagedPtr UndoManager -> UndoManager)
-> Ptr UndoManager -> IO UndoManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr UndoManager -> UndoManager
GtkSource.UndoManager.UndoManager) Ptr UndoManager
result'
        UndoManager -> IO UndoManager
forall (m :: * -> *) a. Monad m => a -> m a
return UndoManager
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe UndoManager -> IO (Maybe UndoManager)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UndoManager
maybeResult

#if defined(ENABLE_OVERLOADING)
data BufferGetUndoManagerMethodInfo
instance (signature ~ (m (Maybe GtkSource.UndoManager.UndoManager)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetUndoManagerMethodInfo a signature where
    overloadedMethod = bufferGetUndoManager

#endif

-- method Buffer::iter_backward_to_context_class_toggle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 = "context_class"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the context class." , 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_buffer_iter_backward_to_context_class_toggle" gtk_source_buffer_iter_backward_to_context_class_toggle :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- context_class : TBasicType TUTF8
    IO CInt

-- | Moves backward to the next toggle (on or off) of the context class. If no
-- matching context class toggles are found, returns 'P.False', otherwise 'P.True'.
-- Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets
-- /@iter@/ to the location of the toggle, or to the end of the buffer if no
-- toggle is found.
-- 
-- See the t'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes.
-- 
-- /Since: 2.10/
bufferIterBackwardToContextClassToggle ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> T.Text
    -- ^ /@contextClass@/: the context class.
    -> m Bool
    -- ^ __Returns:__ whether we found a context class toggle before /@iter@/
bufferIterBackwardToContextClassToggle :: a -> TextIter -> Text -> m Bool
bufferIterBackwardToContextClassToggle buffer :: a
buffer iter :: TextIter
iter contextClass :: Text
contextClass = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
contextClass' <- Text -> IO (Ptr CChar)
textToCString Text
contextClass
    CInt
result <- Ptr Buffer -> Ptr TextIter -> Ptr CChar -> IO CInt
gtk_source_buffer_iter_backward_to_context_class_toggle Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
contextClass'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contextClass'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferIterBackwardToContextClassToggleMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterBackwardToContextClassToggleMethodInfo a signature where
    overloadedMethod = bufferIterBackwardToContextClassToggle

#endif

-- method Buffer::iter_forward_to_context_class_toggle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 = "context_class"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the context class." , 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_buffer_iter_forward_to_context_class_toggle" gtk_source_buffer_iter_forward_to_context_class_toggle :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- context_class : TBasicType TUTF8
    IO CInt

-- | Moves forward to the next toggle (on or off) of the context class. If no
-- matching context class toggles are found, returns 'P.False', otherwise 'P.True'.
-- Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets
-- /@iter@/ to the location of the toggle, or to the end of the buffer if no
-- toggle is found.
-- 
-- See the t'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes.
-- 
-- /Since: 2.10/
bufferIterForwardToContextClassToggle ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> T.Text
    -- ^ /@contextClass@/: the context class.
    -> m Bool
    -- ^ __Returns:__ whether we found a context class toggle after /@iter@/
bufferIterForwardToContextClassToggle :: a -> TextIter -> Text -> m Bool
bufferIterForwardToContextClassToggle buffer :: a
buffer iter :: TextIter
iter contextClass :: Text
contextClass = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
contextClass' <- Text -> IO (Ptr CChar)
textToCString Text
contextClass
    CInt
result <- Ptr Buffer -> Ptr TextIter -> Ptr CChar -> IO CInt
gtk_source_buffer_iter_forward_to_context_class_toggle Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
contextClass'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contextClass'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferIterForwardToContextClassToggleMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterForwardToContextClassToggleMethodInfo a signature where
    overloadedMethod = bufferIterForwardToContextClassToggle

#endif

-- method Buffer::iter_has_context_class
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 = "context_class"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to search for."
--                 , 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_buffer_iter_has_context_class" gtk_source_buffer_iter_has_context_class :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- context_class : TBasicType TUTF8
    IO CInt

-- | Check if the class /@contextClass@/ is set on /@iter@/.
-- 
-- See the t'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes.
-- 
-- /Since: 2.10/
bufferIterHasContextClass ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> T.Text
    -- ^ /@contextClass@/: class to search for.
    -> m Bool
    -- ^ __Returns:__ whether /@iter@/ has the context class.
bufferIterHasContextClass :: a -> TextIter -> Text -> m Bool
bufferIterHasContextClass buffer :: a
buffer iter :: TextIter
iter contextClass :: Text
contextClass = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr CChar
contextClass' <- Text -> IO (Ptr CChar)
textToCString Text
contextClass
    CInt
result <- Ptr Buffer -> Ptr TextIter -> Ptr CChar -> IO CInt
gtk_source_buffer_iter_has_context_class Ptr Buffer
buffer' Ptr TextIter
iter' Ptr CChar
contextClass'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contextClass'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data BufferIterHasContextClassMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterHasContextClassMethodInfo a signature where
    overloadedMethod = bufferIterHasContextClass

#endif

-- method Buffer::join_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_join_lines" gtk_source_buffer_join_lines :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Joins the lines of text between the specified iterators.
-- 
-- /Since: 3.16/
bufferJoinLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> m ()
bufferJoinLines :: a -> TextIter -> TextIter -> m ()
bufferJoinLines buffer :: a
buffer start :: TextIter
start end :: 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    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 Buffer -> Ptr TextIter -> Ptr TextIter -> IO ()
gtk_source_buffer_join_lines Ptr Buffer
buffer' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    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 BufferJoinLinesMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferJoinLinesMethodInfo a signature where
    overloadedMethod = bufferJoinLines

#endif

-- method Buffer::redo
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_redo" gtk_source_buffer_redo :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO ()

-- | Redoes the last undo operation.  Use 'GI.GtkSource.Objects.Buffer.bufferCanRedo'
-- to check whether a call to this function will have any effect.
-- 
-- This function emits the [redo]("GI.GtkSource.Objects.Buffer#signal:redo") signal.
bufferRedo ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m ()
bufferRedo :: a -> m ()
bufferRedo buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Buffer -> IO ()
gtk_source_buffer_redo Ptr Buffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferRedoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRedoMethodInfo a signature where
    overloadedMethod = bufferRedo

#endif

-- method Buffer::remove_source_marks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "category to search for, 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_buffer_remove_source_marks" gtk_source_buffer_remove_source_marks :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- category : TBasicType TUTF8
    IO ()

-- | Remove all marks of /@category@/ between /@start@/ and /@end@/ from the buffer.
-- If /@category@/ is NULL, all marks in the range will be removed.
-- 
-- /Since: 2.2/
bufferRemoveSourceMarks ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Maybe (T.Text)
    -- ^ /@category@/: category to search for, or 'P.Nothing'.
    -> m ()
bufferRemoveSourceMarks :: a -> TextIter -> TextIter -> Maybe Text -> m ()
bufferRemoveSourceMarks buffer :: a
buffer start :: TextIter
start end :: TextIter
end category :: Maybe Text
category = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    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 CChar
maybeCategory <- case Maybe Text
category of
        Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just jCategory :: Text
jCategory -> do
            Ptr CChar
jCategory' <- Text -> IO (Ptr CChar)
textToCString Text
jCategory
            Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCategory'
    Ptr Buffer -> Ptr TextIter -> Ptr TextIter -> Ptr CChar -> IO ()
gtk_source_buffer_remove_source_marks Ptr Buffer
buffer' Ptr TextIter
start' Ptr TextIter
end' Ptr CChar
maybeCategory
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCategory
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferRemoveSourceMarksMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Maybe (T.Text) -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRemoveSourceMarksMethodInfo a signature where
    overloadedMethod = bufferRemoveSourceMarks

#endif

-- method Buffer::set_highlight_matching_brackets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if you want matching brackets highlighted."
--                 , 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_buffer_set_highlight_matching_brackets" gtk_source_buffer_set_highlight_matching_brackets :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    CInt ->                                 -- highlight : TBasicType TBoolean
    IO ()

-- | Controls the bracket match highlighting function in the buffer.  If
-- activated, when you position your cursor over a bracket character
-- (a parenthesis, a square bracket, etc.) the matching opening or
-- closing bracket character will be highlighted.
bufferSetHighlightMatchingBrackets ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Bool
    -- ^ /@highlight@/: 'P.True' if you want matching brackets highlighted.
    -> m ()
bufferSetHighlightMatchingBrackets :: a -> Bool -> m ()
bufferSetHighlightMatchingBrackets buffer :: a
buffer highlight :: Bool
highlight = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    let highlight' :: CInt
highlight' = (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
highlight
    Ptr Buffer -> CInt -> IO ()
gtk_source_buffer_set_highlight_matching_brackets Ptr Buffer
buffer' CInt
highlight'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetHighlightMatchingBracketsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightMatchingBracketsMethodInfo a signature where
    overloadedMethod = bufferSetHighlightMatchingBrackets

#endif

-- method Buffer::set_highlight_syntax
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to enable syntax highlighting, %FALSE to disable it."
--                 , 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_buffer_set_highlight_syntax" gtk_source_buffer_set_highlight_syntax :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    CInt ->                                 -- highlight : TBasicType TBoolean
    IO ()

-- | Controls whether syntax is highlighted in the buffer.
-- 
-- If /@highlight@/ is 'P.True', the text will be highlighted according to the syntax
-- patterns specified in the t'GI.GtkSource.Objects.Language.Language' set with
-- 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'.
-- 
-- If /@highlight@/ is 'P.False', syntax highlighting is disabled and all the
-- t'GI.Gtk.Objects.TextTag.TextTag' objects that have been added by the syntax highlighting engine
-- are removed from the buffer.
bufferSetHighlightSyntax ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Bool
    -- ^ /@highlight@/: 'P.True' to enable syntax highlighting, 'P.False' to disable it.
    -> m ()
bufferSetHighlightSyntax :: a -> Bool -> m ()
bufferSetHighlightSyntax buffer :: a
buffer highlight :: Bool
highlight = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    let highlight' :: CInt
highlight' = (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
highlight
    Ptr Buffer -> CInt -> IO ()
gtk_source_buffer_set_highlight_syntax Ptr Buffer
buffer' CInt
highlight'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetHighlightSyntaxMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = bufferSetHighlightSyntax

#endif

-- method Buffer::set_implicit_trailing_newline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "implicit_trailing_newline"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value." , 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_buffer_set_implicit_trailing_newline" gtk_source_buffer_set_implicit_trailing_newline :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    CInt ->                                 -- implicit_trailing_newline : TBasicType TBoolean
    IO ()

-- | Sets whether the /@buffer@/ has an implicit trailing newline.
-- 
-- If an explicit trailing newline is present in a t'GI.Gtk.Objects.TextBuffer.TextBuffer', t'GI.Gtk.Objects.TextView.TextView'
-- shows it as an empty line. This is generally not what the user expects.
-- 
-- If /@implicitTrailingNewline@/ is 'P.True' (the default value):
--  - when a t'GI.GtkSource.Objects.FileLoader.FileLoader' loads the content of a file into the /@buffer@/,
--    the trailing newline (if present in the file) is not inserted into the
--    /@buffer@/.
--  - when a t'GI.GtkSource.Objects.FileSaver.FileSaver' saves the content of the /@buffer@/ into a file, a
--    trailing newline is added to the file.
-- 
-- On the other hand, if /@implicitTrailingNewline@/ is 'P.False', the file\'s
-- content is not modified when loaded into the /@buffer@/, and the /@buffer@/\'s
-- content is not modified when saved into a file.
-- 
-- /Since: 3.14/
bufferSetImplicitTrailingNewline ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Bool
    -- ^ /@implicitTrailingNewline@/: the new value.
    -> m ()
bufferSetImplicitTrailingNewline :: a -> Bool -> m ()
bufferSetImplicitTrailingNewline buffer :: a
buffer implicitTrailingNewline :: Bool
implicitTrailingNewline = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    let implicitTrailingNewline' :: CInt
implicitTrailingNewline' = (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
implicitTrailingNewline
    Ptr Buffer -> CInt -> IO ()
gtk_source_buffer_set_implicit_trailing_newline Ptr Buffer
buffer' CInt
implicitTrailingNewline'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetImplicitTrailingNewlineMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetImplicitTrailingNewlineMethodInfo a signature where
    overloadedMethod = bufferSetImplicitTrailingNewline

#endif

-- method Buffer::set_language
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "language"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Language" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceLanguage to set, 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_buffer_set_language" gtk_source_buffer_set_language :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr GtkSource.Language.Language ->      -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO ()

-- | Associates a t'GI.GtkSource.Objects.Language.Language' with the buffer.
-- 
-- Note that a t'GI.GtkSource.Objects.Language.Language' affects not only the syntax highlighting, but
-- also the [context classes][context-classes]. If you want to disable just the
-- syntax highlighting, see 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax'.
-- 
-- The buffer holds a reference to /@language@/.
bufferSetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Maybe (b)
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language' to set, or 'P.Nothing'.
    -> m ()
bufferSetLanguage :: a -> Maybe b -> m ()
bufferSetLanguage buffer :: a
buffer language :: Maybe b
language = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Language
maybeLanguage <- case Maybe b
language of
        Nothing -> Ptr Language -> IO (Ptr Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Language
forall a. Ptr a
nullPtr
        Just jLanguage :: b
jLanguage -> do
            Ptr Language
jLanguage' <- b -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jLanguage
            Ptr Language -> IO (Ptr Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Language
jLanguage'
    Ptr Buffer -> Ptr Language -> IO ()
gtk_source_buffer_set_language Ptr Buffer
buffer' Ptr Language
maybeLanguage
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
language b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetLanguageMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) => O.MethodInfo BufferSetLanguageMethodInfo a signature where
    overloadedMethod = bufferSetLanguage

#endif

-- method Buffer::set_max_undo_levels
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_undo_levels"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the desired maximum number of undo levels."
--                 , 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_buffer_set_max_undo_levels" gtk_source_buffer_set_max_undo_levels :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Int32 ->                                -- max_undo_levels : TBasicType TInt
    IO ()

-- | Sets the number of undo levels for user actions the buffer will
-- track.  If the number of user actions exceeds the limit set by this
-- function, older actions will be discarded.
-- 
-- If /@maxUndoLevels@/ is -1, the undo\/redo is unlimited.
-- 
-- If /@maxUndoLevels@/ is 0, the undo\/redo is disabled.
bufferSetMaxUndoLevels ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Int32
    -- ^ /@maxUndoLevels@/: the desired maximum number of undo levels.
    -> m ()
bufferSetMaxUndoLevels :: a -> Int32 -> m ()
bufferSetMaxUndoLevels buffer :: a
buffer maxUndoLevels :: Int32
maxUndoLevels = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Buffer -> Int32 -> IO ()
gtk_source_buffer_set_max_undo_levels Ptr Buffer
buffer' Int32
maxUndoLevels
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetMaxUndoLevelsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetMaxUndoLevelsMethodInfo a signature where
    overloadedMethod = bufferSetMaxUndoLevels

#endif

-- method Buffer::set_style_scheme
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scheme"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "StyleScheme" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceStyleScheme 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_buffer_set_style_scheme" gtk_source_buffer_set_style_scheme :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr GtkSource.StyleScheme.StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})
    IO ()

-- | Sets a t'GI.GtkSource.Objects.StyleScheme.StyleScheme' to be used by the buffer and the view.
-- 
-- Note that a t'GI.GtkSource.Objects.StyleScheme.StyleScheme' affects not only the syntax highlighting,
-- but also other t'GI.GtkSource.Objects.View.View' features such as highlighting the current line,
-- matching brackets, the line numbers, etc.
-- 
-- Instead of setting a 'P.Nothing' /@scheme@/, it is better to disable syntax
-- highlighting with 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax', and setting the
-- t'GI.GtkSource.Objects.StyleScheme.StyleScheme' with the \"classic\" or \"tango\" ID, because those two
-- style schemes follow more closely the GTK+ theme (for example for the
-- background color).
-- 
-- The buffer holds a reference to /@scheme@/.
bufferSetStyleScheme ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Maybe (b)
    -- ^ /@scheme@/: a t'GI.GtkSource.Objects.StyleScheme.StyleScheme' or 'P.Nothing'.
    -> m ()
bufferSetStyleScheme :: a -> Maybe b -> m ()
bufferSetStyleScheme buffer :: a
buffer scheme :: Maybe b
scheme = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr StyleScheme
maybeScheme <- case Maybe b
scheme of
        Nothing -> Ptr StyleScheme -> IO (Ptr StyleScheme)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr StyleScheme
forall a. Ptr a
nullPtr
        Just jScheme :: b
jScheme -> do
            Ptr StyleScheme
jScheme' <- b -> IO (Ptr StyleScheme)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jScheme
            Ptr StyleScheme -> IO (Ptr StyleScheme)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr StyleScheme
jScheme'
    Ptr Buffer -> Ptr StyleScheme -> IO ()
gtk_source_buffer_set_style_scheme Ptr Buffer
buffer' Ptr StyleScheme
maybeScheme
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
scheme b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetStyleSchemeMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) => O.MethodInfo BufferSetStyleSchemeMethodInfo a signature where
    overloadedMethod = bufferSetStyleScheme

#endif

-- method Buffer::set_undo_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "manager"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "UndoManager" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkSourceUndoManager 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_buffer_set_undo_manager" gtk_source_buffer_set_undo_manager :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr GtkSource.UndoManager.UndoManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})
    IO ()

-- | Set the buffer undo manager. If /@manager@/ is 'P.Nothing' the default undo manager
-- will be set.
bufferSetUndoManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Maybe (b)
    -- ^ /@manager@/: A t'GI.GtkSource.Interfaces.UndoManager.UndoManager' or 'P.Nothing'.
    -> m ()
bufferSetUndoManager :: a -> Maybe b -> m ()
bufferSetUndoManager buffer :: a
buffer manager :: Maybe b
manager = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr UndoManager
maybeManager <- case Maybe b
manager of
        Nothing -> Ptr UndoManager -> IO (Ptr UndoManager)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr UndoManager
forall a. Ptr a
nullPtr
        Just jManager :: b
jManager -> do
            Ptr UndoManager
jManager' <- b -> IO (Ptr UndoManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jManager
            Ptr UndoManager -> IO (Ptr UndoManager)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr UndoManager
jManager'
    Ptr Buffer -> Ptr UndoManager -> IO ()
gtk_source_buffer_set_undo_manager Ptr Buffer
buffer' Ptr UndoManager
maybeManager
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
manager b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferSetUndoManagerMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) => O.MethodInfo BufferSetUndoManagerMethodInfo a signature where
    overloadedMethod = bufferSetUndoManager

#endif

-- method Buffer::sort_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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 = "flags"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "SortFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "#GtkSourceSortFlags specifying how the sort should behave"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "sort considering the text starting at the given column"
--                 , 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_buffer_sort_lines" gtk_source_buffer_sort_lines :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GtkSource", name = "SortFlags"})
    Int32 ->                                -- column : TBasicType TInt
    IO ()

-- | Sort the lines of text between the specified iterators.
-- 
-- /Since: 3.18/
bufferSortLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> [GtkSource.Flags.SortFlags]
    -- ^ /@flags@/: t'GI.GtkSource.Flags.SortFlags' specifying how the sort should behave
    -> Int32
    -- ^ /@column@/: sort considering the text starting at the given column
    -> m ()
bufferSortLines :: a -> TextIter -> TextIter -> [SortFlags] -> Int32 -> m ()
bufferSortLines buffer :: a
buffer start :: TextIter
start end :: TextIter
end flags :: [SortFlags]
flags column :: Int32
column = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    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 flags' :: CUInt
flags' = [SortFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SortFlags]
flags
    Ptr Buffer
-> Ptr TextIter -> Ptr TextIter -> CUInt -> Int32 -> IO ()
gtk_source_buffer_sort_lines Ptr Buffer
buffer' Ptr TextIter
start' Ptr TextIter
end' CUInt
flags' Int32
column
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    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 BufferSortLinesMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.SortFlags] -> Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSortLinesMethodInfo a signature where
    overloadedMethod = bufferSortLines

#endif

-- method Buffer::undo
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , 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_buffer_undo" gtk_source_buffer_undo :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO ()

-- | Undoes the last user action which modified the buffer.  Use
-- 'GI.GtkSource.Objects.Buffer.bufferCanUndo' to check whether a call to this
-- function will have any effect.
-- 
-- This function emits the [undo]("GI.GtkSource.Objects.Buffer#signal:undo") signal.
bufferUndo ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m ()
bufferUndo :: a -> m ()
bufferUndo buffer :: a
buffer = 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 Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Buffer -> IO ()
gtk_source_buffer_undo Ptr Buffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BufferUndoMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferUndoMethodInfo a signature where
    overloadedMethod = bufferUndo

#endif