{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GtkSource.Objects.Buffer ( -- * Exported types Buffer(..) , IsBuffer , toBuffer , noBuffer , -- * Methods -- ** backwardIterToSourceMark #method:backwardIterToSourceMark# #if ENABLE_OVERLOADING BufferBackwardIterToSourceMarkMethodInfo, #endif bufferBackwardIterToSourceMark , -- ** beginNotUndoableAction #method:beginNotUndoableAction# #if ENABLE_OVERLOADING BufferBeginNotUndoableActionMethodInfo , #endif bufferBeginNotUndoableAction , -- ** canRedo #method:canRedo# #if ENABLE_OVERLOADING BufferCanRedoMethodInfo , #endif bufferCanRedo , -- ** canUndo #method:canUndo# #if ENABLE_OVERLOADING BufferCanUndoMethodInfo , #endif bufferCanUndo , -- ** changeCase #method:changeCase# #if ENABLE_OVERLOADING BufferChangeCaseMethodInfo , #endif bufferChangeCase , -- ** createSourceMark #method:createSourceMark# #if ENABLE_OVERLOADING BufferCreateSourceMarkMethodInfo , #endif bufferCreateSourceMark , -- ** endNotUndoableAction #method:endNotUndoableAction# #if ENABLE_OVERLOADING BufferEndNotUndoableActionMethodInfo , #endif bufferEndNotUndoableAction , -- ** ensureHighlight #method:ensureHighlight# #if ENABLE_OVERLOADING BufferEnsureHighlightMethodInfo , #endif bufferEnsureHighlight , -- ** forwardIterToSourceMark #method:forwardIterToSourceMark# #if ENABLE_OVERLOADING BufferForwardIterToSourceMarkMethodInfo , #endif bufferForwardIterToSourceMark , -- ** getContextClassesAtIter #method:getContextClassesAtIter# #if ENABLE_OVERLOADING BufferGetContextClassesAtIterMethodInfo , #endif bufferGetContextClassesAtIter , -- ** getHighlightMatchingBrackets #method:getHighlightMatchingBrackets# #if ENABLE_OVERLOADING BufferGetHighlightMatchingBracketsMethodInfo, #endif bufferGetHighlightMatchingBrackets , -- ** getHighlightSyntax #method:getHighlightSyntax# #if ENABLE_OVERLOADING BufferGetHighlightSyntaxMethodInfo , #endif bufferGetHighlightSyntax , -- ** getImplicitTrailingNewline #method:getImplicitTrailingNewline# #if ENABLE_OVERLOADING BufferGetImplicitTrailingNewlineMethodInfo, #endif bufferGetImplicitTrailingNewline , -- ** getLanguage #method:getLanguage# #if ENABLE_OVERLOADING BufferGetLanguageMethodInfo , #endif bufferGetLanguage , -- ** getMaxUndoLevels #method:getMaxUndoLevels# #if ENABLE_OVERLOADING BufferGetMaxUndoLevelsMethodInfo , #endif bufferGetMaxUndoLevels , -- ** getSourceMarksAtIter #method:getSourceMarksAtIter# #if ENABLE_OVERLOADING BufferGetSourceMarksAtIterMethodInfo , #endif bufferGetSourceMarksAtIter , -- ** getSourceMarksAtLine #method:getSourceMarksAtLine# #if ENABLE_OVERLOADING BufferGetSourceMarksAtLineMethodInfo , #endif bufferGetSourceMarksAtLine , -- ** getStyleScheme #method:getStyleScheme# #if ENABLE_OVERLOADING BufferGetStyleSchemeMethodInfo , #endif bufferGetStyleScheme , -- ** getUndoManager #method:getUndoManager# #if ENABLE_OVERLOADING BufferGetUndoManagerMethodInfo , #endif bufferGetUndoManager , -- ** iterBackwardToContextClassToggle #method:iterBackwardToContextClassToggle# #if ENABLE_OVERLOADING BufferIterBackwardToContextClassToggleMethodInfo, #endif bufferIterBackwardToContextClassToggle , -- ** iterForwardToContextClassToggle #method:iterForwardToContextClassToggle# #if ENABLE_OVERLOADING BufferIterForwardToContextClassToggleMethodInfo, #endif bufferIterForwardToContextClassToggle , -- ** iterHasContextClass #method:iterHasContextClass# #if ENABLE_OVERLOADING BufferIterHasContextClassMethodInfo , #endif bufferIterHasContextClass , -- ** joinLines #method:joinLines# #if ENABLE_OVERLOADING BufferJoinLinesMethodInfo , #endif bufferJoinLines , -- ** new #method:new# bufferNew , -- ** newWithLanguage #method:newWithLanguage# bufferNewWithLanguage , -- ** redo #method:redo# #if ENABLE_OVERLOADING BufferRedoMethodInfo , #endif bufferRedo , -- ** removeSourceMarks #method:removeSourceMarks# #if ENABLE_OVERLOADING BufferRemoveSourceMarksMethodInfo , #endif bufferRemoveSourceMarks , -- ** setHighlightMatchingBrackets #method:setHighlightMatchingBrackets# #if ENABLE_OVERLOADING BufferSetHighlightMatchingBracketsMethodInfo, #endif bufferSetHighlightMatchingBrackets , -- ** setHighlightSyntax #method:setHighlightSyntax# #if ENABLE_OVERLOADING BufferSetHighlightSyntaxMethodInfo , #endif bufferSetHighlightSyntax , -- ** setImplicitTrailingNewline #method:setImplicitTrailingNewline# #if ENABLE_OVERLOADING BufferSetImplicitTrailingNewlineMethodInfo, #endif bufferSetImplicitTrailingNewline , -- ** setLanguage #method:setLanguage# #if ENABLE_OVERLOADING BufferSetLanguageMethodInfo , #endif bufferSetLanguage , -- ** setMaxUndoLevels #method:setMaxUndoLevels# #if ENABLE_OVERLOADING BufferSetMaxUndoLevelsMethodInfo , #endif bufferSetMaxUndoLevels , -- ** setStyleScheme #method:setStyleScheme# #if ENABLE_OVERLOADING BufferSetStyleSchemeMethodInfo , #endif bufferSetStyleScheme , -- ** setUndoManager #method:setUndoManager# #if ENABLE_OVERLOADING BufferSetUndoManagerMethodInfo , #endif bufferSetUndoManager , -- ** sortLines #method:sortLines# #if ENABLE_OVERLOADING BufferSortLinesMethodInfo , #endif bufferSortLines , -- ** undo #method:undo# #if ENABLE_OVERLOADING BufferUndoMethodInfo , #endif bufferUndo , -- * Properties -- ** canRedo #attr:canRedo# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING BufferCanRedoPropertyInfo , #endif getBufferCanRedo , -- ** canUndo #attr:canUndo# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING BufferCanUndoPropertyInfo , #endif getBufferCanUndo , -- ** highlightMatchingBrackets #attr:highlightMatchingBrackets# {- | Whether to highlight matching brackets in the buffer. -} #if ENABLE_OVERLOADING BufferHighlightMatchingBracketsPropertyInfo, #endif #if ENABLE_OVERLOADING bufferHighlightMatchingBrackets , #endif constructBufferHighlightMatchingBrackets, getBufferHighlightMatchingBrackets , setBufferHighlightMatchingBrackets , -- ** highlightSyntax #attr:highlightSyntax# {- | Whether to highlight syntax in the buffer. -} #if ENABLE_OVERLOADING BufferHighlightSyntaxPropertyInfo , #endif #if ENABLE_OVERLOADING bufferHighlightSyntax , #endif constructBufferHighlightSyntax , getBufferHighlightSyntax , setBufferHighlightSyntax , -- ** implicitTrailingNewline #attr:implicitTrailingNewline# {- | Whether the buffer has an implicit trailing newline. See 'GI.GtkSource.Objects.Buffer.bufferSetImplicitTrailingNewline'. /Since: 3.14/ -} #if ENABLE_OVERLOADING BufferImplicitTrailingNewlinePropertyInfo, #endif #if ENABLE_OVERLOADING bufferImplicitTrailingNewline , #endif constructBufferImplicitTrailingNewline , getBufferImplicitTrailingNewline , setBufferImplicitTrailingNewline , -- ** language #attr:language# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING BufferLanguagePropertyInfo , #endif #if ENABLE_OVERLOADING bufferLanguage , #endif clearBufferLanguage , constructBufferLanguage , getBufferLanguage , setBufferLanguage , -- ** maxUndoLevels #attr:maxUndoLevels# {- | Number of undo levels for the buffer. -1 means no limit. This property will only affect the default undo manager. -} #if ENABLE_OVERLOADING BufferMaxUndoLevelsPropertyInfo , #endif #if ENABLE_OVERLOADING bufferMaxUndoLevels , #endif constructBufferMaxUndoLevels , getBufferMaxUndoLevels , setBufferMaxUndoLevels , -- ** styleScheme #attr:styleScheme# {- | Style scheme. It contains styles for syntax highlighting, optionally foreground, background, cursor color, current line color, and matching brackets style. -} #if ENABLE_OVERLOADING BufferStyleSchemePropertyInfo , #endif #if ENABLE_OVERLOADING bufferStyleScheme , #endif clearBufferStyleScheme , constructBufferStyleScheme , getBufferStyleScheme , setBufferStyleScheme , -- ** undoManager #attr:undoManager# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING BufferUndoManagerPropertyInfo , #endif #if ENABLE_OVERLOADING bufferUndoManager , #endif clearBufferUndoManager , constructBufferUndoManager , getBufferUndoManager , setBufferUndoManager , -- * Signals -- ** bracketMatched #signal:bracketMatched# BufferBracketMatchedCallback , #if ENABLE_OVERLOADING BufferBracketMatchedSignalInfo , #endif C_BufferBracketMatchedCallback , afterBufferBracketMatched , genClosure_BufferBracketMatched , mk_BufferBracketMatchedCallback , noBufferBracketMatchedCallback , onBufferBracketMatched , wrap_BufferBracketMatchedCallback , -- ** highlightUpdated #signal:highlightUpdated# BufferHighlightUpdatedCallback , #if ENABLE_OVERLOADING BufferHighlightUpdatedSignalInfo , #endif C_BufferHighlightUpdatedCallback , afterBufferHighlightUpdated , genClosure_BufferHighlightUpdated , mk_BufferHighlightUpdatedCallback , noBufferHighlightUpdatedCallback , onBufferHighlightUpdated , wrap_BufferHighlightUpdatedCallback , -- ** redo #signal:redo# BufferRedoCallback , #if ENABLE_OVERLOADING BufferRedoSignalInfo , #endif C_BufferRedoCallback , afterBufferRedo , genClosure_BufferRedo , mk_BufferRedoCallback , noBufferRedoCallback , onBufferRedo , wrap_BufferRedoCallback , -- ** sourceMarkUpdated #signal:sourceMarkUpdated# BufferSourceMarkUpdatedCallback , #if ENABLE_OVERLOADING BufferSourceMarkUpdatedSignalInfo , #endif C_BufferSourceMarkUpdatedCallback , afterBufferSourceMarkUpdated , genClosure_BufferSourceMarkUpdated , mk_BufferSourceMarkUpdatedCallback , noBufferSourceMarkUpdatedCallback , onBufferSourceMarkUpdated , wrap_BufferSourceMarkUpdatedCallback , -- ** undo #signal:undo# BufferUndoCallback , #if ENABLE_OVERLOADING BufferUndoSignalInfo , #endif C_BufferUndoCallback , afterBufferUndo , genClosure_BufferUndo , mk_BufferUndoCallback , noBufferUndoCallback , onBufferUndo , wrap_BufferUndoCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer import qualified GI.Gtk.Objects.TextMark as Gtk.TextMark import qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.UndoManager as GtkSource.UndoManager import {-# SOURCE #-} qualified GI.GtkSource.Objects.Language as GtkSource.Language import {-# SOURCE #-} qualified GI.GtkSource.Objects.Mark as GtkSource.Mark import {-# SOURCE #-} qualified GI.GtkSource.Objects.StyleScheme as GtkSource.StyleScheme -- | Memory-managed wrapper type. newtype Buffer = Buffer (ManagedPtr Buffer) foreign import ccall "gtk_source_buffer_get_type" c_gtk_source_buffer_get_type :: IO GType instance GObject Buffer where gobjectType = c_gtk_source_buffer_get_type -- | Type class for types which can be safely cast to `Buffer`, for instance with `toBuffer`. class (GObject o, O.IsDescendantOf Buffer o) => IsBuffer o instance (GObject o, O.IsDescendantOf Buffer o) => IsBuffer o instance O.HasParentTypes Buffer type instance O.ParentTypes Buffer = '[Gtk.TextBuffer.TextBuffer, GObject.Object.Object] -- | Cast to `Buffer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toBuffer :: (MonadIO m, IsBuffer o) => o -> m Buffer toBuffer = liftIO . unsafeCastTo Buffer -- | A convenience alias for `Nothing` :: `Maybe` `Buffer`. noBuffer :: Maybe Buffer noBuffer = Nothing #if ENABLE_OVERLOADING type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where ResolveBufferMethod "addMark" o = Gtk.TextBuffer.TextBufferAddMarkMethodInfo ResolveBufferMethod "addSelectionClipboard" o = Gtk.TextBuffer.TextBufferAddSelectionClipboardMethodInfo ResolveBufferMethod "applyTag" o = Gtk.TextBuffer.TextBufferApplyTagMethodInfo ResolveBufferMethod "applyTagByName" o = Gtk.TextBuffer.TextBufferApplyTagByNameMethodInfo ResolveBufferMethod "backspace" o = Gtk.TextBuffer.TextBufferBackspaceMethodInfo ResolveBufferMethod "backwardIterToSourceMark" o = BufferBackwardIterToSourceMarkMethodInfo ResolveBufferMethod "beginNotUndoableAction" o = BufferBeginNotUndoableActionMethodInfo ResolveBufferMethod "beginUserAction" o = Gtk.TextBuffer.TextBufferBeginUserActionMethodInfo ResolveBufferMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveBufferMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveBufferMethod "canRedo" o = BufferCanRedoMethodInfo ResolveBufferMethod "canUndo" o = BufferCanUndoMethodInfo ResolveBufferMethod "changeCase" o = BufferChangeCaseMethodInfo ResolveBufferMethod "copyClipboard" o = Gtk.TextBuffer.TextBufferCopyClipboardMethodInfo ResolveBufferMethod "createChildAnchor" o = Gtk.TextBuffer.TextBufferCreateChildAnchorMethodInfo ResolveBufferMethod "createMark" o = Gtk.TextBuffer.TextBufferCreateMarkMethodInfo ResolveBufferMethod "createSourceMark" o = BufferCreateSourceMarkMethodInfo ResolveBufferMethod "cutClipboard" o = Gtk.TextBuffer.TextBufferCutClipboardMethodInfo ResolveBufferMethod "delete" o = Gtk.TextBuffer.TextBufferDeleteMethodInfo ResolveBufferMethod "deleteInteractive" o = Gtk.TextBuffer.TextBufferDeleteInteractiveMethodInfo ResolveBufferMethod "deleteMark" o = Gtk.TextBuffer.TextBufferDeleteMarkMethodInfo ResolveBufferMethod "deleteMarkByName" o = Gtk.TextBuffer.TextBufferDeleteMarkByNameMethodInfo ResolveBufferMethod "deleteSelection" o = Gtk.TextBuffer.TextBufferDeleteSelectionMethodInfo ResolveBufferMethod "deserialize" o = Gtk.TextBuffer.TextBufferDeserializeMethodInfo ResolveBufferMethod "deserializeGetCanCreateTags" o = Gtk.TextBuffer.TextBufferDeserializeGetCanCreateTagsMethodInfo ResolveBufferMethod "deserializeSetCanCreateTags" o = Gtk.TextBuffer.TextBufferDeserializeSetCanCreateTagsMethodInfo ResolveBufferMethod "endNotUndoableAction" o = BufferEndNotUndoableActionMethodInfo ResolveBufferMethod "endUserAction" o = Gtk.TextBuffer.TextBufferEndUserActionMethodInfo ResolveBufferMethod "ensureHighlight" o = BufferEnsureHighlightMethodInfo ResolveBufferMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveBufferMethod "forwardIterToSourceMark" o = BufferForwardIterToSourceMarkMethodInfo ResolveBufferMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveBufferMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveBufferMethod "insert" o = Gtk.TextBuffer.TextBufferInsertMethodInfo ResolveBufferMethod "insertAtCursor" o = Gtk.TextBuffer.TextBufferInsertAtCursorMethodInfo ResolveBufferMethod "insertChildAnchor" o = Gtk.TextBuffer.TextBufferInsertChildAnchorMethodInfo ResolveBufferMethod "insertInteractive" o = Gtk.TextBuffer.TextBufferInsertInteractiveMethodInfo ResolveBufferMethod "insertInteractiveAtCursor" o = Gtk.TextBuffer.TextBufferInsertInteractiveAtCursorMethodInfo ResolveBufferMethod "insertMarkup" o = Gtk.TextBuffer.TextBufferInsertMarkupMethodInfo ResolveBufferMethod "insertPixbuf" o = Gtk.TextBuffer.TextBufferInsertPixbufMethodInfo ResolveBufferMethod "insertRange" o = Gtk.TextBuffer.TextBufferInsertRangeMethodInfo ResolveBufferMethod "insertRangeInteractive" o = Gtk.TextBuffer.TextBufferInsertRangeInteractiveMethodInfo ResolveBufferMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveBufferMethod "iterBackwardToContextClassToggle" o = BufferIterBackwardToContextClassToggleMethodInfo ResolveBufferMethod "iterForwardToContextClassToggle" o = BufferIterForwardToContextClassToggleMethodInfo ResolveBufferMethod "iterHasContextClass" o = BufferIterHasContextClassMethodInfo ResolveBufferMethod "joinLines" o = BufferJoinLinesMethodInfo ResolveBufferMethod "moveMark" o = Gtk.TextBuffer.TextBufferMoveMarkMethodInfo ResolveBufferMethod "moveMarkByName" o = Gtk.TextBuffer.TextBufferMoveMarkByNameMethodInfo ResolveBufferMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveBufferMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveBufferMethod "pasteClipboard" o = Gtk.TextBuffer.TextBufferPasteClipboardMethodInfo ResolveBufferMethod "placeCursor" o = Gtk.TextBuffer.TextBufferPlaceCursorMethodInfo ResolveBufferMethod "redo" o = BufferRedoMethodInfo ResolveBufferMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveBufferMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveBufferMethod "registerDeserializeFormat" o = Gtk.TextBuffer.TextBufferRegisterDeserializeFormatMethodInfo ResolveBufferMethod "registerDeserializeTagset" o = Gtk.TextBuffer.TextBufferRegisterDeserializeTagsetMethodInfo ResolveBufferMethod "registerSerializeFormat" o = Gtk.TextBuffer.TextBufferRegisterSerializeFormatMethodInfo ResolveBufferMethod "registerSerializeTagset" o = Gtk.TextBuffer.TextBufferRegisterSerializeTagsetMethodInfo ResolveBufferMethod "removeAllTags" o = Gtk.TextBuffer.TextBufferRemoveAllTagsMethodInfo ResolveBufferMethod "removeSelectionClipboard" o = Gtk.TextBuffer.TextBufferRemoveSelectionClipboardMethodInfo ResolveBufferMethod "removeSourceMarks" o = BufferRemoveSourceMarksMethodInfo ResolveBufferMethod "removeTag" o = Gtk.TextBuffer.TextBufferRemoveTagMethodInfo ResolveBufferMethod "removeTagByName" o = Gtk.TextBuffer.TextBufferRemoveTagByNameMethodInfo ResolveBufferMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveBufferMethod "selectRange" o = Gtk.TextBuffer.TextBufferSelectRangeMethodInfo ResolveBufferMethod "serialize" o = Gtk.TextBuffer.TextBufferSerializeMethodInfo ResolveBufferMethod "sortLines" o = BufferSortLinesMethodInfo ResolveBufferMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveBufferMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveBufferMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveBufferMethod "undo" o = BufferUndoMethodInfo ResolveBufferMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveBufferMethod "unregisterDeserializeFormat" o = Gtk.TextBuffer.TextBufferUnregisterDeserializeFormatMethodInfo ResolveBufferMethod "unregisterSerializeFormat" o = Gtk.TextBuffer.TextBufferUnregisterSerializeFormatMethodInfo ResolveBufferMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveBufferMethod "getBounds" o = Gtk.TextBuffer.TextBufferGetBoundsMethodInfo ResolveBufferMethod "getCharCount" o = Gtk.TextBuffer.TextBufferGetCharCountMethodInfo ResolveBufferMethod "getContextClassesAtIter" o = BufferGetContextClassesAtIterMethodInfo ResolveBufferMethod "getCopyTargetList" o = Gtk.TextBuffer.TextBufferGetCopyTargetListMethodInfo ResolveBufferMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveBufferMethod "getDeserializeFormats" o = Gtk.TextBuffer.TextBufferGetDeserializeFormatsMethodInfo ResolveBufferMethod "getEndIter" o = Gtk.TextBuffer.TextBufferGetEndIterMethodInfo ResolveBufferMethod "getHasSelection" o = Gtk.TextBuffer.TextBufferGetHasSelectionMethodInfo ResolveBufferMethod "getHighlightMatchingBrackets" o = BufferGetHighlightMatchingBracketsMethodInfo ResolveBufferMethod "getHighlightSyntax" o = BufferGetHighlightSyntaxMethodInfo ResolveBufferMethod "getImplicitTrailingNewline" o = BufferGetImplicitTrailingNewlineMethodInfo ResolveBufferMethod "getInsert" o = Gtk.TextBuffer.TextBufferGetInsertMethodInfo ResolveBufferMethod "getIterAtChildAnchor" o = Gtk.TextBuffer.TextBufferGetIterAtChildAnchorMethodInfo ResolveBufferMethod "getIterAtLine" o = Gtk.TextBuffer.TextBufferGetIterAtLineMethodInfo ResolveBufferMethod "getIterAtLineIndex" o = Gtk.TextBuffer.TextBufferGetIterAtLineIndexMethodInfo ResolveBufferMethod "getIterAtLineOffset" o = Gtk.TextBuffer.TextBufferGetIterAtLineOffsetMethodInfo ResolveBufferMethod "getIterAtMark" o = Gtk.TextBuffer.TextBufferGetIterAtMarkMethodInfo ResolveBufferMethod "getIterAtOffset" o = Gtk.TextBuffer.TextBufferGetIterAtOffsetMethodInfo ResolveBufferMethod "getLanguage" o = BufferGetLanguageMethodInfo ResolveBufferMethod "getLineCount" o = Gtk.TextBuffer.TextBufferGetLineCountMethodInfo ResolveBufferMethod "getMark" o = Gtk.TextBuffer.TextBufferGetMarkMethodInfo ResolveBufferMethod "getMaxUndoLevels" o = BufferGetMaxUndoLevelsMethodInfo ResolveBufferMethod "getModified" o = Gtk.TextBuffer.TextBufferGetModifiedMethodInfo ResolveBufferMethod "getPasteTargetList" o = Gtk.TextBuffer.TextBufferGetPasteTargetListMethodInfo ResolveBufferMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveBufferMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveBufferMethod "getSelectionBound" o = Gtk.TextBuffer.TextBufferGetSelectionBoundMethodInfo ResolveBufferMethod "getSelectionBounds" o = Gtk.TextBuffer.TextBufferGetSelectionBoundsMethodInfo ResolveBufferMethod "getSerializeFormats" o = Gtk.TextBuffer.TextBufferGetSerializeFormatsMethodInfo ResolveBufferMethod "getSlice" o = Gtk.TextBuffer.TextBufferGetSliceMethodInfo ResolveBufferMethod "getSourceMarksAtIter" o = BufferGetSourceMarksAtIterMethodInfo ResolveBufferMethod "getSourceMarksAtLine" o = BufferGetSourceMarksAtLineMethodInfo ResolveBufferMethod "getStartIter" o = Gtk.TextBuffer.TextBufferGetStartIterMethodInfo ResolveBufferMethod "getStyleScheme" o = BufferGetStyleSchemeMethodInfo ResolveBufferMethod "getTagTable" o = Gtk.TextBuffer.TextBufferGetTagTableMethodInfo ResolveBufferMethod "getText" o = Gtk.TextBuffer.TextBufferGetTextMethodInfo ResolveBufferMethod "getUndoManager" o = BufferGetUndoManagerMethodInfo ResolveBufferMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveBufferMethod "setHighlightMatchingBrackets" o = BufferSetHighlightMatchingBracketsMethodInfo ResolveBufferMethod "setHighlightSyntax" o = BufferSetHighlightSyntaxMethodInfo ResolveBufferMethod "setImplicitTrailingNewline" o = BufferSetImplicitTrailingNewlineMethodInfo ResolveBufferMethod "setLanguage" o = BufferSetLanguageMethodInfo ResolveBufferMethod "setMaxUndoLevels" o = BufferSetMaxUndoLevelsMethodInfo ResolveBufferMethod "setModified" o = Gtk.TextBuffer.TextBufferSetModifiedMethodInfo ResolveBufferMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveBufferMethod "setStyleScheme" o = BufferSetStyleSchemeMethodInfo ResolveBufferMethod "setText" o = Gtk.TextBuffer.TextBufferSetTextMethodInfo ResolveBufferMethod "setUndoManager" o = BufferSetUndoManagerMethodInfo ResolveBufferMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveBufferMethod t Buffer, O.MethodInfo info Buffer p) => OL.IsLabel t (Buffer -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal Buffer::bracket-matched {- | /@iter@/ is set to a valid iterator pointing to the matching bracket if /@state@/ is 'GI.GtkSource.Enums.BracketMatchTypeFound'. Otherwise /@iter@/ is meaningless. The signal is emitted only when the /@state@/ changes, typically when the cursor moves. A use-case for this signal is to show messages in a 'GI.Gtk.Objects.Statusbar.Statusbar'. /Since: 2.12/ -} type BufferBracketMatchedCallback = Maybe Gtk.TextIter.TextIter {- ^ /@iter@/: if found, the location of the matching bracket. -} -> GtkSource.Enums.BracketMatchType {- ^ /@state@/: state of bracket matching. -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BufferBracketMatchedCallback`@. noBufferBracketMatchedCallback :: Maybe BufferBracketMatchedCallback noBufferBracketMatchedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BufferBracketMatchedCallback = Ptr () -> -- object Ptr Gtk.TextIter.TextIter -> CUInt -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BufferBracketMatchedCallback`. foreign import ccall "wrapper" mk_BufferBracketMatchedCallback :: C_BufferBracketMatchedCallback -> IO (FunPtr C_BufferBracketMatchedCallback) -- | Wrap the callback into a `GClosure`. genClosure_BufferBracketMatched :: MonadIO m => BufferBracketMatchedCallback -> m (GClosure C_BufferBracketMatchedCallback) genClosure_BufferBracketMatched cb = liftIO $ do let cb' = wrap_BufferBracketMatchedCallback cb mk_BufferBracketMatchedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BufferBracketMatchedCallback` into a `C_BufferBracketMatchedCallback`. wrap_BufferBracketMatchedCallback :: BufferBracketMatchedCallback -> C_BufferBracketMatchedCallback wrap_BufferBracketMatchedCallback _cb _ iter state _ = do maybeIter <- if iter == nullPtr then return Nothing else do B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do return $ Just iter' let state' = (toEnum . fromIntegral) state _cb maybeIter state' {- | Connect a signal handler for the “@bracket-matched@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' buffer #bracketMatched callback @ -} onBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId onBufferBracketMatched obj cb = liftIO $ do let cb' = wrap_BufferBracketMatchedCallback cb cb'' <- mk_BufferBracketMatchedCallback cb' connectSignalFunPtr obj "bracket-matched" cb'' SignalConnectBefore {- | Connect a signal handler for the “@bracket-matched@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' buffer #bracketMatched callback @ -} afterBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId afterBufferBracketMatched obj cb = liftIO $ do let cb' = wrap_BufferBracketMatchedCallback cb cb'' <- mk_BufferBracketMatchedCallback cb' connectSignalFunPtr obj "bracket-matched" cb'' SignalConnectAfter -- signal Buffer::highlight-updated {- | The ::highlight-updated signal is emitted when the syntax highlighting and [context classes][context-classes] are updated in a certain region of the /@buffer@/. -} type BufferHighlightUpdatedCallback = Gtk.TextIter.TextIter {- ^ /@start@/: the start of the updated region -} -> Gtk.TextIter.TextIter {- ^ /@end@/: the end of the updated region -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BufferHighlightUpdatedCallback`@. noBufferHighlightUpdatedCallback :: Maybe BufferHighlightUpdatedCallback noBufferHighlightUpdatedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BufferHighlightUpdatedCallback = Ptr () -> -- object Ptr Gtk.TextIter.TextIter -> Ptr Gtk.TextIter.TextIter -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BufferHighlightUpdatedCallback`. foreign import ccall "wrapper" mk_BufferHighlightUpdatedCallback :: C_BufferHighlightUpdatedCallback -> IO (FunPtr C_BufferHighlightUpdatedCallback) -- | Wrap the callback into a `GClosure`. genClosure_BufferHighlightUpdated :: MonadIO m => BufferHighlightUpdatedCallback -> m (GClosure C_BufferHighlightUpdatedCallback) genClosure_BufferHighlightUpdated cb = liftIO $ do let cb' = wrap_BufferHighlightUpdatedCallback cb mk_BufferHighlightUpdatedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BufferHighlightUpdatedCallback` into a `C_BufferHighlightUpdatedCallback`. wrap_BufferHighlightUpdatedCallback :: BufferHighlightUpdatedCallback -> C_BufferHighlightUpdatedCallback wrap_BufferHighlightUpdatedCallback _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 “@highlight-updated@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' buffer #highlightUpdated callback @ -} onBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId onBufferHighlightUpdated obj cb = liftIO $ do let cb' = wrap_BufferHighlightUpdatedCallback cb cb'' <- mk_BufferHighlightUpdatedCallback cb' connectSignalFunPtr obj "highlight-updated" cb'' SignalConnectBefore {- | Connect a signal handler for the “@highlight-updated@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' buffer #highlightUpdated callback @ -} afterBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId afterBufferHighlightUpdated obj cb = liftIO $ do let cb' = wrap_BufferHighlightUpdatedCallback cb cb'' <- mk_BufferHighlightUpdatedCallback cb' connectSignalFunPtr obj "highlight-updated" cb'' SignalConnectAfter -- signal Buffer::redo {- | The ::redo signal is emitted to redo the last undo operation. -} type BufferRedoCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BufferRedoCallback`@. noBufferRedoCallback :: Maybe BufferRedoCallback noBufferRedoCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BufferRedoCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BufferRedoCallback`. foreign import ccall "wrapper" mk_BufferRedoCallback :: C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback) -- | Wrap the callback into a `GClosure`. genClosure_BufferRedo :: MonadIO m => BufferRedoCallback -> m (GClosure C_BufferRedoCallback) genClosure_BufferRedo cb = liftIO $ do let cb' = wrap_BufferRedoCallback cb mk_BufferRedoCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BufferRedoCallback` into a `C_BufferRedoCallback`. wrap_BufferRedoCallback :: BufferRedoCallback -> C_BufferRedoCallback wrap_BufferRedoCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@redo@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' buffer #redo callback @ -} onBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId onBufferRedo obj cb = liftIO $ do let cb' = wrap_BufferRedoCallback cb cb'' <- mk_BufferRedoCallback cb' connectSignalFunPtr obj "redo" cb'' SignalConnectBefore {- | Connect a signal handler for the “@redo@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' buffer #redo callback @ -} afterBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId afterBufferRedo obj cb = liftIO $ do let cb' = wrap_BufferRedoCallback cb cb'' <- mk_BufferRedoCallback cb' connectSignalFunPtr obj "redo" cb'' SignalConnectAfter -- signal Buffer::source-mark-updated {- | The ::source-mark-updated signal is emitted each time a mark is added to, moved or removed from the /@buffer@/. -} type BufferSourceMarkUpdatedCallback = Gtk.TextMark.TextMark {- ^ /@mark@/: the 'GI.GtkSource.Objects.Mark.Mark' -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BufferSourceMarkUpdatedCallback`@. noBufferSourceMarkUpdatedCallback :: Maybe BufferSourceMarkUpdatedCallback noBufferSourceMarkUpdatedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BufferSourceMarkUpdatedCallback = Ptr () -> -- object Ptr Gtk.TextMark.TextMark -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BufferSourceMarkUpdatedCallback`. foreign import ccall "wrapper" mk_BufferSourceMarkUpdatedCallback :: C_BufferSourceMarkUpdatedCallback -> IO (FunPtr C_BufferSourceMarkUpdatedCallback) -- | Wrap the callback into a `GClosure`. genClosure_BufferSourceMarkUpdated :: MonadIO m => BufferSourceMarkUpdatedCallback -> m (GClosure C_BufferSourceMarkUpdatedCallback) genClosure_BufferSourceMarkUpdated cb = liftIO $ do let cb' = wrap_BufferSourceMarkUpdatedCallback cb mk_BufferSourceMarkUpdatedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BufferSourceMarkUpdatedCallback` into a `C_BufferSourceMarkUpdatedCallback`. wrap_BufferSourceMarkUpdatedCallback :: BufferSourceMarkUpdatedCallback -> C_BufferSourceMarkUpdatedCallback wrap_BufferSourceMarkUpdatedCallback _cb _ mark _ = do mark' <- (newObject Gtk.TextMark.TextMark) mark _cb mark' {- | Connect a signal handler for the “@source-mark-updated@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' buffer #sourceMarkUpdated callback @ -} onBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId onBufferSourceMarkUpdated obj cb = liftIO $ do let cb' = wrap_BufferSourceMarkUpdatedCallback cb cb'' <- mk_BufferSourceMarkUpdatedCallback cb' connectSignalFunPtr obj "source-mark-updated" cb'' SignalConnectBefore {- | Connect a signal handler for the “@source-mark-updated@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' buffer #sourceMarkUpdated callback @ -} afterBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId afterBufferSourceMarkUpdated obj cb = liftIO $ do let cb' = wrap_BufferSourceMarkUpdatedCallback cb cb'' <- mk_BufferSourceMarkUpdatedCallback cb' connectSignalFunPtr obj "source-mark-updated" cb'' SignalConnectAfter -- signal Buffer::undo {- | The ::undo signal is emitted to undo the last user action which modified the buffer. -} type BufferUndoCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BufferUndoCallback`@. noBufferUndoCallback :: Maybe BufferUndoCallback noBufferUndoCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BufferUndoCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BufferUndoCallback`. foreign import ccall "wrapper" mk_BufferUndoCallback :: C_BufferUndoCallback -> IO (FunPtr C_BufferUndoCallback) -- | Wrap the callback into a `GClosure`. genClosure_BufferUndo :: MonadIO m => BufferUndoCallback -> m (GClosure C_BufferUndoCallback) genClosure_BufferUndo cb = liftIO $ do let cb' = wrap_BufferUndoCallback cb mk_BufferUndoCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BufferUndoCallback` into a `C_BufferUndoCallback`. wrap_BufferUndoCallback :: BufferUndoCallback -> C_BufferUndoCallback wrap_BufferUndoCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@undo@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' buffer #undo callback @ -} onBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId onBufferUndo obj cb = liftIO $ do let cb' = wrap_BufferUndoCallback cb cb'' <- mk_BufferUndoCallback cb' connectSignalFunPtr obj "undo" cb'' SignalConnectBefore {- | Connect a signal handler for the “@undo@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' buffer #undo callback @ -} afterBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId afterBufferUndo obj cb = liftIO $ do let cb' = wrap_BufferUndoCallback cb cb'' <- mk_BufferUndoCallback cb' connectSignalFunPtr obj "undo" cb'' SignalConnectAfter -- VVV Prop "can-redo" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@can-redo@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #canRedo @ -} getBufferCanRedo :: (MonadIO m, IsBuffer o) => o -> m Bool getBufferCanRedo obj = liftIO $ B.Properties.getObjectPropertyBool obj "can-redo" #if ENABLE_OVERLOADING data BufferCanRedoPropertyInfo instance AttrInfo BufferCanRedoPropertyInfo where type AttrAllowedOps BufferCanRedoPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint BufferCanRedoPropertyInfo = (~) () type AttrBaseTypeConstraint BufferCanRedoPropertyInfo = IsBuffer type AttrGetType BufferCanRedoPropertyInfo = Bool type AttrLabel BufferCanRedoPropertyInfo = "can-redo" type AttrOrigin BufferCanRedoPropertyInfo = Buffer attrGet _ = getBufferCanRedo attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "can-undo" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@can-undo@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #canUndo @ -} getBufferCanUndo :: (MonadIO m, IsBuffer o) => o -> m Bool getBufferCanUndo obj = liftIO $ B.Properties.getObjectPropertyBool obj "can-undo" #if ENABLE_OVERLOADING data BufferCanUndoPropertyInfo instance AttrInfo BufferCanUndoPropertyInfo where type AttrAllowedOps BufferCanUndoPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint BufferCanUndoPropertyInfo = (~) () type AttrBaseTypeConstraint BufferCanUndoPropertyInfo = IsBuffer type AttrGetType BufferCanUndoPropertyInfo = Bool type AttrLabel BufferCanUndoPropertyInfo = "can-undo" type AttrOrigin BufferCanUndoPropertyInfo = Buffer attrGet _ = getBufferCanUndo attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "highlight-matching-brackets" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@highlight-matching-brackets@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #highlightMatchingBrackets @ -} getBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> m Bool getBufferHighlightMatchingBrackets obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-matching-brackets" {- | Set the value of the “@highlight-matching-brackets@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #highlightMatchingBrackets 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> Bool -> m () setBufferHighlightMatchingBrackets obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-matching-brackets" val {- | Construct a `GValueConstruct` with valid value for the “@highlight-matching-brackets@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferHighlightMatchingBrackets :: (IsBuffer o) => Bool -> IO (GValueConstruct o) constructBufferHighlightMatchingBrackets val = B.Properties.constructObjectPropertyBool "highlight-matching-brackets" val #if ENABLE_OVERLOADING data BufferHighlightMatchingBracketsPropertyInfo instance AttrInfo BufferHighlightMatchingBracketsPropertyInfo where type AttrAllowedOps BufferHighlightMatchingBracketsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = (~) Bool type AttrBaseTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = IsBuffer type AttrGetType BufferHighlightMatchingBracketsPropertyInfo = Bool type AttrLabel BufferHighlightMatchingBracketsPropertyInfo = "highlight-matching-brackets" type AttrOrigin BufferHighlightMatchingBracketsPropertyInfo = Buffer attrGet _ = getBufferHighlightMatchingBrackets attrSet _ = setBufferHighlightMatchingBrackets attrConstruct _ = constructBufferHighlightMatchingBrackets attrClear _ = undefined #endif -- VVV Prop "highlight-syntax" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@highlight-syntax@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #highlightSyntax @ -} getBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> m Bool getBufferHighlightSyntax obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-syntax" {- | Set the value of the “@highlight-syntax@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> Bool -> m () setBufferHighlightSyntax obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-syntax" val {- | Construct a `GValueConstruct` with valid value for the “@highlight-syntax@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferHighlightSyntax :: (IsBuffer o) => Bool -> IO (GValueConstruct o) constructBufferHighlightSyntax val = B.Properties.constructObjectPropertyBool "highlight-syntax" val #if ENABLE_OVERLOADING data BufferHighlightSyntaxPropertyInfo instance AttrInfo BufferHighlightSyntaxPropertyInfo where type AttrAllowedOps BufferHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint BufferHighlightSyntaxPropertyInfo = (~) Bool type AttrBaseTypeConstraint BufferHighlightSyntaxPropertyInfo = IsBuffer type AttrGetType BufferHighlightSyntaxPropertyInfo = Bool type AttrLabel BufferHighlightSyntaxPropertyInfo = "highlight-syntax" type AttrOrigin BufferHighlightSyntaxPropertyInfo = Buffer attrGet _ = getBufferHighlightSyntax attrSet _ = setBufferHighlightSyntax attrConstruct _ = constructBufferHighlightSyntax attrClear _ = undefined #endif -- VVV Prop "implicit-trailing-newline" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@implicit-trailing-newline@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #implicitTrailingNewline @ -} getBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> m Bool getBufferImplicitTrailingNewline obj = liftIO $ B.Properties.getObjectPropertyBool obj "implicit-trailing-newline" {- | Set the value of the “@implicit-trailing-newline@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #implicitTrailingNewline 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> Bool -> m () setBufferImplicitTrailingNewline obj val = liftIO $ B.Properties.setObjectPropertyBool obj "implicit-trailing-newline" val {- | Construct a `GValueConstruct` with valid value for the “@implicit-trailing-newline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferImplicitTrailingNewline :: (IsBuffer o) => Bool -> IO (GValueConstruct o) constructBufferImplicitTrailingNewline val = B.Properties.constructObjectPropertyBool "implicit-trailing-newline" val #if ENABLE_OVERLOADING data BufferImplicitTrailingNewlinePropertyInfo instance AttrInfo BufferImplicitTrailingNewlinePropertyInfo where type AttrAllowedOps BufferImplicitTrailingNewlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = (~) Bool type AttrBaseTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = IsBuffer type AttrGetType BufferImplicitTrailingNewlinePropertyInfo = Bool type AttrLabel BufferImplicitTrailingNewlinePropertyInfo = "implicit-trailing-newline" type AttrOrigin BufferImplicitTrailingNewlinePropertyInfo = Buffer attrGet _ = getBufferImplicitTrailingNewline attrSet _ = setBufferImplicitTrailingNewline attrConstruct _ = constructBufferImplicitTrailingNewline attrClear _ = undefined #endif -- VVV Prop "language" -- Type: TInterface (Name {namespace = "GtkSource", name = "Language"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just True,Just True) {- | Get the value of the “@language@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #language @ -} getBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.Language.Language) getBufferLanguage obj = liftIO $ B.Properties.getObjectPropertyObject obj "language" GtkSource.Language.Language {- | Set the value of the “@language@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #language 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferLanguage :: (MonadIO m, IsBuffer o, GtkSource.Language.IsLanguage a) => o -> a -> m () setBufferLanguage obj val = liftIO $ B.Properties.setObjectPropertyObject obj "language" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@language@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferLanguage :: (IsBuffer o, GtkSource.Language.IsLanguage a) => a -> IO (GValueConstruct o) constructBufferLanguage val = B.Properties.constructObjectPropertyObject "language" (Just val) {- | Set the value of the “@language@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #language @ -} clearBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m () clearBufferLanguage obj = liftIO $ B.Properties.setObjectPropertyObject obj "language" (Nothing :: Maybe GtkSource.Language.Language) #if ENABLE_OVERLOADING data BufferLanguagePropertyInfo instance AttrInfo BufferLanguagePropertyInfo where type AttrAllowedOps BufferLanguagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint BufferLanguagePropertyInfo = GtkSource.Language.IsLanguage type AttrBaseTypeConstraint BufferLanguagePropertyInfo = IsBuffer type AttrGetType BufferLanguagePropertyInfo = (Maybe GtkSource.Language.Language) type AttrLabel BufferLanguagePropertyInfo = "language" type AttrOrigin BufferLanguagePropertyInfo = Buffer attrGet _ = getBufferLanguage attrSet _ = setBufferLanguage attrConstruct _ = constructBufferLanguage attrClear _ = clearBufferLanguage #endif -- VVV Prop "max-undo-levels" -- Type: TBasicType TInt -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@max-undo-levels@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #maxUndoLevels @ -} getBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> m Int32 getBufferMaxUndoLevels obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "max-undo-levels" {- | Set the value of the “@max-undo-levels@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #maxUndoLevels 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> Int32 -> m () setBufferMaxUndoLevels obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "max-undo-levels" val {- | Construct a `GValueConstruct` with valid value for the “@max-undo-levels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferMaxUndoLevels :: (IsBuffer o) => Int32 -> IO (GValueConstruct o) constructBufferMaxUndoLevels val = B.Properties.constructObjectPropertyInt32 "max-undo-levels" val #if ENABLE_OVERLOADING data BufferMaxUndoLevelsPropertyInfo instance AttrInfo BufferMaxUndoLevelsPropertyInfo where type AttrAllowedOps BufferMaxUndoLevelsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint BufferMaxUndoLevelsPropertyInfo = (~) Int32 type AttrBaseTypeConstraint BufferMaxUndoLevelsPropertyInfo = IsBuffer type AttrGetType BufferMaxUndoLevelsPropertyInfo = Int32 type AttrLabel BufferMaxUndoLevelsPropertyInfo = "max-undo-levels" type AttrOrigin BufferMaxUndoLevelsPropertyInfo = Buffer attrGet _ = getBufferMaxUndoLevels attrSet _ = setBufferMaxUndoLevels attrConstruct _ = constructBufferMaxUndoLevels attrClear _ = undefined #endif -- VVV Prop "style-scheme" -- Type: TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just True,Just True) {- | Get the value of the “@style-scheme@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #styleScheme @ -} getBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.StyleScheme.StyleScheme) getBufferStyleScheme obj = liftIO $ B.Properties.getObjectPropertyObject obj "style-scheme" GtkSource.StyleScheme.StyleScheme {- | Set the value of the “@style-scheme@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #styleScheme 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferStyleScheme :: (MonadIO m, IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => o -> a -> m () setBufferStyleScheme obj val = liftIO $ B.Properties.setObjectPropertyObject obj "style-scheme" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@style-scheme@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferStyleScheme :: (IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => a -> IO (GValueConstruct o) constructBufferStyleScheme val = B.Properties.constructObjectPropertyObject "style-scheme" (Just val) {- | Set the value of the “@style-scheme@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #styleScheme @ -} clearBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m () clearBufferStyleScheme obj = liftIO $ B.Properties.setObjectPropertyObject obj "style-scheme" (Nothing :: Maybe GtkSource.StyleScheme.StyleScheme) #if ENABLE_OVERLOADING data BufferStyleSchemePropertyInfo instance AttrInfo BufferStyleSchemePropertyInfo where type AttrAllowedOps BufferStyleSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint BufferStyleSchemePropertyInfo = GtkSource.StyleScheme.IsStyleScheme type AttrBaseTypeConstraint BufferStyleSchemePropertyInfo = IsBuffer type AttrGetType BufferStyleSchemePropertyInfo = (Maybe GtkSource.StyleScheme.StyleScheme) type AttrLabel BufferStyleSchemePropertyInfo = "style-scheme" type AttrOrigin BufferStyleSchemePropertyInfo = Buffer attrGet _ = getBufferStyleScheme attrSet _ = setBufferStyleScheme attrConstruct _ = constructBufferStyleScheme attrClear _ = clearBufferStyleScheme #endif -- VVV Prop "undo-manager" -- Type: TInterface (Name {namespace = "GtkSource", name = "UndoManager"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just True,Just True) {- | Get the value of the “@undo-manager@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #undoManager @ -} getBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.UndoManager.UndoManager) getBufferUndoManager obj = liftIO $ B.Properties.getObjectPropertyObject obj "undo-manager" GtkSource.UndoManager.UndoManager {- | Set the value of the “@undo-manager@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #undoManager 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferUndoManager :: (MonadIO m, IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => o -> a -> m () setBufferUndoManager obj val = liftIO $ B.Properties.setObjectPropertyObject obj "undo-manager" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@undo-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBufferUndoManager :: (IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => a -> IO (GValueConstruct o) constructBufferUndoManager val = B.Properties.constructObjectPropertyObject "undo-manager" (Just val) {- | Set the value of the “@undo-manager@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #undoManager @ -} clearBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m () clearBufferUndoManager obj = liftIO $ B.Properties.setObjectPropertyObject obj "undo-manager" (Nothing :: Maybe GtkSource.UndoManager.UndoManager) #if ENABLE_OVERLOADING data BufferUndoManagerPropertyInfo instance AttrInfo BufferUndoManagerPropertyInfo where type AttrAllowedOps BufferUndoManagerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint BufferUndoManagerPropertyInfo = GtkSource.UndoManager.IsUndoManager type AttrBaseTypeConstraint BufferUndoManagerPropertyInfo = IsBuffer type AttrGetType BufferUndoManagerPropertyInfo = (Maybe GtkSource.UndoManager.UndoManager) type AttrLabel BufferUndoManagerPropertyInfo = "undo-manager" type AttrOrigin BufferUndoManagerPropertyInfo = Buffer attrGet _ = getBufferUndoManager attrSet _ = setBufferUndoManager attrConstruct _ = constructBufferUndoManager attrClear _ = clearBufferUndoManager #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Buffer type instance O.AttributeList Buffer = BufferAttributeList type BufferAttributeList = ('[ '("canRedo", BufferCanRedoPropertyInfo), '("canUndo", BufferCanUndoPropertyInfo), '("copyTargetList", Gtk.TextBuffer.TextBufferCopyTargetListPropertyInfo), '("cursorPosition", Gtk.TextBuffer.TextBufferCursorPositionPropertyInfo), '("hasSelection", Gtk.TextBuffer.TextBufferHasSelectionPropertyInfo), '("highlightMatchingBrackets", BufferHighlightMatchingBracketsPropertyInfo), '("highlightSyntax", BufferHighlightSyntaxPropertyInfo), '("implicitTrailingNewline", BufferImplicitTrailingNewlinePropertyInfo), '("language", BufferLanguagePropertyInfo), '("maxUndoLevels", BufferMaxUndoLevelsPropertyInfo), '("pasteTargetList", Gtk.TextBuffer.TextBufferPasteTargetListPropertyInfo), '("styleScheme", BufferStyleSchemePropertyInfo), '("tagTable", Gtk.TextBuffer.TextBufferTagTablePropertyInfo), '("text", Gtk.TextBuffer.TextBufferTextPropertyInfo), '("undoManager", BufferUndoManagerPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING bufferHighlightMatchingBrackets :: AttrLabelProxy "highlightMatchingBrackets" bufferHighlightMatchingBrackets = AttrLabelProxy bufferHighlightSyntax :: AttrLabelProxy "highlightSyntax" bufferHighlightSyntax = AttrLabelProxy bufferImplicitTrailingNewline :: AttrLabelProxy "implicitTrailingNewline" bufferImplicitTrailingNewline = AttrLabelProxy bufferLanguage :: AttrLabelProxy "language" bufferLanguage = AttrLabelProxy bufferMaxUndoLevels :: AttrLabelProxy "maxUndoLevels" bufferMaxUndoLevels = AttrLabelProxy bufferStyleScheme :: AttrLabelProxy "styleScheme" bufferStyleScheme = AttrLabelProxy bufferUndoManager :: AttrLabelProxy "undoManager" bufferUndoManager = AttrLabelProxy #endif #if ENABLE_OVERLOADING data BufferBracketMatchedSignalInfo instance SignalInfo BufferBracketMatchedSignalInfo where type HaskellCallbackType BufferBracketMatchedSignalInfo = BufferBracketMatchedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BufferBracketMatchedCallback cb cb'' <- mk_BufferBracketMatchedCallback cb' connectSignalFunPtr obj "bracket-matched" cb'' connectMode data BufferHighlightUpdatedSignalInfo instance SignalInfo BufferHighlightUpdatedSignalInfo where type HaskellCallbackType BufferHighlightUpdatedSignalInfo = BufferHighlightUpdatedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BufferHighlightUpdatedCallback cb cb'' <- mk_BufferHighlightUpdatedCallback cb' connectSignalFunPtr obj "highlight-updated" cb'' connectMode data BufferRedoSignalInfo instance SignalInfo BufferRedoSignalInfo where type HaskellCallbackType BufferRedoSignalInfo = BufferRedoCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BufferRedoCallback cb cb'' <- mk_BufferRedoCallback cb' connectSignalFunPtr obj "redo" cb'' connectMode data BufferSourceMarkUpdatedSignalInfo instance SignalInfo BufferSourceMarkUpdatedSignalInfo where type HaskellCallbackType BufferSourceMarkUpdatedSignalInfo = BufferSourceMarkUpdatedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BufferSourceMarkUpdatedCallback cb cb'' <- mk_BufferSourceMarkUpdatedCallback cb' connectSignalFunPtr obj "source-mark-updated" cb'' connectMode data BufferUndoSignalInfo instance SignalInfo BufferUndoSignalInfo where type HaskellCallbackType BufferUndoSignalInfo = BufferUndoCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BufferUndoCallback cb cb'' <- mk_BufferUndoCallback cb' connectSignalFunPtr obj "undo" cb'' connectMode type instance O.SignalList Buffer = BufferSignalList type BufferSignalList = ('[ '("applyTag", Gtk.TextBuffer.TextBufferApplyTagSignalInfo), '("beginUserAction", Gtk.TextBuffer.TextBufferBeginUserActionSignalInfo), '("bracketMatched", BufferBracketMatchedSignalInfo), '("changed", Gtk.TextBuffer.TextBufferChangedSignalInfo), '("deleteRange", Gtk.TextBuffer.TextBufferDeleteRangeSignalInfo), '("endUserAction", Gtk.TextBuffer.TextBufferEndUserActionSignalInfo), '("highlightUpdated", BufferHighlightUpdatedSignalInfo), '("insertChildAnchor", Gtk.TextBuffer.TextBufferInsertChildAnchorSignalInfo), '("insertPixbuf", Gtk.TextBuffer.TextBufferInsertPixbufSignalInfo), '("insertText", Gtk.TextBuffer.TextBufferInsertTextSignalInfo), '("markDeleted", Gtk.TextBuffer.TextBufferMarkDeletedSignalInfo), '("markSet", Gtk.TextBuffer.TextBufferMarkSetSignalInfo), '("modifiedChanged", Gtk.TextBuffer.TextBufferModifiedChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pasteDone", Gtk.TextBuffer.TextBufferPasteDoneSignalInfo), '("redo", BufferRedoSignalInfo), '("removeTag", Gtk.TextBuffer.TextBufferRemoveTagSignalInfo), '("sourceMarkUpdated", BufferSourceMarkUpdatedSignalInfo), '("undo", BufferUndoSignalInfo)] :: [(Symbol, *)]) #endif -- method Buffer::new -- method type : Constructor -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Gtk", name = "TextTagTable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTextTagTable, or %NULL to create a new one.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Buffer"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_new" gtk_source_buffer_new :: Ptr Gtk.TextTagTable.TextTagTable -> -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"}) IO (Ptr Buffer) {- | Creates a new source buffer. -} bufferNew :: (B.CallStack.HasCallStack, MonadIO m, Gtk.TextTagTable.IsTextTagTable a) => Maybe (a) {- ^ /@table@/: a 'GI.Gtk.Objects.TextTagTable.TextTagTable', or 'Nothing' to create a new one. -} -> m Buffer {- ^ __Returns:__ a new source buffer. -} bufferNew table = liftIO $ do maybeTable <- case table of Nothing -> return nullPtr Just jTable -> do jTable' <- unsafeManagedPtrCastPtr jTable return jTable' result <- gtk_source_buffer_new maybeTable checkUnexpectedReturnNULL "bufferNew" result result' <- (wrapObject Buffer) result whenJust table touchManagedPtr return result' #if ENABLE_OVERLOADING #endif -- method Buffer::new_with_language -- method type : Constructor -- Args : [Arg {argCName = "language", argType = TInterface (Name {namespace = "GtkSource", name = "Language"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Buffer"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_new_with_language" gtk_source_buffer_new_with_language :: Ptr GtkSource.Language.Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) IO (Ptr Buffer) {- | Creates a new source buffer using the highlighting patterns in /@language@/. This is equivalent to creating a new source buffer with a new tag table and then calling 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. -} bufferNewWithLanguage :: (B.CallStack.HasCallStack, MonadIO m, GtkSource.Language.IsLanguage a) => a {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} -> m Buffer {- ^ __Returns:__ a new source buffer which will highlight text according to the highlighting patterns in /@language@/. -} bufferNewWithLanguage language = liftIO $ do language' <- unsafeManagedPtrCastPtr language result <- gtk_source_buffer_new_with_language language' checkUnexpectedReturnNULL "bufferNewWithLanguage" result result' <- (wrapObject Buffer) result touchManagedPtr language return result' #if ENABLE_OVERLOADING #endif -- method Buffer::backward_iter_to_source_mark -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_backward_iter_to_source_mark" gtk_source_buffer_backward_iter_to_source_mark :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- category : TBasicType TUTF8 IO CInt {- | Moves /@iter@/ to the position of the previous 'GI.GtkSource.Objects.Mark.Mark' of the given category. Returns 'True' if /@iter@/ was moved. If /@category@/ is NULL, the previous source mark can be of any category. /Since: 2.2/ -} bufferBackwardIterToSourceMark :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: an iterator. -} -> Maybe (T.Text) {- ^ /@category@/: category to search for, or 'Nothing' -} -> m Bool {- ^ __Returns:__ whether /@iter@/ was moved. -} bufferBackwardIterToSourceMark buffer iter category = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter maybeCategory <- case category of Nothing -> return nullPtr Just jCategory -> do jCategory' <- textToCString jCategory return jCategory' result <- gtk_source_buffer_backward_iter_to_source_mark buffer' iter' maybeCategory let result' = (/= 0) result touchManagedPtr buffer touchManagedPtr iter freeMem maybeCategory return result' #if ENABLE_OVERLOADING data BufferBackwardIterToSourceMarkMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferBackwardIterToSourceMarkMethodInfo a signature where overloadedMethod _ = bufferBackwardIterToSourceMark #endif -- method Buffer::begin_not_undoable_action -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_begin_not_undoable_action" gtk_source_buffer_begin_not_undoable_action :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO () {- | Marks the beginning of a not undoable action on the buffer, disabling the undo manager. Typically you would call this function before initially setting the contents of the buffer (e.g. when loading a file in a text editor). You may nest 'GI.GtkSource.Objects.Buffer.bufferBeginNotUndoableAction' \/ 'GI.GtkSource.Objects.Buffer.bufferEndNotUndoableAction' blocks. -} bufferBeginNotUndoableAction :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m () bufferBeginNotUndoableAction buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer gtk_source_buffer_begin_not_undoable_action buffer' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferBeginNotUndoableActionMethodInfo instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferBeginNotUndoableActionMethodInfo a signature where overloadedMethod _ = bufferBeginNotUndoableAction #endif -- method Buffer::can_redo -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_can_redo" gtk_source_buffer_can_redo :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO CInt {- | Determines whether a source buffer can redo the last action (i.e. if the last operation was an undo). -} bufferCanRedo :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Bool {- ^ __Returns:__ 'True' if a redo is possible. -} bufferCanRedo buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_can_redo buffer' let result' = (/= 0) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data BufferCanRedoMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanRedoMethodInfo a signature where overloadedMethod _ = bufferCanRedo #endif -- method Buffer::can_undo -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_can_undo" gtk_source_buffer_can_undo :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO CInt {- | Determines whether a source buffer can undo the last action. -} bufferCanUndo :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Bool {- ^ __Returns:__ 'True' if it\'s possible to undo the last action. -} bufferCanUndo buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_can_undo buffer' let result' = (/= 0) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data BufferCanUndoMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanUndoMethodInfo a signature where overloadedMethod _ = bufferCanUndo #endif -- method Buffer::change_case -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "case_type", argType = TInterface (Name {namespace = "GtkSource", name = "ChangeCaseType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "how to change the case.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_change_case" gtk_source_buffer_change_case :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) CUInt -> -- case_type : TInterface (Name {namespace = "GtkSource", name = "ChangeCaseType"}) Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) IO () {- | Changes the case of the text between the specified iterators. /Since: 3.12/ -} bufferChangeCase :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> GtkSource.Enums.ChangeCaseType {- ^ /@caseType@/: how to change the case. -} -> Gtk.TextIter.TextIter {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> Gtk.TextIter.TextIter {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> m () bufferChangeCase buffer caseType start end = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer let caseType' = (fromIntegral . fromEnum) caseType start' <- unsafeManagedPtrGetPtr start end' <- unsafeManagedPtrGetPtr end gtk_source_buffer_change_case buffer' caseType' start' end' touchManagedPtr buffer touchManagedPtr start touchManagedPtr end return () #if ENABLE_OVERLOADING data BufferChangeCaseMethodInfo instance (signature ~ (GtkSource.Enums.ChangeCaseType -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferChangeCaseMethodInfo a signature where overloadedMethod _ = bufferChangeCase #endif -- method Buffer::create_source_mark -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the mark, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string defining the mark category.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "where", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to place the mark.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Mark"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_create_source_mark" gtk_source_buffer_create_source_mark :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) CString -> -- name : TBasicType TUTF8 CString -> -- category : TBasicType TUTF8 Ptr Gtk.TextIter.TextIter -> -- where : TInterface (Name {namespace = "Gtk", name = "TextIter"}) IO (Ptr GtkSource.Mark.Mark) {- | Creates a source mark in the /@buffer@/ of category /@category@/. A source mark is a 'GI.Gtk.Objects.TextMark.TextMark' but organised into categories. Depending on the category a pixbuf can be specified that will be displayed along the line of the mark. Like a 'GI.Gtk.Objects.TextMark.TextMark', a 'GI.GtkSource.Objects.Mark.Mark' can be anonymous if the passed /@name@/ is 'Nothing'. Also, the buffer owns the marks so you shouldn\'t unreference it. Marks always have left gravity and are moved to the beginning of the line when the user deletes the line they were in. Typical uses for a source mark are bookmarks, breakpoints, current executing instruction indication in a source file, etc.. /Since: 2.2/ -} bufferCreateSourceMark :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Maybe (T.Text) {- ^ /@name@/: the name of the mark, or 'Nothing'. -} -> T.Text {- ^ /@category@/: a string defining the mark category. -} -> Gtk.TextIter.TextIter {- ^ /@where@/: location to place the mark. -} -> m GtkSource.Mark.Mark {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Mark.Mark', owned by the buffer. -} bufferCreateSourceMark buffer name category where_ = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer maybeName <- case name of Nothing -> return nullPtr Just jName -> do jName' <- textToCString jName return jName' category' <- textToCString category where_' <- unsafeManagedPtrGetPtr where_ result <- gtk_source_buffer_create_source_mark buffer' maybeName category' where_' checkUnexpectedReturnNULL "bufferCreateSourceMark" result result' <- (newObject GtkSource.Mark.Mark) result touchManagedPtr buffer touchManagedPtr where_ freeMem maybeName freeMem category' return result' #if ENABLE_OVERLOADING data BufferCreateSourceMarkMethodInfo instance (signature ~ (Maybe (T.Text) -> T.Text -> Gtk.TextIter.TextIter -> m GtkSource.Mark.Mark), MonadIO m, IsBuffer a) => O.MethodInfo BufferCreateSourceMarkMethodInfo a signature where overloadedMethod _ = bufferCreateSourceMark #endif -- method Buffer::end_not_undoable_action -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_end_not_undoable_action" gtk_source_buffer_end_not_undoable_action :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO () {- | Marks the end of a not undoable action on the buffer. When the last not undoable block is closed through the call to this function, the list of undo actions is cleared and the undo manager is re-enabled. -} bufferEndNotUndoableAction :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m () bufferEndNotUndoableAction buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer gtk_source_buffer_end_not_undoable_action buffer' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferEndNotUndoableActionMethodInfo instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEndNotUndoableActionMethodInfo a signature where overloadedMethod _ = bufferEndNotUndoableAction #endif -- method Buffer::ensure_highlight -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of the area to highlight.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of the area to highlight.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_ensure_highlight" gtk_source_buffer_ensure_highlight :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) IO () {- | Forces buffer to analyze and highlight the given area synchronously. \ \ This is a potentially slow operation and should be used only when you need to make sure that some text not currently visible is highlighted, for instance before printing. \<\/para> \<\/note> -} bufferEnsureHighlight :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@start@/: start of the area to highlight. -} -> Gtk.TextIter.TextIter {- ^ /@end@/: end of the area to highlight. -} -> m () bufferEnsureHighlight buffer start end = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer start' <- unsafeManagedPtrGetPtr start end' <- unsafeManagedPtrGetPtr end gtk_source_buffer_ensure_highlight buffer' start' end' touchManagedPtr buffer touchManagedPtr start touchManagedPtr end return () #if ENABLE_OVERLOADING data BufferEnsureHighlightMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEnsureHighlightMethodInfo a signature where overloadedMethod _ = bufferEnsureHighlight #endif -- method Buffer::forward_iter_to_source_mark -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_forward_iter_to_source_mark" gtk_source_buffer_forward_iter_to_source_mark :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- category : TBasicType TUTF8 IO CInt {- | Moves /@iter@/ to the position of the next 'GI.GtkSource.Objects.Mark.Mark' of the given /@category@/. Returns 'True' if /@iter@/ was moved. If /@category@/ is NULL, the next source mark can be of any category. /Since: 2.2/ -} bufferForwardIterToSourceMark :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: an iterator. -} -> Maybe (T.Text) {- ^ /@category@/: category to search for, or 'Nothing' -} -> m Bool {- ^ __Returns:__ whether /@iter@/ was moved. -} bufferForwardIterToSourceMark buffer iter category = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter maybeCategory <- case category of Nothing -> return nullPtr Just jCategory -> do jCategory' <- textToCString jCategory return jCategory' result <- gtk_source_buffer_forward_iter_to_source_mark buffer' iter' maybeCategory let result' = (/= 0) result touchManagedPtr buffer touchManagedPtr iter freeMem maybeCategory return result' #if ENABLE_OVERLOADING data BufferForwardIterToSourceMarkMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferForwardIterToSourceMarkMethodInfo a signature where overloadedMethod _ = bufferForwardIterToSourceMark #endif -- method Buffer::get_context_classes_at_iter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_context_classes_at_iter" gtk_source_buffer_get_context_classes_at_iter :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) IO (Ptr CString) {- | Get all defined context classes at /@iter@/. See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. /Since: 2.10/ -} bufferGetContextClassesAtIter :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> m [T.Text] {- ^ __Returns:__ a new 'Nothing' terminated array of context class names. Use 'GI.GLib.Functions.strfreev' to free the array if it is no longer needed. -} bufferGetContextClassesAtIter buffer iter = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter result <- gtk_source_buffer_get_context_classes_at_iter buffer' iter' checkUnexpectedReturnNULL "bufferGetContextClassesAtIter" result result' <- unpackZeroTerminatedUTF8CArray result mapZeroTerminatedCArray freeMem result freeMem result touchManagedPtr buffer touchManagedPtr iter return result' #if ENABLE_OVERLOADING data BufferGetContextClassesAtIterMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> m [T.Text]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetContextClassesAtIterMethodInfo a signature where overloadedMethod _ = bufferGetContextClassesAtIter #endif -- method Buffer::get_highlight_matching_brackets -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_highlight_matching_brackets" gtk_source_buffer_get_highlight_matching_brackets :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO CInt {- | Determines whether bracket match highlighting is activated for the source buffer. -} bufferGetHighlightMatchingBrackets :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Bool {- ^ __Returns:__ 'True' if the source buffer will highlight matching brackets. -} bufferGetHighlightMatchingBrackets buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_highlight_matching_brackets buffer' let result' = (/= 0) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data BufferGetHighlightMatchingBracketsMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightMatchingBracketsMethodInfo a signature where overloadedMethod _ = bufferGetHighlightMatchingBrackets #endif -- method Buffer::get_highlight_syntax -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_highlight_syntax" gtk_source_buffer_get_highlight_syntax :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO CInt {- | Determines whether syntax highlighting is activated in the source buffer. -} bufferGetHighlightSyntax :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Bool {- ^ __Returns:__ 'True' if syntax highlighting is enabled, 'False' otherwise. -} bufferGetHighlightSyntax buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_highlight_syntax buffer' let result' = (/= 0) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data BufferGetHighlightSyntaxMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightSyntaxMethodInfo a signature where overloadedMethod _ = bufferGetHighlightSyntax #endif -- method Buffer::get_implicit_trailing_newline -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_implicit_trailing_newline" gtk_source_buffer_get_implicit_trailing_newline :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO CInt {- | /No description available in the introspection data./ /Since: 3.14/ -} bufferGetImplicitTrailingNewline :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Bool {- ^ __Returns:__ whether the /@buffer@/ has an implicit trailing newline. -} bufferGetImplicitTrailingNewline buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_implicit_trailing_newline buffer' let result' = (/= 0) result touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data BufferGetImplicitTrailingNewlineMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetImplicitTrailingNewlineMethodInfo a signature where overloadedMethod _ = bufferGetImplicitTrailingNewline #endif -- method Buffer::get_language -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Language"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_language" gtk_source_buffer_get_language :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO (Ptr GtkSource.Language.Language) {- | Returns the 'GI.GtkSource.Objects.Language.Language' associated with the buffer, see 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. The returned object should not be unreferenced by the user. -} bufferGetLanguage :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m (Maybe GtkSource.Language.Language) {- ^ __Returns:__ the 'GI.GtkSource.Objects.Language.Language' associated with the buffer, or 'Nothing'. -} bufferGetLanguage buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_language buffer' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject GtkSource.Language.Language) result' return result'' touchManagedPtr buffer return maybeResult #if ENABLE_OVERLOADING data BufferGetLanguageMethodInfo instance (signature ~ (m (Maybe GtkSource.Language.Language)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetLanguageMethodInfo a signature where overloadedMethod _ = bufferGetLanguage #endif -- method Buffer::get_max_undo_levels -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_max_undo_levels" gtk_source_buffer_get_max_undo_levels :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO Int32 {- | Determines the number of undo levels the buffer will track for buffer edits. -} bufferGetMaxUndoLevels :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m Int32 {- ^ __Returns:__ the maximum number of possible undo levels or -1 if no limit is set. -} bufferGetMaxUndoLevels buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_max_undo_levels buffer' touchManagedPtr buffer return result #if ENABLE_OVERLOADING data BufferGetMaxUndoLevelsMethodInfo instance (signature ~ (m Int32), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetMaxUndoLevelsMethodInfo a signature where overloadedMethod _ = bufferGetMaxUndoLevels #endif -- method Buffer::get_source_marks_at_iter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Mark"}))) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_source_marks_at_iter" gtk_source_buffer_get_source_marks_at_iter :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- category : TBasicType TUTF8 IO (Ptr (GSList (Ptr GtkSource.Mark.Mark))) {- | Returns the list of marks of the given category at /@iter@/. If /@category@/ is 'Nothing' it returns all marks at /@iter@/. /Since: 2.2/ -} bufferGetSourceMarksAtIter :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: an iterator. -} -> Maybe (T.Text) {- ^ /@category@/: category to search for, or 'Nothing' -} -> m [GtkSource.Mark.Mark] {- ^ __Returns:__ a newly allocated 'GI.GLib.Structs.SList.SList'. -} bufferGetSourceMarksAtIter buffer iter category = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter maybeCategory <- case category of Nothing -> return nullPtr Just jCategory -> do jCategory' <- textToCString jCategory return jCategory' result <- gtk_source_buffer_get_source_marks_at_iter buffer' iter' maybeCategory result' <- unpackGSList result result'' <- mapM (newObject GtkSource.Mark.Mark) result' g_slist_free result touchManagedPtr buffer touchManagedPtr iter freeMem maybeCategory return result'' #if ENABLE_OVERLOADING data BufferGetSourceMarksAtIterMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtIterMethodInfo a signature where overloadedMethod _ = bufferGetSourceMarksAtIter #endif -- method Buffer::get_source_marks_at_line -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a line number.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Mark"}))) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_source_marks_at_line" gtk_source_buffer_get_source_marks_at_line :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Int32 -> -- line : TBasicType TInt CString -> -- category : TBasicType TUTF8 IO (Ptr (GSList (Ptr GtkSource.Mark.Mark))) {- | Returns the list of marks of the given category at /@line@/. If /@category@/ is 'Nothing', all marks at /@line@/ are returned. /Since: 2.2/ -} bufferGetSourceMarksAtLine :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Int32 {- ^ /@line@/: a line number. -} -> Maybe (T.Text) {- ^ /@category@/: category to search for, or 'Nothing' -} -> m [GtkSource.Mark.Mark] {- ^ __Returns:__ a newly allocated 'GI.GLib.Structs.SList.SList'. -} bufferGetSourceMarksAtLine buffer line category = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer maybeCategory <- case category of Nothing -> return nullPtr Just jCategory -> do jCategory' <- textToCString jCategory return jCategory' result <- gtk_source_buffer_get_source_marks_at_line buffer' line maybeCategory result' <- unpackGSList result result'' <- mapM (newObject GtkSource.Mark.Mark) result' g_slist_free result touchManagedPtr buffer freeMem maybeCategory return result'' #if ENABLE_OVERLOADING data BufferGetSourceMarksAtLineMethodInfo instance (signature ~ (Int32 -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtLineMethodInfo a signature where overloadedMethod _ = bufferGetSourceMarksAtLine #endif -- method Buffer::get_style_scheme -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_style_scheme" gtk_source_buffer_get_style_scheme :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO (Ptr GtkSource.StyleScheme.StyleScheme) {- | Returns the 'GI.GtkSource.Objects.StyleScheme.StyleScheme' associated with the buffer, see 'GI.GtkSource.Objects.Buffer.bufferSetStyleScheme'. The returned object should not be unreferenced by the user. -} bufferGetStyleScheme :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m (Maybe GtkSource.StyleScheme.StyleScheme) {- ^ __Returns:__ the 'GI.GtkSource.Objects.StyleScheme.StyleScheme' associated with the buffer, or 'Nothing'. -} bufferGetStyleScheme buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_style_scheme buffer' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject GtkSource.StyleScheme.StyleScheme) result' return result'' touchManagedPtr buffer return maybeResult #if ENABLE_OVERLOADING data BufferGetStyleSchemeMethodInfo instance (signature ~ (m (Maybe GtkSource.StyleScheme.StyleScheme)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetStyleSchemeMethodInfo a signature where overloadedMethod _ = bufferGetStyleScheme #endif -- method Buffer::get_undo_manager -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "UndoManager"})) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_get_undo_manager" gtk_source_buffer_get_undo_manager :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO (Ptr GtkSource.UndoManager.UndoManager) {- | Returns the 'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated with the buffer, see 'GI.GtkSource.Objects.Buffer.bufferSetUndoManager'. The returned object should not be unreferenced by the user. -} bufferGetUndoManager :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m (Maybe GtkSource.UndoManager.UndoManager) {- ^ __Returns:__ the 'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated with the buffer, or 'Nothing'. -} bufferGetUndoManager buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer result <- gtk_source_buffer_get_undo_manager buffer' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject GtkSource.UndoManager.UndoManager) result' return result'' touchManagedPtr buffer return maybeResult #if ENABLE_OVERLOADING data BufferGetUndoManagerMethodInfo instance (signature ~ (m (Maybe GtkSource.UndoManager.UndoManager)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetUndoManagerMethodInfo a signature where overloadedMethod _ = bufferGetUndoManager #endif -- method Buffer::iter_backward_to_context_class_toggle -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the context class.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_iter_backward_to_context_class_toggle" gtk_source_buffer_iter_backward_to_context_class_toggle :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- context_class : TBasicType TUTF8 IO CInt {- | Moves backward to the next toggle (on or off) of the context class. If no matching context class toggles are found, returns 'False', otherwise 'True'. Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets /@iter@/ to the location of the toggle, or to the end of the buffer if no toggle is found. See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. /Since: 2.10/ -} bufferIterBackwardToContextClassToggle :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> T.Text {- ^ /@contextClass@/: the context class. -} -> m Bool {- ^ __Returns:__ whether we found a context class toggle before /@iter@/ -} bufferIterBackwardToContextClassToggle buffer iter contextClass = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter contextClass' <- textToCString contextClass result <- gtk_source_buffer_iter_backward_to_context_class_toggle buffer' iter' contextClass' let result' = (/= 0) result touchManagedPtr buffer touchManagedPtr iter freeMem contextClass' return result' #if ENABLE_OVERLOADING data BufferIterBackwardToContextClassToggleMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterBackwardToContextClassToggleMethodInfo a signature where overloadedMethod _ = bufferIterBackwardToContextClassToggle #endif -- method Buffer::iter_forward_to_context_class_toggle -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the context class.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_iter_forward_to_context_class_toggle" gtk_source_buffer_iter_forward_to_context_class_toggle :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- context_class : TBasicType TUTF8 IO CInt {- | Moves forward to the next toggle (on or off) of the context class. If no matching context class toggles are found, returns 'False', otherwise 'True'. Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets /@iter@/ to the location of the toggle, or to the end of the buffer if no toggle is found. See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. /Since: 2.10/ -} bufferIterForwardToContextClassToggle :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> T.Text {- ^ /@contextClass@/: the context class. -} -> m Bool {- ^ __Returns:__ whether we found a context class toggle after /@iter@/ -} bufferIterForwardToContextClassToggle buffer iter contextClass = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter contextClass' <- textToCString contextClass result <- gtk_source_buffer_iter_forward_to_context_class_toggle buffer' iter' contextClass' let result' = (/= 0) result touchManagedPtr buffer touchManagedPtr iter freeMem contextClass' return result' #if ENABLE_OVERLOADING data BufferIterForwardToContextClassToggleMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterForwardToContextClassToggleMethodInfo a signature where overloadedMethod _ = bufferIterForwardToContextClassToggle #endif -- method Buffer::iter_has_context_class -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class to search for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_iter_has_context_class" gtk_source_buffer_iter_has_context_class :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- context_class : TBasicType TUTF8 IO CInt {- | Check if the class /@contextClass@/ is set on /@iter@/. See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. /Since: 2.10/ -} bufferIterHasContextClass :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> T.Text {- ^ /@contextClass@/: class to search for. -} -> m Bool {- ^ __Returns:__ whether /@iter@/ has the context class. -} bufferIterHasContextClass buffer iter contextClass = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer iter' <- unsafeManagedPtrGetPtr iter contextClass' <- textToCString contextClass result <- gtk_source_buffer_iter_has_context_class buffer' iter' contextClass' let result' = (/= 0) result touchManagedPtr buffer touchManagedPtr iter freeMem contextClass' return result' #if ENABLE_OVERLOADING data BufferIterHasContextClassMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterHasContextClassMethodInfo a signature where overloadedMethod _ = bufferIterHasContextClass #endif -- method Buffer::join_lines -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_join_lines" gtk_source_buffer_join_lines :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) IO () {- | Joins the lines of text between the specified iterators. /Since: 3.16/ -} bufferJoinLines :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> Gtk.TextIter.TextIter {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> m () bufferJoinLines buffer start end = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer start' <- unsafeManagedPtrGetPtr start end' <- unsafeManagedPtrGetPtr end gtk_source_buffer_join_lines buffer' start' end' touchManagedPtr buffer touchManagedPtr start touchManagedPtr end return () #if ENABLE_OVERLOADING data BufferJoinLinesMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferJoinLinesMethodInfo a signature where overloadedMethod _ = bufferJoinLines #endif -- method Buffer::redo -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_redo" gtk_source_buffer_redo :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO () {- | Redoes the last undo operation. Use 'GI.GtkSource.Objects.Buffer.bufferCanRedo' to check whether a call to this function will have any effect. This function emits the 'GI.GtkSource.Objects.Buffer.Buffer'::@/redo/@ signal. -} bufferRedo :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m () bufferRedo buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer gtk_source_buffer_redo buffer' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferRedoMethodInfo instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRedoMethodInfo a signature where overloadedMethod _ = bufferRedo #endif -- method Buffer::remove_source_marks -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_remove_source_marks" gtk_source_buffer_remove_source_marks :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CString -> -- category : TBasicType TUTF8 IO () {- | Remove all marks of /@category@/ between /@start@/ and /@end@/ from the buffer. If /@category@/ is NULL, all marks in the range will be removed. /Since: 2.2/ -} bufferRemoveSourceMarks :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> Gtk.TextIter.TextIter {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> Maybe (T.Text) {- ^ /@category@/: category to search for, or 'Nothing'. -} -> m () bufferRemoveSourceMarks buffer start end category = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer start' <- unsafeManagedPtrGetPtr start end' <- unsafeManagedPtrGetPtr end maybeCategory <- case category of Nothing -> return nullPtr Just jCategory -> do jCategory' <- textToCString jCategory return jCategory' gtk_source_buffer_remove_source_marks buffer' start' end' maybeCategory touchManagedPtr buffer touchManagedPtr start touchManagedPtr end freeMem maybeCategory return () #if ENABLE_OVERLOADING data BufferRemoveSourceMarksMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Maybe (T.Text) -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRemoveSourceMarksMethodInfo a signature where overloadedMethod _ = bufferRemoveSourceMarks #endif -- method Buffer::set_highlight_matching_brackets -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want matching brackets highlighted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_highlight_matching_brackets" gtk_source_buffer_set_highlight_matching_brackets :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) CInt -> -- highlight : TBasicType TBoolean IO () {- | Controls the bracket match highlighting function in the buffer. If activated, when you position your cursor over a bracket character (a parenthesis, a square bracket, etc.) the matching opening or closing bracket character will be highlighted. -} bufferSetHighlightMatchingBrackets :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Bool {- ^ /@highlight@/: 'True' if you want matching brackets highlighted. -} -> m () bufferSetHighlightMatchingBrackets buffer highlight = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer let highlight' = (fromIntegral . fromEnum) highlight gtk_source_buffer_set_highlight_matching_brackets buffer' highlight' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferSetHighlightMatchingBracketsMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightMatchingBracketsMethodInfo a signature where overloadedMethod _ = bufferSetHighlightMatchingBrackets #endif -- method Buffer::set_highlight_syntax -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable syntax highlighting, %FALSE to disable it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_highlight_syntax" gtk_source_buffer_set_highlight_syntax :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) CInt -> -- highlight : TBasicType TBoolean IO () {- | Controls whether syntax is highlighted in the buffer. If /@highlight@/ is 'True', the text will be highlighted according to the syntax patterns specified in the 'GI.GtkSource.Objects.Language.Language' set with 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. If /@highlight@/ is 'False', syntax highlighting is disabled and all the 'GI.Gtk.Objects.TextTag.TextTag' objects that have been added by the syntax highlighting engine are removed from the buffer. -} bufferSetHighlightSyntax :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Bool {- ^ /@highlight@/: 'True' to enable syntax highlighting, 'False' to disable it. -} -> m () bufferSetHighlightSyntax buffer highlight = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer let highlight' = (fromIntegral . fromEnum) highlight gtk_source_buffer_set_highlight_syntax buffer' highlight' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferSetHighlightSyntaxMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightSyntaxMethodInfo a signature where overloadedMethod _ = bufferSetHighlightSyntax #endif -- method Buffer::set_implicit_trailing_newline -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implicit_trailing_newline", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_implicit_trailing_newline" gtk_source_buffer_set_implicit_trailing_newline :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) CInt -> -- implicit_trailing_newline : TBasicType TBoolean IO () {- | Sets whether the /@buffer@/ has an implicit trailing newline. If an explicit trailing newline is present in a 'GI.Gtk.Objects.TextBuffer.TextBuffer', 'GI.Gtk.Objects.TextView.TextView' shows it as an empty line. This is generally not what the user expects. If /@implicitTrailingNewline@/ is 'True' (the default value): - when a 'GI.GtkSource.Objects.FileLoader.FileLoader' loads the content of a file into the /@buffer@/, the trailing newline (if present in the file) is not inserted into the /@buffer@/. - when a 'GI.GtkSource.Objects.FileSaver.FileSaver' saves the content of the /@buffer@/ into a file, a trailing newline is added to the file. On the other hand, if /@implicitTrailingNewline@/ is 'False', the file\'s content is not modified when loaded into the /@buffer@/, and the /@buffer@/\'s content is not modified when saved into a file. /Since: 3.14/ -} bufferSetImplicitTrailingNewline :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Bool {- ^ /@implicitTrailingNewline@/: the new value. -} -> m () bufferSetImplicitTrailingNewline buffer implicitTrailingNewline = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer let implicitTrailingNewline' = (fromIntegral . fromEnum) implicitTrailingNewline gtk_source_buffer_set_implicit_trailing_newline buffer' implicitTrailingNewline' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferSetImplicitTrailingNewlineMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetImplicitTrailingNewlineMethodInfo a signature where overloadedMethod _ = bufferSetImplicitTrailingNewline #endif -- method Buffer::set_language -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "language", argType = TInterface (Name {namespace = "GtkSource", name = "Language"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguage to set, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_language" gtk_source_buffer_set_language :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr GtkSource.Language.Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) IO () {- | Associates a 'GI.GtkSource.Objects.Language.Language' with the buffer. Note that a 'GI.GtkSource.Objects.Language.Language' affects not only the syntax highlighting, but also the [context classes][context-classes]. If you want to disable just the syntax highlighting, see 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax'. The buffer holds a reference to /@language@/. -} bufferSetLanguage :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Maybe (b) {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language' to set, or 'Nothing'. -} -> m () bufferSetLanguage buffer language = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer maybeLanguage <- case language of Nothing -> return nullPtr Just jLanguage -> do jLanguage' <- unsafeManagedPtrCastPtr jLanguage return jLanguage' gtk_source_buffer_set_language buffer' maybeLanguage touchManagedPtr buffer whenJust language touchManagedPtr return () #if ENABLE_OVERLOADING data BufferSetLanguageMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) => O.MethodInfo BufferSetLanguageMethodInfo a signature where overloadedMethod _ = bufferSetLanguage #endif -- method Buffer::set_max_undo_levels -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_undo_levels", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired maximum number of undo levels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_max_undo_levels" gtk_source_buffer_set_max_undo_levels :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Int32 -> -- max_undo_levels : TBasicType TInt IO () {- | Sets the number of undo levels for user actions the buffer will track. If the number of user actions exceeds the limit set by this function, older actions will be discarded. If /@maxUndoLevels@/ is -1, the undo\/redo is unlimited. If /@maxUndoLevels@/ is 0, the undo\/redo is disabled. -} bufferSetMaxUndoLevels :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Int32 {- ^ /@maxUndoLevels@/: the desired maximum number of undo levels. -} -> m () bufferSetMaxUndoLevels buffer maxUndoLevels = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer gtk_source_buffer_set_max_undo_levels buffer' maxUndoLevels touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferSetMaxUndoLevelsMethodInfo instance (signature ~ (Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetMaxUndoLevelsMethodInfo a signature where overloadedMethod _ = bufferSetMaxUndoLevels #endif -- method Buffer::set_style_scheme -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleScheme or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_style_scheme" gtk_source_buffer_set_style_scheme :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr GtkSource.StyleScheme.StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) IO () {- | Sets a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' to be used by the buffer and the view. Note that a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' affects not only the syntax highlighting, but also other 'GI.GtkSource.Objects.View.View' features such as highlighting the current line, matching brackets, the line numbers, etc. Instead of setting a 'Nothing' /@scheme@/, it is better to disable syntax highlighting with 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax', and setting the 'GI.GtkSource.Objects.StyleScheme.StyleScheme' with the \"classic\" or \"tango\" ID, because those two style schemes follow more closely the GTK+ theme (for example for the background color). The buffer holds a reference to /@scheme@/. -} bufferSetStyleScheme :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Maybe (b) {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' or 'Nothing'. -} -> m () bufferSetStyleScheme buffer scheme = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer maybeScheme <- case scheme of Nothing -> return nullPtr Just jScheme -> do jScheme' <- unsafeManagedPtrCastPtr jScheme return jScheme' gtk_source_buffer_set_style_scheme buffer' maybeScheme touchManagedPtr buffer whenJust scheme touchManagedPtr return () #if ENABLE_OVERLOADING data BufferSetStyleSchemeMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) => O.MethodInfo BufferSetStyleSchemeMethodInfo a signature where overloadedMethod _ = bufferSetStyleScheme #endif -- method Buffer::set_undo_manager -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GtkSourceUndoManager or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_set_undo_manager" gtk_source_buffer_set_undo_manager :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr GtkSource.UndoManager.UndoManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"}) IO () {- | Set the buffer undo manager. If /@manager@/ is 'Nothing' the default undo manager will be set. -} bufferSetUndoManager :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Maybe (b) {- ^ /@manager@/: A 'GI.GtkSource.Interfaces.UndoManager.UndoManager' or 'Nothing'. -} -> m () bufferSetUndoManager buffer manager = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer maybeManager <- case manager of Nothing -> return nullPtr Just jManager -> do jManager' <- unsafeManagedPtrCastPtr jManager return jManager' gtk_source_buffer_set_undo_manager buffer' maybeManager touchManagedPtr buffer whenJust manager touchManagedPtr return () #if ENABLE_OVERLOADING data BufferSetUndoManagerMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) => O.MethodInfo BufferSetUndoManagerMethodInfo a signature where overloadedMethod _ = bufferSetUndoManager #endif -- method Buffer::sort_lines -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GtkSource", name = "SortFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GtkSourceSortFlags specifying how the sort should behave", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "sort considering the text starting at the given column", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_sort_lines" gtk_source_buffer_sort_lines :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) CUInt -> -- flags : TInterface (Name {namespace = "GtkSource", name = "SortFlags"}) Int32 -> -- column : TBasicType TInt IO () {- | Sort the lines of text between the specified iterators. /Since: 3.18/ -} bufferSortLines :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> Gtk.TextIter.TextIter {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> Gtk.TextIter.TextIter {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} -> [GtkSource.Flags.SortFlags] {- ^ /@flags@/: 'GI.GtkSource.Flags.SortFlags' specifying how the sort should behave -} -> Int32 {- ^ /@column@/: sort considering the text starting at the given column -} -> m () bufferSortLines buffer start end flags column = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer start' <- unsafeManagedPtrGetPtr start end' <- unsafeManagedPtrGetPtr end let flags' = gflagsToWord flags gtk_source_buffer_sort_lines buffer' start' end' flags' column touchManagedPtr buffer touchManagedPtr start touchManagedPtr end return () #if ENABLE_OVERLOADING data BufferSortLinesMethodInfo instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.SortFlags] -> Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSortLinesMethodInfo a signature where overloadedMethod _ = bufferSortLines #endif -- method Buffer::undo -- method type : OrdinaryMethod -- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_source_buffer_undo" gtk_source_buffer_undo :: Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) IO () {- | Undoes the last user action which modified the buffer. Use 'GI.GtkSource.Objects.Buffer.bufferCanUndo' to check whether a call to this function will have any effect. This function emits the 'GI.GtkSource.Objects.Buffer.Buffer'::@/undo/@ signal. -} bufferUndo :: (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => a {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} -> m () bufferUndo buffer = liftIO $ do buffer' <- unsafeManagedPtrCastPtr buffer gtk_source_buffer_undo buffer' touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferUndoMethodInfo instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferUndoMethodInfo a signature where overloadedMethod _ = bufferUndo #endif