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

You may wish to begin by reading the
[text widget conceptual overview][TextWidget]
which gives an overview of all the objects and data
types related to the text widget and how they work together.
-}

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

module GI.Gtk.Objects.TextBuffer
    (

-- * Exported types
    TextBuffer(..)                          ,
    IsTextBuffer                            ,
    toTextBuffer                            ,
    noTextBuffer                            ,


 -- * Methods
-- ** addMark #method:addMark#

#if ENABLE_OVERLOADING
    TextBufferAddMarkMethodInfo             ,
#endif
    textBufferAddMark                       ,


-- ** addSelectionClipboard #method:addSelectionClipboard#

#if ENABLE_OVERLOADING
    TextBufferAddSelectionClipboardMethodInfo,
#endif
    textBufferAddSelectionClipboard         ,


-- ** applyTag #method:applyTag#

#if ENABLE_OVERLOADING
    TextBufferApplyTagMethodInfo            ,
#endif
    textBufferApplyTag                      ,


-- ** applyTagByName #method:applyTagByName#

#if ENABLE_OVERLOADING
    TextBufferApplyTagByNameMethodInfo      ,
#endif
    textBufferApplyTagByName                ,


-- ** backspace #method:backspace#

#if ENABLE_OVERLOADING
    TextBufferBackspaceMethodInfo           ,
#endif
    textBufferBackspace                     ,


-- ** beginUserAction #method:beginUserAction#

#if ENABLE_OVERLOADING
    TextBufferBeginUserActionMethodInfo     ,
#endif
    textBufferBeginUserAction               ,


-- ** copyClipboard #method:copyClipboard#

#if ENABLE_OVERLOADING
    TextBufferCopyClipboardMethodInfo       ,
#endif
    textBufferCopyClipboard                 ,


-- ** createChildAnchor #method:createChildAnchor#

#if ENABLE_OVERLOADING
    TextBufferCreateChildAnchorMethodInfo   ,
#endif
    textBufferCreateChildAnchor             ,


-- ** createMark #method:createMark#

#if ENABLE_OVERLOADING
    TextBufferCreateMarkMethodInfo          ,
#endif
    textBufferCreateMark                    ,


-- ** cutClipboard #method:cutClipboard#

#if ENABLE_OVERLOADING
    TextBufferCutClipboardMethodInfo        ,
#endif
    textBufferCutClipboard                  ,


-- ** delete #method:delete#

#if ENABLE_OVERLOADING
    TextBufferDeleteMethodInfo              ,
#endif
    textBufferDelete                        ,


-- ** deleteInteractive #method:deleteInteractive#

#if ENABLE_OVERLOADING
    TextBufferDeleteInteractiveMethodInfo   ,
#endif
    textBufferDeleteInteractive             ,


-- ** deleteMark #method:deleteMark#

#if ENABLE_OVERLOADING
    TextBufferDeleteMarkMethodInfo          ,
#endif
    textBufferDeleteMark                    ,


-- ** deleteMarkByName #method:deleteMarkByName#

#if ENABLE_OVERLOADING
    TextBufferDeleteMarkByNameMethodInfo    ,
#endif
    textBufferDeleteMarkByName              ,


-- ** deleteSelection #method:deleteSelection#

#if ENABLE_OVERLOADING
    TextBufferDeleteSelectionMethodInfo     ,
#endif
    textBufferDeleteSelection               ,


-- ** deserialize #method:deserialize#

#if ENABLE_OVERLOADING
    TextBufferDeserializeMethodInfo         ,
#endif
    textBufferDeserialize                   ,


-- ** deserializeGetCanCreateTags #method:deserializeGetCanCreateTags#

#if ENABLE_OVERLOADING
    TextBufferDeserializeGetCanCreateTagsMethodInfo,
#endif
    textBufferDeserializeGetCanCreateTags   ,


-- ** deserializeSetCanCreateTags #method:deserializeSetCanCreateTags#

#if ENABLE_OVERLOADING
    TextBufferDeserializeSetCanCreateTagsMethodInfo,
#endif
    textBufferDeserializeSetCanCreateTags   ,


-- ** endUserAction #method:endUserAction#

#if ENABLE_OVERLOADING
    TextBufferEndUserActionMethodInfo       ,
#endif
    textBufferEndUserAction                 ,


-- ** getBounds #method:getBounds#

#if ENABLE_OVERLOADING
    TextBufferGetBoundsMethodInfo           ,
#endif
    textBufferGetBounds                     ,


-- ** getCharCount #method:getCharCount#

#if ENABLE_OVERLOADING
    TextBufferGetCharCountMethodInfo        ,
#endif
    textBufferGetCharCount                  ,


-- ** getCopyTargetList #method:getCopyTargetList#

#if ENABLE_OVERLOADING
    TextBufferGetCopyTargetListMethodInfo   ,
#endif
    textBufferGetCopyTargetList             ,


-- ** getDeserializeFormats #method:getDeserializeFormats#

#if ENABLE_OVERLOADING
    TextBufferGetDeserializeFormatsMethodInfo,
#endif
    textBufferGetDeserializeFormats         ,


-- ** getEndIter #method:getEndIter#

#if ENABLE_OVERLOADING
    TextBufferGetEndIterMethodInfo          ,
#endif
    textBufferGetEndIter                    ,


-- ** getHasSelection #method:getHasSelection#

#if ENABLE_OVERLOADING
    TextBufferGetHasSelectionMethodInfo     ,
#endif
    textBufferGetHasSelection               ,


-- ** getInsert #method:getInsert#

#if ENABLE_OVERLOADING
    TextBufferGetInsertMethodInfo           ,
#endif
    textBufferGetInsert                     ,


-- ** getIterAtChildAnchor #method:getIterAtChildAnchor#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtChildAnchorMethodInfo,
#endif
    textBufferGetIterAtChildAnchor          ,


-- ** getIterAtLine #method:getIterAtLine#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtLineMethodInfo       ,
#endif
    textBufferGetIterAtLine                 ,


-- ** getIterAtLineIndex #method:getIterAtLineIndex#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtLineIndexMethodInfo  ,
#endif
    textBufferGetIterAtLineIndex            ,


-- ** getIterAtLineOffset #method:getIterAtLineOffset#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtLineOffsetMethodInfo ,
#endif
    textBufferGetIterAtLineOffset           ,


-- ** getIterAtMark #method:getIterAtMark#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtMarkMethodInfo       ,
#endif
    textBufferGetIterAtMark                 ,


-- ** getIterAtOffset #method:getIterAtOffset#

#if ENABLE_OVERLOADING
    TextBufferGetIterAtOffsetMethodInfo     ,
#endif
    textBufferGetIterAtOffset               ,


-- ** getLineCount #method:getLineCount#

#if ENABLE_OVERLOADING
    TextBufferGetLineCountMethodInfo        ,
#endif
    textBufferGetLineCount                  ,


-- ** getMark #method:getMark#

#if ENABLE_OVERLOADING
    TextBufferGetMarkMethodInfo             ,
#endif
    textBufferGetMark                       ,


-- ** getModified #method:getModified#

#if ENABLE_OVERLOADING
    TextBufferGetModifiedMethodInfo         ,
#endif
    textBufferGetModified                   ,


-- ** getPasteTargetList #method:getPasteTargetList#

#if ENABLE_OVERLOADING
    TextBufferGetPasteTargetListMethodInfo  ,
#endif
    textBufferGetPasteTargetList            ,


-- ** getSelectionBound #method:getSelectionBound#

#if ENABLE_OVERLOADING
    TextBufferGetSelectionBoundMethodInfo   ,
#endif
    textBufferGetSelectionBound             ,


-- ** getSelectionBounds #method:getSelectionBounds#

#if ENABLE_OVERLOADING
    TextBufferGetSelectionBoundsMethodInfo  ,
#endif
    textBufferGetSelectionBounds            ,


-- ** getSerializeFormats #method:getSerializeFormats#

#if ENABLE_OVERLOADING
    TextBufferGetSerializeFormatsMethodInfo ,
#endif
    textBufferGetSerializeFormats           ,


-- ** getSlice #method:getSlice#

#if ENABLE_OVERLOADING
    TextBufferGetSliceMethodInfo            ,
#endif
    textBufferGetSlice                      ,


-- ** getStartIter #method:getStartIter#

#if ENABLE_OVERLOADING
    TextBufferGetStartIterMethodInfo        ,
#endif
    textBufferGetStartIter                  ,


-- ** getTagTable #method:getTagTable#

#if ENABLE_OVERLOADING
    TextBufferGetTagTableMethodInfo         ,
#endif
    textBufferGetTagTable                   ,


-- ** getText #method:getText#

#if ENABLE_OVERLOADING
    TextBufferGetTextMethodInfo             ,
#endif
    textBufferGetText                       ,


-- ** insert #method:insert#

#if ENABLE_OVERLOADING
    TextBufferInsertMethodInfo              ,
#endif
    textBufferInsert                        ,


-- ** insertAtCursor #method:insertAtCursor#

#if ENABLE_OVERLOADING
    TextBufferInsertAtCursorMethodInfo      ,
#endif
    textBufferInsertAtCursor                ,


-- ** insertChildAnchor #method:insertChildAnchor#

#if ENABLE_OVERLOADING
    TextBufferInsertChildAnchorMethodInfo   ,
#endif
    textBufferInsertChildAnchor             ,


-- ** insertInteractive #method:insertInteractive#

#if ENABLE_OVERLOADING
    TextBufferInsertInteractiveMethodInfo   ,
#endif
    textBufferInsertInteractive             ,


-- ** insertInteractiveAtCursor #method:insertInteractiveAtCursor#

#if ENABLE_OVERLOADING
    TextBufferInsertInteractiveAtCursorMethodInfo,
#endif
    textBufferInsertInteractiveAtCursor     ,


-- ** insertMarkup #method:insertMarkup#

#if ENABLE_OVERLOADING
    TextBufferInsertMarkupMethodInfo        ,
#endif
    textBufferInsertMarkup                  ,


-- ** insertPixbuf #method:insertPixbuf#

#if ENABLE_OVERLOADING
    TextBufferInsertPixbufMethodInfo        ,
#endif
    textBufferInsertPixbuf                  ,


-- ** insertRange #method:insertRange#

#if ENABLE_OVERLOADING
    TextBufferInsertRangeMethodInfo         ,
#endif
    textBufferInsertRange                   ,


-- ** insertRangeInteractive #method:insertRangeInteractive#

#if ENABLE_OVERLOADING
    TextBufferInsertRangeInteractiveMethodInfo,
#endif
    textBufferInsertRangeInteractive        ,


-- ** moveMark #method:moveMark#

#if ENABLE_OVERLOADING
    TextBufferMoveMarkMethodInfo            ,
#endif
    textBufferMoveMark                      ,


-- ** moveMarkByName #method:moveMarkByName#

#if ENABLE_OVERLOADING
    TextBufferMoveMarkByNameMethodInfo      ,
#endif
    textBufferMoveMarkByName                ,


-- ** new #method:new#

    textBufferNew                           ,


-- ** pasteClipboard #method:pasteClipboard#

#if ENABLE_OVERLOADING
    TextBufferPasteClipboardMethodInfo      ,
#endif
    textBufferPasteClipboard                ,


-- ** placeCursor #method:placeCursor#

#if ENABLE_OVERLOADING
    TextBufferPlaceCursorMethodInfo         ,
#endif
    textBufferPlaceCursor                   ,


-- ** registerDeserializeFormat #method:registerDeserializeFormat#

#if ENABLE_OVERLOADING
    TextBufferRegisterDeserializeFormatMethodInfo,
#endif
    textBufferRegisterDeserializeFormat     ,


-- ** registerDeserializeTagset #method:registerDeserializeTagset#

#if ENABLE_OVERLOADING
    TextBufferRegisterDeserializeTagsetMethodInfo,
#endif
    textBufferRegisterDeserializeTagset     ,


-- ** registerSerializeFormat #method:registerSerializeFormat#

#if ENABLE_OVERLOADING
    TextBufferRegisterSerializeFormatMethodInfo,
#endif
    textBufferRegisterSerializeFormat       ,


-- ** registerSerializeTagset #method:registerSerializeTagset#

#if ENABLE_OVERLOADING
    TextBufferRegisterSerializeTagsetMethodInfo,
#endif
    textBufferRegisterSerializeTagset       ,


-- ** removeAllTags #method:removeAllTags#

#if ENABLE_OVERLOADING
    TextBufferRemoveAllTagsMethodInfo       ,
#endif
    textBufferRemoveAllTags                 ,


-- ** removeSelectionClipboard #method:removeSelectionClipboard#

#if ENABLE_OVERLOADING
    TextBufferRemoveSelectionClipboardMethodInfo,
#endif
    textBufferRemoveSelectionClipboard      ,


-- ** removeTag #method:removeTag#

#if ENABLE_OVERLOADING
    TextBufferRemoveTagMethodInfo           ,
#endif
    textBufferRemoveTag                     ,


-- ** removeTagByName #method:removeTagByName#

#if ENABLE_OVERLOADING
    TextBufferRemoveTagByNameMethodInfo     ,
#endif
    textBufferRemoveTagByName               ,


-- ** selectRange #method:selectRange#

#if ENABLE_OVERLOADING
    TextBufferSelectRangeMethodInfo         ,
#endif
    textBufferSelectRange                   ,


-- ** serialize #method:serialize#

#if ENABLE_OVERLOADING
    TextBufferSerializeMethodInfo           ,
#endif
    textBufferSerialize                     ,


-- ** setModified #method:setModified#

#if ENABLE_OVERLOADING
    TextBufferSetModifiedMethodInfo         ,
#endif
    textBufferSetModified                   ,


-- ** setText #method:setText#

#if ENABLE_OVERLOADING
    TextBufferSetTextMethodInfo             ,
#endif
    textBufferSetText                       ,


-- ** unregisterDeserializeFormat #method:unregisterDeserializeFormat#

#if ENABLE_OVERLOADING
    TextBufferUnregisterDeserializeFormatMethodInfo,
#endif
    textBufferUnregisterDeserializeFormat   ,


-- ** unregisterSerializeFormat #method:unregisterSerializeFormat#

#if ENABLE_OVERLOADING
    TextBufferUnregisterSerializeFormatMethodInfo,
#endif
    textBufferUnregisterSerializeFormat     ,




 -- * Properties
-- ** copyTargetList #attr:copyTargetList#
{- | The list of targets this buffer supports for clipboard copying
and as DND source.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    TextBufferCopyTargetListPropertyInfo    ,
#endif
    getTextBufferCopyTargetList             ,
#if ENABLE_OVERLOADING
    textBufferCopyTargetList                ,
#endif


-- ** cursorPosition #attr:cursorPosition#
{- | The position of the insert mark (as offset from the beginning
of the buffer). It is useful for getting notified when the
cursor moves.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    TextBufferCursorPositionPropertyInfo    ,
#endif
    getTextBufferCursorPosition             ,
#if ENABLE_OVERLOADING
    textBufferCursorPosition                ,
#endif


-- ** hasSelection #attr:hasSelection#
{- | Whether the buffer has some text currently selected.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    TextBufferHasSelectionPropertyInfo      ,
#endif
    getTextBufferHasSelection               ,
#if ENABLE_OVERLOADING
    textBufferHasSelection                  ,
#endif


-- ** pasteTargetList #attr:pasteTargetList#
{- | The list of targets this buffer supports for clipboard pasting
and as DND destination.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    TextBufferPasteTargetListPropertyInfo   ,
#endif
    getTextBufferPasteTargetList            ,
#if ENABLE_OVERLOADING
    textBufferPasteTargetList               ,
#endif


-- ** tagTable #attr:tagTable#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TextBufferTagTablePropertyInfo          ,
#endif
    constructTextBufferTagTable             ,
    getTextBufferTagTable                   ,
#if ENABLE_OVERLOADING
    textBufferTagTable                      ,
#endif


-- ** text #attr:text#
{- | The text content of the buffer. Without child widgets and images,
see 'GI.Gtk.Objects.TextBuffer.textBufferGetText' for more information.

/Since: 2.8/
-}
#if ENABLE_OVERLOADING
    TextBufferTextPropertyInfo              ,
#endif
    clearTextBufferText                     ,
    constructTextBufferText                 ,
    getTextBufferText                       ,
    setTextBufferText                       ,
#if ENABLE_OVERLOADING
    textBufferText                          ,
#endif




 -- * Signals
-- ** applyTag #signal:applyTag#

    C_TextBufferApplyTagCallback            ,
    TextBufferApplyTagCallback              ,
#if ENABLE_OVERLOADING
    TextBufferApplyTagSignalInfo            ,
#endif
    afterTextBufferApplyTag                 ,
    genClosure_TextBufferApplyTag           ,
    mk_TextBufferApplyTagCallback           ,
    noTextBufferApplyTagCallback            ,
    onTextBufferApplyTag                    ,
    wrap_TextBufferApplyTagCallback         ,


-- ** beginUserAction #signal:beginUserAction#

    C_TextBufferBeginUserActionCallback     ,
    TextBufferBeginUserActionCallback       ,
#if ENABLE_OVERLOADING
    TextBufferBeginUserActionSignalInfo     ,
#endif
    afterTextBufferBeginUserAction          ,
    genClosure_TextBufferBeginUserAction    ,
    mk_TextBufferBeginUserActionCallback    ,
    noTextBufferBeginUserActionCallback     ,
    onTextBufferBeginUserAction             ,
    wrap_TextBufferBeginUserActionCallback  ,


-- ** changed #signal:changed#

    C_TextBufferChangedCallback             ,
    TextBufferChangedCallback               ,
#if ENABLE_OVERLOADING
    TextBufferChangedSignalInfo             ,
#endif
    afterTextBufferChanged                  ,
    genClosure_TextBufferChanged            ,
    mk_TextBufferChangedCallback            ,
    noTextBufferChangedCallback             ,
    onTextBufferChanged                     ,
    wrap_TextBufferChangedCallback          ,


-- ** deleteRange #signal:deleteRange#

    C_TextBufferDeleteRangeCallback         ,
    TextBufferDeleteRangeCallback           ,
#if ENABLE_OVERLOADING
    TextBufferDeleteRangeSignalInfo         ,
#endif
    afterTextBufferDeleteRange              ,
    genClosure_TextBufferDeleteRange        ,
    mk_TextBufferDeleteRangeCallback        ,
    noTextBufferDeleteRangeCallback         ,
    onTextBufferDeleteRange                 ,
    wrap_TextBufferDeleteRangeCallback      ,


-- ** endUserAction #signal:endUserAction#

    C_TextBufferEndUserActionCallback       ,
    TextBufferEndUserActionCallback         ,
#if ENABLE_OVERLOADING
    TextBufferEndUserActionSignalInfo       ,
#endif
    afterTextBufferEndUserAction            ,
    genClosure_TextBufferEndUserAction      ,
    mk_TextBufferEndUserActionCallback      ,
    noTextBufferEndUserActionCallback       ,
    onTextBufferEndUserAction               ,
    wrap_TextBufferEndUserActionCallback    ,


-- ** insertChildAnchor #signal:insertChildAnchor#

    C_TextBufferInsertChildAnchorCallback   ,
    TextBufferInsertChildAnchorCallback     ,
#if ENABLE_OVERLOADING
    TextBufferInsertChildAnchorSignalInfo   ,
#endif
    afterTextBufferInsertChildAnchor        ,
    genClosure_TextBufferInsertChildAnchor  ,
    mk_TextBufferInsertChildAnchorCallback  ,
    noTextBufferInsertChildAnchorCallback   ,
    onTextBufferInsertChildAnchor           ,
    wrap_TextBufferInsertChildAnchorCallback,


-- ** insertPixbuf #signal:insertPixbuf#

    C_TextBufferInsertPixbufCallback        ,
    TextBufferInsertPixbufCallback          ,
#if ENABLE_OVERLOADING
    TextBufferInsertPixbufSignalInfo        ,
#endif
    afterTextBufferInsertPixbuf             ,
    genClosure_TextBufferInsertPixbuf       ,
    mk_TextBufferInsertPixbufCallback       ,
    noTextBufferInsertPixbufCallback        ,
    onTextBufferInsertPixbuf                ,
    wrap_TextBufferInsertPixbufCallback     ,


-- ** insertText #signal:insertText#

    C_TextBufferInsertTextCallback          ,
    TextBufferInsertTextCallback            ,
#if ENABLE_OVERLOADING
    TextBufferInsertTextSignalInfo          ,
#endif
    afterTextBufferInsertText               ,
    genClosure_TextBufferInsertText         ,
    mk_TextBufferInsertTextCallback         ,
    noTextBufferInsertTextCallback          ,
    onTextBufferInsertText                  ,
    wrap_TextBufferInsertTextCallback       ,


-- ** markDeleted #signal:markDeleted#

    C_TextBufferMarkDeletedCallback         ,
    TextBufferMarkDeletedCallback           ,
#if ENABLE_OVERLOADING
    TextBufferMarkDeletedSignalInfo         ,
#endif
    afterTextBufferMarkDeleted              ,
    genClosure_TextBufferMarkDeleted        ,
    mk_TextBufferMarkDeletedCallback        ,
    noTextBufferMarkDeletedCallback         ,
    onTextBufferMarkDeleted                 ,
    wrap_TextBufferMarkDeletedCallback      ,


-- ** markSet #signal:markSet#

    C_TextBufferMarkSetCallback             ,
    TextBufferMarkSetCallback               ,
#if ENABLE_OVERLOADING
    TextBufferMarkSetSignalInfo             ,
#endif
    afterTextBufferMarkSet                  ,
    genClosure_TextBufferMarkSet            ,
    mk_TextBufferMarkSetCallback            ,
    noTextBufferMarkSetCallback             ,
    onTextBufferMarkSet                     ,
    wrap_TextBufferMarkSetCallback          ,


-- ** modifiedChanged #signal:modifiedChanged#

    C_TextBufferModifiedChangedCallback     ,
    TextBufferModifiedChangedCallback       ,
#if ENABLE_OVERLOADING
    TextBufferModifiedChangedSignalInfo     ,
#endif
    afterTextBufferModifiedChanged          ,
    genClosure_TextBufferModifiedChanged    ,
    mk_TextBufferModifiedChangedCallback    ,
    noTextBufferModifiedChangedCallback     ,
    onTextBufferModifiedChanged             ,
    wrap_TextBufferModifiedChangedCallback  ,


-- ** pasteDone #signal:pasteDone#

    C_TextBufferPasteDoneCallback           ,
    TextBufferPasteDoneCallback             ,
#if ENABLE_OVERLOADING
    TextBufferPasteDoneSignalInfo           ,
#endif
    afterTextBufferPasteDone                ,
    genClosure_TextBufferPasteDone          ,
    mk_TextBufferPasteDoneCallback          ,
    noTextBufferPasteDoneCallback           ,
    onTextBufferPasteDone                   ,
    wrap_TextBufferPasteDoneCallback        ,


-- ** removeTag #signal:removeTag#

    C_TextBufferRemoveTagCallback           ,
    TextBufferRemoveTagCallback             ,
#if ENABLE_OVERLOADING
    TextBufferRemoveTagSignalInfo           ,
#endif
    afterTextBufferRemoveTag                ,
    genClosure_TextBufferRemoveTag          ,
    mk_TextBufferRemoveTagCallback          ,
    noTextBufferRemoveTagCallback           ,
    onTextBufferRemoveTag                   ,
    wrap_TextBufferRemoveTagCallback        ,




    ) 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Atom as Gdk.Atom
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Objects.Clipboard as Gtk.Clipboard
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextChildAnchor as Gtk.TextChildAnchor
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextMark as Gtk.TextMark
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextIter as Gtk.TextIter

-- | Memory-managed wrapper type.
newtype TextBuffer = TextBuffer (ManagedPtr TextBuffer)
foreign import ccall "gtk_text_buffer_get_type"
    c_gtk_text_buffer_get_type :: IO GType

instance GObject TextBuffer where
    gobjectType _ = c_gtk_text_buffer_get_type


-- | Type class for types which can be safely cast to `TextBuffer`, for instance with `toTextBuffer`.
class GObject o => IsTextBuffer o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError TextBuffer a) =>
    IsTextBuffer a
#endif
instance IsTextBuffer TextBuffer
instance GObject.Object.IsObject TextBuffer

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

-- | A convenience alias for `Nothing` :: `Maybe` `TextBuffer`.
noTextBuffer :: Maybe TextBuffer
noTextBuffer = Nothing

#if ENABLE_OVERLOADING
type family ResolveTextBufferMethod (t :: Symbol) (o :: *) :: * where
    ResolveTextBufferMethod "addMark" o = TextBufferAddMarkMethodInfo
    ResolveTextBufferMethod "addSelectionClipboard" o = TextBufferAddSelectionClipboardMethodInfo
    ResolveTextBufferMethod "applyTag" o = TextBufferApplyTagMethodInfo
    ResolveTextBufferMethod "applyTagByName" o = TextBufferApplyTagByNameMethodInfo
    ResolveTextBufferMethod "backspace" o = TextBufferBackspaceMethodInfo
    ResolveTextBufferMethod "beginUserAction" o = TextBufferBeginUserActionMethodInfo
    ResolveTextBufferMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTextBufferMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTextBufferMethod "copyClipboard" o = TextBufferCopyClipboardMethodInfo
    ResolveTextBufferMethod "createChildAnchor" o = TextBufferCreateChildAnchorMethodInfo
    ResolveTextBufferMethod "createMark" o = TextBufferCreateMarkMethodInfo
    ResolveTextBufferMethod "cutClipboard" o = TextBufferCutClipboardMethodInfo
    ResolveTextBufferMethod "delete" o = TextBufferDeleteMethodInfo
    ResolveTextBufferMethod "deleteInteractive" o = TextBufferDeleteInteractiveMethodInfo
    ResolveTextBufferMethod "deleteMark" o = TextBufferDeleteMarkMethodInfo
    ResolveTextBufferMethod "deleteMarkByName" o = TextBufferDeleteMarkByNameMethodInfo
    ResolveTextBufferMethod "deleteSelection" o = TextBufferDeleteSelectionMethodInfo
    ResolveTextBufferMethod "deserialize" o = TextBufferDeserializeMethodInfo
    ResolveTextBufferMethod "deserializeGetCanCreateTags" o = TextBufferDeserializeGetCanCreateTagsMethodInfo
    ResolveTextBufferMethod "deserializeSetCanCreateTags" o = TextBufferDeserializeSetCanCreateTagsMethodInfo
    ResolveTextBufferMethod "endUserAction" o = TextBufferEndUserActionMethodInfo
    ResolveTextBufferMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTextBufferMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTextBufferMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTextBufferMethod "insert" o = TextBufferInsertMethodInfo
    ResolveTextBufferMethod "insertAtCursor" o = TextBufferInsertAtCursorMethodInfo
    ResolveTextBufferMethod "insertChildAnchor" o = TextBufferInsertChildAnchorMethodInfo
    ResolveTextBufferMethod "insertInteractive" o = TextBufferInsertInteractiveMethodInfo
    ResolveTextBufferMethod "insertInteractiveAtCursor" o = TextBufferInsertInteractiveAtCursorMethodInfo
    ResolveTextBufferMethod "insertMarkup" o = TextBufferInsertMarkupMethodInfo
    ResolveTextBufferMethod "insertPixbuf" o = TextBufferInsertPixbufMethodInfo
    ResolveTextBufferMethod "insertRange" o = TextBufferInsertRangeMethodInfo
    ResolveTextBufferMethod "insertRangeInteractive" o = TextBufferInsertRangeInteractiveMethodInfo
    ResolveTextBufferMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTextBufferMethod "moveMark" o = TextBufferMoveMarkMethodInfo
    ResolveTextBufferMethod "moveMarkByName" o = TextBufferMoveMarkByNameMethodInfo
    ResolveTextBufferMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTextBufferMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTextBufferMethod "pasteClipboard" o = TextBufferPasteClipboardMethodInfo
    ResolveTextBufferMethod "placeCursor" o = TextBufferPlaceCursorMethodInfo
    ResolveTextBufferMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTextBufferMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTextBufferMethod "registerDeserializeFormat" o = TextBufferRegisterDeserializeFormatMethodInfo
    ResolveTextBufferMethod "registerDeserializeTagset" o = TextBufferRegisterDeserializeTagsetMethodInfo
    ResolveTextBufferMethod "registerSerializeFormat" o = TextBufferRegisterSerializeFormatMethodInfo
    ResolveTextBufferMethod "registerSerializeTagset" o = TextBufferRegisterSerializeTagsetMethodInfo
    ResolveTextBufferMethod "removeAllTags" o = TextBufferRemoveAllTagsMethodInfo
    ResolveTextBufferMethod "removeSelectionClipboard" o = TextBufferRemoveSelectionClipboardMethodInfo
    ResolveTextBufferMethod "removeTag" o = TextBufferRemoveTagMethodInfo
    ResolveTextBufferMethod "removeTagByName" o = TextBufferRemoveTagByNameMethodInfo
    ResolveTextBufferMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTextBufferMethod "selectRange" o = TextBufferSelectRangeMethodInfo
    ResolveTextBufferMethod "serialize" o = TextBufferSerializeMethodInfo
    ResolveTextBufferMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTextBufferMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTextBufferMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTextBufferMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTextBufferMethod "unregisterDeserializeFormat" o = TextBufferUnregisterDeserializeFormatMethodInfo
    ResolveTextBufferMethod "unregisterSerializeFormat" o = TextBufferUnregisterSerializeFormatMethodInfo
    ResolveTextBufferMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTextBufferMethod "getBounds" o = TextBufferGetBoundsMethodInfo
    ResolveTextBufferMethod "getCharCount" o = TextBufferGetCharCountMethodInfo
    ResolveTextBufferMethod "getCopyTargetList" o = TextBufferGetCopyTargetListMethodInfo
    ResolveTextBufferMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTextBufferMethod "getDeserializeFormats" o = TextBufferGetDeserializeFormatsMethodInfo
    ResolveTextBufferMethod "getEndIter" o = TextBufferGetEndIterMethodInfo
    ResolveTextBufferMethod "getHasSelection" o = TextBufferGetHasSelectionMethodInfo
    ResolveTextBufferMethod "getInsert" o = TextBufferGetInsertMethodInfo
    ResolveTextBufferMethod "getIterAtChildAnchor" o = TextBufferGetIterAtChildAnchorMethodInfo
    ResolveTextBufferMethod "getIterAtLine" o = TextBufferGetIterAtLineMethodInfo
    ResolveTextBufferMethod "getIterAtLineIndex" o = TextBufferGetIterAtLineIndexMethodInfo
    ResolveTextBufferMethod "getIterAtLineOffset" o = TextBufferGetIterAtLineOffsetMethodInfo
    ResolveTextBufferMethod "getIterAtMark" o = TextBufferGetIterAtMarkMethodInfo
    ResolveTextBufferMethod "getIterAtOffset" o = TextBufferGetIterAtOffsetMethodInfo
    ResolveTextBufferMethod "getLineCount" o = TextBufferGetLineCountMethodInfo
    ResolveTextBufferMethod "getMark" o = TextBufferGetMarkMethodInfo
    ResolveTextBufferMethod "getModified" o = TextBufferGetModifiedMethodInfo
    ResolveTextBufferMethod "getPasteTargetList" o = TextBufferGetPasteTargetListMethodInfo
    ResolveTextBufferMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTextBufferMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTextBufferMethod "getSelectionBound" o = TextBufferGetSelectionBoundMethodInfo
    ResolveTextBufferMethod "getSelectionBounds" o = TextBufferGetSelectionBoundsMethodInfo
    ResolveTextBufferMethod "getSerializeFormats" o = TextBufferGetSerializeFormatsMethodInfo
    ResolveTextBufferMethod "getSlice" o = TextBufferGetSliceMethodInfo
    ResolveTextBufferMethod "getStartIter" o = TextBufferGetStartIterMethodInfo
    ResolveTextBufferMethod "getTagTable" o = TextBufferGetTagTableMethodInfo
    ResolveTextBufferMethod "getText" o = TextBufferGetTextMethodInfo
    ResolveTextBufferMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTextBufferMethod "setModified" o = TextBufferSetModifiedMethodInfo
    ResolveTextBufferMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTextBufferMethod "setText" o = TextBufferSetTextMethodInfo
    ResolveTextBufferMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTextBufferMethod t TextBuffer, O.MethodInfo info TextBuffer p) => O.IsLabelProxy t (TextBuffer -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif

-- signal TextBuffer::apply-tag
{- |
The ::apply-tag signal is emitted to apply a tag to a
range of text in a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.
Applying actually occurs in the default handler.

Note that if your handler runs before the default handler it must not
invalidate the /@start@/ and /@end@/ iters (or has to revalidate them).

See also:
'GI.Gtk.Objects.TextBuffer.textBufferApplyTag',
@/gtk_text_buffer_insert_with_tags()/@,
'GI.Gtk.Objects.TextBuffer.textBufferInsertRange'.
-}
type TextBufferApplyTagCallback =
    Gtk.TextTag.TextTag
    {- ^ /@tag@/: the applied tag -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: the start of the range the tag is applied to -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: the end of the range the tag is applied to -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferApplyTagCallback`@.
noTextBufferApplyTagCallback :: Maybe TextBufferApplyTagCallback
noTextBufferApplyTagCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferApplyTag :: TextBufferApplyTagCallback -> IO Closure
genClosure_TextBufferApplyTag cb = do
    let cb' = wrap_TextBufferApplyTagCallback cb
    mk_TextBufferApplyTagCallback cb' >>= newCClosure


-- | Wrap a `TextBufferApplyTagCallback` into a `C_TextBufferApplyTagCallback`.
wrap_TextBufferApplyTagCallback ::
    TextBufferApplyTagCallback ->
    C_TextBufferApplyTagCallback
wrap_TextBufferApplyTagCallback _cb _ tag start end _ = do
    tag' <- (newObject Gtk.TextTag.TextTag) tag
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do
        B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do
            _cb  tag' start' end'


{- |
Connect a signal handler for the “@apply-tag@” 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' textBuffer #applyTag callback
@
-}
onTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> TextBufferApplyTagCallback -> m SignalHandlerId
onTextBufferApplyTag obj cb = liftIO $ do
    let cb' = wrap_TextBufferApplyTagCallback cb
    cb'' <- mk_TextBufferApplyTagCallback cb'
    connectSignalFunPtr obj "apply-tag" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@apply-tag@” 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' textBuffer #applyTag callback
@
-}
afterTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> TextBufferApplyTagCallback -> m SignalHandlerId
afterTextBufferApplyTag obj cb = liftIO $ do
    let cb' = wrap_TextBufferApplyTagCallback cb
    cb'' <- mk_TextBufferApplyTagCallback cb'
    connectSignalFunPtr obj "apply-tag" cb'' SignalConnectAfter


-- signal TextBuffer::begin-user-action
{- |
The ::begin-user-action signal is emitted at the beginning of a single
user-visible operation on a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferBeginUserAction',
'GI.Gtk.Objects.TextBuffer.textBufferInsertInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferInsertRangeInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferDeleteInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferBackspace',
'GI.Gtk.Objects.TextBuffer.textBufferDeleteSelection'.
-}
type TextBufferBeginUserActionCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferBeginUserActionCallback`@.
noTextBufferBeginUserActionCallback :: Maybe TextBufferBeginUserActionCallback
noTextBufferBeginUserActionCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferBeginUserAction :: TextBufferBeginUserActionCallback -> IO Closure
genClosure_TextBufferBeginUserAction cb = do
    let cb' = wrap_TextBufferBeginUserActionCallback cb
    mk_TextBufferBeginUserActionCallback cb' >>= newCClosure


-- | Wrap a `TextBufferBeginUserActionCallback` into a `C_TextBufferBeginUserActionCallback`.
wrap_TextBufferBeginUserActionCallback ::
    TextBufferBeginUserActionCallback ->
    C_TextBufferBeginUserActionCallback
wrap_TextBufferBeginUserActionCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@begin-user-action@” 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' textBuffer #beginUserAction callback
@
-}
onTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> TextBufferBeginUserActionCallback -> m SignalHandlerId
onTextBufferBeginUserAction obj cb = liftIO $ do
    let cb' = wrap_TextBufferBeginUserActionCallback cb
    cb'' <- mk_TextBufferBeginUserActionCallback cb'
    connectSignalFunPtr obj "begin-user-action" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@begin-user-action@” 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' textBuffer #beginUserAction callback
@
-}
afterTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> TextBufferBeginUserActionCallback -> m SignalHandlerId
afterTextBufferBeginUserAction obj cb = liftIO $ do
    let cb' = wrap_TextBufferBeginUserActionCallback cb
    cb'' <- mk_TextBufferBeginUserActionCallback cb'
    connectSignalFunPtr obj "begin-user-action" cb'' SignalConnectAfter


-- signal TextBuffer::changed
{- |
The ::changed signal is emitted when the content of a 'GI.Gtk.Objects.TextBuffer.TextBuffer'
has changed.
-}
type TextBufferChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferChangedCallback`@.
noTextBufferChangedCallback :: Maybe TextBufferChangedCallback
noTextBufferChangedCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferChanged :: TextBufferChangedCallback -> IO Closure
genClosure_TextBufferChanged cb = do
    let cb' = wrap_TextBufferChangedCallback cb
    mk_TextBufferChangedCallback cb' >>= newCClosure


-- | Wrap a `TextBufferChangedCallback` into a `C_TextBufferChangedCallback`.
wrap_TextBufferChangedCallback ::
    TextBufferChangedCallback ->
    C_TextBufferChangedCallback
wrap_TextBufferChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@changed@” 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' textBuffer #changed callback
@
-}
onTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> TextBufferChangedCallback -> m SignalHandlerId
onTextBufferChanged obj cb = liftIO $ do
    let cb' = wrap_TextBufferChangedCallback cb
    cb'' <- mk_TextBufferChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@changed@” 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' textBuffer #changed callback
@
-}
afterTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> TextBufferChangedCallback -> m SignalHandlerId
afterTextBufferChanged obj cb = liftIO $ do
    let cb' = wrap_TextBufferChangedCallback cb
    cb'' <- mk_TextBufferChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectAfter


-- signal TextBuffer::delete-range
{- |
The ::delete-range signal is emitted to delete a range
from a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.

Note that if your handler runs before the default handler it must not
invalidate the /@start@/ and /@end@/ iters (or has to revalidate them).
The default signal handler revalidates the /@start@/ and /@end@/ iters to
both point to the location where text was deleted. Handlers
which run after the default handler (see @/g_signal_connect_after()/@)
do not have access to the deleted text.

See also: 'GI.Gtk.Objects.TextBuffer.textBufferDelete'.
-}
type TextBufferDeleteRangeCallback =
    Gtk.TextIter.TextIter
    {- ^ /@start@/: the start of the range to be deleted -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: the end of the range to be deleted -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferDeleteRangeCallback`@.
noTextBufferDeleteRangeCallback :: Maybe TextBufferDeleteRangeCallback
noTextBufferDeleteRangeCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TextBufferDeleteRangeCallback =
    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_TextBufferDeleteRangeCallback`.
foreign import ccall "wrapper"
    mk_TextBufferDeleteRangeCallback :: C_TextBufferDeleteRangeCallback -> IO (FunPtr C_TextBufferDeleteRangeCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferDeleteRange :: TextBufferDeleteRangeCallback -> IO Closure
genClosure_TextBufferDeleteRange cb = do
    let cb' = wrap_TextBufferDeleteRangeCallback cb
    mk_TextBufferDeleteRangeCallback cb' >>= newCClosure


-- | Wrap a `TextBufferDeleteRangeCallback` into a `C_TextBufferDeleteRangeCallback`.
wrap_TextBufferDeleteRangeCallback ::
    TextBufferDeleteRangeCallback ->
    C_TextBufferDeleteRangeCallback
wrap_TextBufferDeleteRangeCallback _cb _ start end _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do
        B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do
            _cb  start' end'


{- |
Connect a signal handler for the “@delete-range@” 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' textBuffer #deleteRange callback
@
-}
onTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> TextBufferDeleteRangeCallback -> m SignalHandlerId
onTextBufferDeleteRange obj cb = liftIO $ do
    let cb' = wrap_TextBufferDeleteRangeCallback cb
    cb'' <- mk_TextBufferDeleteRangeCallback cb'
    connectSignalFunPtr obj "delete-range" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@delete-range@” 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' textBuffer #deleteRange callback
@
-}
afterTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> TextBufferDeleteRangeCallback -> m SignalHandlerId
afterTextBufferDeleteRange obj cb = liftIO $ do
    let cb' = wrap_TextBufferDeleteRangeCallback cb
    cb'' <- mk_TextBufferDeleteRangeCallback cb'
    connectSignalFunPtr obj "delete-range" cb'' SignalConnectAfter


-- signal TextBuffer::end-user-action
{- |
The ::end-user-action signal is emitted at the end of a single
user-visible operation on the 'GI.Gtk.Objects.TextBuffer.TextBuffer'.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferEndUserAction',
'GI.Gtk.Objects.TextBuffer.textBufferInsertInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferInsertRangeInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferDeleteInteractive',
'GI.Gtk.Objects.TextBuffer.textBufferBackspace',
'GI.Gtk.Objects.TextBuffer.textBufferDeleteSelection',
'GI.Gtk.Objects.TextBuffer.textBufferBackspace'.
-}
type TextBufferEndUserActionCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferEndUserActionCallback`@.
noTextBufferEndUserActionCallback :: Maybe TextBufferEndUserActionCallback
noTextBufferEndUserActionCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferEndUserAction :: TextBufferEndUserActionCallback -> IO Closure
genClosure_TextBufferEndUserAction cb = do
    let cb' = wrap_TextBufferEndUserActionCallback cb
    mk_TextBufferEndUserActionCallback cb' >>= newCClosure


-- | Wrap a `TextBufferEndUserActionCallback` into a `C_TextBufferEndUserActionCallback`.
wrap_TextBufferEndUserActionCallback ::
    TextBufferEndUserActionCallback ->
    C_TextBufferEndUserActionCallback
wrap_TextBufferEndUserActionCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@end-user-action@” 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' textBuffer #endUserAction callback
@
-}
onTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> TextBufferEndUserActionCallback -> m SignalHandlerId
onTextBufferEndUserAction obj cb = liftIO $ do
    let cb' = wrap_TextBufferEndUserActionCallback cb
    cb'' <- mk_TextBufferEndUserActionCallback cb'
    connectSignalFunPtr obj "end-user-action" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@end-user-action@” 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' textBuffer #endUserAction callback
@
-}
afterTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> TextBufferEndUserActionCallback -> m SignalHandlerId
afterTextBufferEndUserAction obj cb = liftIO $ do
    let cb' = wrap_TextBufferEndUserActionCallback cb
    cb'' <- mk_TextBufferEndUserActionCallback cb'
    connectSignalFunPtr obj "end-user-action" cb'' SignalConnectAfter


-- signal TextBuffer::insert-child-anchor
{- |
The ::insert-child-anchor signal is emitted to insert a
'GI.Gtk.Objects.TextChildAnchor.TextChildAnchor' in a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.
Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must
not invalidate the /@location@/ iter (or has to revalidate it).
The default signal handler revalidates it to be placed after the
inserted /@anchor@/.

See also: 'GI.Gtk.Objects.TextBuffer.textBufferInsertChildAnchor'.
-}
type TextBufferInsertChildAnchorCallback =
    Gtk.TextIter.TextIter
    {- ^ /@location@/: position to insert /@anchor@/ in /@textbuffer@/ -}
    -> Gtk.TextChildAnchor.TextChildAnchor
    {- ^ /@anchor@/: the 'GI.Gtk.Objects.TextChildAnchor.TextChildAnchor' to be inserted -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferInsertChildAnchorCallback`@.
noTextBufferInsertChildAnchorCallback :: Maybe TextBufferInsertChildAnchorCallback
noTextBufferInsertChildAnchorCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferInsertChildAnchor :: TextBufferInsertChildAnchorCallback -> IO Closure
genClosure_TextBufferInsertChildAnchor cb = do
    let cb' = wrap_TextBufferInsertChildAnchorCallback cb
    mk_TextBufferInsertChildAnchorCallback cb' >>= newCClosure


-- | Wrap a `TextBufferInsertChildAnchorCallback` into a `C_TextBufferInsertChildAnchorCallback`.
wrap_TextBufferInsertChildAnchorCallback ::
    TextBufferInsertChildAnchorCallback ->
    C_TextBufferInsertChildAnchorCallback
wrap_TextBufferInsertChildAnchorCallback _cb _ location anchor _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter location $ \location' -> do
        anchor' <- (newObject Gtk.TextChildAnchor.TextChildAnchor) anchor
        _cb  location' anchor'


{- |
Connect a signal handler for the “@insert-child-anchor@” 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' textBuffer #insertChildAnchor callback
@
-}
onTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertChildAnchorCallback -> m SignalHandlerId
onTextBufferInsertChildAnchor obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertChildAnchorCallback cb
    cb'' <- mk_TextBufferInsertChildAnchorCallback cb'
    connectSignalFunPtr obj "insert-child-anchor" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@insert-child-anchor@” 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' textBuffer #insertChildAnchor callback
@
-}
afterTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertChildAnchorCallback -> m SignalHandlerId
afterTextBufferInsertChildAnchor obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertChildAnchorCallback cb
    cb'' <- mk_TextBufferInsertChildAnchorCallback cb'
    connectSignalFunPtr obj "insert-child-anchor" cb'' SignalConnectAfter


-- signal TextBuffer::insert-pixbuf
{- |
The ::insert-pixbuf signal is emitted to insert a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'
in a 'GI.Gtk.Objects.TextBuffer.TextBuffer'. Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must not
invalidate the /@location@/ iter (or has to revalidate it).
The default signal handler revalidates it to be placed after the
inserted /@pixbuf@/.

See also: 'GI.Gtk.Objects.TextBuffer.textBufferInsertPixbuf'.
-}
type TextBufferInsertPixbufCallback =
    Gtk.TextIter.TextIter
    {- ^ /@location@/: position to insert /@pixbuf@/ in /@textbuffer@/ -}
    -> GdkPixbuf.Pixbuf.Pixbuf
    {- ^ /@pixbuf@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to be inserted -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferInsertPixbufCallback`@.
noTextBufferInsertPixbufCallback :: Maybe TextBufferInsertPixbufCallback
noTextBufferInsertPixbufCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferInsertPixbuf :: TextBufferInsertPixbufCallback -> IO Closure
genClosure_TextBufferInsertPixbuf cb = do
    let cb' = wrap_TextBufferInsertPixbufCallback cb
    mk_TextBufferInsertPixbufCallback cb' >>= newCClosure


-- | Wrap a `TextBufferInsertPixbufCallback` into a `C_TextBufferInsertPixbufCallback`.
wrap_TextBufferInsertPixbufCallback ::
    TextBufferInsertPixbufCallback ->
    C_TextBufferInsertPixbufCallback
wrap_TextBufferInsertPixbufCallback _cb _ location pixbuf _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter location $ \location' -> do
        pixbuf' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) pixbuf
        _cb  location' pixbuf'


{- |
Connect a signal handler for the “@insert-pixbuf@” 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' textBuffer #insertPixbuf callback
@
-}
onTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertPixbufCallback -> m SignalHandlerId
onTextBufferInsertPixbuf obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertPixbufCallback cb
    cb'' <- mk_TextBufferInsertPixbufCallback cb'
    connectSignalFunPtr obj "insert-pixbuf" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@insert-pixbuf@” 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' textBuffer #insertPixbuf callback
@
-}
afterTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertPixbufCallback -> m SignalHandlerId
afterTextBufferInsertPixbuf obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertPixbufCallback cb
    cb'' <- mk_TextBufferInsertPixbufCallback cb'
    connectSignalFunPtr obj "insert-pixbuf" cb'' SignalConnectAfter


-- signal TextBuffer::insert-text
{- |
The ::insert-text signal is emitted to insert text in a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.
Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must not
invalidate the /@location@/ iter (or has to revalidate it).
The default signal handler revalidates it to point to the end of the
inserted text.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferInsert',
'GI.Gtk.Objects.TextBuffer.textBufferInsertRange'.
-}
type TextBufferInsertTextCallback =
    Gtk.TextIter.TextIter
    {- ^ /@location@/: position to insert /@text@/ in /@textbuffer@/ -}
    -> T.Text
    {- ^ /@text@/: the UTF-8 text to be inserted -}
    -> Int32
    {- ^ /@len@/: length of the inserted text in bytes -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferInsertTextCallback`@.
noTextBufferInsertTextCallback :: Maybe TextBufferInsertTextCallback
noTextBufferInsertTextCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferInsertText :: TextBufferInsertTextCallback -> IO Closure
genClosure_TextBufferInsertText cb = do
    let cb' = wrap_TextBufferInsertTextCallback cb
    mk_TextBufferInsertTextCallback cb' >>= newCClosure


-- | Wrap a `TextBufferInsertTextCallback` into a `C_TextBufferInsertTextCallback`.
wrap_TextBufferInsertTextCallback ::
    TextBufferInsertTextCallback ->
    C_TextBufferInsertTextCallback
wrap_TextBufferInsertTextCallback _cb _ location text len _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter location $ \location' -> do
        text' <- cstringToText text
        _cb  location' text' len


{- |
Connect a signal handler for the “@insert-text@” 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' textBuffer #insertText callback
@
-}
onTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertTextCallback -> m SignalHandlerId
onTextBufferInsertText obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertTextCallback cb
    cb'' <- mk_TextBufferInsertTextCallback cb'
    connectSignalFunPtr obj "insert-text" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@insert-text@” 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' textBuffer #insertText callback
@
-}
afterTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> TextBufferInsertTextCallback -> m SignalHandlerId
afterTextBufferInsertText obj cb = liftIO $ do
    let cb' = wrap_TextBufferInsertTextCallback cb
    cb'' <- mk_TextBufferInsertTextCallback cb'
    connectSignalFunPtr obj "insert-text" cb'' SignalConnectAfter


-- signal TextBuffer::mark-deleted
{- |
The ::mark-deleted signal is emitted as notification
after a 'GI.Gtk.Objects.TextMark.TextMark' is deleted.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferDeleteMark'.
-}
type TextBufferMarkDeletedCallback =
    Gtk.TextMark.TextMark
    {- ^ /@mark@/: The mark that was deleted -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferMarkDeletedCallback`@.
noTextBufferMarkDeletedCallback :: Maybe TextBufferMarkDeletedCallback
noTextBufferMarkDeletedCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferMarkDeleted :: TextBufferMarkDeletedCallback -> IO Closure
genClosure_TextBufferMarkDeleted cb = do
    let cb' = wrap_TextBufferMarkDeletedCallback cb
    mk_TextBufferMarkDeletedCallback cb' >>= newCClosure


-- | Wrap a `TextBufferMarkDeletedCallback` into a `C_TextBufferMarkDeletedCallback`.
wrap_TextBufferMarkDeletedCallback ::
    TextBufferMarkDeletedCallback ->
    C_TextBufferMarkDeletedCallback
wrap_TextBufferMarkDeletedCallback _cb _ mark _ = do
    mark' <- (newObject Gtk.TextMark.TextMark) mark
    _cb  mark'


{- |
Connect a signal handler for the “@mark-deleted@” 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' textBuffer #markDeleted callback
@
-}
onTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> TextBufferMarkDeletedCallback -> m SignalHandlerId
onTextBufferMarkDeleted obj cb = liftIO $ do
    let cb' = wrap_TextBufferMarkDeletedCallback cb
    cb'' <- mk_TextBufferMarkDeletedCallback cb'
    connectSignalFunPtr obj "mark-deleted" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@mark-deleted@” 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' textBuffer #markDeleted callback
@
-}
afterTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> TextBufferMarkDeletedCallback -> m SignalHandlerId
afterTextBufferMarkDeleted obj cb = liftIO $ do
    let cb' = wrap_TextBufferMarkDeletedCallback cb
    cb'' <- mk_TextBufferMarkDeletedCallback cb'
    connectSignalFunPtr obj "mark-deleted" cb'' SignalConnectAfter


-- signal TextBuffer::mark-set
{- |
The ::mark-set signal is emitted as notification
after a 'GI.Gtk.Objects.TextMark.TextMark' is set.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferCreateMark',
'GI.Gtk.Objects.TextBuffer.textBufferMoveMark'.
-}
type TextBufferMarkSetCallback =
    Gtk.TextIter.TextIter
    {- ^ /@location@/: The location of /@mark@/ in /@textbuffer@/ -}
    -> Gtk.TextMark.TextMark
    {- ^ /@mark@/: The mark that is set -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferMarkSetCallback`@.
noTextBufferMarkSetCallback :: Maybe TextBufferMarkSetCallback
noTextBufferMarkSetCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferMarkSet :: TextBufferMarkSetCallback -> IO Closure
genClosure_TextBufferMarkSet cb = do
    let cb' = wrap_TextBufferMarkSetCallback cb
    mk_TextBufferMarkSetCallback cb' >>= newCClosure


-- | Wrap a `TextBufferMarkSetCallback` into a `C_TextBufferMarkSetCallback`.
wrap_TextBufferMarkSetCallback ::
    TextBufferMarkSetCallback ->
    C_TextBufferMarkSetCallback
wrap_TextBufferMarkSetCallback _cb _ location mark _ = do
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter location $ \location' -> do
        mark' <- (newObject Gtk.TextMark.TextMark) mark
        _cb  location' mark'


{- |
Connect a signal handler for the “@mark-set@” 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' textBuffer #markSet callback
@
-}
onTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> TextBufferMarkSetCallback -> m SignalHandlerId
onTextBufferMarkSet obj cb = liftIO $ do
    let cb' = wrap_TextBufferMarkSetCallback cb
    cb'' <- mk_TextBufferMarkSetCallback cb'
    connectSignalFunPtr obj "mark-set" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@mark-set@” 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' textBuffer #markSet callback
@
-}
afterTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> TextBufferMarkSetCallback -> m SignalHandlerId
afterTextBufferMarkSet obj cb = liftIO $ do
    let cb' = wrap_TextBufferMarkSetCallback cb
    cb'' <- mk_TextBufferMarkSetCallback cb'
    connectSignalFunPtr obj "mark-set" cb'' SignalConnectAfter


-- signal TextBuffer::modified-changed
{- |
The ::modified-changed signal is emitted when the modified bit of a
'GI.Gtk.Objects.TextBuffer.TextBuffer' flips.

See also:
'GI.Gtk.Objects.TextBuffer.textBufferSetModified'.
-}
type TextBufferModifiedChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferModifiedChangedCallback`@.
noTextBufferModifiedChangedCallback :: Maybe TextBufferModifiedChangedCallback
noTextBufferModifiedChangedCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferModifiedChanged :: TextBufferModifiedChangedCallback -> IO Closure
genClosure_TextBufferModifiedChanged cb = do
    let cb' = wrap_TextBufferModifiedChangedCallback cb
    mk_TextBufferModifiedChangedCallback cb' >>= newCClosure


-- | Wrap a `TextBufferModifiedChangedCallback` into a `C_TextBufferModifiedChangedCallback`.
wrap_TextBufferModifiedChangedCallback ::
    TextBufferModifiedChangedCallback ->
    C_TextBufferModifiedChangedCallback
wrap_TextBufferModifiedChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@modified-changed@” 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' textBuffer #modifiedChanged callback
@
-}
onTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> TextBufferModifiedChangedCallback -> m SignalHandlerId
onTextBufferModifiedChanged obj cb = liftIO $ do
    let cb' = wrap_TextBufferModifiedChangedCallback cb
    cb'' <- mk_TextBufferModifiedChangedCallback cb'
    connectSignalFunPtr obj "modified-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@modified-changed@” 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' textBuffer #modifiedChanged callback
@
-}
afterTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> TextBufferModifiedChangedCallback -> m SignalHandlerId
afterTextBufferModifiedChanged obj cb = liftIO $ do
    let cb' = wrap_TextBufferModifiedChangedCallback cb
    cb'' <- mk_TextBufferModifiedChangedCallback cb'
    connectSignalFunPtr obj "modified-changed" cb'' SignalConnectAfter


-- signal TextBuffer::paste-done
{- |
The paste-done signal is emitted after paste operation has been completed.
This is useful to properly scroll the view to the end of the pasted text.
See 'GI.Gtk.Objects.TextBuffer.textBufferPasteClipboard' for more details.

/Since: 2.16/
-}
type TextBufferPasteDoneCallback =
    Gtk.Clipboard.Clipboard
    {- ^ /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' pasted from -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferPasteDoneCallback`@.
noTextBufferPasteDoneCallback :: Maybe TextBufferPasteDoneCallback
noTextBufferPasteDoneCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferPasteDone :: TextBufferPasteDoneCallback -> IO Closure
genClosure_TextBufferPasteDone cb = do
    let cb' = wrap_TextBufferPasteDoneCallback cb
    mk_TextBufferPasteDoneCallback cb' >>= newCClosure


-- | Wrap a `TextBufferPasteDoneCallback` into a `C_TextBufferPasteDoneCallback`.
wrap_TextBufferPasteDoneCallback ::
    TextBufferPasteDoneCallback ->
    C_TextBufferPasteDoneCallback
wrap_TextBufferPasteDoneCallback _cb _ clipboard _ = do
    clipboard' <- (newObject Gtk.Clipboard.Clipboard) clipboard
    _cb  clipboard'


{- |
Connect a signal handler for the “@paste-done@” 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' textBuffer #pasteDone callback
@
-}
onTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> TextBufferPasteDoneCallback -> m SignalHandlerId
onTextBufferPasteDone obj cb = liftIO $ do
    let cb' = wrap_TextBufferPasteDoneCallback cb
    cb'' <- mk_TextBufferPasteDoneCallback cb'
    connectSignalFunPtr obj "paste-done" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@paste-done@” 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' textBuffer #pasteDone callback
@
-}
afterTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> TextBufferPasteDoneCallback -> m SignalHandlerId
afterTextBufferPasteDone obj cb = liftIO $ do
    let cb' = wrap_TextBufferPasteDoneCallback cb
    cb'' <- mk_TextBufferPasteDoneCallback cb'
    connectSignalFunPtr obj "paste-done" cb'' SignalConnectAfter


-- signal TextBuffer::remove-tag
{- |
The ::remove-tag signal is emitted to remove all occurrences of /@tag@/ from
a range of text in a 'GI.Gtk.Objects.TextBuffer.TextBuffer'.
Removal actually occurs in the default handler.

Note that if your handler runs before the default handler it must not
invalidate the /@start@/ and /@end@/ iters (or has to revalidate them).

See also:
'GI.Gtk.Objects.TextBuffer.textBufferRemoveTag'.
-}
type TextBufferRemoveTagCallback =
    Gtk.TextTag.TextTag
    {- ^ /@tag@/: the tag to be removed -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: the start of the range the tag is removed from -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: the end of the range the tag is removed from -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TextBufferRemoveTagCallback`@.
noTextBufferRemoveTagCallback :: Maybe TextBufferRemoveTagCallback
noTextBufferRemoveTagCallback = Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_TextBufferRemoveTag :: TextBufferRemoveTagCallback -> IO Closure
genClosure_TextBufferRemoveTag cb = do
    let cb' = wrap_TextBufferRemoveTagCallback cb
    mk_TextBufferRemoveTagCallback cb' >>= newCClosure


-- | Wrap a `TextBufferRemoveTagCallback` into a `C_TextBufferRemoveTagCallback`.
wrap_TextBufferRemoveTagCallback ::
    TextBufferRemoveTagCallback ->
    C_TextBufferRemoveTagCallback
wrap_TextBufferRemoveTagCallback _cb _ tag start end _ = do
    tag' <- (newObject Gtk.TextTag.TextTag) tag
    B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do
        B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do
            _cb  tag' start' end'


{- |
Connect a signal handler for the “@remove-tag@” 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' textBuffer #removeTag callback
@
-}
onTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> TextBufferRemoveTagCallback -> m SignalHandlerId
onTextBufferRemoveTag obj cb = liftIO $ do
    let cb' = wrap_TextBufferRemoveTagCallback cb
    cb'' <- mk_TextBufferRemoveTagCallback cb'
    connectSignalFunPtr obj "remove-tag" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@remove-tag@” 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' textBuffer #removeTag callback
@
-}
afterTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> TextBufferRemoveTagCallback -> m SignalHandlerId
afterTextBufferRemoveTag obj cb = liftIO $ do
    let cb' = wrap_TextBufferRemoveTagCallback cb
    cb'' <- mk_TextBufferRemoveTagCallback cb'
    connectSignalFunPtr obj "remove-tag" cb'' SignalConnectAfter


-- VVV Prop "copy-target-list"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TargetList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #copyTargetList
@
-}
getTextBufferCopyTargetList :: (MonadIO m, IsTextBuffer o) => o -> m Gtk.TargetList.TargetList
getTextBufferCopyTargetList obj = liftIO $ checkUnexpectedNothing "getTextBufferCopyTargetList" $ getObjectPropertyBoxed obj "copy-target-list" Gtk.TargetList.TargetList

#if ENABLE_OVERLOADING
data TextBufferCopyTargetListPropertyInfo
instance AttrInfo TextBufferCopyTargetListPropertyInfo where
    type AttrAllowedOps TextBufferCopyTargetListPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TextBufferCopyTargetListPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TextBufferCopyTargetListPropertyInfo = IsTextBuffer
    type AttrGetType TextBufferCopyTargetListPropertyInfo = Gtk.TargetList.TargetList
    type AttrLabel TextBufferCopyTargetListPropertyInfo = "copy-target-list"
    type AttrOrigin TextBufferCopyTargetListPropertyInfo = TextBuffer
    attrGet _ = getTextBufferCopyTargetList
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "cursor-position"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #cursorPosition
@
-}
getTextBufferCursorPosition :: (MonadIO m, IsTextBuffer o) => o -> m Int32
getTextBufferCursorPosition obj = liftIO $ getObjectPropertyInt32 obj "cursor-position"

#if ENABLE_OVERLOADING
data TextBufferCursorPositionPropertyInfo
instance AttrInfo TextBufferCursorPositionPropertyInfo where
    type AttrAllowedOps TextBufferCursorPositionPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TextBufferCursorPositionPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TextBufferCursorPositionPropertyInfo = IsTextBuffer
    type AttrGetType TextBufferCursorPositionPropertyInfo = Int32
    type AttrLabel TextBufferCursorPositionPropertyInfo = "cursor-position"
    type AttrOrigin TextBufferCursorPositionPropertyInfo = TextBuffer
    attrGet _ = getTextBufferCursorPosition
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "has-selection"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #hasSelection
@
-}
getTextBufferHasSelection :: (MonadIO m, IsTextBuffer o) => o -> m Bool
getTextBufferHasSelection obj = liftIO $ getObjectPropertyBool obj "has-selection"

#if ENABLE_OVERLOADING
data TextBufferHasSelectionPropertyInfo
instance AttrInfo TextBufferHasSelectionPropertyInfo where
    type AttrAllowedOps TextBufferHasSelectionPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TextBufferHasSelectionPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TextBufferHasSelectionPropertyInfo = IsTextBuffer
    type AttrGetType TextBufferHasSelectionPropertyInfo = Bool
    type AttrLabel TextBufferHasSelectionPropertyInfo = "has-selection"
    type AttrOrigin TextBufferHasSelectionPropertyInfo = TextBuffer
    attrGet _ = getTextBufferHasSelection
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "paste-target-list"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TargetList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #pasteTargetList
@
-}
getTextBufferPasteTargetList :: (MonadIO m, IsTextBuffer o) => o -> m Gtk.TargetList.TargetList
getTextBufferPasteTargetList obj = liftIO $ checkUnexpectedNothing "getTextBufferPasteTargetList" $ getObjectPropertyBoxed obj "paste-target-list" Gtk.TargetList.TargetList

#if ENABLE_OVERLOADING
data TextBufferPasteTargetListPropertyInfo
instance AttrInfo TextBufferPasteTargetListPropertyInfo where
    type AttrAllowedOps TextBufferPasteTargetListPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TextBufferPasteTargetListPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TextBufferPasteTargetListPropertyInfo = IsTextBuffer
    type AttrGetType TextBufferPasteTargetListPropertyInfo = Gtk.TargetList.TargetList
    type AttrLabel TextBufferPasteTargetListPropertyInfo = "paste-target-list"
    type AttrOrigin TextBufferPasteTargetListPropertyInfo = TextBuffer
    attrGet _ = getTextBufferPasteTargetList
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "tag-table"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextTagTable"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #tagTable
@
-}
getTextBufferTagTable :: (MonadIO m, IsTextBuffer o) => o -> m Gtk.TextTagTable.TextTagTable
getTextBufferTagTable obj = liftIO $ checkUnexpectedNothing "getTextBufferTagTable" $ getObjectPropertyObject obj "tag-table" Gtk.TextTagTable.TextTagTable

{- |
Construct a `GValueConstruct` with valid value for the “@tag-table@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTextBufferTagTable :: (IsTextBuffer o, Gtk.TextTagTable.IsTextTagTable a) => a -> IO (GValueConstruct o)
constructTextBufferTagTable val = constructObjectPropertyObject "tag-table" (Just val)

#if ENABLE_OVERLOADING
data TextBufferTagTablePropertyInfo
instance AttrInfo TextBufferTagTablePropertyInfo where
    type AttrAllowedOps TextBufferTagTablePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TextBufferTagTablePropertyInfo = Gtk.TextTagTable.IsTextTagTable
    type AttrBaseTypeConstraint TextBufferTagTablePropertyInfo = IsTextBuffer
    type AttrGetType TextBufferTagTablePropertyInfo = Gtk.TextTagTable.TextTagTable
    type AttrLabel TextBufferTagTablePropertyInfo = "tag-table"
    type AttrOrigin TextBufferTagTablePropertyInfo = TextBuffer
    attrGet _ = getTextBufferTagTable
    attrSet _ = undefined
    attrConstruct _ = constructTextBufferTagTable
    attrClear _ = undefined
#endif

-- VVV Prop "text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' textBuffer #text
@
-}
getTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m (Maybe T.Text)
getTextBufferText obj = liftIO $ getObjectPropertyString obj "text"

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

@
'Data.GI.Base.Attributes.set' textBuffer [ #text 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> T.Text -> m ()
setTextBufferText obj val = liftIO $ setObjectPropertyString obj "text" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTextBufferText :: (IsTextBuffer o) => T.Text -> IO (GValueConstruct o)
constructTextBufferText val = constructObjectPropertyString "text" (Just val)

{- |
Set the value of the “@text@” 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' #text
@
-}
clearTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m ()
clearTextBufferText obj = liftIO $ setObjectPropertyString obj "text" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data TextBufferTextPropertyInfo
instance AttrInfo TextBufferTextPropertyInfo where
    type AttrAllowedOps TextBufferTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TextBufferTextPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint TextBufferTextPropertyInfo = IsTextBuffer
    type AttrGetType TextBufferTextPropertyInfo = (Maybe T.Text)
    type AttrLabel TextBufferTextPropertyInfo = "text"
    type AttrOrigin TextBufferTextPropertyInfo = TextBuffer
    attrGet _ = getTextBufferText
    attrSet _ = setTextBufferText
    attrConstruct _ = constructTextBufferText
    attrClear _ = clearTextBufferText
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList TextBuffer
type instance O.AttributeList TextBuffer = TextBufferAttributeList
type TextBufferAttributeList = ('[ '("copyTargetList", TextBufferCopyTargetListPropertyInfo), '("cursorPosition", TextBufferCursorPositionPropertyInfo), '("hasSelection", TextBufferHasSelectionPropertyInfo), '("pasteTargetList", TextBufferPasteTargetListPropertyInfo), '("tagTable", TextBufferTagTablePropertyInfo), '("text", TextBufferTextPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
textBufferCopyTargetList :: AttrLabelProxy "copyTargetList"
textBufferCopyTargetList = AttrLabelProxy

textBufferCursorPosition :: AttrLabelProxy "cursorPosition"
textBufferCursorPosition = AttrLabelProxy

textBufferHasSelection :: AttrLabelProxy "hasSelection"
textBufferHasSelection = AttrLabelProxy

textBufferPasteTargetList :: AttrLabelProxy "pasteTargetList"
textBufferPasteTargetList = AttrLabelProxy

textBufferTagTable :: AttrLabelProxy "tagTable"
textBufferTagTable = AttrLabelProxy

textBufferText :: AttrLabelProxy "text"
textBufferText = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data TextBufferApplyTagSignalInfo
instance SignalInfo TextBufferApplyTagSignalInfo where
    type HaskellCallbackType TextBufferApplyTagSignalInfo = TextBufferApplyTagCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferApplyTagCallback cb
        cb'' <- mk_TextBufferApplyTagCallback cb'
        connectSignalFunPtr obj "apply-tag" cb'' connectMode

data TextBufferBeginUserActionSignalInfo
instance SignalInfo TextBufferBeginUserActionSignalInfo where
    type HaskellCallbackType TextBufferBeginUserActionSignalInfo = TextBufferBeginUserActionCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferBeginUserActionCallback cb
        cb'' <- mk_TextBufferBeginUserActionCallback cb'
        connectSignalFunPtr obj "begin-user-action" cb'' connectMode

data TextBufferChangedSignalInfo
instance SignalInfo TextBufferChangedSignalInfo where
    type HaskellCallbackType TextBufferChangedSignalInfo = TextBufferChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferChangedCallback cb
        cb'' <- mk_TextBufferChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' connectMode

data TextBufferDeleteRangeSignalInfo
instance SignalInfo TextBufferDeleteRangeSignalInfo where
    type HaskellCallbackType TextBufferDeleteRangeSignalInfo = TextBufferDeleteRangeCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferDeleteRangeCallback cb
        cb'' <- mk_TextBufferDeleteRangeCallback cb'
        connectSignalFunPtr obj "delete-range" cb'' connectMode

data TextBufferEndUserActionSignalInfo
instance SignalInfo TextBufferEndUserActionSignalInfo where
    type HaskellCallbackType TextBufferEndUserActionSignalInfo = TextBufferEndUserActionCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferEndUserActionCallback cb
        cb'' <- mk_TextBufferEndUserActionCallback cb'
        connectSignalFunPtr obj "end-user-action" cb'' connectMode

data TextBufferInsertChildAnchorSignalInfo
instance SignalInfo TextBufferInsertChildAnchorSignalInfo where
    type HaskellCallbackType TextBufferInsertChildAnchorSignalInfo = TextBufferInsertChildAnchorCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferInsertChildAnchorCallback cb
        cb'' <- mk_TextBufferInsertChildAnchorCallback cb'
        connectSignalFunPtr obj "insert-child-anchor" cb'' connectMode

data TextBufferInsertPixbufSignalInfo
instance SignalInfo TextBufferInsertPixbufSignalInfo where
    type HaskellCallbackType TextBufferInsertPixbufSignalInfo = TextBufferInsertPixbufCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferInsertPixbufCallback cb
        cb'' <- mk_TextBufferInsertPixbufCallback cb'
        connectSignalFunPtr obj "insert-pixbuf" cb'' connectMode

data TextBufferInsertTextSignalInfo
instance SignalInfo TextBufferInsertTextSignalInfo where
    type HaskellCallbackType TextBufferInsertTextSignalInfo = TextBufferInsertTextCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferInsertTextCallback cb
        cb'' <- mk_TextBufferInsertTextCallback cb'
        connectSignalFunPtr obj "insert-text" cb'' connectMode

data TextBufferMarkDeletedSignalInfo
instance SignalInfo TextBufferMarkDeletedSignalInfo where
    type HaskellCallbackType TextBufferMarkDeletedSignalInfo = TextBufferMarkDeletedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferMarkDeletedCallback cb
        cb'' <- mk_TextBufferMarkDeletedCallback cb'
        connectSignalFunPtr obj "mark-deleted" cb'' connectMode

data TextBufferMarkSetSignalInfo
instance SignalInfo TextBufferMarkSetSignalInfo where
    type HaskellCallbackType TextBufferMarkSetSignalInfo = TextBufferMarkSetCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferMarkSetCallback cb
        cb'' <- mk_TextBufferMarkSetCallback cb'
        connectSignalFunPtr obj "mark-set" cb'' connectMode

data TextBufferModifiedChangedSignalInfo
instance SignalInfo TextBufferModifiedChangedSignalInfo where
    type HaskellCallbackType TextBufferModifiedChangedSignalInfo = TextBufferModifiedChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferModifiedChangedCallback cb
        cb'' <- mk_TextBufferModifiedChangedCallback cb'
        connectSignalFunPtr obj "modified-changed" cb'' connectMode

data TextBufferPasteDoneSignalInfo
instance SignalInfo TextBufferPasteDoneSignalInfo where
    type HaskellCallbackType TextBufferPasteDoneSignalInfo = TextBufferPasteDoneCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferPasteDoneCallback cb
        cb'' <- mk_TextBufferPasteDoneCallback cb'
        connectSignalFunPtr obj "paste-done" cb'' connectMode

data TextBufferRemoveTagSignalInfo
instance SignalInfo TextBufferRemoveTagSignalInfo where
    type HaskellCallbackType TextBufferRemoveTagSignalInfo = TextBufferRemoveTagCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TextBufferRemoveTagCallback cb
        cb'' <- mk_TextBufferRemoveTagCallback cb'
        connectSignalFunPtr obj "remove-tag" cb'' connectMode

type instance O.SignalList TextBuffer = TextBufferSignalList
type TextBufferSignalList = ('[ '("applyTag", TextBufferApplyTagSignalInfo), '("beginUserAction", TextBufferBeginUserActionSignalInfo), '("changed", TextBufferChangedSignalInfo), '("deleteRange", TextBufferDeleteRangeSignalInfo), '("endUserAction", TextBufferEndUserActionSignalInfo), '("insertChildAnchor", TextBufferInsertChildAnchorSignalInfo), '("insertPixbuf", TextBufferInsertPixbufSignalInfo), '("insertText", TextBufferInsertTextSignalInfo), '("markDeleted", TextBufferMarkDeletedSignalInfo), '("markSet", TextBufferMarkSetSignalInfo), '("modifiedChanged", TextBufferModifiedChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pasteDone", TextBufferPasteDoneSignalInfo), '("removeTag", TextBufferRemoveTagSignalInfo)] :: [(Symbol, *)])

#endif

-- method TextBuffer::new
-- method type : Constructor
-- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Gtk", name = "TextTagTable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a tag table, 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 = "Gtk", name = "TextBuffer"}))
-- throws : False
-- Skip return : False

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

{- |
Creates a new text buffer.
-}
textBufferNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.TextTagTable.IsTextTagTable a) =>
    Maybe (a)
    {- ^ /@table@/: a tag table, or 'Nothing' to create a new one -}
    -> m TextBuffer
    {- ^ __Returns:__ a new text buffer -}
textBufferNew table = liftIO $ do
    maybeTable <- case table of
        Nothing -> return nullPtr
        Just jTable -> do
            jTable' <- unsafeManagedPtrCastPtr jTable
            return jTable'
    result <- gtk_text_buffer_new maybeTable
    checkUnexpectedReturnNULL "textBufferNew" result
    result' <- (wrapObject TextBuffer) result
    whenJust table touchManagedPtr
    return result'

#if ENABLE_OVERLOADING
#endif

-- method TextBuffer::add_mark
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mark", argType = TInterface (Name {namespace = "Gtk", name = "TextMark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the mark to add", 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 mark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_add_mark" gtk_text_buffer_add_mark ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextMark.TextMark ->            -- mark : TInterface (Name {namespace = "Gtk", name = "TextMark"})
    Ptr Gtk.TextIter.TextIter ->            -- where : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Adds the mark at position /@where@/. The mark must not be added to
another buffer, and if its name is not 'Nothing' then there must not
be another mark in the buffer with the same name.

Emits the 'GI.Gtk.Objects.TextBuffer.TextBuffer'::@/mark-set/@ signal as notification of the mark\'s
initial placement.

/Since: 2.12/
-}
textBufferAddMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@mark@/: the mark to add -}
    -> Gtk.TextIter.TextIter
    {- ^ /@where@/: location to place mark -}
    -> m ()
textBufferAddMark buffer mark where_ = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    mark' <- unsafeManagedPtrCastPtr mark
    where_' <- unsafeManagedPtrGetPtr where_
    gtk_text_buffer_add_mark buffer' mark' where_'
    touchManagedPtr buffer
    touchManagedPtr mark
    touchManagedPtr where_
    return ()

#if ENABLE_OVERLOADING
data TextBufferAddMarkMethodInfo
instance (signature ~ (b -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) => O.MethodInfo TextBufferAddMarkMethodInfo a signature where
    overloadedMethod _ = textBufferAddMark

#endif

-- method TextBuffer::add_selection_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clipboard", argType = TInterface (Name {namespace = "Gtk", name = "Clipboard"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkClipboard", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_add_selection_clipboard" gtk_text_buffer_add_selection_clipboard ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.Clipboard.Clipboard ->          -- clipboard : TInterface (Name {namespace = "Gtk", name = "Clipboard"})
    IO ()

{- |
Adds /@clipboard@/ to the list of clipboards in which the selection
contents of /@buffer@/ are available. In most cases, /@clipboard@/ will be
the 'GI.Gtk.Objects.Clipboard.Clipboard' of type @/GDK_SELECTION_PRIMARY/@ for a view of /@buffer@/.
-}
textBufferAddSelectionClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@clipboard@/: a 'GI.Gtk.Objects.Clipboard.Clipboard' -}
    -> m ()
textBufferAddSelectionClipboard buffer clipboard = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    clipboard' <- unsafeManagedPtrCastPtr clipboard
    gtk_text_buffer_add_selection_clipboard buffer' clipboard'
    touchManagedPtr buffer
    touchManagedPtr clipboard
    return ()

#if ENABLE_OVERLOADING
data TextBufferAddSelectionClipboardMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) => O.MethodInfo TextBufferAddSelectionClipboardMethodInfo a signature where
    overloadedMethod _ = textBufferAddSelectionClipboard

#endif

-- method TextBuffer::apply_tag
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TInterface (Name {namespace = "Gtk", name = "TextTag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextTag", 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 "one bound of range to be tagged", 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 "other bound of range to be tagged", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_apply_tag" gtk_text_buffer_apply_tag ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextTag.TextTag ->              -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Emits the “apply-tag” signal on /@buffer@/. The default
handler for the signal applies /@tag@/ to the given range.
/@start@/ and /@end@/ do not have to be in order.
-}
textBufferApplyTag ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextTag.IsTextTag b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@tag@/: a 'GI.Gtk.Objects.TextTag.TextTag' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: one bound of range to be tagged -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: other bound of range to be tagged -}
    -> m ()
textBufferApplyTag buffer tag start end = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    tag' <- unsafeManagedPtrCastPtr tag
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    gtk_text_buffer_apply_tag buffer' tag' start' end'
    touchManagedPtr buffer
    touchManagedPtr tag
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
data TextBufferApplyTagMethodInfo
instance (signature ~ (b -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsTextBuffer a, Gtk.TextTag.IsTextTag b) => O.MethodInfo TextBufferApplyTagMethodInfo a signature where
    overloadedMethod _ = textBufferApplyTag

#endif

-- method TextBuffer::apply_tag_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of a named #GtkTextTag", 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 "one bound of range to be tagged", 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 "other bound of range to be tagged", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_apply_tag_by_name" gtk_text_buffer_apply_tag_by_name ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Calls 'GI.Gtk.Objects.TextTagTable.textTagTableLookup' on the buffer’s tag table to
get a 'GI.Gtk.Objects.TextTag.TextTag', then calls 'GI.Gtk.Objects.TextBuffer.textBufferApplyTag'.
-}
textBufferApplyTagByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> T.Text
    {- ^ /@name@/: name of a named 'GI.Gtk.Objects.TextTag.TextTag' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: one bound of range to be tagged -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: other bound of range to be tagged -}
    -> m ()
textBufferApplyTagByName buffer name start end = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    name' <- textToCString name
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    gtk_text_buffer_apply_tag_by_name buffer' name' start' end'
    touchManagedPtr buffer
    touchManagedPtr start
    touchManagedPtr end
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data TextBufferApplyTagByNameMethodInfo
instance (signature ~ (T.Text -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferApplyTagByNameMethodInfo a signature where
    overloadedMethod _ = textBufferApplyTagByName

#endif

-- method TextBuffer::backspace
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 position in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interactive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the deletion is caused by user interaction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the buffer is editable by default", 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_text_buffer_backspace" gtk_text_buffer_backspace ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CInt ->                                 -- interactive : TBasicType TBoolean
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO CInt

{- |
Performs the appropriate action as if the user hit the delete
key with the cursor at the position specified by /@iter@/. In the
normal case a single character will be deleted, but when
combining accents are involved, more than one character can
be deleted, and when precomposed character and accent combinations
are involved, less than one character will be deleted.

Because the buffer is modified, all outstanding iterators become
invalid after calling this function; however, the /@iter@/ will be
re-initialized to point to the location where text was deleted.

/Since: 2.6/
-}
textBufferBackspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a position in /@buffer@/ -}
    -> Bool
    {- ^ /@interactive@/: whether the deletion is caused by user interaction -}
    -> Bool
    {- ^ /@defaultEditable@/: whether the buffer is editable by default -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the buffer was modified -}
textBufferBackspace buffer iter interactive defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    let interactive' = (fromIntegral . fromEnum) interactive
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    result <- gtk_text_buffer_backspace buffer' iter' interactive' defaultEditable'
    let result' = (/= 0) result
    touchManagedPtr buffer
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data TextBufferBackspaceMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Bool -> Bool -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferBackspaceMethodInfo a signature where
    overloadedMethod _ = textBufferBackspace

#endif

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

foreign import ccall "gtk_text_buffer_begin_user_action" gtk_text_buffer_begin_user_action ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO ()

{- |
Called to indicate that the buffer operations between here and a
call to 'GI.Gtk.Objects.TextBuffer.textBufferEndUserAction' are part of a single
user-visible operation. The operations between
'GI.Gtk.Objects.TextBuffer.textBufferBeginUserAction' and
'GI.Gtk.Objects.TextBuffer.textBufferEndUserAction' can then be grouped when creating
an undo stack. 'GI.Gtk.Objects.TextBuffer.TextBuffer' maintains a count of calls to
'GI.Gtk.Objects.TextBuffer.textBufferBeginUserAction' that have not been closed with
a call to 'GI.Gtk.Objects.TextBuffer.textBufferEndUserAction', and emits the
“begin-user-action” and “end-user-action” signals only for the
outermost pair of calls. This allows you to build user actions
from other user actions.

The “interactive” buffer mutation functions, such as
'GI.Gtk.Objects.TextBuffer.textBufferInsertInteractive', automatically call begin\/end
user action around the buffer operations they perform, so there\'s
no need to add extra calls if you user action consists solely of a
single call to one of those functions.
-}
textBufferBeginUserAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ()
textBufferBeginUserAction buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    gtk_text_buffer_begin_user_action buffer'
    touchManagedPtr buffer
    return ()

#if ENABLE_OVERLOADING
data TextBufferBeginUserActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferBeginUserActionMethodInfo a signature where
    overloadedMethod _ = textBufferBeginUserAction

#endif

-- method TextBuffer::copy_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clipboard", argType = TInterface (Name {namespace = "Gtk", name = "Clipboard"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkClipboard object to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_copy_clipboard" gtk_text_buffer_copy_clipboard ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.Clipboard.Clipboard ->          -- clipboard : TInterface (Name {namespace = "Gtk", name = "Clipboard"})
    IO ()

{- |
Copies the currently-selected text to a clipboard.
-}
textBufferCopyClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' object to copy to -}
    -> m ()
textBufferCopyClipboard buffer clipboard = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    clipboard' <- unsafeManagedPtrCastPtr clipboard
    gtk_text_buffer_copy_clipboard buffer' clipboard'
    touchManagedPtr buffer
    touchManagedPtr clipboard
    return ()

#if ENABLE_OVERLOADING
data TextBufferCopyClipboardMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) => O.MethodInfo TextBufferCopyClipboardMethodInfo a signature where
    overloadedMethod _ = textBufferCopyClipboard

#endif

-- method TextBuffer::create_child_anchor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 "location in the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextChildAnchor"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_create_child_anchor" gtk_text_buffer_create_child_anchor ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO (Ptr Gtk.TextChildAnchor.TextChildAnchor)

{- |
This is a convenience function which simply creates a child anchor
with 'GI.Gtk.Objects.TextChildAnchor.textChildAnchorNew' and inserts it into the buffer
with 'GI.Gtk.Objects.TextBuffer.textBufferInsertChildAnchor'. The new anchor is
owned by the buffer; no reference count is returned to
the caller of 'GI.Gtk.Objects.TextBuffer.textBufferCreateChildAnchor'.
-}
textBufferCreateChildAnchor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: location in the buffer -}
    -> m Gtk.TextChildAnchor.TextChildAnchor
    {- ^ __Returns:__ the created child anchor -}
textBufferCreateChildAnchor buffer iter = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    result <- gtk_text_buffer_create_child_anchor buffer' iter'
    checkUnexpectedReturnNULL "textBufferCreateChildAnchor" result
    result' <- (newObject Gtk.TextChildAnchor.TextChildAnchor) result
    touchManagedPtr buffer
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data TextBufferCreateChildAnchorMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> m Gtk.TextChildAnchor.TextChildAnchor), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferCreateChildAnchorMethodInfo a signature where
    overloadedMethod _ = textBufferCreateChildAnchor

#endif

-- method TextBuffer::create_mark
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mark_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "name for mark, or %NULL", 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 mark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "left_gravity", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the mark has left gravity", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextMark"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_create_mark" gtk_text_buffer_create_mark ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- mark_name : TBasicType TUTF8
    Ptr Gtk.TextIter.TextIter ->            -- where : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CInt ->                                 -- left_gravity : TBasicType TBoolean
    IO (Ptr Gtk.TextMark.TextMark)

{- |
Creates a mark at position /@where@/. If /@markName@/ is 'Nothing', the mark
is anonymous; otherwise, the mark can be retrieved by name using
'GI.Gtk.Objects.TextBuffer.textBufferGetMark'. If a mark has left gravity, and text is
inserted at the mark’s current location, the mark will be moved to
the left of the newly-inserted text. If the mark has right gravity
(/@leftGravity@/ = 'False'), the mark will end up on the right of
newly-inserted text. The standard left-to-right cursor is a mark
with right gravity (when you type, the cursor stays on the right
side of the text you’re typing).

The caller of this function does not own a
reference to the returned 'GI.Gtk.Objects.TextMark.TextMark', so you can ignore the
return value if you like. Marks are owned by the buffer and go
away when the buffer does.

Emits the 'GI.Gtk.Objects.TextBuffer.TextBuffer'::@/mark-set/@ signal as notification of the mark\'s
initial placement.
-}
textBufferCreateMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Maybe (T.Text)
    {- ^ /@markName@/: name for mark, or 'Nothing' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@where@/: location to place mark -}
    -> Bool
    {- ^ /@leftGravity@/: whether the mark has left gravity -}
    -> m Gtk.TextMark.TextMark
    {- ^ __Returns:__ the new 'GI.Gtk.Objects.TextMark.TextMark' object -}
textBufferCreateMark buffer markName where_ leftGravity = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    maybeMarkName <- case markName of
        Nothing -> return nullPtr
        Just jMarkName -> do
            jMarkName' <- textToCString jMarkName
            return jMarkName'
    where_' <- unsafeManagedPtrGetPtr where_
    let leftGravity' = (fromIntegral . fromEnum) leftGravity
    result <- gtk_text_buffer_create_mark buffer' maybeMarkName where_' leftGravity'
    checkUnexpectedReturnNULL "textBufferCreateMark" result
    result' <- (newObject Gtk.TextMark.TextMark) result
    touchManagedPtr buffer
    touchManagedPtr where_
    freeMem maybeMarkName
    return result'

#if ENABLE_OVERLOADING
data TextBufferCreateMarkMethodInfo
instance (signature ~ (Maybe (T.Text) -> Gtk.TextIter.TextIter -> Bool -> m Gtk.TextMark.TextMark), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferCreateMarkMethodInfo a signature where
    overloadedMethod _ = textBufferCreateMark

#endif

-- method TextBuffer::cut_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clipboard", argType = TInterface (Name {namespace = "Gtk", name = "Clipboard"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkClipboard object to cut to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default editability of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_cut_clipboard" gtk_text_buffer_cut_clipboard ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.Clipboard.Clipboard ->          -- clipboard : TInterface (Name {namespace = "Gtk", name = "Clipboard"})
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO ()

{- |
Copies the currently-selected text to a clipboard, then deletes
said text if it’s editable.
-}
textBufferCutClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' object to cut to -}
    -> Bool
    {- ^ /@defaultEditable@/: default editability of the buffer -}
    -> m ()
textBufferCutClipboard buffer clipboard defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    clipboard' <- unsafeManagedPtrCastPtr clipboard
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    gtk_text_buffer_cut_clipboard buffer' clipboard' defaultEditable'
    touchManagedPtr buffer
    touchManagedPtr clipboard
    return ()

#if ENABLE_OVERLOADING
data TextBufferCutClipboardMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTextBuffer a, Gtk.Clipboard.IsClipboard b) => O.MethodInfo TextBufferCutClipboardMethodInfo a signature where
    overloadedMethod _ = textBufferCutClipboard

#endif

-- method TextBuffer::delete
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 position in @buffer", 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 "another position in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_delete" gtk_text_buffer_delete ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Deletes text between /@start@/ and /@end@/. The order of /@start@/ and /@end@/
is not actually relevant; 'GI.Gtk.Objects.TextBuffer.textBufferDelete' will reorder
them. This function actually emits the “delete-range” signal, and
the default handler of that signal deletes the text. Because the
buffer is modified, all outstanding iterators become invalid after
calling this function; however, the /@start@/ and /@end@/ will be
re-initialized to point to the location where text was deleted.
-}
textBufferDelete ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: a position in /@buffer@/ -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: another position in /@buffer@/ -}
    -> m ()
textBufferDelete buffer start end = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    gtk_text_buffer_delete buffer' start' end'
    touchManagedPtr buffer
    touchManagedPtr start
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
data TextBufferDeleteMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeleteMethodInfo a signature where
    overloadedMethod _ = textBufferDelete

#endif

-- method TextBuffer::delete_interactive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of range to delete", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the buffer is editable by default", 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_text_buffer_delete_interactive" gtk_text_buffer_delete_interactive ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start_iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end_iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO CInt

{- |
Deletes all editable text in the given range.
Calls 'GI.Gtk.Objects.TextBuffer.textBufferDelete' for each editable sub-range of
[/@start@/,/@end@/). /@start@/ and /@end@/ are revalidated to point to
the location of the last deleted range, or left untouched if
no text was deleted.
-}
textBufferDeleteInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@startIter@/: start of range to delete -}
    -> Gtk.TextIter.TextIter
    {- ^ /@endIter@/: end of range -}
    -> Bool
    {- ^ /@defaultEditable@/: whether the buffer is editable by default -}
    -> m Bool
    {- ^ __Returns:__ whether some text was actually deleted -}
textBufferDeleteInteractive buffer startIter endIter defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    startIter' <- unsafeManagedPtrGetPtr startIter
    endIter' <- unsafeManagedPtrGetPtr endIter
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    result <- gtk_text_buffer_delete_interactive buffer' startIter' endIter' defaultEditable'
    let result' = (/= 0) result
    touchManagedPtr buffer
    touchManagedPtr startIter
    touchManagedPtr endIter
    return result'

#if ENABLE_OVERLOADING
data TextBufferDeleteInteractiveMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Bool -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeleteInteractiveMethodInfo a signature where
    overloadedMethod _ = textBufferDeleteInteractive

#endif

-- method TextBuffer::delete_mark
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mark", argType = TInterface (Name {namespace = "Gtk", name = "TextMark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextMark in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_delete_mark" gtk_text_buffer_delete_mark ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextMark.TextMark ->            -- mark : TInterface (Name {namespace = "Gtk", name = "TextMark"})
    IO ()

{- |
Deletes /@mark@/, so that it’s no longer located anywhere in the
buffer. Removes the reference the buffer holds to the mark, so if
you haven’t called 'GI.GObject.Objects.Object.objectRef' on the mark, it will be freed. Even
if the mark isn’t freed, most operations on /@mark@/ become
invalid, until it gets added to a buffer again with
'GI.Gtk.Objects.TextBuffer.textBufferAddMark'. Use 'GI.Gtk.Objects.TextMark.textMarkGetDeleted' to
find out if a mark has been removed from its buffer.
The 'GI.Gtk.Objects.TextBuffer.TextBuffer'::@/mark-deleted/@ signal will be emitted as notification after
the mark is deleted.
-}
textBufferDeleteMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@mark@/: a 'GI.Gtk.Objects.TextMark.TextMark' in /@buffer@/ -}
    -> m ()
textBufferDeleteMark buffer mark = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    mark' <- unsafeManagedPtrCastPtr mark
    gtk_text_buffer_delete_mark buffer' mark'
    touchManagedPtr buffer
    touchManagedPtr mark
    return ()

#if ENABLE_OVERLOADING
data TextBufferDeleteMarkMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) => O.MethodInfo TextBufferDeleteMarkMethodInfo a signature where
    overloadedMethod _ = textBufferDeleteMark

#endif

-- method TextBuffer::delete_mark_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of a mark in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_delete_mark_by_name" gtk_text_buffer_delete_mark_by_name ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Deletes the mark named /@name@/; the mark must exist. See
'GI.Gtk.Objects.TextBuffer.textBufferDeleteMark' for details.
-}
textBufferDeleteMarkByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> T.Text
    {- ^ /@name@/: name of a mark in /@buffer@/ -}
    -> m ()
textBufferDeleteMarkByName buffer name = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    name' <- textToCString name
    gtk_text_buffer_delete_mark_by_name buffer' name'
    touchManagedPtr buffer
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data TextBufferDeleteMarkByNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeleteMarkByNameMethodInfo a signature where
    overloadedMethod _ = textBufferDeleteMarkByName

#endif

-- method TextBuffer::delete_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interactive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the deletion is caused by user interaction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the buffer is editable by default", 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_text_buffer_delete_selection" gtk_text_buffer_delete_selection ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CInt ->                                 -- interactive : TBasicType TBoolean
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO CInt

{- |
Deletes the range between the “insert” and “selection_bound” marks,
that is, the currently-selected text. If /@interactive@/ is 'True',
the editability of the selection will be considered (users can’t delete
uneditable text).
-}
textBufferDeleteSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Bool
    {- ^ /@interactive@/: whether the deletion is caused by user interaction -}
    -> Bool
    {- ^ /@defaultEditable@/: whether the buffer is editable by default -}
    -> m Bool
    {- ^ __Returns:__ whether there was a non-empty selection to delete -}
textBufferDeleteSelection buffer interactive defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    let interactive' = (fromIntegral . fromEnum) interactive
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    result <- gtk_text_buffer_delete_selection buffer' interactive' defaultEditable'
    let result' = (/= 0) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferDeleteSelectionMethodInfo
instance (signature ~ (Bool -> Bool -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeleteSelectionMethodInfo a signature where
    overloadedMethod _ = textBufferDeleteSelection

#endif

-- method TextBuffer::deserialize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "register_buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkTextBuffer @format is registered with", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkTextBuffer to deserialize into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the rich text format to use for deserializing", 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 "insertion point for the deserialized text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 5 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data to deserialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "gtk_text_buffer_deserialize" gtk_text_buffer_deserialize ::
    Ptr TextBuffer ->                       -- register_buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr TextBuffer ->                       -- content_buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gdk.Atom.Atom ->                    -- format : TInterface (Name {namespace = "Gdk", name = "Atom"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 5 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
This function deserializes rich text in format /@format@/ and inserts
it at /@iter@/.

/@formats@/ to be used must be registered using
'GI.Gtk.Objects.TextBuffer.textBufferRegisterDeserializeFormat' or
'GI.Gtk.Objects.TextBuffer.textBufferRegisterDeserializeTagset' beforehand.

/Since: 2.10/
-}
textBufferDeserialize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) =>
    a
    {- ^ /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' /@format@/ is registered with -}
    -> b
    {- ^ /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to deserialize into -}
    -> Gdk.Atom.Atom
    {- ^ /@format@/: the rich text format to use for deserializing -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: insertion point for the deserialized text -}
    -> ByteString
    {- ^ /@data@/: data to deserialize -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
textBufferDeserialize registerBuffer contentBuffer format iter data_ = liftIO $ do
    let length_ = fromIntegral $ B.length data_
    registerBuffer' <- unsafeManagedPtrCastPtr registerBuffer
    contentBuffer' <- unsafeManagedPtrCastPtr contentBuffer
    format' <- unsafeManagedPtrGetPtr format
    iter' <- unsafeManagedPtrGetPtr iter
    data_' <- packByteString data_
    onException (do
        _ <- propagateGError $ gtk_text_buffer_deserialize registerBuffer' contentBuffer' format' iter' data_' length_
        touchManagedPtr registerBuffer
        touchManagedPtr contentBuffer
        touchManagedPtr format
        touchManagedPtr iter
        freeMem data_'
        return ()
     ) (do
        freeMem data_'
     )

#if ENABLE_OVERLOADING
data TextBufferDeserializeMethodInfo
instance (signature ~ (b -> Gdk.Atom.Atom -> Gtk.TextIter.TextIter -> ByteString -> m ()), MonadIO m, IsTextBuffer a, IsTextBuffer b) => O.MethodInfo TextBufferDeserializeMethodInfo a signature where
    overloadedMethod _ = textBufferDeserialize

#endif

-- method TextBuffer::deserialize_get_can_create_tags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkAtom representing a registered rich text format", 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_text_buffer_deserialize_get_can_create_tags" gtk_text_buffer_deserialize_get_can_create_tags ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gdk.Atom.Atom ->                    -- format : TInterface (Name {namespace = "Gdk", name = "Atom"})
    IO CInt

{- |
This functions returns the value set with
'GI.Gtk.Objects.TextBuffer.textBufferDeserializeSetCanCreateTags'

/Since: 2.10/
-}
textBufferDeserializeGetCanCreateTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gdk.Atom.Atom
    {- ^ /@format@/: a 'GI.Gdk.Structs.Atom.Atom' representing a registered rich text format -}
    -> m Bool
    {- ^ __Returns:__ whether deserializing this format may create tags -}
textBufferDeserializeGetCanCreateTags buffer format = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    format' <- unsafeManagedPtrGetPtr format
    result <- gtk_text_buffer_deserialize_get_can_create_tags buffer' format'
    let result' = (/= 0) result
    touchManagedPtr buffer
    touchManagedPtr format
    return result'

#if ENABLE_OVERLOADING
data TextBufferDeserializeGetCanCreateTagsMethodInfo
instance (signature ~ (Gdk.Atom.Atom -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeserializeGetCanCreateTagsMethodInfo a signature where
    overloadedMethod _ = textBufferDeserializeGetCanCreateTags

#endif

-- method TextBuffer::deserialize_set_can_create_tags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkAtom representing a registered rich text format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "can_create_tags", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether deserializing this format may create tags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_deserialize_set_can_create_tags" gtk_text_buffer_deserialize_set_can_create_tags ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gdk.Atom.Atom ->                    -- format : TInterface (Name {namespace = "Gdk", name = "Atom"})
    CInt ->                                 -- can_create_tags : TBasicType TBoolean
    IO ()

{- |
Use this function to allow a rich text deserialization function to
create new tags in the receiving buffer. Note that using this
function is almost always a bad idea, because the rich text
functions you register should know how to map the rich text format
they handler to your text buffers set of tags.

The ability of creating new (arbitrary!) tags in the receiving buffer
is meant for special rich text formats like the internal one that
is registered using 'GI.Gtk.Objects.TextBuffer.textBufferRegisterDeserializeTagset',
because that format is essentially a dump of the internal structure
of the source buffer, including its tag names.

You should allow creation of tags only if you know what you are
doing, e.g. if you defined a tagset name for your application
suite’s text buffers and you know that it’s fine to receive new
tags from these buffers, because you know that your application can
handle the newly created tags.

/Since: 2.10/
-}
textBufferDeserializeSetCanCreateTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gdk.Atom.Atom
    {- ^ /@format@/: a 'GI.Gdk.Structs.Atom.Atom' representing a registered rich text format -}
    -> Bool
    {- ^ /@canCreateTags@/: whether deserializing this format may create tags -}
    -> m ()
textBufferDeserializeSetCanCreateTags buffer format canCreateTags = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    format' <- unsafeManagedPtrGetPtr format
    let canCreateTags' = (fromIntegral . fromEnum) canCreateTags
    gtk_text_buffer_deserialize_set_can_create_tags buffer' format' canCreateTags'
    touchManagedPtr buffer
    touchManagedPtr format
    return ()

#if ENABLE_OVERLOADING
data TextBufferDeserializeSetCanCreateTagsMethodInfo
instance (signature ~ (Gdk.Atom.Atom -> Bool -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferDeserializeSetCanCreateTagsMethodInfo a signature where
    overloadedMethod _ = textBufferDeserializeSetCanCreateTags

#endif

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

foreign import ccall "gtk_text_buffer_end_user_action" gtk_text_buffer_end_user_action ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO ()

{- |
Should be paired with a call to 'GI.Gtk.Objects.TextBuffer.textBufferBeginUserAction'.
See that function for a full explanation.
-}
textBufferEndUserAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ()
textBufferEndUserAction buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    gtk_text_buffer_end_user_action buffer'
    touchManagedPtr buffer
    return ()

#if ENABLE_OVERLOADING
data TextBufferEndUserActionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferEndUserActionMethodInfo a signature where
    overloadedMethod _ = textBufferEndUserAction

#endif

-- method TextBuffer::get_bounds
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with first position in the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with the end iterator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_bounds" gtk_text_buffer_get_bounds ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{- |
Retrieves the first and last iterators in the buffer, i.e. the
entire buffer lies within the range [/@start@/,/@end@/).
-}
textBufferGetBounds ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))
textBufferGetBounds buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    start <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    end <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_bounds buffer' start end
    start' <- (wrapBoxed Gtk.TextIter.TextIter) start
    end' <- (wrapBoxed Gtk.TextIter.TextIter) end
    touchManagedPtr buffer
    return (start', end')

#if ENABLE_OVERLOADING
data TextBufferGetBoundsMethodInfo
instance (signature ~ (m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetBoundsMethodInfo a signature where
    overloadedMethod _ = textBufferGetBounds

#endif

-- method TextBuffer::get_char_count
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_text_buffer_get_char_count" gtk_text_buffer_get_char_count ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO Int32

{- |
Gets the number of characters in the buffer; note that characters
and bytes are not the same, you can’t e.g. expect the contents of
the buffer in string form to be this many bytes long. The character
count is cached, so this function is very fast.
-}
textBufferGetCharCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Int32
    {- ^ __Returns:__ number of characters in the buffer -}
textBufferGetCharCount buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_char_count buffer'
    touchManagedPtr buffer
    return result

#if ENABLE_OVERLOADING
data TextBufferGetCharCountMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetCharCountMethodInfo a signature where
    overloadedMethod _ = textBufferGetCharCount

#endif

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

foreign import ccall "gtk_text_buffer_get_copy_target_list" gtk_text_buffer_get_copy_target_list ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO (Ptr Gtk.TargetList.TargetList)

{- |
This function returns the list of targets this text buffer can
provide for copying and as DND source. The targets in the list are
added with /@info@/ values from the 'GI.Gtk.Enums.TextBufferTargetInfo' enum,
using 'GI.Gtk.Structs.TargetList.targetListAddRichTextTargets' and
'GI.Gtk.Structs.TargetList.targetListAddTextTargets'.

/Since: 2.10/
-}
textBufferGetCopyTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Gtk.TargetList.TargetList
    {- ^ __Returns:__ the 'GI.Gtk.Structs.TargetList.TargetList' -}
textBufferGetCopyTargetList buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_copy_target_list buffer'
    checkUnexpectedReturnNULL "textBufferGetCopyTargetList" result
    result' <- (newBoxed Gtk.TargetList.TargetList) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetCopyTargetListMethodInfo
instance (signature ~ (m Gtk.TargetList.TargetList), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetCopyTargetListMethodInfo a signature where
    overloadedMethod _ = textBufferGetCopyTargetList

#endif

-- method TextBuffer::get_deserialize_formats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the number of formats", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the number of formats", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Just (TCArray False (-1) 1 (TInterface (Name {namespace = "Gdk", name = "Atom"})))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_deserialize_formats" gtk_text_buffer_get_deserialize_formats ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Int32 ->                            -- n_formats : TBasicType TInt
    IO (Ptr (Ptr Gdk.Atom.Atom))

{- |
This function returns the rich text deserialize formats registered
with /@buffer@/ using 'GI.Gtk.Objects.TextBuffer.textBufferRegisterDeserializeFormat' or
'GI.Gtk.Objects.TextBuffer.textBufferRegisterDeserializeTagset'

/Since: 2.10/
-}
textBufferGetDeserializeFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m [Gdk.Atom.Atom]
    {- ^ __Returns:__ an array of
              @/GdkAtoms/@ representing the registered formats. -}
textBufferGetDeserializeFormats buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    nFormats <- allocMem :: IO (Ptr Int32)
    result <- gtk_text_buffer_get_deserialize_formats buffer' nFormats
    nFormats' <- peek nFormats
    checkUnexpectedReturnNULL "textBufferGetDeserializeFormats" result
    result' <- (unpackPtrArrayWithLength nFormats') result
    result'' <- mapM (newPtr Gdk.Atom.Atom) result'
    freeMem result
    touchManagedPtr buffer
    freeMem nFormats
    return result''

#if ENABLE_OVERLOADING
data TextBufferGetDeserializeFormatsMethodInfo
instance (signature ~ (m [Gdk.Atom.Atom]), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetDeserializeFormatsMethodInfo a signature where
    overloadedMethod _ = textBufferGetDeserializeFormats

#endif

-- method TextBuffer::get_end_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Initializes /@iter@/ with the “end iterator,” one past the last valid
character in the text buffer. If dereferenced with
'GI.Gtk.Structs.TextIter.textIterGetChar', the end iterator has a character value of 0.
The entire buffer lies in the range from the first position in
the buffer (call 'GI.Gtk.Objects.TextBuffer.textBufferGetStartIter' to get
character position 0) to the end iterator.
-}
textBufferGetEndIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetEndIter buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_end_iter buffer' iter
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetEndIterMethodInfo
instance (signature ~ (m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetEndIterMethodInfo a signature where
    overloadedMethod _ = textBufferGetEndIter

#endif

-- method TextBuffer::get_has_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_text_buffer_get_has_selection" gtk_text_buffer_get_has_selection ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO CInt

{- |
Indicates whether the buffer has some text currently selected.

/Since: 2.10/
-}
textBufferGetHasSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the there is text selected -}
textBufferGetHasSelection buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_has_selection buffer'
    let result' = (/= 0) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetHasSelectionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetHasSelectionMethodInfo a signature where
    overloadedMethod _ = textBufferGetHasSelection

#endif

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

foreign import ccall "gtk_text_buffer_get_insert" gtk_text_buffer_get_insert ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO (Ptr Gtk.TextMark.TextMark)

{- |
Returns the mark that represents the cursor (insertion point).
Equivalent to calling 'GI.Gtk.Objects.TextBuffer.textBufferGetMark' to get the mark
named “insert”, but very slightly more efficient, and involves less
typing.
-}
textBufferGetInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Gtk.TextMark.TextMark
    {- ^ __Returns:__ insertion point mark -}
textBufferGetInsert buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_insert buffer'
    checkUnexpectedReturnNULL "textBufferGetInsert" result
    result' <- (newObject Gtk.TextMark.TextMark) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetInsertMethodInfo
instance (signature ~ (m Gtk.TextMark.TextMark), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetInsertMethodInfo a signature where
    overloadedMethod _ = textBufferGetInsert

#endif

-- method TextBuffer::get_iter_at_child_anchor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator to be initialized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "anchor", argType = TInterface (Name {namespace = "Gtk", name = "TextChildAnchor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a child anchor that appears in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_child_anchor" gtk_text_buffer_get_iter_at_child_anchor ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextChildAnchor.TextChildAnchor -> -- anchor : TInterface (Name {namespace = "Gtk", name = "TextChildAnchor"})
    IO ()

{- |
Obtains the location of /@anchor@/ within /@buffer@/.
-}
textBufferGetIterAtChildAnchor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextChildAnchor.IsTextChildAnchor b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@anchor@/: a child anchor that appears in /@buffer@/ -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtChildAnchor buffer anchor = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    anchor' <- unsafeManagedPtrCastPtr anchor
    gtk_text_buffer_get_iter_at_child_anchor buffer' iter anchor'
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    touchManagedPtr anchor
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtChildAnchorMethodInfo
instance (signature ~ (b -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a, Gtk.TextChildAnchor.IsTextChildAnchor b) => O.MethodInfo TextBufferGetIterAtChildAnchorMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtChildAnchor

#endif

-- method TextBuffer::get_iter_at_line
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "line number counting from 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_line" gtk_text_buffer_get_iter_at_line ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Int32 ->                                -- line_number : TBasicType TInt
    IO ()

{- |
Initializes /@iter@/ to the start of the given line. If /@lineNumber@/ is greater
than the number of lines in the /@buffer@/, the end iterator is returned.
-}
textBufferGetIterAtLine ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Int32
    {- ^ /@lineNumber@/: line number counting from 0 -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtLine buffer lineNumber = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_iter_at_line buffer' iter lineNumber
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtLineMethodInfo
instance (signature ~ (Int32 -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetIterAtLineMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtLine

#endif

-- method TextBuffer::get_iter_at_line_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "line number counting from 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "byte_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte index from start of line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_line_index" gtk_text_buffer_get_iter_at_line_index ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Int32 ->                                -- line_number : TBasicType TInt
    Int32 ->                                -- byte_index : TBasicType TInt
    IO ()

{- |
Obtains an iterator pointing to /@byteIndex@/ within the given line.
/@byteIndex@/ must be the start of a UTF-8 character. Note bytes, not
characters; UTF-8 may encode one character as multiple bytes.

Before the 3.20 version, it was not allowed to pass an invalid location.

Since the 3.20 version, if /@lineNumber@/ is greater than the number of lines
in the /@buffer@/, the end iterator is returned. And if /@byteIndex@/ is off the
end of the line, the iterator at the end of the line is returned.
-}
textBufferGetIterAtLineIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Int32
    {- ^ /@lineNumber@/: line number counting from 0 -}
    -> Int32
    {- ^ /@byteIndex@/: byte index from start of line -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtLineIndex buffer lineNumber byteIndex = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_iter_at_line_index buffer' iter lineNumber byteIndex
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtLineIndexMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetIterAtLineIndexMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtLineIndex

#endif

-- method TextBuffer::get_iter_at_line_offset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "line number counting from 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "char_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "char offset from start of line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_line_offset" gtk_text_buffer_get_iter_at_line_offset ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Int32 ->                                -- line_number : TBasicType TInt
    Int32 ->                                -- char_offset : TBasicType TInt
    IO ()

{- |
Obtains an iterator pointing to /@charOffset@/ within the given line. Note
characters, not bytes; UTF-8 may encode one character as multiple bytes.

Before the 3.20 version, it was not allowed to pass an invalid location.

Since the 3.20 version, if /@lineNumber@/ is greater than the number of lines
in the /@buffer@/, the end iterator is returned. And if /@charOffset@/ is off the
end of the line, the iterator at the end of the line is returned.
-}
textBufferGetIterAtLineOffset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Int32
    {- ^ /@lineNumber@/: line number counting from 0 -}
    -> Int32
    {- ^ /@charOffset@/: char offset from start of line -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtLineOffset buffer lineNumber charOffset = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_iter_at_line_offset buffer' iter lineNumber charOffset
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtLineOffsetMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetIterAtLineOffsetMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtLineOffset

#endif

-- method TextBuffer::get_iter_at_mark
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "mark", argType = TInterface (Name {namespace = "Gtk", name = "TextMark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextMark in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_mark" gtk_text_buffer_get_iter_at_mark ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextMark.TextMark ->            -- mark : TInterface (Name {namespace = "Gtk", name = "TextMark"})
    IO ()

{- |
Initializes /@iter@/ with the current position of /@mark@/.
-}
textBufferGetIterAtMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> b
    {- ^ /@mark@/: a 'GI.Gtk.Objects.TextMark.TextMark' in /@buffer@/ -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtMark buffer mark = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    mark' <- unsafeManagedPtrCastPtr mark
    gtk_text_buffer_get_iter_at_mark buffer' iter mark'
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    touchManagedPtr mark
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtMarkMethodInfo
instance (signature ~ (b -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a, Gtk.TextMark.IsTextMark b) => O.MethodInfo TextBufferGetIterAtMarkMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtMark

#endif

-- method TextBuffer::get_iter_at_offset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "char_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "char offset from start of buffer, counting from 0, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_iter_at_offset" gtk_text_buffer_get_iter_at_offset ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Int32 ->                                -- char_offset : TBasicType TInt
    IO ()

{- |
Initializes /@iter@/ to a position /@charOffset@/ chars from the start
of the entire buffer. If /@charOffset@/ is -1 or greater than the number
of characters in the buffer, /@iter@/ is initialized to the end iterator,
the iterator one past the last valid character in the buffer.
-}
textBufferGetIterAtOffset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Int32
    {- ^ /@charOffset@/: char offset from start of buffer, counting from 0, or -1 -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetIterAtOffset buffer charOffset = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_iter_at_offset buffer' iter charOffset
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetIterAtOffsetMethodInfo
instance (signature ~ (Int32 -> m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetIterAtOffsetMethodInfo a signature where
    overloadedMethod _ = textBufferGetIterAtOffset

#endif

-- method TextBuffer::get_line_count
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_text_buffer_get_line_count" gtk_text_buffer_get_line_count ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO Int32

{- |
Obtains the number of lines in the buffer. This value is cached, so
the function is very fast.
-}
textBufferGetLineCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Int32
    {- ^ __Returns:__ number of lines in the buffer -}
textBufferGetLineCount buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_line_count buffer'
    touchManagedPtr buffer
    return result

#if ENABLE_OVERLOADING
data TextBufferGetLineCountMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetLineCountMethodInfo a signature where
    overloadedMethod _ = textBufferGetLineCount

#endif

-- method TextBuffer::get_mark
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a mark name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextMark"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_mark" gtk_text_buffer_get_mark ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Gtk.TextMark.TextMark)

{- |
Returns the mark named /@name@/ in buffer /@buffer@/, or 'Nothing' if no such
mark exists in the buffer.
-}
textBufferGetMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> T.Text
    {- ^ /@name@/: a mark name -}
    -> m (Maybe Gtk.TextMark.TextMark)
    {- ^ __Returns:__ a 'GI.Gtk.Objects.TextMark.TextMark', or 'Nothing' -}
textBufferGetMark buffer name = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    name' <- textToCString name
    result <- gtk_text_buffer_get_mark buffer' name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.TextMark.TextMark) result'
        return result''
    touchManagedPtr buffer
    freeMem name'
    return maybeResult

#if ENABLE_OVERLOADING
data TextBufferGetMarkMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gtk.TextMark.TextMark)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetMarkMethodInfo a signature where
    overloadedMethod _ = textBufferGetMark

#endif

-- method TextBuffer::get_modified
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_text_buffer_get_modified" gtk_text_buffer_get_modified ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO CInt

{- |
Indicates whether the buffer has been modified since the last call
to 'GI.Gtk.Objects.TextBuffer.textBufferSetModified' set the modification flag to
'False'. Used for example to enable a “save” function in a text
editor.
-}
textBufferGetModified ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the buffer has been modified -}
textBufferGetModified buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_modified buffer'
    let result' = (/= 0) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetModifiedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetModifiedMethodInfo a signature where
    overloadedMethod _ = textBufferGetModified

#endif

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

foreign import ccall "gtk_text_buffer_get_paste_target_list" gtk_text_buffer_get_paste_target_list ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO (Ptr Gtk.TargetList.TargetList)

{- |
This function returns the list of targets this text buffer supports
for pasting and as DND destination. The targets in the list are
added with /@info@/ values from the 'GI.Gtk.Enums.TextBufferTargetInfo' enum,
using 'GI.Gtk.Structs.TargetList.targetListAddRichTextTargets' and
'GI.Gtk.Structs.TargetList.targetListAddTextTargets'.

/Since: 2.10/
-}
textBufferGetPasteTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Gtk.TargetList.TargetList
    {- ^ __Returns:__ the 'GI.Gtk.Structs.TargetList.TargetList' -}
textBufferGetPasteTargetList buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_paste_target_list buffer'
    checkUnexpectedReturnNULL "textBufferGetPasteTargetList" result
    result' <- (newBoxed Gtk.TargetList.TargetList) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetPasteTargetListMethodInfo
instance (signature ~ (m Gtk.TargetList.TargetList), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetPasteTargetListMethodInfo a signature where
    overloadedMethod _ = textBufferGetPasteTargetList

#endif

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

foreign import ccall "gtk_text_buffer_get_selection_bound" gtk_text_buffer_get_selection_bound ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO (Ptr Gtk.TextMark.TextMark)

{- |
Returns the mark that represents the selection bound.  Equivalent
to calling 'GI.Gtk.Objects.TextBuffer.textBufferGetMark' to get the mark named
“selection_bound”, but very slightly more efficient, and involves
less typing.

The currently-selected text in /@buffer@/ is the region between the
“selection_bound” and “insert” marks. If “selection_bound” and
“insert” are in the same place, then there is no current selection.
'GI.Gtk.Objects.TextBuffer.textBufferGetSelectionBounds' is another convenient function
for handling the selection, if you just want to know whether there’s a
selection and what its bounds are.
-}
textBufferGetSelectionBound ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Gtk.TextMark.TextMark
    {- ^ __Returns:__ selection bound mark -}
textBufferGetSelectionBound buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_selection_bound buffer'
    checkUnexpectedReturnNULL "textBufferGetSelectionBound" result
    result' <- (newObject Gtk.TextMark.TextMark) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetSelectionBoundMethodInfo
instance (signature ~ (m Gtk.TextMark.TextMark), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetSelectionBoundMethodInfo a signature where
    overloadedMethod _ = textBufferGetSelectionBound

#endif

-- method TextBuffer::get_selection_bounds
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with selection start", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with selection end", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_selection_bounds" gtk_text_buffer_get_selection_bounds ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO CInt

{- |
Returns 'True' if some text is selected; places the bounds
of the selection in /@start@/ and /@end@/ (if the selection has length 0,
then /@start@/ and /@end@/ are filled in with the same value).
/@start@/ and /@end@/ will be in ascending order. If /@start@/ and /@end@/ are
NULL, then they are not filled in, but the return value still indicates
whether text is selected.
-}
textBufferGetSelectionBounds ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))
    {- ^ __Returns:__ whether the selection has nonzero length -}
textBufferGetSelectionBounds buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    start <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    end <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    result <- gtk_text_buffer_get_selection_bounds buffer' start end
    let result' = (/= 0) result
    start' <- (wrapBoxed Gtk.TextIter.TextIter) start
    end' <- (wrapBoxed Gtk.TextIter.TextIter) end
    touchManagedPtr buffer
    return (result', start', end')

#if ENABLE_OVERLOADING
data TextBufferGetSelectionBoundsMethodInfo
instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetSelectionBoundsMethodInfo a signature where
    overloadedMethod _ = textBufferGetSelectionBounds

#endif

-- method TextBuffer::get_serialize_formats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the number of formats", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the number of formats", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Just (TCArray False (-1) 1 (TInterface (Name {namespace = "Gdk", name = "Atom"})))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_serialize_formats" gtk_text_buffer_get_serialize_formats ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Int32 ->                            -- n_formats : TBasicType TInt
    IO (Ptr (Ptr Gdk.Atom.Atom))

{- |
This function returns the rich text serialize formats registered
with /@buffer@/ using 'GI.Gtk.Objects.TextBuffer.textBufferRegisterSerializeFormat' or
'GI.Gtk.Objects.TextBuffer.textBufferRegisterSerializeTagset'

/Since: 2.10/
-}
textBufferGetSerializeFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m [Gdk.Atom.Atom]
    {- ^ __Returns:__ an array of
              @/GdkAtoms/@ representing the registered formats. -}
textBufferGetSerializeFormats buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    nFormats <- allocMem :: IO (Ptr Int32)
    result <- gtk_text_buffer_get_serialize_formats buffer' nFormats
    nFormats' <- peek nFormats
    checkUnexpectedReturnNULL "textBufferGetSerializeFormats" result
    result' <- (unpackPtrArrayWithLength nFormats') result
    result'' <- mapM (newPtr Gdk.Atom.Atom) result'
    freeMem result
    touchManagedPtr buffer
    freeMem nFormats
    return result''

#if ENABLE_OVERLOADING
data TextBufferGetSerializeFormatsMethodInfo
instance (signature ~ (m [Gdk.Atom.Atom]), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetSerializeFormatsMethodInfo a signature where
    overloadedMethod _ = textBufferGetSerializeFormats

#endif

-- method TextBuffer::get_slice
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 a range", 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 a range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "include_hidden_chars", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to include invisible text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_slice" gtk_text_buffer_get_slice ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CInt ->                                 -- include_hidden_chars : TBasicType TBoolean
    IO CString

{- |
Returns the text in the range [/@start@/,/@end@/). Excludes undisplayed
text (text marked with tags that set the invisibility attribute) if
/@includeHiddenChars@/ is 'False'. The returned string includes a
0xFFFC character whenever the buffer contains
embedded images, so byte and character indexes into
the returned string do correspond to byte
and character indexes into the buffer. Contrast with
'GI.Gtk.Objects.TextBuffer.textBufferGetText'. Note that 0xFFFC can occur in normal
text as well, so it is not a reliable indicator that a pixbuf or
widget is in the buffer.
-}
textBufferGetSlice ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: start of a range -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: end of a range -}
    -> Bool
    {- ^ /@includeHiddenChars@/: whether to include invisible text -}
    -> m T.Text
    {- ^ __Returns:__ an allocated UTF-8 string -}
textBufferGetSlice buffer start end includeHiddenChars = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    let includeHiddenChars' = (fromIntegral . fromEnum) includeHiddenChars
    result <- gtk_text_buffer_get_slice buffer' start' end' includeHiddenChars'
    checkUnexpectedReturnNULL "textBufferGetSlice" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr buffer
    touchManagedPtr start
    touchManagedPtr end
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetSliceMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Bool -> m T.Text), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetSliceMethodInfo a signature where
    overloadedMethod _ = textBufferGetSlice

#endif

-- method TextBuffer::get_start_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Initialized /@iter@/ with the first position in the text buffer. This
is the same as using 'GI.Gtk.Objects.TextBuffer.textBufferGetIterAtOffset' to get
the iter at character offset 0.
-}
textBufferGetStartIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m (Gtk.TextIter.TextIter)
textBufferGetStartIter buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    gtk_text_buffer_get_start_iter buffer' iter
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr buffer
    return iter'

#if ENABLE_OVERLOADING
data TextBufferGetStartIterMethodInfo
instance (signature ~ (m (Gtk.TextIter.TextIter)), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetStartIterMethodInfo a signature where
    overloadedMethod _ = textBufferGetStartIter

#endif

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

foreign import ccall "gtk_text_buffer_get_tag_table" gtk_text_buffer_get_tag_table ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO (Ptr Gtk.TextTagTable.TextTagTable)

{- |
Get the 'GI.Gtk.Objects.TextTagTable.TextTagTable' associated with this buffer.
-}
textBufferGetTagTable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m Gtk.TextTagTable.TextTagTable
    {- ^ __Returns:__ the buffer’s tag table -}
textBufferGetTagTable buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_text_buffer_get_tag_table buffer'
    checkUnexpectedReturnNULL "textBufferGetTagTable" result
    result' <- (newObject Gtk.TextTagTable.TextTagTable) result
    touchManagedPtr buffer
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetTagTableMethodInfo
instance (signature ~ (m Gtk.TextTagTable.TextTagTable), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetTagTableMethodInfo a signature where
    overloadedMethod _ = textBufferGetTagTable

#endif

-- method TextBuffer::get_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 a range", 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 a range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "include_hidden_chars", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to include invisible text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_get_text" gtk_text_buffer_get_text ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CInt ->                                 -- include_hidden_chars : TBasicType TBoolean
    IO CString

{- |
Returns the text in the range [/@start@/,/@end@/). Excludes undisplayed
text (text marked with tags that set the invisibility attribute) if
/@includeHiddenChars@/ is 'False'. Does not include characters
representing embedded images, so byte and character indexes into
the returned string do not correspond to byte
and character indexes into the buffer. Contrast with
'GI.Gtk.Objects.TextBuffer.textBufferGetSlice'.
-}
textBufferGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@start@/: start of a range -}
    -> Gtk.TextIter.TextIter
    {- ^ /@end@/: end of a range -}
    -> Bool
    {- ^ /@includeHiddenChars@/: whether to include invisible text -}
    -> m T.Text
    {- ^ __Returns:__ an allocated UTF-8 string -}
textBufferGetText buffer start end includeHiddenChars = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    start' <- unsafeManagedPtrGetPtr start
    end' <- unsafeManagedPtrGetPtr end
    let includeHiddenChars' = (fromIntegral . fromEnum) includeHiddenChars
    result <- gtk_text_buffer_get_text buffer' start' end' includeHiddenChars'
    checkUnexpectedReturnNULL "textBufferGetText" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr buffer
    touchManagedPtr start
    touchManagedPtr end
    return result'

#if ENABLE_OVERLOADING
data TextBufferGetTextMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Bool -> m T.Text), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferGetTextMethodInfo a signature where
    overloadedMethod _ = textBufferGetText

#endif

-- method TextBuffer::insert
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 position in the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text in UTF-8 format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of text in bytes, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_insert" gtk_text_buffer_insert ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- text : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    IO ()

{- |
Inserts /@len@/ bytes of /@text@/ at position /@iter@/.  If /@len@/ is -1,
/@text@/ must be nul-terminated and will be inserted in its
entirety. Emits the “insert-text” signal; insertion actually occurs
in the default handler for the signal. /@iter@/ is invalidated when
insertion occurs (because the buffer contents change), but the
default signal handler revalidates it to point to the end of the
inserted text.
-}
textBufferInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a position in the buffer -}
    -> T.Text
    {- ^ /@text@/: text in UTF-8 format -}
    -> Int32
    {- ^ /@len@/: length of text in bytes, or -1 -}
    -> m ()
textBufferInsert buffer iter text len = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    text' <- textToCString text
    gtk_text_buffer_insert buffer' iter' text' len
    touchManagedPtr buffer
    touchManagedPtr iter
    freeMem text'
    return ()

#if ENABLE_OVERLOADING
data TextBufferInsertMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> Int32 -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferInsertMethodInfo a signature where
    overloadedMethod _ = textBufferInsert

#endif

-- method TextBuffer::insert_at_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text in UTF-8 format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of text, in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_insert_at_cursor" gtk_text_buffer_insert_at_cursor ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- text : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    IO ()

{- |
Simply calls 'GI.Gtk.Objects.TextBuffer.textBufferInsert', using the current
cursor position as the insertion point.
-}
textBufferInsertAtCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> T.Text
    {- ^ /@text@/: text in UTF-8 format -}
    -> Int32
    {- ^ /@len@/: length of text, in bytes -}
    -> m ()
textBufferInsertAtCursor buffer text len = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    text' <- textToCString text
    gtk_text_buffer_insert_at_cursor buffer' text' len
    touchManagedPtr buffer
    freeMem text'
    return ()

#if ENABLE_OVERLOADING
data TextBufferInsertAtCursorMethodInfo
instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferInsertAtCursorMethodInfo a signature where
    overloadedMethod _ = textBufferInsertAtCursor

#endif

-- method TextBuffer::insert_child_anchor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 "location to insert the anchor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "anchor", argType = TInterface (Name {namespace = "Gtk", name = "TextChildAnchor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextChildAnchor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_insert_child_anchor" gtk_text_buffer_insert_child_anchor ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextChildAnchor.TextChildAnchor -> -- anchor : TInterface (Name {namespace = "Gtk", name = "TextChildAnchor"})
    IO ()

{- |
Inserts a child widget anchor into the text buffer at /@iter@/. The
anchor will be counted as one character in character counts, and
when obtaining the buffer contents as a string, will be represented
by the Unicode “object replacement character” 0xFFFC. Note that the
“slice” variants for obtaining portions of the buffer as a string
include this character for child anchors, but the “text” variants do
not. E.g. see 'GI.Gtk.Objects.TextBuffer.textBufferGetSlice' and
'GI.Gtk.Objects.TextBuffer.textBufferGetText'. Consider
'GI.Gtk.Objects.TextBuffer.textBufferCreateChildAnchor' as a more convenient
alternative to this function. The buffer will add a reference to
the anchor, so you can unref it after insertion.
-}
textBufferInsertChildAnchor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, Gtk.TextChildAnchor.IsTextChildAnchor b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: location to insert the anchor -}
    -> b
    {- ^ /@anchor@/: a 'GI.Gtk.Objects.TextChildAnchor.TextChildAnchor' -}
    -> m ()
textBufferInsertChildAnchor buffer iter anchor = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    anchor' <- unsafeManagedPtrCastPtr anchor
    gtk_text_buffer_insert_child_anchor buffer' iter' anchor'
    touchManagedPtr buffer
    touchManagedPtr iter
    touchManagedPtr anchor
    return ()

#if ENABLE_OVERLOADING
data TextBufferInsertChildAnchorMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> b -> m ()), MonadIO m, IsTextBuffer a, Gtk.TextChildAnchor.IsTextChildAnchor b) => O.MethodInfo TextBufferInsertChildAnchorMethodInfo a signature where
    overloadedMethod _ = textBufferInsertChildAnchor

#endif

-- method TextBuffer::insert_interactive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 position in @buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "some UTF-8 text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of text in bytes, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default editability of buffer", 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_text_buffer_insert_interactive" gtk_text_buffer_insert_interactive ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- text : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO CInt

{- |
Like 'GI.Gtk.Objects.TextBuffer.textBufferInsert', but the insertion will not occur if
/@iter@/ is at a non-editable location in the buffer. Usually you
want to prevent insertions at ineditable locations if the insertion
results from a user action (is interactive).

/@defaultEditable@/ indicates the editability of text that doesn\'t
have a tag affecting editability applied to it. Typically the
result of 'GI.Gtk.Objects.TextView.textViewGetEditable' is appropriate here.
-}
textBufferInsertInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a position in /@buffer@/ -}
    -> T.Text
    {- ^ /@text@/: some UTF-8 text -}
    -> Int32
    {- ^ /@len@/: length of text in bytes, or -1 -}
    -> Bool
    {- ^ /@defaultEditable@/: default editability of buffer -}
    -> m Bool
    {- ^ __Returns:__ whether text was actually inserted -}
textBufferInsertInteractive buffer iter text len defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    text' <- textToCString text
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    result <- gtk_text_buffer_insert_interactive buffer' iter' text' len defaultEditable'
    let result' = (/= 0) result
    touchManagedPtr buffer
    touchManagedPtr iter
    freeMem text'
    return result'

#if ENABLE_OVERLOADING
data TextBufferInsertInteractiveMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> Int32 -> Bool -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferInsertInteractiveMethodInfo a signature where
    overloadedMethod _ = textBufferInsertInteractive

#endif

-- method TextBuffer::insert_interactive_at_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text in UTF-8 format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of text in bytes, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default editability of buffer", 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_text_buffer_insert_interactive_at_cursor" gtk_text_buffer_insert_interactive_at_cursor ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    CString ->                              -- text : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    CInt ->                                 -- default_editable : TBasicType TBoolean
    IO CInt

{- |
Calls 'GI.Gtk.Objects.TextBuffer.textBufferInsertInteractive' at the cursor
position.

/@defaultEditable@/ indicates the editability of text that doesn\'t
have a tag affecting editability applied to it. Typically the
result of 'GI.Gtk.Objects.TextView.textViewGetEditable' is appropriate here.
-}
textBufferInsertInteractiveAtCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> T.Text
    {- ^ /@text@/: text in UTF-8 format -}
    -> Int32
    {- ^ /@len@/: length of text in bytes, or -1 -}
    -> Bool
    {- ^ /@defaultEditable@/: default editability of buffer -}
    -> m Bool
    {- ^ __Returns:__ whether text was actually inserted -}
textBufferInsertInteractiveAtCursor buffer text len defaultEditable = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    text' <- textToCString text
    let defaultEditable' = (fromIntegral . fromEnum) defaultEditable
    result <- gtk_text_buffer_insert_interactive_at_cursor buffer' text' len defaultEditable'
    let result' = (/= 0) result
    touchManagedPtr buffer
    freeMem text'
    return result'

#if ENABLE_OVERLOADING
data TextBufferInsertInteractiveAtCursorMethodInfo
instance (signature ~ (T.Text -> Int32 -> Bool -> m Bool), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferInsertInteractiveAtCursorMethodInfo a signature where
    overloadedMethod _ = textBufferInsertInteractiveAtCursor

#endif

-- method TextBuffer::insert_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 "location to insert the markup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a nul-terminated UTF-8 string containing [Pango markup][PangoMarkupFormat]", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @markup in bytes, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_insert_markup" gtk_text_buffer_insert_markup ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    CString ->                              -- markup : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    IO ()

{- |
Inserts the text in /@markup@/ at position /@iter@/. /@markup@/ will be inserted
in its entirety and must be nul-terminated and valid UTF-8. Emits the
'GI.Gtk.Objects.TextBuffer.TextBuffer'::@/insert-text/@ signal, possibly multiple times; insertion
actually occurs in the default handler for the signal. /@iter@/ will point
to the end of the inserted text on return.

/Since: 3.16/
-}
textBufferInsertMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: location to insert the markup -}
    -> T.Text
    {- ^ /@markup@/: a nul-terminated UTF-8 string containing [Pango markup][PangoMarkupFormat] -}
    -> Int32
    {- ^ /@len@/: length of /@markup@/ in bytes, or -1 -}
    -> m ()
textBufferInsertMarkup buffer iter markup len = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    markup' <- textToCString markup
    gtk_text_buffer_insert_markup buffer' iter' markup' len
    touchManagedPtr buffer
    touchManagedPtr iter
    freeMem markup'
    return ()

#if ENABLE_OVERLOADING
data TextBufferInsertMarkupMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> Int32 -> m ()), MonadIO m, IsTextBuffer a) => O.MethodInfo TextBufferInsertMarkupMethodInfo a signature where
    overloadedMethod _ = textBufferInsertMarkup

#endif

-- method TextBuffer::insert_pixbuf
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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 "location to insert the pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_text_buffer_insert_pixbuf" gtk_text_buffer_insert_pixbuf ::
    Ptr TextBuffer ->                       -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
    IO ()

{- |
Inserts an image into the text buffer at /@iter@/. The image will be
counted as one character in character counts, and when obtaining
the buffer contents as a string, will be represented by the Unicode
“object replacement character” 0xFFFC. Note that the “slice”
variants for obtaining portions of the buffer as a string include
this character for pixbufs, but the “text” variants do
not. e.g. see 'GI.Gtk.Objects.TextBuffer.textBufferGetSlice' and
'GI.Gtk.Objects.TextBuffer.textBufferGetText'.
-}
textBufferInsertPixbuf ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextBuffer a, GdkPixbuf.Pixbuf.IsPixbuf b) =>
    a
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: location to insert the pixbuf -}
    -> b
    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}
    -> m ()
textBufferInsertPixbuf buffer iter pixbuf = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    iter' <- unsafeManagedPtrGetPtr iter
    pixbuf' <- unsafeManagedPtrCastPtr pixbuf